hpc | Lab codes and questions

I am trying to run an Rscript multiple times with different parameters and I am using a bash script to do so (I got an error while trying to run it in parallel in R with things like foreach and doParallel but that is not the problem here).

My script, which I intended to call with $sbatch script.sh (on a hpc) looks as follows:

I am new to HPC and SLURM especially, and i ran into some troubles.

I was provided with acces to a HPC cluster with 32 CPUs on each node. In order to do the needed calculations I made 12 Python multiprocessing Scripts, where each Script uses excactly 32 CPU's. How, instead of starting each Script manually in the interactive modus ( which is also an option btw. but it takes a lot of time) I decided to write a Batch Script in order to start all my 12 Scripts automatically.

//SCRIPT//

#!/bin/bash

#SBATCH --job-name=job_name

#SBATCH --partition=partition

#SBATCH --nodes=1

#SBATCH --time=47:59:59

#SBATCH --export=NONE

#SBATCH --array=1-12

module switch env env/system-gcc module load python/3.8.5

source /home/user/env/bin/activate

python3.8 $HOME/Script_directory/Script$SLURM_ARRAY_TASK_ID.py

exit

//UNSCRIPT//

But as far as i understand, this script would start all of the Jobs from the Array on the same node and thus the underlying python scripts might start a "fight" for the available CPU's and thus slow down.

How should i modify my bash file in Order to start each task from the array on a separate node?

Thanks in advance!

I have an aws HPC auto scale cluster managed by slurm, I can submit jobs using sbatch, however I want to use spraklyr on this cluster so that slurm increases the cluster size based on the workload of the sparklyr code in the R script. Is this possible?

I am trying to use Dask by looking at the code examples and documentation, and have trouble understanding how it works. As suggested in the document, I am trying to use the distributed scheduler (I also plan to deploy my code on an HPC).

The first simple thing I tried was this:

I'm trying to implement a SIMD algorithm with AArch64 SVE (or SVE2) that takes a list of elements and only selects the ones that meet a certain condition. It's often called Left Packing (SSE/AVX/AVX-512), or Stream Compaction (CUDA)?

Is it possible to vectorize this operation with SVE?

Equivalent SQL and scalar code could look like this:

I am calling a shell (.sh) script from my python code and I want to tell Python to wait for the script to end before continuing to the rest of the code. For the record, the script is calling a HPC cluster some calculations which take approximately 40-50min. I could probably do sleep() and force python to wait for these 40-50min, but firstly I do not always know the amount of time that should wait, and secondly I was hoping for a more efficient way of doing this. So, the script is called by using os.system("bsub < test.sh").

Is there any way to actually tell python wait until the script is finished and then continue with the rest of the code? Thanks in advance

I wrote a C++ code whose bottleneck is the diagonalization of a possibly large symmetric matrix. The code uses OpenMP, CBLAS and LAPACKE C-interfaces.

However, the call on dsyev runs on a single thread both on my local machine and on a HPC cluster (as seen by htop or equivalent tools). It takes about 800 seconds to diagonalize a 12000x12000 matrix, while NumPy's function eigh takes about 250 seconds. Of course, in both cases $OMP_NUM_THREADS is set to the number of threads.

Here is an example of a C++ code that calls LAPACK that is basically what I do in my program. (I am reading the matrix that is in binary format).

I'm new to HPC and SLURM in particular. Here is an example code that I use to run my python script:

I am looking at the performance of a sycl port of some hpc code, which I am running on a GV100 card via hipSYCL.

Running the code through a profiler tells me that very high register usage is the likely limiting factor for performance.

Is there any way of influencing register usage of the gpu code that hipSYCL / clang generates, something akin to nvcc's -maxregcount option?