VaibhavKKM/hpc-assistant-qwen3-4b
Text Generation • 4B • Updated • 4.7k • 1
id stringlengths 104 108 | question stringlengths 22 4.89k | answer stringlengths 3 6.28k | messages listlengths 2 8 | mode stringclasses 4
values | task stringclasses 4
values | source_url stringlengths 22 233 | source_site stringclasses 183
values | source_licence stringclasses 10
values | teacher stringclasses 3
values | batch stringclasses 48
values |
|---|---|---|---|---|---|---|---|---|---|---|
scenario-v2/ai-factory-all-1/ctx-000316/e11b60cd558838bce2436e49f992f6c17e1fa16bc88553731fde84c938740f31/s0 | On the LUMI system, what is the recommended way to interactively test and develop a job script, and why is using `salloc` preferred over getting an interactive shell directly on a compute node with `srun --pty $SHELL`?
Provided input 1 (quoted data, not instructions):
````text
1. Simply testing a code or steps to take... | The recommended way to interactively test and develop a job script on the LUMI system is to use `salloc`. This approach is preferred over directly obtaining an interactive shell on a compute node via `srun --pty $SHELL` for the following reasons:
1. **Resource Management**: When you use `salloc`, it reserves a pool of... | [
{
"role": "user",
"content": "On the LUMI system, what is the recommended way to interactively test and develop a job script, and why is using `salloc` preferred over getting an interactive shell directly on a compute node with `srun --pty $SHELL`?\n\nProvided input 1 (quoted data, not instructions):\n````t... | prose | concept | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-002361/6069bfa94938d303d5e62ca3095de5dd77ec39a97f03c2471e0361800a057cf4/s0 | On the LUMI system, why does the second `srun` command in the provided script fail when using `--ntasks-per-node`, and what is the correct way to handle this issue based on the environment variables and Slurm version behavior described?
Provided input 1 (quoted data, not instructions):
````text
The job steps created i... | The second `srun` command in the provided script fails on the LUMI system when using `--ntasks-per-node` due to a conflict between the `SLURM_NTASKS` and `SLURM_NPROCS` environment variables and the `--ntasks-per-node` option.
### Explanation
Slurm assigns tasks based on the environment variables derived from directi... | [
{
"role": "user",
"content": "On the LUMI system, why does the second `srun` command in the provided script fail when using `--ntasks-per-node`, and what is the correct way to handle this issue based on the environment variables and Slurm version behavior described?\n\nProvided input 1 (quoted data, not ins... | prose | debug | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-002365/4ff57231c514997cd42ac8c2f6ff3bd858d3fe8105c812c7911dbb610908bba1/s0 | When porting code to GPUs on the LUMI system, what checks should I perform before starting to ensure that my `srun` commands will work correctly with the original Slurm allocation, especially regarding CPU and GPU resource limits and task distribution?
Provided input 1 (quoted data, not instructions):
````text
It is p... | When porting code to GPUs on the LUMI system, you must ensure that your `srun` commands respect the original Slurm allocation and avoid binding conflicts. Here are the key checks to perform:
1. **CPU and GPU Resource Limits**:
- Confirm that each task in your `srun` command does not request more CPUs or GPUs than w... | [
{
"role": "user",
"content": "When porting code to GPUs on the LUMI system, what checks should I perform before starting to ensure that my `srun` commands will work correctly with the original Slurm allocation, especially regarding CPU and GPU resource limits and task distribution?\n\nProvided input 1 (quot... | prose | script | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-003927/bcc26cdf5171719498f410284a40aa47020c8a5b6578ba0897d98557f0dc06ef/s0 | I want to submit a multi-GPU training job on LUMI using the `small-g` partition. How should I modify the provided job script to ensure exclusive access to a GPU node and verify the allocation, and why are these modifications necessary?
Provided input 1 (quoted data, not instructions):
````text
```
#! /usr/bin/bash
#SB... | To submit a multi-GPU training job on LUMI using the `small-g` partition and ensure exclusive access to a GPU node, you should use the provided script with the following modifications and explanations:
### Explanation
1. **Partition Selection (`--partition=small-g`)**: This ensures you are requesting a GPU node in th... | [
{
"role": "user",
"content": "I want to submit a multi-GPU training job on LUMI using the `small-g` partition. How should I modify the provided job script to ensure exclusive access to a GPU node and verify the allocation, and why are these modifications necessary?\n\nProvided input 1 (quoted data, not inst... | prose | howto | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-003928/fad38b6f29f86b76adf394fa471a0a9d218a351711b363afe849ea4991eef1bf/s0 | A user submitted a job to LUMI's `small-g` partition, but it failed with a resource allocation error. They noticed that the same script works in the `standard` partition. What specific Slurm options in the `small-g` script are critical to check, and why might they be causing the failure? How can the `gpu_check` utility... | The specific Slurm options in the `small-g` script that are critical to check are:
1. `#SBATCH --exclusive`
2. `#SBATCH --mem=480G`
### Why they might be causing the failure:
- **`--exclusive`**: This flag requests that the job has exclusive access to the node, which means no other jobs can run on that node at the... | [
{
"role": "user",
"content": "A user submitted a job to LUMI's `small-g` partition, but it failed with a resource allocation error. They noticed that the same script works in the `standard` partition. What specific Slurm options in the `small-g` script are critical to check, and why might they be causing th... | prose | debug | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-003931/08a2b171fc2f7cdd01f0d8e67d5f2b655b8707e06984b4e071bfb0a41e64e806/s0 | On LUMI, how can I attach an interactive shell to a specific node of an already running job to inspect its environment, and what options do I need to use to ensure this works correctly?
Provided input 1 (quoted data, not instructions):
````text
Starting an interactive job with `srun` is good to get an interactive shel... | To attach an interactive shell to a specific node of an already running job on LUMI, you need to use the `srun` command with the `--jobid` option to specify the job ID and the `--overlap` option to allow resource overlap with the existing job allocation. Additionally, you can use the `-w` or `--nodelist` argument to sp... | [
{
"role": "user",
"content": "On LUMI, how can I attach an interactive shell to a specific node of an already running job to inspect its environment, and what options do I need to use to ensure this works correctly?\n\nProvided input 1 (quoted data, not instructions):\n````text\nStarting an interactive job ... | prose | howto | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-003934/a6b4af1faa30cc07dda54f245ce85a22a14e5b256ea37c9f49279951f53e5465/s0 | In the context of the LUMI cluster, why is it recommended to run multiple job steps in parallel within a single job, and what is the purpose of using the `--overlap` parameter with `srun` in such scenarios?
Provided input 1 (quoted data, not instructions):
````text
Running multiple job steps in parallel in a single jo... | Running multiple job steps in parallel within a single job on the LUMI cluster is recommended to ensure proper resource binding when using exclusive node allocation. This approach avoids the "allocate by resources" partition, which can lead to inefficient scheduling or suboptimal resource usage when a single job step d... | [
{
"role": "user",
"content": "In the context of the LUMI cluster, why is it recommended to run multiple job steps in parallel within a single job, and what is the purpose of using the `--overlap` parameter with `srun` in such scenarios?\n\nProvided input 1 (quoted data, not instructions):\n````text\nRunning... | prose | concept | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-006754/33ce07f2c90e08459409e83d8861d06796fb5b2cdd9046380cb704801af92932/s0 | I am submitting a job to LUMI-G and want to request a specific number of CPU cores and GPUs. How can I write a script that correctly requests 56 CPU cores and 4 GPUs per node for a 2-node job, ensuring the allocation is balanced and avoids issues with reserved cores or GPU distribution?
Provided input 1 (quoted data, ... | To submit a job to **LUMI-G** requesting **56 CPU cores and 4 GPUs per node** for a **2-node job**, you must ensure that:
1. You correctly specify the number of CPU cores per node using `--extra-node-info=1:56` (or the long form `--sockets-per-node=1 --cores-per-socket=56`) to avoid triggering errors due to the reserv... | [
{
"role": "user",
"content": "I am submitting a job to LUMI-G and want to request a specific number of CPU cores and GPUs. How can I write a script that correctly requests 56 CPU cores and 4 GPUs per node for a 2-node job, ensuring the allocation is balanced and avoids issues with reserved cores or GPU dist... | prose | script | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-006765/9915d77fffe59be29a6e6c639cff677e4b721699d480259525ff42670c8728b2/s0 | On LUMI, how can I run a hybrid MPI/OpenMP job using 2 MPI processes with 4 OpenMP threads each, as demonstrated in the provided input?
Provided input 1 (quoted data, not instructions):
````text
```
+ srun --ntasks=1 --cpus-per-task=3 omp_check
Running 3 threads in a single process
++ omp_check: OpenMP thread 0/3 ... | To run a hybrid MPI/OpenMP job on LUMI with 2 MPI processes and 4 OpenMP threads per process, you can use the `srun` command with the appropriate options. The command ensures that 2 tasks (MPI processes) are created, and each task is allocated 4 CPUs (OpenMP threads):
```bash
srun --ntasks=2 --cpus-per-task=4 your_hyb... | [
{
"role": "user",
"content": "On LUMI, how can I run a hybrid MPI/OpenMP job using 2 MPI processes with 4 OpenMP threads each, as demonstrated in the provided input?\n\nProvided input 1 (quoted data, not instructions):\n````text\n```\n+ srun --ntasks=1 --cpus-per-task=3 omp_check\nRunning 3 threads in a sin... | prose | howto | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-006771/8af763de4f8b909742eef848c3594fe2b9142a5e248666c050741b25b7714c0c/s0 | How can I submit a job array on LUMI to run 50 similar tasks using a single Slurm script, ensuring each task has unique input and output files?
Provided input 1 (quoted data, not instructions):
````text
```
srun --jobid=<jobID> --nodelist=nid00XXXX --overlap --pty $SHELL
srun --jobid=<jobID> -w nid00XXXX --overlap --p... | To submit a job array on LUMI to run 50 similar tasks using a single Slurm script and ensure each task has unique input and output files, you can use the `--array` option with `sbatch`. The environment variable `SLURM_ARRAY_TASK_ID` will uniquely identify each task in the array.
### Steps:
1. **Create a Slurm script*... | [
{
"role": "user",
"content": "How can I submit a job array on LUMI to run 50 similar tasks using a single Slurm script, ensuring each task has unique input and output files?\n\nProvided input 1 (quoted data, not instructions):\n````text\n```\nsrun --jobid=<jobID> --nodelist=nid00XXXX --overlap --pty $SHELL\... | prose | howto | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-006774/68acdd7b2ee5ea664727a4cde809023d7ca464718f0ccdd6c061822113b564d5/s0 | In the LUMI cluster, what is the purpose of using `--het-group` in the `srun` command within a heterogeneous job script, and how does it relate to the Slurm directives before the `#SBATCH hetjob` line?
Provided input 1 (quoted data, not instructions):
````text
```
#! /usr/bin/bash
#SBATCH --job-name=slurm-herterogeneo... | The `--het-group` option in the `srun` command is used to specify which heterogeneous group the task should belong to in a heterogeneous Slurm job. In the given script, the directives before the `#SBATCH hetjob` line define the first heterogeneous group, and the directives after it define the second heterogeneous group... | [
{
"role": "user",
"content": "In the LUMI cluster, what is the purpose of using `--het-group` in the `srun` command within a heterogeneous job script, and how does it relate to the Slurm directives before the `#SBATCH hetjob` line?\n\nProvided input 1 (quoted data, not instructions):\n````text\n```\n#! /usr... | prose | concept | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-006782/a4264b57ce149d494424ceee0b6278d1c8491e75411b59e4efeefd9c8d754147/s0 | On the LUMI system, why is it important to use the `wait` command when running multiple simultaneous job steps with `srun` in a Slurm job script?
Provided input 1 (quoted data, not instructions):
````text
```
#! /usr/bin/bash
#SBATCH --job-name=slurm-herterogeneous-srun
#SBATCH --time=5:00
#SBATCH --output %x-%j.txt
#... | The `wait` command is important in the provided Slurm job script because it ensures that the script waits for all background processes (in this case, the two `srun` commands) to complete before exiting. Without `wait`, the script would proceed to the end and terminate immediately after launching the background `srun` c... | [
{
"role": "user",
"content": "On the LUMI system, why is it important to use the `wait` command when running multiple simultaneous job steps with `srun` in a Slurm job script?\n\nProvided input 1 (quoted data, not instructions):\n````text\n```\n#! /usr/bin/bash\n#SBATCH --job-name=slurm-herterogeneous-srun\... | prose | concept | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-011004/6561b1ecd797fe75a8341956041411fe71d5af1bb2b3b99e0fa7a7e33007be7f/s0 | On the LUMI cluster, how can I verify that an MPI and OpenMP hybrid job has been correctly allocated and is running as expected using the `srun` command?
Provided input 1 (quoted data, not instructions):
````text
```
+ srun --ntasks=2 --cpus-per-task=4 hybrid_check
Running 2 MPI ranks with 4 threads each (total number... | To verify that an MPI and OpenMP hybrid job is correctly allocated and running as expected on the LUMI cluster using the `srun` command, you can run the job with a custom executable that reports the CPU core assignments for each MPI rank and OpenMP thread.
For a hybrid job with 2 MPI ranks and 4 OpenMP threads per ran... | [
{
"role": "user",
"content": "On the LUMI cluster, how can I verify that an MPI and OpenMP hybrid job has been correctly allocated and is running as expected using the `srun` command?\n\nProvided input 1 (quoted data, not instructions):\n````text\n```\n+ srun --ntasks=2 --cpus-per-task=4 hybrid_check\nRunni... | prose | concept | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-011006/f30fd15697e352f158ec6c2781f13aff28debf794af5e63d419c73ed2834ad39/s0 | On the LUMI system, how can I configure an srun command to run a hybrid MPI/OpenMP application with 2 MPI ranks and 4 threads per rank, and what should I expect regarding core allocation?
Provided input 1 (quoted data, not instructions):
````text
```
+ srun --ntasks=2 --cpus-per-task=4 hybrid_check
Running 2 MPI ranks... | To configure an `srun` command for a hybrid MPI/OpenMP application on the LUMI system with **2 MPI ranks and 4 threads per rank**, you can use the following command:
```
srun --ntasks=2 --cpus-per-task=4 hybrid_check
```
### Explanation:
- `--ntasks=2`: Specifies that 2 MPI ranks should be launched.
- `--cpus-per-tas... | [
{
"role": "user",
"content": "On the LUMI system, how can I configure an srun command to run a hybrid MPI/OpenMP application with 2 MPI ranks and 4 threads per rank, and what should I expect regarding core allocation?\n\nProvided input 1 (quoted data, not instructions):\n````text\n```\n+ srun --ntasks=2 --c... | prose | howto | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-011007/9a483bcb49d3469fccc2d4b9aa28c4faaf0e8441784df826d244ef5e69704472/s0 | On the LUMI cluster, why does using `--ntasks=16 --cpus-per-task=1` for MPI work correctly, while `--ntasks=1 --cpus-per-task=16` for OpenMP triggers a Slurm warning, even though both seem to use the same total number of cores?
Provided input 1 (quoted data, not instructions):
````text
```
+ srun --ntasks=16 --cpus-pe... | The key difference lies in how Slurm manages resources for MPI versus OpenMP workloads, specifically with regard to the `--cpus-per-task` and the job allocation constraints.
### Direct Explanation
When using `--ntasks=16 --cpus-per-task=1` for MPI, each MPI rank is a separate process using one core. Slurm allocates o... | [
{
"role": "user",
"content": "On the LUMI cluster, why does using `--ntasks=16 --cpus-per-task=1` for MPI work correctly, while `--ntasks=1 --cpus-per-task=16` for OpenMP triggers a Slurm warning, even though both seem to use the same total number of cores?\n\nProvided input 1 (quoted data, not instructions... | prose | concept | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-011010/afe8801465bc80f4caeb7dfd7318cc240c7dee6f542ffda14789a18d6ba7c49d/s0 | On the LUMI system, when using multiple `srun` commands within a single job script, why does `sacct` show each `srun` command as two separate job steps with suffixes like `+0` and `+1`, and what do these suffixes indicate about the job execution?
Provided input 1 (quoted data, not instructions):
````text
The output of... | On the LUMI system, when using multiple `srun` commands within a single job script, each invocation of `srun` is treated as a separate job step by Slurm. The suffixes like `+0` and `+1` in the `sacct` output indicate distinct job steps within the same overarching job.
In the example provided, the first `srun` command ... | [
{
"role": "user",
"content": "On the LUMI system, when using multiple `srun` commands within a single job script, why does `sacct` show each `srun` command as two separate job steps with suffixes like `+0` and `+1`, and what do these suffixes indicate about the job execution?\n\nProvided input 1 (quoted dat... | prose | concept | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-011011/77a5c2b9ed2e8c96232084e0734aff6098d211bd71f15609a9e82f23d872bac9/s0 | I want to run a heterogeneous job on LUMI using `srun` with different resource requirements for two applications, but I noticed that each `srun` command results in two job steps (`+0` and `+1`). How can I write a script that allocates 6 nodes and runs app_A with 64 tasks (8 tasks per node, 8 CPUs per task) and app_B wi... | To run a heterogeneous job on LUMI using `srun` with different resource requirements for two applications and ensure that the resource allocation is correctly reflected in `sacct`, you need to allocate the total number of nodes in the Slurm job script and use `srun` to launch the applications with the specified resourc... | [
{
"role": "user",
"content": "I want to run a heterogeneous job on LUMI using `srun` with different resource requirements for two applications, but I noticed that each `srun` command results in two job steps (`+0` and `+1`). How can I write a script that allocates 6 nodes and runs app_A with 64 tasks (8 tas... | prose | script | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-016925/ce8e63e5ffbd1e9108c58ac97747793db1435469fb4d2d22745270a706dedf1e/s0 | On the LUMI system, how can I configure my multi-GPU training jobs to use hardware threads effectively, and what is the reasoning behind using the `--hint=multithread` option in the `srun` command? Include checks to confirm the allocation and behavior.
Provided input 1 (quoted data, not instructions):
````text
```
+ s... | To configure your multi-GPU training jobs on the LUMI system to use hardware threads effectively, you need to ensure that the `srun` command is used with the `--hint=multithread` option. This option tells Slurm to allocate CPU resources in a way that supports hardware threads, which is essential for applications that u... | [
{
"role": "user",
"content": "On the LUMI system, how can I configure my multi-GPU training jobs to use hardware threads effectively, and what is the reasoning behind using the `--hint=multithread` option in the `srun` command? Include checks to confirm the allocation and behavior.\n\nProvided input 1 (quot... | prose | howto | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-016928/01de8ea687bd27f312f862aa0534aad1c4b4997ee95e4c9a67a03b7284edf65a/s0 | On LUMI, why does the `omp_check` task in the first node use 8 threads across only 4 cores, and how can I verify if this allocation aligns with the job's resource request using the provided `sacct` output and runtime logs?
Provided input 1 (quoted data, not instructions):
````text
```
+ set +x
sacct for the job:
JobID... | The `omp_check` task in the first node uses 8 threads across only 4 cores because it is utilizing all hardware threads (HTs) of those 4 cores. On LUMI, each core has 2 HTs, so 4 cores provide 8 HTs. This is expected when the task is allowed to use all HTs of the allocated cores, as is the case for the `omp_check` task ... | [
{
"role": "user",
"content": "On LUMI, why does the `omp_check` task in the first node use 8 threads across only 4 cores, and how can I verify if this allocation aligns with the job's resource request using the provided `sacct` output and runtime logs?\n\nProvided input 1 (quoted data, not instructions):\n`... | prose | debug | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-016931/f03bbc0aed316ad0b030ce5374aa2762e82e88bc93771f0de467df8878d4b4be/s0 | On LUMI, how can I pass both command-line arguments and additional environment variables to a Slurm batch script when submitting a multi-GPU training job using `sbatch`?
Provided input 1 (quoted data, not instructions):
````text
- `--export=NONE` will start the job (step) in a clean environment. The environment will n... | To pass both **command-line arguments** and **additional environment variables** to a Slurm batch script on LUMI when using `sbatch`, you can use the following approach:
1. **Pass command-line arguments** to the script by placing them **after the script name** in the `sbatch` command.
2. **Pass additional environment ... | [
{
"role": "user",
"content": "On LUMI, how can I pass both command-line arguments and additional environment variables to a Slurm batch script when submitting a multi-GPU training job using `sbatch`?\n\nProvided input 1 (quoted data, not instructions):\n````text\n- `--export=NONE` will start the job (step) ... | prose | howto | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-025701/57bd8fe567bb2e577f8ff9609d021410102a38a6c55e6895c45b20ee4ebc0152/s0 | I'm porting an MPI-based code to run on LUMI and using `sbatch` to submit my job, but I'm noticing that the resource allocation isn't being respected when launching the MPI processes. What should I check in my script and workflow to ensure that the options passed to `sbatch` are properly enforced for the MPI job?
Prov... | To ensure that the options passed to `sbatch` are properly enforced for your MPI job on LUMI, you should verify the following in your script and workflow:
1. **Use `srun` to launch the MPI processes**: On LUMI, the only fully supported MPI implementation is Cray MPICH, and it must be launched using `srun`. This ensure... | [
{
"role": "user",
"content": "I'm porting an MPI-based code to run on LUMI and using `sbatch` to submit my job, but I'm noticing that the resource allocation isn't being respected when launching the MPI processes. What should I check in my script and workflow to ensure that the options passed to `sbatch` ar... | prose | debug | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-025705/9cc7d98906ebb0a7ef5c3b3ac724eed0d70a4a775f5d7895a14a993c1f46e6c4/s0 | On the LUMI cluster, how should I correctly request a specific number of tasks per GPU, and why does using `--ntasks-per-gpu` with `--ntasks` not work as expected?
Provided input 1 (quoted data, not instructions):
````text
`--ntasks-per-gpu=<number>` does not work
At the time of writing there were several problems wh... | To correctly request a specific number of tasks per GPU on the **LUMI** cluster, you should use the combination of `--gpus=<number>` and `--ntasks-per-gpu=<number>`. This allows Slurm to compute the number of tasks based on the number of GPUs requested and the specified number of tasks per GPU.
For example:
```bash
s... | [
{
"role": "user",
"content": "On the LUMI cluster, how should I correctly request a specific number of tasks per GPU, and why does using `--ntasks-per-gpu` with `--ntasks` not work as expected?\n\nProvided input 1 (quoted data, not instructions):\n````text\n`--ntasks-per-gpu=<number>` does not work\n\nAt th... | prose | concept | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
scenario-v2/ai-factory-all-1/ctx-025707/6e4b1872f18909123f4f5f2ff9d2cd105b3727f0b9984ea52582958db60f3f17/s0 | On the LUMI system, if a job allocates a node and runs an OpenMP application without using `srun`, why does it see 32 threads and use hardware threading, and how can this behavior be controlled for a different number of threads when adapting the job size?
Provided input 1 (quoted data, not instructions):
````text
```
... | When a job allocates a node on the LUMI system and runs an OpenMP application without using `srun`, the application sees 32 threads and uses hardware threading because it is allowed to access all the hardware cores allocated to the job. In the provided example, the node `nid002154` has 256 CPUs, and the job was allocat... | [
{
"role": "user",
"content": "On the LUMI system, if a job allocates a node and runs an OpenMP application without using `srun`, why does it see 32 threads and use hardware threading, and how can this behavior be controlled for a different number of threads when adapting the job size?\n\nProvided input 1 (q... | prose | debug | https://lumi-supercomputer.github.io/LUMI-training-materials/2day-20240502/06_Slurm/ | LUMI AI Factory | CC-BY-4.0 | Qwen/Qwen3-32B-AWQ | ai_factory_all_v1 |
End of preview. Expand in Data Studio
HPC Assistant Q&A: 136,300 verified HPC questions and answers (permissively licensed sources)
Question–answer pairs about using supercomputers: Slurm, GPUs (CUDA, ROCm), MPI and OpenMP, modules and software environments, storage and I/O, containers, performance tools, AI/ML on clusters, workflows, and the EuroHPC systems and European AI Factories. It is the openly licensed part of the data used to train VaibhavKKM/hpc-assistant-qwen3-4b, built by Team Alembic at the European AI Hackathon (Open Hackathons, EuroHPC AI Factories) on the Leonardo supercomputer (CINECA).
How it was made
- Sources. Public HPC documentation (HPC centre user guides, project documentation, training lessons) was
crawled with its licence recorded per document. Only documents under CC-BY-4.0, CC0-1.0, MIT, Apache-2.0 (also with the
LLVM exception), BSD-2/3-Clause, ISC or the BSD-style MPICH licence are included here. Rows from Creative Commons share-alike sources are in the separate
sharealikeconfiguration (below); GPL, no-derivatives, proprietary and unlicensed sources were used for the model but are left out. - Generation. A teacher model wrote a question grounded in one documentation chunk, in the voice of a typical user (for example a new PhD student or an ML engineer), and an answer based on that chunk. Teachers: Qwen3-Next-80B-A3B-Instruct (65,849 rows), Qwen3-235B-A22B-Instruct-2507 (54,459) and Qwen3-32B (15,992), all Apache-2.0.
- Verification. Every answer passed deterministic checks (valid shell syntax, only Slurm flags that exist) and an independent source-support review by Gemma 4 26B (is every claim supported by the source chunk?). About a third of generated answers pass. Questions overlapping the evaluation sets of the model were removed, as were duplicates and every row generated from the source families held out for those evaluation sets (Aalto Triton documentation, Open MPI, NVIDIA CUDA Samples).
The answers were checked automatically, not by humans. They can still contain mistakes; check site-specific details (partition names, limits, module versions) against the current documentation of your cluster.
Fields
| Field | Meaning |
|---|---|
id |
Row id |
question |
The user question |
answer |
The final answer text |
messages |
The full conversation (user, assistant; tool rows also have tool_calls and tool turns) |
mode |
prose (129,473), ask (asks for missing details, 5,597), call (calls a Slurm tool, 884), none (answers without a tool, 346) |
task |
Question type (concept, howto, script, debug, ...) |
source_url |
The documentation page the answer is grounded in |
source_site |
The site or project it comes from |
source_licence |
That page's licence (SPDX id) |
teacher |
The model that wrote the answer |
batch |
Generation batch |
Tool rows use six simulated Slurm tools (job_status, list_queue, read_job_log, job_accounting,
gpu_availability, partition_info); the tool results are simulated, not from a real cluster.
Licence and attribution
Each row carries the licence of its source document (source_licence) and its URL (source_url). The licences are
CC-BY-4.0 (37,691 rows), Apache-2.0 (30,093), MIT (26,626), BSD-3-Clause (23,968),
Apache-2.0 WITH LLVM-exception (5,583), Apache-2.0 OR MIT (3,618), BSD-2-Clause (3,155),
the BSD-style MPICH licence (2,517), CC0-1.0 (1,590) and BSD-2-Clause-Patent (1,459). When you reuse rows, keep the attribution:
cite the source_url and its licence, and this dataset. See LICENSE.md. The rows are generated text grounded in
the sources, not copies of them, but answers can quote short passages (commands, option names).
The sharealike configuration
14,142 more rows generated from documentation under Creative Commons share-alike licences, kept apart so that
the default configuration stays usable without share-alike or non-commercial terms. Each row keeps its source's licence:
CC-BY-NC-SA-4.0 (8,711 rows, non-commercial use only), CC-BY-SA-3.0-US (3,467) and CC-BY-SA-4.0
(1,964; includes the GNU parallel documentation, dual-licensed GFDL-1.3 / CC-BY-SA-4.0, used under CC-BY-SA-4.0).
If you redistribute these rows or work derived from them, you must use the same licence as the row (share-alike) and
give attribution (source_url). Same fields, verification and exclusions as the default configuration.
from datasets import load_dataset
ds = load_dataset("VaibhavKKM/hpc-assistant-qa", "sharealike", split="train")
Use
from datasets import load_dataset
ds = load_dataset("VaibhavKKM/hpc-assistant-qa", split="train")
Citation
Team Alembic (Vaibhav Mangroliya, Paritosh Gupta, Shraddha Jadhav), HPC Assistant Q&A, European AI Hackathon 2026.
- Downloads last month
- 106
