src: rename internal types following coding conventions

src/core/dependencies/implicit_data_deps.c

@@ -31,7 +31,7 @@
 static void _starpu_add_reader_after_writer(starpu_data_handle_t handle, struct starpu_task *pre_sync_task, struct starpu_task *post_sync_task)
 {
 	/* Add this task to the list of readers */
-	struct starpu_task_wrapper_list *link = (struct starpu_task_wrapper_list *) malloc(sizeof(struct starpu_task_wrapper_list));
+	struct _starpu_task_wrapper_list *link = (struct _starpu_task_wrapper_list *) malloc(sizeof(struct _starpu_task_wrapper_list));
 	link->task = post_sync_task;
 	link->next = handle->last_submitted_readers;
 	handle->last_submitted_readers = link;
@@ -70,7 +70,7 @@ static void _starpu_add_writer_after_readers(starpu_data_handle_t handle, struct
 {
 	/* Count the readers */
 	unsigned nreaders = 0;
-	struct starpu_task_wrapper_list *l;
+	struct _starpu_task_wrapper_list *l;
 	l = handle->last_submitted_readers;
 	while (l)
 	{
@@ -89,7 +89,7 @@ static void _starpu_add_writer_after_readers(starpu_data_handle_t handle, struct
 		task_array[i++] = l->task;
 		_STARPU_DEP_DEBUG("dep %p -> %p\n", l->task, pre_sync_task);
 
-		struct starpu_task_wrapper_list *prev = l;
+		struct _starpu_task_wrapper_list *prev = l;
 		l = l->next;
 		free(prev);
 	}
@@ -100,7 +100,7 @@ static void _starpu_add_writer_after_readers(starpu_data_handle_t handle, struct
 		/* Declare all dependencies with ghost readers */
 		starpu_job_t pre_sync_job = _starpu_get_job_associated_to_task(pre_sync_task);
 
-		struct starpu_jobid_list *ghost_readers_id = handle->last_submitted_ghost_readers_id;
+		struct _starpu_jobid_list *ghost_readers_id = handle->last_submitted_ghost_readers_id;
 		while (ghost_readers_id)
 		{
 			unsigned long id = ghost_readers_id->id;
@@ -108,7 +108,7 @@ static void _starpu_add_writer_after_readers(starpu_data_handle_t handle, struct
 			_starpu_bound_job_id_dep(pre_sync_job, id);
 			_STARPU_DEP_DEBUG("dep ID%lu -> %p\n", id, pre_sync_task);
 
-			struct starpu_jobid_list *prev = ghost_readers_id;
+			struct _starpu_jobid_list *prev = ghost_readers_id;
 			ghost_readers_id = ghost_readers_id->next;
 			free(prev);
 		}
@@ -343,12 +343,12 @@ void _starpu_release_data_enforce_sequential_consistency(struct starpu_task *tas
 
 		/* Same if this is one of the readers: we go through the list
 		 * of readers and remove the task if it is found. */
-		struct starpu_task_wrapper_list *l;
+		struct _starpu_task_wrapper_list *l;
 		l = handle->last_submitted_readers;
-		struct starpu_task_wrapper_list *prev = NULL;
+		struct _starpu_task_wrapper_list *prev = NULL;
 		while (l)
 		{
-			struct starpu_task_wrapper_list *next = l->next;
+			struct _starpu_task_wrapper_list *next = l->next;
 
 			if (l->task == task)
 			{
@@ -361,7 +361,7 @@ void _starpu_release_data_enforce_sequential_consistency(struct starpu_task *tas
 				{
 					/* Save the job id of the reader task in the ghost reader linked list list */
 					starpu_job_t ghost_reader_job = _starpu_get_job_associated_to_task(task);
-					struct starpu_jobid_list *link = (struct starpu_jobid_list *) malloc(sizeof(struct starpu_jobid_list));
+					struct _starpu_jobid_list *link = (struct _starpu_jobid_list *) malloc(sizeof(struct _starpu_jobid_list));
 					STARPU_ASSERT(link);
 					link->next = handle->last_submitted_ghost_readers_id;
 					link->id = ghost_reader_job->job_id; 
@@ -403,7 +403,7 @@ void _starpu_add_post_sync_tasks(struct starpu_task *post_sync_task, starpu_data
 	{
 		handle->post_sync_tasks_cnt++;
 
-		struct starpu_task_wrapper_list *link = (struct starpu_task_wrapper_list *) malloc(sizeof(struct starpu_task_wrapper_list));
+		struct _starpu_task_wrapper_list *link = (struct _starpu_task_wrapper_list *) malloc(sizeof(struct _starpu_task_wrapper_list));
 		link->task = post_sync_task;
 		link->next = handle->post_sync_tasks;
 		handle->post_sync_tasks = link;		
@@ -415,7 +415,7 @@ void _starpu_add_post_sync_tasks(struct starpu_task *post_sync_task, starpu_data
 
 void _starpu_unlock_post_sync_tasks(starpu_data_handle_t handle)
 {
-	struct starpu_task_wrapper_list *post_sync_tasks = NULL;
+	struct _starpu_task_wrapper_list *post_sync_tasks = NULL;
 	unsigned do_submit_tasks = 0;
 
 	_STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
@@ -438,7 +438,7 @@ void _starpu_unlock_post_sync_tasks(starpu_data_handle_t handle)
 
 	if (do_submit_tasks)
 	{
-		struct starpu_task_wrapper_list *link = post_sync_tasks;
+		struct _starpu_task_wrapper_list *link = post_sync_tasks;
 
 		while (link) {
 			/* There is no need to depend on that task now, since it was already unlocked */

src/datawizard/coherency.c

@@ -331,7 +331,7 @@ starpu_data_request_t create_request_to_fetch_data(starpu_data_handle_t handle,
 	if (dst_replicate->state != STARPU_INVALID)
 	{
 #ifdef STARPU_MEMORY_STATUS
-		starpu_cache_state old_state = dst_replicate->state;
+		enum _starpu_cache_state old_state = dst_replicate->state;
 #endif
 		/* the data is already available so we can stop */
 		_starpu_update_data_state(handle, dst_replicate, mode);

src/datawizard/coherency.h

@@ -31,11 +31,11 @@
 #include <datawizard/interfaces/data_interface.h>
 #include <datawizard/datastats.h>
 
-typedef enum {
+enum _starpu_cache_state {
 	STARPU_OWNER,
 	STARPU_SHARED,
 	STARPU_INVALID
-} starpu_cache_state;
+};
 
 /* this should contain the information relative to a given data replicate  */
 LIST_TYPE(starpu_data_replicate,
@@ -55,7 +55,7 @@ LIST_TYPE(starpu_data_replicate,
 	unsigned initialized;
 
 	/* describes the state of the local data in term of coherency */
-	starpu_cache_state	state; 
+	enum _starpu_cache_state	state; 
 
 	int refcnt;
 
@@ -83,15 +83,15 @@ LIST_TYPE(starpu_data_replicate,
 
 struct starpu_data_requester_list_s;
 
-struct starpu_jobid_list {
+struct _starpu_jobid_list {
 	unsigned long id;
-	struct starpu_jobid_list *next;
+	struct _starpu_jobid_list *next;
 };
 
 /* This structure describes a simply-linked list of task */
-struct starpu_task_wrapper_list {
+struct _starpu_task_wrapper_list {
 	struct starpu_task *task;
-	struct starpu_task_wrapper_list *next;
+	struct _starpu_task_wrapper_list *next;
 };
 
 struct _starpu_data_state {
@@ -161,7 +161,7 @@ struct _starpu_data_state {
 	 * sequential_consistency flag is enabled. */
 	enum starpu_access_mode last_submitted_mode;
 	struct starpu_task *last_submitted_writer;
-	struct starpu_task_wrapper_list *last_submitted_readers;
+	struct _starpu_task_wrapper_list *last_submitted_readers;
 
 	/* If FxT is enabled, we keep track of "ghost dependencies": that is to
 	 * say the dependencies that are not needed anymore, but that should
@@ -171,9 +171,9 @@ struct _starpu_data_state {
 	 * enforce this dependency anymore.*/
 	unsigned last_submitted_ghost_writer_id_is_valid;
 	unsigned long last_submitted_ghost_writer_id;
-	struct starpu_jobid_list *last_submitted_ghost_readers_id;
+	struct _starpu_jobid_list *last_submitted_ghost_readers_id;
 	
-	struct starpu_task_wrapper_list *post_sync_tasks;
+	struct _starpu_task_wrapper_list *post_sync_tasks;
 	unsigned post_sync_tasks_cnt;
 
 	/*

src/datawizard/copy_driver.c

@@ -32,14 +32,14 @@ void _starpu_wake_all_blocked_workers_on_node(unsigned nodeid)
 	/* wake up all workers on that memory node */
 	unsigned cond_id;
 
-	starpu_mem_node_descr * const descr = _starpu_get_memory_node_description();
+	struct _starpu_mem_node_descr * const descr = _starpu_get_memory_node_description();
 
 	_STARPU_PTHREAD_RWLOCK_RDLOCK(&descr->conditions_rwlock);
 
 	unsigned nconds = descr->condition_count[nodeid];
 	for (cond_id = 0; cond_id < nconds; cond_id++)
 	{
-		struct _cond_and_mutex *condition;
+		struct _starpu_cond_and_mutex *condition;
 		condition  = &descr->conditions_attached_to_node[nodeid][cond_id];
 
 		/* wake anybody waiting on that condition */
@@ -56,14 +56,14 @@ void starpu_wake_all_blocked_workers(void)
 	/* workers may be blocked on the various queues' conditions */
 	unsigned cond_id;
 
-	starpu_mem_node_descr * const descr = _starpu_get_memory_node_description();
+	struct _starpu_mem_node_descr * const descr = _starpu_get_memory_node_description();
 
 	_STARPU_PTHREAD_RWLOCK_RDLOCK(&descr->conditions_rwlock);
 
 	unsigned nconds = descr->total_condition_count;
 	for (cond_id = 0; cond_id < nconds; cond_id++)
 	{
-		struct _cond_and_mutex *condition;
+		struct _starpu_cond_and_mutex *condition;
 		condition  = &descr->conditions_all[cond_id];
 
 		/* wake anybody waiting on that condition */
@@ -91,8 +91,8 @@ static int copy_data_1_to_1_generic(starpu_data_handle_t handle, struct starpu_d
 	unsigned src_node = src_replicate->memory_node;
 	unsigned dst_node = dst_replicate->memory_node;
 
-	starpu_node_kind src_kind = _starpu_get_node_kind(src_node);
-	starpu_node_kind dst_kind = _starpu_get_node_kind(dst_node);
+	enum _starpu_node_kind src_kind = _starpu_get_node_kind(src_node);
+	enum _starpu_node_kind dst_kind = _starpu_get_node_kind(dst_node);
 
 	STARPU_ASSERT(src_replicate->refcnt);
 	STARPU_ASSERT(dst_replicate->refcnt);
@@ -292,9 +292,9 @@ int __attribute__((warn_unused_result)) _starpu_driver_copy_data_1_to_1(starpu_d
 	return 0;
 }
 
-void _starpu_driver_wait_request_completion(struct starpu_async_channel *async_channel)
+void _starpu_driver_wait_request_completion(struct _starpu_async_channel *async_channel)
 {
-	starpu_node_kind kind = async_channel->type;
+	enum _starpu_node_kind kind = async_channel->type;
 #ifdef STARPU_USE_CUDA
 	cudaEvent_t event;
 	cudaError_t cures;
@@ -331,9 +331,9 @@ void _starpu_driver_wait_request_completion(struct starpu_async_channel *async_c
 	}
 }
 
-unsigned _starpu_driver_test_request_completion(struct starpu_async_channel *async_channel)
+unsigned _starpu_driver_test_request_completion(struct _starpu_async_channel *async_channel)
 {
-	starpu_node_kind kind = async_channel->type;
+	enum _starpu_node_kind kind = async_channel->type;
 	unsigned success;
 #ifdef STARPU_USE_CUDA
 	cudaEvent_t event;

src/datawizard/copy_driver.h

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010  Université de Bordeaux 1
- * Copyright (C) 2010  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011  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_data_replicate_s;
 
 /* this is a structure that can be queried to see whether an asynchronous
  * transfer has terminated or not */
-typedef union {
+union _starpu_async_channel_event {
 	int dummy;
 #ifdef STARPU_USE_CUDA
 	cudaEvent_t cuda_event;
@@ -46,11 +46,11 @@ typedef union {
 #ifdef STARPU_USE_OPENCL
         cl_event opencl_event;
 #endif
-} starpu_async_channel_event;
+};
 
-struct starpu_async_channel {
-	starpu_async_channel_event event;
-	starpu_node_kind type;
+struct _starpu_async_channel {
+	union _starpu_async_channel_event event;
+	enum _starpu_node_kind type;
 };
 
 void _starpu_wake_all_blocked_workers_on_node(unsigned nodeid);
@@ -62,6 +62,6 @@ int _starpu_driver_copy_data_1_to_1(starpu_data_handle_t handle,
 					struct starpu_data_request_s *req,
 					unsigned may_alloc);
 
-unsigned _starpu_driver_test_request_completion(struct starpu_async_channel *async_channel);
-void _starpu_driver_wait_request_completion(struct starpu_async_channel *async_channel);
+unsigned _starpu_driver_test_request_completion(struct _starpu_async_channel *async_channel);
+void _starpu_driver_wait_request_completion(struct _starpu_async_channel *async_channel);
 #endif // __COPY_DRIVER_H__

src/datawizard/data_request.c

@@ -209,7 +209,7 @@ void _starpu_data_request_append_callback(starpu_data_request_t r, void (*callba
 
 	if (callback_func)
 	{
-		struct callback_list *link = (struct callback_list *) malloc(sizeof(struct callback_list));
+		struct _starpu_callback_list *link = (struct _starpu_callback_list *) malloc(sizeof(struct _starpu_callback_list));
 		STARPU_ASSERT(link);
 
 		link->callback_func = callback_func;
@@ -231,7 +231,7 @@ static void starpu_handle_data_request_completion(starpu_data_request_t r)
 
 
 #ifdef STARPU_MEMORY_STATUS
-	starpu_cache_state old_src_replicate_state = src_replicate->state;
+	enum _starpu_cache_state old_src_replicate_state = src_replicate->state;
 #endif
 	_starpu_update_data_state(handle, r->dst_replicate, mode);
 
@@ -301,7 +301,7 @@ static void starpu_handle_data_request_completion(starpu_data_request_t r)
 	r->retval = 0;
 
 	/* In case there are one or multiple callbacks, we execute them now. */
-	struct callback_list *callbacks = r->callbacks;
+	struct _starpu_callback_list *callbacks = r->callbacks;
 	
 	_starpu_spin_unlock(&r->lock);
 
@@ -316,7 +316,7 @@ static void starpu_handle_data_request_completion(starpu_data_request_t r)
 	{
 		callbacks->callback_func(callbacks->callback_arg);
 
-		struct callback_list *next = callbacks->next;
+		struct _starpu_callback_list *next = callbacks->next;
 		free(callbacks);
 		callbacks = next;
 	}

src/datawizard/data_request.h

@@ -26,10 +26,10 @@
 
 struct starpu_data_replicate_s;
 
-struct callback_list {
+struct _starpu_callback_list {
 	void (*callback_func)(void *);
 	void *callback_arg;
-	struct callback_list *next;
+	struct _starpu_callback_list *next;
 };
 
 LIST_TYPE(starpu_data_request,
@@ -44,7 +44,7 @@ LIST_TYPE(starpu_data_request,
 
 	enum starpu_access_mode mode;
 
-	struct starpu_async_channel async_channel;
+	struct _starpu_async_channel async_channel;
 
 	unsigned completed;
 	unsigned prefetch;
@@ -59,7 +59,7 @@ LIST_TYPE(starpu_data_request,
 	/* who should perform the next request ? */
 	unsigned next_req_count;
 
-	struct callback_list *callbacks;
+	struct _starpu_callback_list *callbacks;
 
 #ifdef STARPU_USE_FXT
 	unsigned com_id;

src/datawizard/filters.c

@@ -327,7 +327,7 @@ void starpu_data_unpartition(starpu_data_handle_t root_handle, uint32_t gatherin
 	/* either shared or owned */
 	STARPU_ASSERT(nvalids > 0);
 
-	starpu_cache_state newstate = (nvalids == 1)?STARPU_OWNER:STARPU_SHARED;
+	enum _starpu_cache_state newstate = (nvalids == 1)?STARPU_OWNER:STARPU_SHARED;
 
 	for (node = 0; node < STARPU_MAXNODES; node++)
 	{

src/datawizard/interfaces/bcsr_interface.c

@@ -270,7 +270,7 @@ static ssize_t allocate_bcsr_buffer_on_node(void *data_interface_, uint32_t dst_
 	uint32_t r = bcsr_interface->r;
 	uint32_t c = bcsr_interface->c;
 
-	starpu_node_kind kind = _starpu_get_node_kind(dst_node);
+	enum _starpu_node_kind kind = _starpu_get_node_kind(dst_node);
 
 	switch(kind) {
 		case STARPU_CPU_RAM:
@@ -385,7 +385,7 @@ static void free_bcsr_buffer_on_node(void *data_interface, uint32_t node)
 {
 	struct starpu_bcsr_interface *bcsr_interface = (struct starpu_bcsr_interface *) data_interface;
 
-	starpu_node_kind kind = _starpu_get_node_kind(node);
+	enum _starpu_node_kind kind = _starpu_get_node_kind(node);
 	switch(kind) {
 		case STARPU_CPU_RAM:
 			free((void*)bcsr_interface->nzval);

src/datawizard/interfaces/block_interface.c

@@ -302,7 +302,7 @@ static ssize_t allocate_block_buffer_on_node(void *data_interface_, uint32_t dst
 	uint32_t nz = dst_block->nz;
 	size_t elemsize = dst_block->elemsize;
 
-	starpu_node_kind kind = _starpu_get_node_kind(dst_node);
+	enum _starpu_node_kind kind = _starpu_get_node_kind(dst_node);
 
 	switch(kind) {
 		case STARPU_CPU_RAM:
@@ -370,7 +370,7 @@ static void free_block_buffer_on_node(void *data_interface, uint32_t node)
 	cudaError_t status;
 #endif
 
-	starpu_node_kind kind = _starpu_get_node_kind(node);
+	enum _starpu_node_kind kind = _starpu_get_node_kind(node);
 	switch(kind) {
 		case STARPU_CPU_RAM:
 			free((void*)block_interface->ptr);

src/datawizard/interfaces/csr_interface.c

@@ -244,7 +244,7 @@ static ssize_t allocate_csr_buffer_on_node(void *data_interface_, uint32_t dst_n
 	uint32_t nrow = csr_interface->nrow;
 	size_t elemsize = csr_interface->elemsize;
 
-	starpu_node_kind kind = _starpu_get_node_kind(dst_node);
+	enum _starpu_node_kind kind = _starpu_get_node_kind(dst_node);
 
 	switch(kind) {
 		case STARPU_CPU_RAM:
@@ -359,7 +359,7 @@ static void free_csr_buffer_on_node(void *data_interface, uint32_t node)
 {
 	struct starpu_csr_interface *csr_interface = (struct starpu_csr_interface *) data_interface;
 
-	starpu_node_kind kind = _starpu_get_node_kind(node);
+	enum _starpu_node_kind kind = _starpu_get_node_kind(node);
 	switch(kind) {
 		case STARPU_CPU_RAM:
 			free((void*)csr_interface->nzval);

src/datawizard/interfaces/matrix_interface.c

@@ -282,7 +282,7 @@ static ssize_t allocate_matrix_buffer_on_node(void *data_interface_, uint32_t ds
 	uint32_t ld = nx; // by default
 	size_t elemsize = matrix_interface->elemsize;
 
-	starpu_node_kind kind = _starpu_get_node_kind(dst_node);
+	enum _starpu_node_kind kind = _starpu_get_node_kind(dst_node);
 
 	switch(kind) {
 		case STARPU_CPU_RAM:
@@ -348,7 +348,7 @@ static void free_matrix_buffer_on_node(void *data_interface, uint32_t node)
 	cudaError_t status;
 #endif
 
-	starpu_node_kind kind = _starpu_get_node_kind(node);
+	enum _starpu_node_kind kind = _starpu_get_node_kind(node);
 	switch(kind) {
 		case STARPU_CPU_RAM:
 			free((void*)matrix_interface->ptr);

src/datawizard/interfaces/multiformat_interface.c

@@ -229,7 +229,7 @@ static void free_multiformat_buffer_on_node(void *data_interface, uint32_t node)
 {
 	struct starpu_multiformat_interface *multiformat_interface;
 	multiformat_interface = (struct starpu_multiformat_interface *) data_interface;
-	starpu_node_kind kind = _starpu_get_node_kind(node);
+	enum _starpu_node_kind kind = _starpu_get_node_kind(node);
 
 	switch(kind) {
 		case STARPU_CPU_RAM:
@@ -260,7 +260,7 @@ static ssize_t allocate_multiformat_buffer_on_node(void *data_interface_, uint32
 	uintptr_t addr = 0;
 	ssize_t allocated_memory;
 
-	starpu_node_kind kind = _starpu_get_node_kind(dst_node);
+	enum _starpu_node_kind kind = _starpu_get_node_kind(dst_node);
 	switch(kind) {
 		case STARPU_CPU_RAM:
 			allocated_memory = multiformat_interface->nx * multiformat_interface->ops->cpu_elemsize;

src/datawizard/interfaces/variable_interface.c

@@ -202,7 +202,7 @@ static ssize_t allocate_variable_buffer_on_node(void *data_interface_, uint32_t
 
 	size_t elemsize = variable_interface->elemsize;
 
-	starpu_node_kind kind = _starpu_get_node_kind(dst_node);
+	enum _starpu_node_kind kind = _starpu_get_node_kind(dst_node);
 
 #ifdef STARPU_USE_CUDA
 	cudaError_t status;
@@ -257,7 +257,7 @@ static ssize_t allocate_variable_buffer_on_node(void *data_interface_, uint32_t
 
 static void free_variable_buffer_on_node(void *data_interface, uint32_t node)
 {
-	starpu_node_kind kind = _starpu_get_node_kind(node);
+	enum _starpu_node_kind kind = _starpu_get_node_kind(node);
 	switch(kind) {
 		case STARPU_CPU_RAM:
 			free((void*)STARPU_VARIABLE_GET_PTR(data_interface));

src/datawizard/interfaces/vector_interface.c

@@ -237,7 +237,7 @@ static ssize_t allocate_vector_buffer_on_node(void *data_interface_, uint32_t ds
 	uint32_t nx = vector_interface->nx;
 	size_t elemsize = vector_interface->elemsize;
 
-	starpu_node_kind kind = _starpu_get_node_kind(dst_node);
+	enum _starpu_node_kind kind = _starpu_get_node_kind(dst_node);
 
 #ifdef STARPU_USE_CUDA
 	cudaError_t status;
@@ -300,7 +300,7 @@ static void free_vector_buffer_on_node(void *data_interface, uint32_t node)
 	cudaError_t cures;
 #endif
 
-	starpu_node_kind kind = _starpu_get_node_kind(node);
+	enum _starpu_node_kind kind = _starpu_get_node_kind(node);
 	switch(kind) {
 		case STARPU_CPU_RAM:
 			free((void*)vector_interface->ptr);

src/datawizard/memalloc.c

@@ -685,7 +685,7 @@ void _starpu_request_mem_chunk_removal(starpu_data_handle_t handle, unsigned nod
 
 static size_t _starpu_get_global_mem_size(int dst_node)
 {
-	starpu_node_kind kind = _starpu_get_node_kind(dst_node);
+	enum _starpu_node_kind kind = _starpu_get_node_kind(dst_node);
 	size_t global_mem_size;
 
 	switch(kind)

src/datawizard/memory_nodes.c

@@ -23,7 +23,7 @@
 #include "copy_driver.h"
 #include "memalloc.h"
 
-static starpu_mem_node_descr descr;
+static struct _starpu_mem_node_descr descr;
 static pthread_key_t memory_node_key;
 
 void _starpu_init_memory_nodes(void)
@@ -83,12 +83,12 @@ unsigned _starpu_memory_node_workers(unsigned node)
 	return descr.nworkers[node];
 }
 
-starpu_mem_node_descr *_starpu_get_memory_node_description(void)
+struct _starpu_mem_node_descr *_starpu_get_memory_node_description(void)
 {
 	return &descr;
 }
 
-starpu_node_kind _starpu_get_node_kind(uint32_t node)
+enum _starpu_node_kind _starpu_get_node_kind(uint32_t node)
 {
 	return descr.nodes[node];
 }
@@ -103,7 +103,7 @@ unsigned _starpu_get_memory_nodes_count(void)
 	return descr.nnodes;
 }
 
-unsigned _starpu_register_memory_node(starpu_node_kind kind, int devid)
+unsigned _starpu_register_memory_node(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-2011  Université de Bordeaux 1
- * Copyright (C) 2010  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011  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
@@ -23,48 +23,46 @@
 #include <datawizard/coherency.h>
 #include <datawizard/memalloc.h>
 
-typedef enum {
+enum _starpu_node_kind {
 	STARPU_UNUSED     = 0x00,
 	STARPU_CPU_RAM    = 0x01,
 	STARPU_CUDA_RAM   = 0x02,
 	STARPU_OPENCL_RAM = 0x03,
 	STARPU_SPU_LS     = 0x04
-} starpu_node_kind;
-
-typedef starpu_node_kind starpu_memory_node_tuple;
+};
 
 #define _STARPU_MEMORY_NODE_TUPLE(node1,node2) (node1 | (node2 << 4))
 #define _STARPU_MEMORY_NODE_TUPLE_FIRST(tuple) (tuple & 0x0F)
 #define _STARPU_MEMORY_NODE_TUPLE_SECOND(tuple) (tuple & 0xF0)
 
-struct _cond_and_mutex {
+struct _starpu_cond_and_mutex {
         pthread_cond_t *cond;
-        pthread_mutex_t *mutex;	
+        pthread_mutex_t *mutex;
 };
 
-typedef struct {
+struct _starpu_mem_node_descr {
 	unsigned nnodes;
-	starpu_node_kind nodes[STARPU_MAXNODES];
+	enum _starpu_node_kind nodes[STARPU_MAXNODES];
 
 	/* Get the device id associated to this node, or -1 if not applicable */
 	int devid[STARPU_MAXNODES];
 
 	unsigned nworkers[STARPU_MAXNODES];
 
-	// TODO move this 2 lists outside starpu_mem_node_descr
+	// TODO move this 2 lists outside struct _starpu_mem_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
 	 * list of all these condition variables so that we can wake up all
 	 * worker attached to a memory node that are waiting on a task. */
 	pthread_rwlock_t conditions_rwlock;
-	struct _cond_and_mutex conditions_attached_to_node[STARPU_MAXNODES][STARPU_NMAXWORKERS];
-	struct _cond_and_mutex conditions_all[STARPU_MAXNODES*STARPU_NMAXWORKERS];
+	struct _starpu_cond_and_mutex conditions_attached_to_node[STARPU_MAXNODES][STARPU_NMAXWORKERS];
+	struct _starpu_cond_and_mutex conditions_all[STARPU_MAXNODES*STARPU_NMAXWORKERS];
 	/* the number of queues attached to each node */
 	unsigned total_condition_count;
 	unsigned condition_count[STARPU_MAXNODES];
 
-} starpu_mem_node_descr;
+};
 
 void _starpu_init_memory_nodes(void);
 void _starpu_deinit_memory_nodes(void);
@@ -72,14 +70,14 @@ 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);
-unsigned _starpu_register_memory_node(starpu_node_kind kind, int devid);
+unsigned _starpu_register_memory_node(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(pthread_cond_t *cond, pthread_mutex_t *mutex, unsigned memory_node);
 
-starpu_node_kind _starpu_get_node_kind(uint32_t node);
+enum _starpu_node_kind _starpu_get_node_kind(uint32_t node);
 int starpu_memory_node_to_devid(unsigned node);
 unsigned _starpu_get_memory_nodes_count(void);
 
-starpu_mem_node_descr *_starpu_get_memory_node_description(void);
+struct _starpu_mem_node_descr *_starpu_get_memory_node_description(void);
 
 #endif // __MEMORY_NODES_H__