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
279extern unsigned long _starpu_job_cnt;
280
281static 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
293void enable_fut_flush();
294#endif
295#endif
296#ifdef HAVE_FUT_SET_FILENAME
297#if !HAVE_DECL_FUT_SET_FILENAME
298void fut_set_filename(char *filename);
299#endif
300#endif
301
302extern int _starpu_fxt_started STARPU_ATTRIBUTE_VISIBILITY_DEFAULT;
303extern int _starpu_fxt_willstart STARPU_ATTRIBUTE_VISIBILITY_DEFAULT;
304extern starpu_pthread_mutex_t _starpu_fxt_started_mutex STARPU_ATTRIBUTE_VISIBILITY_DEFAULT;
305extern starpu_pthread_cond_t _starpu_fxt_started_cond STARPU_ATTRIBUTE_VISIBILITY_DEFAULT;
306
308static 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
318extern unsigned long _starpu_submit_order;
319
320static 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
327long _starpu_gettid(void) STARPU_ATTRIBUTE_VISIBILITY_DEFAULT;
328
329int _starpu_generate_paje_trace_read_option(const char *option, struct starpu_fxt_options *options) STARPU_ATTRIBUTE_VISIBILITY_DEFAULT;
330
332void _starpu_fxt_init_profiling(uint64_t trace_buffer_size);
333
335void _starpu_stop_fxt_profiling(void);
336
338void _starpu_profiling_set_mpi_worldsize(int worldsize) STARPU_ATTRIBUTE_VISIBILITY_DEFAULT;
339
341void _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) \
353do { \
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) \
377do { \
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) \
388do { \
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) \
409do { \
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) \
420do { \
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) \
442do { \
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) \
453do { \
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) \
476do { \
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) \
487do { \
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) \
511do { \
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) \
522do { \
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) \
547do { \
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) \
558do { \
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) \
584do { \
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) \
822do { \
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) \
862do { \
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) \
952do { \
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) \
962do { \
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) \
979do { \
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) \
992do { \
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__