|
|
| (2 revisi perantara oleh pengguna yang sama tidak ditampilkan) |
| Baris 1: |
Baris 1: |
| Halaman ini memandu user dalam basis mengalokasikan resources komputasi (node, CPU, RAM, GPU) secara benar berdasarkan hardware yang digunakan oleh ALELEON Supercomputer. | | Halaman ini memandu user dalam basis menjalankan berbagai skenario komputasi dengan menyesuaikan arsitektur ALELEON Supercomputer untuk menghasilkan performa dan efisiensi maksimal. Hal ini termasuk aturan penulisan perintah dan konfigurasi tambahan di SLURM Script untuk skenario komputasi tertentu. |
|
| |
|
| == '''Dasar Memilih Jumlah Node, Core CPU, dan RAM''' == | | == '''[[MPI ALELEON Supercomputer|Menjalankan MPI di ALELEON Supercomputer]]''' == |
| Berikut adalah beberapa dasar untuk mengalokasikan jumlah node, core thread CPU, dan RAM di ALELEON Supercomputer.
| |
|
| |
|
| === Menentukan Jumlah Node ===
| | * [https://wiki.efisonlt.com/wiki/MPI_ALELEON_Supercomputer#Modul_OpenMPI Memuat modul MPI yang telah dioptimasi.] |
| Jumlah node ditentukan dari jenis program yang dijalankan yaitu program MPI dan non-MPI:
| | * [https://wiki.efisonlt.com/wiki/MPI_ALELEON_Supercomputer#Menulis_Perintah_OpenMPI_di_ALELEON_Supercomputer Menjalankan MPI dengan protokol UCX untuk performa dan optimasi maksimal.] |
| *Program MPI adalah program yang ditulis berdasarkan pemodelan MPI ('''Message Parallel Interface''') di mana '''dapat berjalan secara paralel atau lebih dari satu node (multi-node)'''. Berjalan multi-node artinya dapat memanfaatkan lebih dari 128 core thread CPU pada ALELEON Supercomputer. | | * [https://wiki.efisonlt.com/wiki/MPI_ALELEON_Supercomputer#Bagaimana_SLURM_ALELEON_Membagi_Core_Fisik_dan_Thread Menjelaskan bagaimana SLURM menyebar proses MPI pada core fisik dan thread CPU.] |
| *Program non-MPI adalah program yang tidak ditulis dengan pemodelan MPI atau paralel sehingga '''hanya dapat berjalan pada 1 node.''' | | * [https://wiki.efisonlt.com/wiki/MPI_ALELEON_Supercomputer#MPI_Satu_Node_vs_Multi_Node Menjalankan program MPI pada satu node vs multi-node.] |
| {| class="wikitable"
| |
| !Jenis Program
| |
| !Jumlah Node
| |
| |-
| |
| |Non-MPI
| |
| |1
| |
| |-
| |
| |MPI atau paralel
| |
| |1 atau lebih
| |
| |}
| |
| Apabila user menjalankan program komputasi yang tersedia di ALELEON Supercomputer, user dapat mengetahui bahwa program tersebut adalah MPI atau tidak dengan memperhatikan kolom "Dukungan MPI" di [https://wiki.efisonlt.com/wiki/Katalog_Software_ALELEON_Supercomputer#Daftar_Software_Komputasi_.28Global.29 '''tabel daftar software komputasi ALELEON Supercomputer''']
| |
|
| |
|
| ---
| | == '''[[Threading di ALELEON Supercomputer|Komputasi Threading di ALELEON Supercomputer]]''' == |
|
| |
|
| ===Jumlah Core Thread CPU: Kelipatan 4===
| | * [https://wiki.efisonlt.com/wiki/Threading_di_ALELEON_Supercomputer#SLURM_SBATCH_cpus-per-task Mengalokasikan threading pada SLURM.] |
| Berdasarkan arsiktektur CPU AMD yang digunakan oleh ALELEON Supercomputer, user direkomendasikan untuk memilih jumlah core thread CPU (ntasks) berdasarkan kelipatan 4, dimulai dari 1,2,4, kemudian naik kelipatan 4 menjadi 8, 12, 16, 20, 24, 28, 32, 36, 40, dan seterusnya.
| | * [https://wiki.efisonlt.com/wiki/Threading_di_ALELEON_Supercomputer#Menjalankan_Program_Pure_OMP Menjalankan program pure OMP.] |
| | * [https://wiki.efisonlt.com/wiki/Threading_di_ALELEON_Supercomputer#Menjalankan_Program_Paralelisasi_BLAS Menjalankan program dengan paralelisasi BLAS (AMD BLIS, OpenBLAS, MKL).] |
| | * [https://wiki.efisonlt.com/wiki/Threading_di_ALELEON_Supercomputer#Mejalankan_Program_Hybrid_MPI.2FOMP_atau_MPI.2FBLAS Menjalankan program Hybrid MPI.] |
|
| |
|
| ---
| | == '''[[Compiler AMD ALELEON Supercomputer|Optimasi Compiler AMD]]''' == |
| ===Semakin Besar Jumlah Core CPU = Komputasi Semakin Cepat?=== | |
| Bisa iya bisa tidak. Besar jumlah core CPU yang dibutuhkan bergantung pada:
| |
| *'''Apabila menjalankan program CPU:''' bergantung pada '''besarnya skala input komputasi user'''. Admin ALELEON Supercomputer sepenuhnya menyerahkan tanggung jawab kepada user untuk mengetahui sendiri apakah input komputasi yang dijalankan adalah skala kecil atau besar.
| |
| **Input komputasi skala kecil cukup membutuhkan jumlah core kecil (rekomendasi dibawah 16) dan bisa jadi lambat apabila dijalankan dengan jumlah core besar.
| |
| **Input komputasi skala besar dapat menggunakan jumlah core CPU yang besar seperti 32, 64, 128, atau diatasnya.
| |
| *'''Apabila menjalankan program GPU:''' kebanyakan membutuhkan jumlah core kecil karena pada dasarnya semua komputasi dikerjakan oleh GPU. Cukup jarang ada program GPU yang membutuhkan jumlah core CPU besar.
| |
| ---
| |
|
| |
|
| ===Memperkirakan Kapasitas RAM yang Digunakan===
| | * [https://wiki.efisonlt.com/wiki/Compiler_AMD_ALELEON_Supercomputer#Melakukan_Compiling_di_ALELEON_Supercomputer Cara melakukan compiling di ALELEON Supercomputer.] |
| Apakah program user membutuhkan banyak RAM atau tidak? Tidak ada aturan baku untuk mengetahui hal ini karena bergantung dengan jenis software dan besarnya skala input yang dijalankan user. Admin EFISON dapat memberikan saran '''untuk menggunakan jumlah RAM 0.5GB per ntasks sebagai basis'''. Contoh:
| | * [https://wiki.efisonlt.com/wiki/Compiler_AMD_ALELEON_Supercomputer#GCC_untuk_AMD Menggunakan GCC dengan optimasi AMD.] |
| *ntasks=8, alokasikan mem 4GB.
| | * [https://wiki.efisonlt.com/wiki/Compiler_AMD_ALELEON_Supercomputer#AMD_Optimizing_CPU_Libraries_.28AOCL.29 Menggunakan AMD Optimizing CPU Libraries (AOCL).] |
| *ntasks=32, alokasikan mem 16GB.
| | * [https://wiki.efisonlt.com/wiki/Compiler_AMD_ALELEON_Supercomputer#Intel_MKL_di_AMD Menggunakan Math Kernel Library.] |
| User dapat menggunakan kapasitas RAM yang lebih besar (contoh 2GB per ntasks atau lebih) apabila user mengetahui bahwa program yang dijalankan membutuhkan kapasitas RAM besar atau program gagal berjalan dengan alokasi RAM 0.5GB per ntasks.
| |
| | |
| == '''Menjalankan Program non-MPI: multi-core atau cuma 1 core?''' ==
| |
| Terdapat beberapa hal yang perlu diperhatikan oleh user ketika menjalanan program non-MPI:
| |
| *Program komputasi non-MPI dapat berjalan secara multi-core (lebih dari 1 core) atau hanya bisa berjalan dengan 1 core tergantung oleh jenis software dan pemrogramannya. | |
| *Program komputasi non-MPI yang hanya berjalan 1 core sering terjadi pada program yang ditulis sendiri oleh user atau framework komputasi yang menggunakan standar pemrograman serial.
| |
| *Bagi user yang tidak ingin programnya berjalan di ALELEON Supercomputer hanya dengan 1 core, Admin EFISON menyarankan untuk menguji terlebih dahulu dengan menjalankannya pada perangkat komputer pribadi dan lihat status penggunaan CPU-nya.
| |
| **User dapat mengganti coding apabila terjadi pada program yang ditulis sendiri.
| |
| **Apabila menggunakan software komputasi maka user harus mencari alternatif software yang dapat berjalan multi-core.
| |
| | |
| == '''Menjalankan Program MPI: Optimasi mpirun''' ==
| |
| MPI pada ALELEON Supercompter menggunakan OpenMPI yang telah dioptimasi secara khusus berdasarkan arsitektur AMD Zen2 yang digunakan oleh AMD EPYC 7702P dan Threadripper 3990X.
| |
| | |
| ---
| |
| | |
| === Modul OpenMPI ===
| |
| User dapat memuat modul OpenMPI default pada SLURM Script atau terminal dengan perintah:
| |
| module load openmpi
| |
| Admin EFISON selalu menjadikan OpenMPI versi terbaru sebagai default. User dapat melihat ketersediaan OpenMPI lainnya pada [https://wiki.efisonlt.com/wiki/Katalog_Software_ALELEON_Supercomputer#Daftar_Compiler_.28Global.29 tabel daftar compiler ALELEON Supercomputer] atau melalui perintah module av pada terminal:
| |
| $ module av openmpi
| |
| User tidak perlu memuat modul OpenMPI apabila memuat modul software komputasi saintifik MPI yang terdapat pada [https://wiki.efisonlt.com/wiki/Katalog_Software_ALELEON_Supercomputer#Daftar_Software_Komputasi_.28Global.29 daftar software komputasi ALELEON Supercomputer] karena OpenMPI sudah ada didalamnya.
| |
| | |
| ---
| |
| | |
| === Menulis Perintah OpenMPI di ALELEON Supercomputer ===
| |
| Berikut adalah format untuk menjalankan program MPI di ALELEON Supercomputer di SLURM Script:
| |
| '''mpirun -np $SLURM_NTASKS --mca pml ucx --mca osc ucx''' ////
| |
| Keterangan:
| |
| | |
| * Tetap menggunakan perintah mpirun, bukan srun yang biasa digunakan pada SLURM.
| |
| * Semua proses MPI akan dialokasikan ke core thread CPU sehingga '''jumlah proses MPI sama dengan jumlah ntasks pada SBATCH SLURM.''' Variabel '''$SLURM_NTASKS''' menangkap jumlah ntasks sehingga user tidak perlu memasukkan jumlah proses MPI secara manual.
| |
| * Berlaku aturan kelipatan 4 untuk jumlah ntasks.
| |
| * Flag '''--mca pml ucx --mca osc ucx''' menjalankan OpenMPI pada jaringan RDMA melalui protokol UCX (Unified Communication-X) untuk menghasilkan performa MPI terbaik.
| |
| | |
| ---
| |
| | |
| === Bagaimana SLURM dan OpenMPI ALELEON Membagi Core Fisik dan Thread ===
| |
| Proses MPI pada OpenMPI ALELEON Supercomputer yang dijalankan melalui SLURM telah dirancang untuk '''selalu mengisi penuh core thread per core fisik''', artinya:
| |
| | |
| * Contoh menjalankan 32 proses MPI, akan dijalankan oleh 16 core fisik / 32 core thread CPU.
| |
| * Contoh menjalankan 64 proses MPI, akan dijalankan oleh 32 core fisik / 64 core thread CPU.
| |
| * dst.
| |
| | |
| Pembagian ini didasarkan pada pengelompokan core pada CCX dan CCD di arsitektur AMD Zen2 supaya memastikan '''tidak ada penyebaran proses MPI yang berjalan antar grup CCX / CCD yang berjauhan''' di mana menyebabkan ''L3 cache miss'' dan menurunkan performa secara signifikan.
| |
| [[Berkas:Zen2-uarch-1536x1256.jpg|nir|jmpl|600x600px|AMD Zen2 mengelompokkan 4 core fisik / 8 core thread kedalam satu grup yang disebut CCX. Setiap CCX mempunyai L3 cache yang digunakan untuk "meja kerja" antar core. Kemudian 2 CCX dikelompokkan menjadi 1 CCD dan berkomunikasi dengan CCD lainnya (total 8 CCD - menjadi 64 core fisik / 128 core thread). OpenMPI dan SLURM pada ALELEON Supercomputer memastikan penyebaran proses MPI selalu berdekatan antar grup CCX dan CCD (''tightly coupled'') untuk menghasilkan performa terbaik.]]
| |
| Semua software komputasi ALELEON Supercomputer telah dioptimasi untuk berjalan dengan skema di atas. Akan tetapi, apabila user tetap ingin menjalankan program MPI sepenuhnya pada core fisik (contoh ketika mengetahui bahwa file input nya berjalan optimal di core fisik) maka harus mengalokasikan '''jumlah SBATCH ntasks 2 kali lipat dari proses MPI yang mau dijalankan'''. Contoh:
| |
| #SBATCH --ntasks=64
| |
| mpirun -np '''32''' --mca pml ucx --mca osc ucx ////
| |
|
| |
| '''#''' '''Peringatan: sistem akan tetap menghitung 64 core thread''' '''sebagai penghitungan CPU Core Hour!'''
| |
| == '''Menjalankan Program MPI: Satu Node vs Multi Node''' ==
| |
| Kemampuan utama program MPI adalah melakukan komputasi paralel atau dapat berjalan pada lebih dari 1 node (multi-node) atau lebih dari 128 core thread pada ALELEON Supercomputer. Terdapat beberapa hal yang harus diketahui oleh user:
| |
| | |
| ---
| |
| | |
| === ntasks 1 - 64: Gunakan 1 node ===
| |
| Untuk jumlah proses mpirun dibawah 65 (1 - 64) gunakan 1 node.
| |
| #SBATCH --nodes=1
| |
| Selenbihnya bisa dijalankan dengan lebih dari 1 node.
| |
| | |
| ---
| |
| | |
| === ntasks >64: Kapan Bisa Multi-node? ===
| |
| Salah satu hal yang membuat unik (dan sulit) pemograman MPI adalah membutuhkan memori cache CPU sebagai ''buffer'' untuk menampung alur komunikasi paralel.
| |
| | |
| Apa artinya pada ALELEON Supercomputer untuk ntasks diatas 64?
| |
| | |
| *'''Skenario pertama:''' Menjalankan program MPI yang '''tidak efisien''' dalam mengatur alokasi cache CPU, user harus menambah 1 node setiap kelipatan 64 ntasks.
| |
| *'''Skenario kedua:''' Menjalankan program MPI yang '''efisien''' dalam mengatur alokasi cache CPU, user dapat menambah 1 node setiap kelipatan 128 ntasks.
| |
| | |
| {| class="wikitable"
| |
| !Jumlah Node
| |
| !Skenario 1
| |
| Jumlah ntasks:
| |
| !Skenario 2
| |
| Jumlah ntasks:
| |
| |-
| |
| |1
| |
| |1-64
| |
| |1-128
| |
| |-
| |
| |2
| |
| |65-128
| |
| |129-256
| |
| |-
| |
| |3
| |
| |129-192
| |
| |257-384
| |
| |}
| |
| '''Bagaimana User Memilih Jenis Skenario MPI Multi-Node?''' Terdapat beberapa rekomendasi dari admin EFISON:
| |
| | |
| *''Rule of thumb'': selalu memilih '''skenario 1'''. Apabila user '''membutuhkan jumlah ntasks lebih dari 192, gunakan skenario 2'''. | |
| * Admin EFISON akan menguji mandiri semua software komputasi MPI yang terdaftar pada [https://wiki.efisonlt.com/wiki/Katalog_Software_ALELEON_Supercomputer#Daftar_Software_Komputasi_.28Global.29 daftar software komputasi ALELEON Supercomputer] dan menulis jenis skenario MPI multi-node pada masing-masing halaman software komputasi.
| |
| * User dan admin EFISON dapat melakukan kolaborasi untuk melakukan tes benchmark menentukan tipe skenario multi-node program MPI yang dijalankan.
| |
| ---
| |
| | |
| === Bagaimana User Menjalankan MPI Multi-Node ===
| |
| Ketika user mengalokasikan jumlah nodes lebih dari satu pada SBATCH maka SLURM secara otomatis akan menyebarkan proses MPI ke jumlah node yang didefinisikan. Contoh: user mengalokasikan 2 node untuk menjalankan 192 proses MPI:
| |
| #SBATCH --nodes=2
| |
| #SBATCH --ntasks=192
| |
| #SBATCH --mem=128GB
| |
| mpirun -np $SLURM_NTASKS --mca pml ucx --mca osc ucx ////
| |
| Maka SLURM secara otomatis akan menyebarkan 192 proses MPI ke 2 node. SLURM sekaligus melakukan optimasi komputasi multi-node berdasarkan protokol network RDMA / UCX dan grouping CCX dan CCD terdekat antar CPU.
| |
| | |
| ---
| |
| | |
| === Mengalokasikan Memori RAM untuk MPI Multi-Node ===
| |
| Bagaimana user mengalokasikan memori RAM (SBATCH mem) untuk komputasi MPI multi-node?
| |
| | |
| * SBATCH mem secara otomatis mengalokasikan memori RAM '''per node'''. Pada contoh diatas, user mengalokasikan RAM 128GB per node sehingga total menggunakan 256GB untuk 2 node. Batasan SBATCH mem tetap mengikuti kapasitas RAM per node Partisi epyc yaitu 240GB.
| |
| * Jumlah basis RAM disarankan '''1GB per (ntasks / nodes).''' | |
| | |
| *
| |
| | |
| ---
| |
| | |
| === Alternatif MPI Multi-node: SBATCH ntasks-per-node ===
| |
| SLURM menyediakan opsi alternatif untuk menjalankan MPI multi-node yaitu ntasks-per-node di mana menggantikan ntasks. Sesuai namanya, ntasks-per-node mendefinisikan '''jumlah ntasks per node'''.
| |
| '''#SBATCH --ntasks-per-node='''////
| |
| Contoh user menjalankan program MPI pada 2 node dengan 48 core per node:
| |
| '''#SBATCH --nodes=2
| |
| #SBATCH --ntasks-per-node=48
| |
| mpirun -np $SLURM_NTASKS --mca pml ucx --mca osc ucx ////
| |
| | |
| * Total jumlah MPI adalah '''nodes * ntasks-per-node''', pada contoh di atas adalah 2*48 = 96 proses MPI. Variabel $SLURM_NTASKS menangkap total proses MPI ini.
| |
| * SLURM akan menyebar rata 48 proses MPI ke semua node.
| |
| | |
| == '''Paralelisasi Thread per Core (cpus-per-tasks)''' ==
| |
| Paralelisasi thread per core digunakan untuk program yang ditulis dengan '''paralelisasi OpenMP (OMP), library BLAS, atau hybrid MPI/OMP'''. Pada SLURM, user mengalokasikan jumlah thread per core melalui parameter SBATCH '''cpus-per-task''' dan variabel '''SLURM_CPUS_PER_TASK'''.
| |
| | |
| Contoh menggunakan OMP:
| |
| #SBATCH --ntasks=8
| |
| '''#SBATCH --cpus-per-task='''4
| |
| export OMP_NUM_THREADS='''$SLURM_CPUS_PER_TASK'''
| |
| Total penggunaan core thread CPU yang dihitung oleh SLURM adalah '''ntasks * cpus-per-task'''. Pada contoh di atas, user menggunakan 8*4 = 32 core thread CPU.
| |
| | |
| Berikut adalah beberapa skenario menjalankan penggunaan paralelisasi thread di ALELEON Supercomputer:
| |
| | |
| ---
| |
| | |
| === Pure OMP ===
| |
| Gunakan alokasi ntasks=1 untuk menjalankan program pure OMP, dengan nilai maksimal cpus-per-task='''128'''. Program Pure-OMP hanya dapat berjalan 1 node.
| |
| #SBATCH --nodes=1
| |
| #SBATCH --ntasks=1
| |
| #SBATCH --cpus-per-task=////
| |
| ---
| |
| | |
| === Jumlah Thread Optimal untuk Paralelisasi BLAS dan MPI/OMP ===
| |
| Secara umum, program yang menggunakan threading BLAS atau Hybrid MPI/OMP mampu berjalan secara multi-core sehingga admin EFISON merekomendasikan '''jumlah threading 2, 4, atau 8 per ntasks atau proses MPI.'''
| |
| [[Berkas:Ccxccd.png|nir|jmpl|285x285px|Threading BLAS dan MPI/OMP paling optimal disebar ke setiap core fisik di CCX atau CCD sehingga admin EFISON merekomendasikan jumlah threading 2, 4, atau 8.]]
| |
| ---
| |
| | |
| === Threading BLAS pada AMD BLIS ===
| |
| ALELEON Supercomputer menggunakan AMD BLIS (BLAS-like Library Instantiation Software) sebagai library BLAS utama yang telah dioptimasi secara khusus berdasarkan arsitektur AMD Zen2. ALELEON Supercomputer menggunakan AMD BLIS versi 3 keatas sehingga user harus mendefinisikan secara manual variabel threading BLIS:
| |
| #SBATCH --cpus-per-task=////
| |
|
| |
| export BLIS_JC_NT=1
| |
| export BLIS_IC_NT=${SLURM_CPUS_PER_TASK}
| |
| export BLIS_JR_NT=1
| |
| export BLIS_IR_NT=1
| |
| Penjelasan:
| |
| | |
| * BLIS JC, IC, JR, dan IR secara urut adalah paralelisasi di loop terluar, loop ketiga, loop kedua, dan loop kesatu.
| |
| * Aturan dari variabel BLIS adalah total dari JC * IC * JR * IR harus sama dengan total thread yang didefinisikan user.
| |
| * Pada AMD Zen2, karena setiap CCX berkerja pada L3 cache maka paralelisasi dilakukan di level IC sehingga diisi dengan variabel SLURM_CPUS_PER_TASK.
| |
| | |
| ---
| |
| | |
| === Threading BLAS pada OpenBLAS ===
| |
| Threading pada OpenBLAS dideklarasikan melalui variabel OPENBLAS_NUM_THREADS, GOTO_NUM_THREADS, dan OMP_NUM_THREADS:
| |
| #SBATCH --cpus-per-task=////
| |
|
| |
| threads=${SLURM_CPUS_PER_TASK}
| |
| export OPENBLAS_NUM_THREADS=$threads
| |
| export GOTO_NUM_THREADS=$threads
| |
| export OMP_NUM_THREADS=${threads}
| |
| ---
| |
| | |
| === Threading BLAS pada Math Kernel Library (MKL) ===
| |
| Threading pada MKL dideklarasikan melalui variabel OMP_NUM_THREADS dan MKL_NUM_THREADS:
| |
| #SBATCH --cpus-per-task=////
| |
|
| |
| threads=${SLURM_CPUS_PER_TASK}
| |
| export OMP_NUM_THREADS=${threads}
| |
| export MKL_NUM_THREADS=${threads
| |
| ---
| |
| | |
| === Hybrid MPI/OMP: 1 Node dan Multi-Node ===
| |
| Threading pada hybrid MPI/OMP dilakukan dengan alur berikut:
| |
| #SBATCH --nodes=////
| |
| #SBATCH --ntasks=////
| |
| #SBATCH --cpus-per-task=////
| |
|
| |
| export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK
| |
|
| |
| mpirun -np $SLURM_NTASKS --mca pml ucx --mca osc ucx ////
| |
| '''# Total SLURM_NTASKS = ntasks * cpus-per-task'''
| |
| | |
| * Variabel SLURM_NTASKS secara otomatis akan akan menangkap total core thread CPU yang terpakai yaitu '''jumlah ntasks * cpus-per-task.'''
| |
| * Pada penggunaan multi-node, SLURM secara otomatis akan mengatur jumlah threading OMP ke setiap proses MPI (atau ntasks).
| |
| | |
| User juga dapat menggunakan alternatif ntasks-per-node yang lebih kompleks dimana variabel SLURM_NTASKS akan menangkap total core thread CPU yang terpakai yaitu '''jumlah nodes * ntasks-per-node * cpus-per-task'''.
| |
| #SBATCH --nodes=////
| |
| #SBATCH --ntasks-per-node=////
| |
| #SBATCH --cpus-per-task=////
| |
|
| |
| export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK
| |
|
| |
| mpirun -np $SLURM_NTASKS --mca pml ucx --mca osc ucx ////
| |
| '''# Total SLURM_NTASKS = nodes * ntasks-per-node * cpus-per-task'''
| |
