NIMBioS - User contributions [en]

Rocky User Guide

2026-01-12T21:44:02Z

Jondale:

= About Rocky =

Rocky is a [https://en.wikipedia.org/wiki/High-performance_computing HPC] cluster comprised of compute heavy nodes with 40 cores/80 threads and 512GB of ram ['''rocky'''], memory intensive nodes with 20 cores/40 threads and 768GB of RAM ['''moose'''], and a [https://docs.ceph.com Ceph] storage subsystem ['''quarrel''']

== Requesting Access ==
In order to gain access to Rocky you must first fill out the [[Rocky_Access_Form]].

== Logging in to Rocky ==
Rocky's firewall limits access to the UTK network. You will either need to be on campus or using the [https://utk.teamdynamix.com/TDClient/2277/OIT-Portal/KB/ArticleDet?ID=123517 Campus VPN]

Once your account is created you will be able to SSH into a shell or SCP to copy files to/from Rocky.

Rocky uses Public Key Authentication for access instead of passwords.

Please review the following pages for OS specific instructions:

{| class='wikitable'
|-
| [[Rocky_Access_SSH]] || Linux or Mac
|-
| [[Rocky_Access_Windows]] || Windows
|}

== Environmental Modules ==
Rocky uses [https://lmod.readthedocs.io/en/latest/ Lmod] as it's environmental module system. This allows you to easily set your session or job's environment to support the language, libraries, and specific versions needed.

To learn more about using Lmod on Rocky, check out [[ Rocky_Environments | Rocky Environments]].

== Submitting a Job ==

Rocky uses [https://slurm.schedmd.com/documentation.html Slurm] to queue and submit jobs to the cluster's compute nodes.

The nature of a compute cluster is that jobs are meant to be submitted to a queue. Jobs are processed based on a [https://slurm.schedmd.com/classic_fair_share.html Fairshare] priority system. Your job's priority is based on the associations you have (such as your lab) and how much compute you and they have used recently. Sometimes your jobs might run instantly but other times you might have a wait time before they process.

To learn how to set up your own jobs, check out the [[Rocky_Job_Anatomy | Anatomy of a Rocky Job]]

= Examples =

Beyond the below examples, we have also started a [https://github.com/rocky-cluster Github Repository].

==== Python ====
* [[ Rocky_Python_HelloWorld | Hello World ]]
* [[ Rocky_Python_Prime | Discover Prime Numbers ]]
* [[ Rocky_Python_Prime_Array | Discover Prime Numbers using a job array ]]

==== R ====
* [[ Rocky_R_HelloWorld | Hello World ]]
* [[ Rocky_R_Prime | Discover Prime Numbers ]]
* [[ Rocky_R_package | Install packages locally ]]

==== MATLAB ====
* [[ Rocky_MATLAB_HelloWorld | Hello World ]]
* [[ Rocky_MATLAB_Prime_Array | Discover Prime Numbers using a job array ]]

==== MPI ====
* [[ Rocky_MPI_Hello_World | Hello World (C) ]]
* [[ Rocky_Python_MPI_Hello_World | Hello World (Python) ]]

= Acknowledgement and Citations =

If any work on Rocky is used in a research report, journal, or publication that requires citation of authors' work, please acknowledge NIMBioS.

Our suggested acknowledgment is as follows.

'''[A portion of] The computation for this work was performed on the National Institute for Modeling Biological Systems (NIMBioS) computational resources at the University of Tennessee.'''

Rocky User Guide

2026-01-12T21:43:37Z

Jondale:

Rocky Python MPI Hello World

2026-01-12T20:35:32Z

Jondale:

= MPI4PY Jobs on Rocky =

== Supported versions ==

Rocky supports PMIx v3 for MPI process management. MPI applications should be launched via srun using --mpi=pmix_v3.

To see what versions of mpi4py are available use the following command:

<syntaxhighlight lang="bash">
module spider mpi4py
</syntaxhighlight>

<syntaxhighlight lang="bash">
Versions:
mpi4py/3.0.1 (E)
mpi4py/3.0.2 (E)
mpi4py/3.0.3 (E)
mpi4py/3.1.1 (E)
mpi4py/3.1.3 (E)
mpi4py/3.1.4-gompi-2022b
mpi4py/3.1.4-gompi-2023a
mpi4py/3.1.4 (E)
mpi4py/3.1.5-gompi-2023b
mpi4py/3.1.5 (E)
mpi4py/3.1.6 (E)
mpi4py/4.0.1-gompi-2024a
mpi4py/4.0.1 (E)
</syntaxhighlight>

With the above given information we are going to use <code>mpi4py/4.0.1</code>.

== hello_mpi4py.py ==

<syntaxhighlight lang="python">
from mpi4py import MPI
import socket

comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
hostname = socket.gethostname()

print(f"Hello from rank {rank} of {size} on {hostname}")
</syntaxhighlight>

== hello_mpi4py.sbatch ==

Note the usage of <code>--mpi=pmix_v3</code> parameter.
<syntaxhighlight lang="bash">
#!/usr/bin/env bash
#SBATCH --job-name=hello-mpi4py
#SBATCH --output=hello-mpi4py-%j.out
#SBATCH --error=hello-mpi4py-%j.err
#SBATCH --nodes=2
#SBATCH --ntasks=8
#SBATCH --time=00:05:00

module load mpi4py/4.0.1

srun --mpi=pmix_v3 python hello_mpi4py.py
</syntaxhighlight>

Submit the job:

<pre>
sbatch hello_mpi4py.sbatch
</pre>

== Expected Output ==

<pre>
Hello from rank 0 of 8 on rocky4.rocky.nimbios.org
Hello from rank 1 of 8 on rocky4.rocky.nimbios.org
Hello from rank 2 of 8 on rocky4.rocky.nimbios.org
Hello from rank 3 of 8 on rocky4.rocky.nimbios.org
Hello from rank 4 of 8 on rocky5.rocky.nimbios.org
Hello from rank 5 of 8 on rocky5.rocky.nimbios.org
Hello from rank 6 of 8 on rocky5.rocky.nimbios.org
Hello from rank 7 of 8 on rocky5.rocky.nimbios.org
</pre>

Rocky Python MPI Hello World

2026-01-12T20:35:02Z

Jondale:

= MPI4PY Jobs on Rocky =

== Supported versions ==

Rocky supports PMIx v3 for MPI process management. MPI applications should be launched via srun using --mpi=pmix_v3.

To see what versions of mpi4py are available use the following command:

<syntaxhighlight lang="bash">
module spider mpi4py
</syntaxhighlight>

<syntaxhighlight lang="bash">
Versions:
mpi4py/3.0.1 (E)
mpi4py/3.0.2 (E)
mpi4py/3.0.3 (E)
mpi4py/3.1.1 (E)
mpi4py/3.1.3 (E)
mpi4py/3.1.4-gompi-2022b
mpi4py/3.1.4-gompi-2023a
mpi4py/3.1.4 (E)
mpi4py/3.1.5-gompi-2023b
mpi4py/3.1.5 (E)
mpi4py/3.1.6 (E)
mpi4py/4.0.1-gompi-2024a
mpi4py/4.0.1 (E)
</syntaxhighlight>

With the above given information we are going to use <code>OpenMPI/5.0.8-GCC-14.3.0</code> and <code>mpi4py/4.0.1</code>.

== hello_mpi4py.py ==

<syntaxhighlight lang="python">
from mpi4py import MPI
import socket

comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
hostname = socket.gethostname()

print(f"Hello from rank {rank} of {size} on {hostname}")
</syntaxhighlight>

== hello_mpi4py.sbatch ==

Note the usage of <code>--mpi=pmix_v3</code> parameter.
<syntaxhighlight lang="bash">
#!/usr/bin/env bash
#SBATCH --job-name=hello-mpi4py
#SBATCH --output=hello-mpi4py-%j.out
#SBATCH --error=hello-mpi4py-%j.err
#SBATCH --nodes=2
#SBATCH --ntasks=8
#SBATCH --time=00:05:00

module load OpenMPI/5.0.8-GCC-14.3.0
module load mpi4py/4.0.1

srun --mpi=pmix_v3 python hello_mpi4py.py
</syntaxhighlight>

Submit the job:

<pre>
sbatch hello_mpi4py.sbatch
</pre>

== Expected Output ==

<pre>
Hello from rank 0 of 8 on rocky4.rocky.nimbios.org
Hello from rank 1 of 8 on rocky4.rocky.nimbios.org
Hello from rank 2 of 8 on rocky4.rocky.nimbios.org
Hello from rank 3 of 8 on rocky4.rocky.nimbios.org
Hello from rank 4 of 8 on rocky5.rocky.nimbios.org
Hello from rank 5 of 8 on rocky5.rocky.nimbios.org
Hello from rank 6 of 8 on rocky5.rocky.nimbios.org
Hello from rank 7 of 8 on rocky5.rocky.nimbios.org
</pre>

Rocky MPI Hello World

2026-01-12T19:31:35Z

Jondale:

= MPI Jobs on Rocky =

== Supported versions ==

Rocky supports PMIx v3 for MPI process management. MPI applications should be launched via srun using --mpi=pmix_v3.

To see what versions of OpenMPI are available use the following command:

<syntaxhighlight lang="bash">
module spider OpenMPI
</syntaxhighlight>

As of the writing of this document the versions available:
<pre>
Versions:
OpenMPI/3.1.1-GCC-7.3.0-2.30
OpenMPI/3.1.3-GCC-8.2.0-2.31.1
OpenMPI/3.1.4-GCC-8.3.0
OpenMPI/4.0.3-GCC-9.3.0
OpenMPI/4.0.5-GCC-10.2.0
OpenMPI/4.1.1-GCC-10.3.0
OpenMPI/4.1.1-GCC-11.2.0
OpenMPI/4.1.4-GCC-11.3.0
OpenMPI/4.1.4-GCC-12.2.0
OpenMPI/4.1.5-GCC-12.3.0
OpenMPI/4.1.6-GCC-13.2.0
OpenMPI/5.0.3-GCC-13.3.0
OpenMPI/5.0.7-GCC-14.2.0
OpenMPI/5.0.8-GCC-14.3.0
OpenMPI/5.0.8-llvm-compilers-20.1.8
</pre>

----

= MPI Example: Hello World in C =

This example demonstrates compiling and running MPI across multiple nodes.

== Step 1 — Create the MPI program (hello_mpi.c) ==

<syntaxhighlight lang="c">
#include <mpi.h>
#include <stdio.h>

int main(int argc, char *argv[]) {
int rank, size, len;
char name[MPI_MAX_PROCESSOR_NAME];

MPI_Init(&argc, &argv);

MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Get_processor_name(name, &len);

printf("Hello from rank %d of %d on %s", rank, size, name);

MPI_Finalize();
return 0;
}
</syntaxhighlight>

== Step 2 — Compile the program ==

Load the appropriate version of OpenMPI you want to use and then compile your program with mpicc.
<pre>
module load OpenMPI/5.0.8-GCC-14.3.0
mpicc -O2 -o hello_mpi hello_mpi.c
</pre>

This creates the binary file <code>hello_mpi</code> that we will run in our job.

== Step 3 — Submit an MPI batch job (mpi_hello.sbatch) ==

Create the batch file that we'll name <code>mpi_hello.sbatch</code>. 
Notice that we are using <code>--mpi=pmix_v3</code> as a parameter to srun.
<syntaxhighlight lang="bash">
#!/usr/bin/env bash
#SBATCH --job-name=mpi-hello
#SBATCH --output=mpi-hello-%j.out
#SBATCH --error=mpi-hello-%j.err
#SBATCH --nodes=2
#SBATCH --ntasks=8
#SBATCH --time=00:05:00

module load OpenMPI/5.0.8-GCC-14.3.0

srun --mpi=pmix_v3 ./hello_mpi
</syntaxhighlight>

Use sbatch to submit the job defined in our sbatch file:

<pre>
sbatch mpi_hello.sbatch
</pre>

== Step 4 — Expected Output ==

The generated output file (<code>mpi-hello-<jobid>.out</code>) should contain:

<pre>
Hello from rank 0 of 8 on rocky4.rocky.nimbios.org
Hello from rank 1 of 8 on rocky4.rocky.nimbios.org
Hello from rank 2 of 8 on rocky4.rocky.nimbios.org
Hello from rank 3 of 8 on rocky4.rocky.nimbios.org
Hello from rank 4 of 8 on rocky5.rocky.nimbios.org
Hello from rank 5 of 8 on rocky5.rocky.nimbios.org
Hello from rank 6 of 8 on rocky5.rocky.nimbios.org
Hello from rank 7 of 8 on rocky5.rocky.nimbios.org
</pre>

Rocky Python MPI Hello World

2026-01-12T19:15:09Z

Jondale:

= MPI4PY Jobs on Rocky =

== Supported versions ==

Rocky supports PMIx v3 for MPI process management. MPI applications should be launched via srun using --mpi=pmix_v3.

To see what versions of OpenMPI are available use the following command:

<syntaxhighlight lang="bash">
module spider OpenMPI
</syntaxhighlight>

As of the writing of this document the versions available:
<pre>
Versions:
OpenMPI/3.1.1-GCC-7.3.0-2.30
OpenMPI/3.1.3-GCC-8.2.0-2.31.1
OpenMPI/3.1.4-GCC-8.3.0
OpenMPI/4.0.3-GCC-9.3.0
OpenMPI/4.0.5-GCC-10.2.0
OpenMPI/4.1.1-GCC-10.3.0
OpenMPI/4.1.1-GCC-11.2.0
OpenMPI/4.1.4-GCC-11.3.0
OpenMPI/4.1.4-GCC-12.2.0
OpenMPI/4.1.5-GCC-12.3.0
OpenMPI/4.1.6-GCC-13.2.0
OpenMPI/5.0.3-GCC-13.3.0
OpenMPI/5.0.7-GCC-14.2.0
OpenMPI/5.0.8-GCC-14.3.0
OpenMPI/5.0.8-llvm-compilers-20.1.8
</pre>

Similarly, to see what version of mpi4py is available use:

<syntaxhighlight lang="bash">
module spider mpi4py
</syntaxhighlight>

<syntaxhighlight lang="bash">
Versions:
mpi4py/3.0.1 (E)
mpi4py/3.0.2 (E)
mpi4py/3.0.3 (E)
mpi4py/3.1.1 (E)
mpi4py/3.1.3 (E)
mpi4py/3.1.4-gompi-2022b
mpi4py/3.1.4-gompi-2023a
mpi4py/3.1.4 (E)
mpi4py/3.1.5-gompi-2023b
mpi4py/3.1.5 (E)
mpi4py/3.1.6 (E)
mpi4py/4.0.1-gompi-2024a
mpi4py/4.0.1 (E)
</syntaxhighlight>

With the above given information we are going to use <code>OpenMPI/5.0.8-GCC-14.3.0</code> and <code>mpi4py/4.0.1</code>.

== hello_mpi4py.py ==

<syntaxhighlight lang="python">
from mpi4py import MPI
import socket

comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
hostname = socket.gethostname()

print(f"Hello from rank {rank} of {size} on {hostname}")
</syntaxhighlight>

== hello_mpi4py.sbatch ==

Note the usage of <code>--mpi=pmix_v3</code> parameter.
<syntaxhighlight lang="bash">
#!/usr/bin/env bash
#SBATCH --job-name=hello-mpi4py
#SBATCH --output=hello-mpi4py-%j.out
#SBATCH --error=hello-mpi4py-%j.err
#SBATCH --nodes=2
#SBATCH --ntasks=8
#SBATCH --time=00:05:00

module load OpenMPI/5.0.8-GCC-14.3.0
module load mpi4py/4.0.1

srun --mpi=pmix_v3 python hello_mpi4py.py
</syntaxhighlight>

Submit the job:

<pre>
sbatch hello_mpi4py.sbatch
</pre>

== Expected Output ==

<pre>
Hello from rank 0 of 8 on rocky4.rocky.nimbios.org
Hello from rank 1 of 8 on rocky4.rocky.nimbios.org
Hello from rank 2 of 8 on rocky4.rocky.nimbios.org
Hello from rank 3 of 8 on rocky4.rocky.nimbios.org
Hello from rank 4 of 8 on rocky5.rocky.nimbios.org
Hello from rank 5 of 8 on rocky5.rocky.nimbios.org
Hello from rank 6 of 8 on rocky5.rocky.nimbios.org
Hello from rank 7 of 8 on rocky5.rocky.nimbios.org
</pre>

Rocky Python MPI Hello World

2026-01-12T19:08:10Z

Jondale:

= MPI4PY Jobs on Rocky =

== Supported versions ==

Rocky supports PMIx v3 for MPI process management. MPI applications should be launched via srun using --mpi=pmix_v3.

To see what versions of OpenMPI are available use the following command:

<syntaxhighlight lang="bash">
module spider OpenMPI
</syntaxhighlight>

As of the writing of this document the versions available:
<pre>
Versions:
OpenMPI/3.1.1-GCC-7.3.0-2.30
OpenMPI/3.1.3-GCC-8.2.0-2.31.1
OpenMPI/3.1.4-GCC-8.3.0
OpenMPI/4.0.3-GCC-9.3.0
OpenMPI/4.0.5-GCC-10.2.0
OpenMPI/4.1.1-GCC-10.3.0
OpenMPI/4.1.1-GCC-11.2.0
OpenMPI/4.1.4-GCC-11.3.0
OpenMPI/4.1.4-GCC-12.2.0
OpenMPI/4.1.5-GCC-12.3.0
OpenMPI/4.1.6-GCC-13.2.0
OpenMPI/5.0.3-GCC-13.3.0
OpenMPI/5.0.7-GCC-14.2.0
OpenMPI/5.0.8-GCC-14.3.0
OpenMPI/5.0.8-llvm-compilers-20.1.8
</pre>

Similarly, to see what version of mpi4py is available use:

<syntaxhighlight lang="bash">
module spider mpi4py
</syntaxhighlight>

<syntaxhighlight lang="bash">
Versions:
mpi4py/3.0.1 (E)
mpi4py/3.0.2 (E)
mpi4py/3.0.3 (E)
mpi4py/3.1.1 (E)
mpi4py/3.1.3 (E)
mpi4py/3.1.4-gompi-2022b
mpi4py/3.1.4-gompi-2023a
mpi4py/3.1.4 (E)
mpi4py/3.1.5-gompi-2023b
mpi4py/3.1.5 (E)
mpi4py/3.1.6 (E)
mpi4py/4.0.1-gompi-2024a
mpi4py/4.0.1 (E)
</syntaxhighlight>

With the above given information we are going to use <code>OpenMPI/5.0.8-GCC-14.3.0</code> and <code>mpi4py/4.0.1</code>.

== hello_mpi4py.py ==

<syntaxhighlight lang="python">
from mpi4py import MPI
import socket

comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
hostname = socket.gethostname()

print(f"Hello from rank {rank} of {size} on {hostname}")
</syntaxhighlight>

== hello_mpi4py.sbatch ==

<syntaxhighlight lang="bash">
#!/usr/bin/env bash
#SBATCH --job-name=hello-mpi4py
#SBATCH --output=hello-mpi4py-%j.out
#SBATCH --error=hello-mpi4py-%j.err
#SBATCH --nodes=2
#SBATCH --ntasks=8
#SBATCH --time=00:05:00

module load OpenMPI/5.0.8-GCC-14.3.0
module load mpi4py/4.0.1

srun --mpi=pmix_v3 python hello_mpi4py.py
</syntaxhighlight>

Submit the job:

<pre>
sbatch hello_mpi4py.sbatch
</pre>

== Expected Output ==

<pre>
Hello from rank 0 of 8 on rocky4.rocky.nimbios.org
Hello from rank 1 of 8 on rocky4.rocky.nimbios.org
Hello from rank 2 of 8 on rocky4.rocky.nimbios.org
Hello from rank 3 of 8 on rocky4.rocky.nimbios.org
Hello from rank 4 of 8 on rocky5.rocky.nimbios.org
Hello from rank 5 of 8 on rocky5.rocky.nimbios.org
Hello from rank 6 of 8 on rocky5.rocky.nimbios.org
Hello from rank 7 of 8 on rocky5.rocky.nimbios.org
</pre>

Rocky MPI Hello World

2026-01-12T19:01:27Z

Jondale:

= MPI Jobs on Rocky =

== Supported versions ==

Rocky supports PMIx v3 for MPI process management. MPI applications should be launched via srun using --mpi=pmix_v3.

To see what versions of OpenMPI are available use the following command:

<syntaxhighlight lang="bash">
module spider OpenMPI
</syntaxhighlight>

As of the writing of this document the versions available:
<pre>
Versions:
OpenMPI/3.1.1-GCC-7.3.0-2.30
OpenMPI/3.1.3-GCC-8.2.0-2.31.1
OpenMPI/3.1.4-GCC-8.3.0
OpenMPI/4.0.3-GCC-9.3.0
OpenMPI/4.0.5-GCC-10.2.0
OpenMPI/4.1.1-GCC-10.3.0
OpenMPI/4.1.1-GCC-11.2.0
OpenMPI/4.1.4-GCC-11.3.0
OpenMPI/4.1.4-GCC-12.2.0
OpenMPI/4.1.5-GCC-12.3.0
OpenMPI/4.1.6-GCC-13.2.0
OpenMPI/5.0.3-GCC-13.3.0
OpenMPI/5.0.7-GCC-14.2.0
OpenMPI/5.0.8-GCC-14.3.0
OpenMPI/5.0.8-llvm-compilers-20.1.8
</pre>

----

= MPI Example: Hello World in C =

This example demonstrates compiling and running MPI across multiple nodes.

== Step 1 — Create the MPI program (hello_mpi.c) ==

<syntaxhighlight lang="c">
#include <mpi.h>
#include <stdio.h>

int main(int argc, char *argv[]) {
int rank, size, len;
char name[MPI_MAX_PROCESSOR_NAME];

MPI_Init(&argc, &argv);

MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Get_processor_name(name, &len);

printf("Hello from rank %d of %d on %s", rank, size, name);

MPI_Finalize();
return 0;
}
</syntaxhighlight>

== Step 2 — Compile the program ==

Load the appropriate version of OpenMPI you want to use and then compile your program with mpicc.
<pre>
module load OpenMPI/5.0.8-GCC-14.3.0
mpicc -O2 -o hello_mpi hello_mpi.c
</pre>

== Step 3 — Submit an MPI batch job (mpi_hello.sbatch) ==

Create the batch file that we'll name <code>mpi_hello.sbatch</code>. 
Notice that we are using <code>--mpi=pmix_v3</code> as a parameter to srun.
<syntaxhighlight lang="bash">
#!/usr/bin/env bash
#SBATCH --job-name=mpi-hello
#SBATCH --output=mpi-hello-%j.out
#SBATCH --error=mpi-hello-%j.err
#SBATCH --nodes=2
#SBATCH --ntasks=8
#SBATCH --time=00:05:00

module load OpenMPI/5.0.8-GCC-14.3.0

srun --mpi=pmix_v3 ./hello_mpi
</syntaxhighlight>

Use sbatch to submit the job defined in our sbatch file:

<pre>
sbatch mpi_hello.sbatch
</pre>

== Step 4 — Expected Output ==

The generated output file (<code>mpi-hello-<jobid>.out</code>) should contain:

<pre>
Hello from rank 0 of 8 on rocky4.rocky.nimbios.org
Hello from rank 1 of 8 on rocky4.rocky.nimbios.org
Hello from rank 2 of 8 on rocky4.rocky.nimbios.org
Hello from rank 3 of 8 on rocky4.rocky.nimbios.org
Hello from rank 4 of 8 on rocky5.rocky.nimbios.org
Hello from rank 5 of 8 on rocky5.rocky.nimbios.org
Hello from rank 6 of 8 on rocky5.rocky.nimbios.org
Hello from rank 7 of 8 on rocky5.rocky.nimbios.org
</pre>

Rocky MPI Hello World

2026-01-12T18:55:52Z

Jondale:

= MPI Jobs on Rocky =

== Supported versions ==

To see what versions of OpenMPI are available use the following command:

<syntaxhighlight lang="bash">
module spider OpenMPI
</syntaxhighlight>

As of the writing of this document the versions available:
<pre>
Versions:
OpenMPI/3.1.1-GCC-7.3.0-2.30
OpenMPI/3.1.3-GCC-8.2.0-2.31.1
OpenMPI/3.1.4-GCC-8.3.0
OpenMPI/4.0.3-GCC-9.3.0
OpenMPI/4.0.5-GCC-10.2.0
OpenMPI/4.1.1-GCC-10.3.0
OpenMPI/4.1.1-GCC-11.2.0
OpenMPI/4.1.4-GCC-11.3.0
OpenMPI/4.1.4-GCC-12.2.0
OpenMPI/4.1.5-GCC-12.3.0
OpenMPI/4.1.6-GCC-13.2.0
OpenMPI/5.0.3-GCC-13.3.0
OpenMPI/5.0.7-GCC-14.2.0
OpenMPI/5.0.8-GCC-14.3.0
OpenMPI/5.0.8-llvm-compilers-20.1.8
</pre>

----

= MPI Example: Hello World in C =

This example demonstrates compiling and running MPI across multiple nodes.

== Step 1 — Create the MPI program (hello_mpi.c) ==

<syntaxhighlight lang="c">
#include <mpi.h>
#include <stdio.h>

int main(int argc, char *argv[]) {
int rank, size, len;
char name[MPI_MAX_PROCESSOR_NAME];

MPI_Init(&argc, &argv);

MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Get_processor_name(name, &len);

printf("Hello from rank %d of %d on %s", rank, size, name);

MPI_Finalize();
return 0;
}
</syntaxhighlight>

== Step 2 — Compile the program ==

Load the appropriate version of OpenMPI you want to use and then compile your program with mpicc.
<pre>
module load OpenMPI/5.0.8-GCC-14.3.0
mpicc -O2 -o hello_mpi hello_mpi.c
</pre>

== Step 3 — Submit an MPI batch job (mpi_hello.sbatch) ==

Create the batch file that we'll name mpi_hello.sbatch
<syntaxhighlight lang="bash">
#!/usr/bin/env bash
#SBATCH --job-name=mpi-hello
#SBATCH --output=mpi-hello-%j.out
#SBATCH --error=mpi-hello-%j.err
#SBATCH --nodes=2
#SBATCH --ntasks=8
#SBATCH --time=00:05:00

module load OpenMPI/5.0.8-GCC-14.3.0

srun --mpi=pmix_v3 ./hello_mpi
</syntaxhighlight>

Use sbatch to submit the job defined in our sbatch file:

<pre>
sbatch mpi_hello.sbatch
</pre>

== Step 4 — Expected Output ==

The generated output file (<code>mpi-hello-<jobid>.out</code>) should contain:

<pre>
Hello from rank 0 of 8 on rocky4.rocky.nimbios.org
Hello from rank 1 of 8 on rocky4.rocky.nimbios.org
Hello from rank 2 of 8 on rocky4.rocky.nimbios.org
Hello from rank 3 of 8 on rocky4.rocky.nimbios.org
Hello from rank 4 of 8 on rocky5.rocky.nimbios.org
Hello from rank 5 of 8 on rocky5.rocky.nimbios.org
Hello from rank 6 of 8 on rocky5.rocky.nimbios.org
Hello from rank 7 of 8 on rocky5.rocky.nimbios.org
</pre>

Rocky MPI Hello World

2026-01-09T21:28:27Z

Jondale:

= MPI Jobs on Rocky =

== Supported MPI Stack ==

We currently recommend and support:

* '''OpenMPI 4.1.6'''
* '''PMIx 4.2.6'''

''OpenMPI 5+ will be supported with a future software upgrade''

----

= MPI Example: Hello World in C =

This example demonstrates compiling and running MPI across multiple nodes.

== Step 1 — Create the MPI program (hello_mpi.c) ==

<syntaxhighlight lang="c">
#include <mpi.h>
#include <stdio.h>

int main(int argc, char *argv[]) {
int rank, size, len;
char name[MPI_MAX_PROCESSOR_NAME];

MPI_Init(&argc, &argv);

MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Get_processor_name(name, &len);

printf("Hello from rank %d of %d on %s", rank, size, name);

MPI_Finalize();
return 0;
}
</syntaxhighlight>

== Step 2 — Compile the program ==

<pre>
module load OpenMPI/4.1.6-GCC-13.2.0
mpicc -O2 -o hello_mpi hello_mpi.c
</pre>

== Step 3 — Submit an MPI batch job (mpi_hello.sbatch) ==

<syntaxhighlight lang="bash">
#!/usr/bin/env bash
#SBATCH --job-name=mpi-hello
#SBATCH --output=mpi-hello-%j.out
#SBATCH --error=mpi-hello-%j.err
#SBATCH --nodes=2
#SBATCH --ntasks=8
#SBATCH --time=00:05:00

module load OpenMPI/4.1.6-GCC-13.2.0

srun --mpi=pmix_v3 ./hello_mpi
</syntaxhighlight>

Submit the job:

<pre>
sbatch mpi_hello.sbatch
</pre>

== Step 4 — Expected Output ==

The generated output file (<code>mpi-hello-<jobid>.out</code>) should contain:

<pre>
Hello from rank 0 of 8 on rocky4.rocky.nimbios.org
Hello from rank 1 of 8 on rocky4.rocky.nimbios.org
Hello from rank 2 of 8 on rocky4.rocky.nimbios.org
Hello from rank 3 of 8 on rocky4.rocky.nimbios.org
Hello from rank 4 of 8 on rocky5.rocky.nimbios.org
Hello from rank 5 of 8 on rocky5.rocky.nimbios.org
Hello from rank 6 of 8 on rocky5.rocky.nimbios.org
Hello from rank 7 of 8 on rocky5.rocky.nimbios.org
</pre>

Rocky MPI Hello World

2026-01-09T21:27:40Z

Jondale:

Rocky Python MPI Hello World

2025-12-16T14:22:55Z

Jondale:

= MPI4PY Jobs on Rocky =

== Supported Stack ==

We currently recommend and support:

* '''OpenMPI 4.1.6'''
* '''PMIx 4.2.6'''
* '''mpi4py 4.0.1'''

= MPI4PY Example: Hello World in Python =

== hello_mpi4py.py ==

<syntaxhighlight lang="python">
from mpi4py import MPI
import socket

comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
hostname = socket.gethostname()

print(f"Hello from rank {rank} of {size} on {hostname}")
</syntaxhighlight>

== hello_mpi4py.sbatch ==

<syntaxhighlight lang="bash">
#!/usr/bin/env bash
#SBATCH --job-name=hello-mpi4py
#SBATCH --output=hello-mpi4py-%j.out
#SBATCH --error=hello-mpi4py-%j.err
#SBATCH --nodes=2
#SBATCH --ntasks=8
#SBATCH --time=00:05:00

module load OpenMPI/4.1.6-GCC-13.2.0
module load mpi4py/4.0.1

srun --mpi=pmix_v3 python hello_mpi4py.py
</syntaxhighlight>

Submit the job:

<pre>
sbatch hello_mpi4py.sbatch
</pre>

== Expected Output ==

<pre>
Hello from rank 0 of 8 on rocky4.rocky.nimbios.org
Hello from rank 1 of 8 on rocky4.rocky.nimbios.org
Hello from rank 2 of 8 on rocky4.rocky.nimbios.org
Hello from rank 3 of 8 on rocky4.rocky.nimbios.org
Hello from rank 4 of 8 on rocky5.rocky.nimbios.org
Hello from rank 5 of 8 on rocky5.rocky.nimbios.org
Hello from rank 6 of 8 on rocky5.rocky.nimbios.org
Hello from rank 7 of 8 on rocky5.rocky.nimbios.org
</pre>

Rocky Python MPI Hello World

2025-12-16T14:21:56Z

Jondale:

= MPI Jobs on Rocky =

== Supported Stack ==

We currently recommend and support:

* '''OpenMPI 4.1.6'''
* '''PMIx 4.2.6'''
* '''mpi4py 4.0.1'''

= MPI Example: Hello World in Python =

== hello_mpi4py.py ==

<syntaxhighlight lang="python">
from mpi4py import MPI
import socket

comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
hostname = socket.gethostname()

print(f"Hello from rank {rank} of {size} on {hostname}")
</syntaxhighlight>

== hello_mpi4py.sbatch ==

<syntaxhighlight lang="bash">
#!/usr/bin/env bash
#SBATCH --job-name=hello-mpi4py
#SBATCH --output=hello-mpi4py-%j.out
#SBATCH --error=hello-mpi4py-%j.err
#SBATCH --nodes=2
#SBATCH --ntasks=8
#SBATCH --time=00:05:00

module load OpenMPI/4.1.6-GCC-13.2.0
module load mpi4py/4.0.1

srun --mpi=pmix_v3 python hello_mpi4py.py
</syntaxhighlight>

Submit the job:

<pre>
sbatch hello_mpi4py.sbatch
</pre>

== Expected Output ==

<pre>
Hello from rank 0 of 8 on rocky4.rocky.nimbios.org
Hello from rank 1 of 8 on rocky4.rocky.nimbios.org
Hello from rank 2 of 8 on rocky4.rocky.nimbios.org
Hello from rank 3 of 8 on rocky4.rocky.nimbios.org
Hello from rank 4 of 8 on rocky5.rocky.nimbios.org
Hello from rank 5 of 8 on rocky5.rocky.nimbios.org
Hello from rank 6 of 8 on rocky5.rocky.nimbios.org
Hello from rank 7 of 8 on rocky5.rocky.nimbios.org
</pre>

Rocky Python MPI Hello World

2025-12-16T14:19:19Z

Jondale:

= MPI Jobs on Rocky =

== Supported Stack ==

We currently recommend and support:

* '''OpenMPI 4.1.6'''
* '''PMIx 4.2.6'''
* '''mpi4py 4.0.1'''

= MPI Example: Hello World in Python =

== hello_mpi4py.py ==

<syntaxhighlight lang="python">
from mpi4py import MPI
import socket

comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
hostname = socket.gethostname()

print(f"Hello from rank {rank} of {size} on {hostname}")
</syntaxhighlight>

== hello_mpi4py.sbatch ==

<syntaxhighlight lang="bash">
#!/usr/bin/env bash
#SBATCH --job-name=hello-mpi4py
#SBATCH --output=hello-mpi4py-%j.out
#SBATCH --error=hello-mpi4py-%j.err
#SBATCH --nodes=2
#SBATCH --ntasks=8
#SBATCH --time=00:05:00

module load OpenMPI/4.1.6-GCC-13.2.0
module load mpi4py

srun --mpi=pmix_v3 python hello_mpi4py.py
</syntaxhighlight>

Submit the job:

<pre>
sbatch hello_mpi4py.sbatch
</pre>

== Expected Output ==

<pre>
Hello from rank 0 of 8 on rocky4.rocky.nimbios.org
Hello from rank 1 of 8 on rocky4.rocky.nimbios.org
Hello from rank 2 of 8 on rocky4.rocky.nimbios.org
Hello from rank 3 of 8 on rocky4.rocky.nimbios.org
Hello from rank 4 of 8 on rocky5.rocky.nimbios.org
Hello from rank 5 of 8 on rocky5.rocky.nimbios.org
Hello from rank 6 of 8 on rocky5.rocky.nimbios.org
Hello from rank 7 of 8 on rocky5.rocky.nimbios.org
</pre>

Rocky Python MPI Hello World

2025-12-16T14:18:49Z

Jondale:

= MPI Jobs on Rocky =

== Supported Stack ==

We currently recommend and support:

* '''OpenMPI 4.1.6'''
* '''PMIx 4.2.6'''
* '''mpi4py 4.0.1'''

= MPI Example: Hello World in Python =

== hello_mpi4py.py ==

<syntaxhighlight lang="python">
from mpi4py import MPI
import socket

comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
hostname = socket.gethostname()

print(f"Hello from rank {rank} of {size} on {hostname}")
</syntaxhighlight>

== hello_mpi4py.sbatch ==

<syntaxhighlight lang="bash">
#!/usr/bin/env bash
#SBATCH --job-name=hello-mpi4py
#SBATCH --output=hello-mpi4py-%j.out
#SBATCH --error=hello-mpi4py-%j.err
#SBATCH --nodes=2
#SBATCH --ntasks=3
#SBATCH --time=00:05:00

module load OpenMPI/4.1.6-GCC-13.2.0
module load mpi4py

srun --mpi=pmix_v3 python hello_mpi4py.py
</syntaxhighlight>

Submit the job:

<pre>
sbatch hello_mpi4py.sbatch
</pre>

== Expected Output ==

<pre>
Hello from rank 0 of 8 on rocky4.rocky.nimbios.org
Hello from rank 1 of 8 on rocky4.rocky.nimbios.org
Hello from rank 2 of 8 on rocky4.rocky.nimbios.org
Hello from rank 3 of 8 on rocky4.rocky.nimbios.org
Hello from rank 4 of 8 on rocky5.rocky.nimbios.org
Hello from rank 5 of 8 on rocky5.rocky.nimbios.org
Hello from rank 6 of 8 on rocky5.rocky.nimbios.org
Hello from rank 7 of 8 on rocky5.rocky.nimbios.org
</pre>

Rocky Python MPI Hello World

2025-12-16T14:17:24Z

Jondale: Created page with "= MPI Jobs on Rocky = == Supported Stack == We currently recommend and support: * '''OpenMPI 4.1.6''' * '''PMIx 4.2.6''' * '''mpi4py 4.0.1''' = MPI Example: Hello World in Python = == hello_mpi4py.py == <syntaxhighlight lang="python"> from mpi4py import MPI import socket comm = MPI.COMM_WORLD rank = comm.Get_rank() size = comm.Get_size() hostname = socket.gethostname() print(f"Hello from rank {rank} of {size} on {hostname}") </syntaxhighlight> == hello_mpi4py.s..."

= MPI Jobs on Rocky =

== Supported Stack ==

We currently recommend and support:

* '''OpenMPI 4.1.6'''
* '''PMIx 4.2.6'''
* '''mpi4py 4.0.1'''

= MPI Example: Hello World in Python =

== hello_mpi4py.py ==

<syntaxhighlight lang="python">
from mpi4py import MPI
import socket

comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
hostname = socket.gethostname()

print(f"Hello from rank {rank} of {size} on {hostname}")
</syntaxhighlight>

== hello_mpi4py.sbatch ==

<syntaxhighlight lang="bash">
#!/usr/bin/env bash
#SBATCH --job-name=hello-mpi4py
#SBATCH --output=hello-mpi4py-%j.out
#SBATCH --error=hello-mpi4py-%j.err
#SBATCH --nodes=1
#SBATCH --ntasks=3
#SBATCH --time=00:05:00
#SBATCH --partition=kivlin,compute_all

module load OpenMPI/4.1.6-GCC-13.2.0
module load mpi4py

echo "=== Running mpi4py test with Slurm PMIx ==="
srun --mpi=pmix_v3 python hello_mpi4py.py
</syntaxhighlight>

Submit the job:

<pre>
sbatch hello_mpi4py.sbatch
</pre>

== Expected Output ==

<pre>
Hello from rank 0 of 8 on rocky4.rocky.nimbios.org
Hello from rank 1 of 8 on rocky4.rocky.nimbios.org
Hello from rank 2 of 8 on rocky4.rocky.nimbios.org
Hello from rank 3 of 8 on rocky4.rocky.nimbios.org
Hello from rank 4 of 8 on rocky5.rocky.nimbios.org
Hello from rank 5 of 8 on rocky5.rocky.nimbios.org
Hello from rank 6 of 8 on rocky5.rocky.nimbios.org
Hello from rank 7 of 8 on rocky5.rocky.nimbios.org
</pre>

Rocky MPI Hello World

2025-12-16T14:03:29Z

Jondale:

= MPI Jobs on Rocky =

== Supported MPI Stack ==

We currently recommend and support:

* '''OpenMPI 4.1.6'''
* '''PMIx 4.2.6'''

''OpenMPI 5+ will be supported with a future software upgrade''

----

= MPI Example: Hello World in C =

This example demonstrates compiling and running MPI across multiple nodes.

== Step 1 — Create the MPI program (hello_mpi.c) ==

<syntaxhighlight lang="c">
#include <mpi.h>
#include <stdio.h>

int main(int argc, char *argv[]) {
int rank, size, len;
char name[MPI_MAX_PROCESSOR_NAME];

MPI_Init(&argc, &argv);

MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Get_processor_name(name, &len);

printf("Hello from rank %d of %d on %s", rank, size, name);

MPI_Finalize();
return 0;
}
</syntaxhighlight>

== Step 2 — Compile the program ==

<pre>
module load OpenMPI/4.1.6-GCC-13.2.0
mpicc -O2 -o hello_mpi hello_mpi.c
</pre>

== Step 3 — Submit an MPI batch job (mpi_hello.sbatch) ==

<syntaxhighlight lang="bash">
#!/usr/bin/env bash
#SBATCH --job-name=mpi-hello
#SBATCH --output=mpi-hello-%j.out
#SBATCH --error=mpi-hello-%j.err
#SBATCH --nodes=2
#SBATCH --ntasks=8
#SBATCH --time=00:05:00

module load OpenMPI/4.1.6-GCC-13.2.0

srun --mpi=pmix_v3 ./hello_mpi

# optionally use mpirun instead of srun
#mpirun -np "$SLURM_NTASKS" ./hello_mpi
</syntaxhighlight>

Submit the job:

<pre>
sbatch mpi_hello.sbatch
</pre>

== Step 4 — Expected Output ==

The generated output file (<code>mpi-hello-<jobid>.out</code>) should contain:

<pre>
Hello from rank 0 of 8 on rocky4.rocky.nimbios.org
Hello from rank 1 of 8 on rocky4.rocky.nimbios.org
Hello from rank 2 of 8 on rocky4.rocky.nimbios.org
Hello from rank 3 of 8 on rocky4.rocky.nimbios.org
Hello from rank 4 of 8 on rocky5.rocky.nimbios.org
Hello from rank 5 of 8 on rocky5.rocky.nimbios.org
Hello from rank 6 of 8 on rocky5.rocky.nimbios.org
Hello from rank 7 of 8 on rocky5.rocky.nimbios.org
</pre>

----

= Quick Reference =

{| class="wikitable"
! Action !! Command
|-
| Load MPI module || <code>module load OpenMPI/4.1.6-GCC-13.2.0</code>
|-
| Recommended launch || <code>srun --mpi=pmix_v3 ./my_program</code>
|-
| Alternative launch || <code>mpirun ./my_program</code>
|-
| Avoid || <code>srun --mpi=pmi2</code>, <code>srun --mpi=none</code>, OpenMPI 5
|}

Rocky MPI Hello World

2025-12-16T00:40:50Z

Jondale:

= MPI Jobs on Rocky =

== Supported MPI Stack ==

We currently recommend and support:

* '''OpenMPI 4.1.6'''
* '''PMIx 4.2.6'''

''OpenMPI 5+ will be supported with a future software upgrade''

----

= MPI Example: Hello World in C =

This example demonstrates compiling and running MPI across multiple nodes.

== Step 1 — Create the MPI program (hello_mpi.c) ==

<syntaxhighlight lang="c">
#include <mpi.h>
#include <stdio.h>

int main(int argc, char *argv[]) {
int rank, size, len;
char name[MPI_MAX_PROCESSOR_NAME];

MPI_Init(&argc, &argv);

MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Get_processor_name(name, &len);

printf("Hello from rank %d of %d on %s", rank, size, name);

MPI_Finalize();
return 0;
}
</syntaxhighlight>

== Step 2 — Compile the program ==

<pre>
module load OpenMPI/4.1.6-GCC-13.2.0
mpicc -O2 -o hello_mpi hello_mpi.c
</pre>

== Step 3 — Submit an MPI batch job (mpi_hello.sbatch) ==

<syntaxhighlight lang="bash">
#!/usr/bin/env bash
#SBATCH --job-name=mpi-hello
#SBATCH --output=mpi-hello-%j.out
#SBATCH --error=mpi-hello-%j.err
#SBATCH --nodes=2
#SBATCH --ntasks=8
#SBATCH --time=00:05:00
#SBATCH --partition=compute

module load OpenMPI/4.1.6-GCC-13.2.0

srun --mpi=pmix_v3 ./hello_mpi

# optionally use mpirun instead of srun
#mpirun -np "$SLURM_NTASKS" ./hello_mpi
</syntaxhighlight>

Submit the job:

<pre>
sbatch mpi_hello.sbatch
</pre>

== Step 4 — Expected Output ==

The generated output file (<code>mpi-hello-<jobid>.out</code>) should contain:

<pre>
Hello from rank 0 of 8 on rocky4.rocky.nimbios.org
Hello from rank 1 of 8 on rocky4.rocky.nimbios.org
Hello from rank 2 of 8 on rocky4.rocky.nimbios.org
Hello from rank 3 of 8 on rocky4.rocky.nimbios.org
Hello from rank 4 of 8 on rocky5.rocky.nimbios.org
Hello from rank 5 of 8 on rocky5.rocky.nimbios.org
Hello from rank 6 of 8 on rocky5.rocky.nimbios.org
Hello from rank 7 of 8 on rocky5.rocky.nimbios.org
</pre>

----

= Quick Reference =

{| class="wikitable"
! Action !! Command
|-
| Load MPI module || <code>module load OpenMPI/4.1.6-GCC-13.2.0</code>
|-
| Recommended launch || <code>srun --mpi=pmix_v3 ./my_program</code>
|-
| Alternative launch || <code>mpirun ./my_program</code>
|-
| Avoid || <code>srun --mpi=pmi2</code>, <code>srun --mpi=none</code>, OpenMPI 5
|}

Rocky MPI Hello World

2025-11-20T20:48:50Z

Jondale: Created page with "TBA"

TBA

Main Page

2024-06-03T13:47:37Z

Jondale:

Welcome to the NIMBioS Wiki.

= Rocky =

[[Rocky_User_Guide|Rocky User Guide]] 
[[Rocky_Access_Form|Rocky Access Form]] 
[[Rocky_Access_SSH|Accessing Rocky: Linux or Mac]] 
[[Rocky_Access_Windows|Accessing Rocky: Windows]] 

= Facilities =

[[Printers|Printers]]

Printers

2024-04-23T14:23:00Z

Jondale:

= About =

Printers are positioned throughout the first floor of Claxton.

The Business office has scanning and fax capabilities as well.

= Printers =

{| class="wikitable" style="margin:auto"
|-
! Location !! Make/Model !! Type !! Address !! Manuals/Drivers
|-
| Hallway near Claxton 124 || HP Color LaserJet M452dn || Color || printer1.nimbios.org || [https://support.hp.com/us-en/product/hp-color-laserjet-pro-m452-series/7326532 Manuals & Drivers]
|-
| Claxton 126 (Business Office) || Bizhub C300i || Color/Scan/Fax || bizhub.nimbios.org || [https://kmbs.konicaminolta.us/products/multifunction/color-multi-function/bizhub-c360i-c300i-c250i/ Manuals & Drivers]
|}

= Guides =

[https://support.microsoft.com/en-us/help/4015386/windows-10-install-printer Add a printer in Windows 10]

[https://support.apple.com/kb/ph25081?locale=en_US Add a printer in MacOS]

Printers

2024-04-23T14:22:40Z

Jondale:

= About =

Printers are positioned throughout the first floor of Claxton.

The Business office has scanning and fax capabilities as well.

= Printers =

{| class="wikitable" style="margin:auto"
|-
! Location !! Make/Model !! Type !! Address !! Manuals/Drivers
|-
| Hallway near Claxton 124 || HP Color LaserJet M452dn || Color || printer1.nimbios.org || [https://support.hp.com/us-en/product/hp-color-laserjet-pro-m452-series/7326532 Manuals & Drivers]
|-
| Hallway near Claxton 126 || HP LaserJet P2055dn || B+W || printer2.nimbios.org || [https://support.hp.com/us-en/product/HP-LaserJet-P2055-Printer-series/3662052/model/3662058?jumpid=reg_r1002_usen_s-001_title_r0002 Manuals & Drivers]
|-
| Claxton 106 (Business Office) || Bizhub C300i || Color/Scan/Fax || bizhub.nimbios.org || [https://kmbs.konicaminolta.us/products/multifunction/color-multi-function/bizhub-c360i-c300i-c250i/ Manuals & Drivers]
|}

= Guides =

[https://support.microsoft.com/en-us/help/4015386/windows-10-install-printer Add a printer in Windows 10]

[https://support.apple.com/kb/ph25081?locale=en_US Add a printer in MacOS]

Rocky R package

2024-02-29T14:07:09Z

Jondale:

= About =

The R modules on Rocky have many packages pre-loaded but not all of them. We are able to install our own packages locally in our home directory.

= Installing =

First we load the R module we want to use. For our example, we're going to use R/4.2.2-foss-2022b.

<pre>
module load R/4.2.2-foss-2022b
</pre>

Next we decide on a location for the R packages to be installed, make that directory, and then set the R_LIBS_USER environment variable to point to the new location. Here we use the name of the module as the package directory name since each version will need it's own packages installed separately.

<pre>
mkdir -p ~/R/4.2.2-foss-2022b
export R_LIBS_USER="$HOME/R/4.2.2-foss-2022b"
</pre>

Now we start R and install the package. If we have not set a mirror, it will ask for us to choose one.
<pre>
R
install.packages('adespatial')
</pre>

= Using =

In our batch file for our job, we load the R module and set the R_LIBS_USER environment variable so that our job can find our installed packages.

'''spatial_test.sh'''
<pre>
#!/bin/bash

#SBATCH --job-name=SPATIAL_TEST
#SBATCH --output=R_spatial_%j.out

module load R/4.2.2-foss-2022b
export R_LIBS_USER="$HOME/R/4.2.2-foss-2022b"

Rscript spatial.R
</pre>

We run the job just like any other Rocky job by using the sbatch command.

<pre>
sbatch spatial_test.sh
</pre>

Rocky User Guide

2024-02-28T20:13:54Z

Jondale: /* R */

= About Rocky =

Rocky is a [https://en.wikipedia.org/wiki/High-performance_computing HPC] cluster comprised of compute heavy nodes with 40 cores/80 threads and 512GB of ram ['''rocky'''], memory intensive nodes with 20 cores/40 threads and 768GB of RAM ['''moose'''], and a [https://docs.ceph.com Ceph] storage subsystem ['''quarrel''']

== Requesting Access ==
In order to gain access to Rocky you must first fill out the [[Rocky_Access_Form]].

== Logging in to Rocky ==
Rocky's firewall limits access to the UTK network. You will either need to be on campus or using the [https://utk.teamdynamix.com/TDClient/2277/OIT-Portal/KB/ArticleDet?ID=123517 Campus VPN]

Once your account is created you will be able to SSH into a shell or SCP to copy files to/from Rocky.

Rocky uses Public Key Authentication for access instead of passwords.

Please review the following pages for OS specific instructions:

{| class='wikitable'
|-
| [[Rocky_Access_SSH]] || Linux or Mac
|-
| [[Rocky_Access_Windows]] || Windows
|}

== Environmental Modules ==
Rocky uses [https://lmod.readthedocs.io/en/latest/ Lmod] as it's environmental module system. This allows you to easily set your session or job's environment to support the language, libraries, and specific versions needed.

To learn more about using Lmod on Rocky, check out [[ Rocky_Environments | Rocky Environments]].

== Submitting a Job ==

Rocky uses [https://slurm.schedmd.com/documentation.html Slurm] to queue and submit jobs to the cluster's compute nodes.

The nature of a compute cluster is that jobs are meant to be submitted to a queue. Jobs are processed based on a [https://slurm.schedmd.com/classic_fair_share.html Fairshare] priority system. Your job's priority is based on the associations you have (such as your lab) and how much compute you and they have used recently. Sometimes your jobs might run instantly but other times you might have a wait time before they process.

To learn how to set up your own jobs, check out the [[Rocky_Job_Anatomy | Anatomy of a Rocky Job]]

= Examples =

Beyond the below examples, we have also started a [https://github.com/rocky-cluster Github Repository].

==== Python ====
* [[ Rocky_Python_HelloWorld | Hello World ]]
* [[ Rocky_Python_Prime | Discover Prime Numbers ]]
* [[ Rocky_Python_Prime_Array | Discover Prime Numbers using a job array ]]

==== R ====
* [[ Rocky_R_HelloWorld | Hello World ]]
* [[ Rocky_R_Prime | Discover Prime Numbers ]]
* [[ Rocky_R_package | Install packages locally ]]

==== MATLAB ====
* [[ Rocky_MATLAB_HelloWorld | Hello World ]]
* [[ Rocky_MATLAB_Prime_Array | Discover Prime Numbers using a job array ]]

= Acknowledgement and Citations =

If any work on Rocky is used in a research report, journal, or publication that requires citation of authors' work, please acknowledge NIMBioS.

Our suggested acknowledgment is as follows.

'''[A portion of] The computation for this work was performed on the National Institute for Modeling Biological Systems (NIMBioS) computational resources at the University of Tennessee.'''

Rocky R package

2024-02-28T20:12:23Z

Jondale:

= About =

The R modules on Rocky have many packages pre-loaded but not all of them. You are able to install your own packages locally in your home directory.

= Installing =

First we load the R module we want to use. For our example, we're going to use the R/4.2.2-foss-2022b module/version.

<pre>
module load R/4.2.2-foss-2022b
</pre>

Next we decide on a location for the R packages to be installed, make that directory, and then set the R_LIBS_USER environment variable to point to the new location. Here I have decided to use the name of the module/version as the directory name. If I choose to use a different R module/version later, I can choose a different package directory to use.

<pre>
mkdir -p ~/R/4.2.2-foss-2022b
export R_LIBS_USER="$HOME/R/4.2.2-foss-2022b"
</pre>

Now I can start R and install the package. If you have not set a mirror, it will ask you to choose one.
<pre>
R
install.packages('adespatial')
</pre>

= Using =

In our batch file for our job, we need to load the correct module for R and set the R_LIBS_USER environment variable so that it can find our installed packages.

'''spatial_test.sh'''
<pre>
#!/bin/bash

#SBATCH --job-name=SPATIAL_TEST
#SBATCH --output=R_spatial_%j.out

module load R/4.2.2-foss-2022b
export R_LIBS_USER="$HOME/R/4.2.2-foss-2022b"

Rscript spatial.R
</pre>

You will run the job now just like any other job by using the sbatch command.

<pre>
sbatch spatial_test.sh
</pre>

Rocky R package

2024-02-28T20:10:15Z

Jondale: Created page with "= About = The R modules on Rocky have many packages pre-loaded but not all of them. If you find yourself needing one that isn't, you are able to install it locally in your home directory. = Installing = First we load the R module we want to use. For our example, we're going to use the R/4.2.2-foss-2022b module/version. <pre> module load R/4.2.2-foss-2022b </pre> Next we decide on a location for the R packages to be installed, make that directory, and then set th..."

= About =

The R modules on Rocky have many packages pre-loaded but not all of them. If you find yourself needing one that isn't, you are able to install it locally in your home directory.

= Installing =

First we load the R module we want to use. For our example, we're going to use the R/4.2.2-foss-2022b module/version.

<pre>
module load R/4.2.2-foss-2022b
</pre>

Next we decide on a location for the R packages to be installed, make that directory, and then set the R_LIBS_USER environment variable to point to the new location. Here I have decided to use the name of the module/version as the directory name. If I choose to use a different R module/version later, I can choose a different package directory to use.

<pre>
mkdir -p ~/R/4.2.2-foss-2022b
export R_LIBS_USER="$HOME/R/4.2.2-foss-2022b"
</pre>

Now I can start R and install the package. If you have not set a mirror, it will ask you to choose one.
<pre>
R
install.packages('adespatial')
</pre>

= Using =

In our batch file for our job, we need to load the correct module for R and set the R_LIBS_USER environment variable so that it can find our installed packages.

'''spatial_test.sh'''
<pre>
#!/bin/bash

#SBATCH --job-name=SPATIAL_TEST
#SBATCH --output=R_spatial_%j.out

module load R/4.2.2-foss-2022b
export R_LIBS_USER="$HOME/R/4.2.2-foss-2022b"

Rscript spatial.R
</pre>

You will run the job now just like any other job by using the sbatch command.

<pre>
sbatch spatial_test.sh
</pre>

Rocky Kivlin

2024-02-13T14:53:22Z

Jondale:

= About =
Kivlin Lab has purchased compute resources on the [[Rocky User Guide|Rocky cluster]]. These resources are only available to accounts associated with the Kivlin Lab. When [[Rocky Access Form|requesting an account]], please specify your association with the lab to gain access to these resources.

= Kivlin Partition =
Below are the nodes in the Kivlin Partition: 

{| class="wikitable"
|-
! Node !! Type !! Architecture !! vCPU !! Memory
|-
| bull1 || compute || Xeon Gold 6430 (Sapphire Rapids) || 128 || 512G
|}

= Usage =

By default, accounts will use the <code>compute_all</code> partition which includes all shared pool resources. When [[Rocky Job Anatomy|submitting a job to Rocky]], you will need to specify the <code>kivlin</code> partition as part of your batch file. 

Example batch file: 
<pre>
#SBATCH --partition=kivlin,compute_all

#SBATCH --job-name=PYTHON_PRIME
#SBATCH --output=python_prime_%j.out
#SBATCH --mail-user=me@test.com
#SBATCH --mail-type=END

module load Python

python3 prime.py
</pre>

In the above batch file, you can see that we specify the <code>kivlin</code> partition followed by the <code>compute_all</code> partition. With these parameters, the job scheduler will look for available resources on the kivlin partition first. If all those are in use it will then use resources from the shared pool.

Rocky Kivlin

2024-02-12T22:00:47Z

Jondale:

= About =
Kivlin Lab has purchased compute resources on the [[Rocky User Guide|Rocky cluster]]. These resources are only available to accounts associated with the Kivlin Lab. When [[Rocky Access Form|requesting an account]], please specify your association with the lab to gain access to these resources.

= Kivlin Partition =
Below are the nodes in the Kivlin Partition: 

{| class="wikitable"
|-
! Node !! Type !! Architecture !! vCPU !! Memory !! Exclusivity
|-
| bull1 || compute || Xeon Gold 6430 (Sapphire Rapids) || 128 || 512G || 2/13/2024 - 2/13/2027
|}

= Usage =

By default, accounts will use the <code>compute_all</code> partition which includes all shared pool resources. When [[Rocky Job Anatomy|submitting a job to Rocky]], you will need to specify the <code>kivlin</code> partition as part of your batch file. 

Example batch file: 
<pre>
#SBATCH --partition=kivlin,compute_all

#SBATCH --job-name=PYTHON_PRIME
#SBATCH --output=python_prime_%j.out
#SBATCH --mail-user=me@test.com
#SBATCH --mail-type=END

module load Python

python3 prime.py
</pre>

In the above batch file, you can see that we specify the <code>kivlin</code> partition followed by the <code>compute_all</code> partition. With these parameters, the job scheduler will look for available resources on the kivlin partition first. If all those are in use it will then use resources from the shared pool.

Rocky Kivlin

2024-02-12T21:59:51Z

Jondale:

= About =
Kivlin Lab has purchased compute resources on the [[Rocky User Guide|Rocky cluster]]. These resources are only available to accounts associated with the Kivlin Lab. Please specify you are associated with the Kivlin Lab when [[Rocky Access Form|requesting an account]].

= Kivlin Partition =
Below are the nodes in the Kivlin Partition: 

{| class="wikitable"
|-
! Node !! Type !! Architecture !! vCPU !! Memory !! Exclusivity
|-
| bull1 || compute || Xeon Gold 6430 (Sapphire Rapids) || 128 || 512G || 2/13/2024 - 2/13/2027
|}

= Usage =

By default, accounts will use the <code>compute_all</code> partition which includes all shared pool resources. When [[Rocky Job Anatomy|submitting a job to Rocky]], you will need to specify the <code>kivlin</code> partition as part of your batch file. 

Example batch file: 
<pre>
#SBATCH --partition=kivlin,compute_all

#SBATCH --job-name=PYTHON_PRIME
#SBATCH --output=python_prime_%j.out
#SBATCH --mail-user=me@test.com
#SBATCH --mail-type=END

module load Python

python3 prime.py
</pre>

In the above batch file, you can see that we specify the <code>kivlin</code> partition followed by the <code>compute_all</code> partition. With these parameters, the job scheduler will look for available resources on the kivlin partition first. If all those are in use it will then use resources from the shared pool.

Rocky Kivlin

2024-02-12T21:52:50Z

Jondale: Created page with "= About = Kivlin Lab has purchased compute resources on the Rocky cluster. These resources are only available to accounts associated with the Kivlin Lab. Please specify you are associated with the Kivlin Lab when requesting an account. = Exclusive Nodes = {| class="wikitable" |- ! Node !! Type !! Architecture !! vCPU !! Memory !! Exclusivity |- | bull1 || compute || Xeon Gold 6430 (Sapphire Rapids) || 128 || 512G || 2/12/202..."

= About =
Kivlin Lab has purchased compute resources on the [[Rocky User Guide|Rocky cluster]]. These resources are only available to accounts associated with the Kivlin Lab. Please specify you are associated with the Kivlin Lab when [[Rocky Access Form|requesting an account]].

= Exclusive Nodes =
{| class="wikitable"
|-
! Node !! Type !! Architecture !! vCPU !! Memory !! Exclusivity
|-
| bull1 || compute || Xeon Gold 6430 (Sapphire Rapids) || 128 || 512G || 2/12/2024 - 2/12/2027
|}

= Usage =

By default, accounts will use the <code>compute_all</code> partition which includes all shared pool resources. When [[Rocky Job Anatomy|submitting a job to Rocky]], you will need to specify the <code>kivlin</code> partition. 

Example batch file: 
<pre>
#SBATCH --partition=kivlin,compute_all

#SBATCH --job-name=PYTHON_PRIME
#SBATCH --output=python_prime_%j.out
#SBATCH --mail-user=me@test.com
#SBATCH --mail-type=END

module load Python

python3 prime.py
</pre>

In the above batch file, you can see that we specify the <code>kivlin</code> partition followed by the <code>compute_all</code> partition. With these parameters, the job schedule will look for available resources on the kivlin partition first. If all those are in use it will then use resources from the shared pool.

Rocky User Guide

2024-01-11T19:14:31Z

Jondale:

= About Rocky =

Rocky is a [https://en.wikipedia.org/wiki/High-performance_computing HPC] cluster comprised of compute heavy nodes with 40 cores/80 threads and 512GB of ram ['''rocky'''], memory intensive nodes with 20 cores/40 threads and 768GB of RAM ['''moose'''], and a [https://docs.ceph.com Ceph] storage subsystem ['''quarrel''']

== Requesting Access ==
In order to gain access to Rocky you must first fill out the [[Rocky_Access_Form]].

== Logging in to Rocky ==
Rocky's firewall limits access to the UTK network. You will either need to be on campus or using the [https://utk.teamdynamix.com/TDClient/2277/OIT-Portal/KB/ArticleDet?ID=123517 Campus VPN]

Once your account is created you will be able to SSH into a shell or SCP to copy files to/from Rocky.

Rocky uses Public Key Authentication for access instead of passwords.

Please review the following pages for OS specific instructions:

{| class='wikitable'
|-
| [[Rocky_Access_SSH]] || Linux or Mac
|-
| [[Rocky_Access_Windows]] || Windows
|}

== Environmental Modules ==
Rocky uses [https://lmod.readthedocs.io/en/latest/ Lmod] as it's environmental module system. This allows you to easily set your session or job's environment to support the language, libraries, and specific versions needed.

To learn more about using Lmod on Rocky, check out [[ Rocky_Environments | Rocky Environments]].

== Submitting a Job ==

Rocky uses [https://slurm.schedmd.com/documentation.html Slurm] to queue and submit jobs to the cluster's compute nodes.

The nature of a compute cluster is that jobs are meant to be submitted to a queue. Jobs are processed based on a [https://slurm.schedmd.com/classic_fair_share.html Fairshare] priority system. Your job's priority is based on the associations you have (such as your lab) and how much compute you and they have used recently. Sometimes your jobs might run instantly but other times you might have a wait time before they process.

To learn how to set up your own jobs, check out the [[Rocky_Job_Anatomy | Anatomy of a Rocky Job]]

= Examples =

Beyond the below examples, we have also started a [https://github.com/rocky-cluster Github Repository].

==== Python ====
* [[ Rocky_Python_HelloWorld | Hello World ]]
* [[ Rocky_Python_Prime | Discover Prime Numbers ]]
* [[ Rocky_Python_Prime_Array | Discover Prime Numbers using a job array ]]

==== R ====
* [[ Rocky_R_HelloWorld | Hello World ]]
* [[ Rocky_R_Prime | Discover Prime Numbers ]]

==== MATLAB ====
* [[ Rocky_MATLAB_HelloWorld | Hello World ]]
* [[ Rocky_MATLAB_Prime_Array | Discover Prime Numbers using a job array ]]

= Acknowledgement and Citations =

If any work on Rocky is used in a research report, journal, or publication that requires citation of authors' work, please acknowledge NIMBioS.

Our suggested acknowledgment is as follows.

'''[A portion of] The computation for this work was performed on the National Institute for Modeling Biological Systems (NIMBioS) computational resources at the University of Tennessee.'''

Rocky User Guide

2023-10-12T20:49:39Z

Jondale: /* Submitting a Job */

= About Rocky =

Rocky is a [https://en.wikipedia.org/wiki/High-performance_computing HPC] cluster comprised of compute heavy nodes with 40 cores/80 threads and 512GB of ram ['''rocky'''], memory intensive nodes with 20 cores/40 threads and 768GB of RAM ['''moose'''], and a [https://docs.ceph.com Ceph] storage subsystem ['''quarrel''']

== Requesting Access ==
In order to gain access to Rocky you must first fill out the [[Rocky_Access_Form]].

== Logging in to Rocky ==
Rocky's firewall limits access to the UTK network. You will either need to be on campus or using the [https://utk.teamdynamix.com/TDClient/2277/OIT-Portal/KB/ArticleDet?ID=123517 Campus VPN]

Once your account is created you will be able to SSH into a shell or SCP to copy files to/from Rocky.

Rocky uses Public Key Authentication for access instead of passwords.

Please review the following pages for OS specific instructions:

{| class='wikitable'
|-
| [[Rocky_Access_SSH]] || Linux or Mac
|-
| [[Rocky_Access_Windows]] || Windows
|}

== Environmental Modules ==
Rocky uses [https://lmod.readthedocs.io/en/latest/ Lmod] as it's environmental module system. This allows you to easily set your session or job's environment to support the language, libraries, and specific versions needed.

To learn more about using Lmod on Rocky, check out [[ Rocky_Environments | Rocky Environments]].

== Submitting a Job ==

Rocky uses [https://slurm.schedmd.com/documentation.html Slurm] to queue and submit jobs to the cluster's compute nodes.

The nature of a compute cluster is that jobs are meant to be submitted to a queue. Jobs are processed based on a [https://slurm.schedmd.com/classic_fair_share.html Fairshare] priority system. Your job's priority is based on the associations you have (such as your lab) and how much compute you and they have used recently. Sometimes your jobs might run instantly but other times you might have a wait time before they process.

To learn how to set up your own jobs, check out the [[Rocky_Job_Anatomy | Anatomy of a Rocky Job]]

= Examples =

Beyond the below examples, we have also started a [https://github.com/rocky-cluster Github Repository].

==== Python ====
* [[ Rocky_Python_HelloWorld | Hello World ]]
* [[ Rocky_Python_Prime | Discover Prime Numbers ]]
* [[ Rocky_Python_Prime_Array | Discover Prime Numbers using a job array ]]

==== R ====
* [[ Rocky_R_HelloWorld | Hello World ]]
* [[ Rocky_R_Prime | Discover Prime Numbers ]]

==== MATLAB ====
* [[ Rocky_MATLAB_HelloWorld | Hello World ]]
* [[ Rocky_MATLAB_Prime_Array | Discover Prime Numbers using a job array ]]

Rocky Job Anatomy

2023-09-12T15:04:59Z

Jondale:

= Anatomy of a Rocky Job =

Setting up a job to run on Rocky starts by creating or uploading your project's files to the project directory within your home directory on Rocky. These files will include the code you've written, any data files needed, and a batch file.

==== Your Code ====

Your code is what is submitted and executed on Rocky's compute nodes. 
It can be written in any of the languages supported by Rocky environment modules (Lmod).

==== Your Data ====

If your job will be processing data, you'll need to upload that data to your project's directory.

Your home directory is shared amongst all compute nodes. No matter which node your job is assigned, it will have access to your data.

==== Batch Script ====

The batch script is a shell script that brings everything together by defining job parameters, loading any environment modules needed, and finally executing your code.

Job parameters are defined one per line and start with <code>#SBATCH</code>. 
All parameters have default values and are optional but most batch scripts will use some. 

You can view all of the sbatch options at: 
https://slurm.schedmd.com/sbatch.html

Below is an example batch file using some of the most common options:

'''my_job.run'''
<pre>
#!/bin/bash
#SBATCH --job-name=MY_JOB ### job name
#SBATCH --output=my_job_%j.out ### file to store job output
#SBATCH --time=1-00:00:00 ### maximum time limit for job (Days-HH:MM:SS)
#SBATCH --mem-per-cpu=2G ### amount of memory per cpu to allocate
#SBATCH --cpus-per-task=1 ### number of cpu to allocate
#SBATCH --mail-user=me@test.com ### email address to notify
#SBATCH --mail-type=END ### send an email when the job ends

module load R/4.2.1-foss-2022a

Rscript my_code.R
</pre>

= Running Job =

==== Submitting Job ====

Jobs are submitted using the <code>sbatch</code> command and passed your batch script as a parameter. This will add your job to the queue.

<pre>
sbatch my_job.run
</pre>

==== Watching Job ====

While your job is in the queue or being executed you may see it's status using the <code>squeue</code> command. If the job is currently running it will show which node(s) it is assigned.

<pre>
[test_user@rocky7 ~]$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
2947 compute_all my_job test_use R 0:05 1 moose1
</pre>

==== Cancelling Job ====

To cancel a job, use the <code>scancel</code> command and pass the JOBID (as returned by <code>squeue</code>).

<pre>
scancel 2947
</pre>

Rocky Job Anatomy

2023-09-12T14:47:10Z

Jondale:

= Anatomy of a Rocky Job =

Setting up a job to run on Rocky starts by creating or uploading your project's files to the project directory within your home directory on Rocky. These files will include the code you've written, any data files needed, and a batch file.

==== Your Code ====

Your code is what is submitted and executed on Rocky's compute nodes. 
It can be written in any of the languages supported by Rocky environment modules (Lmod).

==== Your Data ====

If your job will be processing data, you'll need to upload that data to your project's directory.

Your home directory is shared amongst all compute nodes. No matter which node your job is assigned, it will have access to your data.

==== Batch Script ====

The batch script is a shell script that brings everything together by defining job parameters, loading any environment modules needed, and finally executing your code.

Job parameters are defined one per line and start with <code>#SBATCH</code>. 
All parameters have default values and are optional but most batch scripts will use some. 

You can view all of the sbatch options at: 
https://slurm.schedmd.com/sbatch.html

Below is an example batch file using some of the most common options:

'''my_job.run'''
<pre>
#!/bin/bash
#SBATCH --job-name=MY_JOB ### Job Name
#SBATCH --output=my_job_%j.out ### File in which to store job output
#SBATCH --time=00:10:00 ### Wall clock time limit in Days-HH:MM:SS
#SBATCH --mem-per-cpu=2G ### How much RAM per cpu
#SBATCH --cpus-per-task=1 ### How many cpu to use per task
#SBATCH --mail-user=me@test.com ### My email address
#SBATCH --mail-type=END ### Which events to send email

module load R/4.2.1-foss-2022a

Rscript my_code.R
</pre>

= Running Job =

==== Submitting Job ====

Jobs are submitted using the <code>sbatch</code> command and passed your batch script as a parameter. This will add your job to the queue.

<pre>
sbatch my_job.run
</pre>

==== Watching Job ====

While your job is in the queue or being executed you may see it's status using the <code>squeue</code> command. If the job is currently running it will show which node(s) it is assigned.

<pre>
[test_user@rocky7 ~]$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
2947 compute_all my_job test_use R 0:05 1 moose1
</pre>

==== Cancelling Job ====

To cancel a job, use the <code>scancel</code> command and pass the JOBID (as returned by <code>squeue</code>).

<pre>
scancel 2947
</pre>

Rocky User Guide

2022-09-14T16:00:22Z

Jondale: /* Workload Management */

Main Page

2022-09-07T14:35:10Z

Jondale: /* Facilities */

Main Page

2022-09-07T14:34:09Z

Jondale: /* Facilities */

Printers

2022-09-07T14:33:45Z

Jondale: /* Printers */

= About =

Printers are positioned throughout the first floor of Claxton.

The Business office has scanning and fax capabilities as well.

= Printers =

{| class="wikitable" style="margin:auto"
|-
! Location !! Make/Model !! Type !! Address !! Manuals/Drivers
|-
| Hallway near Claxton 124 || HP Color LaserJet M452dn || Color || printer1.nimbios.org || [https://support.hp.com/us-en/product/hp-color-laserjet-pro-m452-series/7326532 Manuals & Drivers]
|-
| Hallway near Claxton 130 || HP LaserJet P2055dn || B+W || printer2.nimbios.org || [https://support.hp.com/us-en/product/HP-LaserJet-P2055-Printer-series/3662052/model/3662058?jumpid=reg_r1002_usen_s-001_title_r0002 Manuals & Drivers]
|-
| Claxton 106 (Business Office) || Bizhub C300i || Color/Scan/Fax || bizhub.nimbios.org || [https://kmbs.konicaminolta.us/products/multifunction/color-multi-function/bizhub-c360i-c300i-c250i/ Manuals & Drivers]
|}

= Guides =

[https://support.microsoft.com/en-us/help/4015386/windows-10-install-printer Add a printer in Windows 10]

[https://support.apple.com/kb/ph25081?locale=en_US Add a printer in MacOS]

Rocky User Guide

2022-09-02T20:19:53Z

Jondale: /* Workload Management */

Rocky Slurm Basic Multi

2022-08-25T21:06:48Z

Jondale:

__TOC__

= About =

In these examples, you'll see how to use SBATCH parameters to take advantage of multiple nodes and multiple cores on those nodes. For example purposes, we'll use a simple bash script. It's only purpose is to output the hostname of the node we're on and the cpuid the script is running. This will help illustrate that our script is being run on multiple nodes and/or multiple cores on each node.

'''myscript.sh'''

<pre>
#!/bin/bash

H=`hostname -s`
C=`ps -o cpuid -h -p ${BASHPID} | xargs`

echo "${H} (${C})"
</pre>

= Multiple Nodes =

'''slurm-test-nodes.sh'''
<pre>
#!/bin/bash

#SBATCH --job-name=test_nodes_job
#SBATCH --nodes=3
#SBATCH --output=test_nodes_%j.log

srun myscript.sh
</pre>
''Here you can see we are telling sbatch to use 3 nodes for this job.''

<pre>
sbatch slurm-test-nodes.sh
</pre>

<pre>
moose1 (20)
moose2 (20)
rocky1 (40)
</pre>
''Here you can see from the output that the job used 3 nodes (moose1, moose2, and rocky1).''

= Multiple Tasks and Nodes =

<pre>
#!/bin/bash

#SBATCH --job-name=test_tasksnodes_job
#SBATCH --nodes=3
#SBATCH --ntasks=6
#SBATCH --output=log/test_%j.log

srun myscript.sh
</pre>
''We've asked for 3 nodes and 6 total tasks.''

<pre>
moose1 (0)
moose1 (20)
moose2 (0)
moose2 (20)
rocky1 (0)
rocky1 (40)
</pre>
''The log file shows it broke the 6 tasks up amongst 3 nodes.''

= Many Tasks =

<pre>
#!/bin/bash

#SBATCH --job-name=test_job # Job name
#SBATCH --ntasks=100
#SBATCH --output=log/test_%j.log # Standard output and error log

srun myscript.sh
</pre>
''We've asked for 100 tasks. We have not asked for multiple nodes but this will be more tasks than can fit on a single node.''

<pre>
moose2 (6)
moose2 (7)
moose2 (27)
moose1 (0)
moose1 (1)
moose1 (21)
moose2 (26)
moose1 (20)
moose2 (8)
moose2 (28)
moose1 (19)
moose2 (30)
moose2 (14)
moose2 (9)
moose2 (29)
moose2 (10)
moose1 (28)
moose1 (39)
moose1 (30)
moose2 (20)
moose2 (34)
moose2 (31)
moose1 (26)
moose1 (22)
moose2 (25)
moose2 (23)
moose2 (0)
moose1 (27)
moose2 (3)
moose1 (29)
moose1 (9)
moose2 (4)
moose1 (34)
moose1 (17)
moose1 (6)
moose2 (24)
moose1 (7)
moose2 (5)
moose2 (12)
moose1 (37)
moose2 (1)
moose2 (22)
moose2 (2)
moose2 (13)
moose2 (33)
moose2 (11)
moose1 (3)
moose1 (23)
moose1 (11)
moose1 (10)
moose1 (14)
moose2 (35)
moose2 (18)
moose1 (33)
moose1 (2)
moose1 (12)
moose2 (17)
moose2 (37)
moose1 (8)
moose2 (32)
moose2 (21)
moose1 (31)
moose2 (15)
moose1 (13)
moose2 (16)
moose2 (19)
moose2 (39)
moose1 (5)
moose2 (38)
moose2 (36)
moose1 (32)
moose1 (16)
moose1 (25)
moose1 (38)
moose1 (4)
moose1 (36)
moose1 (15)
moose1 (24)
moose1 (18)
moose1 (35)
rocky1 (16)
rocky1 (56)
rocky1 (0)
rocky1 (40)
rocky1 (4)
rocky1 (44)
rocky1 (14)
rocky1 (54)
rocky1 (18)
rocky1 (58)
rocky1 (42)
rocky1 (52)
rocky1 (2)
rocky1 (12)
rocky1 (10)
rocky1 (50)
rocky1 (8)
rocky1 (48)
rocky1 (6)
rocky1 (46)
</pre>

''Here you can see even though we did not ask for more than one node it has split the tasks up across multiple nodes.''

Rocky Slurm Basic Multi

2022-08-25T21:05:16Z

Jondale: /* Many Tasks */

__TOC__

= About =

In these examples, you'll see how to use SBATCH parameters to take advantage of multiple nodes and multiple cores on those nodes.

= myscript.sh =

<pre>
#!/bin/bash

H=`hostname -s`
C=`ps -o cpuid -h -p ${BASHPID} | xargs`

echo "${H} (${C})"
</pre>

''For example purposes, we'll use a simple bash script. It's only purpose is to output the hostname of the node we're on and the cpuid the script is running. This will help illustrate that our script is being run on multiple nodes and/or multiple cores on each node.''

= Multiple Nodes =

'''slurm-test-nodes.sh'''
<pre>
#!/bin/bash

#SBATCH --job-name=test_nodes_job
#SBATCH --nodes=3
#SBATCH --output=test_nodes_%j.log

srun myscript.sh
</pre>
''Here you can see we are telling sbatch to use 3 nodes for this job.''

<pre>
sbatch slurm-test-nodes.sh
</pre>

<pre>
moose1 (20)
moose2 (20)
rocky1 (40)
</pre>
''Here you can see from the output that the job used 3 nodes (moose1, moose2, and rocky1).''

= Multiple Tasks and Nodes =

<pre>
#!/bin/bash

#SBATCH --job-name=test_tasksnodes_job
#SBATCH --nodes=3
#SBATCH --ntasks=6
#SBATCH --output=log/test_%j.log

srun myscript.sh
</pre>
''We've asked for 3 nodes and 6 total tasks.''

<pre>
moose1 (0)
moose1 (20)
moose2 (0)
moose2 (20)
rocky1 (0)
rocky1 (40)
</pre>
''The log file shows it broke the 6 tasks up amongst 3 nodes.''

= Many Tasks =

<pre>
#!/bin/bash

#SBATCH --job-name=test_job # Job name
#SBATCH --ntasks=100
#SBATCH --output=log/test_%j.log # Standard output and error log

srun myscript.sh
</pre>
''We've asked for 100 tasks. We have not asked for multiple nodes but this will be more tasks than can fit on a single node.''

<pre>
moose2 (6)
moose2 (7)
moose2 (27)
moose1 (0)
moose1 (1)
moose1 (21)
moose2 (26)
moose1 (20)
moose2 (8)
moose2 (28)
moose1 (19)
moose2 (30)
moose2 (14)
moose2 (9)
moose2 (29)
moose2 (10)
moose1 (28)
moose1 (39)
moose1 (30)
moose2 (20)
moose2 (34)
moose2 (31)
moose1 (26)
moose1 (22)
moose2 (25)
moose2 (23)
moose2 (0)
moose1 (27)
moose2 (3)
moose1 (29)
moose1 (9)
moose2 (4)
moose1 (34)
moose1 (17)
moose1 (6)
moose2 (24)
moose1 (7)
moose2 (5)
moose2 (12)
moose1 (37)
moose2 (1)
moose2 (22)
moose2 (2)
moose2 (13)
moose2 (33)
moose2 (11)
moose1 (3)
moose1 (23)
moose1 (11)
moose1 (10)
moose1 (14)
moose2 (35)
moose2 (18)
moose1 (33)
moose1 (2)
moose1 (12)
moose2 (17)
moose2 (37)
moose1 (8)
moose2 (32)
moose2 (21)
moose1 (31)
moose2 (15)
moose1 (13)
moose2 (16)
moose2 (19)
moose2 (39)
moose1 (5)
moose2 (38)
moose2 (36)
moose1 (32)
moose1 (16)
moose1 (25)
moose1 (38)
moose1 (4)
moose1 (36)
moose1 (15)
moose1 (24)
moose1 (18)
moose1 (35)
rocky1 (16)
rocky1 (56)
rocky1 (0)
rocky1 (40)
rocky1 (4)
rocky1 (44)
rocky1 (14)
rocky1 (54)
rocky1 (18)
rocky1 (58)
rocky1 (42)
rocky1 (52)
rocky1 (2)
rocky1 (12)
rocky1 (10)
rocky1 (50)
rocky1 (8)
rocky1 (48)
rocky1 (6)
rocky1 (46)
</pre>

''Here you can see even though we did not ask for more than one node it has split the tasks up across multiple nodes.''

Rocky Slurm Basic Multi

2022-08-25T21:04:42Z

Jondale: /* Multiple Nodes */

__TOC__

= About =

In these examples, you'll see how to use SBATCH parameters to take advantage of multiple nodes and multiple cores on those nodes.

= myscript.sh =

<pre>
#!/bin/bash

H=`hostname -s`
C=`ps -o cpuid -h -p ${BASHPID} | xargs`

echo "${H} (${C})"
</pre>

''For example purposes, we'll use a simple bash script. It's only purpose is to output the hostname of the node we're on and the cpuid the script is running. This will help illustrate that our script is being run on multiple nodes and/or multiple cores on each node.''

= Multiple Nodes =

'''slurm-test-nodes.sh'''
<pre>
#!/bin/bash

#SBATCH --job-name=test_nodes_job
#SBATCH --nodes=3
#SBATCH --output=test_nodes_%j.log

srun myscript.sh
</pre>
''Here you can see we are telling sbatch to use 3 nodes for this job.''

<pre>
sbatch slurm-test-nodes.sh
</pre>

<pre>
moose1 (20)
moose2 (20)
rocky1 (40)
</pre>
''Here you can see from the output that the job used 3 nodes (moose1, moose2, and rocky1).''

= Multiple Tasks and Nodes =

<pre>
#!/bin/bash

#SBATCH --job-name=test_tasksnodes_job
#SBATCH --nodes=3
#SBATCH --ntasks=6
#SBATCH --output=log/test_%j.log

srun myscript.sh
</pre>
''We've asked for 3 nodes and 6 total tasks.''

<pre>
moose1 (0)
moose1 (20)
moose2 (0)
moose2 (20)
rocky1 (0)
rocky1 (40)
</pre>
''The log file shows it broke the 6 tasks up amongst 3 nodes.''

= Many Tasks =

<pre>
#!/bin/bash

#SBATCH --job-name=test_job # Job name
#SBATCH --ntasks=100
#SBATCH --output=log/test_%j.log # Standard output and error log

srun myscript.sh
</pre>
Here you can see we've asked for 100 tasks. We have not asked for multiple nodes but this will be more tasks than can fit on a single node.

<pre>
moose2 (6)
moose2 (7)
moose2 (27)
moose1 (0)
moose1 (1)
moose1 (21)
moose2 (26)
moose1 (20)
moose2 (8)
moose2 (28)
moose1 (19)
moose2 (30)
moose2 (14)
moose2 (9)
moose2 (29)
moose2 (10)
moose1 (28)
moose1 (39)
moose1 (30)
moose2 (20)
moose2 (34)
moose2 (31)
moose1 (26)
moose1 (22)
moose2 (25)
moose2 (23)
moose2 (0)
moose1 (27)
moose2 (3)
moose1 (29)
moose1 (9)
moose2 (4)
moose1 (34)
moose1 (17)
moose1 (6)
moose2 (24)
moose1 (7)
moose2 (5)
moose2 (12)
moose1 (37)
moose2 (1)
moose2 (22)
moose2 (2)
moose2 (13)
moose2 (33)
moose2 (11)
moose1 (3)
moose1 (23)
moose1 (11)
moose1 (10)
moose1 (14)
moose2 (35)
moose2 (18)
moose1 (33)
moose1 (2)
moose1 (12)
moose2 (17)
moose2 (37)
moose1 (8)
moose2 (32)
moose2 (21)
moose1 (31)
moose2 (15)
moose1 (13)
moose2 (16)
moose2 (19)
moose2 (39)
moose1 (5)
moose2 (38)
moose2 (36)
moose1 (32)
moose1 (16)
moose1 (25)
moose1 (38)
moose1 (4)
moose1 (36)
moose1 (15)
moose1 (24)
moose1 (18)
moose1 (35)
rocky1 (16)
rocky1 (56)
rocky1 (0)
rocky1 (40)
rocky1 (4)
rocky1 (44)
rocky1 (14)
rocky1 (54)
rocky1 (18)
rocky1 (58)
rocky1 (42)
rocky1 (52)
rocky1 (2)
rocky1 (12)
rocky1 (10)
rocky1 (50)
rocky1 (8)
rocky1 (48)
rocky1 (6)
rocky1 (46)
</pre>

''Here you can see even though we did not ask for more than one node it has split the tasks up across multiple nodes.''

Rocky Slurm Basic Multi

2022-08-25T21:04:24Z

Jondale: /* Multiple Tasks and Nodes */

__TOC__

= About =

In these examples, you'll see how to use SBATCH parameters to take advantage of multiple nodes and multiple cores on those nodes.

= myscript.sh =

<pre>
#!/bin/bash

H=`hostname -s`
C=`ps -o cpuid -h -p ${BASHPID} | xargs`

echo "${H} (${C})"
</pre>

''For example purposes, we'll use a simple bash script. It's only purpose is to output the hostname of the node we're on and the cpuid the script is running. This will help illustrate that our script is being run on multiple nodes and/or multiple cores on each node.''

= Multiple Nodes =

'''slurm-test-nodes.sh'''
<pre>
#!/bin/bash

#SBATCH --job-name=test_nodes_job
#SBATCH --nodes=3
#SBATCH --output=test_nodes_%j.log

srun myscript.sh
</pre>
''Here you can see we are telling sbatch to use 3 nodes for this job.''

<pre>
sbatch slurm-test-nodes.sh
</pre>

'''test_nodes_2954.log'''
<pre>
moose1 (20)
moose2 (20)
rocky1 (40)
</pre>
''Here you can see from the output that the job used 3 nodes (moose1, moose2, and rocky1).''

= Multiple Tasks and Nodes =

<pre>
#!/bin/bash

#SBATCH --job-name=test_tasksnodes_job
#SBATCH --nodes=3
#SBATCH --ntasks=6
#SBATCH --output=log/test_%j.log

srun myscript.sh
</pre>
''We've asked for 3 nodes and 6 total tasks.''

<pre>
moose1 (0)
moose1 (20)
moose2 (0)
moose2 (20)
rocky1 (0)
rocky1 (40)
</pre>
''The log file shows it broke the 6 tasks up amongst 3 nodes.''

= Many Tasks =

<pre>
#!/bin/bash

#SBATCH --job-name=test_job # Job name
#SBATCH --ntasks=100
#SBATCH --output=log/test_%j.log # Standard output and error log

srun myscript.sh
</pre>
Here you can see we've asked for 100 tasks. We have not asked for multiple nodes but this will be more tasks than can fit on a single node.

<pre>
moose2 (6)
moose2 (7)
moose2 (27)
moose1 (0)
moose1 (1)
moose1 (21)
moose2 (26)
moose1 (20)
moose2 (8)
moose2 (28)
moose1 (19)
moose2 (30)
moose2 (14)
moose2 (9)
moose2 (29)
moose2 (10)
moose1 (28)
moose1 (39)
moose1 (30)
moose2 (20)
moose2 (34)
moose2 (31)
moose1 (26)
moose1 (22)
moose2 (25)
moose2 (23)
moose2 (0)
moose1 (27)
moose2 (3)
moose1 (29)
moose1 (9)
moose2 (4)
moose1 (34)
moose1 (17)
moose1 (6)
moose2 (24)
moose1 (7)
moose2 (5)
moose2 (12)
moose1 (37)
moose2 (1)
moose2 (22)
moose2 (2)
moose2 (13)
moose2 (33)
moose2 (11)
moose1 (3)
moose1 (23)
moose1 (11)
moose1 (10)
moose1 (14)
moose2 (35)
moose2 (18)
moose1 (33)
moose1 (2)
moose1 (12)
moose2 (17)
moose2 (37)
moose1 (8)
moose2 (32)
moose2 (21)
moose1 (31)
moose2 (15)
moose1 (13)
moose2 (16)
moose2 (19)
moose2 (39)
moose1 (5)
moose2 (38)
moose2 (36)
moose1 (32)
moose1 (16)
moose1 (25)
moose1 (38)
moose1 (4)
moose1 (36)
moose1 (15)
moose1 (24)
moose1 (18)
moose1 (35)
rocky1 (16)
rocky1 (56)
rocky1 (0)
rocky1 (40)
rocky1 (4)
rocky1 (44)
rocky1 (14)
rocky1 (54)
rocky1 (18)
rocky1 (58)
rocky1 (42)
rocky1 (52)
rocky1 (2)
rocky1 (12)
rocky1 (10)
rocky1 (50)
rocky1 (8)
rocky1 (48)
rocky1 (6)
rocky1 (46)
</pre>

''Here you can see even though we did not ask for more than one node it has split the tasks up across multiple nodes.''

Rocky Slurm Basic Multi

2022-08-25T21:03:33Z

Jondale: /* Multiple Tasks and Nodes */

__TOC__

= About =

In these examples, you'll see how to use SBATCH parameters to take advantage of multiple nodes and multiple cores on those nodes.

= myscript.sh =

<pre>
#!/bin/bash

H=`hostname -s`
C=`ps -o cpuid -h -p ${BASHPID} | xargs`

echo "${H} (${C})"
</pre>

''For example purposes, we'll use a simple bash script. It's only purpose is to output the hostname of the node we're on and the cpuid the script is running. This will help illustrate that our script is being run on multiple nodes and/or multiple cores on each node.''

= Multiple Nodes =

'''slurm-test-nodes.sh'''
<pre>
#!/bin/bash

#SBATCH --job-name=test_nodes_job
#SBATCH --nodes=3
#SBATCH --output=test_nodes_%j.log

srun myscript.sh
</pre>
''Here you can see we are telling sbatch to use 3 nodes for this job.''

<pre>
sbatch slurm-test-nodes.sh
</pre>

'''test_nodes_2954.log'''
<pre>
moose1 (20)
moose2 (20)
rocky1 (40)
</pre>
''Here you can see from the output that the job used 3 nodes (moose1, moose2, and rocky1).''

= Multiple Tasks and Nodes =

<pre>
#!/bin/bash

#SBATCH --job-name=test_tasksnodes_job
#SBATCH --nodes=3
#SBATCH --ntasks=6
#SBATCH --output=log/test_%j.log

srun myscript.sh
</pre>
''Here you can see that we've asked for 3 nodes and 6 total tasks.''

<pre>
moose1 (0)
moose1 (20)
moose2 (0)
moose2 (20)
rocky1 (0)
rocky1 (40)
</pre>
''Here you can see that it broke the 6 tasks up amongst 3 nodes.''

= Many Tasks =

<pre>
#!/bin/bash

#SBATCH --job-name=test_job # Job name
#SBATCH --ntasks=100
#SBATCH --output=log/test_%j.log # Standard output and error log

srun myscript.sh
</pre>
Here you can see we've asked for 100 tasks. We have not asked for multiple nodes but this will be more tasks than can fit on a single node.

<pre>
moose2 (6)
moose2 (7)
moose2 (27)
moose1 (0)
moose1 (1)
moose1 (21)
moose2 (26)
moose1 (20)
moose2 (8)
moose2 (28)
moose1 (19)
moose2 (30)
moose2 (14)
moose2 (9)
moose2 (29)
moose2 (10)
moose1 (28)
moose1 (39)
moose1 (30)
moose2 (20)
moose2 (34)
moose2 (31)
moose1 (26)
moose1 (22)
moose2 (25)
moose2 (23)
moose2 (0)
moose1 (27)
moose2 (3)
moose1 (29)
moose1 (9)
moose2 (4)
moose1 (34)
moose1 (17)
moose1 (6)
moose2 (24)
moose1 (7)
moose2 (5)
moose2 (12)
moose1 (37)
moose2 (1)
moose2 (22)
moose2 (2)
moose2 (13)
moose2 (33)
moose2 (11)
moose1 (3)
moose1 (23)
moose1 (11)
moose1 (10)
moose1 (14)
moose2 (35)
moose2 (18)
moose1 (33)
moose1 (2)
moose1 (12)
moose2 (17)
moose2 (37)
moose1 (8)
moose2 (32)
moose2 (21)
moose1 (31)
moose2 (15)
moose1 (13)
moose2 (16)
moose2 (19)
moose2 (39)
moose1 (5)
moose2 (38)
moose2 (36)
moose1 (32)
moose1 (16)
moose1 (25)
moose1 (38)
moose1 (4)
moose1 (36)
moose1 (15)
moose1 (24)
moose1 (18)
moose1 (35)
rocky1 (16)
rocky1 (56)
rocky1 (0)
rocky1 (40)
rocky1 (4)
rocky1 (44)
rocky1 (14)
rocky1 (54)
rocky1 (18)
rocky1 (58)
rocky1 (42)
rocky1 (52)
rocky1 (2)
rocky1 (12)
rocky1 (10)
rocky1 (50)
rocky1 (8)
rocky1 (48)
rocky1 (6)
rocky1 (46)
</pre>

''Here you can see even though we did not ask for more than one node it has split the tasks up across multiple nodes.''

Rocky Slurm Basic Multi

2022-08-25T21:03:24Z

Jondale: /* Multiple Nodes */

__TOC__

= About =

In these examples, you'll see how to use SBATCH parameters to take advantage of multiple nodes and multiple cores on those nodes.

= myscript.sh =

<pre>
#!/bin/bash

H=`hostname -s`
C=`ps -o cpuid -h -p ${BASHPID} | xargs`

echo "${H} (${C})"
</pre>

''For example purposes, we'll use a simple bash script. It's only purpose is to output the hostname of the node we're on and the cpuid the script is running. This will help illustrate that our script is being run on multiple nodes and/or multiple cores on each node.''

= Multiple Nodes =

'''slurm-test-nodes.sh'''
<pre>
#!/bin/bash

#SBATCH --job-name=test_nodes_job
#SBATCH --nodes=3
#SBATCH --output=test_nodes_%j.log

srun myscript.sh
</pre>
''Here you can see we are telling sbatch to use 3 nodes for this job.''

<pre>
sbatch slurm-test-nodes.sh
</pre>

'''test_nodes_2954.log'''
<pre>
moose1 (20)
moose2 (20)
rocky1 (40)
</pre>
''Here you can see from the output that the job used 3 nodes (moose1, moose2, and rocky1).''

= Multiple Tasks and Nodes =

<pre>
#!/bin/bash

#SBATCH --job-name=test_tasksnodes_job
#SBATCH --nodes=3
#SBATCH --ntasks=6
#SBATCH --output=log/test_%j.log

srun myscript.sh
</pre>
Here you can see that we've asked for 3 nodes and 6 total tasks.

<pre>
moose1 (0)
moose1 (20)
moose2 (0)
moose2 (20)
rocky1 (0)
rocky1 (40)
</pre>
Here you can see that it broke the 6 tasks up amongst 3 nodes.

= Many Tasks =

<pre>
#!/bin/bash

#SBATCH --job-name=test_job # Job name
#SBATCH --ntasks=100
#SBATCH --output=log/test_%j.log # Standard output and error log

srun myscript.sh
</pre>
Here you can see we've asked for 100 tasks. We have not asked for multiple nodes but this will be more tasks than can fit on a single node.

<pre>
moose2 (6)
moose2 (7)
moose2 (27)
moose1 (0)
moose1 (1)
moose1 (21)
moose2 (26)
moose1 (20)
moose2 (8)
moose2 (28)
moose1 (19)
moose2 (30)
moose2 (14)
moose2 (9)
moose2 (29)
moose2 (10)
moose1 (28)
moose1 (39)
moose1 (30)
moose2 (20)
moose2 (34)
moose2 (31)
moose1 (26)
moose1 (22)
moose2 (25)
moose2 (23)
moose2 (0)
moose1 (27)
moose2 (3)
moose1 (29)
moose1 (9)
moose2 (4)
moose1 (34)
moose1 (17)
moose1 (6)
moose2 (24)
moose1 (7)
moose2 (5)
moose2 (12)
moose1 (37)
moose2 (1)
moose2 (22)
moose2 (2)
moose2 (13)
moose2 (33)
moose2 (11)
moose1 (3)
moose1 (23)
moose1 (11)
moose1 (10)
moose1 (14)
moose2 (35)
moose2 (18)
moose1 (33)
moose1 (2)
moose1 (12)
moose2 (17)
moose2 (37)
moose1 (8)
moose2 (32)
moose2 (21)
moose1 (31)
moose2 (15)
moose1 (13)
moose2 (16)
moose2 (19)
moose2 (39)
moose1 (5)
moose2 (38)
moose2 (36)
moose1 (32)
moose1 (16)
moose1 (25)
moose1 (38)
moose1 (4)
moose1 (36)
moose1 (15)
moose1 (24)
moose1 (18)
moose1 (35)
rocky1 (16)
rocky1 (56)
rocky1 (0)
rocky1 (40)
rocky1 (4)
rocky1 (44)
rocky1 (14)
rocky1 (54)
rocky1 (18)
rocky1 (58)
rocky1 (42)
rocky1 (52)
rocky1 (2)
rocky1 (12)
rocky1 (10)
rocky1 (50)
rocky1 (8)
rocky1 (48)
rocky1 (6)
rocky1 (46)
</pre>

''Here you can see even though we did not ask for more than one node it has split the tasks up across multiple nodes.''

Rocky Slurm Basic Multi

2022-08-25T21:03:12Z

Jondale: /* myscript.sh */

__TOC__

= About =

In these examples, you'll see how to use SBATCH parameters to take advantage of multiple nodes and multiple cores on those nodes.

= myscript.sh =

<pre>
#!/bin/bash

H=`hostname -s`
C=`ps -o cpuid -h -p ${BASHPID} | xargs`

echo "${H} (${C})"
</pre>

''For example purposes, we'll use a simple bash script. It's only purpose is to output the hostname of the node we're on and the cpuid the script is running. This will help illustrate that our script is being run on multiple nodes and/or multiple cores on each node.''

= Multiple Nodes =

'''slurm-test-nodes.sh'''
<pre>
#!/bin/bash

#SBATCH --job-name=test_nodes_job
#SBATCH --nodes=3
#SBATCH --output=test_nodes_%j.log

srun myscript.sh
</pre>
Here you can see we are telling sbatch to use 3 nodes for this job.

<pre>
sbatch slurm-test-nodes.sh
</pre>

'''test_nodes_2954.log'''
<pre>
moose1 (20)
moose2 (20)
rocky1 (40)
</pre>
Here you can see from the output that the job used 3 nodes (moose1, moose2, and rocky1).

= Multiple Tasks and Nodes =

<pre>
#!/bin/bash

#SBATCH --job-name=test_tasksnodes_job
#SBATCH --nodes=3
#SBATCH --ntasks=6
#SBATCH --output=log/test_%j.log

srun myscript.sh
</pre>
Here you can see that we've asked for 3 nodes and 6 total tasks.

<pre>
moose1 (0)
moose1 (20)
moose2 (0)
moose2 (20)
rocky1 (0)
rocky1 (40)
</pre>
Here you can see that it broke the 6 tasks up amongst 3 nodes.

= Many Tasks =

<pre>
#!/bin/bash

#SBATCH --job-name=test_job # Job name
#SBATCH --ntasks=100
#SBATCH --output=log/test_%j.log # Standard output and error log

srun myscript.sh
</pre>
Here you can see we've asked for 100 tasks. We have not asked for multiple nodes but this will be more tasks than can fit on a single node.

<pre>
moose2 (6)
moose2 (7)
moose2 (27)
moose1 (0)
moose1 (1)
moose1 (21)
moose2 (26)
moose1 (20)
moose2 (8)
moose2 (28)
moose1 (19)
moose2 (30)
moose2 (14)
moose2 (9)
moose2 (29)
moose2 (10)
moose1 (28)
moose1 (39)
moose1 (30)
moose2 (20)
moose2 (34)
moose2 (31)
moose1 (26)
moose1 (22)
moose2 (25)
moose2 (23)
moose2 (0)
moose1 (27)
moose2 (3)
moose1 (29)
moose1 (9)
moose2 (4)
moose1 (34)
moose1 (17)
moose1 (6)
moose2 (24)
moose1 (7)
moose2 (5)
moose2 (12)
moose1 (37)
moose2 (1)
moose2 (22)
moose2 (2)
moose2 (13)
moose2 (33)
moose2 (11)
moose1 (3)
moose1 (23)
moose1 (11)
moose1 (10)
moose1 (14)
moose2 (35)
moose2 (18)
moose1 (33)
moose1 (2)
moose1 (12)
moose2 (17)
moose2 (37)
moose1 (8)
moose2 (32)
moose2 (21)
moose1 (31)
moose2 (15)
moose1 (13)
moose2 (16)
moose2 (19)
moose2 (39)
moose1 (5)
moose2 (38)
moose2 (36)
moose1 (32)
moose1 (16)
moose1 (25)
moose1 (38)
moose1 (4)
moose1 (36)
moose1 (15)
moose1 (24)
moose1 (18)
moose1 (35)
rocky1 (16)
rocky1 (56)
rocky1 (0)
rocky1 (40)
rocky1 (4)
rocky1 (44)
rocky1 (14)
rocky1 (54)
rocky1 (18)
rocky1 (58)
rocky1 (42)
rocky1 (52)
rocky1 (2)
rocky1 (12)
rocky1 (10)
rocky1 (50)
rocky1 (8)
rocky1 (48)
rocky1 (6)
rocky1 (46)
</pre>

''Here you can see even though we did not ask for more than one node it has split the tasks up across multiple nodes.''

Rocky Slurm Basic Multi

2022-08-25T21:02:59Z

Jondale:

__TOC__

= About =

In these examples, you'll see how to use SBATCH parameters to take advantage of multiple nodes and multiple cores on those nodes.

= myscript.sh =

<pre>
#!/bin/bash

H=`hostname -s`
C=`ps -o cpuid -h -p ${BASHPID} | xargs`

echo "${H} (${C})"
</pre>

For example purposes, we'll use a simple bash script. It's only purpose is to output the hostname of the node we're on and the cpuid the script is running. This will help illustrate that our script is being run on multiple nodes and/or multiple cores on each node.

= Multiple Nodes =

'''slurm-test-nodes.sh'''
<pre>
#!/bin/bash

#SBATCH --job-name=test_nodes_job
#SBATCH --nodes=3
#SBATCH --output=test_nodes_%j.log

srun myscript.sh
</pre>
Here you can see we are telling sbatch to use 3 nodes for this job.

<pre>
sbatch slurm-test-nodes.sh
</pre>

'''test_nodes_2954.log'''
<pre>
moose1 (20)
moose2 (20)
rocky1 (40)
</pre>
Here you can see from the output that the job used 3 nodes (moose1, moose2, and rocky1).

= Multiple Tasks and Nodes =

<pre>
#!/bin/bash

#SBATCH --job-name=test_tasksnodes_job
#SBATCH --nodes=3
#SBATCH --ntasks=6
#SBATCH --output=log/test_%j.log

srun myscript.sh
</pre>
Here you can see that we've asked for 3 nodes and 6 total tasks.

<pre>
moose1 (0)
moose1 (20)
moose2 (0)
moose2 (20)
rocky1 (0)
rocky1 (40)
</pre>
Here you can see that it broke the 6 tasks up amongst 3 nodes.

= Many Tasks =

<pre>
#!/bin/bash

#SBATCH --job-name=test_job # Job name
#SBATCH --ntasks=100
#SBATCH --output=log/test_%j.log # Standard output and error log

srun myscript.sh
</pre>
Here you can see we've asked for 100 tasks. We have not asked for multiple nodes but this will be more tasks than can fit on a single node.

<pre>
moose2 (6)
moose2 (7)
moose2 (27)
moose1 (0)
moose1 (1)
moose1 (21)
moose2 (26)
moose1 (20)
moose2 (8)
moose2 (28)
moose1 (19)
moose2 (30)
moose2 (14)
moose2 (9)
moose2 (29)
moose2 (10)
moose1 (28)
moose1 (39)
moose1 (30)
moose2 (20)
moose2 (34)
moose2 (31)
moose1 (26)
moose1 (22)
moose2 (25)
moose2 (23)
moose2 (0)
moose1 (27)
moose2 (3)
moose1 (29)
moose1 (9)
moose2 (4)
moose1 (34)
moose1 (17)
moose1 (6)
moose2 (24)
moose1 (7)
moose2 (5)
moose2 (12)
moose1 (37)
moose2 (1)
moose2 (22)
moose2 (2)
moose2 (13)
moose2 (33)
moose2 (11)
moose1 (3)
moose1 (23)
moose1 (11)
moose1 (10)
moose1 (14)
moose2 (35)
moose2 (18)
moose1 (33)
moose1 (2)
moose1 (12)
moose2 (17)
moose2 (37)
moose1 (8)
moose2 (32)
moose2 (21)
moose1 (31)
moose2 (15)
moose1 (13)
moose2 (16)
moose2 (19)
moose2 (39)
moose1 (5)
moose2 (38)
moose2 (36)
moose1 (32)
moose1 (16)
moose1 (25)
moose1 (38)
moose1 (4)
moose1 (36)
moose1 (15)
moose1 (24)
moose1 (18)
moose1 (35)
rocky1 (16)
rocky1 (56)
rocky1 (0)
rocky1 (40)
rocky1 (4)
rocky1 (44)
rocky1 (14)
rocky1 (54)
rocky1 (18)
rocky1 (58)
rocky1 (42)
rocky1 (52)
rocky1 (2)
rocky1 (12)
rocky1 (10)
rocky1 (50)
rocky1 (8)
rocky1 (48)
rocky1 (6)
rocky1 (46)
</pre>

''Here you can see even though we did not ask for more than one node it has split the tasks up across multiple nodes.''

Rocky Slurm Basic Multi

2022-08-25T20:56:24Z

Jondale:

Rocky Slurm Basic Multi

2022-08-25T20:51:32Z

Jondale: /* About */

= About =

In these examples, you'll see how to use SBATCH parameters to take advantage of multiple nodes and multiple cores on those nodes.

= myscript.sh =

<pre>
#!/bin/bash

H=`hostname -s`
C=`ps -o cpuid -h -p ${BASHPID} | xargs`

echo "${H} (${C})"
</pre>

For example purposes, we'll use a simple bash script. It's only purpose is to output the hostname of the node we're on and the cpuid the script is running. This will help illustrate that our script is being run on multiple nodes and/or multiple cores on each node.

Rocky Slurm Basic Multi

2022-08-25T20:45:47Z

Jondale: Created page with "= About = = myscript.sh = <pre> #!/bin/bash H=`hostname -s` C=`ps -o cpuid -h -p ${BASHPID} | xargs` echo "${H} (${C})" </pre> For example purposes, we'll use a simple bash script. It's only purpose is to output the hostname of the node we're on and the cpuid the script is running. This will help illustrate that our script is being run on multiple nodes and/or multiple cores on each node."

= About =

= myscript.sh =

<pre>
#!/bin/bash

H=`hostname -s`
C=`ps -o cpuid -h -p ${BASHPID} | xargs`

echo "${H} (${C})"
</pre>

For example purposes, we'll use a simple bash script. It's only purpose is to output the hostname of the node we're on and the cpuid the script is running. This will help illustrate that our script is being run on multiple nodes and/or multiple cores on each node.