src: memory_nodes function renaming

     _starpu_register_memory_node	->	_starpu_memory_node_register
     _starpu_memory_node_worker_add	->	_starpu_memory_node_add_nworkers
     _starpu_memory_node_workers	->	_starpu_memory_node_get_nworkers
     _starpu_memory_node_to_devid	->	_starpu_memory_node_get_devid
     _starpu_init_memory_nodes		->	_starpu_memory_nodes_init
     _starpu_deinit_memory_nodes	->	_starpu_memory_nodes_deinit
     struct _starpu_mem_node_descr	->	struct _starpu_memory_node_descr
     _starpu_set_local_memory_node_key	->	_starpu_memory_node_set_local_key
     _starpu_get_local_memory_node	->	_starpu_memory_node_get_local_key
     _starpu_get_memory_node_description	->     _starpu_memory_node_get_description

src/core/dependencies/data_concurrency.c

@@ -92,7 +92,7 @@ static unsigned _starpu_attempt_to_submit_data_request(unsigned request_from_cod
 	if (request_from_codelet)
 	{
 		while (_starpu_spin_trylock(&handle->header_lock))
-			_starpu_datawizard_progress(_starpu_get_local_memory_node(), 0);
+			_starpu_datawizard_progress(_starpu_memory_node_get_local_key(), 0);
 	}
 	else
 	{

src/core/simgrid.c

@@ -300,7 +300,7 @@ int _starpu_simgrid_transfer(size_t size, unsigned src_node, unsigned dst_node,
 	transfer->task = task;
 	transfer->src_node = src_node;
 	transfer->dst_node = dst_node;
-	transfer->run_node = _starpu_get_local_memory_node();
+	transfer->run_node = _starpu_memory_node_get_local_key();
 
 	if (req)
 	{

src/core/topology.c

@@ -756,7 +756,7 @@ _starpu_init_workers_binding (struct _starpu_machine_config *config)
 	/* note that even if the CPU cpu are not used, we always have a RAM
 	 * node */
 	/* TODO : support NUMA  ;) */
-	ram_memory_node = _starpu_register_memory_node(STARPU_CPU_RAM, -1);
+	ram_memory_node = _starpu_memory_node_register(STARPU_CPU_RAM, -1);
 
 #ifdef STARPU_SIMGRID
 	char name[16];
@@ -788,7 +788,7 @@ _starpu_init_workers_binding (struct _starpu_machine_config *config)
 			/* "dedicate" a cpu cpu to that worker */
 				is_a_set_of_accelerators = 0;
 				memory_node = ram_memory_node;
-				_starpu_memory_node_worker_add(ram_memory_node);
+				_starpu_memory_node_add_nworkers(ram_memory_node);
 				break;
 #if defined(STARPU_USE_CUDA) || defined(STARPU_SIMGRID)
 			case STARPU_CUDA_WORKER:
@@ -801,14 +801,14 @@ _starpu_init_workers_binding (struct _starpu_machine_config *config)
 				}
 #endif
 				is_a_set_of_accelerators = 0;
-				memory_node = _starpu_register_memory_node(STARPU_CUDA_RAM, workerarg->devid);
+				memory_node = _starpu_memory_node_register(STARPU_CUDA_RAM, workerarg->devid);
 #ifdef STARPU_SIMGRID
 				snprintf(name, sizeof(name), "CUDA%d", workerarg->devid);
 				host = MSG_get_host_by_name(name);
 				STARPU_ASSERT(host);
 				_starpu_simgrid_memory_node_set_host(memory_node, host);
 #endif
-				_starpu_memory_node_worker_add(memory_node);
+				_starpu_memory_node_add_nworkers(memory_node);
 
 				_starpu_register_bus(0, memory_node);
 				_starpu_register_bus(memory_node, 0);
@@ -839,14 +839,14 @@ _starpu_init_workers_binding (struct _starpu_machine_config *config)
 				}
 #endif
 				is_a_set_of_accelerators = 0;
-				memory_node = _starpu_register_memory_node(STARPU_OPENCL_RAM, workerarg->devid);
+				memory_node = _starpu_memory_node_register(STARPU_OPENCL_RAM, workerarg->devid);
 #ifdef STARPU_SIMGRID
 				snprintf(name, sizeof(name), "OpenCL%d", workerarg->devid);
 				host = MSG_get_host_by_name(name);
 				STARPU_ASSERT(host);
 				_starpu_simgrid_memory_node_set_host(memory_node, host);
 #endif
-				_starpu_memory_node_worker_add(memory_node);
+				_starpu_memory_node_add_nworkers(memory_node);
 				_starpu_register_bus(0, memory_node);
 				_starpu_register_bus(memory_node, 0);
 				break;
@@ -911,7 +911,7 @@ _starpu_build_topology (struct _starpu_machine_config *config)
 		return ret;
 
 	/* for the data management library */
-	_starpu_init_memory_nodes();
+	_starpu_memory_nodes_init();
 
 	_starpu_init_workers_binding(config);
 
@@ -923,7 +923,7 @@ _starpu_destroy_topology (
 	struct _starpu_machine_config *config __attribute__ ((unused)))
 {
 	/* cleanup StarPU internal data structures */
-	_starpu_deinit_memory_nodes();
+	_starpu_memory_nodes_deinit();
 
 	unsigned worker;
 	for (worker = 0; worker < config->topology.nworkers; worker++)

src/core/workers.c

@@ -329,7 +329,7 @@ void _starpu_worker_init(struct _starpu_worker *worker, unsigned fut_key)
 	_STARPU_DEBUG("worker %d cpuset start at %d\n", devid, hwloc_bitmap_first(worker->initial_hwloc_cpu_set));
 #endif
 
-	_starpu_set_local_memory_node_key(&worker->memory_node);
+	_starpu_memory_node_set_local_key(&worker->memory_node);
 
 	_starpu_set_local_worker_key(worker);
 

src/datawizard/coherency.c

@@ -158,7 +158,7 @@ static int worker_supports_direct_access(unsigned node, unsigned handling_node)
 	if (node == handling_node)
 		return 1;
 
-	if (!_starpu_memory_node_workers(handling_node))
+	if (!_starpu_memory_node_get_nworkers(handling_node))
 		/* No worker to process the request from that node */
 		return 0;
 
@@ -478,7 +478,7 @@ int _starpu_fetch_data_on_node(starpu_data_handle_t handle, struct _starpu_data_
 			       enum starpu_access_mode mode, unsigned detached, unsigned async,
 			       void (*callback_func)(void *), void *callback_arg)
 {
-	uint32_t local_node = _starpu_get_local_memory_node();
+	uint32_t local_node = _starpu_memory_node_get_local_key();
         _STARPU_LOG_IN();
 
 	while (_starpu_spin_trylock(&handle->header_lock))
@@ -551,7 +551,7 @@ void _starpu_release_data_on_node(starpu_data_handle_t handle, uint32_t default_
 	if ((wt_mask & ~(1<<memory_node)))
 		_starpu_write_through_data(handle, memory_node, wt_mask);
 
-	uint32_t local_node = _starpu_get_local_memory_node();
+	uint32_t local_node = _starpu_memory_node_get_local_key();
 	while (_starpu_spin_trylock(&handle->header_lock))
 		_starpu_datawizard_progress(local_node, 1);
 
@@ -623,7 +623,7 @@ int _starpu_fetch_task_input(struct _starpu_job *j, uint32_t mask)
 	struct starpu_buffer_descr *descrs = j->ordered_buffers;
 	unsigned nbuffers = task->cl->nbuffers;
 
-	unsigned local_memory_node = _starpu_get_local_memory_node();
+	unsigned local_memory_node = _starpu_memory_node_get_local_key();
 
 	int workerid = starpu_worker_get_id();
 
@@ -699,7 +699,7 @@ void _starpu_push_task_output(struct _starpu_job *j, uint32_t mask)
         unsigned nbuffers = task->cl->nbuffers;
 
 	int workerid = starpu_worker_get_id();
-	unsigned local_memory_node = _starpu_get_local_memory_node();
+	unsigned local_memory_node = _starpu_memory_node_get_local_key();
 
 	unsigned index;
 	for (index = 0; index < nbuffers; index++)

src/datawizard/copy_driver.c

@@ -37,7 +37,7 @@ void _starpu_wake_all_blocked_workers_on_node(unsigned nodeid)
 	/* wake up all workers on that memory node */
 	unsigned cond_id;
 
-	struct _starpu_mem_node_descr * const descr = _starpu_get_memory_node_description();
+	struct _starpu_memory_node_descr * const descr = _starpu_memory_node_get_description();
 
 	_STARPU_PTHREAD_RWLOCK_RDLOCK(&descr->conditions_rwlock);
 
@@ -61,7 +61,7 @@ void starpu_wake_all_blocked_workers(void)
 	/* workers may be blocked on the various queues' conditions */
 	unsigned cond_id;
 
-	struct _starpu_mem_node_descr * const descr = _starpu_get_memory_node_description();
+	struct _starpu_memory_node_descr * const descr = _starpu_memory_node_get_description();
 
 	_STARPU_PTHREAD_RWLOCK_RDLOCK(&descr->conditions_rwlock);
 
@@ -126,7 +126,7 @@ static int copy_data_1_to_1_generic(starpu_data_handle_t handle,
 	if ((src_kind == STARPU_CUDA_RAM) || (dst_kind == STARPU_CUDA_RAM))
 	{
 		int node = (dst_kind == STARPU_CUDA_RAM)?dst_node:src_node;
-		starpu_cuda_set_device(_starpu_memory_node_to_devid(node));
+		starpu_cuda_set_device(_starpu_memory_node_get_devid(node));
 	}
 #endif
 
@@ -141,7 +141,7 @@ static int copy_data_1_to_1_generic(starpu_data_handle_t handle,
 	case _STARPU_MEMORY_NODE_TUPLE(STARPU_CUDA_RAM,STARPU_CPU_RAM):
 		/* only the proper CUBLAS thread can initiate this directly ! */
 #if !defined(HAVE_CUDA_MEMCPY_PEER)
-		STARPU_ASSERT(_starpu_get_local_memory_node() == src_node);
+		STARPU_ASSERT(_starpu_memory_node_get_local_key() == src_node);
 #endif
 		STARPU_ASSERT(copy_methods->cuda_to_ram);
 		if (!req || !copy_methods->cuda_to_ram_async)
@@ -166,7 +166,7 @@ static int copy_data_1_to_1_generic(starpu_data_handle_t handle,
 		/* STARPU_CPU_RAM -> CUBLAS_RAM */
 		/* only the proper CUBLAS thread can initiate this ! */
 #if !defined(HAVE_CUDA_MEMCPY_PEER)
-		STARPU_ASSERT(_starpu_get_local_memory_node() == dst_node);
+		STARPU_ASSERT(_starpu_memory_node_get_local_key() == dst_node);
 #endif
 		STARPU_ASSERT(copy_methods->ram_to_cuda);
 		if (!req || !copy_methods->ram_to_cuda_async)
@@ -215,7 +215,7 @@ static int copy_data_1_to_1_generic(starpu_data_handle_t handle,
 #ifdef STARPU_USE_OPENCL
 	case _STARPU_MEMORY_NODE_TUPLE(STARPU_OPENCL_RAM,STARPU_CPU_RAM):
 		/* OpenCL -> RAM */
-		if (_starpu_get_local_memory_node() == src_node)
+		if (_starpu_memory_node_get_local_key() == src_node)
 		{
 			STARPU_ASSERT(copy_methods->opencl_to_ram);
 			if (!req || !copy_methods->opencl_to_ram_async)
@@ -237,7 +237,7 @@ static int copy_data_1_to_1_generic(starpu_data_handle_t handle,
 		break;
 	case _STARPU_MEMORY_NODE_TUPLE(STARPU_CPU_RAM,STARPU_OPENCL_RAM):
 		/* STARPU_CPU_RAM -> STARPU_OPENCL_RAM */
-		STARPU_ASSERT(_starpu_get_local_memory_node() == dst_node);
+		STARPU_ASSERT(_starpu_memory_node_get_local_key() == dst_node);
 		STARPU_ASSERT(copy_methods->ram_to_opencl);
 		if (!req || !copy_methods->ram_to_opencl_async)
 		{

src/datawizard/data_request.c

@@ -138,7 +138,7 @@ int _starpu_wait_data_request_completion(struct _starpu_data_request *r, unsigne
 	int retval;
 	int do_delete = 0;
 
-	uint32_t local_node = _starpu_get_local_memory_node();
+	uint32_t local_node = _starpu_memory_node_get_local_key();
 
 	do
 	{

src/datawizard/interfaces/bcsr_interface.c

@@ -206,7 +206,7 @@ size_t starpu_bcsr_get_elemsize(starpu_data_handle_t handle)
 uintptr_t starpu_bcsr_get_local_nzval(starpu_data_handle_t handle)
 {
 	unsigned node;
-	node = _starpu_get_local_memory_node();
+	node = _starpu_memory_node_get_local_key();
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 

src/datawizard/interfaces/block_interface.c

@@ -222,7 +222,7 @@ uint32_t starpu_block_get_nz(starpu_data_handle_t handle)
 uint32_t starpu_block_get_local_ldy(starpu_data_handle_t handle)
 {
 	unsigned node;
-	node = _starpu_get_local_memory_node();
+	node = _starpu_memory_node_get_local_key();
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
@@ -235,7 +235,7 @@ uint32_t starpu_block_get_local_ldy(starpu_data_handle_t handle)
 uint32_t starpu_block_get_local_ldz(starpu_data_handle_t handle)
 {
 	unsigned node;
-	node = _starpu_get_local_memory_node();
+	node = _starpu_memory_node_get_local_key();
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
@@ -248,7 +248,7 @@ uint32_t starpu_block_get_local_ldz(starpu_data_handle_t handle)
 uintptr_t starpu_block_get_local_ptr(starpu_data_handle_t handle)
 {
 	unsigned node;
-	node = _starpu_get_local_memory_node();
+	node = _starpu_memory_node_get_local_key();
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 

src/datawizard/interfaces/csr_interface.c

@@ -184,7 +184,7 @@ size_t starpu_csr_get_elemsize(starpu_data_handle_t handle)
 uintptr_t starpu_csr_get_local_nzval(starpu_data_handle_t handle)
 {
 	unsigned node;
-	node = _starpu_get_local_memory_node();
+	node = _starpu_memory_node_get_local_key();
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
@@ -197,7 +197,7 @@ uintptr_t starpu_csr_get_local_nzval(starpu_data_handle_t handle)
 uint32_t *starpu_csr_get_local_colind(starpu_data_handle_t handle)
 {
 	unsigned node;
-	node = _starpu_get_local_memory_node();
+	node = _starpu_memory_node_get_local_key();
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
@@ -210,7 +210,7 @@ uint32_t *starpu_csr_get_local_colind(starpu_data_handle_t handle)
 uint32_t *starpu_csr_get_local_rowptr(starpu_data_handle_t handle)
 {
 	unsigned node;
-	node = _starpu_get_local_memory_node();
+	node = _starpu_memory_node_get_local_key();
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
@@ -326,8 +326,8 @@ static int copy_cuda_peer(void *src_interface STARPU_ATTRIBUTE_UNUSED, unsigned
 	uint32_t nrow = src_csr->nrow;
 	size_t elemsize = src_csr->elemsize;
 
-	int src_dev = _starpu_memory_node_to_devid(src_node);
-	int dst_dev = _starpu_memory_node_to_devid(dst_node);
+	int src_dev = _starpu_memory_node_get_devid(src_node);
+	int dst_dev = _starpu_memory_node_get_devid(dst_node);
 
 	cudaError_t cures;
 
@@ -365,8 +365,8 @@ static int copy_cuda_peer_async(void *src_interface STARPU_ATTRIBUTE_UNUSED, uns
 
 	cudaError_t cures;
 
-	int src_dev = _starpu_memory_node_to_devid(src_node);
-	int dst_dev = _starpu_memory_node_to_devid(dst_node);
+	int src_dev = _starpu_memory_node_get_devid(src_node);
+	int dst_dev = _starpu_memory_node_get_devid(dst_node);
 
 	int synchronous_fallback = 0;
 

src/datawizard/interfaces/data_interface.c

@@ -354,7 +354,7 @@ void *starpu_handle_to_pointer(starpu_data_handle_t handle, uint32_t node)
 void *starpu_handle_get_local_ptr(starpu_data_handle_t handle)
 {
 	return starpu_handle_to_pointer(handle,
-					_starpu_get_local_memory_node());
+					_starpu_memory_node_get_local_key());
 }
 
 int starpu_data_get_rank(starpu_data_handle_t handle)
@@ -685,14 +685,14 @@ int starpu_data_interface_get_next_id(void)
 int starpu_handle_pack_data(starpu_data_handle_t handle, void **ptr, size_t *count)
 {
 	STARPU_ASSERT(handle->ops->pack_data);
-	return handle->ops->pack_data(handle, _starpu_get_local_memory_node(), ptr, count);
+	return handle->ops->pack_data(handle, _starpu_memory_node_get_local_key(), ptr, count);
 }
 
 int starpu_handle_unpack_data(starpu_data_handle_t handle, void *ptr, size_t count)
 {
 	STARPU_ASSERT(handle->ops->unpack_data);
 	int ret;
-	ret = handle->ops->unpack_data(handle, _starpu_get_local_memory_node(), ptr, count);
+	ret = handle->ops->unpack_data(handle, _starpu_memory_node_get_local_key(), ptr, count);
 	free(ptr);
 	return ret;
 }

src/datawizard/interfaces/matrix_interface.c

@@ -214,7 +214,7 @@ uint32_t starpu_matrix_get_ny(starpu_data_handle_t handle)
 uint32_t starpu_matrix_get_local_ld(starpu_data_handle_t handle)
 {
 	unsigned node;
-	node = _starpu_get_local_memory_node();
+	node = _starpu_memory_node_get_local_key();
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
@@ -227,7 +227,7 @@ uint32_t starpu_matrix_get_local_ld(starpu_data_handle_t handle)
 uintptr_t starpu_matrix_get_local_ptr(starpu_data_handle_t handle)
 {
 	unsigned node;
-	node = _starpu_get_local_memory_node();
+	node = _starpu_memory_node_get_local_key();
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
@@ -355,8 +355,8 @@ static int copy_cuda_peer(void *src_interface, unsigned src_node STARPU_ATTRIBUT
 	size_t elemsize = src_matrix->elemsize;
 	cudaError_t cures;
 
-	int src_dev = _starpu_memory_node_to_devid(src_node);
-	int dst_dev = _starpu_memory_node_to_devid(dst_node);
+	int src_dev = _starpu_memory_node_get_devid(src_node);
+	int dst_dev = _starpu_memory_node_get_devid(dst_node);
 
 
 #if 0

src/datawizard/interfaces/multiformat_interface.c

@@ -475,8 +475,8 @@ static int copy_cuda_peer_common(void *src_interface, unsigned src_node,
 
 	cudaError_t status;
 	int size = src_multiformat->nx * src_multiformat->ops->cuda_elemsize;
-	int src_dev = _starpu_memory_node_to_devid(src_node);
-	int dst_dev = _starpu_memory_node_to_devid(dst_node);
+	int src_dev = _starpu_memory_node_get_devid(src_node);
+	int dst_dev = _starpu_memory_node_get_devid(dst_node);
 
 	if (stream)
 	{

src/datawizard/interfaces/variable_interface.c

@@ -166,7 +166,7 @@ static size_t variable_interface_get_size(starpu_data_handle_t handle)
 uintptr_t starpu_variable_get_local_ptr(starpu_data_handle_t handle)
 {
 	unsigned node;
-	node = _starpu_get_local_memory_node();
+	node = _starpu_memory_node_get_local_key();
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
@@ -233,8 +233,8 @@ static int copy_cuda_to_cuda(void *src_interface, unsigned src_node, void *dst_i
 	else
 	{
 #ifdef HAVE_CUDA_MEMCPY_PEER
-		int src_dev = _starpu_memory_node_to_devid(src_node);
-		int dst_dev = _starpu_memory_node_to_devid(dst_node);
+		int src_dev = _starpu_memory_node_get_devid(src_node);
+		int dst_dev = _starpu_memory_node_get_devid(dst_node);
 
 		struct starpu_variable_interface *src_variable = src_interface;
 		struct starpu_variable_interface *dst_variable = dst_interface;
@@ -273,8 +273,8 @@ static int copy_cuda_to_cuda_async(void *src_interface, unsigned src_node, void
 	else
 	{
 #ifdef HAVE_CUDA_MEMCPY_PEER
-		int src_dev = _starpu_memory_node_to_devid(src_node);
-		int dst_dev = _starpu_memory_node_to_devid(dst_node);
+		int src_dev = _starpu_memory_node_get_devid(src_node);
+		int dst_dev = _starpu_memory_node_get_devid(dst_node);
 
 		struct starpu_variable_interface *src_variable = src_interface;
 		struct starpu_variable_interface *dst_variable = dst_interface;

src/datawizard/interfaces/vector_interface.c

@@ -192,7 +192,7 @@ uint32_t starpu_vector_get_nx(starpu_data_handle_t handle)
 uintptr_t starpu_vector_get_local_ptr(starpu_data_handle_t handle)
 {
 	unsigned node;
-	node = _starpu_get_local_memory_node();
+	node = _starpu_memory_node_get_local_key();
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
@@ -274,8 +274,8 @@ static int copy_cuda_peer_common(void *src_interface, unsigned src_node,
 
 	size_t length = src_vector->nx*src_vector->elemsize;
 
-	int src_dev = _starpu_memory_node_to_devid(src_node);
-	int dst_dev = _starpu_memory_node_to_devid(dst_node);
+	int src_dev = _starpu_memory_node_get_devid(src_node);
+	int dst_dev = _starpu_memory_node_get_devid(dst_node);
 
 	if (is_async)
 	{

src/datawizard/memalloc.c

@@ -75,7 +75,7 @@ static void lock_all_subtree(starpu_data_handle_t handle)
 	{
 		/* this is a leaf */
 		while (_starpu_spin_trylock(&handle->header_lock))
-			_starpu_datawizard_progress(_starpu_get_local_memory_node(), 0);
+			_starpu_datawizard_progress(_starpu_memory_node_get_local_key(), 0);
 	}
 	else
 	{
@@ -233,7 +233,7 @@ static size_t free_memory_on_node(struct _starpu_mem_chunk *mc, uint32_t node)
 	struct _starpu_data_replicate *replicate = mc->replicate;
 
 //	while (_starpu_spin_trylock(&handle->header_lock))
-//		_starpu_datawizard_progress(_starpu_get_local_memory_node());
+//		_starpu_datawizard_progress(_starpu_memory_node_get_local_key());
 
 #ifdef STARPU_DEVEL
 #warning can we block here ?
@@ -253,7 +253,7 @@ static size_t free_memory_on_node(struct _starpu_mem_chunk *mc, uint32_t node)
 			 * proper CUDA device in case it is needed. This avoids
 			 * having to set it again in the free method of each
 			 * interface. */
-			starpu_cuda_set_device(_starpu_memory_node_to_devid(node));
+			starpu_cuda_set_device(_starpu_memory_node_get_devid(node));
 		}
 #endif
 
@@ -325,7 +325,7 @@ static size_t try_to_free_mem_chunk(struct _starpu_mem_chunk *mc, unsigned node)
 		STARPU_ASSERT(mc->replicate);
 
 		while (_starpu_spin_trylock(&handle->header_lock))
-			_starpu_datawizard_progress(_starpu_get_local_memory_node(), 0);
+			_starpu_datawizard_progress(_starpu_memory_node_get_local_key(), 0);
 
 		if (mc->replicate->refcnt == 0)
 		{
@@ -740,7 +740,7 @@ static size_t _starpu_get_global_mem_size(int dst_node)
 #ifdef STARPU_USE_CUDA
 		case STARPU_CUDA_RAM:
 		{
-			int devid = _starpu_memory_node_to_devid(dst_node);
+			int devid = _starpu_memory_node_get_devid(dst_node);
 			global_mem_size = starpu_cuda_get_global_mem_size(devid);
 			break;
 		}
@@ -748,7 +748,7 @@ static size_t _starpu_get_global_mem_size(int dst_node)
 #ifdef STARPU_USE_OPENCL
 		case STARPU_OPENCL_RAM:
 		{
-			int devid = _starpu_memory_node_to_devid(dst_node);
+			int devid = _starpu_memory_node_get_devid(dst_node);
 			global_mem_size = starpu_opencl_get_global_mem_size(devid);
 			break;
 		}
@@ -968,7 +968,7 @@ static ssize_t _starpu_allocate_interface(starpu_data_handle_t handle, struct _s
 			 * proper CUDA device in case it is needed. This avoids
 			 * having to set it again in the malloc method of each
 			 * interface. */
-			starpu_cuda_set_device(_starpu_memory_node_to_devid(dst_node));
+			starpu_cuda_set_device(_starpu_memory_node_get_devid(dst_node));
 		}
 #endif
 
@@ -999,7 +999,7 @@ static ssize_t _starpu_allocate_interface(starpu_data_handle_t handle, struct _s
 			_STARPU_TRACE_END_MEMRECLAIM(dst_node);
 
 		        while (_starpu_spin_trylock(&handle->header_lock))
-		                _starpu_datawizard_progress(_starpu_get_local_memory_node(), 0);
+		                _starpu_datawizard_progress(_starpu_memory_node_get_local_key(), 0);
 
 			replicate->refcnt--;
 			STARPU_ASSERT(replicate->refcnt >= 0);

src/datawizard/memory_nodes.c

@@ -24,13 +24,13 @@
 #include "copy_driver.h"
 #include "memalloc.h"
 
-static struct _starpu_mem_node_descr descr;
+static struct _starpu_memory_node_descr descr;
 static _starpu_pthread_key_t memory_node_key;
 
-void _starpu_init_memory_nodes(void)
+void _starpu_memory_nodes_init(void)
 {
 	/* there is no node yet, subsequent nodes will be
-	 * added using _starpu_register_memory_node */
+	 * added using _starpu_memory_node_register */
 	descr.nnodes = 0;
 
 	_STARPU_PTHREAD_KEY_CREATE(&memory_node_key, NULL);
@@ -50,7 +50,7 @@ void _starpu_init_memory_nodes(void)
 	descr.total_condition_count = 0;
 }
 
-void _starpu_deinit_memory_nodes(void)
+void _starpu_memory_nodes_deinit(void)
 {
 	_starpu_deinit_data_request_lists();
 	_starpu_deinit_mem_chunk_lists();
@@ -58,12 +58,12 @@ void _starpu_deinit_memory_nodes(void)
 	_STARPU_PTHREAD_KEY_DELETE(memory_node_key);
 }
 
-void _starpu_set_local_memory_node_key(unsigned *node)
+void _starpu_memory_node_set_local_key(unsigned *node)
 {
 	_STARPU_PTHREAD_SETSPECIFIC(memory_node_key, node);
 }
 
-unsigned _starpu_get_local_memory_node(void)
+unsigned _starpu_memory_node_get_local_key(void)
 {
 	unsigned *memory_node;
 	memory_node = (unsigned *) _STARPU_PTHREAD_GETSPECIFIC(memory_node_key);
@@ -76,17 +76,17 @@ unsigned _starpu_get_local_memory_node(void)
 	return *memory_node;
 }
 
-void _starpu_memory_node_worker_add(unsigned node)
+void _starpu_memory_node_add_nworkers(unsigned node)
 {
 	descr.nworkers[node]++;
 }
 
-unsigned _starpu_memory_node_workers(unsigned node)
+unsigned _starpu_memory_node_get_nworkers(unsigned node)
 {
 	return descr.nworkers[node];
 }
 
-struct _starpu_mem_node_descr *_starpu_get_memory_node_description(void)
+struct _starpu_memory_node_descr *_starpu_memory_node_get_description(void)
 {
 	return &descr;
 }
@@ -96,7 +96,7 @@ enum starpu_node_kind starpu_node_get_kind(uint32_t node)
 	return descr.nodes[node];
 }
 
-int _starpu_memory_node_to_devid(unsigned node)
+int _starpu_memory_node_get_devid(unsigned node)
 {
 	return descr.devid[node];
 }
@@ -106,7 +106,7 @@ unsigned starpu_memory_nodes_get_count(void)
 	return descr.nnodes;
 }
 
-unsigned _starpu_register_memory_node(enum starpu_node_kind kind, int devid)
+unsigned _starpu_memory_node_register(enum starpu_node_kind kind, int devid)
 {
 	unsigned nnodes;
 	/* ATOMIC_ADD returns the new value ... */

src/datawizard/memory_nodes.h

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2009-2012  Université de Bordeaux 1
- * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011, 2013  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
@@ -38,7 +38,7 @@ struct _starpu_cond_and_mutex
         _starpu_pthread_mutex_t *mutex;
 };
 
-struct _starpu_mem_node_descr
+struct _starpu_memory_node_descr
 {
 	unsigned nnodes;
 	enum starpu_node_kind nodes[STARPU_MAXNODES];
@@ -52,7 +52,7 @@ struct _starpu_mem_node_descr
 	msg_host_t host[STARPU_MAXNODES];
 #endif
 
-	// TODO move this 2 lists outside struct _starpu_mem_node_descr
+	// TODO move this 2 lists outside struct _starpu_memory_node_descr
 	/* Every worker is associated to a condition variable on which the
 	 * worker waits when there is task available. It is possible that
 	 * multiple worker share the same condition variable, so we maintain a
@@ -67,23 +67,22 @@ struct _starpu_mem_node_descr
 
 };
 
-void _starpu_init_memory_nodes(void);
-void _starpu_deinit_memory_nodes(void);
-void _starpu_set_local_memory_node_key(unsigned *node);
-unsigned _starpu_get_local_memory_node(void);
-void _starpu_memory_node_worker_add(unsigned node);
-unsigned _starpu_memory_node_workers(unsigned node);
+void _starpu_memory_nodes_init(void);
+void _starpu_memory_nodes_deinit(void);
+void _starpu_memory_node_set_local_key(unsigned *node);
+unsigned _starpu_memory_node_get_local_key(void);
+void _starpu_memory_node_add_nworkers(unsigned node);
+unsigned _starpu_memory_node_get_nworkers(unsigned node);
 #ifdef STARPU_SIMGRID
 void _starpu_simgrid_memory_node_set_host(unsigned node, msg_host_t host);
 msg_host_t _starpu_simgrid_memory_node_get_host(unsigned node);
 #endif
-unsigned _starpu_register_memory_node(enum starpu_node_kind kind, int devid);
+unsigned _starpu_memory_node_register(enum starpu_node_kind kind, int devid);
 //void _starpu_memory_node_attach_queue(struct starpu_jobq_s *q, unsigned nodeid);
 void _starpu_memory_node_register_condition(_starpu_pthread_cond_t *cond, _starpu_pthread_mutex_t *mutex, unsigned memory_node);
 
-enum starpu_node_kind _starpu_node_get_kind(uint32_t node);
-int _starpu_memory_node_to_devid(unsigned node);
+int _starpu_memory_node_get_devid(unsigned node);
 
-struct _starpu_mem_node_descr *_starpu_get_memory_node_description(void);
+struct _starpu_memory_node_descr *_starpu_memory_node_get_description(void);
 
 #endif // __MEMORY_NODES_H__

src/drivers/cuda/driver_cuda.c

@@ -598,8 +598,8 @@ starpu_cuda_copy_async_sync(void *src_ptr, unsigned src_node,
 	{
 #ifdef HAVE_CUDA_MEMCPY_PEER
 		peer_copy = 1;
-		src_dev = _starpu_memory_node_to_devid(src_node);
-		dst_dev = _starpu_memory_node_to_devid(dst_node);
+		src_dev = _starpu_memory_node_get_devid(src_node);
+		dst_dev = _starpu_memory_node_get_devid(dst_node);
 #else
 		STARPU_ABORT();
 #endif

tools/dev/internal/rename_internal.sed

@@ -1,7 +1,7 @@
 # StarPU --- Runtime system for heterogeneous multicore architectures.
 #
 # Copyright (C) 2010  Université de Bordeaux 1
-# Copyright (C) 2010, 2011, 2012  Centre National de la Recherche Scientifique
+# Copyright (C) 2010, 2011, 2012, 2013  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
@@ -14,6 +14,17 @@
 #
 # See the GNU Lesser General Public License in COPYING.LGPL for more details.
 
+s/\b_starpu_register_memory_node\b/_starpu_memory_node_register/g
+s/\b_starpu_memory_node_worker_add\b/_starpu_memory_node_add_nworkers/g
+s/\b_starpu_memory_node_workers\b/_starpu_memory_node_get_nworkers/g
+s/\b_starpu_memory_node_to_devid\b/_starpu_memory_node_get_devid/g
+s/\b_starpu_init_memory_nodes\b/_starpu_memory_nodes_init/g
+s/\b_starpu_deinit_memory_nodes\b/_starpu_memory_nodes_deinit/g
+s/\bstruct _starpu_mem_node_descr\b/struct _starpu_memory_node_descr/g
+s/\b_starpu_set_local_memory_node_key\b/_starpu_memory_node_set_local_key/g
+s/\b_starpu_get_local_memory_node\b/_starpu_memory_node_get_local_key/g
+s/\b_starpu_get_memory_node_description\b/_starpu_memory_node_get_description/g
+
 s/\bheft_policy\b/_starpu_sched_heft_policy/g
 s/\bstruct starpu_priority_taskq_s\b/struct _starpu_priority_taskq/g
 s/\bSTARPU_FUT_APPS_KEY\b/_STARPU_FUT_APPS_KEY/g