首先是cuda程式設計，分三步，把資料從記憶體拷貝進視訊記憶體，GPU進行計算，將結果從視訊記憶體拷貝回記憶體。

cuda-C程式氣泡排序案例：

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

#include <stdio.h>
#include <stdlib.h>

#define N 400
void random_ints(int *);

__global__ void myKernel(int *d_a)
{
	__shared__ int s_a[N]; //定義共享變數
	int tid = threadIdx.x;
	s_a[tid] = d_a[tid]; //每個執行緒搬運對應的資料到共享記憶體中
	__syncthreads(); //執行緒同步

	for (int i = 1; i <= N; i++) { //最多N次排序完成

		if (i % 2 == 1 && (2 * tid + 1) < N) { //奇數步
			if (s_a[2 * tid] > s_a[2 * tid + 1]) {
				int temp = s_a[2 * tid];
				s_a[2 * tid] = s_a[2 * tid+1];
				s_a[2 * tid + 1] = temp;
			}
		} 
		__syncthreads(); //執行緒同步
		if (i % 2 == 0 && (2 * tid + 2) < N ) { //偶數步
			if (s_a[2 * tid+1] > s_a[2 * tid + 2]) {
				int temp = s_a[2 * tid+1];
				s_a[2 * tid+1] = s_a[2 * tid + 2];
				s_a[2 * tid + 2] = temp;
			}
		}
		__syncthreads(); //執行緒同步		
	}
	d_a[tid] = s_a[tid]; //將排序結果搬回到Global Memory
}

int main()
{
	//定義變數
	int *a,*d_a;
	int size = N * sizeof(int);

	//Host端變數分配記憶體
	a = (int *)malloc(size); 
	//初始化待排序陣列
	random_ints(a);
	
	//Device端變數分配記憶體
	cudaMalloc((void **)&d_a, size);

	//將資料從Host端拷貝到Device端
	cudaMemcpy(d_a, a, size, cudaMemcpyHostToDevice);

	//呼叫核函式
	myKernel<<<1, N >>> (d_a);

	//將資料從Device端拷貝到Host端
	cudaMemcpy(a, d_a, size, cudaMemcpyDeviceToHost);

	//列印排序結果
	for (int i = 0; i < N; i++) {
		printf("%d ", a[i]);
	}

	//釋放記憶體
	free(a); 
	cudaFree(d_a); 
	return 0;
}
void random_ints(int *a)
{
	if (!a) { //異常判斷
		return;
	}
	for (int i = 0; i < N; i++) {
		a[i] = rand() % N; //產生0-N之間的隨機整數
	}
}
 

然後openmp只需要在迴圈耗時的地方加上一句話即可。

還有就是MPI使用6個基本函式即可。

MPI初始化：通過MPI_Init函式進入MPI環境並完成所有的初始化工作

int MPI_Init( int *argc, char * * * argv )

MPI結束：通過MPI_Finalize函式從MPI環境中退出

int MPI_Finalize(void)

獲取程序的編號：呼叫MPI_Comm_rank函式獲得當前程序在指定通訊域中的編號，將自身與其他程式區分

int MPI_Comm_rank(MPI_Comm comm, int *rank)

獲取指定通訊域的程序數：呼叫MPI_Comm_size函式獲取指定通訊域的程序個數，確定自身完成任務比例

int MPI_Comm_size(MPI_Comm comm, int *size)

訊息傳送：MPI_Send函式用於傳送一個訊息到目標程序

int MPI_Send(void *buf, int count, MPI_Datatype dataytpe, int dest, int tag, MPI_Comm comm) 

訊息接受:MPI_Recv函式用於從指定程序接收一個訊息

int MPI_Recv(void *buf, int count, MPI_Datatype datatyepe,int source, int tag, MPI_Comm comm, MPI_Status *status）
 

圓周率計算案例：

【OpenMP_PI】
#include <omp.h>
#include<stdio.h>
#include<time.h>

#define NUM_THREADS 8
double seriel_pi();
double parallel_pi();
static long num_steps = 1000000000;
double step;
void main()
{
	clock_t start; float time; double pi;
	start = clock();
	pi=seriel_pi();
	time = (float)(clock() - start);
	printf("Seriel:PI=%.5f  time=%.1f\n", pi,time);
	start = clock();
	pi = parallel_pi();
	time = (float)(clock() - start);
	printf("Parallel:PI=%.5f  time=%.1f\n", pi, time);
}
double parallel_pi() {
	int i; double x, pi, sum = 0.0;
	step = 1.0 / (double)num_steps;
	omp_set_num_threads(NUM_THREADS);
#pragma omp parallel for private(x) reduction (+:sum)
	for (i = 0; i< num_steps; i++) {
		x = (i + 0.5)*step;
		sum += 4.0 / (1.0 + x*x);
	}
	pi = sum * step;
	return pi;
}
double seriel_pi() {
	double x, pi, sum = 0.0;
	step = 1.0 / (double)num_steps;
	for (int i = 0; i< num_steps; i++) {
		x = (i + 0.5)*step;
		sum = sum + 4.0 / (1.0 + x*x);
	}
	pi = step * sum;
	return pi;
}

【Cuda_PI】
#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <stdio.h>
#include<stdlib.h>
#include<time.h>

double seriel_pi();
#define B 128     //塊的個數
#define T 512		//每個塊中的執行緒數
#define N 1000000000   //劃分的step個數


__global__ void reducePI1(double *d_sum) {
	

	int gid = threadIdx.x + blockIdx.x*blockDim.x;//執行緒索引

	__shared__ double s_sum[T];//長度為block執行緒數

	s_sum[threadIdx.x] = 0.0; //初始化

	double x;

	while (gid < N) { 
		x = (gid + 0.5)/N;//當前x值
		s_sum[threadIdx.x] += 4.0 / (1.0 + x*x);//對應的y值
		gid += blockDim.x*gridDim.x; //若匯流排程數不足時，進行累加
		__syncthreads();
	}

	for (int i = (blockDim.x >> 1); i>0; i >>= 1) { //歸約到s_sum[0]
		if (threadIdx.x<i) {
			s_sum[threadIdx.x] += s_sum[threadIdx.x + i];
		}
		__syncthreads();
	}


	if (threadIdx.x == 0) {
		d_sum[blockIdx.x] = s_sum[0]; //每個block儲存自己block的歸約值
	}
}

__global__ void reducePI2(double *d_sum) {

	int id = threadIdx.x;

	__shared__ double s_pi[B];


	s_pi[id] = d_sum[id]; //將資料拷貝到共享記憶體區
	__syncthreads();


	for (int i = (blockDim.x >> 1); i>0; i >>= 1) { //歸約到s_pi[0]
		if (id < i) {
			s_pi[id] += s_pi[id + i];  
		}
		__syncthreads();
	}

	if (id == 0) {
		d_sum[0] = s_pi[0]/N;

	}
}

int main()
{
	//定義變數
	double *pi, *d_sum;
	clock_t start; float time;

	//Host端變數分配記憶體
	pi = (double *)malloc(sizeof(double));
	//Device端變數分配記憶體
	cudaMalloc((void **)&d_sum, B*sizeof(double));

	//序列計算
	start = clock();
	pi[0] = seriel_pi();
	time = (float)(clock() - start);
	printf("Seriel:PI=%.5f  time=%.1f\n", pi[0], time);

	//平行計算
	start = clock();
	//呼叫核函式
	reducePI1 <<<B, T >>> (d_sum);
	reducePI2 <<<1, B >>> (d_sum);

	//將資料從Device端拷貝到Host端
	cudaMemcpy(pi, d_sum, sizeof(double), cudaMemcpyDeviceToHost);
	time = (float)(clock() - start);
	printf("Parallel:PI=%.5f  time=%.1f\n", pi[0], time);


	//釋放記憶體
	free(pi);
	cudaFree(d_sum);
	return 0;
}
double seriel_pi() {
	double x, pi,step, sum = 0.0;
	step = 1.0 / (double)N;
	for (int i = 0; i< N; i++) {
		x = (i + 0.5)*step;
		sum = sum + 4.0 / (1.0 + x*x);
	}
	pi = step * sum;
	return pi;
}

【MPI_PI】
#include<stdio.h>
#include "mpi.h"
#include<math.h>
#pragma comment (lib, "msmpi.lib") 


int main(int argc, char *argv[]) {
	int my_rank, num_procs;
	int i, n = 100000000;
	double sum=0.0, step, x, mypi, pi;
	double start = 0.0, stop = 0.0;

	MPI_Init(&argc, &argv);          //初始化環境
	MPI_Comm_size(MPI_COMM_WORLD, &num_procs);   //獲取並行的程序數
	MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);     //當前程序在所有程序中的序號

	start = MPI_Wtime();
	step = 1.0 / n;
	for (i = my_rank; i<n; i += num_procs) {
		x = step*((double)i + 0.5);
		sum += 4.0 / (1.0 + x*x);
	}
	mypi = step*sum;

	MPI_Reduce(&mypi, &pi, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);    //由程序0進行歸約，把每個程序計算出來的mypi進行相加（MPI_SUM）,賦給pi
	if (my_rank == 0) {
		printf("PI is %.20f\n", pi);
		stop = MPI_Wtime();
		printf("Time: %f\n", stop - start);
		fflush(stdout);
	}
	MPI_Finalize();
	return 0;
}

序列

並行