FxT lock traces support added to StarPU. Use --enable-fxt-lock option of configure to activate it

include/starpu_thread.h

@@ -83,9 +83,10 @@ typedef pthread_mutexattr_t starpu_pthread_mutexattr_t;
 
 #define starpu_pthread_mutex_init pthread_mutex_init
 #define starpu_pthread_mutex_destroy pthread_mutex_destroy
-#define starpu_pthread_mutex_lock pthread_mutex_lock
-#define starpu_pthread_mutex_unlock pthread_mutex_unlock
-#define starpu_pthread_mutex_trylock pthread_mutex_trylock
+
+int starpu_pthread_mutex_lock(starpu_pthread_mutex_t *mutex);
+int starpu_pthread_mutex_unlock(starpu_pthread_mutex_t *mutex);
+int starpu_pthread_mutex_trylock(starpu_pthread_mutex_t *mutex);
 
 #define STARPU_PTHREAD_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
 
@@ -139,7 +140,9 @@ typedef pthread_condattr_t starpu_pthread_condattr_t;
 #define starpu_pthread_cond_init pthread_cond_init
 #define starpu_pthread_cond_signal pthread_cond_signal
 #define starpu_pthread_cond_broadcast pthread_cond_broadcast
-#define starpu_pthread_cond_wait pthread_cond_wait
+
+int starpu_pthread_cond_wait(starpu_pthread_cond_t *cond, starpu_pthread_mutex_t *mutex);
+
 #define starpu_pthread_cond_timedwait pthread_cond_timedwait
 #define starpu_pthread_cond_destroy pthread_cond_destroy
 
@@ -167,9 +170,10 @@ typedef pthread_rwlockattr_t starpu_pthread_rwlockattr_t;
 
 #define starpu_pthread_rwlock_init pthread_rwlock_init
 #define starpu_pthread_rwlock_destroy pthread_rwlock_destroy
-#define starpu_pthread_rwlock_rdlock pthread_rwlock_rdlock
-#define starpu_pthread_rwlock_wrlock pthread_rwlock_wrlock
-#define starpu_pthread_rwlock_unlock pthread_rwlock_unlock
+
+int starpu_pthread_rwlock_rdlock(starpu_pthread_rwlock_t *rwlock);
+int starpu_pthread_rwlock_wrlock(starpu_pthread_rwlock_t *rwlock);
+int starpu_pthread_rwlock_unlock(starpu_pthread_rwlock_t *rwlock);
 
 #endif /* STARPU_SIMGRID, _MSC_VER */
 

src/common/fxt.h

@@ -105,6 +105,36 @@
 
 #define _STARPU_FUT_TASK_WAIT_FOR_ALL	0x513b
 
+#define _STARPU_FUT_LOCKING_MUTEX	0x5140	
+#define _STARPU_FUT_MUTEX_LOCKED	0x5141	
+
+#define _STARPU_FUT_UNLOCKING_MUTEX		0x5142	
+#define _STARPU_FUT_MUTEX_UNLOCKED		0x5143	
+
+#define _STARPU_FUT_TRYLOCK_MUTEX		0x5144	
+
+#define _STARPU_FUT_RDLOCKING_RWLOCK	0x5145	
+#define _STARPU_FUT_RWLOCK_RDLOCKED		0x5146	
+
+#define _STARPU_FUT_WRLOCKING_RWLOCK	0x5147	
+#define _STARPU_FUT_RWLOCK_WRLOCKED		0x5148	
+
+#define _STARPU_FUT_UNLOCKING_RWLOCK	0x5149	
+#define _STARPU_FUT_RWLOCK_UNLOCKED		0x514a	
+
+#define _STARPU_FUT_LOCKING_SPINLOCK	0x514b	
+#define _STARPU_FUT_SPINLOCK_LOCKED		0x514c	
+
+#define _STARPU_FUT_UNLOCKING_SPINLOCK		0x514d	
+#define _STARPU_FUT_SPINLOCK_UNLOCKED		0x514e	
+
+#define _STARPU_FUT_TRYLOCK_SPINLOCK		0x514f	
+
+#define _STARPU_FUT_COND_WAIT_BEGIN		0x5150
+#define _STARPU_FUT_COND_WAIT_END		0x5151
+
+#define _STARPU_FUT_MEMORY_FULL			0x5152
+
 #ifdef STARPU_USE_FXT
 #include <fxt/fxt.h>
 #include <fxt/fut.h>
@@ -136,6 +166,24 @@ 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_PROBE2STR(CODE, P1, P2, str)			\
+do {									\
+    if(fut_active) {							\
+	/* No more than FXT_MAX_PARAMS args are allowed */		\
+	/* we add a \0 just in case ... */				\
+	size_t len = STARPU_MIN(strlen(str)+1, (FXT_MAX_PARAMS - 2)*sizeof(unsigned long));\
+	unsigned nbargs_str = (len + sizeof(unsigned long) - 1)/(sizeof(unsigned long));\
+	unsigned nbargs = 2 + nbargs_str;				\
+	size_t total_len = FUT_SIZE(nbargs);				\
+	unsigned long *futargs =					\
+		fut_getstampedbuffer(FUT_CODE(CODE, nbargs), total_len);\
+	*(futargs++) = (unsigned long)(P1);				\
+	*(futargs++) = (unsigned long)(P2);				\
+	snprintf((char *)futargs, len, "%s", str);			\
+	((char *)futargs)[len - 1] = '\0';				\
+    }									\
+} while (0);
+
 #define _STARPU_FUT_DO_PROBE3STR(CODE, P1, P2, P3, str)			\
 do {									\
     if(fut_active) {							\
@@ -341,11 +389,11 @@ do {										\
 #define _STARPU_TRACE_END_ALLOC_REUSE(memnode)		\
 	FUT_DO_PROBE2(_STARPU_FUT_END_ALLOC_REUSE, memnode, _starpu_gettid());
 	
-#define _STARPU_TRACE_START_MEMRECLAIM(memnode)		\
-	FUT_DO_PROBE2(_STARPU_FUT_START_MEMRECLAIM, memnode, _starpu_gettid());
+#define _STARPU_TRACE_START_MEMRECLAIM(memnode,is_prefetch)		\
+	FUT_DO_PROBE3(_STARPU_FUT_START_MEMRECLAIM, memnode, is_prefetch, _starpu_gettid());
 	
-#define _STARPU_TRACE_END_MEMRECLAIM(memnode)		\
-	FUT_DO_PROBE2(_STARPU_FUT_END_MEMRECLAIM, memnode, _starpu_gettid());
+#define _STARPU_TRACE_END_MEMRECLAIM(memnode, is_prefetch)		\
+	FUT_DO_PROBE3(_STARPU_FUT_END_MEMRECLAIM, memnode, is_prefetch, _starpu_gettid());
 	
 /* We skip these events becasue they are called so often that they cause FxT to
  * fail and make the overall trace unreadable anyway. */
@@ -366,6 +414,88 @@ do {										\
 #define _STARPU_TRACE_TASK_WAIT_FOR_ALL			\
 	FUT_DO_PROBE0(_STARPU_FUT_TASK_WAIT_FOR_ALL)
 
+#ifdef STARPU_FXT_LOCK_TRACES 
+
+#define _STARPU_TRACE_LOCKING_MUTEX(file,line)	\
+	_STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_LOCKING_MUTEX,line,_starpu_gettid(),file);
+
+#define _STARPU_TRACE_MUTEX_LOCKED(file,line)			\
+	_STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_MUTEX_LOCKED,line,_starpu_gettid(),file);
+
+#define _STARPU_TRACE_UNLOCKING_MUTEX(file,line)		\
+	_STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_UNLOCKING_MUTEX,line,_starpu_gettid(),file);
+
+#define _STARPU_TRACE_MUTEX_UNLOCKED(file,line)		\
+	_STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_MUTEX_UNLOCKED,line,_starpu_gettid(),file);
+
+#define _STARPU_TRACE_TRYLOCK_MUTEX(file,line)			\
+	_STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_TRYLOCK_MUTEX,line,_starpu_gettid(),file);
+
+#define _STARPU_TRACE_RDLOCKING_RWLOCK(file,line)		\
+	_STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_RDLOCKING_RWLOCK,line,_starpu_gettid(),file);
+
+#define _STARPU_TRACE_RWLOCK_RDLOCKED(file,line)		\
+	_STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_RWLOCK_RDLOCKED,line,_starpu_gettid(),file);
+
+#define _STARPU_TRACE_WRLOCKING_RWLOCK(file,line)		\
+	_STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_WRLOCKING_RWLOCK,line,_starpu_gettid(),file);
+
+#define _STARPU_TRACE_RWLOCK_WRLOCKED(file,line)		\
+	_STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_RWLOCK_WRLOCKED,line,_starpu_gettid(),file);
+
+#define _STARPU_TRACE_UNLOCKING_RWLOCK(file,line)		\
+	_STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_UNLOCKING_RWLOCK,line,_starpu_gettid(),file);
+
+#define _STARPU_TRACE_RWLOCK_UNLOCKED(file,line)		\
+	_STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_RWLOCK_UNLOCKED,line,_starpu_gettid(),file);
+
+#define _STARPU_TRACE_LOCKING_SPINLOCK(file,line)		\
+	_STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_LOCKING_SPINLOCK,line,_starpu_gettid(),file);
+
+#define _STARPU_TRACE_SPINLOCK_LOCKED(file,line)		\
+	_STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_SPINLOCK_LOCKED,line,_starpu_gettid(),file);
+
+#define _STARPU_TRACE_UNLOCKING_SPINLOCK(file,line)	\
+	_STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_UNLOCKING_SPINLOCK,line,_starpu_gettid(),file);
+
+#define _STARPU_TRACE_SPINLOCK_UNLOCKED(file,line)		\
+	_STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_SPINLOCK_UNLOCKED,line,_starpu_gettid(),file);
+
+#define _STARPU_TRACE_TRYLOCK_SPINLOCK(file,line)		\
+	_STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_TRYLOCK_SPINLOCK,line,_starpu_gettid(),file);
+
+#define _STARPU_TRACE_COND_WAIT_BEGIN(file,line)		\
+	_STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_COND_WAIT_BEGIN,line,_starpu_gettid(),file);
+
+#define _STARPU_TRACE_COND_WAIT_END(file,line)		\
+	_STARPU_FUT_DO_PROBE2STR(_STARPU_FUT_COND_WAIT_END,line,_starpu_gettid(),file);
+
+#else // !STARPU_FXT_LOCK_TRACES
+
+#define _STARPU_TRACE_LOCKING_MUTEX(file,line)			do {} while(0)
+#define _STARPU_TRACE_MUTEX_LOCKED(file,line)			do {} while(0)
+#define _STARPU_TRACE_UNLOCKING_MUTEX(file,line)		do {} while(0)
+#define _STARPU_TRACE_MUTEX_UNLOCKED(file,line)		do {} while(0)
+#define _STARPU_TRACE_TRYLOCK_MUTEX(file,line)			do {} while(0)
+#define _STARPU_TRACE_RDLOCKING_RWLOCK(file,line)		do {} while(0)
+#define _STARPU_TRACE_RWLOCK_RDLOCKED(file,line)		do {} while(0)
+#define _STARPU_TRACE_WRLOCKING_RWLOCK(file,line)		do {} while(0)
+#define _STARPU_TRACE_RWLOCK_WRLOCKED(file,line)		do {} while(0)
+#define _STARPU_TRACE_UNLOCKING_RWLOCK(file,line)		do {} while(0)
+#define _STARPU_TRACE_RWLOCK_UNLOCKED(file,line)		do {} while(0)
+#define _STARPU_TRACE_LOCKING_SPINLOCK(file,line)		do {} while(0)
+#define _STARPU_TRACE_SPINLOCK_LOCKED(file,line)		do {} while(0)
+#define _STARPU_TRACE_UNLOCKING_SPINLOCK(file,line)	do {} while(0)
+#define _STARPU_TRACE_SPINLOCK_UNLOCKED(file,line)		do {} while(0)
+#define _STARPU_TRACE_TRYLOCK_SPINLOCK(file,line)		do {} while(0)
+#define _STARPU_TRACE_COND_WAIT_BEGIN(file,line)		do {} while(0)
+#define _STARPU_TRACE_COND_WAIT_END(file,line)			do {} while(0)
+
+#endif // STARPU_FXT_LOCK_TRACES
+
+#define _STARPU_TRACE_MEMORY_FULL(size)	\
+	FUT_DO_PROBE2(_STARPU_FUT_MEMORY_FULL,size,_starpu_gettid());
+
 #else // !STARPU_USE_FXT
 
 /* Dummy macros in case FxT is disabled */
@@ -405,13 +535,32 @@ do {										\
 #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_MEMRECLAIM(memnode,is_prefetch)	do {} while(0)
+#define _STARPU_TRACE_END_MEMRECLAIM(memnode,is_prefetch)	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_LOCKING_MUTEX(file,line)			do {} while(0)
+#define _STARPU_TRACE_MUTEX_LOCKED(file,line)			do {} while(0)
+#define _STARPU_TRACE_UNLOCKING_MUTEX(file,line)		do {} while(0)
+#define _STARPU_TRACE_MUTEX_UNLOCKED(file,line)		do {} while(0)
+#define _STARPU_TRACE_TRYLOCK_MUTEX(file,line)			do {} while(0)
+#define _STARPU_TRACE_RDLOCKING_RWLOCK(file,line)		do {} while(0)
+#define _STARPU_TRACE_RWLOCK_RDLOCKED(file,line)		do {} while(0)
+#define _STARPU_TRACE_WRLOCKING_RWLOCK(file,line)		do {} while(0)
+#define _STARPU_TRACE_RWLOCK_WRLOCKED(file,line)		do {} while(0)
+#define _STARPU_TRACE_UNLOCKING_RWLOCK(file,line)		do {} while(0)
+#define _STARPU_TRACE_RWLOCK_UNLOCKED(file,line)		do {} while(0)
+#define _STARPU_TRACE_LOCKING_SPINLOCK(file,line)		do {} while(0)
+#define _STARPU_TRACE_SPINLOCK_LOCKED(file,line)		do {} while(0)
+#define _STARPU_TRACE_UNLOCKING_SPINLOCK(file,line)	do {} while(0)
+#define _STARPU_TRACE_SPINLOCK_UNLOCKED(file,line)		do {} while(0)
+#define _STARPU_TRACE_TRYLOCK_SPINLOCK(file,line)		do {} while(0)
+#define _STARPU_TRACE_COND_WAIT_BEGIN(file,line)		do {} while(0)
+#define _STARPU_TRACE_COND_WAIT_END(file,line)			do {} while(0)
+#define _STARPU_TRACE_MEMORY_FULL(size)				do {} while(0)
 
 #endif // STARPU_USE_FXT
 

src/common/starpu_spinlock.c

@@ -18,6 +18,7 @@
 #include <common/starpu_spinlock.h>
 #include <common/config.h>
 #include <common/utils.h>
+#include <common/fxt.h>
 #include <starpu_util.h>
 
 #ifdef STARPU_SIMGRID
@@ -147,6 +148,7 @@ int _starpu_spin_trylock(struct _starpu_spinlock *lock)
 #endif
 }
 
+#undef _starpu_spin_unlock
 int _starpu_spin_unlock(struct _starpu_spinlock *lock STARPU_ATTRIBUTE_UNUSED)
 {
 #ifdef STARPU_SIMGRID

src/common/starpu_spinlock.h

@@ -41,27 +41,70 @@ struct _starpu_spinlock
 #endif
 };
 
+#ifdef STARPU_SPINLOCK_CHECK 
+#define STARPU_RECORD_LOCK(lock) do { 	\
+	(lock)->last_taker = __starpu_func__; \
+} while(0) 
+#else // !STARPU_SPINLOCK_CHECK
+#define STARPU_RECORD_LOCK(lock) do {} while(0)
+#endif // STARPU_SPINLOCK_CHECK
+
 int _starpu_spin_init(struct _starpu_spinlock *lock);
 int _starpu_spin_destroy(struct _starpu_spinlock *lock);
 
 int _starpu_spin_lock(struct _starpu_spinlock *lock);
-#if defined(STARPU_SPINLOCK_CHECK)
 #define _starpu_spin_lock(lock) ({ \
+	const char *file;   \
+	if (starpu_worker_get_type(starpu_worker_get_id()) == STARPU_CUDA_WORKER) \
+	{ \
+		file = strrchr(__FILE__,'/'); \
+		file += sizeof(char);\
+		_STARPU_TRACE_LOCKING_SPINLOCK(file,__LINE__); \
+	}\
 	_starpu_spin_lock(lock); \
-	(lock)->last_taker = __starpu_func__; \
+	if (starpu_worker_get_type(starpu_worker_get_id()) == STARPU_CUDA_WORKER) \
+	{ \
+		file = strrchr(__FILE__,'/'); \
+		file += sizeof(char);\
+		_STARPU_TRACE_SPINLOCK_LOCKED(file,__LINE__); \
+	}\
+	STARPU_RECORD_LOCK(lock); \
 	0; \
-})
-#endif
+}) 
+
 int _starpu_spin_trylock(struct _starpu_spinlock *lock);
-#if defined(STARPU_SPINLOCK_CHECK)
 #define _starpu_spin_trylock(lock) ({ \
+	const char *file;   \
+	if (starpu_worker_get_type(starpu_worker_get_id()) == STARPU_CUDA_WORKER) \
+	{ \
+		file = strrchr(__FILE__,'/'); \
+		file += sizeof(char);\
+		_STARPU_TRACE_TRYLOCK_SPINLOCK(file,__LINE__); \
+	}\
 	int err = _starpu_spin_trylock(lock); \
 	if (!err) \
-		(lock)->last_taker = __starpu_func__; \
+		STARPU_RECORD_LOCK(lock); \
 	err; \
 })
-#endif
 int _starpu_spin_checklocked(struct _starpu_spinlock *lock);
 int _starpu_spin_unlock(struct _starpu_spinlock *lock);
+#define _starpu_spin_unlock(lock) ({ \
+	const char *file;   \
+	if (starpu_worker_get_type(starpu_worker_get_id()) == STARPU_CUDA_WORKER) \
+	{ \
+		file = strrchr(__FILE__,'/'); \
+		file += sizeof(char);\
+		_STARPU_TRACE_UNLOCKING_SPINLOCK(file,__LINE__); \
+	}\
+	_starpu_spin_unlock(lock); \
+	if (starpu_worker_get_type(starpu_worker_get_id()) == STARPU_CUDA_WORKER) \
+	{ \
+		file = strrchr(__FILE__,'/'); \
+		file += sizeof(char);\
+		_STARPU_TRACE_SPINLOCK_UNLOCKED(file,__LINE__); \
+	}\
+	0; \
+}) 
+
 
 #endif // __STARPU_SPINLOCK_H__

src/common/thread.c

@@ -84,19 +84,44 @@ int starpu_pthread_mutex_destroy(starpu_pthread_mutex_t *mutex)
 
 int starpu_pthread_mutex_lock(starpu_pthread_mutex_t *mutex)
 {
+	const char *file;   
+	file = strrchr(__FILE__,'/'); 
+	file += sizeof(char);
+	_STARPU_TRACE_LOCKING_MUTEX(file,__LINE__); 
+
 	if (!*mutex) STARPU_PTHREAD_MUTEX_INIT(mutex, NULL);
+	
 	xbt_mutex_acquire(*mutex);
+	file = strrchr(__FILE__,'/'); 
+	file += sizeof(char);
+	_STARPU_TRACE_MUTEX_LOCKED(file,__LINE__); 
+	
 	return 0;
 }
 
 int starpu_pthread_mutex_unlock(starpu_pthread_mutex_t *mutex)
 {
+	const char *file;   
+	file = strrchr(__FILE__,'/'); 
+	file += sizeof(char);
+	_STARPU_TRACE_UNLOCKING_MUTEX(file,__LINE__); 
+
 	xbt_mutex_release(*mutex);
+	
+	file = strrchr(__FILE__,'/'); 
+	file += sizeof(char);
+	_STARPU_TRACE_MUTEX_UNLOCKED(file,__LINE__); 
+	
 	return 0;
 }
 
 int starpu_pthread_mutex_trylock(starpu_pthread_mutex_t *mutex)
 {
+	const char *file;   
+	file = strrchr(__FILE__,'/'); 
+	file += sizeof(char);
+	_STARPU_TRACE_TRYLOCK_MUTEX(file,__LINE__); 
+
 	xbt_mutex_acquire(*mutex);
 	return 0;
 }
@@ -162,9 +187,19 @@ int starpu_pthread_cond_broadcast(starpu_pthread_cond_t *cond)
 
 int starpu_pthread_cond_wait(starpu_pthread_cond_t *cond, starpu_pthread_mutex_t *mutex)
 {
+	const char* file;													
+	file = strrchr(__FILE__,'/');							
+	file += sizeof(char);										
+	_STARPU_TRACE_COND_WAIT_BEGIN(file,__LINE__);			
+
 	if (!*cond)
 		STARPU_PTHREAD_COND_INIT(cond, NULL);
 	xbt_cond_wait(*cond, *mutex);
+	
+	file = strrchr(__FILE__,'/');							
+	file += sizeof(char);										
+	_STARPU_TRACE_COND_WAIT_END(file,__LINE__);			
+	
 	return 0;
 }
 
@@ -187,19 +222,159 @@ int starpu_pthread_rwlock_destroy(starpu_pthread_rwlock_t *rwlock)
 
 int starpu_pthread_rwlock_rdlock(starpu_pthread_rwlock_t *rwlock)
 {
-	return starpu_pthread_mutex_lock(rwlock);
+	const char* file;													
+	file = strrchr(__FILE__,'/');							
+	file += sizeof(char);										
+	_STARPU_TRACE_RDLOCKING_RWLOCK(file,__LINE__);			
+
+ 	int p_ret = starpu_pthread_mutex_lock(rwlock);
+	
+	file = strrchr(__FILE__,'/');							
+	file += sizeof(char);										
+	_STARPU_TRACE_RWLOCK_RDLOCKED(file,__LINE__);			
+	
+	return p_ret;
 }
 
 int starpu_pthread_rwlock_wrlock(starpu_pthread_rwlock_t *rwlock)
 {
-	return starpu_pthread_mutex_lock(rwlock);
+	const char* file;													
+	file = strrchr(__FILE__,'/');							
+	file += sizeof(char);										
+	_STARPU_TRACE_WRLOCKING_RWLOCK(file,__LINE__);			
+
+ 	int p_ret = starpu_pthread_mutex_lock(rwlock);
+	
+	file = strrchr(__FILE__,'/');							
+	file += sizeof(char);										
+	_STARPU_TRACE_RWLOCK_WRLOCKED(file,__LINE__);			
+	
+	return p_ret;
 }
 
 int starpu_pthread_rwlock_unlock(starpu_pthread_rwlock_t *rwlock)
 {
-	return starpu_pthread_mutex_unlock(rwlock);
+	const char* file;													
+	file = strrchr(__FILE__,'/');							
+	file += sizeof(char);										
+	_STARPU_TRACE_UNLOCKING_RWLOCK(file,__LINE__);			
+	
+ 	int p_ret = starpu_pthread_mutex_unlock(rwlock);
+	
+	file = strrchr(__FILE__,'/');							
+	file += sizeof(char);										
+	_STARPU_TRACE_RWLOCK_UNLOCKED(file,__LINE__);			
+	
+	return p_ret;
 }
 
+#elif !defined(_MSC_VER) /* !STARPU_SIMGRID */
+
+int starpu_pthread_mutex_lock(starpu_pthread_mutex_t *mutex)
+{
+	const char *file;   
+	file = strrchr(__FILE__,'/'); 
+	file += sizeof(char);
+	_STARPU_TRACE_LOCKING_MUTEX(file,__LINE__); 
+
+	pthread_mutex_lock(mutex);
+
+	file = strrchr(__FILE__,'/'); 
+	file += sizeof(char);
+	_STARPU_TRACE_MUTEX_LOCKED(file,__LINE__); 
+
+	return 0;
+}
+
+int starpu_pthread_mutex_unlock(starpu_pthread_mutex_t *mutex)
+{
+	const char *file;   
+	file = strrchr(__FILE__,'/'); 
+	file += sizeof(char);
+	_STARPU_TRACE_UNLOCKING_MUTEX(file,__LINE__); 
+
+	pthread_mutex_unlock(mutex);
+
+	file = strrchr(__FILE__,'/'); 
+	file += sizeof(char);
+	_STARPU_TRACE_MUTEX_UNLOCKED(file,__LINE__); 
+
+	return 0;
+}
+
+int starpu_pthread_mutex_trylock(starpu_pthread_mutex_t *mutex)
+{
+	const char *file;   
+	file = strrchr(__FILE__,'/'); 
+	file += sizeof(char);
+	_STARPU_TRACE_LOCKING_MUTEX(file,__LINE__); 
 
+	pthread_mutex_trylock(mutex);
+	return 0;
+}
+
+int starpu_pthread_cond_wait(starpu_pthread_cond_t *cond, starpu_pthread_mutex_t *mutex)
+{
+	const char* file;													
+	file = strrchr(__FILE__,'/');							
+	file += sizeof(char);										
+	_STARPU_TRACE_COND_WAIT_BEGIN(file,__LINE__);			
+
+ 	pthread_cond_wait(cond, mutex);
+
+	file = strrchr(__FILE__,'/');							
+	file += sizeof(char);										
+	_STARPU_TRACE_COND_WAIT_END(file,__LINE__);			
+
+	return 0;
+}
+
+int starpu_pthread_rwlock_rdlock(starpu_pthread_rwlock_t *rwlock)
+{
+	const char* file;													
+	file = strrchr(__FILE__,'/');							
+	file += sizeof(char);										
+	_STARPU_TRACE_RDLOCKING_RWLOCK(file,__LINE__);			
+
+ 	int p_ret = pthread_rwlock_rdlock(rwlock);
+	
+	file = strrchr(__FILE__,'/');							
+	file += sizeof(char);										
+	_STARPU_TRACE_RWLOCK_RDLOCKED(file,__LINE__);			
+
+	return p_ret;
+}
+
+int starpu_pthread_rwlock_wrlock(starpu_pthread_rwlock_t *rwlock)
+{
+	const char* file;													
+	file = strrchr(__FILE__,'/');							
+	file += sizeof(char);										
+	_STARPU_TRACE_WRLOCKING_RWLOCK(file,__LINE__);			
+
+ 	int p_ret = pthread_rwlock_wrlock(rwlock);
+	
+	file = strrchr(__FILE__,'/');							
+	file += sizeof(char);										
+	_STARPU_TRACE_RWLOCK_WRLOCKED(file,__LINE__);			
+	
+	return p_ret;
+}
+
+int starpu_pthread_rwlock_unlock(starpu_pthread_rwlock_t *rwlock)
+{
+	const char* file;													
+	file = strrchr(__FILE__,'/');							
+	file += sizeof(char);										
+	_STARPU_TRACE_UNLOCKING_RWLOCK(file,__LINE__);			
+
+ 	int p_ret = pthread_rwlock_unlock(rwlock);
+	
+	file = strrchr(__FILE__,'/');							
+	file += sizeof(char);										
+	_STARPU_TRACE_RWLOCK_UNLOCKED(file,__LINE__);			
+	
+	return p_ret;
+}
 
-#endif /* STARPU_SIMGRID */
+#endif /* STARPU_SIMGRID, _MSC_VER */

src/common/thread.h

@@ -19,6 +19,7 @@
 #define __COMMON_THREAD_H__
 
 #include <starpu.h>
+#include <common/fxt.h>
 
 #define _starpu_pthread_barrier_t pthread_barrier_t
 

src/datawizard/malloc.c

@@ -19,6 +19,7 @@
 
 #include <core/workers.h>
 #include <common/config.h>
+#include <common/fxt.h>
 #include <starpu.h>
 #include <drivers/opencl/driver_opencl.h>
 #include <datawizard/memory_manager.h>
@@ -94,9 +95,9 @@ int starpu_malloc_flags(void **A, size_t dim, int flags)
 			size_t freed;
 			size_t reclaim = 2 * dim;
 			_STARPU_DEBUG("There is not enough memory left, we are going to reclaim %ld\n", reclaim);
-			_STARPU_TRACE_START_MEMRECLAIM(0);
+			_STARPU_TRACE_START_MEMRECLAIM(0,0);
 			freed = _starpu_memory_reclaim_generic(0, 0, reclaim);
-			_STARPU_TRACE_END_MEMRECLAIM(0);
+			_STARPU_TRACE_END_MEMRECLAIM(0,0);
 			if (freed < dim)
 			{
 				// We could not reclaim enough memory
@@ -438,6 +439,11 @@ starpu_malloc_on_node(unsigned dst_node, size_t size)
 	if (addr == 0)
 	{
 		// Allocation failed, gives the memory back to the memory manager
+		const char* file;					
+		file = strrchr(__FILE__,'/');							
+		file += sizeof(char);										
+		_STARPU_TRACE_MEMORY_FULL(size);
+		printf("ENOMEM\n");
 		_starpu_memory_manager_deallocate_size(size, dst_node);
 	}
 	return addr;

src/datawizard/memalloc.c

@@ -853,14 +853,14 @@ static starpu_ssize_t _starpu_allocate_interface(starpu_data_handle_t handle, st
 			handle->busy_count++;
 			_starpu_spin_unlock(&handle->header_lock);
 
-			_STARPU_TRACE_START_MEMRECLAIM(dst_node);
+			_STARPU_TRACE_START_MEMRECLAIM(dst_node,is_prefetch);
 			if (is_prefetch)
 			{
 				flush_memchunk_cache(dst_node, reclaim);
 			}
 			else
 				_starpu_memory_reclaim_generic(dst_node, 0, reclaim);
-			_STARPU_TRACE_END_MEMRECLAIM(dst_node);
+			_STARPU_TRACE_END_MEMRECLAIM(dst_node,is_prefetch);
 
 		        while (_starpu_spin_trylock(&handle->header_lock))
 		                _starpu_datawizard_progress(_starpu_memory_node_get_local_key(), 0);

src/debug/traces/starpu_fxt.c

@@ -1549,6 +1549,63 @@ void starpu_fxt_parse_new_file(char *filename_in, struct starpu_fxt_options *opt
 				handle_task_wait_for_all();
 				break;
 
+			case _STARPU_FUT_LOCKING_MUTEX:
+				break;
+
+			case _STARPU_FUT_MUTEX_LOCKED:
+				break;
+
+			case _STARPU_FUT_UNLOCKING_MUTEX:
+				break;
+
+			case _STARPU_FUT_MUTEX_UNLOCKED:
+				break;
+
+			case _STARPU_FUT_TRYLOCK_MUTEX:
+				break;
+
+			case _STARPU_FUT_RDLOCKING_RWLOCK:
+				break;
+
+			case _STARPU_FUT_RWLOCK_RDLOCKED:
+				break;
+
+			case _STARPU_FUT_WRLOCKING_RWLOCK:
+				break;
+
+			case _STARPU_FUT_RWLOCK_WRLOCKED:
+				break;
+
+			case _STARPU_FUT_UNLOCKING_RWLOCK:
+				break;
+
+			case _STARPU_FUT_RWLOCK_UNLOCKED:
+				break;
+
+			case _STARPU_FUT_LOCKING_SPINLOCK:
+				break;
+
+			case _STARPU_FUT_SPINLOCK_LOCKED:
+				break;
+
+			case _STARPU_FUT_UNLOCKING_SPINLOCK:
+				break;
+
+			case _STARPU_FUT_SPINLOCK_UNLOCKED:
+				break;
+
+			case _STARPU_FUT_TRYLOCK_SPINLOCK:
+				break;
+
+			case _STARPU_FUT_COND_WAIT_BEGIN:
+				break;
+
+			case _STARPU_FUT_COND_WAIT_END:
+				break;
+
+			case _STARPU_FUT_MEMORY_FULL:
+				break;
+
 			default:
 #ifdef STARPU_VERBOSE
 				fprintf(stderr, "unknown event.. %x at time %llx WITH OFFSET %llx\n",

tests/Makefile.am

@@ -16,7 +16,7 @@
 # See the GNU Lesser General Public License in COPYING.LGPL for more details.
 
 AM_CFLAGS = $(HWLOC_CFLAGS) $(FXT_CFLAGS) -Wall $(STARPU_CUDA_CPPFLAGS) $(STARPU_OPENCL_CPPFLAGS) $(STARPU_COI_CPPFLAGS) $(GLOBAL_AM_CFLAGS) -Wno-unused
-LIBS = $(top_builddir)/src/@LIBSTARPU_LINK@ $(HWLOC_LIBS) @LIBS@
+LIBS = $(top_builddir)/src/@LIBSTARPU_LINK@ $(HWLOC_LIBS) $(FXT_LIBS) @LIBS@
 AM_CPPFLAGS = -I$(top_srcdir)/include/ -I$(top_builddir)/src -I$(top_srcdir)/src/
 AM_LDFLAGS = @STARPU_EXPORT_DYNAMIC@ $(STARPU_OPENCL_LDFLAGS) $(STARPU_CUDA_LDFLAGS) $(STARPU_COI_LDFLAGS) $(FXT_LDFLAGS)