starpu_task_insert_utils.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737
  1. /* StarPU --- Runtime system for heterogeneous multicore architectures.
  2. *
  3. * Copyright (C) 2011, 2013-2017 Université Bordeaux
  4. * Copyright (C) 2011-2017 CNRS
  5. * Copyright (C) 2011, 2014 INRIA
  6. * Copyright (C) 2016-2017 Inria
  7. *
  8. * StarPU is free software; you can redistribute it and/or modify
  9. * it under the terms of the GNU Lesser General Public License as published by
  10. * the Free Software Foundation; either version 2.1 of the License, or (at
  11. * your option) any later version.
  12. *
  13. * StarPU is distributed in the hope that it will be useful, but
  14. * WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  16. *
  17. * See the GNU Lesser General Public License in COPYING.LGPL for more details.
  18. */
  19. #include <util/starpu_task_insert_utils.h>
  20. #include <common/config.h>
  21. #include <common/utils.h>
  22. #include <core/task.h>
  23. static void _starpu_pack_arguments(size_t *current_offset, size_t *arg_buffer_size_, char **arg_buffer_, void *ptr, size_t ptr_size)
  24. {
  25. if (*current_offset + sizeof(ptr_size) + ptr_size > *arg_buffer_size_)
  26. {
  27. if (*arg_buffer_size_ == 0)
  28. *arg_buffer_size_ = 128 + sizeof(ptr_size) + ptr_size;
  29. else
  30. *arg_buffer_size_ = 2 * *arg_buffer_size_ + sizeof(ptr_size) + ptr_size;
  31. _STARPU_REALLOC(*arg_buffer_, *arg_buffer_size_);
  32. }
  33. memcpy(*arg_buffer_+*current_offset, (void *)&ptr_size, sizeof(ptr_size));
  34. *current_offset += sizeof(ptr_size);
  35. memcpy(*arg_buffer_+*current_offset, ptr, ptr_size);
  36. *current_offset += ptr_size;
  37. STARPU_ASSERT(*current_offset <= *arg_buffer_size_);
  38. }
  39. int _starpu_codelet_pack_args(void **arg_buffer, size_t *arg_buffer_size, va_list varg_list)
  40. {
  41. int arg_type;
  42. int nargs = 0;
  43. char *_arg_buffer = NULL; // We would like a void* but we use a char* to allow pointer arithmetic
  44. size_t _arg_buffer_size = 0;
  45. size_t current_offset = sizeof(nargs);
  46. while((arg_type = va_arg(varg_list, int)) != 0)
  47. {
  48. if (arg_type & STARPU_R || arg_type & STARPU_W || arg_type & STARPU_SCRATCH || arg_type & STARPU_REDUX)
  49. {
  50. (void)va_arg(varg_list, starpu_data_handle_t);
  51. }
  52. else if (arg_type==STARPU_DATA_ARRAY)
  53. {
  54. (void)va_arg(varg_list, starpu_data_handle_t*);
  55. (void)va_arg(varg_list, int);
  56. }
  57. else if (arg_type==STARPU_DATA_MODE_ARRAY)
  58. {
  59. (void)va_arg(varg_list, struct starpu_data_descr*);
  60. (void)va_arg(varg_list, int);
  61. }
  62. else if (arg_type==STARPU_VALUE)
  63. {
  64. /* We have a constant value: this should be followed by a pointer to the cst value and the size of the constant */
  65. void *ptr = va_arg(varg_list, void *);
  66. size_t ptr_size = va_arg(varg_list, size_t);
  67. nargs++;
  68. _starpu_pack_arguments(&current_offset, &_arg_buffer_size, &_arg_buffer, ptr, ptr_size);
  69. }
  70. else if (arg_type==STARPU_CL_ARGS)
  71. {
  72. (void)va_arg(varg_list, void *);
  73. (void)va_arg(varg_list, size_t);
  74. }
  75. else if (arg_type==STARPU_CALLBACK)
  76. {
  77. (void)va_arg(varg_list, _starpu_callback_func_t);
  78. }
  79. else if (arg_type==STARPU_CALLBACK_WITH_ARG)
  80. {
  81. va_arg(varg_list, _starpu_callback_func_t);
  82. va_arg(varg_list, void *);
  83. }
  84. else if (arg_type==STARPU_CALLBACK_ARG)
  85. {
  86. (void)va_arg(varg_list, void *);
  87. }
  88. else if (arg_type==STARPU_PROLOGUE_CALLBACK)
  89. {
  90. va_arg(varg_list, _starpu_callback_func_t);
  91. }
  92. else if (arg_type==STARPU_PROLOGUE_CALLBACK_ARG)
  93. {
  94. (void)va_arg(varg_list, void *);
  95. }
  96. else if (arg_type==STARPU_PROLOGUE_CALLBACK_POP)
  97. {
  98. va_arg(varg_list, _starpu_callback_func_t);
  99. }
  100. else if (arg_type==STARPU_PROLOGUE_CALLBACK_POP_ARG)
  101. {
  102. (void)va_arg(varg_list, void *);
  103. }
  104. else if (arg_type==STARPU_PRIORITY)
  105. {
  106. (void)va_arg(varg_list, int);
  107. }
  108. else if (arg_type==STARPU_EXECUTE_ON_NODE)
  109. {
  110. (void)va_arg(varg_list, int);
  111. }
  112. else if (arg_type==STARPU_EXECUTE_ON_DATA)
  113. {
  114. (void)va_arg(varg_list, starpu_data_handle_t);
  115. }
  116. else if (arg_type==STARPU_EXECUTE_WHERE)
  117. {
  118. (void)va_arg(varg_list, unsigned long long);
  119. }
  120. else if (arg_type==STARPU_EXECUTE_ON_WORKER)
  121. {
  122. (void)va_arg(varg_list, int);
  123. }
  124. else if (arg_type==STARPU_WORKER_ORDER)
  125. {
  126. va_arg(varg_list, unsigned);
  127. }
  128. else if (arg_type==STARPU_SCHED_CTX)
  129. {
  130. (void)va_arg(varg_list, unsigned);
  131. }
  132. else if (arg_type==STARPU_HYPERVISOR_TAG)
  133. {
  134. (void)va_arg(varg_list, int);
  135. }
  136. else if (arg_type==STARPU_POSSIBLY_PARALLEL)
  137. {
  138. (void)va_arg(varg_list, unsigned);
  139. }
  140. else if (arg_type==STARPU_FLOPS)
  141. {
  142. (void)va_arg(varg_list, double);
  143. }
  144. else if (arg_type==STARPU_TAG || arg_type==STARPU_TAG_ONLY)
  145. {
  146. (void)va_arg(varg_list, starpu_tag_t);
  147. }
  148. else if (arg_type==STARPU_NAME)
  149. {
  150. (void)va_arg(varg_list, const char *);
  151. }
  152. else if (arg_type==STARPU_NODE_SELECTION_POLICY)
  153. {
  154. (void)va_arg(varg_list, int);
  155. }
  156. else
  157. {
  158. STARPU_ABORT_MSG("Unrecognized argument %d, did you perhaps forget to end arguments with 0?\n", arg_type);
  159. }
  160. }
  161. if (nargs)
  162. {
  163. memcpy(_arg_buffer, (int *)&nargs, sizeof(nargs));
  164. }
  165. else
  166. {
  167. free(_arg_buffer);
  168. _arg_buffer = NULL;
  169. }
  170. *arg_buffer = _arg_buffer;
  171. *arg_buffer_size = _arg_buffer_size;
  172. return 0;
  173. }
  174. static
  175. void _starpu_task_insert_check_nb_buffers(struct starpu_codelet *cl, struct starpu_task **task, int *allocated_buffers, int current_buffer)
  176. {
  177. if (current_buffer >= STARPU_NMAXBUFS)
  178. {
  179. if (*allocated_buffers == 0)
  180. {
  181. int i;
  182. struct starpu_codelet *cl2 = (*task)->cl;
  183. *allocated_buffers = STARPU_NMAXBUFS * 2;
  184. _STARPU_MALLOC((*task)->dyn_handles, *allocated_buffers * sizeof(starpu_data_handle_t));
  185. for(i=0 ; i<current_buffer ; i++)
  186. {
  187. (*task)->dyn_handles[i] = (*task)->handles[i];
  188. }
  189. if (cl2->nbuffers == STARPU_VARIABLE_NBUFFERS || !cl2->dyn_modes)
  190. {
  191. _STARPU_MALLOC((*task)->dyn_modes, *allocated_buffers * sizeof(enum starpu_data_access_mode));
  192. for(i=0 ; i<current_buffer ; i++)
  193. {
  194. (*task)->dyn_modes[i] = (*task)->modes[i];
  195. }
  196. }
  197. }
  198. else if (current_buffer >= *allocated_buffers)
  199. {
  200. *allocated_buffers *= 2;
  201. _STARPU_REALLOC((*task)->dyn_handles, *allocated_buffers * sizeof(starpu_data_handle_t));
  202. if (cl->nbuffers == STARPU_VARIABLE_NBUFFERS || !cl->dyn_modes)
  203. {
  204. _STARPU_REALLOC((*task)->dyn_modes, *allocated_buffers * sizeof(enum starpu_data_access_mode));
  205. }
  206. }
  207. }
  208. }
  209. static inline void starpu_task_insert_process_data_arg(struct starpu_codelet *cl, struct starpu_task **task, int arg_type, starpu_data_handle_t handle, int *current_buffer, int *allocated_buffers)
  210. {
  211. enum starpu_data_access_mode mode = (enum starpu_data_access_mode) arg_type & ~STARPU_SSEND;
  212. STARPU_ASSERT(cl != NULL);
  213. STARPU_ASSERT_MSG(cl->nbuffers == STARPU_VARIABLE_NBUFFERS || *current_buffer < cl->nbuffers, "Too many data passed to starpu_task_insert");
  214. _starpu_task_insert_check_nb_buffers(cl, task, allocated_buffers, *current_buffer);
  215. STARPU_TASK_SET_HANDLE((*task), handle, *current_buffer);
  216. if (cl->nbuffers == STARPU_VARIABLE_NBUFFERS || (cl->nbuffers > STARPU_NMAXBUFS && !cl->dyn_modes))
  217. STARPU_TASK_SET_MODE(*task, mode,* current_buffer);
  218. else if (STARPU_CODELET_GET_MODE(cl, *current_buffer))
  219. {
  220. STARPU_ASSERT_MSG(STARPU_CODELET_GET_MODE(cl, *current_buffer) == mode,
  221. "The codelet <%s> defines the access mode %d for the buffer %d which is different from the mode %d given to starpu_task_insert\n",
  222. cl->name, STARPU_CODELET_GET_MODE(cl, *current_buffer),
  223. *current_buffer, mode);
  224. }
  225. else
  226. {
  227. #ifdef STARPU_DEVEL
  228. # warning shall we print a warning to the user
  229. /* Morse uses it to avoid having to set it in the codelet structure */
  230. #endif
  231. STARPU_CODELET_SET_MODE(cl, mode, *current_buffer);
  232. }
  233. (*current_buffer)++;
  234. }
  235. static inline void starpu_task_insert_process_data_array_arg(struct starpu_codelet *cl, struct starpu_task **task, int nb_handles, starpu_data_handle_t *handles, int *current_buffer, int *allocated_buffers)
  236. {
  237. STARPU_ASSERT(cl != NULL);
  238. int i;
  239. for(i=0 ; i<nb_handles ; i++)
  240. {
  241. _starpu_task_insert_check_nb_buffers(cl, task, allocated_buffers, *current_buffer);
  242. STARPU_TASK_SET_HANDLE((*task), handles[i], *current_buffer);
  243. (*current_buffer)++;
  244. }
  245. }
  246. static inline void starpu_task_insert_process_data_mode_array_arg(struct starpu_codelet *cl, struct starpu_task **task, int nb_descrs, struct starpu_data_descr *descrs, int *current_buffer, int *allocated_buffers)
  247. {
  248. STARPU_ASSERT(cl != NULL);
  249. int i;
  250. for(i=0 ; i<nb_descrs ; i++)
  251. {
  252. STARPU_ASSERT_MSG(cl->nbuffers == STARPU_VARIABLE_NBUFFERS || *current_buffer < cl->nbuffers, "Too many data passed to starpu_task_insert");
  253. _starpu_task_insert_check_nb_buffers(cl, task, allocated_buffers, *current_buffer);
  254. STARPU_TASK_SET_HANDLE((*task), descrs[i].handle, *current_buffer);
  255. if ((*task)->dyn_modes)
  256. {
  257. (*task)->dyn_modes[*current_buffer] = descrs[i].mode;
  258. }
  259. else if (cl->nbuffers == STARPU_VARIABLE_NBUFFERS || (cl->nbuffers > STARPU_NMAXBUFS && !cl->dyn_modes))
  260. STARPU_TASK_SET_MODE(*task, descrs[i].mode, *current_buffer);
  261. else if (STARPU_CODELET_GET_MODE(cl, *current_buffer))
  262. {
  263. STARPU_ASSERT_MSG(STARPU_CODELET_GET_MODE(cl, *current_buffer) == descrs[i].mode,
  264. "The codelet <%s> defines the access mode %d for the buffer %d which is different from the mode %d given to starpu_task_insert\n",
  265. cl->name, STARPU_CODELET_GET_MODE(cl, *current_buffer),
  266. *current_buffer, descrs[i].mode);
  267. }
  268. else
  269. {
  270. STARPU_CODELET_SET_MODE(cl, descrs[i].mode, *current_buffer);
  271. }
  272. (*current_buffer)++;
  273. }
  274. }
  275. int _starpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task **task, va_list varg_list)
  276. {
  277. int arg_type;
  278. char *arg_buffer_ = NULL;
  279. size_t arg_buffer_size_ = 0;
  280. size_t current_offset = sizeof(int);
  281. int current_buffer;
  282. int nargs = 0;
  283. int allocated_buffers = 0;
  284. _STARPU_TRACE_TASK_BUILD_START();
  285. (*task)->cl = cl;
  286. current_buffer = 0;
  287. while((arg_type = va_arg(varg_list, int)) != 0)
  288. {
  289. if (arg_type & STARPU_R || arg_type & STARPU_W || arg_type & STARPU_SCRATCH || arg_type & STARPU_REDUX)
  290. {
  291. /* We have an access mode : we expect to find a handle */
  292. starpu_data_handle_t handle = va_arg(varg_list, starpu_data_handle_t);
  293. starpu_task_insert_process_data_arg(cl, task, arg_type, handle, &current_buffer, &allocated_buffers);
  294. }
  295. else if (arg_type == STARPU_DATA_ARRAY)
  296. {
  297. // Expect to find a array of handles and its size
  298. starpu_data_handle_t *handles = va_arg(varg_list, starpu_data_handle_t *);
  299. int nb_handles = va_arg(varg_list, int);
  300. starpu_task_insert_process_data_array_arg(cl, task, nb_handles, handles, &current_buffer, &allocated_buffers);
  301. }
  302. else if (arg_type==STARPU_DATA_MODE_ARRAY)
  303. {
  304. // Expect to find a array of descr and its size
  305. struct starpu_data_descr *descrs = va_arg(varg_list, struct starpu_data_descr *);
  306. int nb_descrs = va_arg(varg_list, int);
  307. starpu_task_insert_process_data_mode_array_arg(cl, task, nb_descrs, descrs, &current_buffer, &allocated_buffers);
  308. }
  309. else if (arg_type==STARPU_VALUE)
  310. {
  311. void *ptr = va_arg(varg_list, void *);
  312. size_t ptr_size = va_arg(varg_list, size_t);
  313. nargs++;
  314. _starpu_pack_arguments(&current_offset, &arg_buffer_size_, &arg_buffer_, ptr, ptr_size);
  315. }
  316. else if (arg_type==STARPU_CL_ARGS)
  317. {
  318. (*task)->cl_arg = va_arg(varg_list, void *);
  319. (*task)->cl_arg_size = va_arg(varg_list, size_t);
  320. (*task)->cl_arg_free = 1;
  321. }
  322. else if (arg_type==STARPU_CALLBACK)
  323. {
  324. (*task)->callback_func = va_arg(varg_list, _starpu_callback_func_t);
  325. }
  326. else if (arg_type==STARPU_CALLBACK_WITH_ARG)
  327. {
  328. (*task)->callback_func = va_arg(varg_list, _starpu_callback_func_t);
  329. (*task)->callback_arg = va_arg(varg_list, void *);
  330. }
  331. else if (arg_type==STARPU_CALLBACK_ARG)
  332. {
  333. (*task)->callback_arg = va_arg(varg_list, void *);
  334. }
  335. else if (arg_type==STARPU_PROLOGUE_CALLBACK)
  336. {
  337. (*task)->prologue_callback_func = va_arg(varg_list, _starpu_callback_func_t);
  338. }
  339. else if (arg_type==STARPU_PROLOGUE_CALLBACK_ARG)
  340. {
  341. (*task)->prologue_callback_arg = va_arg(varg_list, void *);
  342. }
  343. else if (arg_type==STARPU_PROLOGUE_CALLBACK_POP)
  344. {
  345. (*task)->prologue_callback_pop_func = va_arg(varg_list, _starpu_callback_func_t);
  346. }
  347. else if (arg_type==STARPU_PROLOGUE_CALLBACK_POP_ARG)
  348. {
  349. (*task)->prologue_callback_pop_arg = va_arg(varg_list, void *);
  350. }
  351. else if (arg_type==STARPU_PRIORITY)
  352. {
  353. /* Followed by a priority level */
  354. int prio = va_arg(varg_list, int);
  355. (*task)->priority = prio;
  356. }
  357. else if (arg_type==STARPU_EXECUTE_ON_NODE)
  358. {
  359. (void)va_arg(varg_list, int);
  360. }
  361. else if (arg_type==STARPU_EXECUTE_ON_DATA)
  362. {
  363. (void)va_arg(varg_list, starpu_data_handle_t);
  364. }
  365. else if (arg_type==STARPU_EXECUTE_WHERE)
  366. {
  367. (*task)->where = va_arg(varg_list, unsigned long long);
  368. }
  369. else if (arg_type==STARPU_EXECUTE_ON_WORKER)
  370. {
  371. int worker = va_arg(varg_list, int);
  372. if (worker != -1)
  373. {
  374. (*task)->workerid = worker;
  375. (*task)->execute_on_a_specific_worker = 1;
  376. }
  377. }
  378. else if (arg_type==STARPU_WORKER_ORDER)
  379. {
  380. unsigned order = va_arg(varg_list, unsigned);
  381. if (order != 0)
  382. {
  383. STARPU_ASSERT_MSG((*task)->execute_on_a_specific_worker, "worker order only makes sense if a workerid is provided");
  384. (*task)->workerorder = order;
  385. }
  386. }
  387. else if (arg_type==STARPU_SCHED_CTX)
  388. {
  389. unsigned sched_ctx = va_arg(varg_list, unsigned);
  390. (*task)->sched_ctx = sched_ctx;
  391. }
  392. else if (arg_type==STARPU_HYPERVISOR_TAG)
  393. {
  394. int hypervisor_tag = va_arg(varg_list, int);
  395. (*task)->hypervisor_tag = hypervisor_tag;
  396. }
  397. else if (arg_type==STARPU_POSSIBLY_PARALLEL)
  398. {
  399. unsigned possibly_parallel = va_arg(varg_list, unsigned);
  400. (*task)->possibly_parallel = possibly_parallel;
  401. }
  402. else if (arg_type==STARPU_FLOPS)
  403. {
  404. double flops = va_arg(varg_list, double);
  405. (*task)->flops = flops;
  406. }
  407. else if (arg_type==STARPU_TAG)
  408. {
  409. starpu_tag_t tag = va_arg(varg_list, starpu_tag_t);
  410. (*task)->tag_id = tag;
  411. (*task)->use_tag = 1;
  412. }
  413. else if (arg_type==STARPU_TAG_ONLY)
  414. {
  415. starpu_tag_t tag = va_arg(varg_list, starpu_tag_t);
  416. (*task)->tag_id = tag;
  417. }
  418. else if (arg_type==STARPU_NAME)
  419. {
  420. const char *name = va_arg(varg_list, const char *);
  421. (*task)->name = name;
  422. }
  423. else if (arg_type==STARPU_NODE_SELECTION_POLICY)
  424. {
  425. (void)va_arg(varg_list, int);
  426. }
  427. else
  428. {
  429. STARPU_ABORT_MSG("Unrecognized argument %d, did you perhaps forget to end arguments with 0?\n", arg_type);
  430. }
  431. }
  432. if (cl)
  433. {
  434. if (cl->nbuffers == STARPU_VARIABLE_NBUFFERS)
  435. {
  436. (*task)->nbuffers = current_buffer;
  437. }
  438. else
  439. {
  440. STARPU_ASSERT_MSG(current_buffer == cl->nbuffers, "Incoherent number of buffers between cl (%d) and number of parameters (%d)", cl->nbuffers, current_buffer);
  441. }
  442. }
  443. if (nargs)
  444. {
  445. if ((*task)->cl_arg != NULL)
  446. {
  447. _STARPU_DISP("Parameters STARPU_CL_ARGS and STARPU_VALUE cannot be used in the same call\n");
  448. free(arg_buffer_);
  449. arg_buffer_ = NULL;
  450. return -EINVAL;
  451. }
  452. memcpy(arg_buffer_, (int *)&nargs, sizeof(nargs));
  453. (*task)->cl_arg = arg_buffer_;
  454. (*task)->cl_arg_size = arg_buffer_size_;
  455. }
  456. else
  457. {
  458. free(arg_buffer_);
  459. arg_buffer_ = NULL;
  460. }
  461. _STARPU_TRACE_TASK_BUILD_END();
  462. return 0;
  463. }
  464. int _fstarpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task **task, void **arglist)
  465. {
  466. int arg_i = 0;
  467. char *arg_buffer_ = NULL;
  468. size_t arg_buffer_size_ = 0;
  469. size_t current_offset = sizeof(int);
  470. int current_buffer = 0;
  471. int nargs = 0;
  472. int allocated_buffers = 0;
  473. _STARPU_TRACE_TASK_BUILD_START();
  474. (*task)->cl = cl;
  475. (*task)->name = NULL;
  476. (*task)->cl_arg_free = 1;
  477. while (arglist[arg_i] != NULL)
  478. {
  479. const int arg_type = (int)(intptr_t)arglist[arg_i];
  480. if (arg_type & STARPU_R
  481. || arg_type & STARPU_W
  482. || arg_type & STARPU_SCRATCH
  483. || arg_type & STARPU_REDUX)
  484. {
  485. arg_i++;
  486. starpu_data_handle_t handle = arglist[arg_i];
  487. starpu_task_insert_process_data_arg(cl, task, arg_type, handle, &current_buffer, &allocated_buffers);
  488. }
  489. else if (arg_type == STARPU_DATA_ARRAY)
  490. {
  491. arg_i++;
  492. starpu_data_handle_t *handles = arglist[arg_i];
  493. arg_i++;
  494. int nb_handles = *(int *)arglist[arg_i];
  495. starpu_task_insert_process_data_array_arg(cl, task, nb_handles, handles, &current_buffer, &allocated_buffers);
  496. }
  497. else if (arg_type == STARPU_DATA_MODE_ARRAY)
  498. {
  499. arg_i++;
  500. struct starpu_data_descr *descrs = arglist[arg_i];
  501. arg_i++;
  502. int nb_descrs = *(int *)arglist[arg_i];
  503. starpu_task_insert_process_data_mode_array_arg(cl, task, nb_descrs, descrs, &current_buffer, &allocated_buffers);
  504. }
  505. else if (arg_type == STARPU_VALUE)
  506. {
  507. arg_i++;
  508. void *ptr = arglist[arg_i];
  509. arg_i++;
  510. size_t ptr_size = (size_t)(intptr_t)arglist[arg_i];
  511. nargs++;
  512. _starpu_pack_arguments(&current_offset, &arg_buffer_size_, &arg_buffer_, ptr, ptr_size);
  513. }
  514. else if (arg_type == STARPU_CL_ARGS)
  515. {
  516. arg_i++;
  517. (*task)->cl_arg = arglist[arg_i];
  518. arg_i++;
  519. (*task)->cl_arg_size = (size_t)(intptr_t)arglist[arg_i];
  520. (*task)->cl_arg_free = 1;
  521. }
  522. else if (arg_type == STARPU_CALLBACK)
  523. {
  524. arg_i++;
  525. (*task)->callback_func = (_starpu_callback_func_t)arglist[arg_i];
  526. }
  527. else if (arg_type == STARPU_CALLBACK_WITH_ARG)
  528. {
  529. arg_i++;
  530. (*task)->callback_func = (_starpu_callback_func_t)arglist[arg_i];
  531. arg_i++;
  532. (*task)->callback_arg = arglist[arg_i];
  533. }
  534. else if (arg_type == STARPU_CALLBACK_ARG)
  535. {
  536. arg_i++;
  537. (*task)->callback_arg = arglist[arg_i];
  538. }
  539. else if (arg_type == STARPU_PROLOGUE_CALLBACK)
  540. {
  541. arg_i++;
  542. (*task)->prologue_callback_func = (_starpu_callback_func_t)arglist[arg_i];
  543. }
  544. else if (arg_type == STARPU_PROLOGUE_CALLBACK_ARG)
  545. {
  546. arg_i++;
  547. (*task)->prologue_callback_arg = arglist[arg_i];
  548. }
  549. else if (arg_type == STARPU_PROLOGUE_CALLBACK_POP)
  550. {
  551. arg_i++;
  552. (*task)->prologue_callback_pop_func = (_starpu_callback_func_t)arglist[arg_i];
  553. }
  554. else if (arg_type == STARPU_PROLOGUE_CALLBACK_POP_ARG)
  555. {
  556. arg_i++;
  557. (*task)->prologue_callback_pop_arg = arglist[arg_i];
  558. }
  559. else if (arg_type == STARPU_PRIORITY)
  560. {
  561. arg_i++;
  562. (*task)->priority = *(int *)arglist[arg_i];
  563. }
  564. else if (arg_type == STARPU_EXECUTE_ON_NODE)
  565. {
  566. arg_i++;
  567. (void)arglist[arg_i];
  568. }
  569. else if (arg_type == STARPU_EXECUTE_ON_DATA)
  570. {
  571. arg_i++;
  572. (void)arglist[arg_i];
  573. }
  574. else if (arg_type == STARPU_EXECUTE_WHERE)
  575. {
  576. assert(0);
  577. arg_i++;
  578. unsigned long long where = *(unsigned long long *)arglist[arg_i];
  579. (*task)->where = where;
  580. }
  581. else if (arg_type == STARPU_EXECUTE_ON_WORKER)
  582. {
  583. arg_i++;
  584. int worker = *(int *)arglist[arg_i];
  585. if (worker != -1)
  586. {
  587. (*task)->workerid = worker;
  588. (*task)->execute_on_a_specific_worker = 1;
  589. }
  590. }
  591. else if (arg_type == STARPU_WORKER_ORDER)
  592. {
  593. arg_i++;
  594. unsigned order = *(unsigned *)arglist[arg_i];
  595. if (order != 0)
  596. {
  597. STARPU_ASSERT_MSG((*task)->execute_on_a_specific_worker, "worker order only makes sense if a workerid is provided");
  598. (*task)->workerorder = order;
  599. }
  600. }
  601. else if (arg_type == STARPU_SCHED_CTX)
  602. {
  603. arg_i++;
  604. (*task)->sched_ctx = *(unsigned *)arglist[arg_i];
  605. }
  606. else if (arg_type == STARPU_HYPERVISOR_TAG)
  607. {
  608. arg_i++;
  609. (*task)->hypervisor_tag = *(int *)arglist[arg_i];
  610. }
  611. else if (arg_type == STARPU_POSSIBLY_PARALLEL)
  612. {
  613. arg_i++;
  614. (*task)->possibly_parallel = *(unsigned *)arglist[arg_i];
  615. }
  616. else if (arg_type == STARPU_FLOPS)
  617. {
  618. arg_i++;
  619. (*task)->flops = *(double *)arglist[arg_i];
  620. }
  621. else if (arg_type == STARPU_TAG)
  622. {
  623. arg_i++;
  624. (*task)->tag_id = *(starpu_tag_t *)arglist[arg_i];
  625. (*task)->use_tag = 1;
  626. }
  627. else if (arg_type == STARPU_TAG_ONLY)
  628. {
  629. arg_i++;
  630. (*task)->tag_id = *(starpu_tag_t *)arglist[arg_i];
  631. }
  632. else if (arg_type == STARPU_NAME)
  633. {
  634. arg_i++;
  635. (*task)->name = arglist[arg_i];
  636. }
  637. else if (arg_type == STARPU_NODE_SELECTION_POLICY)
  638. {
  639. arg_i++;
  640. (void)arglist[arg_i];
  641. }
  642. else
  643. {
  644. STARPU_ABORT_MSG("unknown/unsupported argument %d, did you perhaps forget to end arguments with 0?", arg_type);
  645. }
  646. arg_i++;
  647. }
  648. if (cl)
  649. {
  650. if (cl->nbuffers == STARPU_VARIABLE_NBUFFERS)
  651. {
  652. (*task)->nbuffers = current_buffer;
  653. }
  654. else
  655. {
  656. STARPU_ASSERT_MSG(current_buffer == cl->nbuffers, "Incoherent number of buffers between cl (%d) and number of parameters (%d)", cl->nbuffers, current_buffer);
  657. }
  658. }
  659. if (nargs)
  660. {
  661. if ((*task)->cl_arg != NULL)
  662. {
  663. _STARPU_DISP("Parameters STARPU_CL_ARGS and STARPU_VALUE cannot be used in the same call\n");
  664. free(arg_buffer_);
  665. arg_buffer_ = NULL;
  666. return -EINVAL;
  667. }
  668. memcpy(arg_buffer_, (int *)&nargs, sizeof(nargs));
  669. (*task)->cl_arg = arg_buffer_;
  670. (*task)->cl_arg_size = arg_buffer_size_;
  671. }
  672. else
  673. {
  674. free(arg_buffer_);
  675. arg_buffer_ = NULL;
  676. }
  677. _STARPU_TRACE_TASK_BUILD_END();
  678. return 0;
  679. }
  680. /* Fortran interface to task_insert */
  681. void fstarpu_task_insert(void **arglist)
  682. {
  683. struct starpu_codelet *cl = arglist[0];
  684. if (cl == NULL)
  685. {
  686. STARPU_ABORT_MSG("task without codelet");
  687. }
  688. struct starpu_task *task = starpu_task_create();
  689. int ret = _fstarpu_task_insert_create(cl, &task, arglist+1);
  690. if (ret != 0)
  691. {
  692. STARPU_ABORT_MSG("task creation failed");
  693. }
  694. ret = starpu_task_submit(task);
  695. if (ret != 0)
  696. {
  697. STARPU_ABORT_MSG("starpu_task_submit failed");
  698. }
  699. }
  700. /* fstarpu_insert_task: aliased to fstarpu_task_insert in fstarpu_mod.f90 */