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-2022 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 #ifdef STARPU_USE_FXT
40 #include <fxt/fxt.h>
41 #include <fxt/fut.h>
42 #endif
43 
44 #pragma GCC visibility push(hidden)
45 
46 /* some key to identify the worker kind */
47 #define _STARPU_FUT_WORKER_KEY(kind) (kind + 0x100)
48 #define _STARPU_FUT_KEY_WORKER(key) (key - 0x100)
49 
50 #define _STARPU_FUT_WORKER_INIT_START 0x5100
51 #define _STARPU_FUT_WORKER_INIT_END 0x5101
52 
53 #define _STARPU_FUT_START_CODELET_BODY 0x5102
54 #define _STARPU_FUT_END_CODELET_BODY 0x5103
55 
56 #define _STARPU_FUT_JOB_PUSH 0x5104
57 #define _STARPU_FUT_JOB_POP 0x5105
58 
59 #define _STARPU_FUT_UPDATE_TASK_CNT 0x5106
60 
61 #define _STARPU_FUT_START_FETCH_INPUT_ON_TID 0x5107
62 #define _STARPU_FUT_END_FETCH_INPUT_ON_TID 0x5108
63 #define _STARPU_FUT_START_PUSH_OUTPUT_ON_TID 0x5109
64 #define _STARPU_FUT_END_PUSH_OUTPUT_ON_TID 0x5110
65 
66 #define _STARPU_FUT_TAG 0x5111
67 #define _STARPU_FUT_TAG_DEPS 0x5112
68 
69 #define _STARPU_FUT_TASK_DEPS 0x5113
70 
71 #define _STARPU_FUT_DATA_COPY 0x5114
72 #define _STARPU_FUT_WORK_STEALING 0x5115
73 
74 #define _STARPU_FUT_WORKER_DEINIT_START 0x5116
75 #define _STARPU_FUT_WORKER_DEINIT_END 0x5117
76 
77 #define _STARPU_FUT_WORKER_SLEEP_START 0x5118
78 #define _STARPU_FUT_WORKER_SLEEP_END 0x5119
79 
80 #define _STARPU_FUT_TASK_SUBMIT 0x511a
81 #define _STARPU_FUT_CODELET_DATA_HANDLE 0x511b
82 
83 #define _STARPU_FUT_MODEL_NAME 0x511c
84 
85 #define _STARPU_FUT_DATA_NAME 0x511d
86 #define _STARPU_FUT_DATA_COORDINATES 0x511e
87 #define _STARPU_FUT_HANDLE_DATA_UNREGISTER 0x511f
88 
89 #define _STARPU_FUT_CODELET_DATA_HANDLE_NUMA_ACCESS 0x5120
90 
91 #define _STARPU_FUT_NEW_MEM_NODE 0x5122
92 
93 #define _STARPU_FUT_START_CALLBACK 0x5123
94 #define _STARPU_FUT_END_CALLBACK 0x5124
95 
96 #define _STARPU_FUT_TASK_DONE 0x5125
97 #define _STARPU_FUT_TAG_DONE 0x5126
98 
99 #define _STARPU_FUT_START_ALLOC 0x5127
100 #define _STARPU_FUT_END_ALLOC 0x5128
101 
102 #define _STARPU_FUT_START_ALLOC_REUSE 0x5129
103 #define _STARPU_FUT_END_ALLOC_REUSE 0x5130
104 
105 #define _STARPU_FUT_USED_MEM 0x512a
106 
107 #define _STARPU_FUT_TASK_NAME 0x512b
108 
109 #define _STARPU_FUT_DATA_WONT_USE 0x512c
110 
111 #define _STARPU_FUT_TASK_COLOR 0x512d
112 
113 #define _STARPU_FUT_DATA_DOING_WONT_USE 0x512e
114 
115 #define _STARPU_FUT_TASK_LINE 0x512f
116 
117 #define _STARPU_FUT_START_MEMRECLAIM 0x5131
118 #define _STARPU_FUT_END_MEMRECLAIM 0x5132
119 
120 #define _STARPU_FUT_START_DRIVER_COPY 0x5133
121 #define _STARPU_FUT_END_DRIVER_COPY 0x5134
122 
123 #define _STARPU_FUT_START_DRIVER_COPY_ASYNC 0x5135
124 #define _STARPU_FUT_END_DRIVER_COPY_ASYNC 0x5136
125 
126 #define _STARPU_FUT_START_PROGRESS_ON_TID 0x5137
127 #define _STARPU_FUT_END_PROGRESS_ON_TID 0x5138
128 
129 #define _STARPU_FUT_USER_EVENT 0x5139
130 
131 #define _STARPU_FUT_SET_PROFILING 0x513a
132 
133 #define _STARPU_FUT_TASK_WAIT_FOR_ALL 0x513b
134 
135 #define _STARPU_FUT_EVENT 0x513c
136 #define _STARPU_FUT_THREAD_EVENT 0x513d
137 
138 #define _STARPU_FUT_CODELET_DETAILS 0x513e
139 #define _STARPU_FUT_CODELET_DATA 0x513f
140 
141 #define _STARPU_FUT_LOCKING_MUTEX 0x5140
142 #define _STARPU_FUT_MUTEX_LOCKED 0x5141
143 
144 #define _STARPU_FUT_UNLOCKING_MUTEX 0x5142
145 #define _STARPU_FUT_MUTEX_UNLOCKED 0x5143
146 
147 #define _STARPU_FUT_TRYLOCK_MUTEX 0x5144
148 
149 #define _STARPU_FUT_RDLOCKING_RWLOCK 0x5145
150 #define _STARPU_FUT_RWLOCK_RDLOCKED 0x5146
151 
152 #define _STARPU_FUT_WRLOCKING_RWLOCK 0x5147
153 #define _STARPU_FUT_RWLOCK_WRLOCKED 0x5148
154 
155 #define _STARPU_FUT_UNLOCKING_RWLOCK 0x5149
156 #define _STARPU_FUT_RWLOCK_UNLOCKED 0x514a
157 
158 #define _STARPU_FUT_LOCKING_SPINLOCK 0x514b
159 #define _STARPU_FUT_SPINLOCK_LOCKED 0x514c
160 
161 #define _STARPU_FUT_UNLOCKING_SPINLOCK 0x514d
162 #define _STARPU_FUT_SPINLOCK_UNLOCKED 0x514e
163 
164 #define _STARPU_FUT_TRYLOCK_SPINLOCK 0x514f
165 
166 #define _STARPU_FUT_COND_WAIT_BEGIN 0x5150
167 #define _STARPU_FUT_COND_WAIT_END 0x5151
168 
169 #define _STARPU_FUT_MEMORY_FULL 0x5152
170 
171 #define _STARPU_FUT_DATA_LOAD 0x5153
172 
173 #define _STARPU_FUT_START_UNPARTITION_ON_TID 0x5154
174 #define _STARPU_FUT_END_UNPARTITION_ON_TID 0x5155
175 
176 #define _STARPU_FUT_START_FREE 0x5156
177 #define _STARPU_FUT_END_FREE 0x5157
178 
179 #define _STARPU_FUT_START_WRITEBACK 0x5158
180 #define _STARPU_FUT_END_WRITEBACK 0x5159
181 
182 #define _STARPU_FUT_SCHED_COMPONENT_PUSH_PRIO 0x515a
183 #define _STARPU_FUT_SCHED_COMPONENT_POP_PRIO 0x515b
184 
185 #define _STARPU_FUT_START_WRITEBACK_ASYNC 0x515c
186 #define _STARPU_FUT_END_WRITEBACK_ASYNC 0x515d
187 
188 #define _STARPU_FUT_HYPERVISOR_BEGIN 0x5160
189 #define _STARPU_FUT_HYPERVISOR_END 0x5161
190 
191 #define _STARPU_FUT_BARRIER_WAIT_BEGIN 0x5162
192 #define _STARPU_FUT_BARRIER_WAIT_END 0x5163
193 
194 #define _STARPU_FUT_WORKER_SCHEDULING_START 0x5164
195 #define _STARPU_FUT_WORKER_SCHEDULING_END 0x5165
196 #define _STARPU_FUT_WORKER_SCHEDULING_PUSH 0x5166
197 #define _STARPU_FUT_WORKER_SCHEDULING_POP 0x5167
198 
199 #define _STARPU_FUT_START_EXECUTING 0x5168
200 #define _STARPU_FUT_END_EXECUTING 0x5169
201 
202 #define _STARPU_FUT_SCHED_COMPONENT_NEW 0x516a
203 #define _STARPU_FUT_SCHED_COMPONENT_CONNECT 0x516b
204 #define _STARPU_FUT_SCHED_COMPONENT_PUSH 0x516c
205 #define _STARPU_FUT_SCHED_COMPONENT_PULL 0x516d
206 
207 #define _STARPU_FUT_TASK_SUBMIT_START 0x516e
208 #define _STARPU_FUT_TASK_SUBMIT_END 0x516f
209 
210 #define _STARPU_FUT_TASK_BUILD_START 0x5170
211 #define _STARPU_FUT_TASK_BUILD_END 0x5171
212 
213 #define _STARPU_FUT_TASK_MPI_DECODE_START 0x5172
214 #define _STARPU_FUT_TASK_MPI_DECODE_END 0x5173
215 
216 #define _STARPU_FUT_TASK_MPI_PRE_START 0x5174
217 #define _STARPU_FUT_TASK_MPI_PRE_END 0x5175
218 
219 #define _STARPU_FUT_TASK_MPI_POST_START 0x5176
220 #define _STARPU_FUT_TASK_MPI_POST_END 0x5177
221 
222 #define _STARPU_FUT_TASK_WAIT_START 0x5178
223 #define _STARPU_FUT_TASK_WAIT_END 0x5179
224 
225 #define _STARPU_FUT_TASK_WAIT_FOR_ALL_START 0x517a
226 #define _STARPU_FUT_TASK_WAIT_FOR_ALL_END 0x517b
227 
228 #define _STARPU_FUT_HANDLE_DATA_REGISTER 0x517c
229 
230 #define _STARPU_FUT_START_FETCH_INPUT 0x517e
231 #define _STARPU_FUT_END_FETCH_INPUT 0x517f
232 
233 #define _STARPU_FUT_TASK_THROTTLE_START 0x5180
234 #define _STARPU_FUT_TASK_THROTTLE_END 0x5181
235 
236 #define _STARPU_FUT_DATA_STATE_INVALID 0x5182
237 #define _STARPU_FUT_DATA_STATE_OWNER 0x5183
238 #define _STARPU_FUT_DATA_STATE_SHARED 0x5184
239 
240 #define _STARPU_FUT_DATA_REQUEST_CREATED 0x5185
241 #define _STARPU_FUT_PAPI_TASK_EVENT_VALUE 0x5186
242 #define _STARPU_FUT_TASK_EXCLUDE_FROM_DAG 0x5187
243 
244 #define _STARPU_FUT_TASK_END_DEP 0x5188
245 
246 #ifdef STARPU_BUBBLE
247 #define _STARPU_FUT_TASK_BUBBLE 0x5189
248 #endif
249 
250 /* Predefined FUT key masks */
251 #define _STARPU_FUT_KEYMASK_META FUT_KEYMASK0
252 #define _STARPU_FUT_KEYMASK_USER FUT_KEYMASK1
253 #define _STARPU_FUT_KEYMASK_TASK FUT_KEYMASK2
254 #define _STARPU_FUT_KEYMASK_TASK_VERBOSE FUT_KEYMASK3
255 #define _STARPU_FUT_KEYMASK_DATA FUT_KEYMASK4
256 #define _STARPU_FUT_KEYMASK_DATA_VERBOSE FUT_KEYMASK5
257 #define _STARPU_FUT_KEYMASK_WORKER FUT_KEYMASK6
258 #define _STARPU_FUT_KEYMASK_WORKER_VERBOSE FUT_KEYMASK7
259 #define _STARPU_FUT_KEYMASK_DSM FUT_KEYMASK8
260 #define _STARPU_FUT_KEYMASK_DSM_VERBOSE FUT_KEYMASK9
261 #define _STARPU_FUT_KEYMASK_SCHED FUT_KEYMASK10
262 #define _STARPU_FUT_KEYMASK_SCHED_VERBOSE FUT_KEYMASK11
263 #define _STARPU_FUT_KEYMASK_LOCK FUT_KEYMASK12
264 #define _STARPU_FUT_KEYMASK_LOCK_VERBOSE FUT_KEYMASK13
265 #define _STARPU_FUT_KEYMASK_EVENT FUT_KEYMASK14
266 #define _STARPU_FUT_KEYMASK_EVENT_VERBOSE FUT_KEYMASK15
267 #define _STARPU_FUT_KEYMASK_MPI FUT_KEYMASK16
268 #define _STARPU_FUT_KEYMASK_MPI_VERBOSE FUT_KEYMASK17
269 #define _STARPU_FUT_KEYMASK_HYP FUT_KEYMASK18
270 #define _STARPU_FUT_KEYMASK_HYP_VERBOSE FUT_KEYMASK19
271 #define _STARPU_FUT_KEYMASK_TASK_VERBOSE_EXTRA FUT_KEYMASK20
272 #define _STARPU_FUT_KEYMASK_MPI_VERBOSE_EXTRA FUT_KEYMASK21
273 /* When doing modifications to keymasks:
274  * - also adapt _starpu_profile_get_user_keymask() in src/common/fxt.c
275  * - adapt KEYMASKALL_DEFAULT in src/common/fxt.c
276  * - adapt the documentation in 501_environment_variable.doxy and/or
277  * 380_offline_performance_tools.doxy */
278 
279 extern unsigned long _starpu_job_cnt;
280 
281 static inline unsigned long _starpu_fxt_get_job_id(void)
282 {
283  unsigned long ret = STARPU_ATOMIC_ADDL(&_starpu_job_cnt, 1);
284  STARPU_ASSERT_MSG(ret != 0, "Oops, job_id wrapped! There are too many tasks for tracking them for profiling");
285  return ret;
286 }
287 
288 #ifdef STARPU_USE_FXT
289 
290 /* Some versions of FxT do not include the declaration of the function */
291 #ifdef HAVE_ENABLE_FUT_FLUSH
292 #if !HAVE_DECL_ENABLE_FUT_FLUSH
293 void enable_fut_flush();
294 #endif
295 #endif
296 #ifdef HAVE_FUT_SET_FILENAME
297 #if !HAVE_DECL_FUT_SET_FILENAME
298 void fut_set_filename(char *filename);
299 #endif
300 #endif
301 
302 extern int _starpu_fxt_started STARPU_ATTRIBUTE_VISIBILITY_DEFAULT;
303 extern int _starpu_fxt_willstart STARPU_ATTRIBUTE_VISIBILITY_DEFAULT;
304 extern starpu_pthread_mutex_t _starpu_fxt_started_mutex STARPU_ATTRIBUTE_VISIBILITY_DEFAULT;
305 extern starpu_pthread_cond_t _starpu_fxt_started_cond STARPU_ATTRIBUTE_VISIBILITY_DEFAULT;
306 
308 static inline int _starpu_fxt_wait_initialisation()
309 {
310  STARPU_PTHREAD_MUTEX_LOCK(&_starpu_fxt_started_mutex);
311  while (_starpu_fxt_willstart && !_starpu_fxt_started)
312  STARPU_PTHREAD_COND_WAIT(&_starpu_fxt_started_cond, &_starpu_fxt_started_mutex);
313  STARPU_PTHREAD_MUTEX_UNLOCK(&_starpu_fxt_started_mutex);
314 
315  return _starpu_fxt_started;
316 }
317 
318 extern unsigned long _starpu_submit_order;
319 
320 static inline unsigned long _starpu_fxt_get_submit_order(void)
321 {
322  unsigned long ret = STARPU_ATOMIC_ADDL(&_starpu_submit_order, 1);
323  STARPU_ASSERT_MSG(_starpu_submit_order != 0, "Oops, submit_order wrapped! There are too many tasks for tracking them for profiling");
324  return ret;
325 }
326 
327 long _starpu_gettid(void) STARPU_ATTRIBUTE_VISIBILITY_DEFAULT;
328 
329 int _starpu_generate_paje_trace_read_option(const char *option, struct starpu_fxt_options *options) STARPU_ATTRIBUTE_VISIBILITY_DEFAULT;
330 
332 void _starpu_fxt_init_profiling(uint64_t trace_buffer_size);
333 
335 void _starpu_stop_fxt_profiling(void);
336 
338 void _starpu_profiling_set_mpi_worldsize(int worldsize) STARPU_ATTRIBUTE_VISIBILITY_DEFAULT;
339 
341 void _starpu_fxt_dump_file(void);
342 
343 #ifdef FUT_NEEDS_COMMIT
344 #define _STARPU_FUT_COMMIT(size) fut_commitstampedbuffer(size)
345 #else
346 #define _STARPU_FUT_COMMIT(size) do { } while (0)
347 #endif
348 
349 #ifdef FUT_RAW_ALWAYS_PROBE1STR
350 #define _STARPU_FUT_ALWAYS_PROBE1STR(CODE, P1, str) FUT_RAW_ALWAYS_PROBE1STR(CODE, P1, str)
351 #else
352 #define _STARPU_FUT_ALWAYS_PROBE1STR(CODE, P1, str) \
353 do { \
354  if(STARPU_UNLIKELY(fut_active)) { \
355  /* No more than FXT_MAX_PARAMS args are allowed */ \
356  /* we add a \0 just in case ... */ \
357  size_t len = STARPU_MIN(strlen(str)+1, (FXT_MAX_PARAMS - 1)*sizeof(unsigned long));\
358  unsigned nbargs_str = (len + sizeof(unsigned long) - 1)/(sizeof(unsigned long));\
359  unsigned nbargs = 1 + nbargs_str; \
360  size_t total_len = FUT_SIZE(nbargs); \
361  unsigned long *futargs = \
362  fut_getstampedbuffer(FUT_CODE(CODE, nbargs), total_len);\
363  *(futargs++) = (unsigned long)(P1); \
364  snprintf((char *)futargs, len, "%s", str); \
365  ((char *)futargs)[len - 1] = '\0'; \
366  _STARPU_FUT_COMMIT(total_len); \
367  }} while (0)
368 #endif
369 
370 #ifdef FUT_FULL_PROBE1STR
371 #define _STARPU_FUT_FULL_PROBE1STR(KEYMASK, CODE, P1, str) FUT_FULL_PROBE1STR(CODE, P1, str)
372 #else
376 #define _STARPU_FUT_FULL_PROBE1STR(KEYMASK, CODE, P1, str) \
377 do { \
378  if (STARPU_UNLIKELY(KEYMASK & fut_active)) { \
379  _STARPU_FUT_ALWAYS_PROBE1STR(CODE, P1, str); \
380  } \
381 } while (0)
382 #endif
383 
384 #ifdef FUT_ALWAYS_PROBE2STR
385 #define _STARPU_FUT_ALWAYS_PROBE2STR(CODE, P1, P2, str) FUT_RAW_ALWAYS_PROBE2STR(CODE, P1, P2, str)
386 #else
387 #define _STARPU_FUT_ALWAYS_PROBE2STR(CODE, P1, P2, str) \
388 do { \
389  /* No more than FXT_MAX_PARAMS args are allowed */ \
390  /* we add a \0 just in case ... */ \
391  size_t len = STARPU_MIN(strlen(str)+1, (FXT_MAX_PARAMS - 2)*sizeof(unsigned long));\
392  unsigned nbargs_str = (len + sizeof(unsigned long) - 1)/(sizeof(unsigned long));\
393  unsigned nbargs = 2 + nbargs_str; \
394  size_t total_len = FUT_SIZE(nbargs); \
395  unsigned long *futargs = \
396  fut_getstampedbuffer(FUT_CODE(CODE, nbargs), total_len);\
397  *(futargs++) = (unsigned long)(P1); \
398  *(futargs++) = (unsigned long)(P2); \
399  snprintf((char *)futargs, len, "%s", str); \
400  ((char *)futargs)[len - 1] = '\0'; \
401  _STARPU_FUT_COMMIT(total_len); \
402 } while (0)
403 #endif
404 
405 #ifdef FUT_FULL_PROBE2STR
406 #define _STARPU_FUT_FULL_PROBE2STR(KEYMASK, CODE, P1, P2, str) FUT_FULL_PROBE2STR(CODE, P1, P2, str)
407 #else
408 #define _STARPU_FUT_FULL_PROBE2STR(KEYMASK, CODE, P1, P2, str) \
409 do { \
410  if (STARPU_UNLIKELY(KEYMASK & fut_active)) { \
411  _STARPU_FUT_ALWAYS_PROBE2STR(CODE, P1, P2, str); \
412  } \
413 } while (0)
414 #endif
415 
416 #ifdef FUT_ALWAYS_PROBE3STR
417 #define _STARPU_FUT_ALWAYS_PROBE3STR(CODE, P1, P2, P3, str) FUT_RAW_ALWAYS_PROBE3STR(CODE, P1, P2, P3, str)
418 #else
419 #define _STARPU_FUT_ALWAYS_PROBE3STR(CODE, P1, P2, P3, str) \
420 do { \
421  /* No more than FXT_MAX_PARAMS args are allowed */ \
422  /* we add a \0 just in case ... */ \
423  size_t len = STARPU_MIN(strlen(str)+1, (FXT_MAX_PARAMS - 3)*sizeof(unsigned long));\
424  unsigned nbargs_str = (len + sizeof(unsigned long) - 1)/(sizeof(unsigned long));\
425  unsigned nbargs = 3 + nbargs_str; \
426  size_t total_len = FUT_SIZE(nbargs); \
427  unsigned long *futargs = \
428  fut_getstampedbuffer(FUT_CODE(CODE, nbargs), total_len);\
429  *(futargs++) = (unsigned long)(P1); \
430  *(futargs++) = (unsigned long)(P2); \
431  *(futargs++) = (unsigned long)(P3); \
432  snprintf((char *)futargs, len, "%s", str); \
433  ((char *)futargs)[len - 1] = '\0'; \
434  _STARPU_FUT_COMMIT(total_len); \
435 } while (0)
436 #endif
437 
438 #ifdef FUT_FULL_PROBE3STR
439 #define _STARPU_FUT_FULL_PROBE3STR(KEYMASK, CODE, P1, P2, P3, str) FUT_FULL_PROBE3STR(CODE, P1, P2, P3, str)
440 #else
441 #define _STARPU_FUT_FULL_PROBE3STR(KEYMASK, CODE, P1, P2, P3, str) \
442 do { \
443  if (STARPU_UNLIKELY(KEYMASK & fut_active)) { \
444  _STARPU_FUT_ALWAYS_PROBE3STR(CODE, P1, P2, P3, str); \
445  } \
446 } while (0)
447 #endif
448 
449 #ifdef FUT_ALWAYS_PROBE4STR
450 #define _STARPU_FUT_ALWAYS_PROBE4STR(CODE, P1, P2, P3, P4, str) FUT_RAW_ALWAYS_PROBE4STR(CODE, P1, P2, P3, P4, str)
451 #else
452 #define _STARPU_FUT_ALWAYS_PROBE4STR(CODE, P1, P2, P3, P4, str) \
453 do { \
454  /* No more than FXT_MAX_PARAMS args are allowed */ \
455  /* we add a \0 just in case ... */ \
456  size_t len = STARPU_MIN(strlen(str)+1, (FXT_MAX_PARAMS - 4)*sizeof(unsigned long));\
457  unsigned nbargs_str = (len + sizeof(unsigned long) - 1)/(sizeof(unsigned long));\
458  unsigned nbargs = 4 + nbargs_str; \
459  size_t total_len = FUT_SIZE(nbargs); \
460  unsigned long *futargs = \
461  fut_getstampedbuffer(FUT_CODE(CODE, nbargs), total_len);\
462  *(futargs++) = (unsigned long)(P1); \
463  *(futargs++) = (unsigned long)(P2); \
464  *(futargs++) = (unsigned long)(P3); \
465  *(futargs++) = (unsigned long)(P4); \
466  snprintf((char *)futargs, len, "%s", str); \
467  ((char *)futargs)[len - 1] = '\0'; \
468  _STARPU_FUT_COMMIT(total_len); \
469 } while (0)
470 #endif
471 
472 #ifdef FUT_FULL_PROBE4STR
473 #define _STARPU_FUT_FULL_PROBE4STR(KEYMASK, CODE, P1, P2, P3, P4, str) FUT_FULL_PROBE4STR(CODE, P1, P2, P3, P4, str)
474 #else
475 #define _STARPU_FUT_FULL_PROBE4STR(KEYMASK, CODE, P1, P2, P3, P4, str) \
476 do { \
477  if (STARPU_UNLIKELY(KEYMASK & fut_active)) { \
478  _STARPU_FUT_ALWAYS_PROBE4STR(CODE, P1, P2, P3, P4, str); \
479  } \
480 } while (0)
481 #endif
482 
483 #ifdef FUT_ALWAYS_PROBE5STR
484 #define _STARPU_FUT_ALWAYS_PROBE5STR(CODE, P1, P2, P3, P4, P5, str) FUT_RAW_ALWAYS_PROBE5STR(CODE, P1, P2, P3, P4, P5, str)
485 #else
486 #define _STARPU_FUT_ALWAYS_PROBE5STR(CODE, P1, P2, P3, P4, P5, str) \
487 do { \
488  /* No more than FXT_MAX_PARAMS args are allowed */ \
489  /* we add a \0 just in case ... */ \
490  size_t len = STARPU_MIN(strlen(str)+1, (FXT_MAX_PARAMS - 5)*sizeof(unsigned long));\
491  unsigned nbargs_str = (len + sizeof(unsigned long) - 1)/(sizeof(unsigned long));\
492  unsigned nbargs = 5 + nbargs_str; \
493  size_t total_len = FUT_SIZE(nbargs); \
494  unsigned long *futargs = \
495  fut_getstampedbuffer(FUT_CODE(CODE, nbargs), total_len);\
496  *(futargs++) = (unsigned long)(P1); \
497  *(futargs++) = (unsigned long)(P2); \
498  *(futargs++) = (unsigned long)(P3); \
499  *(futargs++) = (unsigned long)(P4); \
500  *(futargs++) = (unsigned long)(P5); \
501  snprintf((char *)futargs, len, "%s", str); \
502  ((char *)futargs)[len - 1] = '\0'; \
503  _STARPU_FUT_COMMIT(total_len); \
504 } while (0)
505 #endif
506 
507 #ifdef FUT_FULL_PROBE5STR
508 #define _STARPU_FUT_FULL_PROBE5STR(KEYMASK, CODE, P1, P2, P3, P4, P5, str) FUT_FULL_PROBE5STR(CODE, P1, P2, P3, P4, P5, str)
509 #else
510 #define _STARPU_FUT_FULL_PROBE5STR(KEYMASK, CODE, P1, P2, P3, P4, P5, str) \
511 do { \
512  if (STARPU_UNLIKELY(KEYMASK & fut_active)) { \
513  _STARPU_FUT_ALWAYS_PROBE5STR(CODE, P1, P2, P3, P4, P5, str); \
514  } \
515 } while (0)
516 #endif
517 
518 #ifdef FUT_ALWAYS_PROBE6STR
519 #define _STARPU_FUT_ALWAYS_PROBE6STR(CODE, P1, P2, P3, P4, P5, P6, str) FUT_RAW_ALWAYS_PROBE6STR(CODE, P1, P2, P3, P4, P5, P6, str)
520 #else
521 #define _STARPU_FUT_ALWAYS_PROBE6STR(CODE, P1, P2, P3, P4, P5, P6, str) \
522 do { \
523  /* No more than FXT_MAX_PARAMS args are allowed */ \
524  /* we add a \0 just in case ... */ \
525  size_t len = STARPU_MIN(strlen(str)+1, (FXT_MAX_PARAMS - 6)*sizeof(unsigned long));\
526  unsigned nbargs_str = (len + sizeof(unsigned long) - 1)/(sizeof(unsigned long));\
527  unsigned nbargs = 6 + nbargs_str; \
528  size_t total_len = FUT_SIZE(nbargs); \
529  unsigned long *futargs = \
530  fut_getstampedbuffer(FUT_CODE(CODE, nbargs), total_len);\
531  *(futargs++) = (unsigned long)(P1); \
532  *(futargs++) = (unsigned long)(P2); \
533  *(futargs++) = (unsigned long)(P3); \
534  *(futargs++) = (unsigned long)(P4); \
535  *(futargs++) = (unsigned long)(P5); \
536  *(futargs++) = (unsigned long)(P6); \
537  snprintf((char *)futargs, len, "%s", str); \
538  ((char *)futargs)[len - 1] = '\0'; \
539  _STARPU_FUT_COMMIT(total_len); \
540 } while (0)
541 #endif
542 
543 #ifdef FUT_FULL_PROBE6STR
544 #define _STARPU_FUT_FULL_PROBE6STR(KEYMASK, CODE, P1, P2, P3, P4, P5, P6, str) FUT_FULL_PROBE6STR(CODE, P1, P2, P3, P4, P5, P6, str)
545 #else
546 #define _STARPU_FUT_FULL_PROBE6STR(KEYMASK, CODE, P1, P2, P3, P4, P5, P6, str) \
547 do { \
548  if (STARPU_UNLIKELY(KEYMASK & fut_active)) { \
549  _STARPU_FUT_ALWAYS_PROBE6STR(CODE, P1, P2, P3, P4, P5, P6, str); \
550  } \
551 } while (0)
552 #endif
553 
554 #ifdef FUT_ALWAYS_PROBE7STR
555 #define _STARPU_FUT_ALWAYS_PROBE7STR(CODE, P1, P2, P3, P4, P5, P6, P7, str) FUT_RAW_ALWAYS_PROBE7STR(CODE, P1, P2, P3, P4, P5, P6, P7, str)
556 #else
557 #define _STARPU_FUT_ALWAYS_PROBE7STR(CODE, P1, P2, P3, P4, P5, P6, P7, str) \
558 do { \
559  /* No more than FXT_MAX_PARAMS args are allowed */ \
560  /* we add a \0 just in case ... */ \
561  size_t len = STARPU_MIN(strlen(str)+1, (FXT_MAX_PARAMS - 7)*sizeof(unsigned long));\
562  unsigned nbargs_str = (len + sizeof(unsigned long) - 1)/(sizeof(unsigned long));\
563  unsigned nbargs = 7 + nbargs_str; \
564  size_t total_len = FUT_SIZE(nbargs); \
565  unsigned long *futargs = \
566  fut_getstampedbuffer(FUT_CODE(CODE, nbargs), total_len);\
567  *(futargs++) = (unsigned long)(P1); \
568  *(futargs++) = (unsigned long)(P2); \
569  *(futargs++) = (unsigned long)(P3); \
570  *(futargs++) = (unsigned long)(P4); \
571  *(futargs++) = (unsigned long)(P5); \
572  *(futargs++) = (unsigned long)(P6); \
573  *(futargs++) = (unsigned long)(P7); \
574  snprintf((char *)futargs, len, "%s", str); \
575  ((char *)futargs)[len - 1] = '\0'; \
576  _STARPU_FUT_COMMIT(total_len); \
577 } while (0)
578 #endif
579 
580 #ifdef FUT_FULL_PROBE7STR
581 #define _STARPU_FUT_FULL_PROBE7STR(KEYMASK, CODE, P1, P2, P3, P4, P5, P6, P7, str) FUT_FULL_PROBE7STR(CODE, P1, P2, P3, P4, P5, P6, P7, str)
582 #else
583 #define _STARPU_FUT_FULL_PROBE7STR(KEYMASK, CODE, P1, P2, P3, P4, P5, P6, P7, str) \
584 do { \
585  if (STARPU_UNLIKELY(KEYMASK & fut_active)) { \
586  _STARPU_FUT_ALWAYS_PROBE7STR(CODE, P1, P2, P3, P4, P5, P6, P7, str); \
587  } \
588 } while (0)
589 #endif
590 
591 #ifndef FUT_RAW_PROBE7
592 #define FUT_RAW_PROBE7(CODE,P1,P2,P3,P4,P5,P6,P7) do { \
593  if(STARPU_UNLIKELY(fut_active)) { \
594  unsigned long *__args __attribute__((unused))= \
595  fut_getstampedbuffer(CODE, \
596  FUT_SIZE(7)); \
597  *(__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); \
598  _STARPU_FUT_COMMIT(FUT_SIZE(7)); \
599  } \
600  } while (0)
601 #endif
602 
603 #ifndef FUT_RAW_ALWAYS_PROBE1
604 #define FUT_RAW_ALWAYS_PROBE1(CODE,P1) do { \
605  unsigned long *__args __attribute__((unused))= \
606  fut_getstampedbuffer(CODE, \
607  FUT_SIZE(1)); \
608  *(__args++)=(unsigned long)(P1); \
609  fut_commitstampedbuffer(FUT_SIZE(1)); \
610  } while (0)
611 #endif
612 #define FUT_DO_ALWAYS_PROBE1(CODE,P1) do { \
613  FUT_RAW_ALWAYS_PROBE1(FUT_CODE(CODE, 1),P1); \
614 } while (0)
615 
616 #ifndef FUT_RAW_ALWAYS_PROBE2
617 #define FUT_RAW_ALWAYS_PROBE2(CODE,P1,P2) do { \
618  unsigned long *__args __attribute__((unused))= \
619  fut_getstampedbuffer(CODE, \
620  FUT_SIZE(2)); \
621  *(__args++)=(unsigned long)(P1);*(__args++)=(unsigned long)(P2); \
622  fut_commitstampedbuffer(FUT_SIZE(2)); \
623  } while (0)
624 #endif
625 #define FUT_DO_ALWAYS_PROBE2(CODE,P1,P2) do { \
626  FUT_RAW_ALWAYS_PROBE2(FUT_CODE(CODE, 2),P1,P2); \
627 } while (0)
628 
629 #ifndef FUT_RAW_ALWAYS_PROBE3
630 #define FUT_RAW_ALWAYS_PROBE3(CODE,P1,P2,P3) do { \
631  unsigned long *__args __attribute__((unused))= \
632  fut_getstampedbuffer(CODE, \
633  FUT_SIZE(3)); \
634  *(__args++)=(unsigned long)(P1);*(__args++)=(unsigned long)(P2);*(__args++)=(unsigned long)(P3); \
635  fut_commitstampedbuffer(FUT_SIZE(3)); \
636  } while (0)
637 #endif
638 #define FUT_DO_ALWAYS_PROBE3(CODE,P1,P2,P3) do { \
639  FUT_RAW_ALWAYS_PROBE3(FUT_CODE(CODE, 3),P1,P2,P3); \
640 } while (0)
641 
642 #ifndef FUT_RAW_ALWAYS_PROBE4
643 #define FUT_RAW_ALWAYS_PROBE4(CODE,P1,P2,P3,P4) do { \
644  unsigned long *__args __attribute__((unused))= \
645  fut_getstampedbuffer(CODE, \
646  FUT_SIZE(4)); \
647  *(__args++)=(unsigned long)(P1);*(__args++)=(unsigned long)(P2);*(__args++)=(unsigned long)(P3);*(__args++)=(unsigned long)(P4); \
648  fut_commitstampedbuffer(FUT_SIZE(4)); \
649  } while (0)
650 #endif
651 #define FUT_DO_ALWAYS_PROBE4(CODE,P1,P2,P3,P4) do { \
652  FUT_RAW_ALWAYS_PROBE4(FUT_CODE(CODE, 4),P1,P2,P3,P4); \
653 } while (0)
654 
655 #ifndef FUT_RAW_ALWAYS_PROBE5
656 #define FUT_RAW_ALWAYS_PROBE5(CODE,P1,P2,P3,P4,P5) do { \
657  unsigned long *__args __attribute__((unused))= \
658  fut_getstampedbuffer(CODE, \
659  FUT_SIZE(5)); \
660  *(__args++)=(unsigned long)(P1);*(__args++)=(unsigned long)(P2);*(__args++)=(unsigned long)(P3);*(__args++)=(unsigned long)(P4);*(__args++)=(unsigned long)(P5); \
661  fut_commitstampedbuffer(FUT_SIZE(5)); \
662  } while (0)
663 #endif
664 #define FUT_DO_ALWAYS_PROBE5(CODE,P1,P2,P3,P4,P5) do { \
665  FUT_RAW_ALWAYS_PROBE5(FUT_CODE(CODE, 5),P1,P2,P3,P4,P5); \
666 } while (0)
667 
668 #ifndef FUT_RAW_ALWAYS_PROBE6
669 #define FUT_RAW_ALWAYS_PROBE6(CODE,P1,P2,P3,P4,P5,P6) do { \
670  unsigned long *__args __attribute__((unused))= \
671  fut_getstampedbuffer(CODE, \
672  FUT_SIZE(6)); \
673  *(__args++)=(unsigned long)(P1);*(__args++)=(unsigned long)(P2);*(__args++)=(unsigned long)(P3);*(__args++)=(unsigned long)(P4);*(__args++)=(unsigned long)(P5);*(__args++)=(unsigned long)(P6); \
674  fut_commitstampedbuffer(FUT_SIZE(6)); \
675  } while (0)
676 #endif
677 #define FUT_DO_ALWAYS_PROBE6(CODE,P1,P2,P3,P4,P5,P6) do { \
678  FUT_RAW_ALWAYS_PROBE6(FUT_CODE(CODE, 6),P1,P2,P3,P4,P5,P6); \
679 } while (0)
680 
681 #ifndef FUT_RAW_ALWAYS_PROBE7
682 #define FUT_RAW_ALWAYS_PROBE7(CODE,P1,P2,P3,P4,P5,P6,P7) do { \
683  unsigned long *__args __attribute__((unused))= \
684  fut_getstampedbuffer(CODE, \
685  FUT_SIZE(7)); \
686  *(__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); \
687  fut_commitstampedbuffer(FUT_SIZE(7)); \
688  } while (0)
689 #endif
690 #define FUT_DO_ALWAYS_PROBE7(CODE,P1,P2,P3,P4,P5,P6,P7) do { \
691  FUT_RAW_ALWAYS_PROBE7(FUT_CODE(CODE, 7),P1,P2,P3,P4,P5,P6,P7); \
692 } while (0)
693 
694 #ifndef FUT_RAW_ALWAYS_PROBE8
695 #define FUT_RAW_ALWAYS_PROBE8(CODE,P1,P2,P3,P4,P5,P6,P7,P8) do { \
696  unsigned long *__args __attribute__((unused))= \
697  fut_getstampedbuffer(CODE, \
698  FUT_SIZE(8)); \
699  *(__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);*(__args++)=(unsigned long)(P8); \
700  fut_commitstampedbuffer(FUT_SIZE(8)); \
701  } while (0)
702 #endif
703 #define FUT_DO_ALWAYS_PROBE8(CODE,P1,P2,P3,P4,P5,P6,P7,P8) do { \
704  FUT_RAW_ALWAYS_PROBE8(FUT_CODE(CODE, 8),P1,P2,P3,P4,P5,P6,P7,P8); \
705 } while (0)
706 
707 #ifndef FUT_RAW_ALWAYS_PROBE9
708 #define FUT_RAW_ALWAYS_PROBE9(CODE,P1,P2,P3,P4,P5,P6,P7,P8,P9) do { \
709  unsigned long *__args __attribute__((unused))= \
710  fut_getstampedbuffer(CODE, \
711  FUT_SIZE(9)); \
712  *(__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);*(__args++)=(unsigned long)(P8);*(__args++)=(unsigned long)(P9); \
713  fut_commitstampedbuffer(FUT_SIZE(9)); \
714  } while (0)
715 #endif
716 #define FUT_DO_ALWAYS_PROBE9(CODE,P1,P2,P3,P4,P5,P6,P7,P8,P9) do { \
717  FUT_RAW_ALWAYS_PROBE9(FUT_CODE(CODE, 9),P1,P2,P3,P4,P5,P6,P7,P8,P9); \
718 } while (0)
719 
720 /* full probes */
721 #ifndef FUT_FULL_PROBE0
722 #define FUT_FULL_PROBE0(KEYMASK,CODE) do { \
723  if (STARPU_UNLIKELY(KEYMASK & fut_active)) { \
724  FUT_RAW_ALWAYS_PROBE0(FUT_CODE(CODE, 0)); \
725  } \
726 } while(0)
727 #endif
728 
729 #ifndef FUT_FULL_PROBE1
730 #define FUT_FULL_PROBE1(KEYMASK,CODE,P1) do { \
731  if (STARPU_UNLIKELY(KEYMASK & fut_active)) { \
732  FUT_RAW_ALWAYS_PROBE1(FUT_CODE(CODE, 1),P1); \
733  } \
734 } while(0)
735 #endif
736 
737 #ifndef FUT_FULL_PROBE2
738 #define FUT_FULL_PROBE2(KEYMASK,CODE,P1,P2) do { \
739  if (STARPU_UNLIKELY(KEYMASK & fut_active)) { \
740  FUT_RAW_ALWAYS_PROBE2(FUT_CODE(CODE, 2),P1,P2); \
741  } \
742 } while(0)
743 #endif
744 
745 #ifndef FUT_FULL_PROBE3
746 #define FUT_FULL_PROBE3(KEYMASK,CODE,P1,P2,P3) do { \
747  if (STARPU_UNLIKELY(KEYMASK & fut_active)) { \
748  FUT_RAW_ALWAYS_PROBE3(FUT_CODE(CODE, 3),P1,P2,P3); \
749  } \
750 } while(0)
751 #endif
752 
753 #ifndef FUT_FULL_PROBE4
754 #define FUT_FULL_PROBE4(KEYMASK,CODE,P1,P2,P3,P4) do { \
755  if (STARPU_UNLIKELY(KEYMASK & fut_active)) { \
756  FUT_RAW_ALWAYS_PROBE4(FUT_CODE(CODE, 4),P1,P2,P3,P4); \
757  } \
758 } while(0)
759 #endif
760 
761 #ifndef FUT_FULL_PROBE5
762 #define FUT_FULL_PROBE5(KEYMASK,CODE,P1,P2,P3,P4,P5) do { \
763  if (STARPU_UNLIKELY(KEYMASK & fut_active)) { \
764  FUT_RAW_ALWAYS_PROBE5(FUT_CODE(CODE, 5),P1,P2,P3,P4,P5); \
765  } \
766 } while(0)
767 #endif
768 
769 #ifndef FUT_FULL_PROBE6
770 #define FUT_FULL_PROBE6(KEYMASK,CODE,P1,P2,P3,P4,P5,P6) do { \
771  if (STARPU_UNLIKELY(KEYMASK & fut_active)) { \
772  FUT_RAW_ALWAYS_PROBE6(FUT_CODE(CODE, 6),P1,P2,P3,P4,P5,P6); \
773  } \
774 } while(0)
775 #endif
776 
777 #ifndef FUT_FULL_PROBE7
778 #define FUT_FULL_PROBE7(KEYMASK,CODE,P1,P2,P3,P4,P5,P6,P7) do { \
779  if (STARPU_UNLIKELY(KEYMASK & fut_active)) { \
780  FUT_RAW_ALWAYS_PROBE7(FUT_CODE(CODE, 7),P1,P2,P3,P4,P5,P6,P7); \
781  } \
782 } while(0)
783 #endif
784 
785 #ifndef FUT_FULL_PROBE8
786 #define FUT_FULL_PROBE8(KEYMASK,CODE,P1,P2,P3,P4,P5,P6,P7,P8) do { \
787  if(KEYMASK & fut_active) { \
788  FUT_RAW_ALWAYS_PROBE8(FUT_CODE(CODE, 8),P1,P2,P3,P4,P5,P6,P7,P8); \
789  } \
790 } while(0)
791 #endif
792 
793 #ifndef FUT_FULL_PROBE9
794 #define FUT_FULL_PROBE9(KEYMASK,CODE,P1,P2,P3,P4,P5,P6,P7,P8,P9) do { \
795  if(KEYMASK & fut_active) { \
796  FUT_RAW_ALWAYS_PROBE9(FUT_CODE(CODE, 9),P1,P2,P3,P4,P5,P6,P7,P8,P9); \
797  } \
798 } while(0)
799 #endif
800 
801 #define _STARPU_TRACE_NEW_MEM_NODE(nodeid) do {\
802  if (_starpu_fxt_started) \
803  FUT_DO_ALWAYS_PROBE2(_STARPU_FUT_NEW_MEM_NODE, nodeid, _starpu_gettid()); \
804 } while (0)
805 
806 #define _STARPU_TRACE_REGISTER_THREAD(cpuid) do {\
807  if (_starpu_fxt_started) \
808  FUT_DO_ALWAYS_PROBE2(FUT_NEW_LWP_CODE, cpuid, _starpu_gettid()); \
809 } while (0)
810 
811 #define _STARPU_TRACE_WORKER_INIT_START(workerkind, workerid, devid, memnode, bindid, sync) do {\
812  if (_starpu_fxt_started) \
813  FUT_DO_ALWAYS_PROBE7(_STARPU_FUT_WORKER_INIT_START, _STARPU_FUT_WORKER_KEY(workerkind), workerid, devid, memnode, bindid, sync, _starpu_gettid()); \
814 } while (0)
815 
816 #define _STARPU_TRACE_WORKER_INIT_END(__workerid) do {\
817  if (_starpu_fxt_started) \
818  FUT_DO_ALWAYS_PROBE2(_STARPU_FUT_WORKER_INIT_END, _starpu_gettid(), (__workerid)); \
819 } while (0)
820 
821 #define _STARPU_TRACE_START_CODELET_BODY(job, nimpl, perf_arch, workerid) \
822 do { \
823  if(STARPU_UNLIKELY((_STARPU_FUT_KEYMASK_TASK|_STARPU_FUT_KEYMASK_TASK_VERBOSE|_STARPU_FUT_KEYMASK_DATA|_STARPU_FUT_KEYMASK_TASK_VERBOSE_EXTRA) & fut_active)) { \
824  FUT_FULL_PROBE4(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_START_CODELET_BODY, (job)->job_id, ((job)->task)->sched_ctx, workerid, starpu_worker_get_memory_node(workerid)); \
825  { \
826  if ((job)->task->cl) \
827  { \
828  const int __nbuffers = STARPU_TASK_GET_NBUFFERS((job)->task); \
829  char __buf[FXT_MAX_PARAMS*sizeof(long)]; \
830  int __i; \
831  for (__i = 0; __i < __nbuffers; __i++) \
832  { \
833  starpu_data_handle_t __handle = STARPU_TASK_GET_HANDLE((job)->task, __i); \
834  void *__interface = _STARPU_TASK_GET_INTERFACES((job)->task)[__i]; \
835  if (__handle->ops->describe) \
836  { \
837  __handle->ops->describe(__interface, __buf, sizeof(__buf)); \
838  _STARPU_FUT_FULL_PROBE1STR(_STARPU_FUT_KEYMASK_DATA, _STARPU_FUT_CODELET_DATA, workerid, __buf); \
839  } \
840  FUT_FULL_PROBE4(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_CODELET_DATA_HANDLE, (job)->job_id, (__handle), _starpu_data_get_size(__handle), STARPU_TASK_GET_MODE((job)->task, __i)); \
841  /* Regarding the memory location:
842  * - if the data interface doesn't provide to_pointer operation, NULL will be returned
843  * and the location will be -1, which is fine;
844  * - we have to check wether the memory is on an actual NUMA node (and not on GPU
845  * memory, for instance);
846  * - looking at memory location before executing the task isn't the best choice:
847  * the page can be not allocated yet. A solution would be to get the memory
848  * location at the end of the task, but there is no FxT probe where we iterate over
849  * handles, after task execution.
850  * */ \
851  FUT_FULL_PROBE3(_STARPU_FUT_KEYMASK_TASK_VERBOSE_EXTRA, _STARPU_FUT_CODELET_DATA_HANDLE_NUMA_ACCESS, (job)->job_id, (__i), starpu_worker_get_memory_node_kind(starpu_worker_get_type(workerid)) == STARPU_CPU_RAM && starpu_task_get_current_data_node(__i) >= 0 ? starpu_get_memory_location_bitmap(starpu_data_handle_to_pointer(__handle, (unsigned) starpu_task_get_current_data_node(__i)), starpu_data_get_size(__handle)) : -1); \
852  } \
853  } \
854  const size_t __job_size = _starpu_job_get_data_size((job)->task->cl?(job)->task->cl->model:NULL, perf_arch, nimpl, (job)); \
855  const uint32_t __job_hash = _starpu_compute_buffers_footprint((job)->task->cl?(job)->task->cl->model:NULL, perf_arch, nimpl, (job));\
856  FUT_FULL_PROBE7(_STARPU_FUT_KEYMASK_TASK_VERBOSE, _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)); \
857  } \
858  } \
859 } while(0)
860 
861 #define _STARPU_TRACE_END_CODELET_BODY(job, nimpl, perf_arch, workerid) \
862 do { \
863  if(STARPU_UNLIKELY((_STARPU_FUT_KEYMASK_TASK) & fut_active)) { \
864  const size_t job_size = _starpu_job_get_data_size((job)->task->cl?(job)->task->cl->model:NULL, perf_arch, nimpl, (job)); \
865  const uint32_t job_hash = _starpu_compute_buffers_footprint((job)->task->cl?(job)->task->cl->model:NULL, perf_arch, nimpl, (job));\
866  char _archname[32]=""; \
867  if (perf_arch) starpu_perfmodel_get_arch_name(perf_arch, _archname, 32, 0); \
868  _STARPU_FUT_FULL_PROBE5STR(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_END_CODELET_BODY, (job)->job_id, (job_size), (job_hash), workerid, _starpu_gettid(), _archname); \
869  } \
870 } while(0)
871 
872 #define _STARPU_TRACE_START_EXECUTING() \
873  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_WORKER_VERBOSE, _STARPU_FUT_START_EXECUTING, _starpu_gettid());
874 
875 #define _STARPU_TRACE_END_EXECUTING() \
876  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_WORKER_VERBOSE, _STARPU_FUT_END_EXECUTING, _starpu_gettid());
877 
878 #define _STARPU_TRACE_START_CALLBACK(job) \
879  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_WORKER_VERBOSE, _STARPU_FUT_START_CALLBACK, job, _starpu_gettid());
880 
881 #define _STARPU_TRACE_END_CALLBACK(job) \
882  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_WORKER_VERBOSE, _STARPU_FUT_END_CALLBACK, job, _starpu_gettid());
883 
884 #define _STARPU_TRACE_JOB_PUSH(task, prio) \
885  FUT_FULL_PROBE3(_STARPU_FUT_KEYMASK_SCHED, _STARPU_FUT_JOB_PUSH, _starpu_get_job_associated_to_task(task)->job_id, prio, _starpu_gettid());
886 
887 #define _STARPU_TRACE_JOB_POP(task, prio) \
888  FUT_FULL_PROBE3(_STARPU_FUT_KEYMASK_SCHED, _STARPU_FUT_JOB_POP, _starpu_get_job_associated_to_task(task)->job_id, prio, _starpu_gettid());
889 
890 #define _STARPU_TRACE_UPDATE_TASK_CNT(counter) \
891  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_UPDATE_TASK_CNT, counter, _starpu_gettid())
892 
893 #define _STARPU_TRACE_START_FETCH_INPUT(job) \
894  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_DSM, _STARPU_FUT_START_FETCH_INPUT_ON_TID, job, _starpu_gettid());
895 
896 #define _STARPU_TRACE_END_FETCH_INPUT(job) \
897  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_DSM, _STARPU_FUT_END_FETCH_INPUT_ON_TID, job, _starpu_gettid());
898 
899 #define _STARPU_TRACE_START_PUSH_OUTPUT(job) \
900  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_DSM, _STARPU_FUT_START_PUSH_OUTPUT_ON_TID, job, _starpu_gettid());
901 
902 #define _STARPU_TRACE_END_PUSH_OUTPUT(job) \
903  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_DSM, _STARPU_FUT_END_PUSH_OUTPUT_ON_TID, job, _starpu_gettid());
904 
905 #define _STARPU_TRACE_WORKER_END_FETCH_INPUT(job, id) \
906  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_WORKER_VERBOSE, _STARPU_FUT_END_FETCH_INPUT, job, id);
907 
908 #define _STARPU_TRACE_WORKER_START_FETCH_INPUT(job, id) \
909  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_WORKER_VERBOSE, _STARPU_FUT_START_FETCH_INPUT, job, id);
910 
911 #define _STARPU_TRACE_TAG(tag, job) \
912  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_TAG, tag, (job)->job_id)
913 
914 #define _STARPU_TRACE_TAG_DEPS(tag_child, tag_father) \
915  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_TAG_DEPS, tag_child, tag_father)
916 
917 #define _STARPU_TRACE_TASK_DEPS(job_prev, job_succ) \
918  _STARPU_FUT_FULL_PROBE4STR(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_TASK_DEPS, (job_prev)->job_id, (job_succ)->job_id, (job_succ)->task->type, 1, "task")
919 
920 #define _STARPU_TRACE_TASK_END_DEP(job_prev, job_succ) \
921  FUT_DO_PROBE2(_STARPU_FUT_TASK_END_DEP, (job_prev)->job_id, (job_succ)->job_id)
922 
923 #define _STARPU_TRACE_GHOST_TASK_DEPS(ghost_prev_id, job_succ) \
924  _STARPU_FUT_FULL_PROBE4STR(_STARPU_FUT_KEYMASK_TASK_VERBOSE, _STARPU_FUT_TASK_DEPS, (ghost_prev_id), (job_succ)->job_id, (job_succ)->task->type, 1, "ghost")
925 
926 #ifdef STARPU_BUBBLE
927 #define _STARPU_TRACE_BUBBLE_TASK_DEPS(prev_id, job_succ) \
928  _STARPU_FUT_FULL_PROBE4STR(_STARPU_FUT_KEYMASK_TASK_VERBOSE, _STARPU_FUT_TASK_DEPS, (prev_id), (job_succ)->job_id, (job_succ)->task->type, 1, "bubble")
929 #endif
930 
931 #define _STARPU_TRACE_TASK_EXCLUDE_FROM_DAG(job) \
932  do { \
933  unsigned exclude_from_dag = (job)->exclude_from_dag; \
934  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_TASK_EXCLUDE_FROM_DAG, (job)->job_id, (long unsigned)exclude_from_dag); \
935 } while(0)
936 
937 #define _STARPU_TRACE_TASK_NAME_LINE_COLOR(job) \
938  do { \
939  _STARPU_TRACE_TASK_NAME(job); \
940  _STARPU_TRACE_TASK_LINE(job); \
941  _STARPU_TRACE_TASK_COLOR(job); \
942  } while(0)
943 
944 #define _STARPU_TRACE_TASK_LINE(job) \
945  do { \
946  if ((job)->task->file) \
947  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_TASK_LINE, (job)->job_id, (job)->task->line, (job)->task->file); \
948 } while(0)
949 
950 #ifdef STARPU_BUBBLE
951 #define _STARPU_TRACE_BUBBLE(job) \
952 do { \
953  if(STARPU_UNLIKELY((_STARPU_FUT_KEYMASK_TASK) & fut_active)) { \
954  unsigned int is_bubble=(job)->is_bubble; \
955  unsigned long bubble_parent=(job)->task->bubble_parent; \
956  FUT_FULL_PROBE3(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_TASK_BUBBLE, (job)->job_id, is_bubble, bubble_parent); \
957  } \
958 } while(0)
959 #endif
960 
961 #define _STARPU_TRACE_TASK_NAME(job) \
962 do { \
963  if(STARPU_UNLIKELY((_STARPU_FUT_KEYMASK_TASK) & fut_active)) { \
964  const char *model_name = _starpu_job_get_model_name((job)); \
965  const char *name = _starpu_job_get_task_name((job)); \
966  if (name) \
967  { \
968  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_TASK_NAME, (job)->job_id, _starpu_gettid(), name); \
969  } \
970  else { \
971  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_TASK_NAME, (job)->job_id, _starpu_gettid(), "unknown");\
972  } \
973  if (model_name) \
974  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_MODEL_NAME, (job)->job_id, _starpu_gettid(), model_name); \
975  } \
976 } while(0)
977 
978 #define _STARPU_TRACE_TASK_COLOR(job) \
979 do { \
980  if(STARPU_UNLIKELY((_STARPU_FUT_KEYMASK_TASK) & fut_active)) { \
981  if ((job)->task->color != 0) \
982  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_TASK_COLOR, (job)->job_id, (job)->task->color); \
983  else if ((job)->task->cl && (job)->task->cl->color != 0) \
984  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_TASK_COLOR, (job)->job_id, (job)->task->cl->color); \
985  } \
986 } while(0)
987 
988 #define _STARPU_TRACE_TASK_DONE(job) \
989  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_TASK_DONE, (job)->job_id, _starpu_gettid())
990 
991 #define _STARPU_TRACE_TAG_DONE(tag) \
992 do { \
993  if(STARPU_UNLIKELY((_STARPU_FUT_KEYMASK_TASK) & fut_active)) { \
994  struct _starpu_job *job = (tag)->job; \
995  const char *model_name = _starpu_job_get_task_name((job)); \
996  if (model_name) \
997  { \
998  _STARPU_FUT_FULL_PROBE3STR(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_TAG_DONE, (tag)->id, _starpu_gettid(), 1, model_name); \
999  } \
1000  else { \
1001  FUT_FULL_PROBE3(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_TAG_DONE, (tag)->id, _starpu_gettid(), 0);\
1002  } \
1003  } \
1004 } while(0)
1005 
1006 #define _STARPU_TRACE_DATA_NAME(handle, name) \
1007  _STARPU_FUT_FULL_PROBE1STR(_STARPU_FUT_KEYMASK_META, _STARPU_FUT_DATA_NAME, handle, name)
1008 
1009 #define _STARPU_TRACE_DATA_COORDINATES(handle, dim, v) do {\
1010  switch (dim) { \
1011  case 1: FUT_FULL_PROBE3(_STARPU_FUT_KEYMASK_META, _STARPU_FUT_DATA_COORDINATES, handle, dim, v[0]); break; \
1012  case 2: FUT_FULL_PROBE4(_STARPU_FUT_KEYMASK_META, _STARPU_FUT_DATA_COORDINATES, handle, dim, v[0], v[1]); break; \
1013  case 3: FUT_FULL_PROBE5(_STARPU_FUT_KEYMASK_META, _STARPU_FUT_DATA_COORDINATES, handle, dim, v[0], v[1], v[2]); break; \
1014  case 4: FUT_FULL_PROBE6(_STARPU_FUT_KEYMASK_META, _STARPU_FUT_DATA_COORDINATES, handle, dim, v[0], v[1], v[2], v[3]); break; \
1015  default: FUT_FULL_PROBE7(_STARPU_FUT_KEYMASK_META, _STARPU_FUT_DATA_COORDINATES, handle, dim, v[0], v[1], v[2], v[3], v[4]); break; \
1016  } \
1017 } while (0)
1018 
1019 #define _STARPU_TRACE_DATA_COPY(src_node, dst_node, size) \
1020  FUT_FULL_PROBE3(_STARPU_FUT_KEYMASK_DSM, _STARPU_FUT_DATA_COPY, src_node, dst_node, size)
1021 
1022 #define _STARPU_TRACE_DATA_WONT_USE(handle) \
1023  FUT_FULL_PROBE4(_STARPU_FUT_KEYMASK_DATA, _STARPU_FUT_DATA_WONT_USE, handle, _starpu_fxt_get_submit_order(), _starpu_fxt_get_job_id(), _starpu_gettid())
1024 
1025 #define _STARPU_TRACE_DATA_DOING_WONT_USE(handle) \
1026  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_DSM, _STARPU_FUT_DATA_DOING_WONT_USE, handle)
1027 
1028 #define _STARPU_TRACE_START_DRIVER_COPY(src_node, dst_node, size, com_id, prefetch, handle) \
1029  FUT_FULL_PROBE6(_STARPU_FUT_KEYMASK_DSM, _STARPU_FUT_START_DRIVER_COPY, src_node, dst_node, size, com_id, prefetch, handle)
1030 
1031 #define _STARPU_TRACE_END_DRIVER_COPY(src_node, dst_node, size, com_id, prefetch) \
1032  FUT_FULL_PROBE5(_STARPU_FUT_KEYMASK_DSM, _STARPU_FUT_END_DRIVER_COPY, src_node, dst_node, size, com_id, prefetch)
1033 
1034 #define _STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node) \
1035  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_DSM, _STARPU_FUT_START_DRIVER_COPY_ASYNC, src_node, dst_node)
1036 
1037 #define _STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node) \
1038  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_DSM, _STARPU_FUT_END_DRIVER_COPY_ASYNC, src_node, dst_node)
1039 
1040 #define _STARPU_TRACE_WORK_STEALING(empty_q, victim_q) \
1041  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_SCHED_VERBOSE, _STARPU_FUT_WORK_STEALING, empty_q, victim_q)
1042 
1043 #define _STARPU_TRACE_WORKER_DEINIT_START do {\
1044  if (_starpu_fxt_started) \
1045  FUT_DO_ALWAYS_PROBE1(_STARPU_FUT_WORKER_DEINIT_START, _starpu_gettid()); \
1046 } while(0)
1047 
1048 #define _STARPU_TRACE_WORKER_DEINIT_END(workerkind) do {\
1049  if (_starpu_fxt_started) \
1050  FUT_DO_ALWAYS_PROBE2(_STARPU_FUT_WORKER_DEINIT_END, _STARPU_FUT_WORKER_KEY(workerkind), _starpu_gettid()); \
1051 } while(0)
1052 
1053 #define _STARPU_TRACE_WORKER_SCHEDULING_START \
1054  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_WORKER_VERBOSE, _STARPU_FUT_WORKER_SCHEDULING_START, _starpu_gettid());
1055 
1056 #define _STARPU_TRACE_WORKER_SCHEDULING_END \
1057  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_WORKER_VERBOSE, _STARPU_FUT_WORKER_SCHEDULING_END, _starpu_gettid());
1058 
1059 #define _STARPU_TRACE_WORKER_SCHEDULING_PUSH \
1060  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_WORKER_VERBOSE, _STARPU_FUT_WORKER_SCHEDULING_PUSH, _starpu_gettid());
1061 
1062 #define _STARPU_TRACE_WORKER_SCHEDULING_POP \
1063  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_WORKER_VERBOSE, _STARPU_FUT_WORKER_SCHEDULING_POP, _starpu_gettid());
1064 
1065 #define _STARPU_TRACE_WORKER_SLEEP_START \
1066  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_WORKER, _STARPU_FUT_WORKER_SLEEP_START, _starpu_gettid());
1067 
1068 #define _STARPU_TRACE_WORKER_SLEEP_END \
1069  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_WORKER, _STARPU_FUT_WORKER_SLEEP_END, _starpu_gettid());
1070 
1071 #define _STARPU_TRACE_TASK_SUBMIT(job, iter, subiter) \
1072  FUT_FULL_PROBE7(_STARPU_FUT_KEYMASK_TASK, _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());
1073 
1074 #define _STARPU_TRACE_TASK_SUBMIT_START() \
1075  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_TASK_VERBOSE, _STARPU_FUT_TASK_SUBMIT_START, _starpu_gettid());
1076 
1077 #define _STARPU_TRACE_TASK_SUBMIT_END() \
1078  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_TASK_VERBOSE, _STARPU_FUT_TASK_SUBMIT_END, _starpu_gettid());
1079 
1080 #define _STARPU_TRACE_TASK_THROTTLE_START() \
1081  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_TASK_THROTTLE_START, _starpu_gettid());
1082 
1083 #define _STARPU_TRACE_TASK_THROTTLE_END() \
1084  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_TASK_THROTTLE_END, _starpu_gettid());
1085 
1086 #define _STARPU_TRACE_TASK_BUILD_START() \
1087  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_TASK_VERBOSE, _STARPU_FUT_TASK_BUILD_START, _starpu_gettid());
1088 
1089 #define _STARPU_TRACE_TASK_BUILD_END() \
1090  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_TASK_VERBOSE, _STARPU_FUT_TASK_BUILD_END, _starpu_gettid());
1091 
1092 #define _STARPU_TRACE_TASK_MPI_DECODE_START() \
1093  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_MPI_VERBOSE, _STARPU_FUT_TASK_MPI_DECODE_START, _starpu_gettid());
1094 
1095 #define _STARPU_TRACE_TASK_MPI_DECODE_END() \
1096  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_MPI_VERBOSE, _STARPU_FUT_TASK_MPI_DECODE_END, _starpu_gettid());
1097 
1098 #define _STARPU_TRACE_TASK_MPI_PRE_START() \
1099  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_MPI_VERBOSE, _STARPU_FUT_TASK_MPI_PRE_START, _starpu_gettid());
1100 
1101 #define _STARPU_TRACE_TASK_MPI_PRE_END() \
1102  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_MPI_VERBOSE, _STARPU_FUT_TASK_MPI_PRE_END, _starpu_gettid());
1103 
1104 #define _STARPU_TRACE_TASK_MPI_POST_START() \
1105  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_MPI_VERBOSE, _STARPU_FUT_TASK_MPI_POST_START, _starpu_gettid());
1106 
1107 #define _STARPU_TRACE_TASK_MPI_POST_END() \
1108  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_MPI_VERBOSE, _STARPU_FUT_TASK_MPI_POST_END, _starpu_gettid());
1109 
1110 #define _STARPU_TRACE_TASK_WAIT_START(job) \
1111  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_TASK_VERBOSE, _STARPU_FUT_TASK_WAIT_START, (job)->job_id, _starpu_gettid());
1112 
1113 #define _STARPU_TRACE_TASK_WAIT_END() \
1114  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_TASK_VERBOSE, _STARPU_FUT_TASK_WAIT_END, _starpu_gettid());
1115 
1116 #define _STARPU_TRACE_TASK_WAIT_FOR_ALL_START() \
1117  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_TASK_VERBOSE, _STARPU_FUT_TASK_WAIT_FOR_ALL_START, _starpu_gettid());
1118 
1119 #define _STARPU_TRACE_TASK_WAIT_FOR_ALL_END() \
1120  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_TASK_VERBOSE, _STARPU_FUT_TASK_WAIT_FOR_ALL_END, _starpu_gettid());
1121 
1122 #define _STARPU_TRACE_START_ALLOC(memnode, size, handle, is_prefetch) \
1123  FUT_FULL_PROBE5(_STARPU_FUT_KEYMASK_DSM, _STARPU_FUT_START_ALLOC, memnode, _starpu_gettid(), size, handle, is_prefetch);
1124 
1125 #define _STARPU_TRACE_END_ALLOC(memnode, handle, r) \
1126  FUT_FULL_PROBE4(_STARPU_FUT_KEYMASK_DSM, _STARPU_FUT_END_ALLOC, memnode, _starpu_gettid(), handle, r);
1127 
1128 #define _STARPU_TRACE_START_ALLOC_REUSE(memnode, size, handle, is_prefetch) \
1129  FUT_FULL_PROBE5(_STARPU_FUT_KEYMASK_DSM_VERBOSE, _STARPU_FUT_START_ALLOC_REUSE, memnode, _starpu_gettid(), size, handle, is_prefetch);
1130 
1131 #define _STARPU_TRACE_END_ALLOC_REUSE(memnode, handle, r) \
1132  FUT_FULL_PROBE4(_STARPU_FUT_KEYMASK_DSM_VERBOSE, _STARPU_FUT_END_ALLOC_REUSE, memnode, _starpu_gettid(), handle, r);
1133 
1134 #define _STARPU_TRACE_START_FREE(memnode, size, handle) \
1135  FUT_FULL_PROBE4(_STARPU_FUT_KEYMASK_DSM_VERBOSE, _STARPU_FUT_START_FREE, memnode, _starpu_gettid(), size, handle);
1136 
1137 #define _STARPU_TRACE_END_FREE(memnode, handle) \
1138  FUT_FULL_PROBE3(_STARPU_FUT_KEYMASK_DSM_VERBOSE, _STARPU_FUT_END_FREE, memnode, _starpu_gettid(), handle);
1139 
1140 #define _STARPU_TRACE_START_WRITEBACK(memnode, handle) \
1141  FUT_FULL_PROBE3(_STARPU_FUT_KEYMASK_DSM_VERBOSE, _STARPU_FUT_START_WRITEBACK, memnode, _starpu_gettid(), handle);
1142 
1143 #define _STARPU_TRACE_END_WRITEBACK(memnode, handle) \
1144  FUT_FULL_PROBE3(_STARPU_FUT_KEYMASK_DSM_VERBOSE, _STARPU_FUT_END_WRITEBACK, memnode, _starpu_gettid(), handle);
1145 
1146 #define _STARPU_TRACE_USED_MEM(memnode,used) \
1147  FUT_FULL_PROBE3(_STARPU_FUT_KEYMASK_DSM_VERBOSE, _STARPU_FUT_USED_MEM, memnode, used, _starpu_gettid());
1148 
1149 #define _STARPU_TRACE_START_MEMRECLAIM(memnode,is_prefetch) \
1150  FUT_FULL_PROBE3(_STARPU_FUT_KEYMASK_DSM_VERBOSE, _STARPU_FUT_START_MEMRECLAIM, memnode, is_prefetch, _starpu_gettid());
1151 
1152 #define _STARPU_TRACE_END_MEMRECLAIM(memnode, is_prefetch) \
1153  FUT_FULL_PROBE3(_STARPU_FUT_KEYMASK_DSM_VERBOSE, _STARPU_FUT_END_MEMRECLAIM, memnode, is_prefetch, _starpu_gettid());
1154 
1155 #define _STARPU_TRACE_START_WRITEBACK_ASYNC(memnode) \
1156  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_DSM_VERBOSE, _STARPU_FUT_START_WRITEBACK_ASYNC, memnode, _starpu_gettid());
1157 
1158 #define _STARPU_TRACE_END_WRITEBACK_ASYNC(memnode) \
1159  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_DSM_VERBOSE, _STARPU_FUT_END_WRITEBACK_ASYNC, memnode, _starpu_gettid());
1160 
1161 #define _STARPU_TRACE_PAPI_TASK_EVENT(event_id, task, value) \
1162  FUT_DO_PROBE3(_STARPU_FUT_PAPI_TASK_EVENT_VALUE, event_id, _starpu_get_job_associated_to_task(task)->job_id, value)
1163 
1164 /* We skip these events becasue they are called so often that they cause FxT to
1165  * fail and make the overall trace unreadable anyway. */
1166 #define _STARPU_TRACE_START_PROGRESS(memnode) \
1167  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_WORKER_VERBOSE, _STARPU_FUT_START_PROGRESS_ON_TID, memnode, _starpu_gettid());
1168 
1169 #define _STARPU_TRACE_END_PROGRESS(memnode) \
1170  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_WORKER_VERBOSE, _STARPU_FUT_END_PROGRESS_ON_TID, memnode, _starpu_gettid());
1171 
1172 #define _STARPU_TRACE_USER_EVENT(code) \
1173  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_USER, _STARPU_FUT_USER_EVENT, code, _starpu_gettid());
1174 
1175 #define _STARPU_TRACE_META(S) \
1176  FUT_FULL_PROBESTR(_STARPU_FUT_KEYMASK_META, _STARPU_FUT_EVENT,S)
1177 
1178 #define _STARPU_TRACE_SET_PROFILING(status) \
1179  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_META, _STARPU_FUT_SET_PROFILING, status, _starpu_gettid());
1180 
1181 #define _STARPU_TRACE_TASK_WAIT_FOR_ALL \
1182  FUT_FULL_PROBE0(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_TASK_WAIT_FOR_ALL)
1183 
1184 #define _STARPU_TRACE_EVENT_ALWAYS(S) do {\
1185  if (_starpu_fxt_started) \
1186  FUT_DO_ALWAYS_PROBESTR(_STARPU_FUT_EVENT,S) \
1187 } while(0)
1188 
1189 #define _STARPU_TRACE_EVENT(S) \
1190  FUT_FULL_PROBESTR(_STARPU_FUT_KEYMASK_EVENT, _STARPU_FUT_EVENT,S)
1191 
1192 #define _STARPU_TRACE_EVENT_VERBOSE(S) \
1193  FUT_FULL_PROBESTR(_STARPU_FUT_KEYMASK_EVENT_VERBOSE, _STARPU_FUT_EVENT,S)
1194 
1195 
1196 #define _STARPU_TRACE_THREAD_EVENT(S) \
1197  _STARPU_FUT_FULL_PROBE1STR(_STARPU_FUT_KEYMASK_WORKER, _STARPU_FUT_THREAD_EVENT, _starpu_gettid(), S)
1198 
1199 #define _STARPU_TRACE_HYPERVISOR_BEGIN() \
1200  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_HYP, _STARPU_FUT_HYPERVISOR_BEGIN, _starpu_gettid());
1201 
1202 #define _STARPU_TRACE_HYPERVISOR_END() \
1203  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_HYP, _STARPU_FUT_HYPERVISOR_END, _starpu_gettid());
1204 
1205 #ifdef STARPU_FXT_LOCK_TRACES
1206 
1207 #define _STARPU_TRACE_LOCKING_MUTEX() do { \
1208  const char *file; \
1209  file = strrchr(__FILE__,'/') + 1; \
1210  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK, _STARPU_FUT_LOCKING_MUTEX,__LINE__,_starpu_gettid(),file); \
1211 } while (0)
1212 
1213 #define _STARPU_TRACE_MUTEX_LOCKED() do { \
1214  const char *file; \
1215  file = strrchr(__FILE__,'/') + 1; \
1216  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK_VERBOSE, _STARPU_FUT_MUTEX_LOCKED,__LINE__,_starpu_gettid(),file); \
1217 } while(0)
1218 
1219 #define _STARPU_TRACE_UNLOCKING_MUTEX() do { \
1220  const char *file; \
1221  file = strrchr(__FILE__,'/') + 1; \
1222  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK, _STARPU_FUT_UNLOCKING_MUTEX,__LINE__,_starpu_gettid(),file); \
1223 } while(0)
1224 
1225 #define _STARPU_TRACE_MUTEX_UNLOCKED() do {\
1226  const char *file; \
1227  file = strrchr(__FILE__,'/') + 1; \
1228  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK_VERBOSE, _STARPU_FUT_MUTEX_UNLOCKED,__LINE__,_starpu_gettid(),file); \
1229 } while(0)
1230 
1231 #define _STARPU_TRACE_TRYLOCK_MUTEX() do { \
1232  const char *file; \
1233  file = strrchr(__FILE__,'/') + 1; \
1234  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK, _STARPU_FUT_TRYLOCK_MUTEX,__LINE__,_starpu_gettid(),file); \
1235 } while(0)
1236 
1237 #define _STARPU_TRACE_RDLOCKING_RWLOCK() do { \
1238  const char *file; \
1239  file = strrchr(__FILE__,'/') + 1; \
1240  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK, _STARPU_FUT_RDLOCKING_RWLOCK,__LINE__,_starpu_gettid(),file); \
1241 } while(0)
1242 
1243 #define _STARPU_TRACE_RWLOCK_RDLOCKED() do { \
1244  const char *file; \
1245  file = strrchr(__FILE__,'/') + 1; \
1246  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK_VERBOSE, _STARPU_FUT_RWLOCK_RDLOCKED,__LINE__,_starpu_gettid(),file); \
1247 } while(0)
1248 
1249 #define _STARPU_TRACE_WRLOCKING_RWLOCK() do { \
1250  const char *file; \
1251  file = strrchr(__FILE__,'/') + 1; \
1252  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK, _STARPU_FUT_WRLOCKING_RWLOCK,__LINE__,_starpu_gettid(),file); \
1253 } while(0)
1254 
1255 #define _STARPU_TRACE_RWLOCK_WRLOCKED() do { \
1256  const char *file; \
1257  file = strrchr(__FILE__,'/') + 1; \
1258  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK_VERBOSE, _STARPU_FUT_RWLOCK_WRLOCKED,__LINE__,_starpu_gettid(),file); \
1259 } while(0)
1260 
1261 #define _STARPU_TRACE_UNLOCKING_RWLOCK() do { \
1262  const char *file; \
1263  file = strrchr(__FILE__,'/') + 1; \
1264  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK, _STARPU_FUT_UNLOCKING_RWLOCK,__LINE__,_starpu_gettid(),file); \
1265 } while(0)
1266 
1267 #define _STARPU_TRACE_RWLOCK_UNLOCKED() do { \
1268  const char *file; \
1269  file = strrchr(__FILE__,'/') + 1; \
1270  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK_VERBOSE, _STARPU_FUT_RWLOCK_UNLOCKED,__LINE__,_starpu_gettid(),file); \
1271 } while(0)
1272 
1273 #define STARPU_TRACE_SPINLOCK_CONDITITION (starpu_worker_get_type(starpu_worker_get_id()) == STARPU_CUDA_WORKER)
1274 
1275 #define _STARPU_TRACE_LOCKING_SPINLOCK(file, line) do {\
1276  if (STARPU_TRACE_SPINLOCK_CONDITITION) { \
1277  const char *xfile; \
1278  xfile = strrchr(file,'/') + 1; \
1279  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK_VERBOSE, _STARPU_FUT_LOCKING_SPINLOCK,line,_starpu_gettid(),xfile); \
1280  } \
1281 } while(0)
1282 
1283 #define _STARPU_TRACE_SPINLOCK_LOCKED(file, line) do { \
1284  if (STARPU_TRACE_SPINLOCK_CONDITITION) { \
1285  const char *xfile; \
1286  xfile = strrchr(file,'/') + 1; \
1287  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK_VERBOSE, _STARPU_FUT_SPINLOCK_LOCKED,line,_starpu_gettid(),xfile); \
1288  } \
1289 } while(0)
1290 
1291 #define _STARPU_TRACE_UNLOCKING_SPINLOCK(file, line) do { \
1292  if (STARPU_TRACE_SPINLOCK_CONDITITION) { \
1293  const char *xfile; \
1294  xfile = strrchr(file,'/') + 1; \
1295  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK_VERBOSE, _STARPU_FUT_UNLOCKING_SPINLOCK,line,_starpu_gettid(),xfile); \
1296  } \
1297 } while(0)
1298 
1299 #define _STARPU_TRACE_SPINLOCK_UNLOCKED(file, line) do { \
1300  if (STARPU_TRACE_SPINLOCK_CONDITITION) { \
1301  const char *xfile; \
1302  xfile = strrchr(file,'/') + 1; \
1303  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK_VERBOSE, _STARPU_FUT_SPINLOCK_UNLOCKED,line,_starpu_gettid(),xfile); \
1304  } \
1305 } while(0)
1306 
1307 #define _STARPU_TRACE_TRYLOCK_SPINLOCK(file, line) do { \
1308  if (STARPU_TRACE_SPINLOCK_CONDITITION) { \
1309  const char *xfile; \
1310  xfile = strrchr(file,'/') + 1; \
1311  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK_VERBOSE, _STARPU_FUT_TRYLOCK_SPINLOCK,line,_starpu_gettid(),xfile); \
1312  } \
1313 } while(0)
1314 
1315 #define _STARPU_TRACE_COND_WAIT_BEGIN() do { \
1316  const char *file; \
1317  file = strrchr(__FILE__,'/') + 1; \
1318  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK, _STARPU_FUT_COND_WAIT_BEGIN,__LINE__,_starpu_gettid(),file); \
1319 } while(0)
1320 
1321 #define _STARPU_TRACE_COND_WAIT_END() do { \
1322  const char *file; \
1323  file = strrchr(__FILE__,'/') + 1; \
1324  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK, _STARPU_FUT_COND_WAIT_END,__LINE__,_starpu_gettid(),file); \
1325 } while(0)
1326 
1327 #define _STARPU_TRACE_BARRIER_WAIT_BEGIN() do { \
1328  const char *file; \
1329  file = strrchr(__FILE__,'/') + 1; \
1330  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK, _STARPU_FUT_BARRIER_WAIT_BEGIN,__LINE__,_starpu_gettid(),file); \
1331 } while(0)
1332 
1333 #define _STARPU_TRACE_BARRIER_WAIT_END() do { \
1334  const char *file; \
1335  file = strrchr(__FILE__,'/') + 1; \
1336  _STARPU_FUT_FULL_PROBE2STR(_STARPU_FUT_KEYMASK_LOCK, _STARPU_FUT_BARRIER_WAIT_END,__LINE__,_starpu_gettid(),file); \
1337 } while(0)
1338 
1339 #else // !STARPU_FXT_LOCK_TRACES
1340 
1341 #define _STARPU_TRACE_LOCKING_MUTEX() do {} while(0)
1342 #define _STARPU_TRACE_MUTEX_LOCKED() do {} while(0)
1343 #define _STARPU_TRACE_UNLOCKING_MUTEX() do {} while(0)
1344 #define _STARPU_TRACE_MUTEX_UNLOCKED() do {} while(0)
1345 #define _STARPU_TRACE_TRYLOCK_MUTEX() do {} while(0)
1346 #define _STARPU_TRACE_RDLOCKING_RWLOCK() do {} while(0)
1347 #define _STARPU_TRACE_RWLOCK_RDLOCKED() do {} while(0)
1348 #define _STARPU_TRACE_WRLOCKING_RWLOCK() do {} while(0)
1349 #define _STARPU_TRACE_RWLOCK_WRLOCKED() do {} while(0)
1350 #define _STARPU_TRACE_UNLOCKING_RWLOCK() do {} while(0)
1351 #define _STARPU_TRACE_RWLOCK_UNLOCKED() do {} while(0)
1352 #define _STARPU_TRACE_LOCKING_SPINLOCK(file, line) do {(void) file; (void)line;} while(0)
1353 #define _STARPU_TRACE_SPINLOCK_LOCKED(file, line) do {(void) file; (void)line;} while(0)
1354 #define _STARPU_TRACE_UNLOCKING_SPINLOCK(file, line) do {(void) file; (void)line;} while(0)
1355 #define _STARPU_TRACE_SPINLOCK_UNLOCKED(file, line) do {(void) file; (void)line;} while(0)
1356 #define _STARPU_TRACE_TRYLOCK_SPINLOCK(file, line) do {(void) file; (void)line;} while(0)
1357 #define _STARPU_TRACE_COND_WAIT_BEGIN() do {} while(0)
1358 #define _STARPU_TRACE_COND_WAIT_END() do {} while(0)
1359 #define _STARPU_TRACE_BARRIER_WAIT_BEGIN() do {} while(0)
1360 #define _STARPU_TRACE_BARRIER_WAIT_END() do {} while(0)
1361 
1362 #endif // STARPU_FXT_LOCK_TRACES
1363 
1364 #define _STARPU_TRACE_MEMORY_FULL(size) \
1365  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_DSM, _STARPU_FUT_MEMORY_FULL,size,_starpu_gettid());
1366 
1367 #define _STARPU_TRACE_DATA_LOAD(workerid,size) \
1368  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_DSM, _STARPU_FUT_DATA_LOAD, workerid, size);
1369 
1370 #define _STARPU_TRACE_START_UNPARTITION(handle, memnode) \
1371  FUT_FULL_PROBE3(_STARPU_FUT_KEYMASK_DSM, _STARPU_FUT_START_UNPARTITION_ON_TID, memnode, _starpu_gettid(), handle);
1372 
1373 #define _STARPU_TRACE_END_UNPARTITION(handle, memnode) \
1374  FUT_FULL_PROBE3(_STARPU_FUT_KEYMASK_DSM, _STARPU_FUT_END_UNPARTITION_ON_TID, memnode, _starpu_gettid(), handle);
1375 
1376 #define _STARPU_TRACE_SCHED_COMPONENT_PUSH_PRIO(workerid, ntasks, exp_len) \
1377  FUT_FULL_PROBE4(_STARPU_FUT_KEYMASK_SCHED, _STARPU_FUT_SCHED_COMPONENT_PUSH_PRIO, _starpu_gettid(), workerid, ntasks, exp_len);
1378 
1379 #define _STARPU_TRACE_SCHED_COMPONENT_POP_PRIO(workerid, ntasks, exp_len) \
1380  FUT_FULL_PROBE4(_STARPU_FUT_KEYMASK_SCHED, _STARPU_FUT_SCHED_COMPONENT_POP_PRIO, _starpu_gettid(), workerid, ntasks, exp_len);
1381 
1382 #define _STARPU_TRACE_SCHED_COMPONENT_NEW(component) \
1383  if (STARPU_UNLIKELY(fut_active)) _STARPU_FUT_ALWAYS_PROBE1STR(_STARPU_FUT_SCHED_COMPONENT_NEW, component, (component)->name);
1384 
1385 #define _STARPU_TRACE_SCHED_COMPONENT_CONNECT(parent, child) \
1386  if (STARPU_UNLIKELY(fut_active)) FUT_RAW_ALWAYS_PROBE2(FUT_CODE(_STARPU_FUT_SCHED_COMPONENT_CONNECT,2), parent, child);
1387 
1388 #define _STARPU_TRACE_SCHED_COMPONENT_PUSH(from, to, task, prio) \
1389  FUT_FULL_PROBE5(_STARPU_FUT_KEYMASK_SCHED, _STARPU_FUT_SCHED_COMPONENT_PUSH, _starpu_gettid(), from, to, task, prio);
1390 
1391 #define _STARPU_TRACE_SCHED_COMPONENT_PULL(from, to, task) \
1392  FUT_FULL_PROBE5(_STARPU_FUT_KEYMASK_SCHED, _STARPU_FUT_SCHED_COMPONENT_PULL, _starpu_gettid(), from, to, task, (task)->priority);
1393 
1394 #define _STARPU_TRACE_HANDLE_DATA_REGISTER(handle) do { \
1395  if(STARPU_UNLIKELY((_STARPU_FUT_KEYMASK_META) & fut_active)) { \
1396  const size_t __data_size = handle->ops->get_size(handle); \
1397  const starpu_ssize_t __max_data_size = _starpu_data_get_max_size(handle); \
1398  char __buf[(FXT_MAX_PARAMS-4)*sizeof(long)]; \
1399  void *__interface = handle->per_node[0].data_interface; \
1400  if (handle->ops->describe) \
1401  handle->ops->describe(__interface, __buf, sizeof(__buf)); \
1402  else \
1403  __buf[0] = 0; \
1404  _STARPU_FUT_FULL_PROBE4STR(_STARPU_FUT_KEYMASK_META, _STARPU_FUT_HANDLE_DATA_REGISTER, handle, __data_size, __max_data_size, handle->home_node, __buf); \
1405  } \
1406 } while (0)
1407 
1408 #define _STARPU_TRACE_HANDLE_DATA_UNREGISTER(handle) \
1409  FUT_FULL_PROBE1(_STARPU_FUT_KEYMASK_DATA, _STARPU_FUT_HANDLE_DATA_UNREGISTER, handle)
1410 
1411 //Coherency Data Traces
1412 #define _STARPU_TRACE_DATA_STATE_INVALID(handle, node) \
1413  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_DSM_VERBOSE, _STARPU_FUT_DATA_STATE_INVALID, handle, node)
1414 
1415 #define _STARPU_TRACE_DATA_STATE_OWNER(handle, node) \
1416  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_DSM_VERBOSE, _STARPU_FUT_DATA_STATE_OWNER, handle, node)
1417 
1418 #define _STARPU_TRACE_DATA_STATE_SHARED(handle, node) \
1419  FUT_FULL_PROBE2(_STARPU_FUT_KEYMASK_DSM_VERBOSE, _STARPU_FUT_DATA_STATE_SHARED, handle, node)
1420 
1421 #define _STARPU_TRACE_DATA_REQUEST_CREATED(handle, orig, dest, prio, is_pre, req) \
1422  FUT_FULL_PROBE6(_STARPU_FUT_KEYMASK_DSM_VERBOSE, _STARPU_FUT_DATA_REQUEST_CREATED, orig, dest, prio, handle, is_pre, req)
1423 
1424 
1425 #else // !STARPU_USE_FXT
1426 
1427 /* Dummy macros in case FxT is disabled */
1428 #define _STARPU_TRACE_NEW_MEM_NODE(nodeid) do {(void)(nodeid);} while(0)
1429 #define _STARPU_TRACE_REGISTER_THREAD(cpuid) do {(void)(cpuid);} while(0)
1430 #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)
1431 #define _STARPU_TRACE_WORKER_INIT_END(workerid) do {(void)(workerid);} while(0)
1432 #define _STARPU_TRACE_START_CODELET_BODY(job, nimpl, perf_arch, workerid) do {(void)(job); (void)(nimpl); (void)(perf_arch); (void)(workerid);} while(0)
1433 #define _STARPU_TRACE_END_CODELET_BODY(job, nimpl, perf_arch, workerid) do {(void)(job); (void)(nimpl); (void)(perf_arch); (void)(workerid);} while(0)
1434 #define _STARPU_TRACE_START_EXECUTING() do {} while(0)
1435 #define _STARPU_TRACE_END_EXECUTING() do {} while(0)
1436 #define _STARPU_TRACE_START_CALLBACK(job) do {(void)(job);} while(0)
1437 #define _STARPU_TRACE_END_CALLBACK(job) do {(void)(job);} while(0)
1438 #define _STARPU_TRACE_JOB_PUSH(task, prio) do {(void)(task); (void)(prio);} while(0)
1439 #define _STARPU_TRACE_JOB_POP(task, prio) do {(void)(task); (void)(prio);} while(0)
1440 #define _STARPU_TRACE_UPDATE_TASK_CNT(counter) do {(void)(counter);} while(0)
1441 #define _STARPU_TRACE_START_FETCH_INPUT(job) do {(void)(job);} while(0)
1442 #define _STARPU_TRACE_END_FETCH_INPUT(job) do {(void)(job);} while(0)
1443 #define _STARPU_TRACE_START_PUSH_OUTPUT(job) do {(void)(job);} while(0)
1444 #define _STARPU_TRACE_END_PUSH_OUTPUT(job) do {(void)(job);} while(0)
1445 #define _STARPU_TRACE_TAG(tag, job) do {(void)(tag); (void)(job);} while(0)
1446 #define _STARPU_TRACE_TAG_DEPS(a, b) do {(void)(a); (void)(b);} while(0)
1447 #define _STARPU_TRACE_TASK_DEPS(a, b) do {(void)(a); (void)(b);} while(0)
1448 #define _STARPU_TRACE_TASK_END_DEP(a, b) do {(void)(a); (void)(b);} while(0)
1449 #define _STARPU_TRACE_GHOST_TASK_DEPS(a, b) do {(void)(a); (void)(b);} while(0)
1450 #define _STARPU_TRACE_TASK_EXCLUDE_FROM_DAG(a) do {(void)(a);} while(0)
1451 #define _STARPU_TRACE_TASK_NAME_LINE_COLOR(a) do {(void)(a);} while(0)
1452 #define _STARPU_TRACE_TASK_NAME(a) do {(void)(a);} while(0)
1453 #define _STARPU_TRACE_TASK_LINE(a) do {(void)(a);} while(0)
1454 #define _STARPU_TRACE_TASK_COLOR(a) do {(void)(a);} while(0)
1455 #define _STARPU_TRACE_TASK_DONE(a) do {(void)(a);} while(0)
1456 #define _STARPU_TRACE_TAG_DONE(a) do {(void)(a);} while(0)
1457 #define _STARPU_TRACE_DATA_NAME(a, b) do {(void)(a); (void)(b);} while(0)
1458 #define _STARPU_TRACE_DATA_COORDINATES(a, b, c) do {(void)(a); (void)(b); (void)(c);} while(0)
1459 #define _STARPU_TRACE_DATA_COPY(a, b, c) do {(void)(a); (void)(b); (void)(c);} while(0)
1460 #define _STARPU_TRACE_DATA_WONT_USE(a) do {(void)(a);} while(0)
1461 #define _STARPU_TRACE_DATA_DOING_WONT_USE(a) do {(void)(a);} while(0)
1462 #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)
1463 #define _STARPU_TRACE_END_DRIVER_COPY(a,b,c,d,e) do {(void)(a); (void)(b); (void)(c); (void)(d); (void)(e);} while(0)
1464 #define _STARPU_TRACE_START_DRIVER_COPY_ASYNC(a,b) do {(void)(a); (void)(b);} while(0)
1465 #define _STARPU_TRACE_END_DRIVER_COPY_ASYNC(a,b) do {(void)(a); (void)(b);} while(0)
1466 #define _STARPU_TRACE_WORK_STEALING(a, b) do {(void)(a); (void)(b);} while(0)
1467 #define _STARPU_TRACE_WORKER_DEINIT_START do {} while(0)
1468 #define _STARPU_TRACE_WORKER_DEINIT_END(a) do {(void)(a);} while(0)
1469 #define _STARPU_TRACE_WORKER_SCHEDULING_START do {} while(0)
1470 #define _STARPU_TRACE_WORKER_SCHEDULING_END do {} while(0)
1471 #define _STARPU_TRACE_WORKER_SCHEDULING_PUSH do {} while(0)
1472 #define _STARPU_TRACE_WORKER_SCHEDULING_POP do {} while(0)
1473 #define _STARPU_TRACE_WORKER_SLEEP_START do {} while(0)
1474 #define _STARPU_TRACE_WORKER_SLEEP_END do {} while(0)
1475 #define _STARPU_TRACE_TASK_SUBMIT(job, a, b) do {(void)(job); (void)(a);(void)(b);} while(0)
1476 #define _STARPU_TRACE_TASK_SUBMIT_START() do {} while(0)
1477 #define _STARPU_TRACE_TASK_SUBMIT_END() do {} while(0)
1478 #define _STARPU_TRACE_TASK_THROTTLE_START() do {} while(0)
1479 #define _STARPU_TRACE_TASK_THROTTLE_END() do {} while(0)
1480 #define _STARPU_TRACE_TASK_BUILD_START() do {} while(0)
1481 #define _STARPU_TRACE_TASK_BUILD_END() do {} while(0)
1482 #define _STARPU_TRACE_TASK_MPI_DECODE_START() do {} while(0)
1483 #define _STARPU_TRACE_TASK_MPI_DECODE_END() do {} while(0)
1484 #define _STARPU_TRACE_TASK_MPI_PRE_START() do {} while(0)
1485 #define _STARPU_TRACE_TASK_MPI_PRE_END() do {} while(0)
1486 #define _STARPU_TRACE_TASK_MPI_POST_START() do {} while(0)
1487 #define _STARPU_TRACE_TASK_MPI_POST_END() do {} while(0)
1488 #define _STARPU_TRACE_TASK_WAIT_START(job) do {(void)(job);} while(0)
1489 #define _STARPU_TRACE_TASK_WAIT_END() do {} while(0)
1490 #define _STARPU_TRACE_TASK_WAIT_FOR_ALL_START() do {} while(0)
1491 #define _STARPU_TRACE_TASK_WAIT_FOR_ALL_END() do {} while(0)
1492 #define _STARPU_TRACE_START_ALLOC(memnode, size, handle, is_prefetch) do {(void)(memnode); (void)(size); (void)(handle);} while(0)
1493 #define _STARPU_TRACE_END_ALLOC(memnode, handle, r) do {(void)(memnode); (void)(handle); (void)(r);} while(0)
1494 #define _STARPU_TRACE_START_ALLOC_REUSE(a, size, handle, is_prefetch) do {(void)(a); (void)(size); (void)(handle);} while(0)
1495 #define _STARPU_TRACE_END_ALLOC_REUSE(a, handle, r) do {(void)(a); (void)(handle); (void)(r);} while(0)
1496 #define _STARPU_TRACE_START_FREE(memnode, size, handle) do {(void)(memnode); (void)(size); (void)(handle);} while(0)
1497 #define _STARPU_TRACE_END_FREE(memnode, handle) do {(void)(memnode); (void)(handle);} while(0)
1498 #define _STARPU_TRACE_START_WRITEBACK(memnode, handle) do {(void)(memnode); (void)(handle);} while(0)
1499 #define _STARPU_TRACE_END_WRITEBACK(memnode, handle) do {(void)(memnode); (void)(handle);} while(0)
1500 #define _STARPU_TRACE_USED_MEM(memnode,used) do {(void)(memnode); (void)(used);} while (0)
1501 #define _STARPU_TRACE_START_MEMRECLAIM(memnode,is_prefetch) do {(void)(memnode); (void)(is_prefetch);} while(0)
1502 #define _STARPU_TRACE_END_MEMRECLAIM(memnode,is_prefetch) do {(void)(memnode); (void)(is_prefetch);} while(0)
1503 #define _STARPU_TRACE_START_WRITEBACK_ASYNC(memnode) do {(void)(memnode);} while(0)
1504 #define _STARPU_TRACE_END_WRITEBACK_ASYNC(memnode) do {(void)(memnode);} while(0)
1505 #define _STARPU_TRACE_START_PROGRESS(memnode) do {(void)(memnode);} while(0)
1506 #define _STARPU_TRACE_END_PROGRESS(memnode) do {(void)(memnode);} while(0)
1507 #define _STARPU_TRACE_USER_EVENT(code) do {(void)(code);} while(0)
1508 #define _STARPU_TRACE_SET_PROFILING(status) do {(void)(status);} while(0)
1509 #define _STARPU_TRACE_TASK_WAIT_FOR_ALL() do {} while(0)
1510 #define _STARPU_TRACE_EVENT_ALWAYS(S) do {(void)(S);} while(0)
1511 #define _STARPU_TRACE_EVENT(S) do {(void)(S);} while(0)
1512 #define _STARPU_TRACE_EVENT_VERBOSE(S) do {(void)(S);} while(0)
1513 #define _STARPU_TRACE_THREAD_EVENT(S) do {(void)(S);} while(0)
1514 #define _STARPU_TRACE_LOCKING_MUTEX() do {} while(0)
1515 #define _STARPU_TRACE_MUTEX_LOCKED() do {} while(0)
1516 #define _STARPU_TRACE_UNLOCKING_MUTEX() do {} while(0)
1517 #define _STARPU_TRACE_MUTEX_UNLOCKED() do {} while(0)
1518 #define _STARPU_TRACE_TRYLOCK_MUTEX() do {} while(0)
1519 #define _STARPU_TRACE_RDLOCKING_RWLOCK() do {} while(0)
1520 #define _STARPU_TRACE_RWLOCK_RDLOCKED() do {} while(0)
1521 #define _STARPU_TRACE_WRLOCKING_RWLOCK() do {} while(0)
1522 #define _STARPU_TRACE_RWLOCK_WRLOCKED() do {} while(0)
1523 #define _STARPU_TRACE_UNLOCKING_RWLOCK() do {} while(0)
1524 #define _STARPU_TRACE_RWLOCK_UNLOCKED() do {} while(0)
1525 #define _STARPU_TRACE_LOCKING_SPINLOCK(file, line) do {(void)(file); (void)(line);} while(0)
1526 #define _STARPU_TRACE_SPINLOCK_LOCKED(file, line) do {(void)(file); (void)(line);} while(0)
1527 #define _STARPU_TRACE_UNLOCKING_SPINLOCK(file, line) do {(void)(file); (void)(line);} while(0)
1528 #define _STARPU_TRACE_SPINLOCK_UNLOCKED(file, line) do {(void)(file); (void)(line);} while(0)
1529 #define _STARPU_TRACE_TRYLOCK_SPINLOCK(file, line) do {(void)(file); (void)(line);} while(0)
1530 #define _STARPU_TRACE_COND_WAIT_BEGIN() do {} while(0)
1531 #define _STARPU_TRACE_COND_WAIT_END() do {} while(0)
1532 #define _STARPU_TRACE_BARRIER_WAIT_BEGIN() do {} while(0)
1533 #define _STARPU_TRACE_BARRIER_WAIT_END() do {} while(0)
1534 #define _STARPU_TRACE_MEMORY_FULL(size) do {(void)(size);} while(0)
1535 #define _STARPU_TRACE_DATA_LOAD(workerid,size) do {(void)(workerid); (void)(size);} while(0)
1536 #define _STARPU_TRACE_START_UNPARTITION(handle, memnode) do {(void)(handle); (void)(memnode);} while(0)
1537 #define _STARPU_TRACE_END_UNPARTITION(handle, memnode) do {(void)(handle); (void)(memnode);} while(0)
1538 #define _STARPU_TRACE_SCHED_COMPONENT_PUSH_PRIO(workerid, ntasks, exp_len) do {(void)(workerid); (void)(ntasks); (void)(exp_len);} while(0)
1539 #define _STARPU_TRACE_SCHED_COMPONENT_POP_PRIO(workerid, ntasks, exp_len) do {(void)(workerid); (void)(ntasks); (void)(exp_len);} while(0)
1540 #define _STARPU_TRACE_HYPERVISOR_BEGIN() do {} while(0)
1541 #define _STARPU_TRACE_HYPERVISOR_END() do {} while(0)
1542 #define _STARPU_TRACE_SCHED_COMPONENT_NEW(component) do {(void)(component);} while (0)
1543 #define _STARPU_TRACE_SCHED_COMPONENT_CONNECT(parent, child) do {(void)(parent); (void)(child);} while (0)
1544 #define _STARPU_TRACE_SCHED_COMPONENT_PUSH(from, to, task, prio) do {(void)(from); (void)(to); (void)(task); (void)(prio);} while (0)
1545 #define _STARPU_TRACE_SCHED_COMPONENT_PULL(from, to, task) do {(void)(from); (void)(to); (void)(task);} while (0)
1546 #define _STARPU_TRACE_HANDLE_DATA_REGISTER(handle) do {(void)(handle);} while (0)
1547 #define _STARPU_TRACE_HANDLE_DATA_UNREGISTER(handle) do {(void)(handle);} while (0)
1548 #define _STARPU_TRACE_WORKER_START_FETCH_INPUT(job, id) do {(void)(job); (void)(id);} while(0)
1549 #define _STARPU_TRACE_WORKER_END_FETCH_INPUT(job, id) do {(void)(job); (void)(id);} while(0)
1550 #define _STARPU_TRACE_DATA_STATE_INVALID(handle, node) do {(void)(handle); (void)(node);} while(0)
1551 #define _STARPU_TRACE_DATA_STATE_OWNER(handle, node) do {(void)(handle); (void)(node);} while(0)
1552 #define _STARPU_TRACE_DATA_STATE_SHARED(handle, node) do {(void)(handle); (void)(node);} while(0)
1553 #define _STARPU_TRACE_DATA_REQUEST_CREATED(handle, orig, dest, prio, is_pre, req) do {(void)(handle); (void)(orig); (void)(dest); (void)(prio); (void)(is_pre); (void)(req); } while(0)
1554 #define _STARPU_TRACE_PAPI_TASK_EVENT(event_id, task, value) do {(void)(event_id); (void)(task); (void)(value);} while(0)
1555 
1556 #ifdef STARPU_BUBBLE
1557 #define _STARPU_TRACE_BUBBLE_TASK_DEPS(a, b) do {(void)(a); (void)(b);} while(0)
1558 #define _STARPU_TRACE_BUBBLE(a) do {(void)(a);} while(0)
1559 #endif
1560 
1561 #endif // STARPU_USE_FXT
1562 
1563 #pragma GCC visibility pop
1564 
1565 #endif // __FXT_H__