memory stats: group all functions in new file src/datawizard/memstats.c and rename them to follow pattern starpu_memory_...

include/starpu_data.h

@@ -87,7 +87,7 @@ void starpu_data_release_on_node(starpu_data_handle_t handle, unsigned node);
 
 int starpu_malloc(void **A, size_t dim);
 int starpu_free(void *A);
-void starpu_display_memory_stats();
+void starpu_memory_display_stats();
 
 /* XXX These macros are provided to avoid breaking old codes. But consider
  * these function names as deprecated. */

src/Makefile.am

@@ -83,6 +83,7 @@ noinst_HEADERS = 						\
 	datawizard/filters.h					\
 	datawizard/write_back.h					\
 	datawizard/datastats.h					\
+	datawizard/memstats.h					\
 	datawizard/memalloc.h					\
 	datawizard/copy_driver.h				\
 	datawizard/coherency.h					\
@@ -170,6 +171,7 @@ libstarpu_@STARPU_EFFECTIVE_VERSION@_la_SOURCES = 						\
 	datawizard/filters.c					\
 	datawizard/sort_data_handles.c				\
 	datawizard/memalloc.c					\
+	datawizard/memstats.c					\
 	datawizard/footprint.c					\
 	datawizard/datastats.c					\
 	datawizard/user_interactions.c				\

src/core/workers.c

@@ -895,7 +895,7 @@ void starpu_shutdown(void)
 	     if (stats != 0)
 	     {
 		  // Display statistics on data which have not been unregistered
-		  starpu_display_memory_stats();
+		  starpu_memory_display_stats();
 	     }
 	}
 

src/datawizard/coherency.c

@@ -357,12 +357,12 @@ struct _starpu_data_request *_starpu_create_request_to_fetch_data(starpu_data_ha
 		_starpu_msi_cache_hit(requesting_node);
 
 #ifdef STARPU_MEMORY_STATS
-		_starpu_handle_stats_cache_hit(handle, requesting_node);
+		_starpu_memory_handle_stats_cache_hit(handle, requesting_node);
 
 		/* XXX Broken ? */
 		if (old_state == STARPU_SHARED
 		    && dst_replicate->state == STARPU_OWNER)
-			_starpu_handle_stats_shared_to_owner(handle, requesting_node);
+			_starpu_memory_handle_stats_shared_to_owner(handle, requesting_node);
 #endif
 
 		_starpu_memchunk_recently_used(dst_replicate->mc, requesting_node);

src/datawizard/coherency.h

@@ -30,6 +30,7 @@
 #include <datawizard/data_request.h>
 #include <datawizard/interfaces/data_interface.h>
 #include <datawizard/datastats.h>
+#include <datawizard/memstats.h>
 
 enum _starpu_cache_state
 {
@@ -210,14 +211,7 @@ struct _starpu_data_state
         int rank;
 	int tag;
 
-#ifdef STARPU_MEMORY_STATS
-	/* Handle access stats per node */
-	unsigned stats_direct_access[STARPU_MAXNODES];
-	unsigned stats_loaded_shared[STARPU_MAXNODES];
-	unsigned stats_loaded_owner[STARPU_MAXNODES];
-	unsigned stats_shared_to_owner[STARPU_MAXNODES];
-	unsigned stats_invalidated[STARPU_MAXNODES];
-#endif
+	_starpu_memory_stats_t memory_stats;
 
 	unsigned int mf_node; //XXX
 };

src/datawizard/data_request.c

@@ -245,7 +245,7 @@ static void starpu_handle_data_request_completion(struct _starpu_data_request *r
 	if (src_replicate->state == STARPU_INVALID)
 	{
 		if (old_src_replicate_state == STARPU_OWNER)
-			_starpu_handle_stats_invalidated(handle, src_replicate->memory_node);
+			_starpu_memory_handle_stats_invalidated(handle, src_replicate->memory_node);
 		else
 		{
 			/* XXX Currently only ex-OWNER are tagged as invalidated */
@@ -254,10 +254,10 @@ static void starpu_handle_data_request_completion(struct _starpu_data_request *r
 
 	}
 	if (dst_replicate->state == STARPU_SHARED)
-		_starpu_handle_stats_loaded_shared(handle, dst_replicate->memory_node);
+		_starpu_memory_handle_stats_loaded_shared(handle, dst_replicate->memory_node);
 	else if (dst_replicate->state == STARPU_OWNER)
 	{
-		_starpu_handle_stats_loaded_owner(handle, dst_replicate->memory_node);
+		_starpu_memory_handle_stats_loaded_owner(handle, dst_replicate->memory_node);
 	}
 #endif
 

src/datawizard/interfaces/data_interface.c

@@ -23,6 +23,7 @@
 #include <common/starpu_spinlock.h>
 #include <core/task.h>
 #include <core/workers.h>
+#include <datawizard/memstats.h>
 
 /* Entry in the `registered_handles' hash table.  */
 struct handle_entry
@@ -239,17 +240,11 @@ static starpu_data_handle_t _starpu_data_handle_allocate(struct starpu_data_inte
 
 	size_t interfacesize = interface_ops->interface_size;
 
+	_starpu_memory_stats_init(handle);
 	unsigned node;
 	for (node = 0; node < STARPU_MAXNODES; node++)
 	{
-#ifdef STARPU_MEMORY_STATS
-		/* Stats initilization */
-		handle->stats_direct_access[node]=0;
-		handle->stats_loaded_shared[node]=0;
-		handle->stats_shared_to_owner[node]=0;
-		handle->stats_loaded_owner[node]=0;
-		handle->stats_invalidated[node]=0;
-#endif
+		_starpu_memory_stats_init_per_node(handle, node);
 
 		struct _starpu_data_replicate *replicate;
 		replicate = &handle->per_node[node];
@@ -598,6 +593,7 @@ static void _starpu_data_unregister(starpu_data_handle_t handle, unsigned cohere
 		_starpu_request_mem_chunk_removal(handle, node, 1);
 	}
 
+	_starpu_memory_stats_free(handle);
 	_starpu_data_requester_list_delete(handle->req_list);
 	_starpu_data_requester_list_delete(handle->reduction_req_list);
 

src/datawizard/memalloc.c

@@ -346,7 +346,7 @@ static size_t try_to_free_mem_chunk(struct _starpu_mem_chunk *mc, unsigned node)
 
 #ifdef STARPU_MEMORY_STATS
 			if (handle->per_node[node].state == STARPU_OWNER)
-				_starpu_handle_stats_invalidated(handle, node);
+				_starpu_memory_handle_stats_invalidated(handle, node);
 			/* else XXX Considering only owner to invalidate */
 #endif
 
@@ -355,7 +355,7 @@ static size_t try_to_free_mem_chunk(struct _starpu_mem_chunk *mc, unsigned node)
 			transfer_subtree_to_node(handle, node, 0);
 
 #ifdef STARPU_MEMORY_STATS
-			_starpu_handle_stats_loaded_owner(handle, 0);
+			_starpu_memory_handle_stats_loaded_owner(handle, 0);
 #endif
 			STARPU_ASSERT(handle->per_node[node].refcnt == 0);
 
@@ -976,9 +976,8 @@ static void starpu_lru(unsigned node)
 	_STARPU_PTHREAD_RWLOCK_UNLOCK(&lru_rwlock[node]);
 }
 
-
 #ifdef STARPU_MEMORY_STATS
-void _starpu_display_memory_stats_by_node(int node)
+void _starpu_memory_display_stats_by_node(int node)
 {
 	_STARPU_PTHREAD_RWLOCK_WRLOCK(&mc_rwlock[node]);
 
@@ -993,7 +992,7 @@ void _starpu_display_memory_stats_by_node(int node)
 		     mc != _starpu_mem_chunk_list_end(mc_list[node]);
 		     mc = _starpu_mem_chunk_list_next(mc))
 		{
-			_starpu_display_memory_handle_stats(mc->data);
+			_starpu_memory_display_handle_stats(mc->data);
 		}
 
 	}
@@ -1002,7 +1001,7 @@ void _starpu_display_memory_stats_by_node(int node)
 }
 #endif
 
-void starpu_display_memory_stats(void)
+void starpu_memory_display_stats(void)
 {
 #ifdef STARPU_MEMORY_STATS
 	unsigned node;
@@ -1011,65 +1010,8 @@ void starpu_display_memory_stats(void)
 	fprintf(stderr, "Memory stats :\n");
 	for (node = 0; node < STARPU_MAXNODES; node++)
 	{
-	     _starpu_display_memory_stats_by_node(node);
+	     _starpu_memory_display_stats_by_node(node);
 	}
 	fprintf(stderr, "\n#---------------------\n");
 #endif
 }
-
-#ifdef STARPU_MEMORY_STATS
-void _starpu_display_memory_handle_stats(starpu_data_handle_t handle)
-{
-	unsigned node;
-
-	fprintf(stderr, "#-----\n");
-	fprintf(stderr, "Data : %p\n", handle);
-	fprintf(stderr, "Size : %d\n", (int)handle->data_size);
-	fprintf(stderr, "\n");
-
-	fprintf(stderr, "#--\n");
-	fprintf(stderr, "Data access stats\n");
-	fprintf(stderr, "/!\\ Work Underway\n");
-	for (node = 0; node < STARPU_MAXNODES; node++)
-	{
-		if (handle->stats_direct_access[node]+handle->stats_loaded_shared[node]
-		    +handle->stats_invalidated[node]+handle->stats_loaded_owner[node])
-		{
-			fprintf(stderr, "Node #%d\n", node);
-			fprintf(stderr, "\tDirect access : %d\n", handle->stats_direct_access[node]);
-			/* XXX Not Working yet. */
-			if (handle->stats_shared_to_owner[node])
-				fprintf(stderr, "\t\tShared to Owner : %d\n", handle->stats_shared_to_owner[node]);
-			fprintf(stderr, "\tLoaded (Owner) : %d\n", handle->stats_loaded_owner[node]);
-			fprintf(stderr, "\tLoaded (Shared) : %d\n", handle->stats_loaded_shared[node]);
-			fprintf(stderr, "\tInvalidated (was Owner) : %d\n\n", handle->stats_invalidated[node]);
-		}
-	}
-}
-
-void _starpu_handle_stats_cache_hit(starpu_data_handle_t handle, unsigned node)
-{
-	handle->stats_direct_access[node]++;
-}
-
-void _starpu_handle_stats_loaded_shared(starpu_data_handle_t handle, unsigned node)
-{
-	handle->stats_loaded_shared[node]++;
-}
-
-void _starpu_handle_stats_loaded_owner(starpu_data_handle_t handle, unsigned node)
-{
-	handle->stats_loaded_owner[node]++;
-}
-
-void _starpu_handle_stats_shared_to_owner(starpu_data_handle_t handle, unsigned node)
-{
-	handle->stats_shared_to_owner[node]++;
-}
-
-void _starpu_handle_stats_invalidated(starpu_data_handle_t handle, unsigned node)
-{
-	handle->stats_invalidated[node]++;
-}
-
-#endif

src/datawizard/memalloc.h

@@ -65,12 +65,5 @@ size_t _starpu_free_all_automatically_allocated_buffers(uint32_t node);
 void _starpu_memchunk_recently_used(struct _starpu_mem_chunk *mc, unsigned node);
 
 void _starpu_display_memory_stats_by_node(int node);
-void _starpu_display_memory_handle_stats(starpu_data_handle_t handle);
-
-void _starpu_handle_stats_cache_hit(starpu_data_handle_t handle, unsigned node);
-void _starpu_handle_stats_loaded_shared(starpu_data_handle_t handle, unsigned node);
-void _starpu_handle_stats_loaded_owner(starpu_data_handle_t handle, unsigned node);
-void _starpu_handle_stats_shared_to_owner(starpu_data_handle_t handle, unsigned node);
-void _starpu_handle_stats_invalidated(starpu_data_handle_t handle, unsigned node);
 
 #endif

src/datawizard/memstats.c

@@ -0,0 +1,107 @@
+/* StarPU --- Runtime system for heterogeneous multicore architectures.
+ *
+ * Copyright (C) 2009, 2010  Université de Bordeaux 1
+ * Copyright (C) 2010, 2011, 2012  Centre National de la Recherche Scientifique
+ *
+ * StarPU is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * StarPU is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * See the GNU Lesser General Public License in COPYING.LGPL for more details.
+ */
+
+#include <starpu.h>
+#include <datawizard/memstats.h>
+#include <common/config.h>
+#include <datawizard/coherency.h>
+
+void _starpu_memory_stats_init(starpu_data_handle_t handle)
+{
+#ifdef STARPU_MEMORY_STATS
+	handle->memory_stats = calloc(1, sizeof(struct _starpu_memory_stats));
+#endif
+}
+
+void _starpu_memory_stats_init_per_node(starpu_data_handle_t handle, unsigned node)
+{
+#ifdef STARPU_MEMORY_STATS
+	/* Stats initilization */
+	handle->memory_stats->direct_access[node]=0;
+	handle->memory_stats->loaded_shared[node]=0;
+	handle->memory_stats->shared_to_owner[node]=0;
+	handle->memory_stats->loaded_owner[node]=0;
+	handle->memory_stats->invalidated[node]=0;
+#endif
+}
+
+void _starpu_memory_stats_free(starpu_data_handle_t handle)
+{
+#ifdef STARPU_MEMORY_STATS
+	free(handle->memory_stats);
+#endif
+}
+
+#ifdef STARPU_MEMORY_STATS
+void _starpu_memory_display_handle_stats(starpu_data_handle_t handle)
+{
+	unsigned node;
+
+	fprintf(stderr, "#-----\n");
+	fprintf(stderr, "Data : %p\n", handle);
+	fprintf(stderr, "Size : %d\n", (int)handle->data_size);
+	fprintf(stderr, "\n");
+
+	fprintf(stderr, "#--\n");
+	fprintf(stderr, "Data access stats\n");
+	fprintf(stderr, "/!\\ Work Underway\n");
+	for (node = 0; node < STARPU_MAXNODES; node++)
+	{
+		if (handle->memory_stats->direct_access[node]+handle->memory_stats->loaded_shared[node]
+		    +handle->memory_stats->invalidated[node]+handle->memory_stats->loaded_owner[node])
+		{
+			fprintf(stderr, "Node #%d\n", node);
+			fprintf(stderr, "\tDirect access : %d\n", handle->memory_stats->direct_access[node]);
+			/* XXX Not Working yet. */
+			if (handle->memory_stats->shared_to_owner[node])
+				fprintf(stderr, "\t\tShared to Owner : %d\n", handle->memory_stats->shared_to_owner[node]);
+			fprintf(stderr, "\tLoaded (Owner) : %d\n", handle->memory_stats->loaded_owner[node]);
+			fprintf(stderr, "\tLoaded (Shared) : %d\n", handle->memory_stats->loaded_shared[node]);
+			fprintf(stderr, "\tInvalidated (was Owner) : %d\n\n", handle->memory_stats->invalidated[node]);
+		}
+	}
+}
+
+void _starpu_memory_handle_stats_cache_hit(starpu_data_handle_t handle, unsigned node)
+{
+	handle->memory_stats->direct_access[node]++;
+}
+
+void _starpu_memory_handle_stats_loaded_shared(starpu_data_handle_t handle, unsigned node)
+{
+	handle->memory_stats->loaded_shared[node]++;
+}
+
+void _starpu_memory_handle_stats_loaded_owner(starpu_data_handle_t handle, unsigned node)
+{
+	handle->memory_stats->loaded_owner[node]++;
+}
+
+void _starpu_memory_handle_stats_shared_to_owner(starpu_data_handle_t handle, unsigned node)
+{
+	handle->memory_stats->shared_to_owner[node]++;
+}
+
+void _starpu_memory_handle_stats_invalidated(starpu_data_handle_t handle, unsigned node)
+{
+	handle->memory_stats->invalidated[node]++;
+}
+
+#endif
+
+
+

src/datawizard/memstats.h

@@ -0,0 +1,53 @@
+/* StarPU --- Runtime system for heterogeneous multicore architectures.
+ *
+ * Copyright (C) 2009, 2010  Université de Bordeaux 1
+ * Copyright (C) 2010, 2011, 2012  Centre National de la Recherche Scientifique
+ *
+ * StarPU is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * StarPU is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * See the GNU Lesser General Public License in COPYING.LGPL for more details.
+ */
+
+#ifndef __MEMSTATS_H__
+#define __MEMSTATS_H__
+
+#include <starpu.h>
+#include <common/config.h>
+
+#ifdef STARPU_MEMORY_STATS
+struct _starpu_memory_stats
+{
+	/* Handle access stats per node */
+	unsigned direct_access[STARPU_MAXNODES];
+	unsigned loaded_shared[STARPU_MAXNODES];
+	unsigned loaded_owner[STARPU_MAXNODES];
+	unsigned shared_to_owner[STARPU_MAXNODES];
+	unsigned invalidated[STARPU_MAXNODES];
+};
+
+typedef	struct _starpu_memory_stats * _starpu_memory_stats_t;
+#else
+typedef void * _starpu_memory_stats_t;
+#endif
+
+void _starpu_memory_stats_init(starpu_data_handle_t handle);
+void _starpu_memory_stats_init_per_node(starpu_data_handle_t handle, unsigned node);
+
+void _starpu_memory_stats_free(starpu_data_handle_t handle);
+
+void _starpu_memory_display_handle_stats(starpu_data_handle_t handle);
+
+void _starpu_memory_handle_stats_cache_hit(starpu_data_handle_t handle, unsigned node);
+void _starpu_memory_handle_stats_loaded_shared(starpu_data_handle_t handle, unsigned node);
+void _starpu_memory_handle_stats_loaded_owner(starpu_data_handle_t handle, unsigned node);
+void _starpu_memory_handle_stats_shared_to_owner(starpu_data_handle_t handle, unsigned node);
+void _starpu_memory_handle_stats_invalidated(starpu_data_handle_t handle, unsigned node);
+
+#endif /* __MEMSTATS_H__ */