Thrust的各种高级迭代器的使用(重要)

东方耀

Thrust的各种高级迭代器的使用(重要)

1. #include <thrust/iterator/constant_iterator.h>
   
2. #include <thrust/iterator/transform_iterator.h>
   
3. #include <thrust/iterator/counting_iterator.h>
   
4. #include <thrust/iterator/permutation_iterator.h>
   
5. #include <thrust/iterator/zip_iterator.h>
   
6. #include <thrust/reduce.h>
   
7. #include <thrust/device_vector.h>
   
8. #include <iostream>
   
9. 
   
10. 
    
11. void constant_iterator(){
    
12.     //常量迭代器最明显的特点，是每次解引用时，都会返回一个相同的值
    
13.     //当需要输入恒值序列时，常量迭代器将会是最便捷、高效的解决方案
    
14.     // create iterators
    
15.     thrust::constant_iterator<int> first(10);
    
16.     thrust::constant_iterator<int> last = first + 3;
    
17. 
    
18.     std::cout << "XXX" << std::endl;
    
19. 
    
20.     std::cout << first[0] << std::endl;   // returns 10
    
21.     std::cout << first[1] << std::endl;   // returns 10
    
22.     std::cout << first[10000] << std::endl; // returns 10 不需要内存开销
    
23. 
    
24.     // sum of [first, last)
    
25.     std::cout << thrust::reduce(first, last) << std::endl;   // returns 30 (i.e. 3 * 10)
    
26. }
    
27. 
    
28. 
    
29. void counting_iterator(){
    
30.     //如果一个序列需要不断增长的值，计数迭代器将是一个很好的选择 像数组一样访问该迭代器
    
31.     //虽然常量迭代器和计数迭代器可以以数组形式访问，但实际上它们并不需要存储器开销
    
32.     //每次解引用某个迭代器时，它会生成对应的值，并将该值返回给调用函数
    
33.     // create iterators
    
34.     thrust::counting_iterator<int> first(10);
    
35.     thrust::counting_iterator<int> last = first + 3;
    
36.     std::cout << first[0] << std::endl; // returns 10
    
37.     std::cout << first[1] << std::endl; // returns 11
    
38.     std::cout << last[0] << std::endl;  // returns 13
    
39.     std::cout << first[100] << std::endl; // returns 110
    
40. 
    
41.     // sum of [first, last)
    
42.     std::cout << thrust::reduce(first, last) << std::endl; // returns 33 (i.e. 10 + 11 + 12)
    
43. 
    
44. }
    
45. 
    
46. 
    
47. void transform_iterator(){
    
48.     //将transform算法和reduce算法，组合成单一的transform_reduce操作
    
49.     //另一种融合transformation算法和reduction算法的方式
    
50.     // initialize vector
    
51.     thrust::device_vector<int> vec(3);
    
52.     vec[0] = 10; vec[1] = 20; vec[2] = 30;
    
53. 
    
54.     // create iterator (type omitted)
    
55.     // 这里用的 预定义的一元函数对象 肯定是可以自定义的 uniay
    
56.     typedef thrust::transform_iterator<thrust::negate<int>, thrust::device_vector<int>::iterator> J;
    
57.     //转换迭代器的缺点之一，是它返回的迭代器类型很长
    
58.    
    
59.     J first = thrust::make_transform_iterator(vec.begin(), thrust::negate<int>());
    
60.     J last  = thrust::make_transform_iterator(vec.end(),   thrust::negate<int>());
    
61. 
    
62.     std::cout << first[0] << std::endl;   // returns -10
    
63.     std::cout << first[1] << std::endl;   // returns -20
    
64.     std::cout << first[2] << std::endl;   // returns -30
    
65. 
    
66.     // sum of [first, last)
    
67.     std::cout << thrust::reduce(first, last) << std::endl;   // returns -60 (i.e. -10 + -20 + -30)
    
68. 
    
69.     // sum of [first, last)
    
70.     //转换迭代器的缺点之一，是它返回的迭代器类型很长
    
71.     //针对这个问题，通常的解决方法是：只要把make_transform_iterator放在被调用算法的参数里
    
72.     //这样就避免了创建变量来存储第一个和最后一个迭代器
    
73.     std::cout << thrust::reduce(thrust::make_transform_iterator(vec.begin(), thrust::negate<int>()),
    
74.     thrust::make_transform_iterator(vec.end(), thrust::negate<int>())) << std::endl;
    
75. }
    
76. 
    
77. void permutation_iterator(){
    
78.     //排列迭代器可以将分散（scatter）、聚集（gather）操作和Thrust算法进行融合
    
79.      // gather locations
    
80.      thrust::device_vector<int> map(4);
    
81.      map[0] = 3;
    
82.      map[1] = 1;
    
83.      map[2] = 0;
    
84.      map[3] = 5;
    
85. 
    
86.      // array to gather from
    
87.      thrust::device_vector<int> source(6);
    
88.      source[0] = 10;
    
89.      source[1] = 20;
    
90.      source[2] = 30;
    
91.      source[3] = 40;
    
92.      source[4] = 50;
    
93.      source[5] = 60;
    
94. 
    
95.      // fuse gather with reduction:
    
96.      //   sum = source[map[0]] + source[map[1]] + ...
    
97.      int sum = thrust::reduce(thrust::make_permutation_iterator(source.begin(), map.begin()),
    
98.                               thrust::make_permutation_iterator(source.begin(), map.end()));
    
99. 
    
100.      // print sum = 130
     
101.      //这里使用了make_permutation_iterator函数来构建排列迭代器
     
102.      //make_permutation_iterator的第一个参数是聚合操作的源数组，第二个参数是索引数组
     
103.      //当排列迭代器作为一个函数的输出序列时，它相当于分散操作与该函数的融合
     
104.      //通常排列迭代器允许对序列的特定的值进行操作，而不需要对整个序列进行操作。
     
105.      std::cout << "怎么求和的sum is " << sum << std::endl;
     
106. }
     
107. 
     
108. 
     
109. void zip_iterator(){  //最好的迭代器总是放在最后
     
110.     //zip迭代器是一个非常实用的小工具：它将多个输入序列用来产生一个元组（tuple）序列
     
111.     //zip迭代器之所以非常实用，是因为大多数算法只能容纳一个输入序列，或者最多可以容纳两个
     
112.     //zip迭代器将多个独立的序列合并成一个单一的元组序列，使更多算法能够处理这些序列
     
113.     //zip迭代器除了方便，还能使程序更有效地运行
     
114.     //在CUDA里，将三维空间的点储存为float3型的数组是糟糕的，因为在访问操作时不能合并存储器的访问
     
115.     //使用zip迭代器，可以将三个坐标分别存储在三个不同的数组中，这样就可以合并访存
     
116.     //在这种情况下使用zip迭代器创建一个包含三维向量的（虚拟）数组，再作为thrust算法的参数
     
117.     // initialize vectors
     
118.     thrust::device_vector<int>  A(3);
     
119.     thrust::device_vector<char> B(3);
     
120.     A[0] = 10;  A[1] = 20;  A[2] = 30;
     
121.     B[0] = 'x'; B[1] = 'y'; B[2] = 'z';
     
122. 
     
123.     typedef thrust::device_vector<int>::iterator   IntIterator;  //整型的迭代器
     
124.     typedef thrust::device_vector<char>::iterator  CharIterator;  //字符的
     
125.     typedef thrust::tuple<IntIterator, CharIterator> IteratorTuple;  // 元组的
     
126.     typedef thrust::zip_iterator<IteratorTuple> ZipIterator;      // zip的
     
127. 
     
128.     // create iterator (type omitted)
     
129.     ZipIterator first = thrust::make_zip_iterator(thrust::make_tuple(A.begin(), B.begin()));
     
130.     ZipIterator last  = thrust::make_zip_iterator(thrust::make_tuple(A.end(),   B.end()));
     
131. 
     
132.     std::cout << thrust::get<0>(first[0]) << std::endl;   // returns tuple(10, 'x')
     
133.     std::cout << thrust::get<1>(first[0]) << std::endl;
     
134.     //std::cout << first[1] << std::endl;   // returns tuple(20, 'y')
     
135.     //std::cout << first[2] << std::endl;   // returns tuple(30, 'z')
     
136.     std::cout << thrust::get<0>(first[2]) << std::endl;
     
137.     std::cout << thrust::get<1>(first[2]) << std::endl;
     
138. 
     
139.     // maximum of [first, last)
     
140.     thrust::maximum< thrust::tuple<int,char> > binary_op;
     
141.     thrust::tuple<int,char> init = first[0];
     
142.     thrust::tuple<int,char> result = thrust::reduce(first, last, init, binary_op);  
     
143.      // returns tuple(30, 'z')
     
144.     std::cout << thrust::get<0>(result) << std::endl;
     
145.     std::cout << thrust::get<1>(result) << std::endl;
     
146. }
     
147. 
     
148. //Thrust的各种高级迭代器的使用(重要)
     
149. //对于那些熟悉的Boost C ++库的开发者，他们会发现Thrust的高级迭代器与Boost迭代器库非常相似。
     
150. int main(){
     
151. 
     
152.     // constant_iterator();
     
153. 
     
154.     // counting_iterator();
     
155.     // transform_iterator();
     
156.     // permutation_iterator();
     
157. 
     
158.     zip_iterator();
     
159. 
     
160. 
     
161.    
     
162.     return 0;
     
163. }
     
164. 
     
165. 
     
166. 
     
167. 
     
168. 
     
169. 
     

复制代码

zouqiqi

让天下人人学会人工智能！人工智能的前景一片大好！