StarPU Internal Handbook
fxt.h
Go to the documentation of this file.
1 /* StarPU --- Runtime system for heterogeneous multicore architectures.
2  *
3  * Copyright (C) 2008-2020 Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
4  * Copyright (C) 2013 Joris Pablo
5  * Copyright (C) 2018,2020 Federal University of Rio Grande do Sul (UFRGS)
6  *
7  * StarPU is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser General Public License as published by
9  * the Free Software Foundation; either version 2.1 of the License, or (at
10  * your option) any later version.
11  *
12  * StarPU is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
15  *
16  * See the GNU Lesser General Public License in COPYING.LGPL for more details.
17  */
18 
19 #ifndef __FXT_H__
20 #define __FXT_H__
21 
22 
25 #ifndef _GNU_SOURCE
26 #define _GNU_SOURCE 1 /* ou _BSD_SOURCE ou _SVID_SOURCE */
27 #endif
28 
29 #include <string.h>
30 #include <sys/types.h>
31 #include <stdlib.h>
32 #include <common/config.h>
33 #ifdef HAVE_UNISTD_H
34 #include <unistd.h>
35 #endif
36 #include <common/utils.h>
37 #include <starpu.h>
38 
39 /* some key to identify the worker kind */
40 #define _STARPU_FUT_APPS_KEY 0x100
41 #define _STARPU_FUT_CPU_KEY 0x101
42 #define _STARPU_FUT_CUDA_KEY 0x102
43 #define _STARPU_FUT_OPENCL_KEY 0x103
44 #define _STARPU_FUT_MIC_KEY 0x104
45 #define _STARPU_FUT_MPI_KEY 0x106
46 
47 #define _STARPU_FUT_WORKER_INIT_START 0x5100
48 #define _STARPU_FUT_WORKER_INIT_END 0x5101
49 
50 #define _STARPU_FUT_START_CODELET_BODY 0x5102
51 #define _STARPU_FUT_END_CODELET_BODY 0x5103
52 
53 #define _STARPU_FUT_JOB_PUSH 0x5104
54 #define _STARPU_FUT_JOB_POP 0x5105
55 
56 #define _STARPU_FUT_UPDATE_TASK_CNT 0x5106
57 
58 #define _STARPU_FUT_START_FETCH_INPUT_ON_TID 0x5107
59 #define _STARPU_FUT_END_FETCH_INPUT_ON_TID 0x5108
60 #define _STARPU_FUT_START_PUSH_OUTPUT_ON_TID 0x5109
61 #define _STARPU_FUT_END_PUSH_OUTPUT_ON_TID 0x5110
62 
63 #define _STARPU_FUT_TAG 0x5111
64 #define _STARPU_FUT_TAG_DEPS 0x5112
65 
66 #define _STARPU_FUT_TASK_DEPS 0x5113
67 
68 #define _STARPU_FUT_DATA_COPY 0x5114
69 #define _STARPU_FUT_WORK_STEALING 0x5115
70 
71 #define _STARPU_FUT_WORKER_DEINIT_START 0x5116
72 #define _STARPU_FUT_WORKER_DEINIT_END 0x5117
73 
74 #define _STARPU_FUT_WORKER_SLEEP_START 0x5118
75 #define _STARPU_FUT_WORKER_SLEEP_END 0x5119
76 
77 #define _STARPU_FUT_TASK_SUBMIT 0x511a
78 #define _STARPU_FUT_CODELET_DATA_HANDLE 0x511b
79 
80 #define _STARPU_FUT_MODEL_NAME 0x511c
81 
82 #define _STARPU_FUT_DATA_NAME 0x511d
83 #define _STARPU_FUT_DATA_COORDINATES 0x511e
84 #define _STARPU_FUT_HANDLE_DATA_UNREGISTER 0x511f
85 
86 #define _STARPU_FUT_USER_DEFINED_START 0x5120
87 #define _STARPU_FUT_USER_DEFINED_END 0x5121
88 
89 #define _STARPU_FUT_NEW_MEM_NODE 0x5122
90 
91 #define _STARPU_FUT_START_CALLBACK 0x5123
92 #define _STARPU_FUT_END_CALLBACK 0x5124
93 
94 #define _STARPU_FUT_TASK_DONE 0x5125
95 #define _STARPU_FUT_TAG_DONE 0x5126
96 
97 #define _STARPU_FUT_START_ALLOC 0x5127
98 #define _STARPU_FUT_END_ALLOC 0x5128
99 
100 #define _STARPU_FUT_START_ALLOC_REUSE 0x5129
101 #define _STARPU_FUT_END_ALLOC_REUSE 0x5130
102 
103 #define _STARPU_FUT_USED_MEM 0x512a
104 
105 #define _STARPU_FUT_TASK_NAME 0x512b
106 
107 #define _STARPU_FUT_DATA_WONT_USE 0x512c
108 
109 #define _STARPU_FUT_TASK_COLOR 0x512d
110 
111 #define _STARPU_FUT_DATA_DOING_WONT_USE 0x512e
112 
113 #define _STARPU_FUT_START_MEMRECLAIM 0x5131
114 #define _STARPU_FUT_END_MEMRECLAIM 0x5132
115 
116 #define _STARPU_FUT_START_DRIVER_COPY 0x5133
117 #define _STARPU_FUT_END_DRIVER_COPY 0x5134
118 
119 #define _STARPU_FUT_START_DRIVER_COPY_ASYNC 0x5135
120 #define _STARPU_FUT_END_DRIVER_COPY_ASYNC 0x5136
121 
122 #define _STARPU_FUT_START_PROGRESS_ON_TID 0x5137
123 #define _STARPU_FUT_END_PROGRESS_ON_TID 0x5138
124 
125 #define _STARPU_FUT_USER_EVENT 0x5139
126 
127 #define _STARPU_FUT_SET_PROFILING 0x513a
128 
129 #define _STARPU_FUT_TASK_WAIT_FOR_ALL 0x513b
130 
131 #define _STARPU_FUT_EVENT 0x513c
132 #define _STARPU_FUT_THREAD_EVENT 0x513d
133 
134 #define _STARPU_FUT_CODELET_DETAILS 0x513e
135 #define _STARPU_FUT_CODELET_DATA 0x513f
136 
137 #define _STARPU_FUT_LOCKING_MUTEX 0x5140
138 #define _STARPU_FUT_MUTEX_LOCKED 0x5141
139 
140 #define _STARPU_FUT_UNLOCKING_MUTEX 0x5142
141 #define _STARPU_FUT_MUTEX_UNLOCKED 0x5143
142 
143 #define _STARPU_FUT_TRYLOCK_MUTEX 0x5144
144 
145 #define _STARPU_FUT_RDLOCKING_RWLOCK 0x5145
146 #define _STARPU_FUT_RWLOCK_RDLOCKED 0x5146
147 
148 #define _STARPU_FUT_WRLOCKING_RWLOCK 0x5147
149 #define _STARPU_FUT_RWLOCK_WRLOCKED 0x5148
150 
151 #define _STARPU_FUT_UNLOCKING_RWLOCK 0x5149
152 #define _STARPU_FUT_RWLOCK_UNLOCKED 0x514a
153 
154 #define _STARPU_FUT_LOCKING_SPINLOCK 0x514b
155 #define _STARPU_FUT_SPINLOCK_LOCKED 0x514c
156 
157 #define _STARPU_FUT_UNLOCKING_SPINLOCK 0x514d
158 #define _STARPU_FUT_SPINLOCK_UNLOCKED 0x514e
159 
160 #define _STARPU_FUT_TRYLOCK_SPINLOCK 0x514f
161 
162 #define _STARPU_FUT_COND_WAIT_BEGIN 0x5150
163 #define _STARPU_FUT_COND_WAIT_END 0x5151
164 
165 #define _STARPU_FUT_MEMORY_FULL 0x5152
166 
167 #define _STARPU_FUT_DATA_LOAD 0x5153
168 
169 #define _STARPU_FUT_START_UNPARTITION_ON_TID 0x5154
170 #define _STARPU_FUT_END_UNPARTITION_ON_TID 0x5155
171 
172 #define _STARPU_FUT_START_FREE 0x5156
173 #define _STARPU_FUT_END_FREE 0x5157
174 
175 #define _STARPU_FUT_START_WRITEBACK 0x5158
176 #define _STARPU_FUT_END_WRITEBACK 0x5159
177 
178 #define _STARPU_FUT_SCHED_COMPONENT_PUSH_PRIO 0x515a
179 #define _STARPU_FUT_SCHED_COMPONENT_POP_PRIO 0x515b
180 
181 #define _STARPU_FUT_START_WRITEBACK_ASYNC 0x515c
182 #define _STARPU_FUT_END_WRITEBACK_ASYNC 0x515d
183 
184 #define _STARPU_FUT_HYPERVISOR_BEGIN 0x5160
185 #define _STARPU_FUT_HYPERVISOR_END 0x5161
186 
187 #define _STARPU_FUT_BARRIER_WAIT_BEGIN 0x5162
188 #define _STARPU_FUT_BARRIER_WAIT_END 0x5163
189 
190 #define _STARPU_FUT_WORKER_SCHEDULING_START 0x5164
191 #define _STARPU_FUT_WORKER_SCHEDULING_END 0x5165
192 #define _STARPU_FUT_WORKER_SCHEDULING_PUSH 0x5166
193 #define _STARPU_FUT_WORKER_SCHEDULING_POP 0x5167
194 
195 #define _STARPU_FUT_START_EXECUTING 0x5168
196 #define _STARPU_FUT_END_EXECUTING 0x5169
197 
198 #define _STARPU_FUT_SCHED_COMPONENT_NEW 0x516a
199 #define _STARPU_FUT_SCHED_COMPONENT_CONNECT 0x516b
200 #define _STARPU_FUT_SCHED_COMPONENT_PUSH 0x516c
201 #define _STARPU_FUT_SCHED_COMPONENT_PULL 0x516d
202 
203 #define _STARPU_FUT_TASK_SUBMIT_START 0x516e
204 #define _STARPU_FUT_TASK_SUBMIT_END 0x516f
205 
206 #define _STARPU_FUT_TASK_BUILD_START 0x5170
207 #define _STARPU_FUT_TASK_BUILD_END 0x5171
208 
209 #define _STARPU_FUT_TASK_MPI_DECODE_START 0x5172
210 #define _STARPU_FUT_TASK_MPI_DECODE_END 0x5173
211 
212 #define _STARPU_FUT_TASK_MPI_PRE_START 0x5174
213 #define _STARPU_FUT_TASK_MPI_PRE_END 0x5175
214 
215 #define _STARPU_FUT_TASK_MPI_POST_START 0x5176
216 #define _STARPU_FUT_TASK_MPI_POST_END 0x5177
217 
218 #define _STARPU_FUT_TASK_WAIT_START 0x5178
219 #define _STARPU_FUT_TASK_WAIT_END 0x5179
220 
221 #define _STARPU_FUT_TASK_WAIT_FOR_ALL_START 0x517a
222 #define _STARPU_FUT_TASK_WAIT_FOR_ALL_END 0x517b
223 
224 #define _STARPU_FUT_HANDLE_DATA_REGISTER 0x517c
225 
226 #define _STARPU_FUT_START_FETCH_INPUT 0x517e
227 #define _STARPU_FUT_END_FETCH_INPUT 0x517f
228 
229 #define _STARPU_FUT_TASK_THROTTLE_START 0x5180
230 #define _STARPU_FUT_TASK_THROTTLE_END 0x5181
231 
232 #define _STARPU_FUT_DATA_STATE_INVALID 0x5182
233 #define _STARPU_FUT_DATA_STATE_OWNER 0x5183
234 #define _STARPU_FUT_DATA_STATE_SHARED 0x5184
235 
236 #define _STARPU_FUT_DATA_REQUEST_CREATED 0x5185
237 
238 extern unsigned long _starpu_job_cnt;
239 
240 static inline unsigned long _starpu_fxt_get_job_id(void)
241 {
242  unsigned long ret = STARPU_ATOMIC_ADDL(&_starpu_job_cnt, 1);
243  STARPU_ASSERT_MSG(_starpu_job_cnt != 0, "Oops, job_id wrapped! There are too many tasks for tracking them for profiling");
244  return ret;
245 }
246 
247 #ifdef STARPU_USE_FXT
248 #include <fxt/fxt.h>
249 #include <fxt/fut.h>
250 
251 /* Some versions of FxT do not include the declaration of the function */
252 #ifdef HAVE_ENABLE_FUT_FLUSH
253 #if !HAVE_DECL_ENABLE_FUT_FLUSH
254 void enable_fut_flush();
255 #endif
256 #endif
257 #ifdef HAVE_FUT_SET_FILENAME
258 #if !HAVE_DECL_FUT_SET_FILENAME
259 void fut_set_filename(char *filename);
260 #endif
261 #endif
262 
263 extern int _starpu_fxt_started;
264 extern int _starpu_fxt_willstart;
265 extern starpu_pthread_mutex_t _starpu_fxt_started_mutex;
266 extern starpu_pthread_cond_t _starpu_fxt_started_cond;
267 
268 static inline void _starpu_fxt_wait_initialisation()
269 {
270  STARPU_PTHREAD_MUTEX_LOCK(&_starpu_fxt_started_mutex);
271  while (_starpu_fxt_willstart && !_starpu_fxt_started)
272  STARPU_PTHREAD_COND_WAIT(&_starpu_fxt_started_cond, &_starpu_fxt_started_mutex);
273  STARPU_PTHREAD_MUTEX_UNLOCK(&_starpu_fxt_started_mutex);
274 }
275 
276 extern unsigned long _starpu_submit_order;
277 
278 static inline unsigned long _starpu_fxt_get_submit_order(void)
279 {
280  unsigned long ret = STARPU_ATOMIC_ADDL(&_starpu_submit_order, 1);
281  STARPU_ASSERT_MSG(_starpu_submit_order != 0, "Oops, submit_order wrapped! There are too many tasks for tracking them for profiling");
282  return ret;
283 }
284 
285 long _starpu_gettid(void);
286 
288 void _starpu_fxt_init_profiling(unsigned trace_buffer_size);
289 
291 void _starpu_stop_fxt_profiling(void);
292 
294 void _starpu_fxt_dump_file(void);
295 
296 /* Associate the current processing unit to the identifier of the LWP that runs
297  * the worker. */
298 void _starpu_fxt_register_thread(unsigned);
299 
300 #ifdef FUT_NEEDS_COMMIT
301 #define _STARPU_FUT_COMMIT(size) fut_commitstampedbuffer(size)
302 #else
303 #define _STARPU_FUT_COMMIT(size) do { } while (0)
304 #endif
305 
306 #ifdef FUT_DO_PROBE1STR
307 #define _STARPU_FUT_DO_PROBE1STR(CODE, P1, str) FUT_DO_PROBE1STR(CODE, P1, str)
308 #else
309 
312 #define _STARPU_FUT_DO_PROBE1STR(CODE, P1, str) \
313 do { \
314  if(fut_active) { \
315  /* No more than FXT_MAX_PARAMS args are allowed */ \
316  /* we add a \0 just in case ... */ \
317  size_t len = STARPU_MIN(strlen(str)+1, (FXT_MAX_PARAMS - 1)*sizeof(unsigned long));\
318  unsigned nbargs_str = (len + sizeof(unsigned long) - 1)/(sizeof(unsigned long));\
319  unsigned nbargs = 1 + nbargs_str; \
320  size_t total_len = FUT_SIZE(nbargs); \
321  unsigned long *futargs = \
322  fut_getstampedbuffer(FUT_CODE(CODE, nbargs), total_len);\
323  *(futargs++) = (unsigned long)(P1); \
324  snprintf((char *)futargs, len, "%s", str); \
325  ((char *)futargs)[len - 1] = '\0'; \
326  _STARPU_FUT_COMMIT(total_len); \
327  } \
328 } while (0);
329 #endif
330 
331 #ifdef FUT_DO_PROBE2STR
332 #define _STARPU_FUT_DO_PROBE2STR(CODE, P1, P2, str) FUT_DO_PROBE2STR(CODE, P1, P2, str)
333 #else
334 
337 #define _STARPU_FUT_DO_PROBE2STR(CODE, P1, P2, str) \
338 do { \
339  if(fut_active) { \
340  /* No more than FXT_MAX_PARAMS args are allowed */ \
341  /* we add a \0 just in case ... */ \
342  size_t len = STARPU_MIN(strlen(str)+1, (FXT_MAX_PARAMS - 2)*sizeof(unsigned long));\
343  unsigned nbargs_str = (len + sizeof(unsigned long) - 1)/(sizeof(unsigned long));\
344  unsigned nbargs = 2 + nbargs_str; \
345  size_t total_len = FUT_SIZE(nbargs); \
346  unsigned long *futargs = \
347  fut_getstampedbuffer(FUT_CODE(CODE, nbargs), total_len);\
348  *(futargs++) = (unsigned long)(P1); \
349  *(futargs++) = (unsigned long)(P2); \
350  snprintf((char *)futargs, len, "%s", str); \
351  ((char *)futargs)[len - 1] = '\0'; \
352  _STARPU_FUT_COMMIT(total_len); \
353  } \
354 } while (0);
355 #endif
356 
357 #ifdef FUT_DO_PROBE3STR
358 #define _STARPU_FUT_DO_PROBE3STR(CODE, P1, P2, P3, str) FUT_DO_PROBE3STR(CODE, P1, P2, P3, str)
359 #else
360 #define _STARPU_FUT_DO_PROBE3STR(CODE, P1, P2, P3, str) \
361 do { \
362  if(fut_active) { \
363  /* No more than FXT_MAX_PARAMS args are allowed */ \
364  /* we add a \0 just in case ... */ \
365  size_t len = STARPU_MIN(strlen(str)+1, (FXT_MAX_PARAMS - 3)*sizeof(unsigned long));\
366  unsigned nbargs_str = (len + sizeof(unsigned long) - 1)/(sizeof(unsigned long));\
367  unsigned nbargs = 3 + nbargs_str; \
368  size_t total_len = FUT_SIZE(nbargs); \
369  unsigned long *futargs = \
370  fut_getstampedbuffer(FUT_CODE(CODE, nbargs), total_len);\
371  *(futargs++) = (unsigned long)(P1); \
372  *(futargs++) = (unsigned long)(P2); \
373  *(futargs++) = (unsigned long)(P3); \
374  snprintf((char *)futargs, len, "%s", str); \
375  ((char *)futargs)[len - 1] = '\0'; \
376  _STARPU_FUT_COMMIT(total_len); \
377  } \
378 } while (0);
379 #endif
380 
381 #ifdef FUT_DO_PROBE4STR
382 #define _STARPU_FUT_DO_PROBE4STR(CODE, P1, P2, P3, P4, str) FUT_DO_PROBE4STR(CODE, P1, P2, P3, P4, str)
383 #else
384 #define _STARPU_FUT_DO_PROBE4STR(CODE, P1, P2, P3, P4, str) \
385 do { \
386  if(fut_active) { \
387  /* No more than FXT_MAX_PARAMS args are allowed */ \
388  /* we add a \0 just in case ... */ \
389  size_t len = STARPU_MIN(strlen(str)+1, (FXT_MAX_PARAMS - 4)*sizeof(unsigned long));\
390  unsigned nbargs_str = (len + sizeof(unsigned long) - 1)/(sizeof(unsigned long));\
391  unsigned nbargs = 4 + nbargs_str; \
392  size_t total_len = FUT_SIZE(nbargs); \
393  unsigned long *futargs = \
394  fut_getstampedbuffer(FUT_CODE(CODE, nbargs), total_len);\
395  *(futargs++) = (unsigned long)(P1); \
396  *(futargs++) = (unsigned long)(P2); \
397  *(futargs++) = (unsigned long)(P3); \
398  *(futargs++) = (unsigned long)(P4); \
399  snprintf((char *)futargs, len, "%s", str); \
400  ((char *)futargs)[len - 1] = '\0'; \
401  _STARPU_FUT_COMMIT(total_len); \
402  } \
403 } while (0);
404 #endif
405 
406 #ifdef FUT_DO_PROBE5STR
407 #define _STARPU_FUT_DO_PROBE5STR(CODE, P1, P2, P3, P4, P5, str) FUT_DO_PROBE5STR(CODE, P1, P2, P3, P4, P5, str)
408 #else
409 #define _STARPU_FUT_DO_PROBE5STR(CODE, P1, P2, P3, P4, P5, str) \
410 do { \
411  if(fut_active) { \
412  /* No more than FXT_MAX_PARAMS args are allowed */ \
413  /* we add a \0 just in case ... */ \
414  size_t len = STARPU_MIN(strlen(str)+1, (FXT_MAX_PARAMS - 5)*sizeof(unsigned long));\
415  unsigned nbargs_str = (len + sizeof(unsigned long) - 1)/(sizeof(unsigned long));\
416  unsigned nbargs = 5 + nbargs_str; \
417  size_t total_len = FUT_SIZE(nbargs); \
418  unsigned long *futargs = \
419  fut_getstampedbuffer(FUT_CODE(CODE, nbargs), total_len);\
420  *(futargs++) = (unsigned long)(P1); \
421  *(futargs++) = (unsigned long)(P2); \
422  *(futargs++) = (unsigned long)(P3); \
423  *(futargs++) = (unsigned long)(P4); \
424  *(futargs++) = (unsigned long)(P5); \
425  snprintf((char *)futargs, len, "%s", str); \
426  ((char *)futargs)[len - 1] = '\0'; \
427  _STARPU_FUT_COMMIT(total_len); \
428  } \
429 } while (0);
430 #endif
431 
432 #ifdef FUT_DO_PROBE6STR
433 #define _STARPU_FUT_DO_PROBE6STR(CODE, P1, P2, P3, P4, P5, P6, str) FUT_DO_PROBE6STR(CODE, P1, P2, P3, P4, P5, P6, str)
434 #else
435 #define _STARPU_FUT_DO_PROBE6STR(CODE, P1, P2, P3, P4, P5, P6, str) \
436 do { \
437  if(fut_active) { \
438  /* No more than FXT_MAX_PARAMS args are allowed */ \
439  /* we add a \0 just in case ... */ \
440  size_t len = STARPU_MIN(strlen(str)+1, (FXT_MAX_PARAMS - 6)*sizeof(unsigned long));\
441  unsigned nbargs_str = (len + sizeof(unsigned long) - 1)/(sizeof(unsigned long));\
442  unsigned nbargs = 6 + nbargs_str; \
443  size_t total_len = FUT_SIZE(nbargs); \
444  unsigned long *futargs = \
445  fut_getstampedbuffer(FUT_CODE(CODE, nbargs), total_len);\
446  *(futargs++) = (unsigned long)(P1); \
447  *(futargs++) = (unsigned long)(P2); \
448  *(futargs++) = (unsigned long)(P3); \
449  *(futargs++) = (unsigned long)(P4); \
450  *(futargs++) = (unsigned long)(P5); \
451  *(futargs++) = (unsigned long)(P6); \
452  snprintf((char *)futargs, len, "%s", str); \
453  ((char *)futargs)[len - 1] = '\0'; \
454  _STARPU_FUT_COMMIT(total_len); \
455  } \
456 } while (0);
457 #endif
458 
459 #ifdef FUT_DO_PROBE7STR
460 #define _STARPU_FUT_DO_PROBE7STR(CODE, P1, P2, P3, P4, P5, P6, P7, str) FUT_DO_PROBE7STR(CODE, P1, P2, P3, P4, P5, P6, P7, str)
461 #else
462 #define _STARPU_FUT_DO_PROBE7STR(CODE, P1, P2, P3, P4, P5, P6, P7, str) \
463 do { \
464  if(fut_active) { \
465  /* No more than FXT_MAX_PARAMS args are allowed */ \
466  /* we add a \0 just in case ... */ \
467  size_t len = STARPU_MIN(strlen(str)+1, (FXT_MAX_PARAMS - 7)*sizeof(unsigned long));\
468  unsigned nbargs_str = (len + sizeof(unsigned long) - 1)/(sizeof(unsigned long));\
469  unsigned nbargs = 7 + nbargs_str; \
470  size_t total_len = FUT_SIZE(nbargs); \
471  unsigned long *futargs = \
472  fut_getstampedbuffer(FUT_CODE(CODE, nbargs), total_len);\
473  *(futargs++) = (unsigned long)(P1); \
474  *(futargs++) = (unsigned long)(P2); \
475  *(futargs++) = (unsigned long)(P3); \
476  *(futargs++) = (unsigned long)(P4); \
477  *(futargs++) = (unsigned long)(P5); \
478  *(futargs++) = (unsigned long)(P6); \
479  *(futargs++) = (unsigned long)(P7); \
480  snprintf((char *)futargs, len, "%s", str); \
481  ((char *)futargs)[len - 1] = '\0'; \
482  _STARPU_FUT_COMMIT(total_len); \
483  } \
484 } while (0);
485 #endif
486 
487 #ifndef FUT_RAW_PROBE7
488 #define FUT_RAW_PROBE7(CODE,P1,P2,P3,P4,P5,P6,P7) do { \
489  if(fut_active) { \
490  unsigned long *__args __attribute__((unused))= \
491  fut_getstampedbuffer(CODE, \
492  FUT_SIZE(7)); \
493  *(__args++)=(unsigned long)(P1);*(__args++)=(unsigned long)(P2);*(__args++)=(unsigned long)(P3);*(__args++)=(unsigned long)(P4);*(__args++)=(unsigned long)(P5);*(__args++)=(unsigned long)(P6);*(__args++)=(unsigned long)(P7); \
494  _STARPU_FUT_COMMIT(FUT_SIZE(7)); \
495  } \
496  } while (0)
497 #endif
498 
499 #ifndef FUT_DO_PROBE7
500 #define FUT_DO_PROBE7(CODE,P1,P2,P3,P4,P5,P6,P7) do { \
501  FUT_RAW_PROBE7(FUT_CODE(CODE, 7),P1,P2,P3,P4,P5,P6,P7); \
502 } while (0)
503 #endif
504 
505 #ifndef FUT_RAW_ALWAYS_PROBE2
506 #define FUT_RAW_ALWAYS_PROBE2(CODE,P1,P2) do { \
507  unsigned long *__args __attribute__((unused))= \
508  fut_getstampedbuffer(CODE, \
509  FUT_SIZE(2)); \
510  *(__args++)=(unsigned long)(P1);*(__args++)=(unsigned long)(P2); \
511  fut_commitstampedbuffer(FUT_SIZE(2)); \
512  } while (0)
513 #endif
514 #define FUT_DO_ALWAYS_PROBE2(CODE,P1,P2) do { \
515  FUT_RAW_ALWAYS_PROBE2(FUT_CODE(CODE, 2),P1,P2); \
516 } while (0)
517 
518 #ifndef FUT_RAW_ALWAYS_PROBE3
519 #define FUT_RAW_ALWAYS_PROBE3(CODE,P1,P2,P3) do { \
520  unsigned long *__args __attribute__((unused))= \
521  fut_getstampedbuffer(CODE, \
522  FUT_SIZE(3)); \
523  *(__args++)=(unsigned long)(P1);*(__args++)=(unsigned long)(P2);*(__args++)=(unsigned long)(P3); \
524  fut_commitstampedbuffer(FUT_SIZE(3)); \
525  } while (0)
526 #endif
527 #define FUT_DO_ALWAYS_PROBE3(CODE,P1,P2,P3) do { \
528  FUT_RAW_ALWAYS_PROBE3(FUT_CODE(CODE, 3),P1,P2,P3); \
529 } while (0)
530 
531 #ifndef FUT_RAW_ALWAYS_PROBE4
532 #define FUT_RAW_ALWAYS_PROBE4(CODE,P1,P2,P3,P4) do { \
533  unsigned long *__args __attribute__((unused))= \
534  fut_getstampedbuffer(CODE, \
535  FUT_SIZE(4)); \
536  *(__args++)=(unsigned long)(P1);*(__args++)=(unsigned long)(P2);*(__args++)=(unsigned long)(P3);*(__args++)=(unsigned long)(P4); \
537  fut_commitstampedbuffer(FUT_SIZE(4)); \
538  } while (0)
539 #endif
540 #define FUT_DO_ALWAYS_PROBE4(CODE,P1,P2,P3,P4) do { \
541  FUT_RAW_ALWAYS_PROBE4(FUT_CODE(CODE, 4),P1,P2,P3,P4); \
542 } while (0)
543 
544 #ifndef FUT_RAW_ALWAYS_PROBE5
545 #define FUT_RAW_ALWAYS_PROBE5(CODE,P1,P2,P3,P4,P5) do { \
546  unsigned long *__args __attribute__((unused))= \
547  fut_getstampedbuffer(CODE, \
548  FUT_SIZE(5)); \
549  *(__args++)=(unsigned long)(P1);*(__args++)=(unsigned long)(P2);*(__args++)=(unsigned long)(P3);*(__args++)=(unsigned long)(P4);*(__args++)=(unsigned long)(P5); \
550  fut_commitstampedbuffer(FUT_SIZE(5)); \
551  } while (0)
552 #endif
553 #define FUT_DO_ALWAYS_PROBE5(CODE,P1,P2,P3,P4,P5) do { \
554  FUT_RAW_ALWAYS_PROBE5(FUT_CODE(CODE, 5),P1,P2,P3,P4,P5); \
555 } while (0)
556 
557 #ifndef FUT_RAW_ALWAYS_PROBE6
558 #define FUT_RAW_ALWAYS_PROBE6(CODE,P1,P2,P3,P4,P5,P6) do { \
559  unsigned long *__args __attribute__((unused))= \
560  fut_getstampedbuffer(CODE, \
561  FUT_SIZE(6)); \
562  *(__args++)=(unsigned long)(P1);*(__args++)=(unsigned long)(P2);*(__args++)=(unsigned long)(P3);*(__args++)=(unsigned long)(P4);*(__args++)=(unsigned long)(P5);*(__args++)=(unsigned long)(P6); \
563  fut_commitstampedbuffer(FUT_SIZE(6)); \
564  } while (0)
565 #endif
566 #define FUT_DO_ALWAYS_PROBE6(CODE,P1,P2,P3,P4,P5,P6) do { \
567  FUT_RAW_ALWAYS_PROBE6(FUT_CODE(CODE, 6),P1,P2,P3,P4,P5,P6); \
568 } while (0)
569 
570 #ifndef FUT_RAW_ALWAYS_PROBE7
571 #define FUT_RAW_ALWAYS_PROBE7(CODE,P1,P2,P3,P4,P5,P6,P7) do { \
572  unsigned long *__args __attribute__((unused))= \
573  fut_getstampedbuffer(CODE, \
574  FUT_SIZE(7)); \
575  *(__args++)=(unsigned long)(P1);*(__args++)=(unsigned long)(P2);*(__args++)=(unsigned long)(P3);*(__args++)=(unsigned long)(P4);*(__args++)=(unsigned long)(P5);*(__args++)=(unsigned long)(P6);*(__args++)=(unsigned long)(P7); \
576  fut_commitstampedbuffer(FUT_SIZE(7)); \
577  } while (0)
578 #endif
579 #define FUT_DO_ALWAYS_PROBE7(CODE,P1,P2,P3,P4,P5,P6,P7) do { \
580  FUT_RAW_ALWAYS_PROBE7(FUT_CODE(CODE, 7),P1,P2,P3,P4,P5,P6,P7); \
581 } while (0)
582 
583 
584 
585 /* workerkind = _STARPU_FUT_CPU_KEY for instance */
586 #define _STARPU_TRACE_NEW_MEM_NODE(nodeid) do {\
587  if (_starpu_fxt_started) \
588  FUT_DO_ALWAYS_PROBE2(_STARPU_FUT_NEW_MEM_NODE, nodeid, _starpu_gettid()); \
589 } while (0)
590 
591 #define _STARPU_TRACE_WORKER_INIT_START(workerkind, workerid, devid, memnode, bindid, sync) \
592  FUT_DO_PROBE7(_STARPU_FUT_WORKER_INIT_START, workerkind, workerid, devid, memnode, bindid, sync, _starpu_gettid());
593 
594 #define _STARPU_TRACE_WORKER_INIT_END(__workerid) \
595  FUT_DO_PROBE2(_STARPU_FUT_WORKER_INIT_END, _starpu_gettid(), (__workerid));
596 
597 #define _STARPU_TRACE_START_CODELET_BODY(job, nimpl, perf_arch, workerid) \
598 do { \
599  const char *model_name = _starpu_job_get_model_name((job)), *name = _starpu_job_get_task_name((job)); \
600  if (name) \
601  { \
602  /* we include the task name */ \
603  _STARPU_FUT_DO_PROBE5STR(_STARPU_FUT_START_CODELET_BODY, (job)->job_id, ((job)->task)->sched_ctx, workerid, starpu_worker_get_memory_node(workerid), 1, name); \
604  if (model_name) \
605  _STARPU_FUT_DO_PROBE1STR(_STARPU_FUT_MODEL_NAME, (job)->job_id, model_name); \
606  } \
607  else { \
608  FUT_DO_PROBE5(_STARPU_FUT_START_CODELET_BODY, (job)->job_id, ((job)->task)->sched_ctx, workerid, starpu_worker_get_memory_node(workerid), 0); \
609  } \
610  { \
611  if ((job)->task->cl) \
612  { \
613  const int __nbuffers = STARPU_TASK_GET_NBUFFERS((job)->task); \
614  char __buf[FXT_MAX_PARAMS*sizeof(long)]; \
615  int __i; \
616  for (__i = 0; __i < __nbuffers; __i++) \
617  { \
618  starpu_data_handle_t __handle = STARPU_TASK_GET_HANDLE((job)->task, __i); \
619  void *__interface = _STARPU_TASK_GET_INTERFACES((job)->task)[__i]; \
620  if (__handle->ops->describe) \
621  { \
622  __handle->ops->describe(__interface, __buf, sizeof(__buf)); \
623  _STARPU_FUT_DO_PROBE1STR(_STARPU_FUT_CODELET_DATA, workerid, __buf); \
624  } \
625  FUT_DO_PROBE4(_STARPU_FUT_CODELET_DATA_HANDLE, (job)->job_id, (__handle), _starpu_data_get_size(__handle), STARPU_TASK_GET_MODE((job)->task, __i)); \
626  } \
627  } \
628  const size_t __job_size = _starpu_job_get_data_size((job)->task->cl?(job)->task->cl->model:NULL, perf_arch, nimpl, (job)); \
629  const uint32_t __job_hash = _starpu_compute_buffers_footprint((job)->task->cl?(job)->task->cl->model:NULL, perf_arch, nimpl, (job));\
630  FUT_DO_PROBE7(_STARPU_FUT_CODELET_DETAILS, ((job)->task)->sched_ctx, __job_size, __job_hash, (job)->task->flops / 1000 / ((job)->task->cl && job->task->cl->type != STARPU_SEQ ? j->task_size : 1), (job)->task->tag_id, workerid, ((job)->job_id)); \
631  } \
632 } while(0);
633 
634 #define _STARPU_TRACE_END_CODELET_BODY(job, nimpl, perf_arch, workerid) \
635 do { \
636  const size_t job_size = _starpu_job_get_data_size((job)->task->cl?(job)->task->cl->model:NULL, perf_arch, nimpl, (job)); \
637  const uint32_t job_hash = _starpu_compute_buffers_footprint((job)->task->cl?(job)->task->cl->model:NULL, perf_arch, nimpl, (job));\
638  char _archname[32]=""; \
639  starpu_perfmodel_get_arch_name(perf_arch, _archname, 32, 0); \
640  _STARPU_FUT_DO_PROBE5STR(_STARPU_FUT_END_CODELET_BODY, (job)->job_id, (job_size), (job_hash), workerid, _starpu_gettid(), _archname); \
641 } while(0);
642 
643 #define _STARPU_TRACE_START_EXECUTING() \
644  FUT_DO_PROBE1(_STARPU_FUT_START_EXECUTING, _starpu_gettid());
645 
646 #define _STARPU_TRACE_END_EXECUTING() \
647  FUT_DO_PROBE1(_STARPU_FUT_END_EXECUTING, _starpu_gettid());
648 
649 #define _STARPU_TRACE_START_CALLBACK(job) \
650  FUT_DO_PROBE2(_STARPU_FUT_START_CALLBACK, job, _starpu_gettid());
651 
652 #define _STARPU_TRACE_END_CALLBACK(job) \
653  FUT_DO_PROBE2(_STARPU_FUT_END_CALLBACK, job, _starpu_gettid());
654 
655 #define _STARPU_TRACE_JOB_PUSH(task, prio) \
656  FUT_DO_PROBE3(_STARPU_FUT_JOB_PUSH, _starpu_get_job_associated_to_task(task)->job_id, prio, _starpu_gettid());
657 
658 #define _STARPU_TRACE_JOB_POP(task, prio) \
659  FUT_DO_PROBE3(_STARPU_FUT_JOB_POP, _starpu_get_job_associated_to_task(task)->job_id, prio, _starpu_gettid());
660 
661 #define _STARPU_TRACE_UPDATE_TASK_CNT(counter) \
662  FUT_DO_PROBE2(_STARPU_FUT_UPDATE_TASK_CNT, counter, _starpu_gettid())
663 
664 #define _STARPU_TRACE_START_FETCH_INPUT(job) \
665  FUT_DO_PROBE2(_STARPU_FUT_START_FETCH_INPUT_ON_TID, job, _starpu_gettid());
666 
667 #define _STARPU_TRACE_END_FETCH_INPUT(job) \
668  FUT_DO_PROBE2(_STARPU_FUT_END_FETCH_INPUT_ON_TID, job, _starpu_gettid());
669 
670 #define _STARPU_TRACE_START_PUSH_OUTPUT(job) \
671  FUT_DO_PROBE2(_STARPU_FUT_START_PUSH_OUTPUT_ON_TID, job, _starpu_gettid());
672 
673 #define _STARPU_TRACE_END_PUSH_OUTPUT(job) \
674  FUT_DO_PROBE2(_STARPU_FUT_END_PUSH_OUTPUT_ON_TID, job, _starpu_gettid());
675 
676 #define _STARPU_TRACE_WORKER_END_FETCH_INPUT(job, id) \
677  FUT_DO_PROBE2(_STARPU_FUT_END_FETCH_INPUT, job, id);
678 
679 #define _STARPU_TRACE_WORKER_START_FETCH_INPUT(job, id) \
680  FUT_DO_PROBE2(_STARPU_FUT_START_FETCH_INPUT, job, id);
681 
682 #define _STARPU_TRACE_TAG(tag, job) \
683  FUT_DO_PROBE2(_STARPU_FUT_TAG, tag, (job)->job_id)
684 
685 #define _STARPU_TRACE_TAG_DEPS(tag_child, tag_father) \
686  FUT_DO_PROBE2(_STARPU_FUT_TAG_DEPS, tag_child, tag_father)
687 
688 #define _STARPU_TRACE_TASK_DEPS(job_prev, job_succ) \
689  _STARPU_FUT_DO_PROBE4STR(_STARPU_FUT_TASK_DEPS, (job_prev)->job_id, (job_succ)->job_id, (job_succ)->task->type, 1, "task")
690 
691 #define _STARPU_TRACE_GHOST_TASK_DEPS(ghost_prev_id, job_succ) \
692  _STARPU_FUT_DO_PROBE4STR(_STARPU_FUT_TASK_DEPS, (ghost_prev_id), (job_succ)->job_id, (job_succ)->task->type, 1, "ghost")
693 
694 #define _STARPU_TRACE_TASK_NAME(job) \
695 do { \
696  unsigned exclude_from_dag = (job)->exclude_from_dag; \
697  const char *model_name = _starpu_job_get_task_name((job)); \
698  if (model_name) \
699  { \
700  _STARPU_FUT_DO_PROBE4STR(_STARPU_FUT_TASK_NAME, (job)->job_id, _starpu_gettid(), (long unsigned)exclude_from_dag, 1, model_name);\
701  } \
702  else { \
703  FUT_DO_PROBE4(_STARPU_FUT_TASK_NAME, (job)->job_id, _starpu_gettid(), (long unsigned)exclude_from_dag, 0);\
704  } \
705 } while(0);
706 
707 #define _STARPU_TRACE_TASK_COLOR(job) \
708 do { \
709  if ((job)->task->color != 0) \
710  FUT_DO_PROBE3(_STARPU_FUT_TASK_COLOR, (job)->job_id, (job)->task->color, _starpu_gettid()); \
711  else if ((job)->task->cl && (job)->task->cl->color != 0) \
712  FUT_DO_PROBE3(_STARPU_FUT_TASK_COLOR, (job)->job_id, (job)->task->cl->color, _starpu_gettid()); \
713 } while(0)
714 
715 #define _STARPU_TRACE_TASK_DONE(job) \
716  FUT_DO_PROBE2(_STARPU_FUT_TASK_DONE, (job)->job_id, _starpu_gettid())
717 
718 #define _STARPU_TRACE_TAG_DONE(tag) \
719 do { \
720  struct _starpu_job *job = (tag)->job; \
721  const char *model_name = _starpu_job_get_task_name((job)); \
722  if (model_name) \
723  { \
724  _STARPU_FUT_DO_PROBE3STR(_STARPU_FUT_TAG_DONE, (tag)->id, _starpu_gettid(), 1, model_name); \
725  } \
726  else { \
727  FUT_DO_PROBE3(_STARPU_FUT_TAG_DONE, (tag)->id, _starpu_gettid(), 0);\
728  } \
729 } while(0);
730 
731 #define _STARPU_TRACE_DATA_NAME(handle, name) \
732  _STARPU_FUT_DO_PROBE1STR(_STARPU_FUT_DATA_NAME, handle, name)
733 
734 #define _STARPU_TRACE_DATA_COORDINATES(handle, dim, v) do {\
735  if (_starpu_fxt_started) \
736  switch (dim) { \
737  case 1: FUT_DO_ALWAYS_PROBE3(_STARPU_FUT_DATA_COORDINATES, handle, dim, v[0]); break; \
738  case 2: FUT_DO_ALWAYS_PROBE4(_STARPU_FUT_DATA_COORDINATES, handle, dim, v[0], v[1]); break; \
739  case 3: FUT_DO_ALWAYS_PROBE5(_STARPU_FUT_DATA_COORDINATES, handle, dim, v[0], v[1], v[2]); break; \
740  case 4: FUT_DO_ALWAYS_PROBE6(_STARPU_FUT_DATA_COORDINATES, handle, dim, v[0], v[1], v[2], v[3]); break; \
741  default: FUT_DO_ALWAYS_PROBE7(_STARPU_FUT_DATA_COORDINATES, handle, dim, v[0], v[1], v[2], v[3], v[4]); break; \
742  } \
743 } while (0)
744 
745 #define _STARPU_TRACE_DATA_COPY(src_node, dst_node, size) \
746  FUT_DO_PROBE3(_STARPU_FUT_DATA_COPY, src_node, dst_node, size)
747 
748 #define _STARPU_TRACE_DATA_WONT_USE(handle) \
749  FUT_DO_PROBE4(_STARPU_FUT_DATA_WONT_USE, handle, _starpu_fxt_get_submit_order(), _starpu_fxt_get_job_id(), _starpu_gettid())
750 
751 #define _STARPU_TRACE_DATA_DOING_WONT_USE(handle) \
752  FUT_DO_PROBE1(_STARPU_FUT_DATA_DOING_WONT_USE, handle)
753 
754 #define _STARPU_TRACE_START_DRIVER_COPY(src_node, dst_node, size, com_id, prefetch, handle) \
755  FUT_DO_PROBE6(_STARPU_FUT_START_DRIVER_COPY, src_node, dst_node, size, com_id, prefetch, handle)
756 
757 #define _STARPU_TRACE_END_DRIVER_COPY(src_node, dst_node, size, com_id, prefetch) \
758  FUT_DO_PROBE5(_STARPU_FUT_END_DRIVER_COPY, src_node, dst_node, size, com_id, prefetch)
759 
760 #define _STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node) \
761  FUT_DO_PROBE2(_STARPU_FUT_START_DRIVER_COPY_ASYNC, src_node, dst_node)
762 
763 #define _STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node) \
764  FUT_DO_PROBE2(_STARPU_FUT_END_DRIVER_COPY_ASYNC, src_node, dst_node)
765 
766 #define _STARPU_TRACE_WORK_STEALING(empty_q, victim_q) \
767  FUT_DO_PROBE2(_STARPU_FUT_WORK_STEALING, empty_q, victim_q)
768 
769 #define _STARPU_TRACE_WORKER_DEINIT_START \
770  FUT_DO_PROBE1(_STARPU_FUT_WORKER_DEINIT_START, _starpu_gettid());
771 
772 #define _STARPU_TRACE_WORKER_DEINIT_END(workerkind) \
773  FUT_DO_PROBE2(_STARPU_FUT_WORKER_DEINIT_END, workerkind, _starpu_gettid());
774 
775 #define _STARPU_TRACE_WORKER_SCHEDULING_START \
776  FUT_DO_PROBE1(_STARPU_FUT_WORKER_SCHEDULING_START, _starpu_gettid());
777 
778 #define _STARPU_TRACE_WORKER_SCHEDULING_END \
779  FUT_DO_PROBE1(_STARPU_FUT_WORKER_SCHEDULING_END, _starpu_gettid());
780 
781 #define _STARPU_TRACE_WORKER_SCHEDULING_PUSH \
782  FUT_DO_PROBE1(_STARPU_FUT_WORKER_SCHEDULING_PUSH, _starpu_gettid());
783 
784 #define _STARPU_TRACE_WORKER_SCHEDULING_POP \
785  FUT_DO_PROBE1(_STARPU_FUT_WORKER_SCHEDULING_POP, _starpu_gettid());
786 
787 #define _STARPU_TRACE_WORKER_SLEEP_START \
788  FUT_DO_PROBE1(_STARPU_FUT_WORKER_SLEEP_START, _starpu_gettid());
789 
790 #define _STARPU_TRACE_WORKER_SLEEP_END \
791  FUT_DO_PROBE1(_STARPU_FUT_WORKER_SLEEP_END, _starpu_gettid());
792 
793 #define _STARPU_TRACE_TASK_SUBMIT(job, iter, subiter) \
794  FUT_DO_PROBE7(_STARPU_FUT_TASK_SUBMIT, (job)->job_id, iter, subiter, (job)->task->no_submitorder?0:_starpu_fxt_get_submit_order(), (job)->task->priority, (job)->task->type, _starpu_gettid());
795 
796 #define _STARPU_TRACE_TASK_SUBMIT_START() \
797  FUT_DO_PROBE1(_STARPU_FUT_TASK_SUBMIT_START, _starpu_gettid());
798 
799 #define _STARPU_TRACE_TASK_SUBMIT_END() \
800  FUT_DO_PROBE1(_STARPU_FUT_TASK_SUBMIT_END, _starpu_gettid());
801 
802 #define _STARPU_TRACE_TASK_THROTTLE_START() \
803  FUT_DO_PROBE1(_STARPU_FUT_TASK_THROTTLE_START, _starpu_gettid());
804 
805 #define _STARPU_TRACE_TASK_THROTTLE_END() \
806  FUT_DO_PROBE1(_STARPU_FUT_TASK_THROTTLE_END, _starpu_gettid());
807 
808 #define _STARPU_TRACE_TASK_BUILD_START() \
809  FUT_DO_PROBE1(_STARPU_FUT_TASK_BUILD_START, _starpu_gettid());
810 
811 #define _STARPU_TRACE_TASK_BUILD_END() \
812  FUT_DO_PROBE1(_STARPU_FUT_TASK_BUILD_END, _starpu_gettid());
813 
814 #define _STARPU_TRACE_TASK_MPI_DECODE_START() \
815  FUT_DO_PROBE1(_STARPU_FUT_TASK_MPI_DECODE_START, _starpu_gettid());
816 
817 #define _STARPU_TRACE_TASK_MPI_DECODE_END() \
818  FUT_DO_PROBE1(_STARPU_FUT_TASK_MPI_DECODE_END, _starpu_gettid());
819 
820 #define _STARPU_TRACE_TASK_MPI_PRE_START() \
821  FUT_DO_PROBE1(_STARPU_FUT_TASK_MPI_PRE_START, _starpu_gettid());
822 
823 #define _STARPU_TRACE_TASK_MPI_PRE_END() \
824  FUT_DO_PROBE1(_STARPU_FUT_TASK_MPI_PRE_END, _starpu_gettid());
825 
826 #define _STARPU_TRACE_TASK_MPI_POST_START() \
827  FUT_DO_PROBE1(_STARPU_FUT_TASK_MPI_POST_START, _starpu_gettid());
828 
829 #define _STARPU_TRACE_TASK_MPI_POST_END() \
830  FUT_DO_PROBE1(_STARPU_FUT_TASK_MPI_POST_END, _starpu_gettid());
831 
832 #define _STARPU_TRACE_TASK_WAIT_START(job) \
833  FUT_DO_PROBE2(_STARPU_FUT_TASK_WAIT_START, (job)->job_id, _starpu_gettid());
834 
835 #define _STARPU_TRACE_TASK_WAIT_END() \
836  FUT_DO_PROBE1(_STARPU_FUT_TASK_WAIT_END, _starpu_gettid());
837 
838 #define _STARPU_TRACE_TASK_WAIT_FOR_ALL_START() \
839  FUT_DO_PROBE1(_STARPU_FUT_TASK_WAIT_FOR_ALL_START, _starpu_gettid());
840 
841 #define _STARPU_TRACE_TASK_WAIT_FOR_ALL_END() \
842  FUT_DO_PROBE1(_STARPU_FUT_TASK_WAIT_FOR_ALL_END, _starpu_gettid());
843 
844 #define _STARPU_TRACE_USER_DEFINED_START \
845  FUT_DO_PROBE1(_STARPU_FUT_USER_DEFINED_START, _starpu_gettid());
846 
847 #define _STARPU_TRACE_USER_DEFINED_END \
848  FUT_DO_PROBE1(_STARPU_FUT_USER_DEFINED_END, _starpu_gettid());
849 
850 #define _STARPU_TRACE_START_ALLOC(memnode, size, handle, is_prefetch) \
851  FUT_DO_PROBE5(_STARPU_FUT_START_ALLOC, memnode, _starpu_gettid(), size, handle, is_prefetch);
852 
853 #define _STARPU_TRACE_END_ALLOC(memnode, handle, r) \
854  FUT_DO_PROBE4(_STARPU_FUT_END_ALLOC, memnode, _starpu_gettid(), handle, r);
855 
856 #define _STARPU_TRACE_START_ALLOC_REUSE(memnode, size, handle, is_prefetch) \
857  FUT_DO_PROBE5(_STARPU_FUT_START_ALLOC_REUSE, memnode, _starpu_gettid(), size, handle, is_prefetch);
858 
859 #define _STARPU_TRACE_END_ALLOC_REUSE(memnode, handle, r) \
860  FUT_DO_PROBE4(_STARPU_FUT_END_ALLOC_REUSE, memnode, _starpu_gettid(), handle, r);
861 
862 #define _STARPU_TRACE_START_FREE(memnode, size, handle) \
863  FUT_DO_PROBE4(_STARPU_FUT_START_FREE, memnode, _starpu_gettid(), size, handle);
864 
865 #define _STARPU_TRACE_END_FREE(memnode, handle) \
866  FUT_DO_PROBE3(_STARPU_FUT_END_FREE, memnode, _starpu_gettid(), handle);
867 
868 #define _STARPU_TRACE_START_WRITEBACK(memnode, handle) \
869  FUT_DO_PROBE3(_STARPU_FUT_START_WRITEBACK, memnode, _starpu_gettid(), handle);
870 
871 #define _STARPU_TRACE_END_WRITEBACK(memnode, handle) \
872  FUT_DO_PROBE3(_STARPU_FUT_END_WRITEBACK, memnode, _starpu_gettid(), handle);
873 
874 #define _STARPU_TRACE_USED_MEM(memnode,used) \
875  FUT_DO_PROBE3(_STARPU_FUT_USED_MEM, memnode, used, _starpu_gettid());
876 
877 #define _STARPU_TRACE_START_MEMRECLAIM(memnode,is_prefetch) \
878  FUT_DO_PROBE3(_STARPU_FUT_START_MEMRECLAIM, memnode, is_prefetch, _starpu_gettid());
879 
880 #define _STARPU_TRACE_END_MEMRECLAIM(memnode, is_prefetch) \
881  FUT_DO_PROBE3(_STARPU_FUT_END_MEMRECLAIM, memnode, is_prefetch, _starpu_gettid());
882 
883 #define _STARPU_TRACE_START_WRITEBACK_ASYNC(memnode) \
884  FUT_DO_PROBE2(_STARPU_FUT_START_WRITEBACK_ASYNC, memnode, _starpu_gettid());
885 
886 #define _STARPU_TRACE_END_WRITEBACK_ASYNC(memnode) \
887  FUT_DO_PROBE2(_STARPU_FUT_END_WRITEBACK_ASYNC, memnode, _starpu_gettid());
888 
889 /* We skip these events becasue they are called so often that they cause FxT to
890  * fail and make the overall trace unreadable anyway. */
891 #define _STARPU_TRACE_START_PROGRESS(memnode) \
892  FUT_DO_PROBE2(_STARPU_FUT_START_PROGRESS_ON_TID, memnode, _starpu_gettid());
893 
894 #define _STARPU_TRACE_END_PROGRESS(memnode) \
895  FUT_DO_PROBE2(_STARPU_FUT_END_PROGRESS_ON_TID, memnode, _starpu_gettid());
896 
897 #define _STARPU_TRACE_USER_EVENT(code) \
898  FUT_DO_PROBE2(_STARPU_FUT_USER_EVENT, code, _starpu_gettid());
899 
900 #define _STARPU_TRACE_SET_PROFILING(status) \
901  FUT_DO_PROBE2(_STARPU_FUT_SET_PROFILING, status, _starpu_gettid());
902 
903 #define _STARPU_TRACE_TASK_WAIT_FOR_ALL \
904  FUT_DO_PROBE0(_STARPU_FUT_TASK_WAIT_FOR_ALL)
905 
906 #define _STARPU_TRACE_EVENT(S) \
907  FUT_DO_PROBESTR(_STARPU_FUT_EVENT,S)
908 
909 #define _STARPU_TRACE_THREAD_EVENT(S) \
910  _STARPU_FUT_DO_PROBE1STR(_STARPU_FUT_THREAD_EVENT, _starpu_gettid(), S)
911 
912 #define _STARPU_TRACE_HYPERVISOR_BEGIN() \
913  FUT_DO_PROBE1(_STARPU_FUT_HYPERVISOR_BEGIN, _starpu_gettid());
914 
915 #define _STARPU_TRACE_HYPERVISOR_END() \
916  FUT_DO_PROBE1(_STARPU_FUT_HYPERVISOR_END, _starpu_gettid());
917 
918 #ifdef STARPU_FXT_LOCK_TRACES
919 
920 #define _STARPU_TRACE_LOCKING_MUTEX() do { \
921  const char *file; \
922  file = strrchr(__FILE__,'/') + 1; \
923  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_LOCKING_MUTEX,__LINE__,_starpu_gettid(),file); \
924 } while (0)
925 
926 #define _STARPU_TRACE_MUTEX_LOCKED() do { \
927  const char *file; \
928  file = strrchr(__FILE__,'/') + 1; \
929  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_MUTEX_LOCKED,__LINE__,_starpu_gettid(),file); \
930 } while(0)
931 
932 #define _STARPU_TRACE_UNLOCKING_MUTEX() do { \
933  const char *file; \
934  file = strrchr(__FILE__,'/') + 1; \
935  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_UNLOCKING_MUTEX,__LINE__,_starpu_gettid(),file); \
936 } while(0)
937 
938 #define _STARPU_TRACE_MUTEX_UNLOCKED() do {\
939  const char *file; \
940  file = strrchr(__FILE__,'/') + 1; \
941  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_MUTEX_UNLOCKED,__LINE__,_starpu_gettid(),file); \
942 } while(0)
943 
944 #define _STARPU_TRACE_TRYLOCK_MUTEX() do { \
945  const char *file; \
946  file = strrchr(__FILE__,'/') + 1; \
947  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_TRYLOCK_MUTEX,__LINE__,_starpu_gettid(),file); \
948 } while(0)
949 
950 #define _STARPU_TRACE_RDLOCKING_RWLOCK() do { \
951  const char *file; \
952  file = strrchr(__FILE__,'/') + 1; \
953  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_RDLOCKING_RWLOCK,__LINE__,_starpu_gettid(),file); \
954 } while(0)
955 
956 #define _STARPU_TRACE_RWLOCK_RDLOCKED() do { \
957  const char *file; \
958  file = strrchr(__FILE__,'/') + 1; \
959  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_RWLOCK_RDLOCKED,__LINE__,_starpu_gettid(),file); \
960 } while(0)
961 
962 #define _STARPU_TRACE_WRLOCKING_RWLOCK() do { \
963  const char *file; \
964  file = strrchr(__FILE__,'/') + 1; \
965  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_WRLOCKING_RWLOCK,__LINE__,_starpu_gettid(),file); \
966 } while(0)
967 
968 #define _STARPU_TRACE_RWLOCK_WRLOCKED() do { \
969  const char *file; \
970  file = strrchr(__FILE__,'/') + 1; \
971  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_RWLOCK_WRLOCKED,__LINE__,_starpu_gettid(),file); \
972 } while(0)
973 
974 #define _STARPU_TRACE_UNLOCKING_RWLOCK() do { \
975  const char *file; \
976  file = strrchr(__FILE__,'/') + 1; \
977  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_UNLOCKING_RWLOCK,__LINE__,_starpu_gettid(),file); \
978 } while(0)
979 
980 #define _STARPU_TRACE_RWLOCK_UNLOCKED() do { \
981  const char *file; \
982  file = strrchr(__FILE__,'/') + 1; \
983  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_RWLOCK_UNLOCKED,__LINE__,_starpu_gettid(),file); \
984 } while(0)
985 
986 #define STARPU_TRACE_SPINLOCK_CONDITITION (starpu_worker_get_type(starpu_worker_get_id()) == STARPU_CUDA_WORKER)
987 
988 #define _STARPU_TRACE_LOCKING_SPINLOCK(file, line) do {\
989  if (STARPU_TRACE_SPINLOCK_CONDITITION) { \
990  const char *xfile; \
991  xfile = strrchr(file,'/') + 1; \
992  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_LOCKING_SPINLOCK,line,_starpu_gettid(),xfile); \
993  } \
994 } while(0)
995 
996 #define _STARPU_TRACE_SPINLOCK_LOCKED(file, line) do { \
997  if (STARPU_TRACE_SPINLOCK_CONDITITION) { \
998  const char *xfile; \
999  xfile = strrchr(file,'/') + 1; \
1000  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_SPINLOCK_LOCKED,line,_starpu_gettid(),xfile); \
1001  } \
1002 } while(0)
1003 
1004 #define _STARPU_TRACE_UNLOCKING_SPINLOCK(file, line) do { \
1005  if (STARPU_TRACE_SPINLOCK_CONDITITION) { \
1006  const char *xfile; \
1007  xfile = strrchr(file,'/') + 1; \
1008  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_UNLOCKING_SPINLOCK,line,_starpu_gettid(),xfile); \
1009  } \
1010 } while(0)
1011 
1012 #define _STARPU_TRACE_SPINLOCK_UNLOCKED(file, line) do { \
1013  if (STARPU_TRACE_SPINLOCK_CONDITITION) { \
1014  const char *xfile; \
1015  xfile = strrchr(file,'/') + 1; \
1016  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_SPINLOCK_UNLOCKED,line,_starpu_gettid(),xfile); \
1017  } \
1018 } while(0)
1019 
1020 #define _STARPU_TRACE_TRYLOCK_SPINLOCK(file, line) do { \
1021  if (STARPU_TRACE_SPINLOCK_CONDITITION) { \
1022  const char *xfile; \
1023  xfile = strrchr(file,'/') + 1; \
1024  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_TRYLOCK_SPINLOCK,line,_starpu_gettid(),xfile); \
1025  } \
1026 } while(0)
1027 
1028 #define _STARPU_TRACE_COND_WAIT_BEGIN() do { \
1029  const char *file; \
1030  file = strrchr(__FILE__,'/') + 1; \
1031  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_COND_WAIT_BEGIN,__LINE__,_starpu_gettid(),file); \
1032 } while(0)
1033 
1034 #define _STARPU_TRACE_COND_WAIT_END() do { \
1035  const char *file; \
1036  file = strrchr(__FILE__,'/') + 1; \
1037  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_COND_WAIT_END,__LINE__,_starpu_gettid(),file); \
1038 } while(0)
1039 
1040 #define _STARPU_TRACE_BARRIER_WAIT_BEGIN() do { \
1041  const char *file; \
1042  file = strrchr(__FILE__,'/') + 1; \
1043  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_BARRIER_WAIT_BEGIN,__LINE__,_starpu_gettid(),file); \
1044 } while(0)
1045 
1046 #define _STARPU_TRACE_BARRIER_WAIT_END() do { \
1047  const char *file; \
1048  file = strrchr(__FILE__,'/') + 1; \
1049  _STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_BARRIER_WAIT_END,__LINE__,_starpu_gettid(),file); \
1050 } while(0)
1051 
1052 #else // !STARPU_FXT_LOCK_TRACES
1053 
1054 #define _STARPU_TRACE_LOCKING_MUTEX() do {} while(0)
1055 #define _STARPU_TRACE_MUTEX_LOCKED() do {} while(0)
1056 #define _STARPU_TRACE_UNLOCKING_MUTEX() do {} while(0)
1057 #define _STARPU_TRACE_MUTEX_UNLOCKED() do {} while(0)
1058 #define _STARPU_TRACE_TRYLOCK_MUTEX() do {} while(0)
1059 #define _STARPU_TRACE_RDLOCKING_RWLOCK() do {} while(0)
1060 #define _STARPU_TRACE_RWLOCK_RDLOCKED() do {} while(0)
1061 #define _STARPU_TRACE_WRLOCKING_RWLOCK() do {} while(0)
1062 #define _STARPU_TRACE_RWLOCK_WRLOCKED() do {} while(0)
1063 #define _STARPU_TRACE_UNLOCKING_RWLOCK() do {} while(0)
1064 #define _STARPU_TRACE_RWLOCK_UNLOCKED() do {} while(0)
1065 #define _STARPU_TRACE_LOCKING_SPINLOCK(file, line) do {(void) file; (void)line;} while(0)
1066 #define _STARPU_TRACE_SPINLOCK_LOCKED(file, line) do {(void) file; (void)line;} while(0)
1067 #define _STARPU_TRACE_UNLOCKING_SPINLOCK(file, line) do {(void) file; (void)line;} while(0)
1068 #define _STARPU_TRACE_SPINLOCK_UNLOCKED(file, line) do {(void) file; (void)line;} while(0)
1069 #define _STARPU_TRACE_TRYLOCK_SPINLOCK(file, line) do {(void) file; (void)line;} while(0)
1070 #define _STARPU_TRACE_COND_WAIT_BEGIN() do {} while(0)
1071 #define _STARPU_TRACE_COND_WAIT_END() do {} while(0)
1072 #define _STARPU_TRACE_BARRIER_WAIT_BEGIN() do {} while(0)
1073 #define _STARPU_TRACE_BARRIER_WAIT_END() do {} while(0)
1074 
1075 #endif // STARPU_FXT_LOCK_TRACES
1076 
1077 #define _STARPU_TRACE_MEMORY_FULL(size) \
1078  FUT_DO_PROBE2(_STARPU_FUT_MEMORY_FULL,size,_starpu_gettid());
1079 
1080 #define _STARPU_TRACE_DATA_LOAD(workerid,size) \
1081  FUT_DO_PROBE2(_STARPU_FUT_DATA_LOAD, workerid, size);
1082 
1083 #define _STARPU_TRACE_START_UNPARTITION(handle, memnode) \
1084  FUT_DO_PROBE3(_STARPU_FUT_START_UNPARTITION_ON_TID, memnode, _starpu_gettid(), handle);
1085 
1086 #define _STARPU_TRACE_END_UNPARTITION(handle, memnode) \
1087  FUT_DO_PROBE3(_STARPU_FUT_END_UNPARTITION_ON_TID, memnode, _starpu_gettid(), handle);
1088 
1089 #define _STARPU_TRACE_SCHED_COMPONENT_PUSH_PRIO(workerid, ntasks, exp_len) \
1090  FUT_DO_PROBE4(_STARPU_FUT_SCHED_COMPONENT_PUSH_PRIO, _starpu_gettid(), workerid, ntasks, exp_len);
1091 
1092 #define _STARPU_TRACE_SCHED_COMPONENT_POP_PRIO(workerid, ntasks, exp_len) \
1093  FUT_DO_PROBE4(_STARPU_FUT_SCHED_COMPONENT_POP_PRIO, _starpu_gettid(), workerid, ntasks, exp_len);
1094 
1095 #define _STARPU_TRACE_SCHED_COMPONENT_NEW(component) \
1096  _STARPU_FUT_DO_PROBE1STR(_STARPU_FUT_SCHED_COMPONENT_NEW, component, (component)->name);
1097 
1098 #define _STARPU_TRACE_SCHED_COMPONENT_CONNECT(parent, child) \
1099  FUT_DO_PROBE2(_STARPU_FUT_SCHED_COMPONENT_CONNECT, parent, child);
1100 
1101 #define _STARPU_TRACE_SCHED_COMPONENT_PUSH(from, to, task) \
1102  FUT_DO_PROBE5(_STARPU_FUT_SCHED_COMPONENT_PUSH, _starpu_gettid(), from, to, task, (task)->priority);
1103 
1104 #define _STARPU_TRACE_SCHED_COMPONENT_PULL(from, to, task) \
1105  FUT_DO_PROBE5(_STARPU_FUT_SCHED_COMPONENT_PULL, _starpu_gettid(), from, to, task, (task)->priority);
1106 
1107 #define _STARPU_TRACE_HANDLE_DATA_REGISTER(handle) do { \
1108  const size_t __data_size = handle->ops->get_size(handle); \
1109  char __buf[(FXT_MAX_PARAMS-2)*sizeof(long)]; \
1110  void *__interface = handle->per_node[0].data_interface; \
1111  if (handle->ops->describe) \
1112  handle->ops->describe(__interface, __buf, sizeof(__buf)); \
1113  else \
1114  __buf[0] = 0; \
1115  FUT_DO_PROBE3STR(_STARPU_FUT_HANDLE_DATA_REGISTER, handle, __data_size, handle->home_node, __buf); \
1116 } while (0)
1117 
1118 #define _STARPU_TRACE_HANDLE_DATA_UNREGISTER(handle) \
1119  FUT_DO_PROBE1(_STARPU_FUT_HANDLE_DATA_UNREGISTER, handle)
1120 
1121 //Coherency Data Traces
1122 #define _STARPU_TRACE_DATA_STATE_INVALID(handle, node) \
1123  FUT_DO_PROBE2(_STARPU_FUT_DATA_STATE_INVALID, handle, node)
1124 
1125 #define _STARPU_TRACE_DATA_STATE_OWNER(handle, node) \
1126  FUT_DO_PROBE2(_STARPU_FUT_DATA_STATE_OWNER, handle, node)
1127 
1128 #define _STARPU_TRACE_DATA_STATE_SHARED(handle, node) \
1129  FUT_DO_PROBE2(_STARPU_FUT_DATA_STATE_SHARED, handle, node)
1130 
1131 #define _STARPU_TRACE_DATA_REQUEST_CREATED(handle, orig, dest, prio, is_pre) \
1132  FUT_DO_PROBE5(_STARPU_FUT_DATA_REQUEST_CREATED, orig, dest, prio, handle, is_pre)
1133 
1134 
1135 #else // !STARPU_USE_FXT
1136 
1137 /* Dummy macros in case FxT is disabled */
1138 #define _STARPU_TRACE_NEW_MEM_NODE(nodeid) do {(void)(nodeid);} while(0)
1139 #define _STARPU_TRACE_WORKER_INIT_START(a,b,c,d,e,f) do {(void)(a); (void)(b); (void)(c); (void)(d); (void)(e); (void)(f);} while(0)
1140 #define _STARPU_TRACE_WORKER_INIT_END(workerid) do {(void)(workerid);} while(0)
1141 #define _STARPU_TRACE_START_CODELET_BODY(job, nimpl, perf_arch, workerid) do {(void)(job); (void)(nimpl); (void)(perf_arch); (void)(workerid);} while(0)
1142 #define _STARPU_TRACE_END_CODELET_BODY(job, nimpl, perf_arch, workerid) do {(void)(job); (void)(nimpl); (void)(perf_arch); (void)(workerid);} while(0)
1143 #define _STARPU_TRACE_START_EXECUTING() do {} while(0)
1144 #define _STARPU_TRACE_END_EXECUTING() do {} while(0)
1145 #define _STARPU_TRACE_START_CALLBACK(job) do {(void)(job);} while(0)
1146 #define _STARPU_TRACE_END_CALLBACK(job) do {(void)(job);} while(0)
1147 #define _STARPU_TRACE_JOB_PUSH(task, prio) do {(void)(task); (void)(prio);} while(0)
1148 #define _STARPU_TRACE_JOB_POP(task, prio) do {(void)(task); (void)(prio);} while(0)
1149 #define _STARPU_TRACE_UPDATE_TASK_CNT(counter) do {(void)(counter);} while(0)
1150 #define _STARPU_TRACE_START_FETCH_INPUT(job) do {(void)(job);} while(0)
1151 #define _STARPU_TRACE_END_FETCH_INPUT(job) do {(void)(job);} while(0)
1152 #define _STARPU_TRACE_START_PUSH_OUTPUT(job) do {(void)(job);} while(0)
1153 #define _STARPU_TRACE_END_PUSH_OUTPUT(job) do {(void)(job);} while(0)
1154 #define _STARPU_TRACE_TAG(tag, job) do {(void)(tag); (void)(job);} while(0)
1155 #define _STARPU_TRACE_TAG_DEPS(a, b) do {(void)(a); (void)(b);} while(0)
1156 #define _STARPU_TRACE_TASK_DEPS(a, b) do {(void)(a); (void)(b);} while(0)
1157 #define _STARPU_TRACE_GHOST_TASK_DEPS(a, b) do {(void)(a); (void)(b);} while(0)
1158 #define _STARPU_TRACE_TASK_NAME(a) do {(void)(a);} while(0)
1159 #define _STARPU_TRACE_TASK_COLOR(a) do {(void)(a);} while(0)
1160 #define _STARPU_TRACE_TASK_DONE(a) do {(void)(a);} while(0)
1161 #define _STARPU_TRACE_TAG_DONE(a) do {(void)(a);} while(0)
1162 #define _STARPU_TRACE_DATA_NAME(a, b) do {(void)(a); (void)(b);} while(0)
1163 #define _STARPU_TRACE_DATA_COORDINATES(a, b, c) do {(void)(a); (void)(b); (void)(c);} while(0)
1164 #define _STARPU_TRACE_DATA_COPY(a, b, c) do {(void)(a); (void)(b); (void)(c);} while(0)
1165 #define _STARPU_TRACE_DATA_WONT_USE(a) do {(void)(a);} while(0)
1166 #define _STARPU_TRACE_DATA_DOING_WONT_USE(a) do {(void)(a);} while(0)
1167 #define _STARPU_TRACE_START_DRIVER_COPY(a,b,c,d,e,f) do {(void)(a); (void)(b); (void)(c); (void)(d); (void)(e); (void)(f);} while(0)
1168 #define _STARPU_TRACE_END_DRIVER_COPY(a,b,c,d,e) do {(void)(a); (void)(b); (void)(c); (void)(d); (void)(e);} while(0)
1169 #define _STARPU_TRACE_START_DRIVER_COPY_ASYNC(a,b) do {(void)(a); (void)(b);} while(0)
1170 #define _STARPU_TRACE_END_DRIVER_COPY_ASYNC(a,b) do {(void)(a); (void)(b);} while(0)
1171 #define _STARPU_TRACE_WORK_STEALING(a, b) do {(void)(a); (void)(b);} while(0)
1172 #define _STARPU_TRACE_WORKER_DEINIT_START do {} while(0)
1173 #define _STARPU_TRACE_WORKER_DEINIT_END(a) do {(void)(a);} while(0)
1174 #define _STARPU_TRACE_WORKER_SCHEDULING_START do {} while(0)
1175 #define _STARPU_TRACE_WORKER_SCHEDULING_END do {} while(0)
1176 #define _STARPU_TRACE_WORKER_SCHEDULING_PUSH do {} while(0)
1177 #define _STARPU_TRACE_WORKER_SCHEDULING_POP do {} while(0)
1178 #define _STARPU_TRACE_WORKER_SLEEP_START do {} while(0)
1179 #define _STARPU_TRACE_WORKER_SLEEP_END do {} while(0)
1180 #define _STARPU_TRACE_TASK_SUBMIT(job, a, b) do {(void)(job); (void)(a);(void)(b);} while(0)
1181 #define _STARPU_TRACE_TASK_SUBMIT_START() do {} while(0)
1182 #define _STARPU_TRACE_TASK_SUBMIT_END() do {} while(0)
1183 #define _STARPU_TRACE_TASK_THROTTLE_START() do {} while(0)
1184 #define _STARPU_TRACE_TASK_THROTTLE_END() do {} while(0)
1185 #define _STARPU_TRACE_TASK_BUILD_START() do {} while(0)
1186 #define _STARPU_TRACE_TASK_BUILD_END() do {} while(0)
1187 #define _STARPU_TRACE_TASK_MPI_DECODE_START() do {} while(0)
1188 #define _STARPU_TRACE_TASK_MPI_DECODE_END() do {} while(0)
1189 #define _STARPU_TRACE_TASK_MPI_PRE_START() do {} while(0)
1190 #define _STARPU_TRACE_TASK_MPI_PRE_END() do {} while(0)
1191 #define _STARPU_TRACE_TASK_MPI_POST_START() do {} while(0)
1192 #define _STARPU_TRACE_TASK_MPI_POST_END() do {} while(0)
1193 #define _STARPU_TRACE_TASK_WAIT_START(job) do {(void)(job);} while(0)
1194 #define _STARPU_TRACE_TASK_WAIT_END() do {} while(0)
1195 #define _STARPU_TRACE_TASK_WAIT_FOR_ALL_START() do {} while(0)
1196 #define _STARPU_TRACE_TASK_WAIT_FOR_ALL_END() do {} while(0)
1197 #define _STARPU_TRACE_USER_DEFINED_START() do {} while(0)
1198 #define _STARPU_TRACE_USER_DEFINED_END() do {} while(0)
1199 #define _STARPU_TRACE_START_ALLOC(memnode, size, handle, is_prefetch) do {(void)(memnode); (void)(size); (void)(handle);} while(0)
1200 #define _STARPU_TRACE_END_ALLOC(memnode, handle, r) do {(void)(memnode); (void)(handle); (void)(r);} while(0)
1201 #define _STARPU_TRACE_START_ALLOC_REUSE(a, size, handle, is_prefetch) do {(void)(a); (void)(size); (void)(handle);} while(0)
1202 #define _STARPU_TRACE_END_ALLOC_REUSE(a, handle, r) do {(void)(a); (void)(handle); (void)(r);} while(0)
1203 #define _STARPU_TRACE_START_FREE(memnode, size, handle) do {(void)(memnode); (void)(size); (void)(handle);} while(0)
1204 #define _STARPU_TRACE_END_FREE(memnode, handle) do {(void)(memnode); (void)(handle);} while(0)
1205 #define _STARPU_TRACE_START_WRITEBACK(memnode, handle) do {(void)(memnode); (void)(handle);} while(0)
1206 #define _STARPU_TRACE_END_WRITEBACK(memnode, handle) do {(void)(memnode); (void)(handle);} while(0)
1207 #define _STARPU_TRACE_USED_MEM(memnode,used) do {(void)(memnode); (void)(used);} while (0)
1208 #define _STARPU_TRACE_START_MEMRECLAIM(memnode,is_prefetch) do {(void)(memnode); (void)(is_prefetch);} while(0)
1209 #define _STARPU_TRACE_END_MEMRECLAIM(memnode,is_prefetch) do {(void)(memnode); (void)(is_prefetch);} while(0)
1210 #define _STARPU_TRACE_START_WRITEBACK_ASYNC(memnode) do {(void)(memnode);} while(0)
1211 #define _STARPU_TRACE_END_WRITEBACK_ASYNC(memnode) do {(void)(memnode);} while(0)
1212 #define _STARPU_TRACE_START_PROGRESS(memnode) do {(void)( memnode);} while(0)
1213 #define _STARPU_TRACE_END_PROGRESS(memnode) do {(void)( memnode);} while(0)
1214 #define _STARPU_TRACE_USER_EVENT(code) do {(void)(code);} while(0)
1215 #define _STARPU_TRACE_SET_PROFILING(status) do {(void)(status);} while(0)
1216 #define _STARPU_TRACE_TASK_WAIT_FOR_ALL() do {} while(0)
1217 #define _STARPU_TRACE_EVENT(S) do {(void)(S);} while(0)
1218 #define _STARPU_TRACE_THREAD_EVENT(S) do {(void)(S);} while(0)
1219 #define _STARPU_TRACE_LOCKING_MUTEX() do {} while(0)
1220 #define _STARPU_TRACE_MUTEX_LOCKED() do {} while(0)
1221 #define _STARPU_TRACE_UNLOCKING_MUTEX() do {} while(0)
1222 #define _STARPU_TRACE_MUTEX_UNLOCKED() do {} while(0)
1223 #define _STARPU_TRACE_TRYLOCK_MUTEX() do {} while(0)
1224 #define _STARPU_TRACE_RDLOCKING_RWLOCK() do {} while(0)
1225 #define _STARPU_TRACE_RWLOCK_RDLOCKED() do {} while(0)
1226 #define _STARPU_TRACE_WRLOCKING_RWLOCK() do {} while(0)
1227 #define _STARPU_TRACE_RWLOCK_WRLOCKED() do {} while(0)
1228 #define _STARPU_TRACE_UNLOCKING_RWLOCK() do {} while(0)
1229 #define _STARPU_TRACE_RWLOCK_UNLOCKED() do {} while(0)
1230 #define _STARPU_TRACE_LOCKING_SPINLOCK(file, line) do {(void)(file); (void)(line);} while(0)
1231 #define _STARPU_TRACE_SPINLOCK_LOCKED(file, line) do {(void)(file); (void)(line);} while(0)
1232 #define _STARPU_TRACE_UNLOCKING_SPINLOCK(file, line) do {(void)(file); (void)(line);} while(0)
1233 #define _STARPU_TRACE_SPINLOCK_UNLOCKED(file, line) do {(void)(file); (void)(line);} while(0)
1234 #define _STARPU_TRACE_TRYLOCK_SPINLOCK(file, line) do {(void)(file); (void)(line);} while(0)
1235 #define _STARPU_TRACE_COND_WAIT_BEGIN() do {} while(0)
1236 #define _STARPU_TRACE_COND_WAIT_END() do {} while(0)
1237 #define _STARPU_TRACE_BARRIER_WAIT_BEGIN() do {} while(0)
1238 #define _STARPU_TRACE_BARRIER_WAIT_END() do {} while(0)
1239 #define _STARPU_TRACE_MEMORY_FULL(size) do {(void)(size);} while(0)
1240 #define _STARPU_TRACE_DATA_LOAD(workerid,size) do {(void)(workerid); (void)(size);} while(0)
1241 #define _STARPU_TRACE_START_UNPARTITION(handle, memnode) do {(void)(handle); (void)(memnode);} while(0)
1242 #define _STARPU_TRACE_END_UNPARTITION(handle, memnode) do {(void)(handle); (void)(memnode);} while(0)
1243 #define _STARPU_TRACE_SCHED_COMPONENT_PUSH_PRIO(workerid, ntasks, exp_len) do {(void)(workerid); (void)(ntasks); (void)(exp_len);} while(0)
1244 #define _STARPU_TRACE_SCHED_COMPONENT_POP_PRIO(workerid, ntasks, exp_len) do {(void)(workerid); (void)(ntasks); (void)(exp_len);} while(0)
1245 #define _STARPU_TRACE_HYPERVISOR_BEGIN() do {} while(0)
1246 #define _STARPU_TRACE_HYPERVISOR_END() do {} while(0)
1247 #define _STARPU_TRACE_SCHED_COMPONENT_NEW(component) do {(void)(component);} while (0)
1248 #define _STARPU_TRACE_SCHED_COMPONENT_CONNECT(parent, child) do {(void)(parent); (void)(child);} while (0)
1249 #define _STARPU_TRACE_SCHED_COMPONENT_PUSH(from, to, task) do {(void)(from); (void)(to); (void)(task);} while (0)
1250 #define _STARPU_TRACE_SCHED_COMPONENT_PULL(from, to, task) do {(void)(from); (void)(to); (void)(task);} while (0)
1251 #define _STARPU_TRACE_HANDLE_DATA_REGISTER(handle) do {(void)(handle);} while (0)
1252 #define _STARPU_TRACE_HANDLE_DATA_UNREGISTER(handle) do {(void)(handle);} while (0)
1253 #define _STARPU_TRACE_WORKER_START_FETCH_INPUT(job, id) do {(void)(job); (void)(id);} while(0)
1254 #define _STARPU_TRACE_WORKER_END_FETCH_INPUT(job, id) do {(void)(job); (void)(id);} while(0)
1255 #define _STARPU_TRACE_DATA_STATE_INVALID(handle, node) do {(void)(handle); (void)(node);} while(0)
1256 #define _STARPU_TRACE_DATA_STATE_OWNER(handle, node) do {(void)(handle); (void)(node);} while(0)
1257 #define _STARPU_TRACE_DATA_STATE_SHARED(handle, node) do {(void)(handle); (void)(node);} while(0)
1258 #define _STARPU_TRACE_DATA_REQUEST_CREATED(handle, orig, dest, prio, is_pre) do {(void)(handle); (void)(orig); (void)(dest); (void)(prio); (void)(is_pre);} while(0)
1259 
1260 #endif // STARPU_USE_FXT
1261 
1262 #endif // __FXT_H__
utils.h