{"type":"doc","content":[{"type":"heading","attrs":{"level":2},"content":[{"text":"Juypter","type":"text"}]},{"type":"paragraph","content":[{"text":"This setup allows a user to run Jupyter Lab on a SLURM-managed compute node, facilitating remote access via SSH tunneling. The SLURM script handles resource allocation, while the Jupyter script sets up the environment and launches the server, providing clear instructions for accessing the notebook from a local machine.","type":"text"}]},{"type":"paragraph","content":[{"text":"SLURM Job Script jupyter.slurm","type":"text"}]},{"type":"codeBlock","content":[{"text":"#!/bin/bash -l\n#SBATCH --job-name=jupyter # create a short name for your job\n#SBATCH --nodes=1 # node count\n#SBATCH --ntasks=1 # total number of tasks across all nodes\n#SBATCH --cpus-per-task=1 # cpu-cores per task (>1 if multi-threaded tasks)\n#SBATCH --mem=10G # total memory (RAM) per node\n#SBATCH --time=1:00:00 # total run time limit (HH:MM:SS)\n\nmodule load conda/3\n\n./jupyter.sh\n\n","type":"text"}]},{"type":"paragraph","content":[{"text":"The above executes another script jupyter.sh, which contains the commands to set up the Jupyter environment and launch Jupyter Lab","type":"text"}]},{"type":"codeBlock","content":[{"text":"export PORT=8888\necho \"set up SSH port forwarding between the compute resource and your local computer (laptop/desktop)\"\necho \"ssh -N -L $PORT:[HOST]:$PORT [userID]@hpc.c2b2.columbia.edu\"\necho \"Access the Jupyter Notebook via your web browser on your local computer.\"\necho \"http://127.0.0.1:$PORT/\"\n\nmodule load conda/3\necho \" \"\necho \"=============================================================================\"\necho \"=== jupyterlab.sh Install and run JupyterLab locally\"\necho \"+++ installing jupyter\"\npython -m venv .jup\n. .jup/bin/activate\npython -m pip install pip --upgrade\npython -m pip install --upgrade jupyterlab\npython -m pip install --upgrade bash_kernel\npython -m bash_kernel.install\npython -m pip install --upgrade jupyterlab-spellchecker\n\necho \"+++ run jupyter\"\n\n\njupyter-lab --ip=0.0.0.0 --port=$PORT --no-browser\n","type":"text"}]},{"type":"codeBlock","content":[{"text":"jupyter-lab --ip=0.0.0.0 --port=$PORT --no-browser\n\n","type":"text"}]},{"type":"paragraph","content":[{"text":"This command starts the Jupyter Lab server, making it accessible from any IP address (0.0.0.0) on the specified port. The --no-browser option prevents Jupyter from trying to open a browser on the compute node, which is typically not possible in HPC environments.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Access the Notebook","type":"text"}]},{"type":"paragraph","content":[{"text":"After submitting the job, you'll need to set up port forwarding to access the Jupyter Notebook server.","type":"text"}]},{"type":"orderedList","attrs":{"order":1},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Find the allocated node: Check the output of the job submission to see on which node the Jupyter Notebook is running.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"SSH into the node: Use the following command to create an SSH tunnel:","type":"text"}]}]}]},{"type":"codeBlock","content":[{"text":"ssh -N -L $PORT:[HOST]:$PORT [userID]@hpc.c2b2.columbia.edu\n\n","type":"text"}]},{"type":"orderedList","attrs":{"order":3},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Open your browser: In your web browser, go to ","type":"text"},{"text":"http://127.0.0.1:$PORT","type":"text","marks":[{"type":"underline"},{"type":"link","attrs":{"href":"http://127.0.0.1:$PORT/"}}]},{"text":". You should be able to access your Jupyter Notebook server.","type":"text"}]}]}]},{"type":"heading","attrs":{"level":1},"content":[{"text":"GPU JOBS","type":"text"}]},{"type":"paragraph","content":[{"text":"To add a GPU to your Slurm allocation:","type":"text"}]},{"type":"codeBlock","content":[{"text":"#SBATCH --gres=gpu:L40S:1 # number of L40S gpus per node\n#SBATCH --partition=gpu #GPU queue\n","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"CuPy","type":"text"}]},{"type":"paragraph","content":[{"text":"CuPy","type":"text","marks":[{"type":"underline"},{"type":"link","attrs":{"href":"https://cupy.chainer.org/"}}]},{"text":" is a library that provides an interface similar to NumPy but is designed to leverage NVIDIA GPUs for accelerated computing. It allows users to perform operations on large arrays and matrices efficiently by utilizing the parallel processing power of GPU. You can roughly think of CuPy as NumPy for GPUs","type":"text"}]},{"type":"paragraph","content":[{"text":"To install CuPy","type":"text"}]},{"type":"codeBlock","content":[{"text":"module load conda\nconda create --prefix=/users/sysops/tmp/workshop/cupyenv cupy --channel conda-forge","type":"text"}]},{"type":"paragraph","content":[{"text":"In this example we will perform a Singular Value Decomposition (SVD) on a randomly generated matrix using CuPy, which leverages GPU acceleration.","type":"text"}]},{"type":"codeBlock","content":[{"text":"from time import perf_counter\nimport cupy as cp\n\nN = 2000\nX = cp.random.randn(N, N, dtype=cp.float64)\n\ntrials = 5\ntimes = []\nfor _ in range(trials):\n t0 = perf_counter()\n u, s, v = cp.linalg.svd(X)\n cp.cuda.Device(0).synchronize()\n times.append(perf_counter() - t0)\nprint(\"Execution time: \", min(times))\nprint(\"sum(s) = \", s.sum())\nprint(\"CuPy version: \", cp.__version__)\n","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Here is the breakdown of what each part does:","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Imports:","type":"text"}]},{"type":"paragraph","content":[{"text":"perf_counter from time for high-resolution timing.","type":"text"}]},{"type":"paragraph","content":[{"text":"cupy for GPU array operations.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Matrix Generation:","type":"text"}]},{"type":"paragraph","content":[{"text":"N = 2000 sets the size of the matrix.","type":"text"}]},{"type":"paragraph","content":[{"text":"X = cp.random.randn(N, N, dtype=cp.float64) creates a 2000x2000 matrix with normally distributed random numbers.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Timing Execution:","type":"text"}]},{"type":"paragraph","content":[{"text":"The code runs the SVD operation 5 times to measure performance accurately.","type":"text"}]},{"type":"paragraph","content":[{"text":"cp.linalg.svd(X) computes the SVD of matrix X.","type":"text"}]},{"type":"paragraph","content":[{"text":"cp.cuda.Device(0).synchronize() ensures that all GPU operations are complete before timing stops.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Results:","type":"text"}]},{"type":"paragraph","content":[{"text":"The minimum execution time from the trials is printed.","type":"text"}]},{"type":"paragraph","content":[{"text":"The sum of the singular values (s) is calculated and displayed.","type":"text"}]},{"type":"paragraph","content":[{"text":"The CuPy version used is printed.","type":"text"}]},{"type":"paragraph","content":[{"text":"Below is a sample Slurm script:","type":"text"}]},{"type":"codeBlock","content":[{"text":"#!/bin/bash -l\n#SBATCH --job-name=cupy-gpu # create a short name for your job\n#SBATCH --nodes=1 # node count\n#SBATCH --ntasks=1 # total number of tasks across all nodes\n#SBATCH --cpus-per-task=1 # cpu-cores per task (>1 if multi-threaded tasks)\n#SBATCH --gres=gpu:L40S:1 # number of gpus per node\n#SBATCH --mem=4G # total memory (RAM) per node\n#SBATCH --time=00:00:30 # total run time limit (HH:MM:SS)\n#SBATCH --partition=gpu # Queue/Partition\n\nmodule load conda/3\n\nconda activate /users/sysops/tmp/workshop/cupyenv\npython svd.py","type":"text"}]},{"type":"paragraph","content":[{"text":"Submit the job:","type":"text"}]},{"type":"codeBlock","content":[{"text":"$ sbatch job.sh","type":"text"}]},{"type":"paragraph","content":[{"text":"You can track the job's progress using squeue -u $USER. After the job finishes, check the output using cat slurm-*.out. What happen if we will double th value of N ? Will the execution time double? There's also a CPU version of the code; let's give that a try.","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"PyTorch","type":"text"}]},{"type":"paragraph","content":[{"text":"PyTorch","type":"text","marks":[{"type":"underline"},{"type":"link","attrs":{"href":"https://pytorch.org/"}}]},{"text":" is an open-source machine learning library widely used for deep learning applications. It provides a flexible and dynamic framework for building neural networks, enabling efficient computation on both CPUs and GPUs.","type":"text"}]},{"type":"paragraph","content":[{"text":"To install PyTorch","type":"text"}]},{"type":"codeBlock","content":[{"text":"module load conda\n$ conda create --prefix=/users/sysops/tmp/workshop/torch-env torchvision pytorch-cuda=12.4 -c pytorch -c nvidia\n$ conda create --name torch-env pytorch torchvision pytorch-cuda=12.4 -c pytorch -c nvidia\n$ conda activate /users/sysops/tmp/workshop/torch-env","type":"text"}]},{"type":"paragraph","content":[{"text":"In this example we will utilizes PyTorch to perform Singular Value Decomposition (SVD) on a randomly generated matrix, leveraging GPU acceleration.","type":"text"}]},{"type":"codeBlock","content":[{"text":"from time import perf_counter\nimport torch\n\nN = 2000\n\ncuda0 = torch.device('cuda:0')\nx = torch.randn(N, N, dtype=torch.float64, device=cuda0)\nt0 = perf_counter()\nu, s, v = torch.svd(x)\nelapsed_time = perf_counter() - t0\n\nprint(\"Execution time: \", elapsed_time)\nprint(\"Result: \", torch.sum(s).cpu().numpy())\nprint(\"PyTorch version: \", torch.__version__)","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Breakdown of the Code:","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Imports:","type":"text"}]},{"type":"paragraph","content":[{"text":"perf_counter from the time module for precise timing.","type":"text"}]},{"type":"paragraph","content":[{"text":"torch for tensor operations and GPU support.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Matrix Setup:","type":"text"}]},{"type":"paragraph","content":[{"text":"N = 2000 defines the dimensions of the matrix.","type":"text"}]},{"type":"paragraph","content":[{"text":"cuda0 = torch.device('cuda:0') specifies that computations should occur on the first GPU.","type":"text"}]},{"type":"paragraph","content":[{"text":"x = torch.randn(N, N, dtype=torch.float64, device=cuda0) generates a 2000x2000 matrix filled with random numbers, stored on the GPU.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"SVD Computation:","type":"text"}]},{"type":"paragraph","content":[{"text":"t0 = perf_counter() starts the timer. u, s, v = torch.svd(x) computes the SVD of the matrix. elapsed_time = perf_counter() - t0 calculates the total time taken for the operation.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Results:","type":"text"}]},{"type":"paragraph","content":[{"text":"The execution time is printed.","type":"text"}]},{"type":"paragraph","content":[{"text":"The sum of the singular values (s) is computed and transferred back to the CPU for display using .cpu().numpy().","type":"text"}]},{"type":"paragraph","content":[{"text":"The PyTorch version is printed.","type":"text"}]},{"type":"paragraph","content":[{"text":"Here is a sample Slurm script:","type":"text"}]},{"type":"codeBlock","content":[{"text":"#!/bin/bash -l\n#SBATCH --job-name=torch # Job name\n#SBATCH --nodes=1 # node count\n#SBATCH --ntasks=1 # total number of tasks across all nodes\n#SBATCH --cpus-per-task=1 # cpu-cores per task (>1 if multi-threaded tasks)\n#SBATCH --gres=gpu:L40S:1 # number of gpus per node\n#SBATCH --mem=4G # total memory (RAM) per node\n#SBATCH --time=00:00:30 # total run time limit (HH:MM:SS)\n#SBATCH --partition=gpu # Queue/Partition\n\nmodule load conda/3\n\nconda activate /users/sysops/tmp/workshop/torch-env\npython svd.py","type":"text"}]},{"type":"paragraph","content":[{"text":"Submit the job:","type":"text"}]},{"type":"codeBlock","content":[{"text":"$ sbatch job.sh","type":"text"}]},{"type":"paragraph","content":[{"text":"You can track the job's progress using squeue -u $USER. After the job finishes, check the output using cat slurm-*.out","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"MATLAB","type":"text"}]},{"type":"paragraph","content":[{"text":"MATLAB is available on the cluster.","type":"text"}]},{"type":"paragraph","content":[{"text":"In this example we will use MATLAB to perform Singular Value Decomposition (SVD) on a randomly generated matrix, leveraging GPU acceleration.","type":"text"}]},{"type":"codeBlock","content":[{"text":"gpu = gpuDevice();\nfprintf('Using a %s GPU.\\n', gpu.Name);\ndisp(gpuDevice);\n\nX = gpuArray([1 0 2; -1 5 0; 0 3 -9]);\nwhos X;\n[U,S,V] = svd(X)\nfprintf('trace(S): %f\\n', trace(S))\nquit;\n\n","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Breakdown of the Code:","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Initialize GPU Device:","type":"text"}]},{"type":"paragraph","content":[{"text":"gpu = gpuDevice(); retrieves the current GPU device. fprintf and disp display the name and details of the GPU being used.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Create a GPU Array:","type":"text"}]},{"type":"paragraph","content":[{"text":"X is created as a GPU array containing specified values. whos X; displays information about the variable X.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Perform SVD:","type":"text"}]},{"type":"paragraph","content":[{"text":"Computes the SVD of the matrix X, returning matrices U, S, and V.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Calculate and Display the Trace:","type":"text"}]},{"type":"paragraph","content":[{"text":"Calculates the trace of matrix S (the sum of its diagonal elements) and prints it.","type":"text"}]},{"type":"paragraph","content":[{"text":"Here is Slurm Script","type":"text"}]},{"type":"codeBlock","content":[{"text":"#!/bin/bash\n#SBATCH --job-name=matlab-svd # create a short name for your job\n#SBATCH --nodes=1 # node count\n#SBATCH --ntasks=1 # total number of tasks across all nodes\n#SBATCH --cpus-per-task=1 # cpu-cores per task (>1 if multi-threaded tasks)\n#SBATCH --time=00:10:00 # total run time limit (HH:MM:SS)\n#SBATCH --mem=4G # total memory (RAM) per node\n#SBATCH --gres=gpu:L40S:1 # number of gpus per node\n#SBATCH --partition=gpu # Queue/Partition\n\nmodule load matlab/R2023a\n\nmatlab -singleCompThread -nodisplay -nosplash -r svd","type":"text"}]},{"type":"paragraph","content":[{"text":"Submit the job:","type":"text"}]},{"type":"codeBlock","content":[{"text":"$ sbatch job.sh","type":"text"}]},{"type":"paragraph","content":[{"text":"You can track the job's progress using squeue -u $USER. After the job finishes, check the output using cat slurm-*.out","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"C++","type":"text"}]},{"type":"paragraph","content":[{"text":"In this example C++ CUDA code defines a simple kernel that adds the elements of two arrays and demonstrates the use of Unified Memory.","type":"text"}]},{"type":"codeBlock","content":[{"text":"#include \n#include \n// Kernel function to add the elements of two arrays\n__global__\nvoid add(int n, float *x, float *y)\n{\n for (int i = 0; i < n; i++)\n y[i] = x[i] + y[i];\n}\n\nint main(void)\n{\n int N = 1<<20;\n float *x, *y;\n\n // Allocate Unified Memory – accessible from CPU or GPU\n cudaMallocManaged(&x, N*sizeof(float));\n cudaMallocManaged(&y, N*sizeof(float));\n\n // initialize x and y arrays on the host\n for (int i = 0; i < N; i++) {\n x[i] = 1.0f;\n y[i] = 2.0f;\n }\n\n // Run kernel on 1M elements on the GPU\n add<<<1, 1>>>(N, x, y);\n\n // Wait for GPU to finish before accessing on host\n cudaDeviceSynchronize();\n\n // Check for errors (all values should be 3.0f)\n float maxError = 0.0f;\n for (int i = 0; i < N; i++)\n maxError = fmax(maxError, fabs(y[i]-3.0f));\n std::cout << \"Max error: \" << maxError << std::endl;\n\n // Free memory\n cudaFree(x);\n cudaFree(y);\n\n return 0;\n}","type":"text"}]},{"type":"paragraph","content":[{"text":"Here's a breakdown of the code:","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Includes:","type":"text"}]},{"type":"paragraph","content":[{"text":"Includes the necessary headers for input/output and mathematical functions.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Kernel Function:","type":"text"}]},{"type":"paragraph","content":[{"text":"This function runs on the GPU and performs element-wise addition of arrays x and y.","type":"text"}]},{"type":"paragraph","content":[{"text":"Note that this implementation is not efficient for parallel execution since it runs a loop on a single thread.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Main Function:","type":"text"}]},{"type":"paragraph","content":[{"text":"N is set to 2","type":"text"},{"text":"20","type":"text","marks":[{"type":"subsup","attrs":{"type":"sup"}}]},{"text":" (1 million elements).","type":"text"}]},{"type":"paragraph","content":[{"text":"Unified Memory is allocated for the arrays x and y, making them accessible from both the CPU and GPU.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Initialize Arrays:","type":"text"}]},{"type":"paragraph","content":[{"text":"The host initializes the arrays x and y with values 1.0 and 2.0, respectively.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Kernel Launch:","type":"text"}]},{"type":"paragraph","content":[{"text":"The kernel is launched with one block and one thread. The device is synchronized to ensure the GPU finishes before accessing the results.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Error Checking:","type":"text"}]},{"type":"paragraph","content":[{"text":"The maximum error is computed to verify that all elements of y have been correctly updated to 3.0.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Memory Cleanup:","type":"text"}]},{"type":"paragraph","content":[{"text":"Frees the allocated Unified Memory for x and y.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Output","type":"text"}]},{"type":"paragraph","content":[{"text":"The program will output the maximum error, which should be very close to 0.0 if the addition was successful.","type":"text"}]},{"type":"paragraph","content":[{"text":"Here is te Slurm Script","type":"text"}]},{"type":"codeBlock","content":[{"text":"#!/bin/bash -l\n#SBATCH --job-name=c++-gpu # create a short name for your job\n#SBATCH --nodes=1 # node count\n#SBATCH --ntasks=1 # total number of tasks across all nodes\n#SBATCH --cpus-per-task=1 # cpu-cores per task (>1 if multi-threaded tasks)\n#SBATCH --gres=gpu:L40S:1 # number of gpus per node\n#SBATCH --mem=4G # total memory (RAM) per node\n#SBATCH --time=00:03:00 # total run time limit (HH:MM:SS)\n#SBATCH --partition=gpu # Queue/Partition\n\nmodule load cuda\n\n##Compile the cuda script using the nvcc compiler\nnvcc matrix_add -o matrix_add.cu\n\n## Run the script\n./matrix_add","type":"text"}]},{"type":"paragraph","content":[{"text":"This slurm script Compiles the CUDA file named matrix_add.cu using the NVIDIA CUDA Compiler (nvcc), outputting an executable named matrix_add and executes the compiled CUDA application.","type":"text"}]},{"type":"paragraph","content":[{"text":"Submit the job:","type":"text"}]},{"type":"codeBlock","content":[{"text":"$ sbatch job.sh","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"R","type":"text"}]},{"type":"paragraph","content":[{"text":"R is already installed in CLUSTER. To use R load the module","type":"text"}]},{"type":"codeBlock","content":[{"text":"module load R/4.2.1\n","type":"text"}]},{"type":"paragraph","content":[{"text":"In this example we will utilizes GPU to compute the means of a list of random vectors. To install","type":"text"}]},{"type":"codeBlock","content":[{"text":"$ module load load R/4.2.1\n$ R\n> install.packages(\"gpuR\")","type":"text"}]},{"type":"paragraph","content":[{"text":"Here is the R code","type":"text"}]},{"type":"codeBlock","content":[{"text":"# Load necessary library\nlibrary(gpuR)\n\n\n# Create a list of random vectors (reduce size for testing)\nvectors <- replicate(500, rnorm(500), simplify = FALSE)\n\n# Define a function to compute the mean of a vector using GPU\nmean_vector_gpu <- function(vec) {\n gpu_vec <- gpuVector(vec, type = \"float\") # Use gpuVector\n mean_value <- mean(gpu_vec) # Compute mean using GPU\n return(as.numeric(mean_value))\n}\n\n# Compute the means of the vectors using GPU\nstart_time <- Sys.time()\nmeans_gpu <- sapply(vectors, mean_vector_gpu)\nend_time <- Sys.time()\n\n# Print the execution time\ncat(\"GPU execution time:\", end_time - start_time, \"\\n\")\n\n","type":"text"}]},{"type":"paragraph","content":[{"text":"Breakdown of the code:","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Load the Necessary Library:","type":"text"}]},{"type":"paragraph","content":[{"text":"library(gpuR) loads the gpuR package, which provides tools for performing GPU-accelerated computations in R. It allows users to utilize the processing power of GPUs for tasks like matrix operations, making computations faster compared to running on a CPU.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Create a List of Random Vectors:","type":"text"}]},{"type":"paragraph","content":[{"text":"This generates a list of 500 random vectors, each containing 500 normally distributed numbers.","type":"text"}]},{"type":"paragraph","content":[{"text":"rnorm(500) creates a vector of 500 random numbers from a standard normal distribution (mean = 0, standard deviation = 1).","type":"text"}]},{"type":"paragraph","content":[{"text":"replicate(500, ...) runs the rnorm(500) function 500 times, creating a list of 500 vectors. The simplify = FALSE argument ensures that the output is a list rather than a matrix.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Define the Mean Calculation Function Using GPU:","type":"text"}]},{"type":"codeBlock","content":[{"text":"mean_vector_gpu <- function(vec) {\n gpu_vec <- gpuVector(vec, type = \"float\") # Use gpuVector\n mean_value <- mean(gpu_vec) # Compute mean using GPU\n return(as.numeric(mean_value))\n}\n","type":"text"}]},{"type":"paragraph","content":[{"text":"This function takes a vector vec as input and computes its mean using the GPU.","type":"text"}]},{"type":"paragraph","content":[{"text":"gpuVector(vec, type = \"float\"): Converts the input vector into a gpuVector, which is a data structure compatible with GPU operations. Specifying type = \"float\" indicates that the data type of the elements is floating-point.","type":"text"}]},{"type":"paragraph","content":[{"text":"mean(gpu_vec): Computes the mean of the GPU vector. This operation takes advantage of the GPU's parallel processing capabilities, which can be much faster than calculating the mean on a CPU for large datasets.","type":"text"}]},{"type":"paragraph","content":[{"text":"as.numeric(mean_value): Converts the result back to a numeric value for easier handling in R.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Compute the Means Using GPU:","type":"text"}]},{"type":"paragraph","content":[{"text":"start_time <- Sys.time(): Records the current time before starting the computation. This is used to measure how long the computation takes.","type":"text"}]},{"type":"paragraph","content":[{"text":"means_gpu <- sapply(vectors, mean_vector_gpu): Applies the mean_vector_gpu function to each vector in the vectors list. The sapply function simplifies the output to a numeric vector containing the means.","type":"text"}]},{"type":"paragraph","content":[{"text":"end_time <- Sys.time(): Records the time after the computation has finished.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Print the Execution Time:","type":"text"}]},{"type":"paragraph","content":[{"text":"This calculates the total execution time by subtracting start_time from end_time and prints the result to the console. The output shows how long the GPU computation took.","type":"text"}]},{"type":"paragraph","content":[{"text":"Here is the Slurm script:","type":"text"}]},{"type":"codeBlock","content":[{"text":"#!/bin/bash -l\n#SBATCH --job-name=mean-vector # create a short name for your job\n#SBATCH --nodes=1 # node count\n#SBATCH --ntasks=1 # total number of tasks across all nodes\n#SBATCH --cpus-per-task=1 # cpu-cores per task (>1 if multi-threaded tasks)\n#SBATCH --gres=gpu:L40S:1 # number of gpus per node\n#SBATCH --mem=4G # total memory (RAM) per node\n#SBATCH --time=00:00:30 # total run time limit (HH:MM:SS)\n#SBATCH --partition=gpu # Queue/Partition\n\n\n# Load the R module\nmodule load R/4.2.1\n\nmodule load cuda\n\n# Run the R script\nRscript mean_vector.R\n\n","type":"text"}]},{"type":"heading","attrs":{"level":1},"content":[{"text":"CPU JOBS","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"R","type":"text"}]},{"type":"paragraph","content":[{"text":"R is already installed in CLUSTER. To use R load the module","type":"text"}]},{"type":"codeBlock","content":[{"text":"module load R/4.2.1\n","type":"text"}]},{"type":"paragraph","content":[{"text":"In this example we will utilizes parallel processing to compute the means of a list of random vectors. To install","type":"text"}]},{"type":"codeBlock","content":[{"text":"$ module load load R/4.2.1\n$ R\n> install.packages(doParallel)\n","type":"text"}]},{"type":"paragraph","content":[{"text":"Here is the R code","type":"text"}]},{"type":"codeBlock","content":[{"text":"mean_vectors.R\nlibrary(foreach)\nlibrary(doParallel)\n\n# Create a list of 1000 random vectors\nvectors <- replicate(1000, rnorm(1000), simplify = FALSE)\n\n# Define a function to compute the mean of a vector\nmean_vector <- function(vec) {\n mean(vec)\n}\n\n# Compute the means of the vectors using foreach with 4 cores\ncl <- makeCluster(4)\nregisterDoParallel(cl)\nstart_time <- Sys.time()\nmeans <- foreach(vec = vectors) %dopar% mean_vector(vec)\nend_time <- Sys.time()\nstopCluster(cl)\n\n# Compute the means of the vectors using a for loop\nstart_time_serial <- Sys.time()\nmeans_serial <- numeric(length(vectors))\nfor (i in seq_along(vectors)) {\n means_serial[i] <- mean_vector(vectors[[i]])\n}\nend_time_serial <- Sys.time()\n\n# Print the execution times\ncat(\"Parallel execution time:\", end_time - start_time, \"\\n\")\ncat(\"Serial execution time:\", end_time_serial - start_time_serial, \"\\n\")\n\n","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Code Breakdown:","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Load Libraries:","type":"text"}]},{"type":"paragraph","content":[{"text":"Loads the necessary libraries for parallel processing.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Generate Random Vectors:","type":"text"}]},{"type":"paragraph","content":[{"text":"Creates a list of 1000 random vectors, each containing 1000 normally distributed numbers.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Define the Mean Function:","type":"text"}]},{"type":"paragraph","content":[{"text":"Defines a function to compute the mean of a vector.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Parallel Mean Calculation:","type":"text"}]},{"type":"paragraph","content":[{"text":"Creates a cluster with 4 cores.","type":"text"}]},{"type":"paragraph","content":[{"text":"Registers the cluster for parallel processing.","type":"text"}]},{"type":"paragraph","content":[{"text":"Measures the execution time for computing the means in parallel using foreach.","type":"text"}]},{"type":"paragraph","content":[{"text":"Stops the cluster after the computation.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Serial Mean Calculation:","type":"text"}]},{"type":"paragraph","content":[{"text":"Measures the execution time for computing the means serially using a for loop.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Print Execution Times:","type":"text"}]},{"type":"paragraph","content":[{"text":"Outputs the execution times for both parallel and serial computations.","type":"text"}]},{"type":"paragraph","content":[{"text":"Here is the slurm script","type":"text"}]},{"type":"codeBlock","content":[{"text":"#!/bin/bash\n#SBATCH --job-name=mean_vectors # Job name\n#SBATCH --output=mean_vectors.out # Standard output and error log\n#SBATCH --ntasks=1 # Run on a single task\n#SBATCH --cpus-per-task=4 # Number of CPU cores\n#SBATCH --time=00:05:00 # Time limit hrs:min:sec\n#SBATCH --mem=4G # Memory limit\n\n# Load the R module\nmodule load load R/4.2.1\n\n# Run the R script\nRscript mean_vectors.R\n\n","type":"text"}]},{"type":"paragraph","content":[{"text":"This slurm script allocates 4 CPU cores for this task, which matches the parallel processing in R script","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Numpy","type":"text"}]},{"type":"paragraph","content":[{"text":"In this example we will perform a Singular Value Decomposition (SVD) on a randomly generated matrix using Numpy.","type":"text"}]},{"type":"codeBlock","content":[{"text":"from time import perf_counter\n\nN = 2000\ncpu_runs = 5\n\ntimes = []\nimport numpy as np\nX = np.random.randn(N, N).astype(np.float64)\nfor _ in range(cpu_runs):\n t0 = perf_counter()\n u, s, v = np.linalg.svd(X)\n times.append(perf_counter() - t0)\n\nprint(\"CPU Execution time: \", min(times))\nprint(\"sum(s) = \", s.sum())\nprint(\"NumPy version: \", np.__version__)\n","type":"text"}]},{"type":"paragraph","content":[{"text":"Here’s a breakdown of of code:","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Imports and Setup:","type":"text"}]},{"type":"paragraph","content":[{"text":"Import perf_counter for timing, and set up a matrix of size 2000x2000 filled with random values from a normal distribution.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"SVD Computation:","type":"text"}]},{"type":"paragraph","content":[{"text":"Run the SVD computation five times, timing each run and storing the times in a list.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Results:","type":"text"}]},{"type":"paragraph","content":[{"text":"Finally, print the minimum execution time, the sum of the singular values, and the version of NumPy being used.","type":"text"}]},{"type":"paragraph","content":[{"text":"Here is slurm script","type":"text"}]},{"type":"codeBlock","content":[{"text":"#!/bin/bash -l\n#SBATCH --job-name=numpy-cpu # create a short name for your job\n#SBATCH --nodes=1 # node count\n#SBATCH --ntasks=1 # total number of tasks across all nodes\n#SBATCH --cpus-per-task=1 # cpu-cores per task (>1 if multi-threaded tasks)\n#SBATCH --mem=4G # total memory (RAM) per node\n#SBATCH --time=00:00:30 # total run time limit (HH:MM:SS)\n\nmodule load conda/3\nconda activate /users/sysops/tmp/workshop/cupyenv\n\npython svd.py","type":"text"}]},{"type":"paragraph"}],"version":1}

Browser not supported