CUDA 算法之 奇偶排序+cuda好几个小李子_cuda unique 算法

CUDA 算法之 奇偶排序

• 要CUDA并行排序，
• 介绍CUDA适用的排序方法：
• 奇偶排序（odd even sort），
  • 基于冒泡排序衍生

 

• CUDA的算法复杂度：O(n),稳定排序
• 每个“小块”交换时都互不相关，
• 用CUDA进行并行计算非常合适。

 

canci

• 添加链接描述

输出hello world

#include<stdio.h>

__global__ void kernel() {
  printf("hello world");
}

int main() {

  kernel<<<1, 1>>>();

  return 0;

}
1
2
3
4
5
6
7
8
9
10
11
12
13

• __global__表示这个函数是在GPU上运行
• 函数调用增加了<<<>>>修饰
  • 数字将传递个CUDA的运行时系统，
  • 至于能干啥，下一章会讲。

进阶版

#include<stdio.h>
__global__ void add(int a,int b,int *c){

  *c = a + b;
}

int main(){
  int c;
  int *dev_c;
  cudaMalloc((void**)&dev_c,sizeof(int));
  add<<<1,1>>>(2,7,dev_c);
  cudaMemcpy(&c,dev_c,sizeof(int),cudaMemcpyDeviceToHost);
  printf("2 + 7 = %d",c);
  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• GPU和主机之间的内存交换
• cudaMalloc是在GPU的内存里开辟一片空间，然后通过操作之后，这个内存里有了计算出来内容，再通过cudaMemcpy这个函数把内容从GPU复制出来。

第四章 CUDA C并行编程

• 以下是一个数组求和的代码

#include<stdio.h>
#define N   10
__global__ void add( int *a, int *b, int *c ) {

    int tid = blockIdx.x;    // this thread handles the data at its thread id

    if (tid < N)

        c[tid] = a[tid] + b[tid];

}
int main( void ) {

    int a[N], b[N], c[N];

    int *dev_a, *dev_b, *dev_c;

    // allocate the memory on the GPU

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

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

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

 

    // fill the arrays 'a' and 'b' on the CPU

    for (int i=0; i<N; i++) {

        a[i] = -i;

        b[i] = i * i;

    }

 

    // copy the arrays 'a' and 'b' to the GPU

    cudaMemcpy( dev_a, a, N * sizeof(int),

                              cudaMemcpyHostToDevice );

    cudaMemcpy( dev_b, b, N * sizeof(int),

                              cudaMemcpyHostToDevice );

 

    add<<<N,1>>>( dev_a, dev_b, dev_c );

 

    // copy the array 'c' back from the GPU to the CPU

    cudaMemcpy( c, dev_c, N * sizeof(int),

                              cudaMemcpyDeviceToHost );

    // display the results

    for (int i=0; i<N; i++) {
        printf( "%d + %d = %d\n", a[i], b[i], c[i] );
    }

    // free the memory allocated on the GPU
    cudaFree( dev_a );
    cudaFree( dev_b );
    cudaFree( dev_c );
    return 0;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

• 重点也是对于初学者最难理解的就是kernel函数了：

 __global__ void add( int *a, int *b, int *c ) {

    int tid = blockIdx.x;

    if (tid < N)

        c[tid] = a[tid] + b[tid];

}
1
2
3
4
5
6
7
8
9

• 数组求和竟然不要循环！
• 为什么不要循环，就是因为这里的tid可以把整个循环的工作做了
• 这里的tid也就是thread的id，每个thread负责数组一个数的操作，所以将10个循环操作拆分成了十个线程同时搞定。
• 这里的kernel函数也就是可以同时并发执行，而里面的tid的数值是不一样的。

参考链接

• https://blog.csdn.net/wfei101/article/details/81292686