src: rename internal objects following coding conventions

src/common/fxt.c

@@ -144,6 +144,6 @@ void _starpu_fxt_register_thread(unsigned cpuid)
 void starpu_trace_user_event(unsigned long code STARPU_ATTRIBUTE_UNUSED)
 {
 #ifdef STARPU_USE_FXT
-	STARPU_TRACE_USER_EVENT(code);
+	_STARPU_TRACE_USER_EVENT(code);
 #endif
 }

src/common/fxt.h

@@ -32,75 +32,75 @@
 #include <starpu.h>
 
 /* some key to identify the worker kind */
-#define STARPU_FUT_APPS_KEY	0x100
-#define STARPU_FUT_CPU_KEY	0x101
-#define STARPU_FUT_CUDA_KEY	0x102
-#define STARPU_FUT_OPENCL_KEY	0x103
+#define _STARPU_FUT_APPS_KEY	0x100
+#define _STARPU_FUT_CPU_KEY	0x101
+#define _STARPU_FUT_CUDA_KEY	0x102
+#define _STARPU_FUT_OPENCL_KEY	0x103
 
-#define STARPU_FUT_WORKER_INIT_START	0x5100
-#define STARPU_FUT_WORKER_INIT_END	0x5101
+#define _STARPU_FUT_WORKER_INIT_START	0x5100
+#define _STARPU_FUT_WORKER_INIT_END	0x5101
 
-#define	STARPU_FUT_START_CODELET_BODY	0x5102
-#define	STARPU_FUT_END_CODELET_BODY	0x5103
+#define	_STARPU_FUT_START_CODELET_BODY	0x5102
+#define	_STARPU_FUT_END_CODELET_BODY	0x5103
 
-#define STARPU_FUT_JOB_PUSH		0x5104
-#define STARPU_FUT_JOB_POP		0x5105
+#define _STARPU_FUT_JOB_PUSH		0x5104
+#define _STARPU_FUT_JOB_POP		0x5105
 
-#define STARPU_FUT_UPDATE_TASK_CNT	0x5106
+#define _STARPU_FUT_UPDATE_TASK_CNT	0x5106
 
-#define STARPU_FUT_START_FETCH_INPUT	0x5107
-#define STARPU_FUT_END_FETCH_INPUT	0x5108
-#define STARPU_FUT_START_PUSH_OUTPUT	0x5109
-#define STARPU_FUT_END_PUSH_OUTPUT	0x5110
+#define _STARPU_FUT_START_FETCH_INPUT	0x5107
+#define _STARPU_FUT_END_FETCH_INPUT	0x5108
+#define _STARPU_FUT_START_PUSH_OUTPUT	0x5109
+#define _STARPU_FUT_END_PUSH_OUTPUT	0x5110
 
-#define STARPU_FUT_TAG		0x5111
-#define STARPU_FUT_TAG_DEPS	0x5112
+#define _STARPU_FUT_TAG		0x5111
+#define _STARPU_FUT_TAG_DEPS	0x5112
 
-#define STARPU_FUT_TASK_DEPS		0x5113
+#define _STARPU_FUT_TASK_DEPS		0x5113
 
-#define STARPU_FUT_DATA_COPY		0x5114
-#define STARPU_FUT_WORK_STEALING	0x5115
+#define _STARPU_FUT_DATA_COPY		0x5114
+#define _STARPU_FUT_WORK_STEALING	0x5115
 
-#define STARPU_FUT_WORKER_DEINIT_START	0x5116
-#define STARPU_FUT_WORKER_DEINIT_END	0x5117
+#define _STARPU_FUT_WORKER_DEINIT_START	0x5116
+#define _STARPU_FUT_WORKER_DEINIT_END	0x5117
 
-#define STARPU_FUT_WORKER_SLEEP_START	0x5118
-#define STARPU_FUT_WORKER_SLEEP_END	0x5119
+#define _STARPU_FUT_WORKER_SLEEP_START	0x5118
+#define _STARPU_FUT_WORKER_SLEEP_END	0x5119
 
-#define STARPU_FUT_USER_DEFINED_START	0x5120
-#define STARPU_FUT_USER_DEFINED_END	0x5121
+#define _STARPU_FUT_USER_DEFINED_START	0x5120
+#define _STARPU_FUT_USER_DEFINED_END	0x5121
 
-#define	STARPU_FUT_NEW_MEM_NODE		0x5122
+#define	_STARPU_FUT_NEW_MEM_NODE		0x5122
 
-#define	STARPU_FUT_START_CALLBACK	0x5123
-#define	STARPU_FUT_END_CALLBACK		0x5124
+#define	_STARPU_FUT_START_CALLBACK	0x5123
+#define	_STARPU_FUT_END_CALLBACK		0x5124
 
-#define	STARPU_FUT_TASK_DONE		0x5125
-#define	STARPU_FUT_TAG_DONE		0x5126
+#define	_STARPU_FUT_TASK_DONE		0x5125
+#define	_STARPU_FUT_TAG_DONE		0x5126
 
-#define	STARPU_FUT_START_ALLOC		0x5127
-#define	STARPU_FUT_END_ALLOC		0x5128
+#define	_STARPU_FUT_START_ALLOC		0x5127
+#define	_STARPU_FUT_END_ALLOC		0x5128
 
-#define	STARPU_FUT_START_ALLOC_REUSE	0x5129
-#define	STARPU_FUT_END_ALLOC_REUSE	0x5130
+#define	_STARPU_FUT_START_ALLOC_REUSE	0x5129
+#define	_STARPU_FUT_END_ALLOC_REUSE	0x5130
 
-#define	STARPU_FUT_START_MEMRECLAIM	0x5131
-#define	STARPU_FUT_END_MEMRECLAIM	0x5132
+#define	_STARPU_FUT_START_MEMRECLAIM	0x5131
+#define	_STARPU_FUT_END_MEMRECLAIM	0x5132
 
-#define	STARPU_FUT_START_DRIVER_COPY	0x5133
-#define	STARPU_FUT_END_DRIVER_COPY	0x5134
+#define	_STARPU_FUT_START_DRIVER_COPY	0x5133
+#define	_STARPU_FUT_END_DRIVER_COPY	0x5134
 
-#define	STARPU_FUT_START_DRIVER_COPY_ASYNC	0x5135
-#define	STARPU_FUT_END_DRIVER_COPY_ASYNC	0x5136
+#define	_STARPU_FUT_START_DRIVER_COPY_ASYNC	0x5135
+#define	_STARPU_FUT_END_DRIVER_COPY_ASYNC	0x5136
 
-#define	STARPU_FUT_START_PROGRESS	0x5137
-#define	STARPU_FUT_END_PROGRESS		0x5138
+#define	_STARPU_FUT_START_PROGRESS	0x5137
+#define	_STARPU_FUT_END_PROGRESS		0x5138
 
-#define STARPU_FUT_USER_EVENT		0x5139
+#define _STARPU_FUT_USER_EVENT		0x5139
 
-#define STARPU_FUT_SET_PROFILING	0x513a
+#define _STARPU_FUT_SET_PROFILING	0x513a
 
-#define STARPU_FUT_TASK_WAIT_FOR_ALL	0x513b
+#define _STARPU_FUT_TASK_WAIT_FOR_ALL	0x513b
 
 #ifdef STARPU_USE_FXT
 #include <sys/syscall.h> /* pour les définitions de SYS_xxx */
@@ -120,7 +120,7 @@ void _starpu_fxt_register_thread(unsigned);
 /* Sometimes we need something a little more specific than the wrappers from
  * FxT: these macro permit to put add an event with 3 (or 4) numbers followed
  * by a string. */
-#define STARPU_FUT_DO_PROBE3STR(CODE, P1, P2, P3, str)			\
+#define _STARPU_FUT_DO_PROBE3STR(CODE, P1, P2, P3, str)			\
 do {									\
 	/* No more than FXT_MAX_PARAMS args are allowed */		\
 	/* we add a \0 just in case ... */				\
@@ -137,7 +137,7 @@ do {									\
 	((char *)futargs)[len - 1] = '\0';				\
 } while (0);
 
-#define STARPU_FUT_DO_PROBE4STR(CODE, P1, P2, P3, P4, str)		\
+#define _STARPU_FUT_DO_PROBE4STR(CODE, P1, P2, P3, P4, str)		\
 do {									\
 	/* No more than FXT_MAX_PARAMS args are allowed */		\
 	/* we add a \0 just in case ... */				\
@@ -155,7 +155,7 @@ do {									\
 	((char *)futargs)[len - 1] = '\0';				\
 } while (0);
 
-#define STARPU_FUT_DO_PROBE5STR(CODE, P1, P2, P3, P4, P5, str)		\
+#define _STARPU_FUT_DO_PROBE5STR(CODE, P1, P2, P3, P4, P5, str)		\
 do {									\
 	/* No more than FXT_MAX_PARAMS args are allowed */		\
 	/* we add a \0 just in case ... */				\
@@ -176,221 +176,220 @@ do {									\
 
 
 
-/* workerkind = STARPU_FUT_CPU_KEY for instance */
-#define STARPU_TRACE_NEW_MEM_NODE(nodeid)			\
-	FUT_DO_PROBE2(STARPU_FUT_NEW_MEM_NODE, nodeid, syscall(SYS_gettid));
+/* workerkind = _STARPU_FUT_CPU_KEY for instance */
+#define _STARPU_TRACE_NEW_MEM_NODE(nodeid)			\
+	FUT_DO_PROBE2(_STARPU_FUT_NEW_MEM_NODE, nodeid, syscall(SYS_gettid));
 
-#define STARPU_TRACE_WORKER_INIT_START(workerkind, devid, memnode)	\
-	FUT_DO_PROBE4(STARPU_FUT_WORKER_INIT_START, workerkind, devid, memnode, syscall(SYS_gettid));
+#define _STARPU_TRACE_WORKER_INIT_START(workerkind, devid, memnode)	\
+	FUT_DO_PROBE4(_STARPU_FUT_WORKER_INIT_START, workerkind, devid, memnode, syscall(SYS_gettid));
 
-#define STARPU_TRACE_WORKER_INIT_END				\
-	FUT_DO_PROBE1(STARPU_FUT_WORKER_INIT_END, syscall(SYS_gettid));
+#define _STARPU_TRACE_WORKER_INIT_END				\
+	FUT_DO_PROBE1(_STARPU_FUT_WORKER_INIT_END, syscall(SYS_gettid));
 
-#define STARPU_TRACE_START_CODELET_BODY(job)				\
+#define _STARPU_TRACE_START_CODELET_BODY(job)				\
 do {									\
         const char *model_name = _starpu_get_model_name((job));         \
 	if (model_name)                                                 \
 	{								\
 		/* we include the symbol name */			\
-		STARPU_FUT_DO_PROBE3STR(STARPU_FUT_START_CODELET_BODY, (job), syscall(SYS_gettid), 1, model_name); \
+		_STARPU_FUT_DO_PROBE3STR(_STARPU_FUT_START_CODELET_BODY, (job), syscall(SYS_gettid), 1, model_name); \
 	}								\
 	else {                                                          \
-		FUT_DO_PROBE3(STARPU_FUT_START_CODELET_BODY, (job), syscall(SYS_gettid), 0); \
+		FUT_DO_PROBE3(_STARPU_FUT_START_CODELET_BODY, (job), syscall(SYS_gettid), 0); \
 	}								\
 } while(0);
 
-#define STARPU_TRACE_END_CODELET_BODY(job, archtype)			\
+#define _STARPU_TRACE_END_CODELET_BODY(job, archtype)			\
 do {									\
 	const size_t job_size = _starpu_job_get_data_size((job));	\
 	const uint32_t job_hash = _starpu_compute_buffers_footprint(job);\
-	FUT_DO_PROBE5(STARPU_FUT_END_CODELET_BODY, job, (job_size), (job_hash), (archtype), syscall(SYS_gettid));	\
+	FUT_DO_PROBE5(_STARPU_FUT_END_CODELET_BODY, job, (job_size), (job_hash), (archtype), syscall(SYS_gettid));	\
 } while(0);
 
-#define STARPU_TRACE_START_CALLBACK(job)	\
-	FUT_DO_PROBE2(STARPU_FUT_START_CALLBACK, job, syscall(SYS_gettid));
+#define _STARPU_TRACE_START_CALLBACK(job)	\
+	FUT_DO_PROBE2(_STARPU_FUT_START_CALLBACK, job, syscall(SYS_gettid));
 
-#define STARPU_TRACE_END_CALLBACK(job)	\
-	FUT_DO_PROBE2(STARPU_FUT_END_CALLBACK, job, syscall(SYS_gettid));
+#define _STARPU_TRACE_END_CALLBACK(job)	\
+	FUT_DO_PROBE2(_STARPU_FUT_END_CALLBACK, job, syscall(SYS_gettid));
 
-#define STARPU_TRACE_JOB_PUSH(task, prio)	\
-	FUT_DO_PROBE3(STARPU_FUT_JOB_PUSH, task, prio, syscall(SYS_gettid));
+#define _STARPU_TRACE_JOB_PUSH(task, prio)	\
+	FUT_DO_PROBE3(_STARPU_FUT_JOB_PUSH, task, prio, syscall(SYS_gettid));
 
-#define STARPU_TRACE_JOB_POP(task, prio)	\
-	FUT_DO_PROBE3(STARPU_FUT_JOB_POP, task, prio, syscall(SYS_gettid));
+#define _STARPU_TRACE_JOB_POP(task, prio)	\
+	FUT_DO_PROBE3(_STARPU_FUT_JOB_POP, task, prio, syscall(SYS_gettid));
 
-#define STARPU_TRACE_UPDATE_TASK_CNT(counter)	\
-	FUT_DO_PROBE2(STARPU_FUT_UPDATE_TASK_CNT, counter, syscall(SYS_gettid))
+#define _STARPU_TRACE_UPDATE_TASK_CNT(counter)	\
+	FUT_DO_PROBE2(_STARPU_FUT_UPDATE_TASK_CNT, counter, syscall(SYS_gettid))
 
-#define STARPU_TRACE_START_FETCH_INPUT(job)	\
-	FUT_DO_PROBE2(STARPU_FUT_START_FETCH_INPUT, job, syscall(SYS_gettid));
+#define _STARPU_TRACE_START_FETCH_INPUT(job)	\
+	FUT_DO_PROBE2(_STARPU_FUT_START_FETCH_INPUT, job, syscall(SYS_gettid));
 
-#define STARPU_TRACE_END_FETCH_INPUT(job)	\
-	FUT_DO_PROBE2(STARPU_FUT_END_FETCH_INPUT, job, syscall(SYS_gettid));
+#define _STARPU_TRACE_END_FETCH_INPUT(job)	\
+	FUT_DO_PROBE2(_STARPU_FUT_END_FETCH_INPUT, job, syscall(SYS_gettid));
 
-#define STARPU_TRACE_START_PUSH_OUTPUT(job)	\
-	FUT_DO_PROBE2(STARPU_FUT_START_PUSH_OUTPUT, job, syscall(SYS_gettid));
+#define _STARPU_TRACE_START_PUSH_OUTPUT(job)	\
+	FUT_DO_PROBE2(_STARPU_FUT_START_PUSH_OUTPUT, job, syscall(SYS_gettid));
 
-#define STARPU_TRACE_END_PUSH_OUTPUT(job)	\
-	FUT_DO_PROBE2(STARPU_FUT_END_PUSH_OUTPUT, job, syscall(SYS_gettid));
+#define _STARPU_TRACE_END_PUSH_OUTPUT(job)	\
+	FUT_DO_PROBE2(_STARPU_FUT_END_PUSH_OUTPUT, job, syscall(SYS_gettid));
 
-#define STARPU_TRACE_TAG(tag, job)	\
-	FUT_DO_PROBE2(STARPU_FUT_TAG, tag, (job)->job_id)
+#define _STARPU_TRACE_TAG(tag, job)	\
+	FUT_DO_PROBE2(_STARPU_FUT_TAG, tag, (job)->job_id)
 
-#define STARPU_TRACE_TAG_DEPS(tag_child, tag_father)	\
-	FUT_DO_PROBE2(STARPU_FUT_TAG_DEPS, tag_child, tag_father)
+#define _STARPU_TRACE_TAG_DEPS(tag_child, tag_father)	\
+	FUT_DO_PROBE2(_STARPU_FUT_TAG_DEPS, tag_child, tag_father)
 
-#define STARPU_TRACE_TASK_DEPS(job_prev, job_succ)	\
-	FUT_DO_PROBE2(STARPU_FUT_TASK_DEPS, (job_prev)->job_id, (job_succ)->job_id)
+#define _STARPU_TRACE_TASK_DEPS(job_prev, job_succ)	\
+	FUT_DO_PROBE2(_STARPU_FUT_TASK_DEPS, (job_prev)->job_id, (job_succ)->job_id)
 
-#define STARPU_TRACE_GHOST_TASK_DEPS(ghost_prev_id, job_succ_id)		\
-	FUT_DO_PROBE2(STARPU_FUT_TASK_DEPS, (ghost_prev_id), (job_succ_id))
+#define _STARPU_TRACE_GHOST_TASK_DEPS(ghost_prev_id, job_succ_id)		\
+	FUT_DO_PROBE2(_STARPU_FUT_TASK_DEPS, (ghost_prev_id), (job_succ_id))
 
-#define STARPU_TRACE_TASK_DONE(job)						\
+#define _STARPU_TRACE_TASK_DONE(job)						\
 do {										\
 	unsigned exclude_from_dag = (job)->exclude_from_dag;			\
         const char *model_name = _starpu_get_model_name((job));                       \
 	if (model_name)					                        \
 	{									\
-		STARPU_FUT_DO_PROBE4STR(STARPU_FUT_TASK_DONE, (job)->job_id, syscall(SYS_gettid), (long unsigned)exclude_from_dag, 1, model_name);\
+		_STARPU_FUT_DO_PROBE4STR(_STARPU_FUT_TASK_DONE, (job)->job_id, syscall(SYS_gettid), (long unsigned)exclude_from_dag, 1, model_name);\
 	}									\
 	else {									\
-		FUT_DO_PROBE4(STARPU_FUT_TASK_DONE, (job)->job_id, syscall(SYS_gettid), (long unsigned)exclude_from_dag, 0);\
+		FUT_DO_PROBE4(_STARPU_FUT_TASK_DONE, (job)->job_id, syscall(SYS_gettid), (long unsigned)exclude_from_dag, 0);\
 	}									\
 } while(0);
 
-#define STARPU_TRACE_TAG_DONE(tag)						\
+#define _STARPU_TRACE_TAG_DONE(tag)						\
 do {										\
         struct starpu_job_s *job = (tag)->job;                                  \
         const char *model_name = _starpu_get_model_name((job));                       \
 	if (model_name)                                                         \
 	{									\
-          STARPU_FUT_DO_PROBE3STR(STARPU_FUT_TAG_DONE, (tag)->id, syscall(SYS_gettid), 1, model_name); \
+          _STARPU_FUT_DO_PROBE3STR(_STARPU_FUT_TAG_DONE, (tag)->id, syscall(SYS_gettid), 1, model_name); \
 	}									\
 	else {									\
-		FUT_DO_PROBE3(STARPU_FUT_TAG_DONE, (tag)->id, syscall(SYS_gettid), 0);\
+		FUT_DO_PROBE3(_STARPU_FUT_TAG_DONE, (tag)->id, syscall(SYS_gettid), 0);\
 	}									\
 } while(0);
 
-#define STARPU_TRACE_DATA_COPY(src_node, dst_node, size)	\
-	FUT_DO_PROBE3(STARPU_FUT_DATA_COPY, src_node, dst_node, size)
+#define _STARPU_TRACE_DATA_COPY(src_node, dst_node, size)	\
+	FUT_DO_PROBE3(_STARPU_FUT_DATA_COPY, src_node, dst_node, size)
 
-#define STARPU_TRACE_START_DRIVER_COPY(src_node, dst_node, size, com_id)	\
-	FUT_DO_PROBE4(STARPU_FUT_START_DRIVER_COPY, src_node, dst_node, size, com_id)
+#define _STARPU_TRACE_START_DRIVER_COPY(src_node, dst_node, size, com_id)	\
+	FUT_DO_PROBE4(_STARPU_FUT_START_DRIVER_COPY, src_node, dst_node, size, com_id)
 
-#define STARPU_TRACE_END_DRIVER_COPY(src_node, dst_node, size, com_id)	\
-	FUT_DO_PROBE4(STARPU_FUT_END_DRIVER_COPY, src_node, dst_node, size, com_id)
+#define _STARPU_TRACE_END_DRIVER_COPY(src_node, dst_node, size, com_id)	\
+	FUT_DO_PROBE4(_STARPU_FUT_END_DRIVER_COPY, src_node, dst_node, size, com_id)
 
-#define STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node)	\
-	FUT_DO_PROBE2(STARPU_FUT_START_DRIVER_COPY_ASYNC, src_node, dst_node)
+#define _STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node)	\
+	FUT_DO_PROBE2(_STARPU_FUT_START_DRIVER_COPY_ASYNC, src_node, dst_node)
 
-#define STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node)	\
-	FUT_DO_PROBE2(STARPU_FUT_END_DRIVER_COPY, src_node, dst_node)
+#define _STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node)	\
+	FUT_DO_PROBE2(_STARPU_FUT_END_DRIVER_COPY, src_node, dst_node)
 
-#define STARPU_TRACE_WORK_STEALING(empty_q, victim_q)		\
-	FUT_DO_PROBE2(STARPU_FUT_WORK_STEALING, empty_q, victim_q)
+#define _STARPU_TRACE_WORK_STEALING(empty_q, victim_q)		\
+	FUT_DO_PROBE2(_STARPU_FUT_WORK_STEALING, empty_q, victim_q)
 
-#define STARPU_TRACE_WORKER_DEINIT_START			\
-	FUT_DO_PROBE1(STARPU_FUT_WORKER_DEINIT_START, syscall(SYS_gettid));
+#define _STARPU_TRACE_WORKER_DEINIT_START			\
+	FUT_DO_PROBE1(_STARPU_FUT_WORKER_DEINIT_START, syscall(SYS_gettid));
 
-#define STARPU_TRACE_WORKER_DEINIT_END(workerkind)		\
-	FUT_DO_PROBE2(STARPU_FUT_WORKER_DEINIT_END, workerkind, syscall(SYS_gettid));
+#define _STARPU_TRACE_WORKER_DEINIT_END(workerkind)		\
+	FUT_DO_PROBE2(_STARPU_FUT_WORKER_DEINIT_END, workerkind, syscall(SYS_gettid));
 
-#define STARPU_TRACE_WORKER_SLEEP_START	\
-	FUT_DO_PROBE1(STARPU_FUT_WORKER_SLEEP_START, syscall(SYS_gettid));
+#define _STARPU_TRACE_WORKER_SLEEP_START	\
+	FUT_DO_PROBE1(_STARPU_FUT_WORKER_SLEEP_START, syscall(SYS_gettid));
 
-#define STARPU_TRACE_WORKER_SLEEP_END	\
-	FUT_DO_PROBE1(STARPU_FUT_WORKER_SLEEP_END, syscall(SYS_gettid));
+#define _STARPU_TRACE_WORKER_SLEEP_END	\
+	FUT_DO_PROBE1(_STARPU_FUT_WORKER_SLEEP_END, syscall(SYS_gettid));
 
-#define STARPU_TRACE_USER_DEFINED_START	\
-	FUT_DO_PROBE1(STARPU_FUT_USER_DEFINED_START, syscall(SYS_gettid));
+#define _STARPU_TRACE_USER_DEFINED_START	\
+	FUT_DO_PROBE1(_STARPU_FUT_USER_DEFINED_START, syscall(SYS_gettid));
 
-#define STARPU_TRACE_USER_DEFINED_END		\
-	FUT_DO_PROBE1(STARPU_FUT_USER_DEFINED_END, syscall(SYS_gettid));
+#define _STARPU_TRACE_USER_DEFINED_END		\
+	FUT_DO_PROBE1(_STARPU_FUT_USER_DEFINED_END, syscall(SYS_gettid));
 
-#define STARPU_TRACE_START_ALLOC(memnode)		\
-	FUT_DO_PROBE2(STARPU_FUT_START_ALLOC, memnode, syscall(SYS_gettid));
+#define _STARPU_TRACE_START_ALLOC(memnode)		\
+	FUT_DO_PROBE2(_STARPU_FUT_START_ALLOC, memnode, syscall(SYS_gettid));
 	
-#define STARPU_TRACE_END_ALLOC(memnode)		\
-	FUT_DO_PROBE2(STARPU_FUT_END_ALLOC, memnode, syscall(SYS_gettid));
+#define _STARPU_TRACE_END_ALLOC(memnode)		\
+	FUT_DO_PROBE2(_STARPU_FUT_END_ALLOC, memnode, syscall(SYS_gettid));
 
-#define STARPU_TRACE_START_ALLOC_REUSE(memnode)		\
-	FUT_DO_PROBE2(STARPU_FUT_START_ALLOC_REUSE, memnode, syscall(SYS_gettid));
+#define _STARPU_TRACE_START_ALLOC_REUSE(memnode)		\
+	FUT_DO_PROBE2(_STARPU_FUT_START_ALLOC_REUSE, memnode, syscall(SYS_gettid));
 	
-#define STARPU_TRACE_END_ALLOC_REUSE(memnode)		\
-	FUT_DO_PROBE2(STARPU_FUT_END_ALLOC_REUSE, memnode, syscall(SYS_gettid));
+#define _STARPU_TRACE_END_ALLOC_REUSE(memnode)		\
+	FUT_DO_PROBE2(_STARPU_FUT_END_ALLOC_REUSE, memnode, syscall(SYS_gettid));
 	
-#define STARPU_TRACE_START_MEMRECLAIM(memnode)		\
-	FUT_DO_PROBE2(STARPU_FUT_START_MEMRECLAIM, memnode, syscall(SYS_gettid));
+#define _STARPU_TRACE_START_MEMRECLAIM(memnode)		\
+	FUT_DO_PROBE2(_STARPU_FUT_START_MEMRECLAIM, memnode, syscall(SYS_gettid));
 	
-#define STARPU_TRACE_END_MEMRECLAIM(memnode)		\
-	FUT_DO_PROBE2(STARPU_FUT_END_MEMRECLAIM, memnode, syscall(SYS_gettid));
+#define _STARPU_TRACE_END_MEMRECLAIM(memnode)		\
+	FUT_DO_PROBE2(_STARPU_FUT_END_MEMRECLAIM, memnode, syscall(SYS_gettid));
 	
 /* We skip these events becasue they are called so often that they cause FxT to
  * fail and make the overall trace unreadable anyway. */
-#define STARPU_TRACE_START_PROGRESS(memnode)		\
+#define _STARPU_TRACE_START_PROGRESS(memnode)		\
 	do {} while (0);
-//	FUT_DO_PROBE2(STARPU_FUT_START_PROGRESS, memnode, syscall(SYS_gettid));
+//	FUT_DO_PROBE2(_STARPU_FUT_START_PROGRESS, memnode, syscall(SYS_gettid));
 
-#define STARPU_TRACE_END_PROGRESS(memnode)		\
+#define _STARPU_TRACE_END_PROGRESS(memnode)		\
 	do {} while (0);
-	//FUT_DO_PROBE2(STARPU_FUT_END_PROGRESS, memnode, syscall(SYS_gettid));
+	//FUT_DO_PROBE2(_STARPU_FUT_END_PROGRESS, memnode, syscall(SYS_gettid));
 	
-#define STARPU_TRACE_USER_EVENT(code)			\
-	FUT_DO_PROBE2(STARPU_FUT_USER_EVENT, code, syscall(SYS_gettid));
+#define _STARPU_TRACE_USER_EVENT(code)			\
+	FUT_DO_PROBE2(_STARPU_FUT_USER_EVENT, code, syscall(SYS_gettid));
 
-#define STARPU_TRACE_SET_PROFILING(status)		\
-	FUT_DO_PROBE2(STARPU_FUT_SET_PROFILING, status, syscall(SYS_gettid));
+#define _STARPU_TRACE_SET_PROFILING(status)		\
+	FUT_DO_PROBE2(_STARPU_FUT_SET_PROFILING, status, syscall(SYS_gettid));
 
-#define STARPU_TRACE_TASK_WAIT_FOR_ALL			\
-	FUT_DO_PROBE0(STARPU_FUT_TASK_WAIT_FOR_ALL)
+#define _STARPU_TRACE_TASK_WAIT_FOR_ALL			\
+	FUT_DO_PROBE0(_STARPU_FUT_TASK_WAIT_FOR_ALL)
 
 #else // !STARPU_USE_FXT
 
 /* Dummy macros in case FxT is disabled */
-#define STARPU_TRACE_NEW_MEM_NODE(nodeid)	do {} while(0);
-#define TRACE_NEW_WORKER(a,b)			do {} while(0);
-#define STARPU_TRACE_WORKER_INIT_START(a,b,c)	do {} while(0);
-#define STARPU_TRACE_WORKER_INIT_END		do {} while(0);
-#define STARPU_TRACE_START_CODELET_BODY(job)	do {} while(0);
-#define STARPU_TRACE_END_CODELET_BODY(job, a)	do {} while(0);
-#define STARPU_TRACE_START_CALLBACK(job)	do {} while(0);
-#define STARPU_TRACE_END_CALLBACK(job)		do {} while(0);
-#define STARPU_TRACE_JOB_PUSH(task, prio)	do {} while(0);
-#define STARPU_TRACE_JOB_POP(task, prio)	do {} while(0);
-#define STARPU_TRACE_UPDATE_TASK_CNT(counter)	do {} while(0);
-#define STARPU_TRACE_START_FETCH_INPUT(job)	do {} while(0);
-#define STARPU_TRACE_END_FETCH_INPUT(job)	do {} while(0);
-#define STARPU_TRACE_START_PUSH_OUTPUT(job)	do {} while(0);
-#define STARPU_TRACE_END_PUSH_OUTPUT(job)	do {} while(0);
-#define STARPU_TRACE_TAG(tag, job)	do {} while(0);
-#define STARPU_TRACE_TAG_DEPS(a, b)	do {} while(0);
-#define STARPU_TRACE_TASK_DEPS(a, b)		do {} while(0);
-#define STARPU_TRACE_GHOST_TASK_DEPS(a, b)	do {} while(0);
-#define STARPU_TRACE_TASK_DONE(a)		do {} while(0);
-#define STARPU_TRACE_TAG_DONE(a)		do {} while(0);
-#define STARPU_TRACE_DATA_COPY(a, b, c)		do {} while(0);
-#define STARPU_TRACE_START_DRIVER_COPY(a,b,c,d)	do {} while(0);
-#define STARPU_TRACE_END_DRIVER_COPY(a,b,c,d)	do {} while(0);
-#define STARPU_TRACE_START_DRIVER_COPY_ASYNC(a,b)	do {} while(0);
-#define STARPU_TRACE_END_DRIVER_COPY_ASYNC(a,b)	do {} while(0);
-#define STARPU_TRACE_WORK_STEALING(a, b)	do {} while(0);
-#define STARPU_TRACE_WORKER_DEINIT_START	do {} while(0);
-#define STARPU_TRACE_WORKER_DEINIT_END(a)	do {} while(0);
-#define STARPU_TRACE_WORKER_SLEEP_START		do {} while(0);
-#define STARPU_TRACE_WORKER_SLEEP_END		do {} while(0);
-#define STARPU_TRACE_USER_DEFINED_START		do {} while(0);
-#define STARPU_TRACE_USER_DEFINED_END		do {} while(0);
-#define STARPU_TRACE_START_ALLOC(memnode)	do {} while(0);
-#define STARPU_TRACE_END_ALLOC(memnode)		do {} while(0);
-#define STARPU_TRACE_START_ALLOC_REUSE(a)	do {} while(0);
-#define STARPU_TRACE_END_ALLOC_REUSE(a)		do {} while(0);
-#define STARPU_TRACE_START_MEMRECLAIM(memnode)	do {} while(0);
-#define STARPU_TRACE_END_MEMRECLAIM(memnode)	do {} while(0);
-#define STARPU_TRACE_START_PROGRESS(memnode)	do {} while(0);
-#define STARPU_TRACE_END_PROGRESS(memnode)	do {} while(0);
-#define STARPU_TRACE_USER_EVENT(code)		do {} while(0);
-#define STARPU_TRACE_SET_PROFILING(status)	do {} while(0);
-#define STARPU_TRACE_TASK_WAIT_FOR_ALL		do {} while(0);
+#define _STARPU_TRACE_NEW_MEM_NODE(nodeid)	do {} while(0);
+#define _STARPU_TRACE_WORKER_INIT_START(a,b,c)	do {} while(0);
+#define _STARPU_TRACE_WORKER_INIT_END		do {} while(0);
+#define _STARPU_TRACE_START_CODELET_BODY(job)	do {} while(0);
+#define _STARPU_TRACE_END_CODELET_BODY(job, a)	do {} while(0);
+#define _STARPU_TRACE_START_CALLBACK(job)	do {} while(0);
+#define _STARPU_TRACE_END_CALLBACK(job)		do {} while(0);
+#define _STARPU_TRACE_JOB_PUSH(task, prio)	do {} while(0);
+#define _STARPU_TRACE_JOB_POP(task, prio)	do {} while(0);
+#define _STARPU_TRACE_UPDATE_TASK_CNT(counter)	do {} while(0);
+#define _STARPU_TRACE_START_FETCH_INPUT(job)	do {} while(0);
+#define _STARPU_TRACE_END_FETCH_INPUT(job)	do {} while(0);
+#define _STARPU_TRACE_START_PUSH_OUTPUT(job)	do {} while(0);
+#define _STARPU_TRACE_END_PUSH_OUTPUT(job)	do {} while(0);
+#define _STARPU_TRACE_TAG(tag, job)	do {} while(0);
+#define _STARPU_TRACE_TAG_DEPS(a, b)	do {} while(0);
+#define _STARPU_TRACE_TASK_DEPS(a, b)		do {} while(0);
+#define _STARPU_TRACE_GHOST_TASK_DEPS(a, b)	do {} while(0);
+#define _STARPU_TRACE_TASK_DONE(a)		do {} while(0);
+#define _STARPU_TRACE_TAG_DONE(a)		do {} while(0);
+#define _STARPU_TRACE_DATA_COPY(a, b, c)		do {} while(0);
+#define _STARPU_TRACE_START_DRIVER_COPY(a,b,c,d)	do {} while(0);
+#define _STARPU_TRACE_END_DRIVER_COPY(a,b,c,d)	do {} while(0);
+#define _STARPU_TRACE_START_DRIVER_COPY_ASYNC(a,b)	do {} while(0);
+#define _STARPU_TRACE_END_DRIVER_COPY_ASYNC(a,b)	do {} while(0);
+#define _STARPU_TRACE_WORK_STEALING(a, b)	do {} while(0);
+#define _STARPU_TRACE_WORKER_DEINIT_START	do {} while(0);
+#define _STARPU_TRACE_WORKER_DEINIT_END(a)	do {} while(0);
+#define _STARPU_TRACE_WORKER_SLEEP_START		do {} while(0);
+#define _STARPU_TRACE_WORKER_SLEEP_END		do {} while(0);
+#define _STARPU_TRACE_USER_DEFINED_START		do {} while(0);
+#define _STARPU_TRACE_USER_DEFINED_END		do {} while(0);
+#define _STARPU_TRACE_START_ALLOC(memnode)	do {} while(0);
+#define _STARPU_TRACE_END_ALLOC(memnode)		do {} while(0);
+#define _STARPU_TRACE_START_ALLOC_REUSE(a)	do {} while(0);
+#define _STARPU_TRACE_END_ALLOC_REUSE(a)		do {} while(0);
+#define _STARPU_TRACE_START_MEMRECLAIM(memnode)	do {} while(0);
+#define _STARPU_TRACE_END_MEMRECLAIM(memnode)	do {} while(0);
+#define _STARPU_TRACE_START_PROGRESS(memnode)	do {} while(0);
+#define _STARPU_TRACE_END_PROGRESS(memnode)	do {} while(0);
+#define _STARPU_TRACE_USER_EVENT(code)		do {} while(0);
+#define _STARPU_TRACE_SET_PROFILING(status)	do {} while(0);
+#define _STARPU_TRACE_TASK_WAIT_FOR_ALL		do {} while(0);
 
 #endif // STARPU_USE_FXT
 

src/core/dependencies/implicit_data_deps.c

@@ -59,7 +59,7 @@ static void _starpu_add_reader_after_writer(starpu_data_handle_t handle, struct
 		handle->last_submitted_ghost_writer_id_is_valid)
 	{
 		starpu_job_t pre_sync_job = _starpu_get_job_associated_to_task(pre_sync_task);
-		STARPU_TRACE_GHOST_TASK_DEPS(handle->last_submitted_ghost_writer_id, pre_sync_job->job_id);
+		_STARPU_TRACE_GHOST_TASK_DEPS(handle->last_submitted_ghost_writer_id, pre_sync_job->job_id);
 		_starpu_bound_job_id_dep(pre_sync_job, handle->last_submitted_ghost_writer_id);
 		_STARPU_DEP_DEBUG("dep ID%lu -> %p\n", handle->last_submitted_ghost_writer_id, pre_sync_task);
 	}
@@ -104,7 +104,7 @@ static void _starpu_add_writer_after_readers(starpu_data_handle_t handle, struct
 		while (ghost_readers_id)
 		{
 			unsigned long id = ghost_readers_id->id;
-			STARPU_TRACE_GHOST_TASK_DEPS(id, pre_sync_job->job_id);
+			_STARPU_TRACE_GHOST_TASK_DEPS(id, pre_sync_job->job_id);
 			_starpu_bound_job_id_dep(pre_sync_job, id);
 			_STARPU_DEP_DEBUG("dep ID%lu -> %p\n", id, pre_sync_task);
 
@@ -146,7 +146,7 @@ static void _starpu_add_writer_after_writer(starpu_data_handle_t handle, struct
 		if (handle->last_submitted_ghost_writer_id_is_valid)
 		{
 			starpu_job_t pre_sync_job = _starpu_get_job_associated_to_task(pre_sync_task);
-			STARPU_TRACE_GHOST_TASK_DEPS(handle->last_submitted_ghost_writer_id, pre_sync_job->job_id);
+			_STARPU_TRACE_GHOST_TASK_DEPS(handle->last_submitted_ghost_writer_id, pre_sync_job->job_id);
 			_starpu_bound_job_id_dep(pre_sync_job, handle->last_submitted_ghost_writer_id);
 			_STARPU_DEP_DEBUG("dep ID%lu -> %p\n", handle->last_submitted_ghost_writer_id, pre_sync_task);
 			handle->last_submitted_ghost_writer_id_is_valid = 0;
@@ -208,7 +208,7 @@ void _starpu_detect_implicit_data_deps_with_handle(struct starpu_task *pre_sync_
 #endif
 		)
 		{
-			STARPU_TRACE_GHOST_TASK_DEPS(pre_sync_job->job_id, post_sync_job->job_id);
+			_STARPU_TRACE_GHOST_TASK_DEPS(pre_sync_job->job_id, post_sync_job->job_id);
 			_starpu_bound_task_dep(post_sync_job, pre_sync_job);
 		}
 

src/core/dependencies/tags.c

@@ -183,7 +183,7 @@ void _starpu_notify_tag_dependencies(struct _starpu_tag *tag)
 	_starpu_spin_lock(&tag->lock);
 
 	tag->state = STARPU_DONE;
-	STARPU_TRACE_TAG_DONE(tag);
+	_STARPU_TRACE_TAG_DONE(tag);
 
 	_starpu_notify_cg_list(&tag->tag_successors);
 
@@ -199,7 +199,7 @@ void starpu_tag_notify_from_apps(starpu_tag_t id)
 
 void _starpu_tag_declare(starpu_tag_t id, struct starpu_job_s *job)
 {
-	STARPU_TRACE_TAG(id, job);
+	_STARPU_TRACE_TAG(id, job);
 	job->task->use_tag = 1;
 	
 	struct _starpu_tag *tag= gettag_struct(id);
@@ -233,7 +233,7 @@ void starpu_tag_declare_deps_array(starpu_tag_t id, unsigned ndeps, starpu_tag_t
 		
 		/* id depends on dep_id
 		 * so cg should be among dep_id's successors*/
-		STARPU_TRACE_TAG_DEPS(id, dep_id);
+		_STARPU_TRACE_TAG_DEPS(id, dep_id);
 		_starpu_bound_tag_dep(id, dep_id);
 		struct _starpu_tag *tag_dep = gettag_struct(dep_id);
 		STARPU_ASSERT(tag_dep != tag_child);
@@ -267,7 +267,7 @@ void starpu_tag_declare_deps(starpu_tag_t id, unsigned ndeps, ...)
 	
 		/* id depends on dep_id
 		 * so cg should be among dep_id's successors*/
-		STARPU_TRACE_TAG_DEPS(id, dep_id);
+		_STARPU_TRACE_TAG_DEPS(id, dep_id);
 		_starpu_bound_tag_dep(id, dep_id);
 		struct _starpu_tag *tag_dep = gettag_struct(dep_id);
 		STARPU_ASSERT(tag_dep != tag_child);

src/core/dependencies/task_deps.c

@@ -82,7 +82,7 @@ void starpu_task_declare_deps_array(struct starpu_task *task, unsigned ndeps, st
 		dep_job = _starpu_get_job_associated_to_task(dep_task);
 		STARPU_ASSERT(dep_job != job);
 
-		STARPU_TRACE_TASK_DEPS(dep_job, job);
+		_STARPU_TRACE_TASK_DEPS(dep_job, job);
 		_starpu_bound_task_dep(job, dep_job);
 
 		_STARPU_PTHREAD_MUTEX_LOCK(&dep_job->sync_mutex);

src/core/jobs.c

@@ -177,9 +177,9 @@ void _starpu_handle_job_termination(starpu_job_t j, unsigned job_is_already_lock
 
 		_starpu_set_current_task(task);
 
-		STARPU_TRACE_START_CALLBACK(j);
+		_STARPU_TRACE_START_CALLBACK(j);
 		task->callback_func(task->callback_arg);
-		STARPU_TRACE_END_CALLBACK(j);
+		_STARPU_TRACE_END_CALLBACK(j);
 		
 		_starpu_set_current_task(current_task);
 
@@ -191,7 +191,7 @@ void _starpu_handle_job_termination(starpu_job_t j, unsigned job_is_already_lock
 
 	_starpu_sched_post_exec_hook(task);
 
-	STARPU_TRACE_TASK_DONE(j);
+	_STARPU_TRACE_TASK_DONE(j);
 
 	/* NB: we do not save those values before the callback, in case the
 	 * application changes some parameters eventually (eg. a task may not

src/core/task.c

@@ -338,7 +338,7 @@ int starpu_task_wait_for_all(void)
 
 	_STARPU_PTHREAD_MUTEX_LOCK(&submitted_mutex);
 
-	STARPU_TRACE_TASK_WAIT_FOR_ALL;
+	_STARPU_TRACE_TASK_WAIT_FOR_ALL;
 
 	while (nsubmitted > 0)
 		_STARPU_PTHREAD_COND_WAIT(&submitted_cond, &submitted_mutex);
@@ -359,7 +359,7 @@ int starpu_task_wait_for_no_ready(void)
 
 	_STARPU_PTHREAD_MUTEX_LOCK(&submitted_mutex);
 
-	STARPU_TRACE_TASK_WAIT_FOR_ALL;
+	_STARPU_TRACE_TASK_WAIT_FOR_ALL;
 
 	while (nready > 0)
 		_STARPU_PTHREAD_COND_WAIT(&submitted_cond, &submitted_mutex);
@@ -376,7 +376,7 @@ void _starpu_decrement_nsubmitted_tasks(void)
 	if (--nsubmitted == 0)
 		_STARPU_PTHREAD_COND_BROADCAST(&submitted_cond);
 
-	STARPU_TRACE_UPDATE_TASK_CNT(nsubmitted);
+	_STARPU_TRACE_UPDATE_TASK_CNT(nsubmitted);
 
 	_STARPU_PTHREAD_MUTEX_UNLOCK(&submitted_mutex);
 
@@ -388,7 +388,7 @@ static void _starpu_increment_nsubmitted_tasks(void)
 
 	nsubmitted++;
 
-	STARPU_TRACE_UPDATE_TASK_CNT(nsubmitted);
+	_STARPU_TRACE_UPDATE_TASK_CNT(nsubmitted);
 
 	_STARPU_PTHREAD_MUTEX_UNLOCK(&submitted_mutex);
 }

src/datawizard/coherency.c

@@ -587,7 +587,7 @@ int starpu_prefetch_task_input_on_node(struct starpu_task *task, uint32_t node)
 
 int _starpu_fetch_task_input(struct starpu_task *task, uint32_t mask)
 {
-	STARPU_TRACE_START_FETCH_INPUT(NULL);
+	_STARPU_TRACE_START_FETCH_INPUT(NULL);
 
 	int profiling = starpu_profiling_status_get();
 	if (profiling && task->profiling_info)
@@ -635,7 +635,7 @@ int _starpu_fetch_task_input(struct starpu_task *task, uint32_t mask)
 	if (profiling && task->profiling_info)
 		_starpu_clock_gettime(&task->profiling_info->acquire_data_end_time);
 
-	STARPU_TRACE_END_FETCH_INPUT(NULL);
+	_STARPU_TRACE_END_FETCH_INPUT(NULL);
 
 	return 0;
 
@@ -650,7 +650,7 @@ enomem:
 
 void _starpu_push_task_output(struct starpu_task *task, uint32_t mask)
 {
-	STARPU_TRACE_START_PUSH_OUTPUT(NULL);
+	_STARPU_TRACE_START_PUSH_OUTPUT(NULL);
 
 	int profiling = starpu_profiling_status_get();
 	if (profiling && task->profiling_info)
@@ -692,7 +692,7 @@ void _starpu_push_task_output(struct starpu_task *task, uint32_t mask)
 	if (profiling && task->profiling_info)
 		_starpu_clock_gettime(&task->profiling_info->release_data_end_time);
 
-	STARPU_TRACE_END_PUSH_OUTPUT(NULL);
+	_STARPU_TRACE_END_PUSH_OUTPUT(NULL);
 }
 
 /* NB : this value can only be an indication of the status of a data

src/datawizard/copy_driver.c

@@ -276,13 +276,13 @@ int __attribute__((warn_unused_result)) _starpu_driver_copy_data_1_to_1(starpu_d
 			req->com_id = com_id;
 #endif
 
-		STARPU_TRACE_START_DRIVER_COPY(src_node, dst_node, size, com_id);
+		_STARPU_TRACE_START_DRIVER_COPY(src_node, dst_node, size, com_id);
 		ret_copy = copy_data_1_to_1_generic(handle, src_replicate, dst_replicate, req);
 
 #ifdef STARPU_USE_FXT
 		if (ret_copy != -EAGAIN)
 		{
-			STARPU_TRACE_END_DRIVER_COPY(src_node, dst_node, size, com_id);
+			_STARPU_TRACE_END_DRIVER_COPY(src_node, dst_node, size, com_id);
 		}
 #endif
 

src/datawizard/data_request.c

@@ -259,7 +259,7 @@ static void starpu_handle_data_request_completion(starpu_data_request_t r)
 	uint32_t src_node = src_replicate->memory_node;
 	uint32_t dst_node = dst_replicate->memory_node;
 	size_t size = _starpu_data_get_size(handle);
-	STARPU_TRACE_END_DRIVER_COPY(src_node, dst_node, size, r->com_id);
+	_STARPU_TRACE_END_DRIVER_COPY(src_node, dst_node, size, r->com_id);
 #endif
 
 	/* Once the request has been fulfilled, we may submit the requests that

src/datawizard/interfaces/bcsr_interface.c

@@ -438,7 +438,7 @@ static int copy_cuda_common(void *src_interface, unsigned src_node STARPU_ATTRIB
 	if (STARPU_UNLIKELY(cures))
 		STARPU_CUDA_REPORT_ERROR(cures);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*r*c*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*r*c*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
 
 	return 0;
 }
@@ -486,7 +486,7 @@ static int copy_opencl_to_ram(void *src_interface, unsigned src_node STARPU_ATTR
 	if (STARPU_UNLIKELY(err))
 		STARPU_OPENCL_REPORT_ERROR(err);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*r*c*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*r*c*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
 
 	return 0;
 }
@@ -517,7 +517,7 @@ static int copy_ram_to_opencl(void *src_interface, unsigned src_node STARPU_ATTR
 	if (STARPU_UNLIKELY(err))
 		STARPU_OPENCL_REPORT_ERROR(err);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*r*c*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*r*c*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
 
 	return 0;
 }
@@ -542,7 +542,7 @@ static int copy_ram_to_ram(void *src_interface, unsigned src_node STARPU_ATTRIBU
 
 	memcpy((void *)dst_bcsr->rowptr, (void *)src_bcsr->rowptr, (nrow+1)*sizeof(uint32_t));
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*elemsize*r*c + (nnz+nrow+1)*sizeof(uint32_t));
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*elemsize*r*c + (nnz+nrow+1)*sizeof(uint32_t));
 
 	return 0;
 }

src/datawizard/interfaces/block_interface.c

@@ -442,7 +442,7 @@ static int copy_cuda_common(void *src_interface, unsigned src_node STARPU_ATTRIB
 		}
 	}
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_block->nx*src_block->ny*src_block->elemsize*src_block->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_block->nx*src_block->ny*src_block->elemsize*src_block->elemsize);
 
 	return 0;
 }
@@ -468,10 +468,10 @@ static int copy_cuda_async_common(void *src_interface, unsigned src_node STARPU_
 		/* Is that a single contiguous buffer ? */
 		if (((nx*ny) == src_block->ldz) && (src_block->ldz == dst_block->ldz))
 		{
-			STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+			_STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
 			cures = cudaMemcpyAsync((char *)dst_block->ptr, (char *)src_block->ptr,
 					nx*ny*nz*elemsize, kind, stream);
-			STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+			_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 			if (STARPU_UNLIKELY(cures))
 			{
 				cures = cudaMemcpy((char *)dst_block->ptr, (char *)src_block->ptr,
@@ -488,11 +488,11 @@ static int copy_cuda_async_common(void *src_interface, unsigned src_node STARPU_
 		}
 		else {
 			/* Are all plans contiguous */
-			STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+			_STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
 			cures = cudaMemcpy2DAsync((char *)dst_block->ptr, dst_block->ldz*elemsize,
 					(char *)src_block->ptr, src_block->ldz*elemsize,
 					nx*ny*elemsize, nz, kind, stream);
-			STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+			_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 			if (STARPU_UNLIKELY(cures))
 			{
 				cures = cudaMemcpy2D((char *)dst_block->ptr, dst_block->ldz*elemsize,
@@ -516,11 +516,11 @@ static int copy_cuda_async_common(void *src_interface, unsigned src_node STARPU_
 			uint8_t *src_ptr = ((uint8_t *)src_block->ptr) + layer*src_block->ldz*src_block->elemsize;
 			uint8_t *dst_ptr = ((uint8_t *)dst_block->ptr) + layer*dst_block->ldz*dst_block->elemsize;
 
-			STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+			_STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
 			cures = cudaMemcpy2DAsync((char *)dst_ptr, dst_block->ldy*elemsize,
                                                   (char *)src_ptr, src_block->ldy*elemsize,
                                                   nx*elemsize, ny, kind, stream);
-			STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+			_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 
 			if (STARPU_UNLIKELY(cures))
 			{
@@ -534,7 +534,7 @@ static int copy_cuda_async_common(void *src_interface, unsigned src_node STARPU_
 
 	}
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_block->nx*src_block->ny*src_block->nz*src_block->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_block->nx*src_block->ny*src_block->nz*src_block->elemsize);
 
 	return ret;
 
@@ -555,7 +555,7 @@ no_async_default:
 			STARPU_CUDA_REPORT_ERROR(cures);
 	}
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_block->nx*src_block->ny*src_block->nz*src_block->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_block->nx*src_block->ny*src_block->nz*src_block->elemsize);
 	return 0;
 	}
 }
@@ -649,7 +649,7 @@ static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node STARP
                 }
         }
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_block->nx*src_block->ny*src_block->nz*src_block->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_block->nx*src_block->ny*src_block->nz*src_block->elemsize);
 
 	return ret;
 }
@@ -710,7 +710,7 @@ static int copy_opencl_to_ram_async(void *src_interface, unsigned src_node STARP
                 }
         }
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_block->nx*src_block->ny*src_block->nz*src_block->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_block->nx*src_block->ny*src_block->nz*src_block->elemsize);
 
 	return ret;
 }
@@ -757,7 +757,7 @@ static int copy_ram_to_ram(void *src_interface, unsigned src_node STARPU_ATTRIBU
 			(void *)(ptr_src + src_offset), nx*elemsize);
 	}
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, nx*ny*nz*elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, nx*ny*nz*elemsize);
 
 	return 0;
 }

src/datawizard/interfaces/csr_interface.c

@@ -409,7 +409,7 @@ static int copy_cuda_common(void *src_interface, unsigned src_node STARPU_ATTRIB
 	if (STARPU_UNLIKELY(cures))
 		STARPU_CUDA_REPORT_ERROR(cures);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
 
 	return 0;
 }
@@ -427,12 +427,12 @@ static int copy_cuda_common_async(void *src_interface, unsigned src_node STARPU_
 
 	int synchronous_fallback = 0;
 
-	STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+	_STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
 	cures = cudaMemcpyAsync((char *)dst_csr->nzval, (char *)src_csr->nzval, nnz*elemsize, kind, stream);
 	if (cures)
 	{
 		synchronous_fallback = 1;
-		STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 		cures = cudaMemcpy((char *)dst_csr->nzval, (char *)src_csr->nzval, nnz*elemsize, kind);
 		if (STARPU_UNLIKELY(cures))
 			STARPU_CUDA_REPORT_ERROR(cures);
@@ -446,7 +446,7 @@ static int copy_cuda_common_async(void *src_interface, unsigned src_node STARPU_
 	if (synchronous_fallback || cures != cudaSuccess)
 	{
 		synchronous_fallback = 1;
-		STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 		cures = cudaMemcpy((char *)dst_csr->colind, (char *)src_csr->colind, nnz*sizeof(uint32_t), kind);
 		if (STARPU_UNLIKELY(cures))
 			STARPU_CUDA_REPORT_ERROR(cures);
@@ -460,7 +460,7 @@ static int copy_cuda_common_async(void *src_interface, unsigned src_node STARPU_
 	if (synchronous_fallback || cures != cudaSuccess)
 	{
 		synchronous_fallback = 1;
-		STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 		cures = cudaMemcpy((char *)dst_csr->rowptr, (char *)src_csr->rowptr, (nrow+1)*sizeof(uint32_t), kind);
 		if (STARPU_UNLIKELY(cures))
 			STARPU_CUDA_REPORT_ERROR(cures);
@@ -468,11 +468,11 @@ static int copy_cuda_common_async(void *src_interface, unsigned src_node STARPU_
 	
 	if (synchronous_fallback)
 	{
-		STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
+		_STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
 		return 0;
 	}
 	else {
-		STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 		return -EAGAIN;
 	}
 }
@@ -504,7 +504,7 @@ static int copy_cuda_peer(void *src_interface STARPU_ATTRIBUTE_UNUSED, unsigned
 	if (STARPU_UNLIKELY(cures))
 		STARPU_CUDA_REPORT_ERROR(cures);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
 
 	return 0;
 #else
@@ -531,12 +531,12 @@ static int copy_cuda_peer_async(void *src_interface STARPU_ATTRIBUTE_UNUSED, uns
 
 	int synchronous_fallback = 0;
 
-	STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+	_STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
 	cures = cudaMemcpyPeerAsync((char *)dst_csr->nzval, dst_dev, (char *)src_csr->nzval, src_dev, nnz*elemsize, stream);
 	if (cures)
 	{
 		synchronous_fallback = 1;
-		STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 		cures = cudaMemcpyPeer((char *)dst_csr->nzval, dst_dev, (char *)src_csr->nzval, src_dev, nnz*elemsize);
 		if (STARPU_UNLIKELY(cures))
 			STARPU_CUDA_REPORT_ERROR(cures);
@@ -550,7 +550,7 @@ static int copy_cuda_peer_async(void *src_interface STARPU_ATTRIBUTE_UNUSED, uns
 	if (synchronous_fallback || cures != cudaSuccess)
 	{
 		synchronous_fallback = 1;
-		STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 		cures = cudaMemcpyPeer((char *)dst_csr->colind, dst_dev, (char *)src_csr->colind, src_dev, nnz*sizeof(uint32_t));
 		if (STARPU_UNLIKELY(cures))
 			STARPU_CUDA_REPORT_ERROR(cures);
@@ -564,7 +564,7 @@ static int copy_cuda_peer_async(void *src_interface STARPU_ATTRIBUTE_UNUSED, uns
 	if (synchronous_fallback || cures != cudaSuccess)
 	{
 		synchronous_fallback = 1;
-		STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 		cures = cudaMemcpyPeer((char *)dst_csr->rowptr, dst_dev, (char *)src_csr->rowptr, src_dev, (nrow+1)*sizeof(uint32_t));
 		if (STARPU_UNLIKELY(cures))
 			STARPU_CUDA_REPORT_ERROR(cures);
@@ -572,11 +572,11 @@ static int copy_cuda_peer_async(void *src_interface STARPU_ATTRIBUTE_UNUSED, uns
 	
 	if (synchronous_fallback)
 	{
-		STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
+		_STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
 		return 0;
 	}
 	else {
-		STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 		return -EAGAIN;
 	}
 #else
@@ -648,7 +648,7 @@ static int copy_opencl_to_ram(void *src_interface, unsigned src_node STARPU_ATTR
 	if (STARPU_UNLIKELY(err))
                 STARPU_OPENCL_REPORT_ERROR(err);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
 
 	return 0;
 }
@@ -676,7 +676,7 @@ static int copy_ram_to_opencl(void *src_interface, unsigned src_node STARPU_ATTR
 	if (STARPU_UNLIKELY(err))
                 STARPU_OPENCL_REPORT_ERROR(err);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
 
 	return 0;
 }
@@ -698,7 +698,7 @@ static int copy_ram_to_ram(void *src_interface, unsigned src_node STARPU_ATTRIBU
 
 	memcpy((void *)dst_csr->rowptr, (void *)src_csr->rowptr, (nrow+1)*sizeof(uint32_t));
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, nnz*elemsize + (nnz+nrow+1)*sizeof(uint32_t));
 
 	return 0;
 }

src/datawizard/interfaces/matrix_interface.c

@@ -391,9 +391,9 @@ static int copy_cuda_common(void *src_interface, unsigned src_node STARPU_ATTRIB
 
 	if (is_async)
 	{
-		STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
 		cures = cudaMemcpy3DAsync(&p, stream);
-		STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 		if (!cures)
 			return -EAGAIN;
 	}
@@ -405,11 +405,11 @@ static int copy_cuda_common(void *src_interface, unsigned src_node STARPU_ATTRIB
 
 	if (is_async)
 	{
-		STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
 		cures = cudaMemcpy2DAsync((char *)dst_matrix->ptr, dst_matrix->ld*elemsize,
 			(char *)src_matrix->ptr, src_matrix->ld*elemsize,
 			src_matrix->nx*elemsize, src_matrix->ny, kind, stream);
-		STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 		if (!cures)
 			return -EAGAIN;
 	}
@@ -421,7 +421,7 @@ static int copy_cuda_common(void *src_interface, unsigned src_node STARPU_ATTRIB
 		STARPU_CUDA_REPORT_ERROR(cures);
 #endif
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, (size_t)src_matrix->nx*src_matrix->ny*src_matrix->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, (size_t)src_matrix->nx*src_matrix->ny*src_matrix->elemsize);
 
 	return 0;
 }
@@ -507,9 +507,9 @@ static int copy_cuda_peer(void *src_interface, unsigned src_node STARPU_ATTRIBUT
 
 	if (is_async)
 	{
-		STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
 		cures = cudaMemcpy3DPeerAsync(&p, stream);
-		STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 		if (!cures)
 			return -EAGAIN;
 	}
@@ -525,9 +525,9 @@ static int copy_cuda_peer(void *src_interface, unsigned src_node STARPU_ATTRIBUT
 
 	if (is_async)
 	{
-		STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
 		cures = cudaMemcpyPeerAsync((char *)dst_matrix->ptr, dst_dev, (char *)src_matrix->ptr, src_dev, dst_matrix->nx*dst_matrix->ny*elemsize, stream);
-		STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 		if (!cures)
 			return -EAGAIN;
 	}
@@ -537,7 +537,7 @@ static int copy_cuda_peer(void *src_interface, unsigned src_node STARPU_ATTRIBUT
 		STARPU_CUDA_REPORT_ERROR(cures);
 #endif
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, (size_t)src_matrix->nx*src_matrix->ny*src_matrix->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, (size_t)src_matrix->nx*src_matrix->ny*src_matrix->elemsize);
 
 	return 0;
 }
@@ -602,7 +602,7 @@ static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node STARP
         if (STARPU_UNLIKELY(err))
                 STARPU_OPENCL_REPORT_ERROR(err);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_matrix->nx*src_matrix->ny*src_matrix->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_matrix->nx*src_matrix->ny*src_matrix->elemsize);
 
 	return ret;
 }
@@ -623,7 +623,7 @@ static int copy_opencl_to_ram_async(void *src_interface, unsigned src_node STARP
         if (STARPU_UNLIKELY(err))
                 STARPU_OPENCL_REPORT_ERROR(err);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_matrix->nx*src_matrix->ny*src_matrix->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_matrix->nx*src_matrix->ny*src_matrix->elemsize);
 
 	return ret;
 }
@@ -667,7 +667,7 @@ static int copy_ram_to_ram(void *src_interface, unsigned src_node STARPU_ATTRIBU
 			(void *)(ptr_src + src_offset), nx*elemsize);
 	}
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, (size_t)nx*ny*elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, (size_t)nx*ny*elemsize);
 
 	return 0;
 }

src/datawizard/interfaces/multiformat_interface.c

@@ -519,11 +519,11 @@ static int copy_cuda_peer_common(void *src_interface, unsigned src_node,
 
 	if (stream)
 	{
-		STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
 		status = cudaMemcpyPeerAsync(dst_multiformat->cuda_ptr, dst_dev,
 					     src_multiformat->cuda_ptr, src_dev,
 					     size, stream);
-		STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 		/* All good ! Still, returning -EAGAIN, because we will need to
                    check the transfert completion later */
 		if (status == cudaSuccess)
@@ -538,7 +538,7 @@ static int copy_cuda_peer_common(void *src_interface, unsigned src_node,
 	if (STARPU_UNLIKELY(status != cudaSuccess))
 		STARPU_CUDA_REPORT_ERROR(status);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, size);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, size);
 
 	return 0;
 }
@@ -631,7 +631,7 @@ static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node,
         if (STARPU_UNLIKELY(err))
                 STARPU_OPENCL_REPORT_ERROR(err);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, size);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, size);
 	return ret;
 }
 
@@ -665,7 +665,7 @@ static int copy_opencl_to_ram_async(void *src_interface, unsigned src_node,
         if (STARPU_UNLIKELY(err))
                 STARPU_OPENCL_REPORT_ERROR(err);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, size);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, size);
 
 	/* XXX So much for asynchronicity */
 	clWaitForEvents(1, _event);

src/datawizard/interfaces/variable_interface.c

@@ -290,7 +290,7 @@ static int copy_cuda_common(void *src_interface, unsigned src_node STARPU_ATTRIB
 	if (STARPU_UNLIKELY(cures))
 		STARPU_CUDA_REPORT_ERROR(cures);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_variable->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_variable->elemsize);
 
 	return 0;
 }
@@ -328,7 +328,7 @@ static int copy_cuda_to_cuda(void *src_interface, unsigned src_node STARPU_ATTRI
 		if (STARPU_UNLIKELY(cures))
 			STARPU_CUDA_REPORT_ERROR(cures);
 
-		STARPU_TRACE_DATA_COPY(src_node, dst_node, src_variable->elemsize);
+		_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_variable->elemsize);
 
 #else
 		/* This is illegal without support for cudaMemcpyPeer */
@@ -346,9 +346,9 @@ static int copy_cuda_async_common(void *src_interface, unsigned src_node STARPU_
 	struct starpu_variable_interface *dst_variable = dst_interface;
 
 	cudaError_t cures;
-	STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+	_STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
 	cures = cudaMemcpyAsync((char *)dst_variable->ptr, (char *)src_variable->ptr, src_variable->elemsize, kind, stream);
-	STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+	_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 	if (cures)
 	{
 		/* do it in a synchronous fashion */
@@ -360,7 +360,7 @@ static int copy_cuda_async_common(void *src_interface, unsigned src_node STARPU_
 		return 0;
 	}
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_variable->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_variable->elemsize);
 
 	return -EAGAIN;
 }
@@ -395,9 +395,9 @@ static int copy_cuda_to_cuda_async(void *src_interface, unsigned src_node,					v
 		size_t length = src_variable->elemsize;
 
 		cudaError_t cures;
-		STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
 		cures = cudaMemcpyPeerAsync((char *)dst_variable->ptr, dst_dev, (char *)src_variable->ptr, src_dev, length, stream);
-		STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 		if (cures)
 		{
 			/* sychronous fallback */
@@ -408,7 +408,7 @@ static int copy_cuda_to_cuda_async(void *src_interface, unsigned src_node,					v
 			return 0;
 		}
 
-		STARPU_TRACE_DATA_COPY(src_node, dst_node, length);
+		_STARPU_TRACE_DATA_COPY(src_node, dst_node, length);
 
 		return -EAGAIN;
 #else
@@ -435,7 +435,7 @@ static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node STARP
         if (STARPU_UNLIKELY(err))
                 STARPU_OPENCL_REPORT_ERROR(err);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_variable->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_variable->elemsize);
 
 	return ret;
 }
@@ -452,7 +452,7 @@ static int copy_opencl_to_ram_async(void *src_interface, unsigned src_node STARP
         if (STARPU_UNLIKELY(err))
                 STARPU_OPENCL_REPORT_ERROR(err);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_variable->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_variable->elemsize);
 
 	return ret;
 }
@@ -485,7 +485,7 @@ static int copy_opencl_to_opencl(void *src_interface, unsigned src_node STARPU_A
 	if (STARPU_UNLIKELY(err))
 		STARPU_OPENCL_REPORT_ERROR(err);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_variable->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_variable->elemsize);
 
 	return 0;
 }
@@ -504,7 +504,7 @@ static int copy_ram_to_ram(void *src_interface, unsigned src_node STARPU_ATTRIBU
 
 	memcpy((void *)ptr_dst, (void *)ptr_src, elemsize);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, elemsize);
 
 	return 0;
 }

src/datawizard/interfaces/vector_interface.c

@@ -334,7 +334,7 @@ static int copy_cuda_common(void *src_interface, unsigned src_node STARPU_ATTRIB
 	if (STARPU_UNLIKELY(cures))
 		STARPU_CUDA_REPORT_ERROR(cures);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_vector->nx*src_vector->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_vector->nx*src_vector->elemsize);
 
 	return 0;
 }
@@ -356,11 +356,11 @@ static int copy_cuda_peer_common(void *src_interface, unsigned src_node,
 
 	if (is_async)
 	{
-		STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
 		cures = cudaMemcpyPeerAsync((char *)dst_vector->ptr, dst_dev,
 						(char *)src_vector->ptr, src_dev,
 						length, stream);
-		STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+		_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 		if (!cures)
 			return -EAGAIN;
 	}
@@ -370,7 +370,7 @@ static int copy_cuda_peer_common(void *src_interface, unsigned src_node,
 	if (STARPU_UNLIKELY(cures))
 		STARPU_CUDA_REPORT_ERROR(cures);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, length);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, length);
 
 	return 0;
 }
@@ -415,9 +415,9 @@ static int copy_cuda_async_common(void *src_interface, unsigned src_node STARPU_
 
 	cudaError_t cures;
 
-	STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+	_STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
 	cures = cudaMemcpyAsync((char *)dst_vector->ptr, (char *)src_vector->ptr, src_vector->nx*src_vector->elemsize, kind, stream);
-	STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+	_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 	if (cures)
 	{
 		/* do it in a synchronous fashion */
@@ -428,7 +428,7 @@ static int copy_cuda_async_common(void *src_interface, unsigned src_node STARPU_
 		return 0;
 	}
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_vector->nx*src_vector->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_vector->nx*src_vector->elemsize);
 
 	return -EAGAIN;
 }
@@ -478,7 +478,7 @@ static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node STARP
         if (STARPU_UNLIKELY(err))
                 STARPU_OPENCL_REPORT_ERROR(err);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_vector->nx*src_vector->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_vector->nx*src_vector->elemsize);
 
 	return ret;
 }
@@ -495,7 +495,7 @@ static int copy_opencl_to_ram_async(void *src_interface, unsigned src_node STARP
         if (STARPU_UNLIKELY(err))
                 STARPU_OPENCL_REPORT_ERROR(err);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_vector->nx*src_vector->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_vector->nx*src_vector->elemsize);
 
 	return ret;
 }
@@ -529,7 +529,7 @@ static int copy_opencl_to_opencl(void *src_interface, unsigned src_node STARPU_A
         if (STARPU_UNLIKELY(err))
                 STARPU_OPENCL_REPORT_ERROR(err);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_vector->nx*src_vector->elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_vector->nx*src_vector->elemsize);
 
 	return 0;
 }
@@ -551,7 +551,7 @@ static int copy_ram_to_ram(void *src_interface, unsigned src_node STARPU_ATTRIBU
 
 	memcpy((void *)ptr_dst, (void *)ptr_src, nx*elemsize);
 
-	STARPU_TRACE_DATA_COPY(src_node, dst_node, nx*elemsize);
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, nx*elemsize);
 
 	return 0;
 }

src/datawizard/memalloc.c

@@ -741,7 +741,7 @@ static ssize_t _starpu_allocate_interface(starpu_data_handle_t handle, struct st
 	/* perhaps we can directly reuse a buffer in the free-list */
 	uint32_t footprint = _starpu_compute_data_footprint(handle);
 
-	STARPU_TRACE_START_ALLOC_REUSE(dst_node);
+	_STARPU_TRACE_START_ALLOC_REUSE(dst_node);
 	_STARPU_PTHREAD_RWLOCK_WRLOCK(&mc_rwlock[node]);
 
 	if (try_to_find_reusable_mem_chunk(dst_node, handle, footprint))
@@ -753,14 +753,14 @@ static ssize_t _starpu_allocate_interface(starpu_data_handle_t handle, struct st
 	}
 
 	_STARPU_PTHREAD_RWLOCK_UNLOCK(&mc_rwlock[node]);
-	STARPU_TRACE_END_ALLOC_REUSE(dst_node);
+	_STARPU_TRACE_END_ALLOC_REUSE(dst_node);
 #endif
 
 	do {
 		STARPU_ASSERT(handle->ops);
 		STARPU_ASSERT(handle->ops->allocate_data_on_node);
 
-		STARPU_TRACE_START_ALLOC(dst_node);
+		_STARPU_TRACE_START_ALLOC(dst_node);
 		STARPU_ASSERT(replicate->data_interface);
 
 #if defined(STARPU_USE_CUDA) && defined(HAVE_CUDA_MEMCPY_PEER)
@@ -776,7 +776,7 @@ static ssize_t _starpu_allocate_interface(starpu_data_handle_t handle, struct st
 #endif
 
 		allocated_memory = handle->ops->allocate_data_on_node(replicate->data_interface, dst_node);
-		STARPU_TRACE_END_ALLOC(dst_node);
+		_STARPU_TRACE_END_ALLOC(dst_node);
 
 		if (allocated_memory == -ENOMEM)
 		{
@@ -789,12 +789,12 @@ static ssize_t _starpu_allocate_interface(starpu_data_handle_t handle, struct st
 			handle->busy_count++;
 			_starpu_spin_unlock(&handle->header_lock);
 
-			STARPU_TRACE_START_MEMRECLAIM(dst_node);
+			_STARPU_TRACE_START_MEMRECLAIM(dst_node);
 			if (is_prefetch)
 				flush_memchunk_cache(dst_node, reclaim);
 			else
 				reclaim_memory_generic(dst_node, 0, reclaim);
-			STARPU_TRACE_END_MEMRECLAIM(dst_node);
+			_STARPU_TRACE_END_MEMRECLAIM(dst_node);
 
 		        while (_starpu_spin_trylock(&handle->header_lock))
 		                _starpu_datawizard_progress(_starpu_get_local_memory_node(), 0);

src/datawizard/memory_nodes.c

@@ -110,7 +110,7 @@ unsigned _starpu_register_memory_node(enum _starpu_node_kind kind, int devid)
 	nnodes = STARPU_ATOMIC_ADD(&descr.nnodes, 1);
 
 	descr.nodes[nnodes-1] = kind;
-	STARPU_TRACE_NEW_MEM_NODE(nnodes-1);
+	_STARPU_TRACE_NEW_MEM_NODE(nnodes-1);
 
 	descr.devid[nnodes-1] = devid;
 

src/debug/traces/starpu_fxt.c

@@ -223,21 +223,21 @@ static void handle_worker_init_start(struct fxt_ev_64 *ev, struct starpu_fxt_opt
 	enum starpu_perf_archtype archtype = 0;
 
 	switch (ev->param[0]) {
-		case STARPU_FUT_APPS_KEY:
+		case _STARPU_FUT_APPS_KEY:
 			set_next_other_worker_color(workerid);
 			kindstr = "apps";
 			break;
-		case STARPU_FUT_CPU_KEY:
+		case _STARPU_FUT_CPU_KEY:
 			set_next_cpu_worker_color(workerid);
 			kindstr = "cpu";
 			archtype = STARPU_CPU_DEFAULT;
 			break;
-		case STARPU_FUT_CUDA_KEY:
+		case _STARPU_FUT_CUDA_KEY:
 			set_next_cuda_worker_color(workerid);
 			kindstr = "cuda";
 			archtype = STARPU_CUDA_DEFAULT + devid;
 			break;
-		case STARPU_FUT_OPENCL_KEY:
+		case _STARPU_FUT_OPENCL_KEY:
 			set_next_opencl_worker_color(workerid);
 			kindstr = "opencl";
 			archtype = STARPU_OPENCL_DEFAULT + devid;
@@ -841,151 +841,151 @@ void starpu_fxt_parse_new_file(char *filename_in, struct starpu_fxt_options *opt
 		}
 
 		switch (ev.code) {
-			case STARPU_FUT_WORKER_INIT_START:
+			case _STARPU_FUT_WORKER_INIT_START:
 				handle_worker_init_start(&ev, options);
 				break;
 
-			case STARPU_FUT_WORKER_INIT_END:
+			case _STARPU_FUT_WORKER_INIT_END:
 				handle_worker_init_end(&ev, options);
 				break;
 
-			case STARPU_FUT_NEW_MEM_NODE:
+			case _STARPU_FUT_NEW_MEM_NODE:
 				handle_new_mem_node(&ev, options);
 				break;
 
 			/* detect when the workers were idling or not */
-			case STARPU_FUT_START_CODELET_BODY:
+			case _STARPU_FUT_START_CODELET_BODY:
 				handle_start_codelet_body(&ev, options);
 				break;
-			case STARPU_FUT_END_CODELET_BODY:
+			case _STARPU_FUT_END_CODELET_BODY:
 				handle_end_codelet_body(&ev, options);
 				break;
 
-			case STARPU_FUT_START_CALLBACK:
+			case _STARPU_FUT_START_CALLBACK:
 				handle_start_callback(&ev, options);
 				break;
-			case STARPU_FUT_END_CALLBACK:
+			case _STARPU_FUT_END_CALLBACK:
 				handle_end_callback(&ev, options);
 				break;
 
-			case STARPU_FUT_UPDATE_TASK_CNT:
+			case _STARPU_FUT_UPDATE_TASK_CNT:
 				handle_update_task_cnt(&ev, options);
 				break;
 
 			/* monitor stack size */
-			case STARPU_FUT_JOB_PUSH:
+			case _STARPU_FUT_JOB_PUSH:
 				handle_job_push(&ev, options);
 				break;
-			case STARPU_FUT_JOB_POP:
+			case _STARPU_FUT_JOB_POP:
 				handle_job_pop(&ev, options);
 				break;
 
 			/* check the memory transfer overhead */
-			case STARPU_FUT_START_FETCH_INPUT:
+			case _STARPU_FUT_START_FETCH_INPUT:
 				handle_worker_status(&ev, options, "Fi");
 				break;
 
-			case STARPU_FUT_START_PUSH_OUTPUT:
+			case _STARPU_FUT_START_PUSH_OUTPUT:
 				handle_worker_status(&ev, options, "Po");
 				break;
 
-			case STARPU_FUT_START_PROGRESS:
+			case _STARPU_FUT_START_PROGRESS:
 				handle_worker_status(&ev, options, "P");
 				break;
 
-			case STARPU_FUT_END_FETCH_INPUT:
-			case STARPU_FUT_END_PROGRESS:
-			case STARPU_FUT_END_PUSH_OUTPUT:
+			case _STARPU_FUT_END_FETCH_INPUT:
+			case _STARPU_FUT_END_PROGRESS:
+			case _STARPU_FUT_END_PUSH_OUTPUT:
 				handle_worker_status(&ev, options, "B");
 				break;
 
-			case STARPU_FUT_WORKER_SLEEP_START:
+			case _STARPU_FUT_WORKER_SLEEP_START:
 				handle_start_sleep(&ev, options);
 				break;
 
-			case STARPU_FUT_WORKER_SLEEP_END:
+			case _STARPU_FUT_WORKER_SLEEP_END:
 				handle_end_sleep(&ev, options);
 				break;
 
-			case STARPU_FUT_TAG:
+			case _STARPU_FUT_TAG:
 				/* XXX */
 				break;
 
-			case STARPU_FUT_TAG_DEPS:
+			case _STARPU_FUT_TAG_DEPS:
 				handle_codelet_tag_deps(&ev);
 				break;
 
-			case STARPU_FUT_TASK_DEPS:
+			case _STARPU_FUT_TASK_DEPS:
 				handle_task_deps(&ev);
 				break;
 
-			case STARPU_FUT_TASK_DONE:
+			case _STARPU_FUT_TASK_DONE:
 				handle_task_done(&ev, options);
 				break;
 
-			case STARPU_FUT_TAG_DONE:
+			case _STARPU_FUT_TAG_DONE:
 				handle_tag_done(&ev, options);
 				break;
 
-			case STARPU_FUT_DATA_COPY:
+			case _STARPU_FUT_DATA_COPY:
 				if (!options->no_bus)
 				handle_data_copy();
 				break;
 
-			case STARPU_FUT_START_DRIVER_COPY:
+			case _STARPU_FUT_START_DRIVER_COPY:
 				if (!options->no_bus)
 				handle_start_driver_copy(&ev, options);
 				break;
 
-			case STARPU_FUT_END_DRIVER_COPY:
+			case _STARPU_FUT_END_DRIVER_COPY:
 				if (!options->no_bus)
 				handle_end_driver_copy(&ev, options);
 				break;
 
-			case STARPU_FUT_START_DRIVER_COPY_ASYNC:
+			case _STARPU_FUT_START_DRIVER_COPY_ASYNC:
 				if (!options->no_bus)
 				handle_start_driver_copy_async(&ev, options);
 				break;
 
-			case STARPU_FUT_END_DRIVER_COPY_ASYNC:
+			case _STARPU_FUT_END_DRIVER_COPY_ASYNC:
 				if (!options->no_bus)
 				handle_end_driver_copy_async(&ev, options);
 				break;
 
-			case STARPU_FUT_WORK_STEALING:
+			case _STARPU_FUT_WORK_STEALING:
 				/* XXX */
 				break;
 
-			case STARPU_FUT_WORKER_DEINIT_START:
+			case _STARPU_FUT_WORKER_DEINIT_START:
 				handle_worker_deinit_start(&ev, options);
 				break;
 
-			case STARPU_FUT_WORKER_DEINIT_END:
+			case _STARPU_FUT_WORKER_DEINIT_END:
 				handle_worker_deinit_end(&ev, options);
 				break;
 
-			case STARPU_FUT_START_ALLOC:
+			case _STARPU_FUT_START_ALLOC:
 				if (!options->no_bus)
 				handle_memnode_event(&ev, options, "A");
 				break;
 
-			case STARPU_FUT_START_ALLOC_REUSE:
+			case _STARPU_FUT_START_ALLOC_REUSE:
 				if (!options->no_bus)
 				handle_memnode_event(&ev, options, "Ar");
 				break;
 
-			case STARPU_FUT_START_MEMRECLAIM:
+			case _STARPU_FUT_START_MEMRECLAIM:
 				handle_memnode_event(&ev, options, "R");
 				break;
 
-			case STARPU_FUT_END_ALLOC:
-			case STARPU_FUT_END_ALLOC_REUSE:
-			case STARPU_FUT_END_MEMRECLAIM:
+			case _STARPU_FUT_END_ALLOC:
+			case _STARPU_FUT_END_ALLOC_REUSE:
+			case _STARPU_FUT_END_MEMRECLAIM:
 				if (!options->no_bus)
 				handle_memnode_event(&ev, options, "No");
 				break;
 
-			case STARPU_FUT_USER_EVENT:
+			case _STARPU_FUT_USER_EVENT:
 				handle_user_event(&ev, options);
 				break;
 
@@ -1001,11 +1001,11 @@ void starpu_fxt_parse_new_file(char *filename_in, struct starpu_fxt_options *opt
 				handle_mpi_irecv_end(&ev, options);
 				break;
 
-			case STARPU_FUT_SET_PROFILING:
+			case _STARPU_FUT_SET_PROFILING:
 				handle_set_profiling(&ev, options);
 				break;
 
-			case STARPU_FUT_TASK_WAIT_FOR_ALL:
+			case _STARPU_FUT_TASK_WAIT_FOR_ALL:
 				handle_task_wait_for_all();
 				break;
 

src/drivers/cpu/driver_cpu.c

@@ -94,7 +94,7 @@ void *_starpu_cpu_worker(void *arg)
 #ifdef STARPU_USE_FXT
 	_starpu_fxt_register_thread(cpu_arg->bindid);
 #endif
-	STARPU_TRACE_WORKER_INIT_START(STARPU_FUT_CPU_KEY, devid, memnode);
+	_STARPU_TRACE_WORKER_INIT_START(_STARPU_FUT_CPU_KEY, devid, memnode);
 
 	_starpu_bind_thread_on_cpu(cpu_arg->config, cpu_arg->bindid);
 
@@ -109,7 +109,7 @@ void *_starpu_cpu_worker(void *arg)
 
 	cpu_arg->status = STATUS_UNKNOWN;
 
-	STARPU_TRACE_WORKER_INIT_END
+	_STARPU_TRACE_WORKER_INIT_END
 
         /* tell the main thread that we are ready */
 	_STARPU_PTHREAD_MUTEX_LOCK(&cpu_arg->mutex);
@@ -124,9 +124,9 @@ void *_starpu_cpu_worker(void *arg)
 
 	while (_starpu_machine_is_running())
 	{
-		STARPU_TRACE_START_PROGRESS(memnode);
+		_STARPU_TRACE_START_PROGRESS(memnode);
 		_starpu_datawizard_progress(memnode, 1);
-		STARPU_TRACE_END_PROGRESS(memnode);
+		_STARPU_TRACE_END_PROGRESS(memnode);
 
 		_STARPU_PTHREAD_MUTEX_LOCK(cpu_arg->sched_mutex);
 
@@ -206,7 +206,7 @@ void *_starpu_cpu_worker(void *arg)
 			_starpu_handle_job_termination(j, 0);
         }
 
-	STARPU_TRACE_WORKER_DEINIT_START
+	_STARPU_TRACE_WORKER_DEINIT_START
 
 	_starpu_handle_all_pending_node_data_requests(memnode);
 
@@ -215,7 +215,7 @@ void *_starpu_cpu_worker(void *arg)
 	 * coherency is not maintained anymore at that point ! */
 	_starpu_free_all_automatically_allocated_buffers(memnode);
 
-	STARPU_TRACE_WORKER_DEINIT_END(STARPU_FUT_CPU_KEY);
+	_STARPU_TRACE_WORKER_DEINIT_END(_STARPU_FUT_CPU_KEY);
 
 	pthread_exit(NULL);
 	return NULL;

src/drivers/cuda/driver_cuda.c

@@ -250,7 +250,7 @@ void *_starpu_cuda_worker(void *arg)
 #ifdef STARPU_USE_FXT
 	_starpu_fxt_register_thread(args->bindid);
 #endif
-	STARPU_TRACE_WORKER_INIT_START(STARPU_FUT_CUDA_KEY, devid, memnode);
+	_STARPU_TRACE_WORKER_INIT_START(_STARPU_FUT_CUDA_KEY, devid, memnode);
 
 	_starpu_bind_thread_on_cpu(args->config, args->bindid);
 
@@ -285,7 +285,7 @@ void *_starpu_cuda_worker(void *arg)
 	snprintf(args->short_name, sizeof(args->short_name), "CUDA %d", args->devid);
 	_STARPU_DEBUG("cuda (%s) dev id %d thread is ready to run on CPU %d !\n", devname, devid, args->bindid);
 
-	STARPU_TRACE_WORKER_INIT_END
+	_STARPU_TRACE_WORKER_INIT_END
 
 	/* tell the main thread that this one is ready */
 	_STARPU_PTHREAD_MUTEX_LOCK(&args->mutex);
@@ -299,9 +299,9 @@ void *_starpu_cuda_worker(void *arg)
 
 	while (_starpu_machine_is_running())
 	{
-		STARPU_TRACE_START_PROGRESS(memnode);
+		_STARPU_TRACE_START_PROGRESS(memnode);
 		_starpu_datawizard_progress(memnode, 1);
-		STARPU_TRACE_END_PROGRESS(memnode);
+		_STARPU_TRACE_END_PROGRESS(memnode);
 
 		_STARPU_PTHREAD_MUTEX_LOCK(args->sched_mutex);
 
@@ -351,7 +351,7 @@ void *_starpu_cuda_worker(void *arg)
 		_starpu_handle_job_termination(j, 0);
 	}
 
-	STARPU_TRACE_WORKER_DEINIT_START
+	_STARPU_TRACE_WORKER_DEINIT_START
 
 	_starpu_handle_all_pending_node_data_requests(memnode);
 
@@ -362,7 +362,7 @@ void *_starpu_cuda_worker(void *arg)
 
 	deinit_context(args->workerid, args->devid);
 
-	STARPU_TRACE_WORKER_DEINIT_END(STARPU_FUT_CUDA_KEY);
+	_STARPU_TRACE_WORKER_DEINIT_END(_STARPU_FUT_CUDA_KEY);
 
 	pthread_exit(NULL);
 

src/drivers/driver_common/driver_common.c

@@ -56,7 +56,7 @@ void _starpu_driver_start_job(struct _starpu_worker *args, starpu_job_t j, struc
 	if (starpu_top)
 		starpu_top_task_started(task,workerid,codelet_start);
 
-	STARPU_TRACE_START_CODELET_BODY(j);
+	_STARPU_TRACE_START_CODELET_BODY(j);
 }
 
 void _starpu_driver_end_job(struct _starpu_worker *args, starpu_job_t j, struct timespec *codelet_end, int rank)
@@ -70,7 +70,7 @@ void _starpu_driver_end_job(struct _starpu_worker *args, starpu_job_t j, struct
 	unsigned calibrate_model = 0;
 	enum starpu_perf_archtype archtype STARPU_ATTRIBUTE_UNUSED = args->perf_arch;
 
-	STARPU_TRACE_END_CODELET_BODY(j, archtype);
+	_STARPU_TRACE_END_CODELET_BODY(j, archtype);
 
 	if (cl->model && cl->model->benchmarking)
 		calibrate_model = 1;
@@ -147,7 +147,7 @@ void _starpu_block_worker(int workerid, pthread_cond_t *cond, pthread_mutex_t *m
 {
 	struct timespec start_time, end_time;
 
-	STARPU_TRACE_WORKER_SLEEP_START
+	_STARPU_TRACE_WORKER_SLEEP_START
 	_starpu_worker_set_status(workerid, STATUS_SLEEPING);
 
 	_starpu_clock_gettime(&start_time);
@@ -156,7 +156,7 @@ void _starpu_block_worker(int workerid, pthread_cond_t *cond, pthread_mutex_t *m
 	_STARPU_PTHREAD_COND_WAIT(cond, mutex);
 
 	_starpu_worker_set_status(workerid, STATUS_UNKNOWN);
-	STARPU_TRACE_WORKER_SLEEP_END
+	_STARPU_TRACE_WORKER_SLEEP_END
 	_starpu_clock_gettime(&end_time);
 
 	int profiling = starpu_profiling_status_get();

src/drivers/opencl/driver_opencl.c

@@ -200,10 +200,10 @@ cl_int _starpu_opencl_copy_ram_to_opencl_async_sync(void *ptr, unsigned src_node
         blocking = (event == NULL) ? CL_TRUE : CL_FALSE;
 
         if (event)
-                STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+                _STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
         err = clEnqueueWriteBuffer(transfer_queues[worker->devid], buffer, blocking, offset, size, ptr, 0, NULL, event);
         if (event)
-                STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+                _STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
         if (STARPU_LIKELY(err == CL_SUCCESS)) {
                 *ret = (event == NULL) ? 0 : -EAGAIN;
                 return CL_SUCCESS;
@@ -232,10 +232,10 @@ cl_int _starpu_opencl_copy_ram_to_opencl(void *ptr, unsigned src_node STARPU_ATT
 
         blocking = (event == NULL) ? CL_TRUE : CL_FALSE;
         if (event)
-                STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+                _STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
         err = clEnqueueWriteBuffer(transfer_queues[worker->devid], buffer, blocking, offset, size, ptr, 0, NULL, event);
         if (event)
-                STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+                _STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
         if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
 
         return CL_SUCCESS;
@@ -249,10 +249,10 @@ cl_int _starpu_opencl_copy_opencl_to_ram_async_sync(cl_mem buffer, unsigned src_
 
         blocking = (event == NULL) ? CL_TRUE : CL_FALSE;
         if (event)
-                STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+                _STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
         err = clEnqueueReadBuffer(transfer_queues[worker->devid], buffer, blocking, offset, size, ptr, 0, NULL, event);
         if (event)
-                STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+                _STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
         if (STARPU_LIKELY(err == CL_SUCCESS)) {
                 *ret = (event == NULL) ? 0 : -EAGAIN;
                 return CL_SUCCESS;
@@ -280,10 +280,10 @@ cl_int _starpu_opencl_copy_opencl_to_ram(cl_mem buffer, unsigned src_node STARPU
 
         blocking = (event == NULL) ? CL_TRUE : CL_FALSE;
         if (event)
-                STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+                _STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
         err = clEnqueueReadBuffer(transfer_queues[worker->devid], buffer, blocking, offset, size, ptr, 0, NULL, event);
         if (event)
-                STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+                _STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
         if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
 
         return CL_SUCCESS;
@@ -300,11 +300,11 @@ cl_int _starpu_opencl_copy_rect_opencl_to_ram(cl_mem buffer, unsigned src_node S
 
         blocking = (event == NULL) ? CL_TRUE : CL_FALSE;
         if (event)
-                STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+                _STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
         err = clEnqueueReadBufferRect(transfer_queues[worker->devid], buffer, blocking, buffer_origin, host_origin, region, buffer_row_pitch,
                                       buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, 0, NULL, event);
         if (event)
-                STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+                _STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
         if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
 
         return CL_SUCCESS;
@@ -320,11 +320,11 @@ cl_int _starpu_opencl_copy_rect_ram_to_opencl(void *ptr, unsigned src_node STARP
 
         blocking = (event == NULL) ? CL_TRUE : CL_FALSE;
         if (event)
-                STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+                _STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
         err = clEnqueueWriteBufferRect(transfer_queues[worker->devid], buffer, blocking, buffer_origin, host_origin, region, buffer_row_pitch,
                                        buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, 0, NULL, event);
         if (event)
-                STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+                _STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
         if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
 
         return CL_SUCCESS;
@@ -423,7 +423,7 @@ void *_starpu_opencl_worker(void *arg)
 #endif
 
 	unsigned memnode = args->memory_node;
-	STARPU_TRACE_WORKER_INIT_START(STARPU_FUT_OPENCL_KEY, devid, memnode);
+	_STARPU_TRACE_WORKER_INIT_START(_STARPU_FUT_OPENCL_KEY, devid, memnode);
 
 	_starpu_bind_thread_on_cpu(args->config, args->bindid);
 
@@ -446,7 +446,7 @@ void *_starpu_opencl_worker(void *arg)
 
 	_STARPU_DEBUG("OpenCL (%s) dev id %d thread is ready to run on CPU %d !\n", devname, devid, args->bindid);
 
-	STARPU_TRACE_WORKER_INIT_END
+	_STARPU_TRACE_WORKER_INIT_END
 
 	/* tell the main thread that this one is ready */
 	_STARPU_PTHREAD_MUTEX_LOCK(&args->mutex);
@@ -460,9 +460,9 @@ void *_starpu_opencl_worker(void *arg)
 
 	while (_starpu_machine_is_running())
 	{
-		STARPU_TRACE_START_PROGRESS(memnode);
+		_STARPU_TRACE_START_PROGRESS(memnode);
 		_starpu_datawizard_progress(memnode, 1);
-		STARPU_TRACE_END_PROGRESS(memnode);
+		_STARPU_TRACE_END_PROGRESS(memnode);
 
 		_STARPU_PTHREAD_MUTEX_LOCK(args->sched_mutex);
 
@@ -512,7 +512,7 @@ void *_starpu_opencl_worker(void *arg)
 		_starpu_handle_job_termination(j, 0);
 	}
 
-	STARPU_TRACE_WORKER_DEINIT_START
+	_STARPU_TRACE_WORKER_DEINIT_START
 
 	_starpu_handle_all_pending_node_data_requests(memnode);
 

src/profiling/profiling.c

@@ -64,7 +64,7 @@ int starpu_profiling_status_set(int status)
 	int prev_value = profiling;
 	profiling = status;
 
-	STARPU_TRACE_SET_PROFILING(status);
+	_STARPU_TRACE_SET_PROFILING(status);
 
 	/* If we enable profiling, we reset the counters. */
 	if (status == STARPU_PROFILING_ENABLE)

src/sched_policies/deque_modeling_policy_data_aware.c

@@ -108,7 +108,7 @@ static struct starpu_task *_starpu_fifo_pop_first_ready_task(struct _starpu_fifo
 		
 		starpu_task_list_erase(&fifo_queue->taskq, task);
 
-		STARPU_TRACE_JOB_POP(task, 0);
+		_STARPU_TRACE_JOB_POP(task, 0);
 	}
 	
 	return task;
@@ -209,7 +209,7 @@ int _starpu_fifo_push_sorted_task(struct _starpu_fifo_taskq *fifo_queue, pthread
 
 	_STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
 
-	STARPU_TRACE_JOB_PUSH(task, 0);
+	_STARPU_TRACE_JOB_PUSH(task, 0);
 
 	if (list->head == NULL)
 	{

src/sched_policies/deque_queues.c

@@ -76,7 +76,7 @@ struct starpu_task *_starpu_deque_pop_task(struct _starpu_deque_jobq *deque_queu
 		STARPU_ASSERT(j);
 		deque_queue->njobs--;
 		
-		STARPU_TRACE_JOB_POP(j, 0);
+		_STARPU_TRACE_JOB_POP(j, 0);
 
 		return j->task;
 	}

src/sched_policies/eager_central_priority_policy.c

@@ -106,7 +106,7 @@ static int _starpu_priority_push_task(struct starpu_task *task)
 	/* wake people waiting for a task */
 	_STARPU_PTHREAD_MUTEX_LOCK(&global_sched_mutex);
 
-	STARPU_TRACE_JOB_PUSH(task, 1);
+	_STARPU_TRACE_JOB_PUSH(task, 1);
 	
 	unsigned priolevel = task->priority - STARPU_MIN_PRIO;
 
@@ -146,7 +146,7 @@ static struct starpu_task *_starpu_priority_pop_task(void)
 				task = starpu_task_list_pop_back(&taskq->taskq[priolevel]);
 				taskq->ntasks[priolevel]--;
 				taskq->total_ntasks--;
-				STARPU_TRACE_JOB_POP(task, 0);
+				_STARPU_TRACE_JOB_POP(task, 0);
 			}
 		} while (!task && priolevel-- > 0);
 	}

src/sched_policies/fifo_queues.c

@@ -53,7 +53,7 @@ int _starpu_fifo_push_task(struct _starpu_fifo_taskq *fifo_queue, pthread_mutex_
 {
 	_STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
 
-	STARPU_TRACE_JOB_PUSH(task, 0);
+	_STARPU_TRACE_JOB_PUSH(task, 0);
 	/* TODO: if prio, put at back */
 	starpu_task_list_push_front(&fifo_queue->taskq, task);
 	fifo_queue->ntasks++;
@@ -81,7 +81,7 @@ struct starpu_task *_starpu_fifo_pop_task(struct _starpu_fifo_taskq *fifo_queue,
 		STARPU_ASSERT(task);
 		fifo_queue->ntasks--;
 		
-		STARPU_TRACE_JOB_POP(task, 0);
+		_STARPU_TRACE_JOB_POP(task, 0);
 	}
 	
 	return task;

src/sched_policies/stack_queues.c

@@ -62,7 +62,7 @@ void _starpu_stack_push_task(struct _starpu_stack_jobq *stack_queue, pthread_mut
 	_STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
 	total_number_of_jobs++;
 
-	STARPU_TRACE_JOB_PUSH(task, 0);
+	_STARPU_TRACE_JOB_PUSH(task, 0);
 	if (task->task->priority)
 		starpu_job_list_push_back(stack_queue->jobq, task);
 	else
@@ -90,7 +90,7 @@ starpu_job_t _starpu_stack_pop_task(struct _starpu_stack_jobq *stack_queue, pthr
 		STARPU_ASSERT(j);
 		stack_queue->njobs--;
 		
-		STARPU_TRACE_JOB_POP(j, 0);
+		_STARPU_TRACE_JOB_POP(j, 0);
 
 		/* we are sure that we got it now, so at worst, some people thought 
 		 * there remained some work and will soon discover it is not true */

src/sched_policies/work_stealing_policy.c

@@ -161,7 +161,7 @@ static struct starpu_task *ws_pop_task(void)
 
 	task = _starpu_deque_pop_task(victimq, workerid);
 	if (task) {
-		STARPU_TRACE_WORK_STEALING(q, victimq);
+		_STARPU_TRACE_WORK_STEALING(q, victimq);
 		performed_total++;
 	}
 
@@ -183,7 +183,7 @@ static int ws_push_task(struct starpu_task *task)
 	// XXX reuse ?
         //total_number_of_jobs++;
 
-        STARPU_TRACE_JOB_PUSH(task, 0);
+        _STARPU_TRACE_JOB_PUSH(task, 0);
         starpu_job_list_push_front(deque_queue->jobq, j);
         deque_queue->njobs++;
         deque_queue->nprocessed++;

tools/starpu_fxt_stats.c

@@ -97,13 +97,13 @@ int main(int argc, char **argv)
 		__attribute__ ((unused)) int nbparam = ev.nb_params;
 
 		switch (ev.code) {
-			case STARPU_FUT_DATA_COPY:
+			case _STARPU_FUT_DATA_COPY:
 				handle_data_copy();
 				break;
-			case STARPU_FUT_JOB_POP:
+			case _STARPU_FUT_JOB_POP:
 				njob++;
 				break;
-			case STARPU_FUT_WORK_STEALING:
+			case _STARPU_FUT_WORK_STEALING:
 				nws++;
 				break;
 			default: