Prefixing of src/common/fxt.h (3rd and last step)

find . -type f -not -name "*svn*"|xargs sed -i s/"\bFUT_DO_PROBE3STR\b"/STARPU_FUT_DO_PROBE3STR/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_NEW_MEM_NODE\b"/STARPU_TRACE_NEW_MEM_NODE/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_WORKER_INIT_START\b"/STARPU_TRACE_WORKER_INIT_START/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_WORKER_INIT_END\b"/STARPU_TRACE_WORKER_INIT_END/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_START_CODELET_BODY\b"/STARPU_TRACE_START_CODELET_BODY/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_END_CODELET_BODY\b"/STARPU_TRACE_END_CODELET_BODY/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_START_CALLBACK\b"/STARPU_TRACE_START_CALLBACK/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_END_CALLBACK\b"/STARPU_TRACE_END_CALLBACK/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_JOB_PUSH\b"/STARPU_TRACE_JOB_PUSH/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_JOB_POP\b"/STARPU_TRACE_JOB_POP/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_START_FETCH_INPUT\b"/STARPU_TRACE_START_FETCH_INPUT/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_END_FETCH_INPUT\b"/STARPU_TRACE_END_FETCH_INPUT/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_START_PUSH_OUTPUT\b"/STARPU_TRACE_START_PUSH_OUTPUT/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_END_PUSH_OUTPUT\b"/STARPU_TRACE_END_PUSH_OUTPUT/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_CODELET_TAG\b"/STARPU_TRACE_CODELET_TAG/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_CODELET_TAG_DEPS\b"/STARPU_TRACE_CODELET_TAG_DEPS/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_TASK_DONE\b"/STARPU_TRACE_TASK_DONE/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_DATA_COPY\b"/STARPU_TRACE_DATA_COPY/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_START_DRIVER_COPY\b"/STARPU_TRACE_START_DRIVER_COPY/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_END_DRIVER_COPY\b"/STARPU_TRACE_END_DRIVER_COPY/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_WORK_STEALING\b"/STARPU_TRACE_WORK_STEALING/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_WORKER_DEINIT_START\b"/STARPU_TRACE_WORKER_DEINIT_START/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_WORKER_DEINIT_END\b"/STARPU_TRACE_WORKER_DEINIT_END/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_USER_DEFINED_START\b"/STARPU_TRACE_USER_DEFINED_START/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_USER_DEFINED_END\b"/STARPU_TRACE_USER_DEFINED_END/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_START_ALLOC\b"/STARPU_TRACE_START_ALLOC/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_END_ALLOC\b"/STARPU_TRACE_END_ALLOC/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_START_ALLOC_REUSE\b"/STARPU_TRACE_START_ALLOC_REUSE/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_END_ALLOC_REUSE\b"/STARPU_TRACE_END_ALLOC_REUSE/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_START_MEMRECLAIM\b"/STARPU_TRACE_START_MEMRECLAIM/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_END_MEMRECLAIM\b"/STARPU_TRACE_END_MEMRECLAIM/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_START_PROGRESS\b"/STARPU_TRACE_START_PROGRESS/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_END_PROGRESS\b"/STARPU_TRACE_END_PROGRESS/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bTRACE_USER_EVENT\b"/STARPU_TRACE_USER_EVENT/g

src/common/fxt.c

@@ -100,6 +100,6 @@ void _starpu_fxt_register_thread(unsigned cpuid)
 void starpu_trace_user_event(unsigned code __attribute__((unused)))
 {
 #ifdef STARPU_USE_FXT
-	TRACE_USER_EVENT(code);
+	STARPU_TRACE_USER_EVENT(code);
 #endif
 }

src/common/fxt.h

@@ -96,7 +96,7 @@ void _starpu_fxt_register_thread(unsigned);
 
 /* sometimes we need something a little more specific than the wrappers from
  * FxT */
-#define FUT_DO_PROBE3STR(CODE, P1, P2, P3, str)				\
+#define STARPU_FUT_DO_PROBE3STR(CODE, P1, P2, P3, str)				\
 do {									\
 	/* we add a \0 just in case ... */				\
 	size_t len = strlen((str)) + 1;					\
@@ -111,22 +111,22 @@ do {									\
 } while (0);
 
 /* workerkind = STARPU_FUT_CPU_KEY for instance */
-#define TRACE_NEW_MEM_NODE(nodeid)			\
+#define STARPU_TRACE_NEW_MEM_NODE(nodeid)			\
 	FUT_DO_PROBE2(STARPU_FUT_NEW_MEM_NODE, nodeid, syscall(SYS_gettid));
 
-#define TRACE_WORKER_INIT_START(workerkind,memnode)	\
+#define STARPU_TRACE_WORKER_INIT_START(workerkind,memnode)	\
 	FUT_DO_PROBE3(STARPU_FUT_WORKER_INIT_START, workerkind, memnode, syscall(SYS_gettid));
 
-#define TRACE_WORKER_INIT_END				\
+#define STARPU_TRACE_WORKER_INIT_END				\
 	FUT_DO_PROBE1(STARPU_FUT_WORKER_INIT_END, syscall(SYS_gettid));
 
-#define TRACE_START_CODELET_BODY(job)					\
+#define STARPU_TRACE_START_CODELET_BODY(job)					\
 do {									\
 	struct starpu_perfmodel_t *model = (job)->task->cl->model;	\
 	if (model && model->symbol)					\
 	{								\
 		/* we include the symbol name */			\
-		FUT_DO_PROBE3STR(STARPU_FUT_START_CODELET_BODY, job, syscall(SYS_gettid), 1, model->symbol);\
+		STARPU_FUT_DO_PROBE3STR(STARPU_FUT_START_CODELET_BODY, job, syscall(SYS_gettid), 1, model->symbol);\
 	}								\
 	else {								\
 		FUT_DO_PROBE3(STARPU_FUT_START_CODELET_BODY, job, syscall(SYS_gettid), 0);\
@@ -134,40 +134,40 @@ do {									\
 } while(0);
 
 
-#define TRACE_END_CODELET_BODY(job)	\
+#define STARPU_TRACE_END_CODELET_BODY(job)	\
 	FUT_DO_PROBE2(STARPU_FUT_END_CODELET_BODY, job, syscall(SYS_gettid));
 
-#define TRACE_START_CALLBACK(job)	\
+#define STARPU_TRACE_START_CALLBACK(job)	\
 	FUT_DO_PROBE2(STARPU_FUT_START_CALLBACK, job, syscall(SYS_gettid));
 
-#define TRACE_END_CALLBACK(job)	\
+#define STARPU_TRACE_END_CALLBACK(job)	\
 	FUT_DO_PROBE2(STARPU_FUT_END_CALLBACK, job, syscall(SYS_gettid));
 
-#define TRACE_JOB_PUSH(task, prio)	\
+#define STARPU_TRACE_JOB_PUSH(task, prio)	\
 	FUT_DO_PROBE3(STARPU_FUT_JOB_PUSH, task, prio, syscall(SYS_gettid));
 
-#define TRACE_JOB_POP(task, prio)	\
+#define STARPU_TRACE_JOB_POP(task, prio)	\
 	FUT_DO_PROBE3(STARPU_FUT_JOB_POP, task, prio, syscall(SYS_gettid));
 
-#define TRACE_START_FETCH_INPUT(job)	\
+#define STARPU_TRACE_START_FETCH_INPUT(job)	\
 	FUT_DO_PROBE2(STARPU_FUT_START_FETCH_INPUT, job, syscall(SYS_gettid));
 
-#define TRACE_END_FETCH_INPUT(job)	\
+#define STARPU_TRACE_END_FETCH_INPUT(job)	\
 	FUT_DO_PROBE2(STARPU_FUT_END_FETCH_INPUT, job, syscall(SYS_gettid));
 
-#define TRACE_START_PUSH_OUTPUT(job)	\
+#define STARPU_TRACE_START_PUSH_OUTPUT(job)	\
 	FUT_DO_PROBE2(STARPU_FUT_START_PUSH_OUTPUT, job, syscall(SYS_gettid));
 
-#define TRACE_END_PUSH_OUTPUT(job)	\
+#define STARPU_TRACE_END_PUSH_OUTPUT(job)	\
 	FUT_DO_PROBE2(STARPU_FUT_END_PUSH_OUTPUT, job, syscall(SYS_gettid));
 
-#define TRACE_CODELET_TAG(tag, job)	\
+#define STARPU_TRACE_CODELET_TAG(tag, job)	\
 	FUT_DO_PROBE2(STARPU_FUT_CODELET_TAG, tag, job)
 
-#define TRACE_CODELET_TAG_DEPS(tag_child, tag_father)	\
+#define STARPU_TRACE_CODELET_TAG_DEPS(tag_child, tag_father)	\
 	FUT_DO_PROBE2(STARPU_FUT_CODELET_TAG_DEPS, tag_child, tag_father)
 
-#define TRACE_TASK_DONE(tag)							\
+#define STARPU_TRACE_TASK_DONE(tag)							\
 do {										\
 	struct starpu_job_s *job = (tag)->job;						\
 	if (job && job->task 							\
@@ -176,100 +176,100 @@ do {										\
 		&& job->task->cl->model->symbol)				\
 	{									\
 		char *symbol = job->task->cl->model->symbol;			\
-		FUT_DO_PROBE3STR(STARPU_FUT_TASK_DONE, tag->id, syscall(SYS_gettid), 1, symbol);\
+		STARPU_FUT_DO_PROBE3STR(STARPU_FUT_TASK_DONE, tag->id, syscall(SYS_gettid), 1, symbol);\
 	}									\
 	else {									\
 		FUT_DO_PROBE3(STARPU_FUT_TASK_DONE, tag->id, syscall(SYS_gettid), 0);	\
 	}									\
 } while(0);
 
-#define TRACE_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 TRACE_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 TRACE_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 TRACE_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 TRACE_WORKER_DEINIT_START			\
+#define STARPU_TRACE_WORKER_DEINIT_START			\
 	FUT_DO_PROBE1(STARPU_FUT_WORKER_DEINIT_START, syscall(SYS_gettid));
 
-#define TRACE_WORKER_DEINIT_END(workerkind)		\
+#define STARPU_TRACE_WORKER_DEINIT_END(workerkind)		\
 	FUT_DO_PROBE2(STARPU_FUT_WORKER_DEINIT_END, workerkind, syscall(SYS_gettid));
 
-#define TRACE_USER_DEFINED_START	\
+#define STARPU_TRACE_USER_DEFINED_START	\
 	FUT_DO_PROBE1(STARPU_FUT_USER_DEFINED_START, syscall(SYS_gettid));
 
-#define TRACE_USER_DEFINED_END		\
+#define STARPU_TRACE_USER_DEFINED_END		\
 	FUT_DO_PROBE1(STARPU_FUT_USER_DEFINED_END, syscall(SYS_gettid));
 
-#define TRACE_START_ALLOC(memnode)		\
+#define STARPU_TRACE_START_ALLOC(memnode)		\
 	FUT_DO_PROBE2(STARPU_FUT_START_ALLOC, memnode, syscall(SYS_gettid));
 	
-#define TRACE_END_ALLOC(memnode)		\
+#define STARPU_TRACE_END_ALLOC(memnode)		\
 	FUT_DO_PROBE2(STARPU_FUT_END_ALLOC, memnode, syscall(SYS_gettid));
 
-#define TRACE_START_ALLOC_REUSE(memnode)		\
+#define STARPU_TRACE_START_ALLOC_REUSE(memnode)		\
 	FUT_DO_PROBE2(STARPU_FUT_START_ALLOC_REUSE, memnode, syscall(SYS_gettid));
 	
-#define TRACE_END_ALLOC_REUSE(memnode)		\
+#define STARPU_TRACE_END_ALLOC_REUSE(memnode)		\
 	FUT_DO_PROBE2(STARPU_FUT_END_ALLOC_REUSE, memnode, syscall(SYS_gettid));
 	
-#define TRACE_START_MEMRECLAIM(memnode)		\
+#define STARPU_TRACE_START_MEMRECLAIM(memnode)		\
 	FUT_DO_PROBE2(STARPU_FUT_START_MEMRECLAIM, memnode, syscall(SYS_gettid));
 	
-#define TRACE_END_MEMRECLAIM(memnode)		\
+#define STARPU_TRACE_END_MEMRECLAIM(memnode)		\
 	FUT_DO_PROBE2(STARPU_FUT_END_MEMRECLAIM, memnode, syscall(SYS_gettid));
 	
-#define TRACE_START_PROGRESS(memnode)		\
+#define STARPU_TRACE_START_PROGRESS(memnode)		\
 	FUT_DO_PROBE2(STARPU_FUT_START_PROGRESS, memnode, syscall(SYS_gettid));
 
-#define TRACE_END_PROGRESS(memnode)		\
+#define STARPU_TRACE_END_PROGRESS(memnode)		\
 	FUT_DO_PROBE2(STARPU_FUT_END_PROGRESS, memnode, syscall(SYS_gettid));
 	
-#define TRACE_USER_EVENT(code)			\
+#define STARPU_TRACE_USER_EVENT(code)			\
 	FUT_DO_PROBE2(STARPU_FUT_USER_EVENT, code, syscall(SYS_gettid));
 
 #else // !STARPU_USE_FXT
 
-#define TRACE_NEW_MEM_NODE(nodeid)	do {} while(0);
+#define STARPU_TRACE_NEW_MEM_NODE(nodeid)	do {} while(0);
 #define TRACE_NEW_WORKER(a,b)		do {} while(0);
-#define TRACE_WORKER_INIT_START(a,b)	do {} while(0);
-#define TRACE_WORKER_INIT_END		do {} while(0);
-#define TRACE_START_CODELET_BODY(job)	do {} while(0);
-#define TRACE_END_CODELET_BODY(job)	do {} while(0);
-#define TRACE_START_CALLBACK(job)	do {} while(0);
-#define TRACE_END_CALLBACK(job)		do {} while(0);
-#define TRACE_JOB_PUSH(task, prio)	do {} while(0);
-#define TRACE_JOB_POP(task, prio)	do {} while(0);
-#define TRACE_START_FETCH_INPUT(job)	do {} while(0);
-#define TRACE_END_FETCH_INPUT(job)	do {} while(0);
-#define TRACE_START_PUSH_OUTPUT(job)	do {} while(0);
-#define TRACE_END_PUSH_OUTPUT(job)	do {} while(0);
-#define TRACE_CODELET_TAG(tag, job)	do {} while(0);
-#define TRACE_CODELET_TAG_DEPS(a, b)	do {} while(0);
-#define TRACE_TASK_DONE(tag)		do {} while(0);
-#define TRACE_DATA_COPY(a, b, c)	do {} while(0);
-#define TRACE_START_DRIVER_COPY(a,b,c,d)	do {} while(0);
-#define TRACE_END_DRIVER_COPY(a,b,c,d)	do {} while(0);
-#define TRACE_WORK_STEALING(a, b)	do {} while(0);
-#define TRACE_WORKER_DEINIT_START	do {} while(0);
-#define TRACE_WORKER_DEINIT_END(a)	do {} while(0);
-#define TRACE_USER_DEFINED_START	do {} while(0);
-#define TRACE_USER_DEFINED_END		do {} while(0);
-#define TRACE_START_ALLOC(memnode)	do {} while(0);
-#define TRACE_END_ALLOC(memnode)	do {} while(0);
-#define TRACE_START_ALLOC_REUSE(a)	do {} while(0);
-#define TRACE_END_ALLOC_REUSE(a)	do {} while(0);
-#define TRACE_START_MEMRECLAIM(memnode)	do {} while(0);
-#define TRACE_END_MEMRECLAIM(memnode)	do {} while(0);
-#define TRACE_START_PROGRESS(memnode)	do {} while(0);
-#define TRACE_END_PROGRESS(memnode)	do {} while(0);
-#define TRACE_USER_EVENT(code)		do {} while(0);
+#define STARPU_TRACE_WORKER_INIT_START(a,b)	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)	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_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_CODELET_TAG(tag, job)	do {} while(0);
+#define STARPU_TRACE_CODELET_TAG_DEPS(a, b)	do {} while(0);
+#define STARPU_TRACE_TASK_DONE(tag)		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_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_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);
 
 #endif // STARPU_USE_FXT
 

src/core/dependencies/tags.c

@@ -176,7 +176,7 @@ static void _starpu_notify_tag_dependencies(struct starpu_tag_s *tag)
 	_starpu_spin_lock(&tag->lock);
 
 	tag->state = STARPU_DONE;
-	TRACE_TASK_DONE(tag);
+	STARPU_TRACE_TASK_DONE(tag);
 
 	_starpu_notify_cg_list(&tag->tag_successors);
 
@@ -205,7 +205,7 @@ void starpu_tag_notify_from_apps(starpu_tag_t id)
 
 void _starpu_tag_declare(starpu_tag_t id, struct starpu_job_s *job)
 {
-	TRACE_CODELET_TAG(id, job);
+	STARPU_TRACE_CODELET_TAG(id, job);
 	job->task->use_tag = 1;
 	
 	struct starpu_tag_s *tag= gettag_struct(id);
@@ -239,7 +239,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*/
-		TRACE_CODELET_TAG_DEPS(id, dep_id);
+		STARPU_TRACE_CODELET_TAG_DEPS(id, dep_id);
 		struct starpu_tag_s *tag_dep = gettag_struct(dep_id);
 		_starpu_spin_lock(&tag_dep->lock);
 		_starpu_tag_add_succ(tag_dep, cg);
@@ -271,7 +271,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*/
-		TRACE_CODELET_TAG_DEPS(id, dep_id);
+		STARPU_TRACE_CODELET_TAG_DEPS(id, dep_id);
 		struct starpu_tag_s *tag_dep = gettag_struct(dep_id);
 		_starpu_spin_lock(&tag_dep->lock);
 		_starpu_tag_add_succ(tag_dep, cg);

src/core/jobs.c

@@ -108,9 +108,9 @@ void _starpu_handle_job_termination(starpu_job_t j)
 		 * within the callback */
 		_starpu_set_local_worker_status(STATUS_CALLBACK);
 
-		TRACE_START_CALLBACK(j);
+		STARPU_TRACE_START_CALLBACK(j);
 		task->callback_func(task->callback_arg);
-		TRACE_END_CALLBACK(j);
+		STARPU_TRACE_END_CALLBACK(j);
 
 		_starpu_set_local_worker_status(STATUS_UNKNOWN);
 	}

src/core/mechanisms/deque_queues.c

@@ -123,7 +123,7 @@ int _starpu_deque_push_task(struct starpu_jobq_s *q, starpu_job_t task)
 	/* wake people waiting locally */
 	pthread_mutex_lock(&q->activity_mutex);
 
-	TRACE_JOB_PUSH(task, 0);
+	STARPU_TRACE_JOB_PUSH(task, 0);
 	starpu_job_list_push_front(deque_queue->jobq, task);
 	deque_queue->njobs++;
 	deque_queue->nprocessed++;
@@ -154,7 +154,7 @@ starpu_job_t _starpu_deque_pop_task(struct starpu_jobq_s *q)
 		STARPU_ASSERT(j);
 		deque_queue->njobs--;
 		
-		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/core/mechanisms/fifo_queues.c

@@ -93,7 +93,7 @@ int _starpu_fifo_push_prio_task(struct starpu_jobq_s *q, starpu_job_t task)
 	/* wake people waiting locally */
 	pthread_mutex_lock(&q->activity_mutex);
 
-	TRACE_JOB_PUSH(task, 0);
+	STARPU_TRACE_JOB_PUSH(task, 0);
 	starpu_job_list_push_back(fifo_queue->jobq, task);
 	fifo_queue->njobs++;
 	fifo_queue->nprocessed++;
@@ -121,7 +121,7 @@ int _starpu_fifo_push_task(struct starpu_jobq_s *q, starpu_job_t task)
 	/* wake people waiting locally */
 	pthread_mutex_lock(&q->activity_mutex);
 
-	TRACE_JOB_PUSH(task, 0);
+	STARPU_TRACE_JOB_PUSH(task, 0);
 	starpu_job_list_push_front(fifo_queue->jobq, task);
 	fifo_queue->njobs++;
 	fifo_queue->nprocessed++;
@@ -150,7 +150,7 @@ starpu_job_t _starpu_fifo_pop_task(struct starpu_jobq_s *q)
 		STARPU_ASSERT(j);
 		fifo_queue->njobs--;
 		
-		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/core/mechanisms/priority_queues.c

@@ -95,7 +95,7 @@ int _starpu_priority_push_task(struct starpu_jobq_s *q, starpu_job_t j)
 	/* wake people waiting locally */
 	pthread_mutex_lock(&q->activity_mutex);
 
-	TRACE_JOB_PUSH(j, 1);
+	STARPU_TRACE_JOB_PUSH(j, 1);
 	
 	unsigned priolevel = j->task->priority - STARPU_MIN_PRIO;
 
@@ -137,7 +137,7 @@ starpu_job_t _starpu_priority_pop_task(struct starpu_jobq_s *q)
 				j = starpu_job_list_pop_back(queue->jobq[priolevel]);
 				queue->njobs[priolevel]--;
 				queue->total_njobs--;
-				TRACE_JOB_POP(j, 0);
+				STARPU_TRACE_JOB_POP(j, 0);
 			}
 		} while (!j && priolevel-- > 0);
 	}

src/core/mechanisms/stack_queues.c

@@ -99,7 +99,7 @@ void _starpu_stack_push_prio_task(struct starpu_jobq_s *q, starpu_job_t task)
 	/* wake people waiting locally */
 	pthread_mutex_lock(&q->activity_mutex);
 
-	TRACE_JOB_PUSH(task, 0);
+	STARPU_TRACE_JOB_PUSH(task, 0);
 	starpu_job_list_push_back(stack_queue->jobq, task);
 	deque_queue->njobs++;
 	deque_queue->nprocessed++;
@@ -125,7 +125,7 @@ void _starpu_stack_push_task(struct starpu_jobq_s *q, starpu_job_t task)
 	/* wake people waiting locally */
 	pthread_mutex_lock(&q->activity_mutex);
 
-	TRACE_JOB_PUSH(task, 0);
+	STARPU_TRACE_JOB_PUSH(task, 0);
 	starpu_job_list_push_front(stack_queue->jobq, task);
 	deque_queue->njobs++;
 	deque_queue->nprocessed++;
@@ -152,7 +152,7 @@ starpu_job_t _starpu_stack_pop_task(struct starpu_jobq_s *q)
 		STARPU_ASSERT(j);
 		stack_queue->njobs--;
 		
-		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/core/policies/work-stealing-policy.c

@@ -151,7 +151,7 @@ static starpu_job_t ws_pop_task(struct starpu_jobq_s *q)
 		j = _starpu_deque_pop_task(victimq);
 		_starpu_jobq_unlock(victimq);
 
-		TRACE_WORK_STEALING(q, j);
+		STARPU_TRACE_WORK_STEALING(q, j);
 		performed_total++;
 	}
 

src/datawizard/coherency.c

@@ -346,7 +346,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)
 {
-	TRACE_START_FETCH_INPUT(NULL);
+	STARPU_TRACE_START_FETCH_INPUT(NULL);
 
 //	fprintf(stderr, "_starpu_fetch_task_input\n");
 
@@ -374,7 +374,7 @@ int _starpu_fetch_task_input(struct starpu_task *task, uint32_t mask)
 		task->interface[index] = src_interface;
 	}
 
-	TRACE_END_FETCH_INPUT(NULL);
+	STARPU_TRACE_END_FETCH_INPUT(NULL);
 
 	return 0;
 
@@ -389,7 +389,7 @@ enomem:
 
 void _starpu_push_task_output(struct starpu_task *task, uint32_t mask)
 {
-	TRACE_START_PUSH_OUTPUT(NULL);
+	STARPU_TRACE_START_PUSH_OUTPUT(NULL);
 
 	//fprintf(stderr, "_starpu_push_task_output\n");
 
@@ -404,7 +404,7 @@ void _starpu_push_task_output(struct starpu_task *task, uint32_t mask)
 		_starpu_release_data_on_node(descrs[index].handle, mask, local_node);
 	}
 
-	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

@@ -230,14 +230,14 @@ int __attribute__((warn_unused_result)) _starpu_driver_copy_data_1_to_1(starpu_d
 #endif
 
 		/* for now we set the size to 0 in the FxT trace XXX */
-		TRACE_START_DRIVER_COPY(src_node, dst_node, 0, com_id);
+		STARPU_TRACE_START_DRIVER_COPY(src_node, dst_node, 0, com_id);
 		ret_copy = copy_data_1_to_1_generic(handle, src_node, dst_node, req);
 
 #ifdef STARPU_USE_FXT
 		if (ret_copy != EAGAIN)
 		{
 			size_t size = handle->ops->get_size(handle);
-			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

@@ -213,7 +213,7 @@ static void starpu_handle_data_request_completion(starpu_data_request_t r)
 
 #ifdef STARPU_USE_FXT
 	size_t size = handle->ops->get_size(handle);
-	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
 
 	unsigned chained_req;

src/datawizard/interfaces/bcsr_interface.c

@@ -378,7 +378,7 @@ static int copy_cuda_to_ram(starpu_data_handle handle, uint32_t src_node, uint32
 
 	cudaThreadSynchronize();
 
-	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;
 }
@@ -414,7 +414,7 @@ static int copy_ram_to_cuda(starpu_data_handle handle, uint32_t src_node, uint32
 
 	cudaThreadSynchronize();
 
-	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;
 }
@@ -442,7 +442,7 @@ static int dummy_copy_ram_to_ram(starpu_data_handle handle, uint32_t src_node, u
 
 	memcpy((void *)dst_bcsr->rowptr, (void *)src_bcsr->rowptr, (nrow+1)*sizeof(uint32_t));
 
-	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/blas_interface.c

@@ -319,7 +319,7 @@ static int copy_cuda_to_ram(starpu_data_handle handle, uint32_t src_node, uint32
 	if (STARPU_UNLIKELY(cures))
 		STARPU_CUDA_REPORT_ERROR(cures);
 
-	TRACE_DATA_COPY(src_node, dst_node, (size_t)src_blas->nx*src_blas->ny*src_blas->elemsize);
+	STARPU_TRACE_DATA_COPY(src_node, dst_node, (size_t)src_blas->nx*src_blas->ny*src_blas->elemsize);
 
 	return 0;
 }
@@ -345,7 +345,7 @@ static int copy_ram_to_cuda(starpu_data_handle handle, uint32_t src_node, uint32
 	if (STARPU_UNLIKELY(cures))
 		STARPU_CUDA_REPORT_ERROR(cures);
 		
-	TRACE_DATA_COPY(src_node, dst_node, (size_t)src_blas->nx*src_blas->ny*src_blas->elemsize);
+	STARPU_TRACE_DATA_COPY(src_node, dst_node, (size_t)src_blas->nx*src_blas->ny*src_blas->elemsize);
 
 	return 0;
 }
@@ -383,7 +383,7 @@ static int copy_cuda_to_ram_async(starpu_data_handle handle, uint32_t src_node,
 		return 0;
 	}
 
-	TRACE_DATA_COPY(src_node, dst_node, (size_t)src_blas->nx*src_blas->ny*src_blas->elemsize);
+	STARPU_TRACE_DATA_COPY(src_node, dst_node, (size_t)src_blas->nx*src_blas->ny*src_blas->elemsize);
 
 	return EAGAIN;
 }
@@ -416,7 +416,7 @@ static int copy_ram_to_cuda_async(starpu_data_handle handle, uint32_t src_node,
 		return 0;
 	}
 
-	TRACE_DATA_COPY(src_node, dst_node, (size_t)src_blas->nx*src_blas->ny*src_blas->elemsize);
+	STARPU_TRACE_DATA_COPY(src_node, dst_node, (size_t)src_blas->nx*src_blas->ny*src_blas->elemsize);
 
 	return EAGAIN;
 }
@@ -453,7 +453,7 @@ static int dummy_copy_ram_to_ram(starpu_data_handle handle, uint32_t src_node, u
 			(void *)(ptr_src + src_offset), nx*elemsize);
 	}
 
-	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/block_interface.c

@@ -368,7 +368,7 @@ static int copy_cuda_to_ram(starpu_data_handle handle, uint32_t src_node, uint32
 	
 	cudaThreadSynchronize();
 
-	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;
 }
@@ -461,7 +461,7 @@ static int copy_cuda_to_ram_async(starpu_data_handle handle, uint32_t src_node,
 
 	}
 
-	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;
 
@@ -486,7 +486,7 @@ no_async_default:
 	}
 	cudaThreadSynchronize();
 
-	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;
 	}
 }
@@ -581,7 +581,7 @@ static int copy_ram_to_cuda_async(starpu_data_handle handle, uint32_t src_node,
 
 	}
 
-	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;
 
@@ -606,7 +606,7 @@ no_async_default:
 	}
 	cudaThreadSynchronize();
 
-	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;
 	}
 }
@@ -654,7 +654,7 @@ static int copy_ram_to_cuda(starpu_data_handle handle, uint32_t src_node, uint32
 
 	cudaThreadSynchronize();
 
-	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;
 }
@@ -693,7 +693,7 @@ static int dummy_copy_ram_to_ram(starpu_data_handle handle, uint32_t src_node, u
 			(void *)(ptr_src + src_offset), nx*elemsize);
 	}
 
-	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

@@ -347,7 +347,7 @@ static int copy_cuda_to_ram(starpu_data_handle handle, uint32_t src_node, uint32
 
 	cudaThreadSynchronize();
 
-	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;
 }
@@ -380,7 +380,7 @@ static int copy_ram_to_cuda(starpu_data_handle handle, uint32_t src_node, uint32
 
 	cudaThreadSynchronize();
 
-	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;
 }
@@ -406,7 +406,7 @@ static int dummy_copy_ram_to_ram(starpu_data_handle handle, uint32_t src_node, u
 
 	memcpy((void *)dst_csr->rowptr, (void *)src_csr->rowptr, (nrow+1)*sizeof(uint32_t));
 
-	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/vector_interface.c

@@ -267,7 +267,7 @@ static int copy_cuda_to_ram(starpu_data_handle handle, uint32_t src_node, uint32
 	if (STARPU_UNLIKELY(cures))
 		STARPU_CUDA_REPORT_ERROR(cures);
 
-	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;
 }
@@ -287,7 +287,7 @@ static int copy_ram_to_cuda(starpu_data_handle handle, uint32_t src_node, uint32
 	if (STARPU_UNLIKELY(cures))
 		STARPU_CUDA_REPORT_ERROR(cures);
 
-	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;
 }
@@ -314,7 +314,7 @@ static int copy_cuda_to_ram_async(starpu_data_handle handle, uint32_t src_node,
 		return 0;
 	}
 
-	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;
 }
@@ -342,7 +342,7 @@ static int copy_ram_to_cuda_async(starpu_data_handle handle, uint32_t src_node,
 		return 0;
 	}
 
-	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;
 }
@@ -366,7 +366,7 @@ static int dummy_copy_ram_to_ram(starpu_data_handle handle, uint32_t src_node, u
 
 	memcpy((void *)ptr_dst, (void *)ptr_src, nx*elemsize);
 
-	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

@@ -554,22 +554,22 @@ int _starpu_allocate_memory_on_node(starpu_data_handle handle, uint32_t dst_node
 	/* perhaps we can directly reuse a buffer in the free-list */
 	uint32_t footprint = _starpu_compute_data_footprint(handle);
 
-	TRACE_START_ALLOC_REUSE(dst_node);
+	STARPU_TRACE_START_ALLOC_REUSE(dst_node);
 	if (try_to_find_reusable_mem_chunk(dst_node, handle, footprint))
 	{
 		_starpu_allocation_cache_hit(dst_node);
 		return 0;
 	}
-	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);
 
-		TRACE_START_ALLOC(dst_node);
+		STARPU_TRACE_START_ALLOC(dst_node);
 		allocated_memory = handle->ops->allocate_data_on_node(handle, dst_node);
-		TRACE_END_ALLOC(dst_node);
+		STARPU_TRACE_END_ALLOC(dst_node);
 
 		if (!allocated_memory) {
 			/* XXX perhaps we should find the proper granularity 
@@ -577,9 +577,9 @@ int _starpu_allocate_memory_on_node(starpu_data_handle handle, uint32_t dst_node
 			STARPU_ASSERT(handle->ops->get_size);
 			size_t data_size = handle->ops->get_size(handle);
 
-			TRACE_START_MEMRECLAIM(dst_node);
+			STARPU_TRACE_START_MEMRECLAIM(dst_node);
 			reclaim_memory(dst_node, 2*data_size, attempts);
-			TRACE_END_MEMRECLAIM(dst_node);
+			STARPU_TRACE_END_MEMRECLAIM(dst_node);
 		}
 		
 	} while(!allocated_memory && attempts++ < 2);

src/datawizard/memory_nodes.c

@@ -92,7 +92,7 @@ unsigned _starpu_register_memory_node(starpu_node_kind kind)
 	nnodes = STARPU_ATOMIC_ADD(&descr.nnodes, 1);
 
 	descr.nodes[nnodes-1] = kind;
-	TRACE_NEW_MEM_NODE(nnodes-1);
+	STARPU_TRACE_NEW_MEM_NODE(nnodes-1);
 
 	/* for now, there is no queue related to that newly created node */
 	descr.queues_count[nnodes-1] = 0;

src/drivers/cpu/driver_cpu.c

@@ -50,7 +50,7 @@ static int execute_job_on_cpu(starpu_job_t j, struct starpu_worker_s *cpu_args)
 		return -EAGAIN;
 	}
 
-	TRACE_START_CODELET_BODY(j);
+	STARPU_TRACE_START_CODELET_BODY(j);
 
 	if (calibrate_model || STARPU_BENCHMARK_COMM)
 		STARPU_GET_TICK(codelet_start);
@@ -64,7 +64,7 @@ static int execute_job_on_cpu(starpu_job_t j, struct starpu_worker_s *cpu_args)
 	if (calibrate_model || STARPU_BENCHMARK_COMM)
 		STARPU_GET_TICK(codelet_end);
 
-	TRACE_END_CODELET_BODY(j);
+	STARPU_TRACE_END_CODELET_BODY(j);
 	cpu_args->status = STATUS_UNKNOWN;
 
 	_starpu_push_task_output(task, 0);
@@ -101,7 +101,7 @@ void *_starpu_cpu_worker(void *arg)
 #ifdef STARPU_USE_FXT
 	_starpu_fxt_register_thread(cpu_arg->bindid);
 #endif
-	TRACE_WORKER_INIT_START(STARPU_FUT_CPU_KEY, cpu_arg->memory_node);
+	STARPU_TRACE_WORKER_INIT_START(STARPU_FUT_CPU_KEY, cpu_arg->memory_node);
 
 	_starpu_bind_thread_on_cpu(cpu_arg->config, cpu_arg->bindid);
 
@@ -128,7 +128,7 @@ void *_starpu_cpu_worker(void *arg)
 
 	cpu_arg->status = STATUS_UNKNOWN;
 	
-	TRACE_WORKER_INIT_END
+	STARPU_TRACE_WORKER_INIT_END
 
         /* tell the main thread that we are ready */
 	pthread_mutex_lock(&cpu_arg->mutex);
@@ -145,9 +145,9 @@ void *_starpu_cpu_worker(void *arg)
 
 	while (_starpu_machine_is_running())
 	{
-		TRACE_START_PROGRESS(memnode);
+		STARPU_TRACE_START_PROGRESS(memnode);
 		_starpu_datawizard_progress(memnode, 1);
-		TRACE_END_PROGRESS(memnode);
+		STARPU_TRACE_END_PROGRESS(memnode);
 
 		_starpu_execute_registered_progression_hooks();
 
@@ -191,7 +191,7 @@ void *_starpu_cpu_worker(void *arg)
 		_starpu_handle_job_termination(j);
         }
 
-	TRACE_WORKER_DEINIT_START
+	STARPU_TRACE_WORKER_DEINIT_START
 
 #ifdef STARPU_DATA_STATS
 	fprintf(stderr, "CPU #%d computation %le comm %le (%lf \%%)\n", cpu_arg->id, cpu_arg->jobq->total_computation_time, cpu_arg->jobq->total_communication_time,  cpu_arg->jobq->total_communication_time*100.0/cpu_arg->jobq->total_computation_time);
@@ -207,7 +207,7 @@ void *_starpu_cpu_worker(void *arg)
 	_starpu_print_to_logfile("MODEL ERROR: CPU %d ERROR %lf EXEC %lf RATIO %lf NTASKS %d\n", cpu_arg->id, cpu_arg->jobq->total_computation_time_error, cpu_arg->jobq->total_computation_time, ratio, cpu_arg->jobq->total_job_performed);
 #endif
 
-	TRACE_WORKER_DEINIT_END(STARPU_FUT_CPU_KEY);
+	STARPU_TRACE_WORKER_DEINIT_END(STARPU_FUT_CPU_KEY);
 
 	pthread_exit(NULL);
 }

src/drivers/cuda/driver_cuda.c

@@ -124,7 +124,7 @@ static int execute_job_on_cuda(starpu_job_t j, struct starpu_worker_s *args)
 		STARPU_GET_TICK(codelet_end_comm);
 	}
 
-	TRACE_START_CODELET_BODY(j);
+	STARPU_TRACE_START_CODELET_BODY(j);
 
 	args->status = STATUS_EXECUTING;
 	cl_func func = cl->cuda_func;
@@ -138,7 +138,7 @@ static int execute_job_on_cuda(starpu_job_t j, struct starpu_worker_s *args)
 
 	args->status = STATUS_UNKNOWN;
 
-	TRACE_END_CODELET_BODY(j);	
+	STARPU_TRACE_END_CODELET_BODY(j);	
 
 	if (calibrate_model || STARPU_BENCHMARK_COMM)
 	{
@@ -173,7 +173,7 @@ void *_starpu_cuda_worker(void *arg)
 #ifdef STARPU_USE_FXT
 	_starpu_fxt_register_thread(args->bindid);
 #endif
-	TRACE_WORKER_INIT_START(STARPU_FUT_CUDA_KEY, memory_node);
+	STARPU_TRACE_WORKER_INIT_START(STARPU_FUT_CUDA_KEY, memory_node);
 
 	_starpu_bind_thread_on_cpu(args->config, args->bindid);
 
@@ -210,7 +210,7 @@ void *_starpu_cuda_worker(void *arg)
 	fprintf(stderr, "cuda (%s) dev id %d thread is ready to run on CPU %d !\n", devname, devid, args->bindid);
 #endif
 
-	TRACE_WORKER_INIT_END
+	STARPU_TRACE_WORKER_INIT_END
 
 	/* tell the main thread that this one is ready */
 	pthread_mutex_lock(&args->mutex);
@@ -227,9 +227,9 @@ void *_starpu_cuda_worker(void *arg)
 	
 	while (_starpu_machine_is_running())
 	{
-		TRACE_START_PROGRESS(memnode);
+		STARPU_TRACE_START_PROGRESS(memnode);
 		_starpu_datawizard_progress(memnode, 1);
-		TRACE_END_PROGRESS(memnode);
+		STARPU_TRACE_END_PROGRESS(memnode);
 
 		_starpu_execute_registered_progression_hooks();
 	
@@ -276,7 +276,7 @@ void *_starpu_cuda_worker(void *arg)
 		_starpu_handle_job_termination(j);
 	}
 
-	TRACE_WORKER_DEINIT_START
+	STARPU_TRACE_WORKER_DEINIT_START
 
 	deinit_context(args->workerid);
 
@@ -295,7 +295,7 @@ void *_starpu_cuda_worker(void *arg)
 	_starpu_print_to_logfile("MODEL ERROR: CUDA %d ERROR %lf EXEC %lf RATIO %lf NTASKS %d\n", args->id, args->jobq->total_computation_time_error, args->jobq->total_computation_time, ratio, args->jobq->total_job_performed);
 #endif
 
-	TRACE_WORKER_DEINIT_END(STARPU_FUT_CUDA_KEY);
+	STARPU_TRACE_WORKER_DEINIT_END(STARPU_FUT_CUDA_KEY);
 
 	pthread_exit(NULL);