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