Input: Output: 1. Sub String Program

#define SIZE 4
__global__ void dotProduct(int *a, int *b, int *c)

{
int i = threadIdx.x;
*c += a[i]*b[i];
//atomicAdd(c, a[i]*b[i])
}
int main()
{
int a[SIZE] = {1,2,3,4};
int b[SIZE] = {1,2,3,4};
int c = 0;
int *da, *db, *dc, size = SIZE*sizeof(int);

cudaMalloc((void **)&da, size);
cudaMemcpy(da, a, size, cudaMemcpyHostToDevice);
cudaMalloc((void **)&db, size);
cudaMemcpy(db, b, size, cudaMemcpyHostToDevice);
cudaMalloc((void **)&dc, sizeof(int));
cudaMemcpy(dc, &c, sizeof(int), cudaMemcpyHostToDevice);
dotProduct<<<1,SIZE>>>(da, db, dc);

cudaMemcpy(&c, dc, sizeof(int), cudaMemcpyDeviceToHost);
cout<<"Dot Product : "<<c;
return 0;
}
Input:
Output:
Dot Product: 30
1. Sub String
Program:
__global__ void subString(char *da, char *db, int lena, int lenb, int *count)
{
int i = threadIdx.x, c = 0;
for (int j = 0; j<lenb; i++, j++)

if (da[i] == db[j])
c++;
if (c == lenb)
count++;
// atomicAdd(count, 1);
}
int main()
{
char a[] = "HaiHelloHowru", b[] = "H";
int lena = strlen(a), lenb = strlen(b);
cout << a << "\t" << lena << endl << b << "\t" << lenb << endl;
char *da, *db;

cudaMalloc((void**)&da, lena);
cudaMemcpy(da, a, lena, cudaMemcpyHostToDevice);
cudaMalloc((void**)&db, lenb);
cudaMemcpy(db, b, lenb, cudaMemcpyHostToDevice);
int c = 0, *dc;
cudaMalloc((void **)&dc, sizeof(int));
cudaMemcpy(dc, &c, sizeof(int), cudaMemcpyHostToDevice);
subString << <1, lena - lenb >> >(da, db, lena, lenb, dc);
cudaMemcpy(&c, dc, sizeof(int), cudaMemcpyDeviceToHost);
cudaDeviceSynchronize();
cout << "\nCount : " << c;
return 0;
}
Input:
Output:
HaiHelloHowru 13 H 1
Count : 3
2. Matrix Multiplication
Program:
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;
#define SIZE 20
#define TILESIZE 2
#define WINDOW 2
__global__ void matMul(int *a, int *b, int *c)

{
int i = blockIdx.x * blockDim.x + threadIdx.x;
if (i < SIZE)
for (int j = 0; j<SIZE; j++)
for (int k = 0; k<SIZE; k++)
c[i*SIZE + j] += a[i*SIZE + k] * b[k*SIZE + j];
}
__global__ void matMul2D(int *a, int *b, int *c)

{
int j = blockIdx.x * blockDim.x + threadIdx.x;
int i = blockIdx.y * blockDim.y + threadIdx.y;
int I = i*WINDOW;
int J = j*WINDOW;
int m = I + WINDOW, n = J + WINDOW, k;
if (I < SIZE && J < SIZE)

for (i = I; i<m && i<SIZE; i++)
for (j = J; j<n && j<SIZE; j++)
for (k = 0; k<SIZE; k++)
c[i*SIZE + j] += a[i*SIZE + k] * b[k*SIZE + j];
}
void printMatrix(int *a)
{
for (int i = 0; i<SIZE; i++)
{
for (int j = 0; j<SIZE; j++)
cout << *a++ << "\t";
cout << endl;
}
}
//
int main()
{
int a[SIZE*SIZE], b[SIZE*SIZE], c[SIZE*SIZE], d[SIZE*SIZE];
int i, j, k = 0;
for (i = 0; i<SIZE; i++)

for (j = 0; j<SIZE; j++)
{
a[i*SIZE + j] = 1;
b[i*SIZE + j] = k++;
c[i*SIZE + j] = d[i*SIZE + j] = 0;
}
int *da, *db, *dc;
int size = SIZE*SIZE*sizeof(int);
cudaMalloc(&da, size);
cudaMalloc(&db, size);
cudaMalloc(&dc, size);

cudaMemcpy(db, b, size, cudaMemcpyHostToDevice);
cudaMemcpy(dc, c, size, cudaMemcpyHostToDevice);
/* dim3 block(TILESIZE);
dim3 grid(SIZE/TILESIZE+1);
matMul<<<grid,block>>>(da, db, dc);
cudaMemcpy(c, dc, size, cudaMemcpyDeviceToHost);
cudaMemcpy(dc, d, size, cudaMemcpyHostToDevice);*/

dim3 block2D(TILESIZE, TILESIZE);
dim3 grid2D(SIZE / (TILESIZE*WINDOW) + 1, SIZE / (TILESIZE*WINDOW) + 1);
matMul2D << <grid2D, block2D >> >(da, db, dc);
cudaMemcpy(d, dc, size, cudaMemcpyDeviceToHost);
/* cout<<endl;
printMatrix(c);
cout<<endl;
printMatrix(d);*/
}
Input
Matrix A
22222
22222
22222
22222
22222
Matrix B
11111
11111
11111
11111
11111
Output:
Matrix C
10 10 10 10 10
10 10 10 10 10
10 10 10 10 10
10 10 10 10 10
10 10 10 10 10
3. Quick Sort
Program
#define N 5
using namespace std;
__global__ void quickSort(int *x, int *dfirst, int *dlast, int *list)
{
int idx = threadIdx.x;
int first = dfirst[idx];
int last = dlast[idx];
list[idx] = 0;
if(first<last)
{
int pivot, j, temp, i;
pivot = first;
i = first;
j = last;
while(i<j)
{
while(x[i]<=x[pivot] && i<last)
i++;
while(x[j] > x[pivot])
j--;
if(i<j)
{
temp = x[i];
x[i] = x[j];
x[j] = temp;
}
}
temp = x[pivot];
x[pivot] = x[j];
x[j] = temp;
for(i=first; i<=last; i++)

if(x[i] > x[i+1])
{
list[idx] = j+1;
break;
}
}
}
int main()
{
int a[N] = {1, 5, 9, 3, 6}, *da, i, size = N*sizeof(int), len = 0;
int *list, *dlist, *dfirst, *dlast;
cudaMalloc(&da, size);
vector<int> v;
while(true)
{
size = (++len)*sizeof(int);
int *first = (int *)malloc(size);

int *last = (int *)malloc(size);
first[0] = 0;
last[len-1] = N-1;
for(i=0; i<v.size(); i++)

{
first[i+1] = v[i]+1;
last[i] = v[i]-1;
}
cudaMalloc(&dfirst, size);
cudaMemcpy(dfirst, first, size, cudaMemcpyHostToDevice);
cudaMalloc(&dlast, size);
cudaMemcpy(dlast, last, size, cudaMemcpyHostToDevice);
cudaMalloc(&dlist, size);
quickSort<<<1,len>>>(da, dfirst, dlast, dlist);
list = (int *)malloc(size);

cudaMemcpy(list, dlist, size, cudaMemcpyDeviceToHost);
v.clear();
for(i=0; i<len; i++)
if(list[i] != 0)
v.push_back(list[i]-1);
len = v.size();
if(len == 0)
break;
}
cudaMemcpy(a, da, N*sizeof(int), cudaMemcpyDeviceToHost);

for(i=0; i<N; i++)
printf("%d\t", a[i]);
}
Input:
15936
Output:
13569
4. Gauss Elimination
Program
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <stdio.h>
#define N 4
#define M N+1
__global__ void ge(float *A, int i)

{
for (int j = blockIdx.x + i + 1; j<N; j += gridDim.x)
{
float ratio = A[j*(N + 1) + i] / A[i*(N + 1) + i];
for (int k = threadIdx.x + i; k <= N; k += blockDim.x)
A[j*(N + 1) + k] -= ratio*A[i*(N + 1) + k];
}
}
void print(float *A)

{
for (int i = 0; i<N; i++)
{
for (int j = 0; j<N + 1; j++)
printf("%f ", A[i*(N + 1) + j]);
printf("\n");
}
printf("\n");
}
int main()
{
float A[N*(N + 1)] = { 2, 1, -1, 2, 5, 4, 5, -3, 6, 9, -2, 5, -2, 6,
4, 4, 11, -4, 8, 2 };
float *dev_a;
int size = N*(N + 1)*sizeof(float), i, j;
print(A);
cudaMalloc(&dev_a, size);
cudaMemcpy(dev_a, A, size, cudaMemcpyHostToDevice);
for (i = 0; i<N - 1; i++)

ge << <N - 1 - i, N - i + 1 >> >(dev_a, i);
cudaMemcpy(A, dev_a, size, cudaMemcpyDeviceToHost);

print(A);
for (i = N - 1; i >= 0; i--)

{
for (j = N - 1; j >= i + 1; j--)
A[i*(N + 1) + N] -= A[i*(N + 1) + j];
A[i*(N + 1) + N] /= A[i*(N + 1) + j];
printf("x%d=%.1f\n", i, A[i*(N + 1) + N]);
for (j = i - 1; j >= 0; j--)

A[j*(N + 1) + i] *= A[i*(N + 1) + N];
}
return 0;
}

Input: Output: 1. Sub String Program

Uploaded by

Copyright:

Available Formats

Input: Output: 1. Sub String Program

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Input: Output: 1. Sub String Program

Uploaded by

Copyright:

Available Formats

#define SIZE 4

__global__ void dotProduct(int *a, int *b, int *c)

int *da, *db, *dc, size = SIZE*sizeof(int);

dotProduct<<<1,SIZE>>>(da, db, dc);

for (int j = 0; j<lenb; i++, j++)

char *da, *db;

cudaMemcpy(&c, dc, sizeof(int), cudaMemcpyDeviceToHost);

cout << "\nCount : " << c;

__global__ void matMul(int *a, int *b, int *c)

__global__ void matMul2D(int *a, int *b, int *c)

if (I < SIZE && J < SIZE)

for (i = 0; i<SIZE; i++)

cudaMemcpy(da, a, size, cudaMemcpyHostToDevice);

cudaMemcpy(dc, d, size, cudaMemcpyHostToDevice);*/

using namespace std;

for(i=first; i<=last; i++)

int *first = (int *)malloc(size);

for(i=0; i<v.size(); i++)

quickSort<<<1,len>>>(da, dfirst, dlast, dlist);

list = (int *)malloc(size);

cudaMemcpy(a, da, N*sizeof(int), cudaMemcpyDeviceToHost);

__global__ void ge(float *A, int i)

void print(float *A)

for (i = 0; i<N - 1; i++)

cudaMemcpy(A, dev_a, size, cudaMemcpyDeviceToHost);

for (i = N - 1; i >= 0; i--)

for (j = i - 1; j >= 0; j--)

You might also like

global void dotProduct(int a, int b, int *c)

int da, db, dc, size = SIZEsizeof(int);

char da, db;

global void matMul(int a, int b, int *c)

global void matMul2D(int a, int b, int *c)

int first = (int )malloc(size);

global void ge(float *A, int i)