使用CUDA C进行并行编程

#include<iostream>
#include<cuda.h>
#include<cuda_runtime.h>
__global__ void gpuAdd(int d_a, int d_b, int* d_c) {
    *d_c = d_a + d_b;
}

            int main(void) {
    //定义主机变量，统一以h_开头int h_c;
    //定义设备变量，统一以d_开头，作为参数传递给内核的指针应该仅指向设备显存int* d_c;
    //在设备上分配d_c变量的内存，cudaMalloc类似于C中的malloc函数
    //分配了一个整数变量大小的内存块，并返回指向该内存位置的指针d_c
    cudaMalloc((void**)&d_c, sizeof(int));
    //调用gpuAdd，其中1和4是两个输入变量，d_c是一个作为输出指针变量的设备显存指针
    //
    gpuAdd << <1, 1 >> > (1, 4, d_c);
    //将结果从设备内存复制到主机内存中
    cudaMemcpy(&h_c, d_c, sizeof(int), cudaMemcpyDeviceToHost);
    //释放设备上通过cudaMalloc使用的所有内存    cudaFree(d_c);
    return0;
}

gpuAdd << <1, 1 >> > (1, 4, d_c)

#include "stdio.h"
#include<iostream>
//定义向量元素个数#define N    5
//定义CPU向量加法void cpuAdd(int *h_a, int *h_b, int *h_c) {
    int tid = 0;    
    while (tid < N)
    {
        h_c[tid] = h_a[tid] + h_b[tid];
        tid += 1;
    }
}

int main(void) {
    int h_a[N], h_b[N], h_c[N];
        //向量初始化for (int i = 0; i < N; i++) {
        h_a[i] = 2 * i*i;
        h_b[i] = i;
    }
    //调用CPU向量加法函数    cpuAdd (h_a, h_b, h_c);
    //输出结果
    printf("Vector addition on CPU\n");
    for (int i = 0; i < N; i++) {
        printf("The sum of %d element is %d + %d = %d\n", i, h_a[i], h_b[i], h_c[i]);
    }
    return0;
}

#include "stdio.h"
#include<iostream>
#include <cuda.h>
#include <cuda_runtime.h>
//定义向量元素个数#define N 5
//定义向量加法内核函数
__global__ void gpuAdd(int *d_a, int *d_b, int *d_c) {
    //获取当前内核的块IDint tid = blockIdx.x;    //在当前块ID来初始化tid
    //因为是同时启动的，每个块必须直到自己要处理的数据是什么
if (tid < N)
        d_c[tid] = d_a[tid] + d_b[tid];
}

int main(void) {
    //定义主机变量int h_a[N], h_b[N], h_c[N];
    //定义设备指针，指向cudaMalloc分配的显存int *d_a, *d_b, *d_c;
    //给设备变量分配内存
    cudaMalloc((void**)&d_a, N * sizeof(int));
    cudaMalloc((void**)&d_b, N * sizeof(int));
    cudaMalloc((void**)&d_c, N * sizeof(int));
    //主机向量初始化for (int i = 0; i < N; i++) {
        h_a[i] = 2*i*i;
        h_b[i] = i ;
    }
    //将主机向量复制到设备向量中
    cudaMemcpy(d_a, h_a, N * sizeof(int), cudaMemcpyHostToDevice);
    cudaMemcpy(d_b, h_b, N * sizeof(int), cudaMemcpyHostToDevice);
    //使用内核启动符号<<<>>>调用内核函数，启动N个块（和向量长度一样，使用不同的块并行处理向量N个位置的加法），每个块1个线程，传递参数为设备指针
    gpuAdd << <N, 1 >> >(d_a, d_b, d_c);
    //将结果从设备内存复制到主机内存中
    cudaMemcpy(h_c, d_c, N * sizeof(int), cudaMemcpyDeviceToHost);

    printf("Vector addition on GPU \n");
    //在控制台中输出结果for (int i = 0; i < N; i++) {
        printf("The sum of %d element is %d + %d = %d\n", i, h_a[i], h_b[i], h_c[i]);
    }
    //释放内存    cudaFree(d_a);
    cudaFree(d_b);
    cudaFree(d_c);
    return0;
}

#include "stdio.h"
#include<iostream>
#include <cuda.h>
#include <cuda_runtime.h>
//定义向量元素个数#define N    5
//平方内核函数
__global__ void gpuSquare(float *d_in, float *d_out) {
    //获取当前调用内核函数启动的线程IDint tid = threadIdx.x;    //使用内核函数计算线程ID对应的向量中的元素float temp = d_in[tid];
    d_out[tid] = temp*temp;
}

int main(void) {
    //定义主机向量float h_in[N], h_out[N];
    //定义设备指针float *d_in, *d_out;

    //在CPU上分配内存
    cudaMalloc((void**)&d_in, N * sizeof(float));
    cudaMalloc((void**)&d_out, N * sizeof(float));
    //Initializing Arrayfor (int i = 0; i < N; i++) {
        h_in[i] = i;
    }
    //将主机上的数组复制到设备上
    cudaMemcpy(d_in, h_in, N * sizeof(float), cudaMemcpyHostToDevice);
    //调用1个块，N个线程的内核函数
    gpuSquare << <1, N >> >(d_in, d_out);
    //将设备上的结果复制到主机内存上
    cudaMemcpy(h_out, d_out, N * sizeof(float), cudaMemcpyDeviceToHost);
    //控制台输出结果
    printf("Square of Number on GPU \n");
    for (int i = 0; i < N; i++) {
        printf("The square of %f is %f\n", h_in[i], h_out[i]);
    }
    //释放内存    cudaFree(d_in);
    cudaFree(d_out);
    return0;
}

d_out[i] = d_in[i] * 2;

            out[i] = (in[i - 1] + in[i] + in[i + 1]) / 3;

            out[i - 1] += 2 * in[i] and out[i + 1] += 3 * in[i];