Name: Maryam Asad

Reg. no.: COSC211101083

Course Instructor: Sir Ahsan Aslam

Due Date: 30th December, 2024 (14:00 hours)

1. Host to Device Code Conversions

Example 1: Basic Vector Addition

Host Code (CPU)

#include <iostream>

void vectorAdd(float* A, float* B, float* C, int N) {

for (int i = 0; i < N; ++i) {
C[i] = A[i] + B[i];
}
}

int main() {
int N = 1000;
float A[N], B[N], C[N];
// Initialize A and B arrays
vectorAdd(A, B, C, N);
return 0;
}

Device Code (GPU)

#include <iostream>

__global__ void vectorAddKernel(float* A, float* B, float* C, int N) {

int idx = threadIdx.x + blockIdx.x * blockDim.x;
if (idx < N) {
C[idx] = A[idx] + B[idx];
}
}

int main() {
int N = 1000;
float *d_A, *d_B, *d_C;
float A[N], B[N], C[N];

// Allocate device memory

cudaMalloc((void**)&d_A, N * sizeof(float));
cudaMalloc((void**)&d_B, N * sizeof(float));
cudaMalloc((void**)&d_C, N * sizeof(float));

// Copy data to device

cudaMemcpy(d_A, A, N * sizeof(float), cudaMemcpyHostToDevice);
cudaMemcpy(d_B, B, N * sizeof(float), cudaMemcpyHostToDevice);

// Launch the kernel

vectorAddKernel<<<(N + 255) / 256, 256>>>(d_A, d_B, d_C, N);

// Copy result back to host

cudaMemcpy(C, d_C, N * sizeof(float), cudaMemcpyDeviceToHost);

// Free device memory

cudaFree(d_A);
cudaFree(d_B);
 cudaFree(d_C);

return 0;
}

Example 2: Array Initialization and Summation

Host Code (CPU)

#include <iostream>

int main() {
const int N = 1000;
int A[N];
int sum = 0;

// Initialize array A
for (int i = 0; i < N; ++i) {
A[i] = i;
}

// Calculate sum of A
for (int i = 0; i < N; ++i) {
sum += A[i];
}

std::cout << "Sum: " << sum << std::endl;

return 0;
}

Device Code (GPU)

#include <iostream>

__global__ void sumKernel(int* A, int* sum, int N) {

int idx = threadIdx.x + blockIdx.x * blockDim.x;
if (idx < N) {
atomicAdd(sum, A[idx]);
}
}

int main() {
const int N = 1000;
int *d_A, *d_sum;
int A[N];
int sum = 0;

// Initialize array A
for (int i = 0; i < N; ++i) {
A[i] = i;
}

// Allocate device memory

cudaMalloc((void**)&d_A, N * sizeof(int));
cudaMalloc((void**)&d_sum, sizeof(int));

// Initialize sum to 0 on device

cudaMemcpy(d_sum, &sum, sizeof(int), cudaMemcpyHostToDevice);
 // Copy data to device
cudaMemcpy(d_A, A, N * sizeof(int), cudaMemcpyHostToDevice);

// Launch kernel
sumKernel<<<(N + 255) / 256, 256>>>(d_A, d_sum, N);

// Copy result back to host

cudaMemcpy(&sum, d_sum, sizeof(int), cudaMemcpyDeviceToHost);

std::cout << "Sum: " << sum << std::endl;

// Free device memory

cudaFree(d_A);
cudaFree(d_sum);

return 0;
}

Example 3: Parallel Array Scaling

Host Code (CPU)

#include <iostream>

void scaleArray(int* A, int scale, int N) {

for (int i = 0; i < N; ++i) {
A[i] *= scale;
}
}

int main() {
const int N = 1000;
int A[N];

// Initialize array A
for (int i = 0; i < N; ++i) {
A[i] = i;
}

int scale = 2;
scaleArray(A, scale, N);

return 0;
}

Device Code (GPU)

#include <iostream>

__global__ void scaleArrayKernel(int* A, int scale, int N) {

int idx = threadIdx.x + blockIdx.x * blockDim.x;
if (idx < N) {
A[idx] *= scale;
}
}

int main() {
 const int N = 1000;
int *d_A;
int A[N];

// Initialize array A
for (int i = 0; i < N; ++i) {
A[i] = i;
}

int scale = 2;

// Allocate device memory

cudaMalloc((void**)&d_A, N * sizeof(int));

// Copy data to device

cudaMemcpy(d_A, A, N * sizeof(int), cudaMemcpyHostToDevice);

// Launch kernel
scaleArrayKernel<<<(N + 255) / 256, 256>>>(d_A, scale, N);

// Copy result back to host

cudaMemcpy(A, d_A, N * sizeof(int), cudaMemcpyDeviceToHost);

// Free device memory

cudaFree(d_A);

return 0;
}

Example 4: Matrix Transposition

Host Code (CPU)

#include <iostream>

void transposeMatrix(int* A, int* B, int N) {

for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
B[j * N + i] = A[i * N + j];
}
}
}

int main() {
const int N = 3;
int A[N * N] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int B[N * N];

transposeMatrix(A, B, N);

return 0;
}

Device Code (GPU)

#include <iostream>

__global__ void transposeMatrixKernel(int* A, int* B, int N) {

 int idx = threadIdx.x + blockIdx.x * blockDim.x;
int idy = threadIdx.y + blockIdx.y * blockDim.y;

if (idx < N && idy < N) {

B[idy * N + idx] = A[idx * N + idy];
}
}

int main() {
const int N = 3;
int *d_A, *d_B;
int A[N * N] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int B[N * N];

// Allocate device memory

cudaMalloc((void**)&d_A, N * N * sizeof(int));
cudaMalloc((void**)&d_B, N * N * sizeof(int));

// Copy data to device

cudaMemcpy(d_A, A, N * N * sizeof(int), cudaMemcpyHostToDevice);

// Launch kernel
dim3 block(1, 1);
dim3 grid(N, N);
transposeMatrixKernel<<<grid, block>>>(d_A, d_B, N);

// Copy result back to host

cudaMemcpy(B, d_B, N * N * sizeof(int), cudaMemcpyDeviceToHost);

// Free device memory

cudaFree(d_A);
cudaFree(d_B);

return 0;
}

Example 5: Finding the Maximum Value

Host Code (CPU)

#include <iostream>

int findMax(int* A, int N) {

int maxVal = A[0];
for (int i = 1; i < N; ++i) {
if (A[i] > maxVal) {
maxVal = A[i];
}
}
return maxVal;
}

int main() {
const int N = 1000;
int A[N];

// Initialize array A
for (int i = 0; i < N; ++i) {
A[i] = i;
 }

int maxVal = findMax(A, N);

std::cout << "Max Value: " << maxVal << std::endl;

return 0;
}

Device Code (GPU)

#include <iostream>

__global__ void findMaxKernel(int* A, int* maxVal, int N) {

int idx = threadIdx.x + blockIdx.x * blockDim.x;
if (idx < N) {
atomicMax(maxVal, A[idx]);
}
}

int main() {
const int N = 1000;
int *d_A, *d_maxVal;
int A[N];
int maxVal = 0;

// Initialize array A
for (int i = 0; i < N; ++i) {
A[i] = i;
}

// Allocate device memory

cudaMalloc((void**)&d_A, N * sizeof(int));
cudaMalloc((void**)&d_maxVal, sizeof(int));

// Initialize maxVal to 0 on device

cudaMemcpy(d_maxVal, &maxVal, sizeof(int), cudaMemcpyHostToDevice);

// Copy data to device

cudaMemcpy(d_A, A, N * sizeof(int), cudaMemcpyHostToDevice);

// Launch kernel
findMaxKernel<<<(N + 255) / 256, 256>>>(d_A, d_maxVal, N);

// Copy result back to host

cudaMemcpy(&maxVal, d_maxVal, sizeof(int), cudaMemcpyDeviceToHost);

std::cout << "Max Value: " << maxVal << std::endl;

// Free device memory

cudaFree(d_A);
cudaFree(d_maxVal);

return 0;
}

2. Matrix Multiplication Examples in Device Code

Matrix Multiplication (Example 1)

Device Code (GPU)

#include <iostream>

__global__ void matrixMultiplyKernel(int* A, int* B, int* C, int N) {

int row = threadIdx.x + blockIdx.x * blockDim.x;
int col = threadIdx.y + blockIdx.y * blockDim.y;
if (row < N && col < N) {
int val = 0;
for (int k = 0; k < N; ++k) {
val += A[row * N + k] * B[k * N + col];
}
C[row * N + col] = val;
}
}

int main() {
const int N = 3;
int *d_A, *d_B, *d_C;
int A[N * N] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int B[N * N] = {9, 8, 7, 6, 5, 4, 3, 2, 1};
int C[N * N] = {0};

// Allocate device memory

cudaMalloc((void**)&d_A, N * N * sizeof(int));
cudaMalloc((void**)&d_B, N * N * sizeof(int));
cudaMalloc((void**)&d_C, N * N * sizeof(int));

// Copy data to device

cudaMemcpy(d_A, A, N * N * sizeof(int), cudaMemcpyHostToDevice);
cudaMemcpy(d_B, B, N * N * sizeof(int), cudaMemcpyHostToDevice);

// Launch kernel
dim3 block(1, 1);
dim3 grid(N, N);
matrixMultiplyKernel<<<grid, block>>>(d_A, d_B, d_C, N);

// Copy result back to host

cudaMemcpy(C, d_C, N * N * sizeof(int), cudaMemcpyDeviceToHost);

// Free device memory

cudaFree(d_A);
cudaFree(d_B);
cudaFree(d_C);

return 0;
}

Matrix Multiplication (Example 2)

Device Code (GPU)

#include <iostream>

__global__ void matrixMultiplyKernel(int* A, int* B, int* C, int N) {

int row = threadIdx.x + blockIdx.x * blockDim.x;
 int col = threadIdx.y + blockIdx.y * blockDim.y;
if (row < N && col < N) {
int value = 0;
for (int i = 0; i < N; i++) {
value += A[row * N + i] * B[i * N + col];
}
C[row * N + col] = value;
}
}

int main() {
const int N = 4;
int *d_A, *d_B, *d_C;
int A[N * N] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
int B[N * N] = {16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
int C[N * N] = {0};

// Allocate device memory

cudaMalloc((void**)&d_A, N * N * sizeof(int));
cudaMalloc((void**)&d_B, N * N * sizeof(int));
cudaMalloc((void**)&d_C, N * N * sizeof(int));

// Copy data to device

cudaMemcpy(d_A, A, N * N * sizeof(int), cudaMemcpyHostToDevice);
cudaMemcpy(d_B, B, N * N * sizeof(int), cudaMemcpyHostToDevice);

// Launch kernel
dim3 block(2, 2);
dim3 grid(N / 2, N / 2);
matrixMultiplyKernel<<<grid, block>>>(d_A, d_B, d_C, N);

// Copy result back to host

cudaMemcpy(C, d_C, N * N * sizeof(int), cudaMemcpyDeviceToHost);

// Free device memory

cudaFree(d_A);
cudaFree(d_B);
cudaFree(d_C);

return 0;
}