Instituto de Física - UFRGS - Contribuições do usuário [pt-br]

Cluster

2025-01-09T17:27:19Z

Leon: /* Criating and executing a Job */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

<pre>

The cluster is managed by professors representing the fields of Astronomy, Theoretical Physics, and Experimental Physics, in addition to an IT department employee from the Physics Institute.

Astronomy: Rogério Riffel

Theoretical Physics: Leonardo Brunnet

Experimental Physics: Pedro Grande

TI employee: Gustavo Feller

</pre>

== Users Committee ==

<pre>

Users have two channels for communication/discussion:

1) The fis-linux-if@grupos.ufrgs.br mailing list

2) Direct messages to the IT department via the email fisica-ti@ufrgs.br.

</pre>

== Infraestruture ==

=== Management Software ===

The system of queues and scheduling of tasks is controlled by the [https://slurm.schedmd.com/ Slurm Workload Manager].

<pre>

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== Rules for scheduling, access control, and usage of the research infrastructure ==

=== Online scheduling ===

The cluster is accessible using the UFRGS virtual prived network ([https://www1.ufrgs.br/CatalogoServicos/servicos/servico?servico=3178 vpn]) through server lovelace.if.ufrgs.br.

To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may configure winscp to enter the address lovelace.if.ufrgs.br.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to use <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager! Just after the second # they are comments. To comment the whole line put ## at the beginning.)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-04T13:52:01Z

Leon: /* Rules for scheduling, access control, and usage of the research infrastructure */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

<pre>

The cluster is managed by professors representing the fields of Astronomy, Theoretical Physics, and Experimental Physics, in addition to an IT department employee from the Physics Institute.

Astronomy: Rogério Riffel

Theoretical Physics: Leonardo Brunnet

Experimental Physics: Pedro Grande

TI employee: Gustavo Feller

</pre>

== Users Committee ==

<pre>

Users have two channels for communication/discussion:

1) The fis-linux-if@grupos.ufrgs.br mailing list

2) Direct messages to the IT department via the email fisica-ti@ufrgs.br.

</pre>

== Infraestruture ==

=== Management Software ===

The system of queues and scheduling of tasks is controlled by the [https://slurm.schedmd.com/ Slurm Workload Manager].

<pre>

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== Rules for scheduling, access control, and usage of the research infrastructure ==

=== Online scheduling ===

The cluster is accessible using the UFRGS virtual prived network ([https://www1.ufrgs.br/CatalogoServicos/servicos/servico?servico=3178 vpn]) through server lovelace.if.ufrgs.br.

To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may configure winscp to enter the address lovelace.if.ufrgs.br.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to use <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-04T13:50:30Z

Leon: /* Management Software */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

<pre>

The cluster is managed by professors representing the fields of Astronomy, Theoretical Physics, and Experimental Physics, in addition to an IT department employee from the Physics Institute.

Astronomy: Rogério Riffel

Theoretical Physics: Leonardo Brunnet

Experimental Physics: Pedro Grande

TI employee: Gustavo Feller

</pre>

== Users Committee ==

<pre>

Users have two channels for communication/discussion:

1) The fis-linux-if@grupos.ufrgs.br mailing list

2) Direct messages to the IT department via the email fisica-ti@ufrgs.br.

</pre>

== Infraestruture ==

=== Management Software ===

The system of queues and scheduling of tasks is controlled by the [https://slurm.schedmd.com/ Slurm Workload Manager].

<pre>

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== Rules for scheduling, access control, and usage of the research infrastructure ==

=== Online scheduling ===

The cluster is accessible using the UFRGS virtual prived network ([https://www1.ufrgs.br/CatalogoServicos/servicos/servico?servico=3178 vpn]) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may configure winscp to enter the address lovelace.if.ufrgs.br.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to use <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-04T13:47:57Z

Leon: /* Management Software */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

<pre>

The cluster is managed by professors representing the fields of Astronomy, Theoretical Physics, and Experimental Physics, in addition to an IT department employee from the Physics Institute.

Astronomy: Rogério Riffel

Theoretical Physics: Leonardo Brunnet

Experimental Physics: Pedro Grande

TI employee: Gustavo Feller

</pre>

== Users Committee ==

<pre>

Users have two channels for communication/discussion:

1) The fis-linux-if@grupos.ufrgs.br mailing list

2) Direct messages to the IT department via the email fisica-ti@ufrgs.br.

</pre>

== Infraestruture ==

=== Management Software ===

[https://slurm.schedmd.com/ Slurm Workload Manager]

<pre>

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== Rules for scheduling, access control, and usage of the research infrastructure ==

=== Online scheduling ===

The cluster is accessible using the UFRGS virtual prived network ([https://www1.ufrgs.br/CatalogoServicos/servicos/servico?servico=3178 vpn]) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may configure winscp to enter the address lovelace.if.ufrgs.br.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to use <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-04T13:46:09Z

Leon: /* Management Software */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

<pre>

The cluster is managed by professors representing the fields of Astronomy, Theoretical Physics, and Experimental Physics, in addition to an IT department employee from the Physics Institute.

Astronomy: Rogério Riffel

Theoretical Physics: Leonardo Brunnet

Experimental Physics: Pedro Grande

TI employee: Gustavo Feller

</pre>

== Users Committee ==

<pre>

Users have two channels for communication/discussion:

1) The fis-linux-if@grupos.ufrgs.br mailing list

2) Direct messages to the IT department via the email fisica-ti@ufrgs.br.

</pre>

== Infraestruture ==

=== Management Software ===

<pre>
[https://slurm.schedmd.com/ Slurm Workload Manager]

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== Rules for scheduling, access control, and usage of the research infrastructure ==

=== Online scheduling ===

The cluster is accessible using the UFRGS virtual prived network ([https://www1.ufrgs.br/CatalogoServicos/servicos/servico?servico=3178 vpn]) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may configure winscp to enter the address lovelace.if.ufrgs.br.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to use <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-04T13:44:56Z

Leon: /* Users Committee */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

<pre>

The cluster is managed by professors representing the fields of Astronomy, Theoretical Physics, and Experimental Physics, in addition to an IT department employee from the Physics Institute.

Astronomy: Rogério Riffel

Theoretical Physics: Leonardo Brunnet

Experimental Physics: Pedro Grande

TI employee: Gustavo Feller

</pre>

== Users Committee ==

<pre>

Users have two channels for communication/discussion:

1) The fis-linux-if@grupos.ufrgs.br mailing list

2) Direct messages to the IT department via the email fisica-ti@ufrgs.br.

</pre>

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== Rules for scheduling, access control, and usage of the research infrastructure ==

=== Online scheduling ===

The cluster is accessible using the UFRGS virtual prived network ([https://www1.ufrgs.br/CatalogoServicos/servicos/servico?servico=3178 vpn]) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may configure winscp to enter the address lovelace.if.ufrgs.br.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to use <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-04T13:10:29Z

Leon: /* Online scheduling */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

<pre>

The cluster is managed by professors representing the fields of Astronomy, Theoretical Physics, and Experimental Physics, in addition to an IT department employee from the Physics Institute.

Astronomy: Rogério Riffel

Theoretical Physics: Leonardo Brunnet

Experimental Physics: Pedro Grande

TI employee: Gustavo Feller

</pre>

== Users Committee ==

<pre>

Users have two channels for communication:

1) The fis-linux-if@grupos.ufrgs.br mailing list

2) Direct messages to the IT department via the email fisica-ti@ufrgs.br.

</pre>

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== Rules for scheduling, access control, and usage of the research infrastructure ==

=== Online scheduling ===

The cluster is accessible using the UFRGS virtual prived network ([https://www1.ufrgs.br/CatalogoServicos/servicos/servico?servico=3178 vpn]) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may configure winscp to enter the address lovelace.if.ufrgs.br.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to use <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-04T13:07:42Z

Leon: /* Rules for scheduling, access control, and usage of the research infrastructure */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

<pre>

The cluster is managed by professors representing the fields of Astronomy, Theoretical Physics, and Experimental Physics, in addition to an IT department employee from the Physics Institute.

Astronomy: Rogério Riffel

Theoretical Physics: Leonardo Brunnet

Experimental Physics: Pedro Grande

TI employee: Gustavo Feller

</pre>

== Users Committee ==

<pre>

Users have two channels for communication:

1) The fis-linux-if@grupos.ufrgs.br mailing list

2) Direct messages to the IT department via the email fisica-ti@ufrgs.br.

</pre>

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== Rules for scheduling, access control, and usage of the research infrastructure ==

=== Online scheduling ===

The clusters are accessible using the UFRGS virtual prived network ([https://www1.ufrgs.br/CatalogoServicos/servicos/servico?servico=3178 vpn]) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to use <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-04T12:50:54Z

Leon: /* Using softwares in the cluster */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

<pre>

The cluster is managed by professors representing the fields of Astronomy, Theoretical Physics, and Experimental Physics, in addition to an IT department employee from the Physics Institute.

Astronomy: Rogério Riffel

Theoretical Physics: Leonardo Brunnet

Experimental Physics: Pedro Grande

TI employee: Gustavo Feller

</pre>

== Users Committee ==

<pre>

Users have two channels for communication:

1) The fis-linux-if@grupos.ufrgs.br mailing list

2) Direct messages to the IT department via the email fisica-ti@ufrgs.br.

</pre>

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== Rules for scheduling, access control, and usage of the research infrastructure ==

=== Online scheduling ===

The clusters are accessible using the UFRGS virtual prived network (vpn) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to use <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-04T12:49:58Z

Leon: /* Installed Software */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

<pre>

The cluster is managed by professors representing the fields of Astronomy, Theoretical Physics, and Experimental Physics, in addition to an IT department employee from the Physics Institute.

Astronomy: Rogério Riffel

Theoretical Physics: Leonardo Brunnet

Experimental Physics: Pedro Grande

TI employee: Gustavo Feller

</pre>

== Users Committee ==

<pre>

Users have two channels for communication:

1) The fis-linux-if@grupos.ufrgs.br mailing list

2) Direct messages to the IT department via the email fisica-ti@ufrgs.br.

</pre>

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== Rules for scheduling, access control, and usage of the research infrastructure ==

=== Online scheduling ===

The clusters are accessible using the UFRGS virtual prived network (vpn) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-04T12:49:25Z

Leon: /* Hardware in ada nodes */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

<pre>

The cluster is managed by professors representing the fields of Astronomy, Theoretical Physics, and Experimental Physics, in addition to an IT department employee from the Physics Institute.

Astronomy: Rogério Riffel

Theoretical Physics: Leonardo Brunnet

Experimental Physics: Pedro Grande

TI employee: Gustavo Feller

</pre>

== Users Committee ==

<pre>

Users have two channels for communication:

1) The fis-linux-if@grupos.ufrgs.br mailing list

2) Direct messages to the IT department via the email fisica-ti@ufrgs.br.

</pre>

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12 (in lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== Rules for scheduling, access control, and usage of the research infrastructure ==

=== Online scheduling ===

The clusters are accessible using the UFRGS virtual prived network (vpn) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-03T15:10:21Z

Leon: /* Rules for scheduling, access control, and usage of the research infrastructure existing within the institution */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

<pre>

The cluster is managed by professors representing the fields of Astronomy, Theoretical Physics, and Experimental Physics, in addition to an IT department employee from the Physics Institute.

Astronomy: Rogério Riffel

Theoretical Physics: Leonardo Brunnet

Experimental Physics: Pedro Grande

TI employee: Gustavo Feller

</pre>

== Users Committee ==

<pre>

Users have two channels for communication:

1) The fis-linux-if@grupos.ufrgs.br mailing list

2) Direct messages to the IT department via the email fisica-ti@ufrgs.br.

</pre>

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12 (in lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== Rules for scheduling, access control, and usage of the research infrastructure ==

=== Online scheduling ===

The clusters are accessible using the UFRGS virtual prived network (vpn) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-03T15:07:12Z

Leon: /* Conect to cluster-slurm */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

<pre>

The cluster is managed by professors representing the fields of Astronomy, Theoretical Physics, and Experimental Physics, in addition to an IT department employee from the Physics Institute.

Astronomy: Rogério Riffel

Theoretical Physics: Leonardo Brunnet

Experimental Physics: Pedro Grande

TI employee: Gustavo Feller

</pre>

== Users Committee ==

<pre>

Users have two channels for communication:

1) The fis-linux-if@grupos.ufrgs.br mailing list

2) Direct messages to the IT department via the email fisica-ti@ufrgs.br.

</pre>

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12 (in lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== Rules for scheduling, access control, and usage of the research infrastructure existing within the institution ==

=== Online scheduling ===

The clusters are accessible using the UFRGS virtual prived network (vpn) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-03T15:06:01Z

Leon: /* How to use */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

<pre>

The cluster is managed by professors representing the fields of Astronomy, Theoretical Physics, and Experimental Physics, in addition to an IT department employee from the Physics Institute.

Astronomy: Rogério Riffel

Theoretical Physics: Leonardo Brunnet

Experimental Physics: Pedro Grande

TI employee: Gustavo Feller

</pre>

== Users Committee ==

<pre>

Users have two channels for communication:

1) The fis-linux-if@grupos.ufrgs.br mailing list

2) Direct messages to the IT department via the email fisica-ti@ufrgs.br.

</pre>

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12 (in lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== Rules for scheduling, access control, and usage of the research infrastructure existing within the institution ==

=== Conect to cluster-slurm ===

The clusters are accessible using the UFRGS virtual prived network (vpn) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-03T14:54:54Z

Leon: /* Users Committee */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

<pre>

The cluster is managed by professors representing the fields of Astronomy, Theoretical Physics, and Experimental Physics, in addition to an IT department employee from the Physics Institute.

Astronomy: Rogério Riffel

Theoretical Physics: Leonardo Brunnet

Experimental Physics: Pedro Grande

TI employee: Gustavo Feller

</pre>

== Users Committee ==

<pre>

Users have two channels for communication:

1) The fis-linux-if@grupos.ufrgs.br mailing list

2) Direct messages to the IT department via the email fisica-ti@ufrgs.br.

</pre>

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12 (in lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible using the UFRGS virtual prived network (vpn) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-03T14:48:07Z

Leon: /* Management Committee */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

<pre>

The cluster is managed by professors representing the fields of Astronomy, Theoretical Physics, and Experimental Physics, in addition to an IT department employee from the Physics Institute.

Astronomy: Rogério Riffel

Theoretical Physics: Leonardo Brunnet

Experimental Physics: Pedro Grande

TI employee: Gustavo Feller

</pre>

== Users Committee ==

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12 (in lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible using the UFRGS virtual prived network (vpn) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-03T14:46:26Z

Leon: /* Management Committee */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

The cluster is managed by professors representing the fields of Astronomy, Theoretical Physics, and Experimental Physics, in addition to an IT department employee from the Physics Institute.

Astronomy: Rogério Riffel

Theoretical Physics: Leonardo Brunnet

Experimental Physics: Pedro Grande

TI employee: Gustavo Feller

== Users Committee ==

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12 (in lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible using the UFRGS virtual prived network (vpn) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-03T14:45:27Z

Leon: /* Management Committee */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

The cluster is managed by professors representing the fields of Astronomy, Theoretical Physics, and Experimental Physics, in addition to an IT department employee from the IF.
Astronomy: Rogério Riffel
Theoretical Physics: Leonardo Brunnet
Experimental Physics: Pedro Grande
TI employee: Gustavo Feller

== Users Committee ==

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12 (in lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible using the UFRGS virtual prived network (vpn) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-03T14:39:25Z

Leon: /* Hardware in lovelace nodes */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

== Users Committee ==

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: Three nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12 (in lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible using the UFRGS virtual prived network (vpn) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-03T14:38:45Z

Leon: /* Clusters Ada and Lovelace - Instituto de Física UFRGS */

= Cluster Lovelace - Instituto de Física UFRGS =

The cluster is located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

== Users Committee ==

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: hree nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12 (in lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible using the UFRGS virtual prived network (vpn) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-03T14:38:12Z

Leon: /* Installed Software */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

== Users Committee ==

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: hree nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 12 (in lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible using the UFRGS virtual prived network (vpn) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-03T14:37:39Z

Leon: /* Conect to cluster-slurm */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

== Users Committee ==

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: hree nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 8 (in ada)
OS: Debian 12 (in lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible using the UFRGS virtual prived network (vpn) through server lovelace.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-03T14:37:02Z

Leon: /* Conect to cluster-slurm */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

== Users Committee ==

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: hree nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 8 (in ada)
OS: Debian 12 (in lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible using the UFRGS virtual prived network (vpn) through server cluster-slurm.if.ufrgs.br.
To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-04-03T14:33:28Z

Leon: /* Clusters Ada and Lovelace - Instituto de Física UFRGS */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Management Committee ==

== Users Committee ==

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: hree nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 8 (in ada)
OS: Debian 12 (in lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-01-25T12:22:51Z

Leon: /* Management Software */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150

Account request: mail to fisica-ti@ufrgs.br
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: hree nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 8 (in ada)
OS: Debian 12 (in lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-01-25T12:20:27Z

Leon: /* Installed Software */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: hree nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 8 (in ada)
OS: Debian 12 (in lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-01-25T12:19:46Z

Leon: /* Hardware in lovelace nodes */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores) + AMD 16 cores
RAM: 64 GB each
GPU: hree nodes with NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 8 (in cluster ada)
OS: Debian 12 (in cluster lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-01-25T12:17:39Z

Leon: /* Hardware in the lovelace nodes */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores)
RAM: 64 GB each
GPU: two nodes have NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 8 (in cluster ada)
OS: Debian 12 (in cluster lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-01-25T12:17:00Z

Leon: /* Software in the nodes */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in the lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores)
RAM: 64 GB each
GPU: two nodes have NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Installed Software ===

<pre>
OS: Debian 8 (in cluster ada)
OS: Debian 12 (in cluster lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-01-25T12:16:30Z

Leon: /* Hardware in the ada nodes */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150
</pre>

=== Hardware in ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in the lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores)
RAM: 64 GB each
GPU: two nodes have NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Software in the nodes ===

<pre>
OS: Debian 8 (in cluster ada)
OS: Debian 12 (in cluster lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-01-24T20:47:46Z

Leon: /* Management Software */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.

Number of users on 1/24/2023: 150
</pre>

=== Hardware in the ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in the lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores)
RAM: 64 GB each
GPU: two nodes have NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Software in the nodes ===

<pre>
OS: Debian 8 (in cluster ada)
OS: Debian 12 (in cluster lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-01-24T20:45:54Z

Leon: /* Software in the nodes */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.
</pre>

=== Hardware in the ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in the lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores)
RAM: 64 GB each
GPU: two nodes have NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Software in the nodes ===

<pre>
OS: Debian 8 (in cluster ada)
OS: Debian 12 (in cluster lovelace)
Basic packages installed:
gcc
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-01-24T20:45:02Z

Leon: /* Conect to cluster-slurm */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.
</pre>

=== Hardware in the ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in the lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores)
RAM: 64 GB each
GPU: two nodes have NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Software in the nodes ===

<pre>
OS: Debian 8 (in cluster ada)
OS: Debian 12 (in cluster lovelace)
Basic packages installed:
GCC
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@lovelace.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-01-24T20:44:10Z

Leon: /* Software in the nodes */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.
</pre>

=== Hardware in the ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in the lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores)
RAM: 64 GB each
GPU: two nodes have NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Software in the nodes ===

<pre>
OS: Debian 8 (in cluster ada)
OS: Debian 12 (in cluster lovelace)
Basic packages installed:
GCC
gfortran
python: torch, numba
julia
conda
compucel3d
espresso
gromacs
lammps
mesa
openmpi
povray
quantum-espresso
vasp
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@cluster-slurm.if.ufrgs.br
</pre>

or

<pre>
ssh <user>@ada.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-01-24T20:40:49Z

Leon: /* Management Software */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager(https://slurm.schedmd.com/)

Number of jobs per user controlled on demand.
</pre>

=== Hardware in the ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in the lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores)
RAM: 64 GB each
GPU: two nodes have NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Software in the nodes ===

<pre>
OS: Debian 8 (in cluster ada)
OS: Debian 12 (in cluster lovelace)
Basic packages installed:
GCC
gfortran
python: torch, numba
julia
conda
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@cluster-slurm.if.ufrgs.br
</pre>

or

<pre>
ssh <user>@ada.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-01-24T20:39:55Z

Leon: /* Management Software */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager

Site :https://slurm.schedmd.com/
Number of jobs per user controlled on demand.
</pre>

=== Hardware in the ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in the lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores)
RAM: 64 GB each
GPU: two nodes have NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Software in the nodes ===

<pre>
OS: Debian 8 (in cluster ada)
OS: Debian 12 (in cluster lovelace)
Basic packages installed:
GCC
gfortran
python: torch, numba
julia
conda
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@cluster-slurm.if.ufrgs.br
</pre>

or

<pre>
ssh <user>@ada.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-01-24T20:34:38Z

Leon: /* Software in the nodes */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager

Site :https://slurm.schedmd.com/
</pre>

=== Hardware in the ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in the lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores)
RAM: 64 GB each
GPU: two nodes have NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Software in the nodes ===

<pre>
OS: Debian 8 (in cluster ada)
OS: Debian 12 (in cluster lovelace)
Basic packages installed:
GCC
gfortran
python: torch, numba
julia
conda
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@cluster-slurm.if.ufrgs.br
</pre>

or

<pre>
ssh <user>@ada.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-01-24T20:32:02Z

Leon: /* Hardware in the ada nodes */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager

Site :https://slurm.schedmd.com/
</pre>

=== Hardware in the ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes with NVIDIA CUDA
Storage: storage Asustor 12TB
Inter-node connection: Gigabit
</pre>

=== Hardware in the lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores)
RAM: 64 GB each
GPU: two nodes have NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Software in the nodes ===

<pre>
OS: Debian 8 (in cluster ada)
OS: Debian 11 (in cluster lovelace)
Basic packages installed:
GCC
gfortran
python2
python3
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@cluster-slurm.if.ufrgs.br
</pre>

or

<pre>
ssh <user>@ada.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-01-24T20:30:06Z

Leon: /* Hardware in the lovelace nodes */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager

Site :https://slurm.schedmd.com/
</pre>

=== Hardware in the ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes have NVIDIA CUDA
Storage: storage with 50GB quota per user
</pre>

=== Hardware in the lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores)
RAM: 64 GB each
GPU: two nodes have NVIDIA CUDA
Storage: storage Dell 12TB
Conection inter-nodes: Gigabit
</pre>

=== Software in the nodes ===

<pre>
OS: Debian 8 (in cluster ada)
OS: Debian 11 (in cluster lovelace)
Basic packages installed:
GCC
gfortran
python2
python3
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@cluster-slurm.if.ufrgs.br
</pre>

or

<pre>
ssh <user>@ada.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-01-24T20:28:46Z

Leon: /* Hardware in the lovelace nodes */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager

Site :https://slurm.schedmd.com/
</pre>

=== Hardware in the ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes have NVIDIA CUDA
Storage: storage with 50GB quota per user
</pre>

=== Hardware in the lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores)
RAM: 64 GB each
GPU: two nodes have NVIDIA CUDA
Storage: storage with 50GB quota per user
Conection inter-nodes: Gigabit
</pre>

=== Software in the nodes ===

<pre>
OS: Debian 8 (in cluster ada)
OS: Debian 11 (in cluster lovelace)
Basic packages installed:
GCC
gfortran
python2
python3
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@cluster-slurm.if.ufrgs.br
</pre>

or

<pre>
ssh <user>@ada.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2024-01-24T20:14:35Z

Leon: /* Hardware in the ada nodes */

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager

Site :https://slurm.schedmd.com/
</pre>

=== Hardware in the ada nodes ===

<pre>
CPU: 16 nodes x86_64
RAM: varies between 8 GB - 16 GB
GPU: 3 nodes have NVIDIA CUDA
Storage: storage with 50GB quota per user
</pre>

=== Hardware in the lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores)
RAM: varia entre 64 GB
GPU: two nodes have NVIDIA CUDA
Storage: storage with 50GB quota per user
</pre>

=== Software in the nodes ===

<pre>
OS: Debian 8 (in cluster ada)
OS: Debian 11 (in cluster lovelace)
Basic packages installed:
GCC
gfortran
python2
python3
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@cluster-slurm.if.ufrgs.br
</pre>

or

<pre>
ssh <user>@ada.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Página principal

2022-12-22T17:45:52Z

Leon: /* [//www.if.ufrgs.br/if/informatica/cluster/Cluster] */

'''<center><big><big>Universidade Federal do Rio Grande do Sul</big></big>

'''<big><big>Instituto de Física</big></big>'''
</center>'''''

__NOTOC__

== [[PeIF| Planejamento Estratégico IF]] ==
== [[Física Experimental|Física Experimental IF/UFRGS]] ==
== [[Laboratório de Implantação Iônica]] ==
== [[Observatório Astronômico do Campus do Vale]] ==
== [//www.if.ufrgs.br/if/comissao-de-extensao/ Comissão de Extensão IF/UFRGS] ==
== [//www.if.ufrgs.br/if/informatica/cluster/ Cluster] ==

Página principal

2022-12-22T17:45:02Z

Leon: /* Cluster */

Cluster

2022-03-14T18:51:47Z

Leon:

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager

Site :https://slurm.schedmd.com/
</pre>

=== Hardware in the ada nodes ===

<pre>
CPU: x86_64
RAM: varies between 8 GB - 16 GB
GPU: some nodes have NVIDIA CUDA
Storage: storage with 50GB quota per user
</pre>

=== Hardware in the lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores)
RAM: varia entre 64 GB
GPU: two nodes have NVIDIA CUDA
Storage: storage with 50GB quota per user
</pre>

=== Software in the nodes ===

<pre>
OS: Debian 8 (in cluster ada)
OS: Debian 11 (in cluster lovelace)
Basic packages installed:
GCC
gfortran
python2
python3
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@cluster-slurm.if.ufrgs.br
</pre>

or

<pre>
ssh <user>@ada.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OR

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2022-03-14T18:48:46Z

Leon:

= Clusters Ada and Lovelace - Instituto de Física UFRGS =

The clusters are located at Instituto de Física da UFRGS, in Porto Alegre.

== Infraestruture ==

=== Management Software ===

<pre>
Slurm Workload Manager

Site :https://slurm.schedmd.com/
</pre>

=== Hardware in the ada nodes ===

<pre>
CPU: x86_64
RAM: varies between 8 GB - 16 GB
GPU: some nodes have NVIDIA CUDA
Storage: storage with 50GB quota per user
</pre>

=== Hardware in the lovelace nodes ===

<pre>
CPU: Ryzen (32 and 2*24 cores)
RAM: varia entre 64 GB
GPU: two nodes have NVIDIA CUDA
Storage: storage with 50GB quota per user
</pre>

=== Software in the nodes ===

<pre>
OS: Debian 8 (in cluster ada)
OS: Debian 11 (in cluster lovelace)
Basic packages installed:
GCC
gfortran
python2
python3
</pre>

== How to use ==

=== Conect to cluster-slurm ===

The clusters are accessible through server cluster-slurm.if.ufrgs.br (ou ada.if.ufrgr.br). To access through a unix-like system use:
<pre>
ssh <user>@cluster-slurm.if.ufrgs.br
</pre>

or

<pre>
ssh <user>@ada.if.ufrgs.br
</pre>

Under windows you may use winscp.

If you are not registered, ask for registration sending an email to fisica-ti@ufrgs.br

=== Using softwares in the cluster ===

To execute a software in a cluster job this program must:

1. Be already installed

OU

2. Be copied to the user home

Ex:
<pre>
scp my_programm <user>@cluster-slurm.if.ufrgs.br:~/
</pre>

If you are compiling your program in the cluster, one option is to user <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh <user>@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
This will generate file <code>a.out</code>, which is the executable.

Being accessible by methods 1 or 2, the program can be executed in the cluster through one JOB.

OBS: If you execute your executable without submitting as JOB, it will be executed in the server, not in the nodes. This is not recommended since the server computational capabilities are limited and you will be slowing down the server for everyone else.

=== Criating and executing a Job ===

Slurm manages jobs and each job represents a program or task being executed.

To submit a new job, you must create a script file describing the requisites and characteristics of the Job.

A typical example of the content of a submission script is below

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Number of cpus to be allocated (Despite the # these SBATCH lines are compiled by the slurm manager!)
#SBATCH -N 1 # Nummber of nodes to be allocated (You don't have to use all requisites, comment with ##)
#SBATCH -t 0-00:05 # Limit execution time (D-HH:MM)
#SBATCH -p long # Partition to be submitted
#SBATCH --qos qos_long # QOS

# Your program execution commands
./a.out
</pre>

In option --qos, use the partition name with "qos_" prefix:

partition: short -> qos: qos_short -> limit 2 weeks

partition: long -> qos: qos_long -> limit de 3 month

If you run on GPU, specify the "generic resource" gpu in cluster ada:

<pre>
#!/bin/bash
#SBATCH -n 1
#SBATCH -N 1
#SBATCH -t 0-00:05
#SBATCH -p long
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

To ask for a specific gpu:
<pre>
#SBATCH --constraint="gtx970"
</pre>

To submit the job, execute:

<pre>
sbatch job.sh
</pre>

== Usefull commands ==
* To list jobs:
squeue

* To list all jobs running in the cluster now:
sudo squeue

* To delete a running job:
scancel [job_id]

* To list available partitions:
sinfo

* To list gpu's in the nodes:
sinfo -o "%N %f"

* To list characteristic of all nodes:
sinfo -Nel

Cluster

2021-03-10T21:12:23Z

Leon: /* Como utilizar */

= Cluster Ada - Instituto de Física UFRGS =

O Cluster está localizado no Instituto de Física da UFRGS, em Porto Alegre.

== Infraestrutura ==

=== Software de gerenciamento ===

<pre>
Slurm Workload Manager

Site :https://slurm.schedmd.com/
</pre>

=== Hardware dos nodes ===

<pre>
CPU: x86_64
RAM: varia entre 4 GB - 8 GB
GPU: alguns nodes possuem NVIDIA CUDA
Storage: storage em rede com quota de 50 GB por usuário, os nodes não possuem HD local
</pre>

=== Software nos nodes ===

<pre>
OS: Debian 8 (Jessie) x86_64
Pacotes instalados:
gcc
python2
python3
</pre>

== Como utilizar ==

=== Conectar-se ao cluster-slurm ===

O cluster é acessível através do servidor cluster-slurm (ou ada). Para acessar o server via SSH, use:
<pre>
ssh usuario@cluster-slurm.if.ufrgs.br
</pre>

ou

<pre>
ssh usuario@ada.if.ufrgs.br
</pre>

Caso você não tenha cadastro ou não é vinculado ao Instituto de Física, solicite o cadastro enviando um email para fisica-ti@ufrgs.br.

=== Utilizando softwares no Cluster ===

Para que seja possível executar um programa em um job no cluster, o programa deve:

1. Já estar instalado

OU

2. Ser copiado para sua home (pasta do seu usuário)

Ex:
<pre>
scp meu_executavel usuario@cluster-slurm.if.ufrgs.br:~/
</pre>

Caso queira compilar o programa para uso no Cluster, uma das opções é usar o <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh usuario@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
Isso irá gerar um arquivo <code>a.out</code>, que é o executável.

Estando acessível pelo método 1 ou 2, o programa pode ser executado no Cluster através de um JOB.

OBS: Caso você execute o programa sem submetê-lo como JOB, ele não será executado nos nodes, e sim apenas no próprio server (cluster-slurm), que possui capacidades bem limitadas de processamento.

=== Criando e executando um Job ===

O Slurm gerencia jobs, e cada job representa um programa ou tarefa sendo executado.

Para submeter um novo Job, deve-se criar um arquivo de script descrevendo os requisitos e características de execução do Job.

Formato do arquivo abaixo.

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Numero de CPU cores a serem alocados
#SBATCH -N 1 # Numero de nodes a serem alocados
#SBATCH -t 0-00:05 # Tempo limite de execucao (D-HH:MM)
#SBATCH -p long # Particao (fila) a ser submetido
#SBATCH --qos qos_long # QOS

# Comandos de execução do seu programa:
./a.out
</pre>

Na opção --qos, deve-se colocar o nome da partição com o prefixo "qos_":

partição: short -> qos: qos_short -> limite de 2 semanas

partição: long -> qos: qos_long -> limite de 3 meses

Caso deseje rodar em GPU, é necessário especificar a fila e pedir explicitamente a ''generic resource'' gpu:
<pre>
#!/bin/bash
#SBATCH -n 1 # Numero de CPU cores a serem alocados
#SBATCH -N 1 # Numero de nodes a serem alocados
#SBATCH -t 0-00:05 # Tempo limite de execucao (D-HH:MM)
#SBATCH -p long # Particao (fila) a ser submetido
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

Para pedir alguma GPU específica, use um constraint adicionando a linha:
<pre>
#SBATCH --constraint="gtx970"
</pre>

Para submeter o job, execute o comando

<pre>
sbatch job.sh
</pre>

== Comandos úteis ==
* Para listar os seus jobs:
squeue

* Para listar todos os jobs rodando no cluster neste momento:
sudo squeue

* Para deletar um job:
scancel [job_id]

* Para listar as partições disponíveis:
sinfo

* Para listar as gpus presentes nos nodes:
sinfo -o "%N %f"

* Para listar um resumo de todos os nodes:
sinfo -Nel

Cluster

2021-03-10T21:11:32Z

Leon: /* Conectar-se ao cluster-slurm */

= Cluster Ada - Instituto de Física UFRGS =

O Cluster está localizado no Instituto de Física da UFRGS, em Porto Alegre.

== Infraestrutura ==

=== Software de gerenciamento ===

<pre>
Slurm Workload Manager

Site :https://slurm.schedmd.com/
</pre>

=== Hardware dos nodes ===

<pre>
CPU: x86_64
RAM: varia entre 4 GB - 8 GB
GPU: alguns nodes possuem NVIDIA CUDA
Storage: storage em rede com quota de 50 GB por usuário, os nodes não possuem HD local
</pre>

=== Software nos nodes ===

<pre>
OS: Debian 8 (Jessie) x86_64
Pacotes instalados:
gcc
python2
python3
</pre>

== Como utilizar ==

=== Conectar-se ao cluster-slurm ===

O cluster é acessível através do server cluster-slurm. Para acessar o server via SSH, use:
<pre>
ssh usuario@cluster-slurm.if.ufrgs.br
</pre>

ou

<pre>
ssh usuario@ada.if.ufrgs.br
</pre>

Caso você não tenha cadastro ou não é vinculado ao Instituto de Física, solicite o cadastro enviando um email para fisica-ti@ufrgs.br.

=== Utilizando softwares no Cluster ===

Para que seja possível executar um programa em um job no cluster, o programa deve:

1. Já estar instalado

OU

2. Ser copiado para sua home (pasta do seu usuário)

Ex:
<pre>
scp meu_executavel usuario@cluster-slurm.if.ufrgs.br:~/
</pre>

Caso queira compilar o programa para uso no Cluster, uma das opções é usar o <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh usuario@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
Isso irá gerar um arquivo <code>a.out</code>, que é o executável.

Estando acessível pelo método 1 ou 2, o programa pode ser executado no Cluster através de um JOB.

OBS: Caso você execute o programa sem submetê-lo como JOB, ele não será executado nos nodes, e sim apenas no próprio server (cluster-slurm), que possui capacidades bem limitadas de processamento.

=== Criando e executando um Job ===

O Slurm gerencia jobs, e cada job representa um programa ou tarefa sendo executado.

Para submeter um novo Job, deve-se criar um arquivo de script descrevendo os requisitos e características de execução do Job.

Formato do arquivo abaixo.

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Numero de CPU cores a serem alocados
#SBATCH -N 1 # Numero de nodes a serem alocados
#SBATCH -t 0-00:05 # Tempo limite de execucao (D-HH:MM)
#SBATCH -p long # Particao (fila) a ser submetido
#SBATCH --qos qos_long # QOS

# Comandos de execução do seu programa:
./a.out
</pre>

Na opção --qos, deve-se colocar o nome da partição com o prefixo "qos_":

partição: short -> qos: qos_short -> limite de 2 semanas

partição: long -> qos: qos_long -> limite de 3 meses

Caso deseje rodar em GPU, é necessário especificar a fila e pedir explicitamente a ''generic resource'' gpu:
<pre>
#!/bin/bash
#SBATCH -n 1 # Numero de CPU cores a serem alocados
#SBATCH -N 1 # Numero de nodes a serem alocados
#SBATCH -t 0-00:05 # Tempo limite de execucao (D-HH:MM)
#SBATCH -p long # Particao (fila) a ser submetido
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

Para pedir alguma GPU específica, use um constraint adicionando a linha:
<pre>
#SBATCH --constraint="gtx970"
</pre>

Para submeter o job, execute o comando

<pre>
sbatch job.sh
</pre>

== Comandos úteis ==
* Para listar os seus jobs:
squeue

* Para listar todos os jobs rodando no cluster neste momento:
sudo squeue

* Para deletar um job:
scancel [job_id]

* Para listar as partições disponíveis:
sinfo

* Para listar as gpus presentes nos nodes:
sinfo -o "%N %f"

* Para listar um resumo de todos os nodes:
sinfo -Nel

Cluster

2019-03-19T17:03:04Z

Leon: /* Comandos úteis */

= Cluster Ada - Instituto de Física UFRGS =

O Cluster está localizado no Instituto de Física da UFRGS, em Porto Alegre.

== Infraestrutura ==

=== Software de gerenciamento ===

<pre>
Slurm Workload Manager

Site :https://slurm.schedmd.com/
</pre>

=== Hardware dos nodes ===

<pre>
CPU: x86_64
RAM: varia entre 4 GB - 8 GB
GPU: alguns nodes possuem NVIDIA CUDA
Storage: storage em rede com quota de 50 GB por usuário, os nodes não possuem HD local
</pre>

=== Software nos nodes ===

<pre>
OS: Debian 8 (Jessie) x86_64
Pacotes instalados:
gcc
python2
python3
</pre>

== Como utilizar ==

=== Conectar-se ao cluster-slurm ===

O cluster é acessível através do server cluster-slurm. Para acessar o server via SSH, use:
<pre>
ssh usuario@cluster-slurm.if.ufrgs.br
</pre>

Caso você não tenha cadastro ou não é vinculado ao Instituto de Física, solicite o cadastro enviando um email para fisica-ti@ufrgs.br.

=== Utilizando softwares no Cluster ===

Para que seja possível executar um programa em um job no cluster, o programa deve:

1. Já estar instalado

OU

2. Ser copiado para sua home (pasta do seu usuário)

Ex:
<pre>
scp meu_executavel usuario@cluster-slurm.if.ufrgs.br:~/
</pre>

Caso queira compilar o programa para uso no Cluster, uma das opções é usar o <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh usuario@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
Isso irá gerar um arquivo <code>a.out</code>, que é o executável.

Estando acessível pelo método 1 ou 2, o programa pode ser executado no Cluster através de um JOB.

OBS: Caso você execute o programa sem submetê-lo como JOB, ele não será executado nos nodes, e sim apenas no próprio server (cluster-slurm), que possui capacidades bem limitadas de processamento.

=== Criando e executando um Job ===

O Slurm gerencia jobs, e cada job representa um programa ou tarefa sendo executado.

Para submeter um novo Job, deve-se criar um arquivo de script descrevendo os requisitos e características de execução do Job.

Formato do arquivo abaixo.

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Numero de CPU cores a serem alocados
#SBATCH -N 1 # Numero de nodes a serem alocados
#SBATCH -t 0-00:05 # Tempo limite de execucao (D-HH:MM)
#SBATCH -p long # Particao (fila) a ser submetido
#SBATCH --qos qos_long # QOS

# Comandos de execução do seu programa:
./a.out
</pre>

Na opção --qos, deve-se colocar o nome da partição com o prefixo "qos_":

partição: short -> qos: qos_short -> limite de 2 semanas

partição: long -> qos: qos_long -> limite de 3 meses

Caso deseje rodar em GPU, é necessário especificar a fila e pedir explicitamente a ''generic resource'' gpu:
<pre>
#!/bin/bash
#SBATCH -n 1 # Numero de CPU cores a serem alocados
#SBATCH -N 1 # Numero de nodes a serem alocados
#SBATCH -t 0-00:05 # Tempo limite de execucao (D-HH:MM)
#SBATCH -p long # Particao (fila) a ser submetido
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

Para pedir alguma GPU específica, use um constraint adicionando a linha:
<pre>
#SBATCH --constraint="gtx970"
</pre>

Para submeter o job, execute o comando

<pre>
sbatch job.sh
</pre>

== Comandos úteis ==
* Para listar os seus jobs:
squeue

* Para listar todos os jobs rodando no cluster neste momento:
sudo squeue

* Para deletar um job:
scancel [job_id]

* Para listar as partições disponíveis:
sinfo

* Para listar as gpus presentes nos nodes:
sinfo -o "%N %f"

* Para listar um resumo de todos os nodes:
sinfo -Nel

Cluster

2019-03-19T17:02:25Z

Leon: /* Comandos úteis */

= Cluster Ada - Instituto de Física UFRGS =

O Cluster está localizado no Instituto de Física da UFRGS, em Porto Alegre.

== Infraestrutura ==

=== Software de gerenciamento ===

<pre>
Slurm Workload Manager

Site :https://slurm.schedmd.com/
</pre>

=== Hardware dos nodes ===

<pre>
CPU: x86_64
RAM: varia entre 4 GB - 8 GB
GPU: alguns nodes possuem NVIDIA CUDA
Storage: storage em rede com quota de 50 GB por usuário, os nodes não possuem HD local
</pre>

=== Software nos nodes ===

<pre>
OS: Debian 8 (Jessie) x86_64
Pacotes instalados:
gcc
python2
python3
</pre>

== Como utilizar ==

=== Conectar-se ao cluster-slurm ===

O cluster é acessível através do server cluster-slurm. Para acessar o server via SSH, use:
<pre>
ssh usuario@cluster-slurm.if.ufrgs.br
</pre>

Caso você não tenha cadastro ou não é vinculado ao Instituto de Física, solicite o cadastro enviando um email para fisica-ti@ufrgs.br.

=== Utilizando softwares no Cluster ===

Para que seja possível executar um programa em um job no cluster, o programa deve:

1. Já estar instalado

OU

2. Ser copiado para sua home (pasta do seu usuário)

Ex:
<pre>
scp meu_executavel usuario@cluster-slurm.if.ufrgs.br:~/
</pre>

Caso queira compilar o programa para uso no Cluster, uma das opções é usar o <code>gcc</code>.

Ex:
<pre>
scp -r source-code/ usuario@cluster-slurm.if.ufrgs.br:~/
ssh usuario@cluster-slurm.if.ufrgs.br:~/
cd source-code
gcc main.c funcoes.c
</pre>
Isso irá gerar um arquivo <code>a.out</code>, que é o executável.

Estando acessível pelo método 1 ou 2, o programa pode ser executado no Cluster através de um JOB.

OBS: Caso você execute o programa sem submetê-lo como JOB, ele não será executado nos nodes, e sim apenas no próprio server (cluster-slurm), que possui capacidades bem limitadas de processamento.

=== Criando e executando um Job ===

O Slurm gerencia jobs, e cada job representa um programa ou tarefa sendo executado.

Para submeter um novo Job, deve-se criar um arquivo de script descrevendo os requisitos e características de execução do Job.

Formato do arquivo abaixo.

Ex: <code>job.sh</code>

<pre>
#!/bin/bash
#SBATCH -n 1 # Numero de CPU cores a serem alocados
#SBATCH -N 1 # Numero de nodes a serem alocados
#SBATCH -t 0-00:05 # Tempo limite de execucao (D-HH:MM)
#SBATCH -p long # Particao (fila) a ser submetido
#SBATCH --qos qos_long # QOS

# Comandos de execução do seu programa:
./a.out
</pre>

Na opção --qos, deve-se colocar o nome da partição com o prefixo "qos_":

partição: short -> qos: qos_short -> limite de 2 semanas

partição: long -> qos: qos_long -> limite de 3 meses

Caso deseje rodar em GPU, é necessário especificar a fila e pedir explicitamente a ''generic resource'' gpu:
<pre>
#!/bin/bash
#SBATCH -n 1 # Numero de CPU cores a serem alocados
#SBATCH -N 1 # Numero de nodes a serem alocados
#SBATCH -t 0-00:05 # Tempo limite de execucao (D-HH:MM)
#SBATCH -p long # Particao (fila) a ser submetido
#SBATCH --qos qos_long # QOS
#SBATCH --gres=gpu:1

# Comandos de execução do seu programa:
./a.out
</pre>

Para pedir alguma GPU específica, use um constraint adicionando a linha:
<pre>
#SBATCH --constraint="gtx970"
</pre>

Para submeter o job, execute o comando

<pre>
sbatch job.sh
</pre>

== Comandos úteis ==
* Para listar os seus jobs:
squeue

* Para listar todos os jobs:
sudo squeue

* Para deletar um job:
scancel [job_id]

* Para listar as partições disponíveis:
sinfo

* Para listar as gpus presentes nos nodes:
sinfo -o "%N %f"

* Para listar um resumo de todos os nodes:
sinfo -Nel

Minuano

2010-06-14T12:23:18Z

Leon:

'''Instalação dos nós'''

1 - Instalação atual: debian squeeze

2 - Pacotes necessários além do básico: nfs-common, nis

a) Configuração do NFS: editar /etc/fstab
# Substituir a opção ro por defaults na montagem do /.

# Acrescentar ao final do arquivo os nfs mounts:
10.0.0.06:/home_agua /home_agua nfs wsize=8192,rsize=8192 0 0
10.0.0.05:/home05 /home05 nfs wsize=8192,rsize=8192 0 0
10.0.0.25:/home25 /home25 nfs wsize=8192,rsize=8192 0 0
10.0.1.3:/home103 /home103 nfs wsize=8192,rsize=8192 0 0
10.0.1.11:/work05 /work05 nfs wsize=8192,rsize=8192 0 0
10.0.1.12:/work25 /work25 nfs wsize=8192,rsize=8192 0 0
10.0.1.13:/work103 /work103 nfs wsize=8192,rsize=8192 0 0

#Teste de montagem: mount -a; df -h

b) Na configuração do nis:

# Acrescentar "ypserver 10.0.0.254" na ultima linha de /etc/yp.serv e comentar o resto.

# Acrescentar "cluster.if.ufrgs.br" na ultima linha de /etc/defaultdomain e comentar o resto.

# Editar o arquivo /etc/nsswitch.conf e reescrever as linhas de passwd, group e shadow adicionando nis, i.e.
passwd: nis compat
group: nis compat
shadow: nis compat

# Lançar o nis: /etc/init.d/nis restart

# Testes para saber se está tudo funcionando:
> ypcat passwd
> su leon

3 - Cliente do torque (pbs_mom):http://debianclusters.org/index.php/Resource_Manager:_Torque