GPU Jobs

vi script.sh

#!/bin/bash

##Resource Request

#SBATCH --job-name CudaJob
#SBATCH --output result.out   ## filename of the output; the %j is equivalent to jobID; default is slurm-[jobID].out
#SBATCH --partition=backfill  ## the partitions to run in (comma seperated)
#SBATCH --ntasks=1  ## number of tasks (analyses) to run
#SBATCH --gpus-per-task=1 # number of gpus per task
#SBATCH --constraint=v100 # select node with v100 GPU
#SBATCH --mem-per-gpu=100M # Memory allocated for the job
#SBATCH --time=0-00:10:00  ## time for analysis (day-hour:min:sec)

##Load the CUDA module
module load cuda

##Compile the cuda script using the nvcc compiler
nvcc -o stats stats.cu

## Run the script
srun stats

vi stats.cu

#include <stdio.h>
#include <cuda_runtime.h>

void printDeviceInfo(cudaDeviceProp prop) {

   printf("Name                         - %s\n",  prop.name);
   printf("Total global memory          - %lu MB \n", prop.totalGlobalMem/(1024*1024));
   printf("Total constant memory        - %lu KB \n", prop.totalConstMem/1024);

   printf("Shared memory per block      - %lu KB \n", prop.sharedMemPerBlock/1024);
   printf("Total registers per block    - %d\n", prop.regsPerBlock);
   printf("Maximum threads per block    - %d\n", prop.maxThreadsPerBlock);

   printf("Clock rate                   - %d\n",  prop.clockRate);
   printf("Number of multi-processors   - %d\n",  prop.multiProcessorCount);

  }

int main( ) {

    int deviceCount;
    cudaGetDeviceCount(&deviceCount);
    printf("Available CUDA devices - %d\n", deviceCount);
    for (int i=0;i<deviceCount;i++){

        // Device informatioon
        printf("\nCUDA Device #%d\n", i);
        cudaDeviceProp prop;
        cudaGetDeviceProperties(&prop, i);
        printDeviceInfo(prop);

    }
}

vi script.sh

#!/bin/bash

##Resource Request

#SBATCH --job-name CudaJob
#SBATCH --output result.out   ## filename of the output; the %j is equal to jobID; default is slurm-[jobID].out
#SBATCH --ntasks=2  ## number of tasks (analyses) to run
#SBATCH --gpus-per-task=1 # number of gpus per task
#SBATCH --mem-per-gpu=100M # Memory allocated per gpu
#SBATCH --constraint=mig # Select Node with Multi-Instance GPU
#SBATCH --partition=backfill  ## the partitions to run in (comma seperated)
#SBATCH --time=0-00:10:00  ## time for analysis (day-hour:min:sec)

##Load the modules
module load cuda

##Compile the cuda script
nvcc -o add add.cu

## Run the script
srun -n 1 add 1 &
srun -n 1 add 2 &
wait

vi add.cu

#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <stdio.h>

__global__ void addKernel(int* c, const int* a, const int* b, int size) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < size) {
        c[i] = a[i] + b[i];
    }
}

// Helper function for using CUDA to add vectors in parallel.
void addWithCuda(int* c, const int* a, const int* b, int size) {
    int* dev_a = NULL;
    int* dev_b = NULL;
    int* dev_c = NULL;

    // Allocate GPU buffers for three vectors (two input, one output)
    cudaMalloc((void**)&dev_c, size * sizeof(int));
    cudaMalloc((void**)&dev_a, size * sizeof(int));
    cudaMalloc((void**)&dev_b, size * sizeof(int));

    // Copy input vectors from host memory to GPU buffers.
    cudaMemcpy(dev_a, a, size * sizeof(int), cudaMemcpyHostToDevice);
    cudaMemcpy(dev_b, b, size * sizeof(int), cudaMemcpyHostToDevice);

    // Launch a kernel on the GPU with one thread for each element.
    // 2 is number of computational blocks and (size + 1) / 2 is a number of threads in a block
    addKernel<<<2, (size + 1) / 2>>>(dev_c, dev_a, dev_b, size);

    // cudaDeviceSynchronize waits for the kernel to finish, and returns
    // any errors encountered during the launch.
    cudaDeviceSynchronize();

    // Copy output vector from GPU buffer to host memory.
    cudaMemcpy(c, dev_c, size * sizeof(int), cudaMemcpyDeviceToHost);

    cudaFree(dev_c);
    cudaFree(dev_a);
    cudaFree(dev_b);
}

int main(int argc, char** argv) {
    const int arraySize = 5;
    const int a[arraySize] = {  1,  2,  3,  4,  5 };
    const int b[arraySize] = { 10, 20, 30, 40, 50 };
    const int c[arraySize] = {11, 12, 13, 14, 15};
    const int d[arraySize] = {100, 200, 300, 400, 500};

    int result[arraySize] = { 0 };
    int input = atoi(argv[1]);

    if (input == 1) {
    	addWithCuda(result, a, b, arraySize);
    }
    else {
    	addWithCuda(result, c, d, arraySize);
    }
    //Printing the output
    printf("Addition of two arrays = {%d, %d, %d, %d, %d}\n", result[0], result[1], result[2], result[3], result[4]);

    cudaDeviceReset();

    return 0;
}