intel线程库tbb的使用

首先下载：

http://www.threadingbuildingblocks.org/uploads/77/111/2.1/tbb21_20080605oss_win.zip

当前是2.1版本

解压到c盘，打开vs2005，设置vc＋＋的项目目录

include：

C:\tbb21oss_win\include

执行文件：

C:\tbb21oss_win\ia32\vc8\bin

库文件：

C:\tbb21oss_win\ia32\vc8\lib

最后设置 我的电脑－－环境变量设置

添加下面到path部分的最前面，记得加上一个“；”：C:\tbb21oss_win\ia32\vc8\bin

然后添加一个变量：

TBB21_INSTALL_DIR 为C:\tbb21oss_win

开启vs2005的命令行工具，进入到C:\tbb21oss_win\ia32\vc8\bin路径，执行tbbvars.bat文件

可以开始第一个程序了，记得带上tbb.lib对应的是release编译模式

1. /*
2. Copyright2005-2008IntelCorporation.AllRightsReserved.
4. ThisfileispartofThreadingBuildingBlocks.
6. ThreadingBuildingBlocksisfreesoftware;youcanredistributeit
7. and/ormodifyitunderthetermsoftheGNUGeneralPublicLicense
8. version2aspublishedbytheFreeSoftwareFoundation.
10. ThreadingBuildingBlocksisdistributedinthehopethatitwillbe
11. useful,butWITHOUTANYWARRANTY;withouteventheimpliedwarranty
12. ofMERCHANTABILITYorFITNESSFORAPARTICULARPURPOSE.Seethe
13. GNUGeneralPublicLicenseformoredetails.
15. YoushouldhavereceivedacopyoftheGNUGeneralPublicLicense
16. alongwithThreadingBuildingBlocks;ifnot,writetotheFreeSoftware
17. Foundation,Inc.,51FranklinSt,FifthFloor,Boston,MA02110-1301USA
19. Asaspecialexception,youmayusethisfileaspartofafreesoftware
20. librarywithoutrestriction.Specifically,ifotherfilesinstantiate
21. templatesorusemacrosorinlinefunctionsfromthisfile,oryoucompile
22. thisfileandlinkitwithotherfilestoproduceanexecutable,this
23. filedoesnotbyitselfcausetheresultingexecutabletobecoveredby
24. theGNUGeneralPublicLicense.Thisexceptiondoesnothowever
25. invalidateanyotherreasonswhytheexecutablefilemightbecoveredby
26. theGNUGeneralPublicLicense.
27. */
29. //
30. //Exampleprogramthatreadsafileoftextandchangesthefirstletter
31. //ofeachwordtouppercase.
32. //
33. #include"tbb/pipeline.h"
34. #include"tbb/tick_count.h"
35. #include"tbb/task_scheduler_init.h"
36. #include<cstring>
37. #include<cstdlib>
38. #include<cstdio>
39. #include<cctype>
41. usingnamespacestd;
43. //!Bufferthatholdsblockofcharactersandlastcharacterofpreviousbuffer.
44. classMyBuffer{
45. staticconstsize_tbuffer_size=10000;
46. char*my_end;
47. //!storage[0]holdsthelastcharacterofthepreviousbuffer.
48. charstorage[1+buffer_size];
49. public:
50. //!Pointertofirstcharacterinthebuffer
51. char*begin(){returnstorage+1;}
52. constchar*begin()const{returnstorage+1;}
53. //!Pointertoonepastlastcharacterinthebuffer
54. char*end()const{returnmy_end;}
55. //!Setendofbuffer.
56. voidset_end(char*new_ptr){my_end=new_ptr;}
57. //!Numberofbytesabuffercanhold
58. size_tmax_size()const{returnbuffer_size;}
59. //!Numberofbytesappendedtobuffer.
60. size_tsize()const{returnmy_end-begin();}
61. };
63. classMyInputFilter:publictbb::filter{
64. public:
65. staticconstsize_tn_buffer=8;
66. MyInputFilter(FILE*input_file_);
67. private:
68. FILE*input_file;
69. size_tnext_buffer;
70. charlast_char_of_previous_buffer;
71. MyBufferbuffer[n_buffer];
72. /*override*/void*operator()(void*);
73. };
75. MyInputFilter::MyInputFilter(FILE*input_file_):
76. filter(/*is_serial=*/true),
77. next_buffer(0),
78. input_file(input_file_),
79. last_char_of_previous_buffer('')
80. {
81. }
83. void*MyInputFilter::operator()(void*){
84. MyBuffer&b=buffer[next_buffer];
85. next_buffer=(next_buffer+1)%n_buffer;
86. size_tn=fread(b.begin(),1,b.max_size(),input_file);
87. if(!n){
88. //endoffile
89. returnNULL;
90. }else{
91. b.begin()[-1]=last_char_of_previous_buffer;
92. last_char_of_previous_buffer=b.begin()[n-1];
93. b.set_end(b.begin()+n);
94. return&b;
95. }
96. }
98. //!Filterthatchangesthefirstletterofeachwordfromlowercasetouppercase.
99. classMyTransformFilter:publictbb::filter{
100. public:
101. MyTransformFilter();
102. /*override*/void*operator()(void*item);
103. };
105. MyTransformFilter::MyTransformFilter():
106. tbb::filter(/*ordered=*/false)
107. {}
109. /*override*/void*MyTransformFilter::operator()(void*item){
110. MyBuffer&b=*static_cast<MyBuffer*>(item);
111. intprev_char_is_space=b.begin()[-1]=='';
112. for(char*s=b.begin();s!=b.end();++s){
113. if(prev_char_is_space&&islower((unsignedchar)*s))
114. *s=toupper(*s);
115. prev_char_is_space=isspace((unsignedchar)*s);
116. }
117. return&b;
118. }
120. //!Filterthatwriteseachbuffertoafile.
121. classMyOutputFilter:publictbb::filter{
122. FILE*my_output_file;
123. public:
124. MyOutputFilter(FILE*output_file);
125. /*override*/void*operator()(void*item);
126. };
128. MyOutputFilter::MyOutputFilter(FILE*output_file):
129. tbb::filter(/*is_serial=*/true),
130. my_output_file(output_file)
131. {
132. }
134. void*MyOutputFilter::operator()(void*item){
135. MyBuffer&b=*static_cast<MyBuffer*>(item);
136. fwrite(b.begin(),1,b.size(),my_output_file);
137. returnNULL;
138. }
140. staticintNThread=tbb::task_scheduler_init::automatic;
141. staticconstchar*InputFileName="input.txt";
142. staticconstchar*OutputFileName="output.txt";
143. staticboolis_number_of_threads_set=false;
145. voidUsage()
146. {
147. fprintf(stderr,"Usage:\ttext_filter[input-file[output-file[nthread]]]\n");
148. }
150. intParseCommandLine(intargc,char*argv[]){
151. //Parsecommandline
152. if(argc>4){
153. Usage();
154. return0;
155. }
156. if(argc>=2)InputFileName=argv[1];
157. if(argc>=3)OutputFileName=argv[2];
158. if(argc>=4){
159. NThread=strtol(argv[3],0,0);
160. if(NThread<1){
161. fprintf(stderr,"nthreadsetto%d,butmustbeatleast1\n",NThread);
162. return0;
163. }
164. is_number_of_threads_set=true;//Numberofthreadsissetexplicitly
165. }
166. return1;
167. }
169. intrun_pipeline(intnthreads)
170. {
171. FILE*input_file=fopen(InputFileName,"r");
172. if(!input_file){
173. perror(InputFileName);
174. Usage();
175. return0;
176. }
177. FILE*output_file=fopen(OutputFileName,"w");
178. if(!output_file){
179. perror(OutputFileName);
180. return0;
181. }
183. //Createthepipeline
184. tbb::pipelinepipeline;
186. //Createfile-readingwritingstageandaddittothepipeline
187. MyInputFilterinput_filter(input_file);
188. pipeline.add_filter(input_filter);
190. //Createcapitalizationstageandaddittothepipeline
191. MyTransformFiltertransform_filter;
192. pipeline.add_filter(transform_filter);
194. //Createfile-writingstageandaddittothepipeline
195. MyOutputFilteroutput_filter(output_file);
196. pipeline.add_filter(output_filter);
198. //Runthepipeline
199. tbb::tick_countt0=tbb::tick_count::now();
200. pipeline.run(MyInputFilter::n_buffer);
201. tbb::tick_countt1=tbb::tick_count::now();
203. //Removefiltersfrompipelinebeforetheyareimplicitlydestroyed.
204. pipeline.clear();
206. fclose(output_file);
207. fclose(input_file);
209. if(is_number_of_threads_set){
210. printf("threads=%dtime=%g\n",nthreads,(t1-t0).seconds());
211. }else{
212. if(nthreads==1){
213. printf("serialruntime=%g\n",(t1-t0).seconds());
214. }else{
215. printf("parallelruntime=%g\n",(t1-t0).seconds());
216. }
217. }
218. return1;
219. }
221. intmain(intargc,char*argv[]){
222. if(!ParseCommandLine(argc,argv))
223. return1;
224. if(is_number_of_threads_set){
225. //Starttaskscheduler
226. tbb::task_scheduler_initinit(NThread);
227. if(!run_pipeline(NThread))
228. return1;
229. }else{//Numberofthreadswasn'tsetexplicitly.Runserialandparallelversion
230. {//serialrun
231. tbb::task_scheduler_initinit_serial(1);
232. if(!run_pipeline(1))
233. return1;
234. }
235. {//parallelrun(numberofthreadsisselectedautomatically)
236. tbb::task_scheduler_initinit_parallel;
237. if(!run_pipeline(0))
238. return1;
239. }
240. }
241. return0;
242. }

第二个程序，对应debug模式，带上tbb_debug.lib：

1. #include"tbb/task_scheduler_init.h"
2. #include"tbb/blocked_range.h"
3. #include"tbb/parallel_for.h"
5. //链接tbb_debug.lib
6. //#pragmacomment(lib,"tbb_debug.lib")
8. usingnamespacetbb;
10. //对每个Item执行该操作
11. voidFoo(floatvalue)
12. {
13. printf("%.2f\n",value);
14. }
16. classApplyFoo
17. {
18. float*constmy_a;
19. public:
20. voidoperator()(constblocked_range<size_t>&r)const
21. {
22. float*a=my_a;
23. for(size_ti=r.begin();i!=r.end();++i)
24. Foo(a[i]);
25. }
27. ApplyFoo(floata[]):my_a(a){}
28. };
30. int_tmain(intargc,_TCHAR*argv[])
31. {
32. //创建taskscheduler
33. //task_scheduler_init支持一个参数，以指定使用的线程数
34. task_scheduler_initinit;
35. floata[100];
36. for(inti=0;i<100;i++)
37. a[i]=(float)i;
38. //TBB会把数组分成若干的block
39. //对block调用ApplyFoo这个functor
40. parallel_for(blocked_range<size_t>(0,100),ApplyFoo(a));
41. return0;
42. }