test_post_process_lib_loader.cpp 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835
  1. #include <stdio.h>
  2. #include <sys/mman.h>
  3. #include <sys/stat.h>
  4. #include <sys/types.h>
  5. #include <sys/time.h>
  6. #include "csi_dsp_api.h"
  7. #include "csi_dsp_task_defs.h"
  8. #include "csi_dsp_post_process_defs.h"
  9. #include "CppUTest/TestHarness.h"
  10. #include "CppUTest/CommandLineTestRunner.h"
  11. struct buf_param{
  12. int with;
  13. int height;
  14. int stride;
  15. int plane_num;
  16. };
  17. TEST_GROUP(DspPostProcessTestLibLoader)
  18. {
  19. void setup()
  20. {
  21. instance = csi_dsp_create_instance(0);
  22. if(!instance)
  23. {
  24. FAIL_TEST("create fail\n");
  25. }
  26. task= csi_dsp_create_task(instance,CSI_DSP_TASK_SW_TO_SW);
  27. if(!task)
  28. {
  29. FAIL_TEST("task create fail\n");
  30. }
  31. }
  32. void teardown()
  33. {
  34. csi_dsp_destroy_task(task);
  35. csi_dsp_delete_instance(instance);
  36. }
  37. void *instance;
  38. void *task;
  39. int oneRequsetHelper(int with,int height,int stride,int plane_num,char *name)
  40. {
  41. int i=0;
  42. int j=0;
  43. int ret =0 ;
  44. struct timeval time_enqueue;
  45. struct timeval time_dequeue;
  46. csi_dsp_algo_load_req_t alog_config={
  47. .algo_id=0,
  48. };
  49. if(csi_dsp_task_acquire_algo(task,name))
  50. {
  51. FAIL_TEST("algo kernel load fail\n");
  52. }
  53. struct csi_sw_task_req* req=NULL;
  54. req =csi_dsp_task_create_request(task);
  55. if(req==NULL)
  56. {
  57. FAIL_TEST("req create fail\n");
  58. }
  59. struct csi_dsp_buffer buf1;
  60. buf1.buf_id = 0;
  61. buf1.dir = CSI_DSP_BUFFER_IN;
  62. buf1.type = CSI_DSP_BUF_ALLOC_DRV;
  63. buf1.plane_count = plane_num;
  64. buf1.width =with;
  65. buf1.height =height;
  66. for(i=0;i<buf1.plane_count;i++)
  67. {
  68. buf1.planes[i].stride= stride;
  69. buf1.planes[i].size= stride*buf1.height;
  70. }
  71. if(csi_dsp_request_add_buffer(req,&buf1))
  72. {
  73. csi_dsp_task_release_request(req);
  74. FAIL_TEST("Add buffer:%d\n");
  75. }
  76. int *buf;
  77. for(j=0;j<buf1.plane_count;j++)
  78. {
  79. buf = (int *)buf1.planes[j].buf_vir;
  80. for(i=0;i<buf1.planes[j].size/4;i++)
  81. {
  82. buf[i]=rand();
  83. }
  84. printf("plane:%d, buf1 data:%d\n",j,buf[0]);
  85. }
  86. struct csi_dsp_buffer buf2;
  87. buf2.buf_id = 1;
  88. buf2.dir = CSI_DSP_BUFFER_OUT;
  89. buf2.type = CSI_DSP_BUF_ALLOC_DRV;
  90. buf2.plane_count = plane_num;
  91. buf2.width =with;
  92. buf2.height =height;
  93. for(i=0;i<buf2.plane_count;i++)
  94. {
  95. buf2.planes[i].stride= stride;
  96. buf2.planes[i].size= stride*buf2.height;
  97. }
  98. if(csi_dsp_request_add_buffer(req,&buf2))
  99. {
  100. csi_dsp_task_release_request(req);
  101. FAIL_TEST("Add buffer:%d\n");
  102. }
  103. for(j=0;j<buf2.plane_count;j++)
  104. {
  105. buf = (int *)buf2.planes[j].buf_vir;
  106. for(i=0;i<buf2.planes[0].size/4;i++)
  107. {
  108. buf[i]=rand();
  109. }
  110. printf("plane:%d, buf2 data:%d\n",j,buf[0]);
  111. }
  112. if(csi_dsp_request_enqueue(req))
  113. {
  114. csi_dsp_task_release_request(req);
  115. FAIL_TEST("Add buffer:%d\n");
  116. }
  117. gettimeofday(&time_enqueue, 0);
  118. req = csi_dsp_request_dequeue(task);
  119. if(req==NULL && req->status != CSI_DSP_SW_REQ_DONE)
  120. {
  121. FAIL_TEST("req dequeue fail\n");
  122. }
  123. gettimeofday(&time_dequeue, 0);
  124. printf("req:%d,start:%d,%d,end:%d,%d\n",req->request_id,time_enqueue.tv_sec,time_enqueue.tv_usec,time_dequeue.tv_sec,time_dequeue.tv_usec);
  125. // MEMCMP_EQUAL((void*)buf1.planes[0].buf_vir,(void *)buf2.planes[0].buf_vir,buf1.planes[0].size);
  126. // memset((void *)buf2.planes[0].buf_vir,0xff,16);
  127. for(i=0;i<buf2.plane_count;i++)
  128. {
  129. ret |= memcmp((void*)buf1.planes[i].buf_vir,(void *)buf2.planes[i].buf_vir,buf2.planes[i].size);
  130. printf("compare plane:%d, buf1:%d,buf2:%d,size:%d\n",i,((int*)buf1.planes[i].buf_vir)[0],((int*)buf2.planes[i].buf_vir)[0],buf2.planes[i].size);
  131. }
  132. CHECK_EQUAL_ZERO(ret);
  133. csi_dsp_task_release_request(req);
  134. return 0;
  135. }
  136. // int task_thread_process(struct buf_param * param)
  137. // {
  138. // }
  139. };
  140. TEST(DspPostProcessTestLibLoader,oneProcessReq_640_480_fl_lib)
  141. {
  142. CHECK_EQUAL_ZERO(oneRequsetHelper(640,480,640,1,"dsp_dummy_algo_flo"));
  143. }
  144. TEST(DspPostProcessTestLibLoader,oneProcessReq_640_480_pi_lib)
  145. {
  146. CHECK_EQUAL_ZERO(oneRequsetHelper(640,480,640,1,"dsp_dummy_algo_pisl"));
  147. }
  148. TEST(DspPostProcessTestLibLoader,oneProcessReq_1920_1080_fl_lib)
  149. {
  150. CHECK_EQUAL_ZERO(oneRequsetHelper(1920,1080,1920,1,"dsp_dummy_algo_flo"));
  151. }
  152. TEST(DspPostProcessTestLibLoader,oneProcessReq_4096_2160_pi_lib)
  153. {
  154. CHECK_EQUAL_ZERO(oneRequsetHelper(4096,2160,4096,1,"dsp_dummy_algo_pisl"));
  155. }
  156. // TEST(DspPostProcessTestLibLoader,oneProcessReq_multi_planes_lib)
  157. // {
  158. // CHECK_EQUAL_ZERO(oneRequsetHelper(640,480,640,3));
  159. // }
  160. TEST(DspPostProcessTestLibLoader,oneProcessReq_multi_planes_1280_960_pi_lib)
  161. {
  162. CHECK_EQUAL_ZERO(oneRequsetHelper(1280,960,1280,3,"dsp_dummy_algo_pisl"));
  163. }
  164. // TEST(DspPostProcessTestLibLoader,oneProcessReq_multi_planes_1920_1080_lib)
  165. // {
  166. // CHECK_EQUAL_ZERO(oneRequsetHelper(1920,1080,1920,3));
  167. // }
  168. // TEST(DspPostProcessTestLibLoader,MultiProcessReq)
  169. // {
  170. // struct csi_sw_task_req* req_list[6];
  171. // int loop=0;
  172. // int req_num = sizeof(req_list)/sizeof(struct csi_sw_task_req*);
  173. // struct csi_sw_task_req* req=NULL;
  174. // csi_dsp_algo_load_req_t alog_config={
  175. // .algo_id=0,
  176. // };
  177. // if(csi_dsp_task_load_algo(task,&alog_config))
  178. // {
  179. // FAIL_TEST("algo kernel load fail\n");
  180. // }
  181. // for(loop =0 ;loop < req_num;loop++)
  182. // {
  183. // req =csi_dsp_task_create_request(task);
  184. // if(req==NULL)
  185. // {
  186. // FAIL_TEST("req create fail\n");
  187. // }
  188. // req_list[loop]=req;
  189. // struct csi_dsp_buffer buf1;
  190. // buf1.buf_id = 0;
  191. // buf1.dir = CSI_DSP_BUFFER_IN;
  192. // buf1.type = CSI_DSP_BUF_ALLOC_DRV;
  193. // buf1.plane_count = 1;
  194. // buf1.width =640;
  195. // buf1.height =480;
  196. // buf1.planes[0].stride= 640;
  197. // buf1.planes[0].size= 640*480;
  198. // if(csi_dsp_request_add_buffer(req,&buf1))
  199. // {
  200. // csi_dsp_task_release_request(req);
  201. // FAIL_TEST("Add buffer:%d\n");
  202. // }
  203. // int i=0;
  204. // for(i=0;i<buf1.planes[0].size/4;i++)
  205. // {
  206. // ((int *)(buf1.planes[0].buf_vir))[i]=rand();
  207. // }
  208. // struct csi_dsp_buffer buf2;
  209. // buf2.buf_id = 1;
  210. // buf2.dir = CSI_DSP_BUFFER_OUT;
  211. // buf2.type = CSI_DSP_BUF_ALLOC_DRV;
  212. // buf2.plane_count = 1;
  213. // buf2.width =640;
  214. // buf2.height =480;
  215. // buf2.planes[0].stride= 640;
  216. // buf2.planes[0].size= 640*480;
  217. // if(csi_dsp_request_add_buffer(req,&buf2))
  218. // {
  219. // csi_dsp_task_release_request(req);
  220. // FAIL_TEST("Add buffer:%d\n");
  221. // }
  222. // if(csi_dsp_request_enqueue(req))
  223. // {
  224. // csi_dsp_task_release_request(req);
  225. // FAIL_TEST("Add buffer:%d\n");
  226. // }
  227. // }
  228. // for(;loop>0;loop--)
  229. // {
  230. // req = csi_dsp_request_dequeue(task);
  231. // if(req==NULL && req->status != CSI_DSP_SW_REQ_DONE)
  232. // {
  233. // FAIL_TEST("req dequeue fail\n");
  234. // }
  235. // // MEMCMP_EQUAL((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  236. // int ret = memcmp((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  237. // CHECK_EQUAL_ZERO(ret);
  238. // csi_dsp_task_release_request(req);
  239. // }
  240. // }
  241. // TEST(DspPostProcessTestLibLoader,MultiProcessReqEnqueueConcentration)
  242. // {
  243. // struct csi_sw_task_req* req_list[6];
  244. // int loop=0;
  245. // struct csi_sw_task_req* req=NULL;
  246. // int req_num = sizeof(req_list)/sizeof(struct csi_sw_task_req*);
  247. // csi_dsp_algo_load_req_t alog_config={
  248. // .algo_id=0,
  249. // };
  250. // if(csi_dsp_task_load_algo(task,&alog_config))
  251. // {
  252. // FAIL_TEST("algo kernel load fail\n");
  253. // }
  254. // for(loop =0 ;loop < req_num;loop++)
  255. // {
  256. // req =csi_dsp_task_create_request(task);
  257. // if(req==NULL)
  258. // {
  259. // FAIL_TEST("req create fail\n");
  260. // }
  261. // req_list[loop]=req;
  262. // struct csi_dsp_buffer buf1;
  263. // buf1.buf_id = 0;
  264. // buf1.dir = CSI_DSP_BUFFER_IN;
  265. // buf1.type = CSI_DSP_BUF_ALLOC_DRV;
  266. // buf1.plane_count = 1;
  267. // buf1.width =640;
  268. // buf1.height =480;
  269. // buf1.planes[0].stride= 640;
  270. // buf1.planes[0].size= 640*480;
  271. // if(csi_dsp_request_add_buffer(req,&buf1))
  272. // {
  273. // csi_dsp_task_release_request(req);
  274. // FAIL_TEST("Add buffer:%d\n");
  275. // }
  276. // int i=0;
  277. // for(i=0;i<buf1.planes[0].size/4;i++)
  278. // {
  279. // ((int *)(buf1.planes[0].buf_vir))[i]=rand();
  280. // }
  281. // struct csi_dsp_buffer buf2;
  282. // buf2.buf_id = 1;
  283. // buf2.dir = CSI_DSP_BUFFER_OUT;
  284. // buf2.type = CSI_DSP_BUF_ALLOC_DRV;
  285. // buf2.plane_count = 1;
  286. // buf2.width =640;
  287. // buf2.height =480;
  288. // buf2.planes[0].stride= 640;
  289. // buf2.planes[0].size= 640*480;
  290. // if(csi_dsp_request_add_buffer(req,&buf2))
  291. // {
  292. // csi_dsp_task_release_request(req);
  293. // FAIL_TEST("Add buffer:%d\n");
  294. // }
  295. // }
  296. // for(loop =0 ;loop < req_num;loop++)
  297. // {
  298. // if(csi_dsp_request_enqueue(req_list[loop]))
  299. // {
  300. // csi_dsp_task_release_request(req_list[loop]);
  301. // FAIL_TEST("Add buffer:%d\n");
  302. // }
  303. // }
  304. // for(;loop>0;loop--)
  305. // {
  306. // req = csi_dsp_request_dequeue(task);
  307. // if(req==NULL && req->status != CSI_DSP_SW_REQ_DONE)
  308. // {
  309. // FAIL_TEST("req dequeue fail\n");
  310. // }
  311. // // MEMCMP_EQUAL((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  312. // int ret = memcmp((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  313. // CHECK_EQUAL_ZERO(ret);
  314. // csi_dsp_task_release_request(req);
  315. // }
  316. // }
  317. // TEST(DspPostProcessTestLibLoader,MultiProcessReqEnqueueConcentration_1)
  318. // {
  319. // struct csi_sw_task_req* req_list[6];
  320. // int loop=0;
  321. // struct csi_sw_task_req* req=NULL;
  322. // int req_num = sizeof(req_list)/sizeof(struct csi_sw_task_req*);
  323. // csi_dsp_algo_load_req_t alog_config={
  324. // .algo_id=0,
  325. // };
  326. // if(csi_dsp_task_load_algo(task,&alog_config))
  327. // {
  328. // FAIL_TEST("algo kernel load fail\n");
  329. // }
  330. // for(loop =0 ;loop < req_num;loop++)
  331. // {
  332. // req =csi_dsp_task_create_request(task);
  333. // if(req==NULL)
  334. // {
  335. // FAIL_TEST("req create fail\n");
  336. // }
  337. // req_list[loop]=req;
  338. // struct csi_dsp_buffer buf1;
  339. // buf1.buf_id = 0;
  340. // buf1.dir = CSI_DSP_BUFFER_IN;
  341. // buf1.type = CSI_DSP_BUF_ALLOC_DRV;
  342. // buf1.plane_count = 1;
  343. // buf1.width =640;
  344. // buf1.height =480;
  345. // buf1.planes[0].stride= 640;
  346. // buf1.planes[0].size= 640*480;
  347. // if(csi_dsp_request_add_buffer(req,&buf1))
  348. // {
  349. // csi_dsp_task_release_request(req);
  350. // FAIL_TEST("Add buffer:%d\n");
  351. // }
  352. // int i=0;
  353. // for(i=0;i<buf1.planes[0].size/4;i++)
  354. // {
  355. // ((int *)(buf1.planes[0].buf_vir))[i]=rand();
  356. // }
  357. // struct csi_dsp_buffer buf2;
  358. // buf2.buf_id = 1;
  359. // buf2.dir = CSI_DSP_BUFFER_OUT;
  360. // buf2.type = CSI_DSP_BUF_ALLOC_DRV;
  361. // buf2.plane_count = 1;
  362. // buf2.width =640;
  363. // buf2.height =480;
  364. // buf2.planes[0].stride= 640;
  365. // buf2.planes[0].size= 640*480;
  366. // if(csi_dsp_request_add_buffer(req,&buf2))
  367. // {
  368. // csi_dsp_task_release_request(req);
  369. // FAIL_TEST("Add buffer:%d\n");
  370. // }
  371. // }
  372. // for(loop =0 ;loop < req_num;loop++)
  373. // {
  374. // if(csi_dsp_request_enqueue(req_list[loop]))
  375. // {
  376. // csi_dsp_task_release_request(req_list[loop]);
  377. // FAIL_TEST("Add buffer:%d\n");
  378. // }
  379. // }
  380. // for(;loop>0;loop--)
  381. // {
  382. // req = csi_dsp_request_dequeue(task);
  383. // if(req==NULL && req->status != CSI_DSP_SW_REQ_DONE)
  384. // {
  385. // FAIL_TEST("req dequeue fail\n");
  386. // }
  387. // }
  388. // for(loop =0 ;loop < req_num;loop++)
  389. // {
  390. // req = req_list[loop];
  391. // // MEMCMP_EQUAL((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  392. // int ret = memcmp((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  393. // CHECK_EQUAL_ZERO(ret);
  394. // csi_dsp_task_release_request(req);
  395. // }
  396. // }
  397. // TEST(DspPostProcessTestLibLoader,MultiProcessReqEnqueueConcentration_profile_640)
  398. // {
  399. // struct csi_sw_task_req* req_list[6];
  400. // struct timeval cur_time_enqueue[6];
  401. // struct timeval cur_time_dequeue[6];
  402. // int loop=0;
  403. // struct csi_sw_task_req* req=NULL;
  404. // int req_num = sizeof(req_list)/sizeof(struct csi_sw_task_req*);
  405. // csi_dsp_algo_load_req_t alog_config={
  406. // .algo_id=0,
  407. // };
  408. // if(csi_dsp_task_load_algo(task,&alog_config))
  409. // {
  410. // FAIL_TEST("algo kernel load fail\n");
  411. // }
  412. // for(loop =0 ;loop < req_num;loop++)
  413. // {
  414. // req =csi_dsp_task_create_request(task);
  415. // if(req==NULL)
  416. // {
  417. // FAIL_TEST("req create fail\n");
  418. // }
  419. // req_list[loop]=req;
  420. // struct csi_dsp_buffer buf1;
  421. // buf1.buf_id = 0;
  422. // buf1.dir = CSI_DSP_BUFFER_IN;
  423. // buf1.type = CSI_DSP_BUF_ALLOC_DRV;
  424. // buf1.plane_count = 1;
  425. // buf1.width =640;
  426. // buf1.height =480;
  427. // buf1.planes[0].stride= 640;
  428. // buf1.planes[0].size= 640*480;
  429. // if(csi_dsp_request_add_buffer(req,&buf1))
  430. // {
  431. // csi_dsp_task_release_request(req);
  432. // FAIL_TEST("Add buffer:%d\n");
  433. // }
  434. // int i=0;
  435. // for(i=0;i<buf1.planes[0].size/4;i++)
  436. // {
  437. // ((int *)(buf1.planes[0].buf_vir))[i]=rand();
  438. // }
  439. // struct csi_dsp_buffer buf2;
  440. // buf2.buf_id = 1;
  441. // buf2.dir = CSI_DSP_BUFFER_OUT;
  442. // buf2.type = CSI_DSP_BUF_ALLOC_DRV;
  443. // buf2.plane_count = 1;
  444. // buf2.width =640;
  445. // buf2.height =480;
  446. // buf2.planes[0].stride= 640;
  447. // buf2.planes[0].size= 640*480;
  448. // if(csi_dsp_request_add_buffer(req,&buf2))
  449. // {
  450. // csi_dsp_task_release_request(req);
  451. // FAIL_TEST("Add buffer:%d\n");
  452. // }
  453. // }
  454. // for(loop =0 ;loop < req_num;loop++)
  455. // {
  456. // if(csi_dsp_request_enqueue(req_list[loop]))
  457. // {
  458. // csi_dsp_task_release_request(req_list[loop]);
  459. // FAIL_TEST("Add buffer:%d\n");
  460. // }
  461. // gettimeofday(&cur_time_enqueue[loop], 0);
  462. // }
  463. // for(;loop>0;loop--)
  464. // {
  465. // req = csi_dsp_request_dequeue(task);
  466. // if(req==NULL && req->status != CSI_DSP_SW_REQ_DONE)
  467. // {
  468. // FAIL_TEST("req dequeue fail\n");
  469. // }
  470. // gettimeofday(&cur_time_dequeue[loop], 0);
  471. // }
  472. // for(loop =0 ;loop < req_num;loop++)
  473. // {
  474. // printf("req:%d,start:%d,%d,end:%d,%d\n",req_list[loop]->request_id,cur_time_enqueue[loop].tv_sec,cur_time_enqueue[loop].tv_usec,
  475. // cur_time_dequeue[loop].tv_sec,cur_time_dequeue[loop].tv_usec);
  476. // }
  477. // for(loop =0 ;loop < req_num;loop++)
  478. // {
  479. // req = req_list[loop];
  480. // // MEMCMP_EQUAL((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  481. // int ret = memcmp((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  482. // CHECK_EQUAL_ZERO(ret);
  483. // csi_dsp_task_release_request(req);
  484. // }
  485. // }
  486. // TEST(DspPostProcessTestLibLoader,MultiProcessReqEnqueueConcentration_profile_1920)
  487. // {
  488. // struct csi_sw_task_req* req_list[6];
  489. // struct timeval cur_time_enqueue[6];
  490. // struct timeval cur_time_dequeue[6];
  491. // int loop=0;
  492. // struct csi_sw_task_req* req=NULL;
  493. // int req_num = sizeof(req_list)/sizeof(struct csi_sw_task_req*);
  494. // csi_dsp_algo_load_req_t alog_config={
  495. // .algo_id=0,
  496. // };
  497. // if(csi_dsp_task_load_algo(task,&alog_config))
  498. // {
  499. // FAIL_TEST("algo kernel load fail\n");
  500. // }
  501. // for(loop =0 ;loop < req_num;loop++)
  502. // {
  503. // req =csi_dsp_task_create_request(task);
  504. // if(req==NULL)
  505. // {
  506. // FAIL_TEST("req create fail\n");
  507. // }
  508. // req_list[loop]=req;
  509. // struct csi_dsp_buffer buf1;
  510. // buf1.buf_id = 0;
  511. // buf1.dir = CSI_DSP_BUFFER_IN;
  512. // buf1.type = CSI_DSP_BUF_ALLOC_DRV;
  513. // buf1.plane_count = 1;
  514. // buf1.width =1920;
  515. // buf1.height =1080;
  516. // buf1.planes[0].stride= 1920;
  517. // buf1.planes[0].size= 1920*1080;
  518. // if(csi_dsp_request_add_buffer(req,&buf1))
  519. // {
  520. // csi_dsp_task_release_request(req);
  521. // FAIL_TEST("Add buffer:%d\n");
  522. // }
  523. // int i=0;
  524. // for(i=0;i<buf1.planes[0].size/4;i++)
  525. // {
  526. // ((int *)(buf1.planes[0].buf_vir))[i]=rand();
  527. // }
  528. // struct csi_dsp_buffer buf2;
  529. // buf2.buf_id = 1;
  530. // buf2.dir = CSI_DSP_BUFFER_OUT;
  531. // buf2.type = CSI_DSP_BUF_ALLOC_DRV;
  532. // buf2.plane_count = 1;
  533. // buf2.width =1920;
  534. // buf2.height =1080;
  535. // buf2.planes[0].stride= 1920;
  536. // buf2.planes[0].size= 1920*1080;
  537. // if(csi_dsp_request_add_buffer(req,&buf2))
  538. // {
  539. // csi_dsp_task_release_request(req);
  540. // FAIL_TEST("Add buffer:%d\n");
  541. // }
  542. // }
  543. // for(loop =0 ;loop < req_num;loop++)
  544. // {
  545. // if(csi_dsp_request_enqueue(req_list[loop]))
  546. // {
  547. // csi_dsp_task_release_request(req_list[loop]);
  548. // FAIL_TEST("Add buffer:%d\n");
  549. // }
  550. // gettimeofday(&cur_time_enqueue[loop], 0);
  551. // }
  552. // for(;loop>0;loop--)
  553. // {
  554. // req = csi_dsp_request_dequeue(task);
  555. // if(req==NULL && req->status != CSI_DSP_SW_REQ_DONE)
  556. // {
  557. // FAIL_TEST("req dequeue fail\n");
  558. // }
  559. // gettimeofday(&cur_time_dequeue[loop], 0);
  560. // }
  561. // uint32_t counter;
  562. // for(loop =0 ;loop < req_num;loop++)
  563. // {
  564. // printf("req:%d,start:%d,%d,end:%d,%d\n",req_list[loop]->request_id,cur_time_enqueue[loop].tv_sec,cur_time_enqueue[loop].tv_usec,
  565. // cur_time_dequeue[loop].tv_sec,cur_time_dequeue[loop].tv_usec);
  566. // }
  567. // for(loop =0 ;loop < req_num;loop++)
  568. // {
  569. // req = req_list[loop];
  570. // // MEMCMP_EQUAL((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  571. // int ret = memcmp((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  572. // CHECK_EQUAL_ZERO(ret);
  573. // csi_dsp_task_release_request(req);
  574. // }
  575. // }
  576. // TEST(DspPostProcessTestLibLoader,MultiProcessReqEnqueueConcentration_profile_4096)
  577. // {
  578. // struct csi_sw_task_req* req_list[6];
  579. // struct timeval cur_time_enqueue[6];
  580. // struct timeval cur_time_dequeue[6];
  581. // int loop=0;
  582. // struct csi_sw_task_req* req=NULL;
  583. // int req_num = sizeof(req_list)/sizeof(struct csi_sw_task_req*);
  584. // csi_dsp_algo_load_req_t alog_config={
  585. // .algo_id=0,
  586. // };
  587. // if(csi_dsp_task_load_algo(task,&alog_config))
  588. // {
  589. // FAIL_TEST("algo kernel load fail\n");
  590. // }
  591. // for(loop =0 ;loop < req_num;loop++)
  592. // {
  593. // req =csi_dsp_task_create_request(task);
  594. // if(req==NULL)
  595. // {
  596. // FAIL_TEST("req create fail\n");
  597. // }
  598. // req_list[loop]=req;
  599. // struct csi_dsp_buffer buf1;
  600. // buf1.buf_id = 0;
  601. // buf1.dir = CSI_DSP_BUFFER_IN;
  602. // buf1.type = CSI_DSP_BUF_ALLOC_DRV;
  603. // buf1.plane_count = 1;
  604. // buf1.width =4096;
  605. // buf1.height =2160;
  606. // buf1.planes[0].stride= 4096;
  607. // buf1.planes[0].size= 4096*2160;
  608. // if(csi_dsp_request_add_buffer(req,&buf1))
  609. // {
  610. // csi_dsp_task_release_request(req);
  611. // FAIL_TEST("Add buffer:%d\n");
  612. // }
  613. // int i=0;
  614. // for(i=0;i<buf1.planes[0].size/4;i++)
  615. // {
  616. // ((int *)(buf1.planes[0].buf_vir))[i]=rand();
  617. // }
  618. // struct csi_dsp_buffer buf2;
  619. // buf2.buf_id = 1;
  620. // buf2.dir = CSI_DSP_BUFFER_OUT;
  621. // buf2.type = CSI_DSP_BUF_ALLOC_DRV;
  622. // buf2.plane_count = 1;
  623. // buf2.width =4096;
  624. // buf2.height =2160;
  625. // buf2.planes[0].stride= 640;
  626. // buf2.planes[0].size= 4096*2160;
  627. // if(csi_dsp_request_add_buffer(req,&buf2))
  628. // {
  629. // csi_dsp_task_release_request(req);
  630. // FAIL_TEST("Add buffer:%d\n");
  631. // }
  632. // }
  633. // for(loop =0 ;loop < req_num;loop++)
  634. // {
  635. // if(csi_dsp_request_enqueue(req_list[loop]))
  636. // {
  637. // csi_dsp_task_release_request(req_list[loop]);
  638. // FAIL_TEST("Add buffer:%d\n");
  639. // }
  640. // gettimeofday(&cur_time_enqueue[loop], 0);
  641. // }
  642. // for(;loop>0;loop--)
  643. // {
  644. // req = csi_dsp_request_dequeue(task);
  645. // if(req==NULL && req->status != CSI_DSP_SW_REQ_DONE)
  646. // {
  647. // FAIL_TEST("req dequeue fail\n");
  648. // }
  649. // gettimeofday(&cur_time_dequeue[loop], 0);
  650. // }
  651. // uint32_t counter;
  652. // for(loop =0 ;loop < req_num;loop++)
  653. // {
  654. // printf("req:%d,start:%d,%d,end:%d,%d\n",req_list[loop]->request_id,cur_time_enqueue[loop].tv_sec,cur_time_enqueue[loop].tv_usec,
  655. // cur_time_dequeue[loop].tv_sec,cur_time_dequeue[loop].tv_usec);
  656. // }
  657. // for(loop =0 ;loop < req_num;loop++)
  658. // {
  659. // req = req_list[loop];
  660. // // MEMCMP_EQUAL((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  661. // int ret = memcmp((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  662. // CHECK_EQUAL_ZERO(ret);
  663. // csi_dsp_task_release_request(req);
  664. // }
  665. // }