Rename public opaque type starpu_data_handle as starpu_data_handle_t

doc/chapters/advanced-api.texi

@@ -60,7 +60,7 @@ todo. The different fields are:
 @end table
 @end deftp
 
-@deftypefun void starpu_multiformat_data_register (starpu_data_handle *@var{handle}, uint32_t @var{home_node}, void *@var{ptr}, uint32_t @var{nobjects}, struct starpu_multiformat_data_interface_ops *@var{format_ops});
+@deftypefun void starpu_multiformat_data_register (starpu_data_handle_t *@var{handle}, uint32_t @var{home_node}, void *@var{ptr}, uint32_t @var{nobjects}, struct starpu_multiformat_data_interface_ops *@var{format_ops});
 Register a piece of data that can be represented in different ways, depending upon
 the processing unit that manipulates it. It allows the programmer, for instance, to
 use an array of structures when working on a CPU, and a structure of arrays when
@@ -72,7 +72,7 @@ the format.
 @example
 #define NX 1024
 struct point array_of_structs[NX];
-starpu_data_handle handle;
+starpu_data_handle_t handle;
 
 /*
  * The conversion of a piece of data is itself a task, though it is created,
@@ -327,7 +327,7 @@ Returns an estimated speedup factor relative to CPU speed
 Returns expected data transfer time in µs
 @end deftypefun
 
-@deftypefun double starpu_data_expected_transfer_time (starpu_data_handle @var{handle}, unsigned @var{memory_node}, {enum starpu_access_mode} @var{mode})
+@deftypefun double starpu_data_expected_transfer_time (starpu_data_handle_t @var{handle}, unsigned @var{memory_node}, {enum starpu_access_mode} @var{mode})
 Predict the transfer time (in µs) to move a handle to a memory node
 @end deftypefun
 

doc/chapters/advanced-examples.texi

@@ -137,7 +137,7 @@ An existing piece of data can be partitioned in sub parts to be used by differen
 @cartouche
 @smallexample
 int vector[NX];
-starpu_data_handle handle;
+starpu_data_handle_t handle;
 
 /* Declare data to StarPU */
 starpu_vector_data_register(&handle, 0, (uintptr_t)vector, NX, sizeof(vector[0]));
@@ -157,7 +157,7 @@ starpu_data_partition(handle, &f);
 /* Submit a task on each sub-vector */
 for (i=0; i<starpu_data_get_nb_children(handle); i++) @{
     /* Get subdata number i (there is only 1 dimension) */
-    starpu_data_handle sub_handle = starpu_data_get_sub_data(handle, 1, i);
+    starpu_data_handle_t sub_handle = starpu_data_get_sub_data(handle, 1, i);
     struct starpu_task *task = starpu_task_create();
 
     task->buffers[0].handle = sub_handle;

doc/chapters/basic-api.texi

@@ -295,15 +295,15 @@ This datatype describes a data access mode. The different available modes are:
 @end table
 @end deftp
 
-@deftp {Data Type} {starpu_data_handle}
-StarPU uses @code{starpu_data_handle} as an opaque handle to manage a piece of
+@deftp {Data Type} {starpu_data_handle_t}
+StarPU uses @code{starpu_data_handle_t} as an opaque handle to manage a piece of
 data. Once a piece of data has been registered to StarPU, it is associated to a
-@code{starpu_data_handle} which keeps track of the state of the piece of data
+@code{starpu_data_handle_t} which keeps track of the state of the piece of data
 over the entire machine, so that we can maintain data consistency and locate
 data replicates for instance.
 @end deftp
 
-@deftypefun void starpu_data_register (starpu_data_handle *@var{handleptr}, uint32_t @var{home_node}, void *@var{interface}, {struct starpu_data_interface_ops} *@var{ops})
+@deftypefun void starpu_data_register (starpu_data_handle_t *@var{handleptr}, uint32_t @var{home_node}, void *@var{interface}, {struct starpu_data_interface_ops} *@var{ops})
 Register a piece of data into the handle located at the @var{handleptr}
 address. The @var{interface} buffer contains the initial description of the
 data in the home node. The @var{ops} argument is a pointer to a structure
@@ -320,7 +320,7 @@ matrix) which can be registered by the means of helper functions (e.g.
 @code{starpu_vector_data_register} or @code{starpu_matrix_data_register}).
 @end deftypefun
 
-@deftypefun void starpu_data_unregister (starpu_data_handle @var{handle})
+@deftypefun void starpu_data_unregister (starpu_data_handle_t @var{handle})
 This function unregisters a data handle from StarPU. If the data was
 automatically allocated by StarPU because the home node was -1, all
 automatically allocated buffers are freed. Otherwise, a valid copy of the data
@@ -329,12 +329,12 @@ Using a data handle that has been unregistered from StarPU results in an
 undefined behaviour.
 @end deftypefun
 
-@deftypefun void starpu_data_unregister_no_coherency (starpu_data_handle @var{handle})
+@deftypefun void starpu_data_unregister_no_coherency (starpu_data_handle_t @var{handle})
 This is the same as starpu_data_unregister, except that StarPU does not put back
 a valid copy into the home node, in the buffer that was initially registered.
 @end deftypefun
 
-@deftypefun void starpu_data_invalidate (starpu_data_handle @var{handle})
+@deftypefun void starpu_data_invalidate (starpu_data_handle_t @var{handle})
 Destroy all replicates of the data handle. After data invalidation, the first
 access to the handle must be performed in write-only mode. Accessing an
 invalidated data in read-mode results in undefined behaviour.
@@ -342,12 +342,12 @@ invalidated data in read-mode results in undefined behaviour.
 
 @c TODO create a specific sections about user interaction with the DSM ?
 
-@deftypefun void starpu_data_set_wt_mask (starpu_data_handle @var{handle}, uint32_t @var{wt_mask})
+@deftypefun void starpu_data_set_wt_mask (starpu_data_handle_t @var{handle}, uint32_t @var{wt_mask})
 This function sets the write-through mask of a given data, i.e. a bitmask of
 nodes where the data should be always replicated after modification.
 @end deftypefun
 
-@deftypefun int starpu_data_prefetch_on_node (starpu_data_handle @var{handle}, unsigned @var{node}, unsigned @var{async})
+@deftypefun int starpu_data_prefetch_on_node (starpu_data_handle_t @var{handle}, unsigned @var{node}, unsigned @var{async})
 Issue a prefetch request for a given data to a given node, i.e.
 requests that the data be replicated to the given node, so that it is available
 there for tasks. If the @var{async} parameter is 0, the call will block until
@@ -355,31 +355,31 @@ the transfer is achieved, else the call will return as soon as the request is
 scheduled (which may however have to wait for a task completion).
 @end deftypefun
 
-@deftypefun starpu_data_handle starpu_data_lookup ({const void *}@var{ptr})
+@deftypefun starpu_data_handle_t starpu_data_lookup ({const void *}@var{ptr})
 todo
 @end deftypefun
 
-@deftypefun int starpu_data_request_allocation (starpu_data_handle @var{handle}, uint32_t @var{node})
+@deftypefun int starpu_data_request_allocation (starpu_data_handle_t @var{handle}, uint32_t @var{node})
 todo
 @end deftypefun
 
-@deftypefun void starpu_data_query_status (starpu_data_handle @var{handle}, int @var{memory_node}, {int *}@var{is_allocated}, {int *}@var{is_valid}, {int *}@var{is_requested})
+@deftypefun void starpu_data_query_status (starpu_data_handle_t @var{handle}, int @var{memory_node}, {int *}@var{is_allocated}, {int *}@var{is_valid}, {int *}@var{is_requested})
 Query the status of the handle on the specified memory node.
 @end deftypefun
 
-@deftypefun void starpu_data_advise_as_important (starpu_data_handle @var{handle}, unsigned @var{is_important})
+@deftypefun void starpu_data_advise_as_important (starpu_data_handle_t @var{handle}, unsigned @var{is_important})
 This function allows to specify that a piece of data can be discarded
 without impacting the application.
 @end deftypefun
 
-@deftypefun void starpu_data_set_reduction_methods (starpu_data_handle @var{handle}, {struct starpu_codelet_t *}@var{redux_cl}, {struct starpu_codelet_t *}@var{init_cl})
+@deftypefun void starpu_data_set_reduction_methods (starpu_data_handle_t @var{handle}, {struct starpu_codelet_t *}@var{redux_cl}, {struct starpu_codelet_t *}@var{init_cl})
 todo
 @end deftypefun
 
 @node Access registered data from the application
 @subsection Access registered data from the application
 
-@deftypefun int starpu_data_acquire (starpu_data_handle @var{handle}, {enum starpu_access_mode} @var{mode})
+@deftypefun int starpu_data_acquire (starpu_data_handle_t @var{handle}, {enum starpu_access_mode} @var{mode})
 The application must call this function prior to accessing registered data from
 main memory outside tasks. StarPU ensures that the application will get an
 up-to-date copy of the data in main memory located where the data was
@@ -398,7 +398,7 @@ tasks or from their callbacks (in that case, @code{starpu_data_acquire} returns
 @end deftypefun
 
 
-@deftypefun int starpu_data_acquire_cb (starpu_data_handle @var{handle}, {enum starpu_access_mode} @var{mode}, void (*@var{callback})(void *), void *@var{arg})
+@deftypefun int starpu_data_acquire_cb (starpu_data_handle_t @var{handle}, {enum starpu_access_mode} @var{mode}, void (*@var{callback})(void *), void *@var{arg})
 @code{starpu_data_acquire_cb} is the asynchronous equivalent of
 @code{starpu_data_release}. When the data specified in the first argument is
 available in the appropriate access mode, the callback function is executed.
@@ -412,7 +412,7 @@ be called from task callbacks. Upon successful completion, this function
 returns 0.
 @end deftypefun
 
-@deftypefun void STARPU_DATA_ACQUIRE_CB (starpu_data_handle @var{handle}, {enum starpu_access_mode} @var{mode}, code)
+@deftypefun void STARPU_DATA_ACQUIRE_CB (starpu_data_handle_t @var{handle}, {enum starpu_access_mode} @var{mode}, code)
 @code{STARPU_DATA_ACQUIRE_CB} is the same as @code{starpu_data_acquire_cb},
 except that the code to be executed in a callback is directly provided as a
 macro parameter, and the data handle is automatically released after it. This
@@ -420,7 +420,7 @@ permits to easily execute code which depends on the value of some registered
 data. This is non-blocking too and may be called from task callbacks.
 @end deftypefun
 
-@deftypefun void starpu_data_release (starpu_data_handle @var{handle})
+@deftypefun void starpu_data_release (starpu_data_handle_t @var{handle})
 This function releases the piece of data acquired by the application either by
 @code{starpu_data_acquire} or by @code{starpu_data_acquire_cb}.
 @end deftypefun
@@ -440,7 +440,7 @@ There are several ways to register a memory region so that it can be managed by
 StarPU.  The functions below allow the registration of vectors, 2D matrices, 3D
 matrices as well as  BCSR and CSR sparse matrices.
 
-@deftypefun void starpu_void_data_register ({starpu_data_handle *}@var{handle})
+@deftypefun void starpu_void_data_register ({starpu_data_handle_t *}@var{handle})
 Register a void interface. There is no data really associated to that
 interface, but it may be used as a synchronization mechanism. It also
 permits to express an abstract piece of data that is managed by the
@@ -449,31 +449,31 @@ concurrent execution of different tasks accessing the same "void" data
 in read-write concurrently.
 @end deftypefun
 
-@deftypefun void starpu_variable_data_register ({starpu_data_handle *}@var{handle}, uint32_t @var{home_node}, uintptr_t @var{ptr}, size_t @var{size})
+@deftypefun void starpu_variable_data_register ({starpu_data_handle_t *}@var{handle}, uint32_t @var{home_node}, uintptr_t @var{ptr}, size_t @var{size})
 Register the @var{size}-byte element pointed to by @var{ptr}, which is
 typically a scalar, and initialize @var{handle} to represent this data
 item.
 
 @smallexample
 float var;
-starpu_data_handle var_handle;
+starpu_data_handle_t var_handle;
 starpu_variable_data_register(&var_handle, 0, (uintptr_t)&var, sizeof(var));
 @end smallexample
 @end deftypefun
 
-@deftypefun void starpu_vector_data_register ({starpu_data_handle *}@var{handle}, uint32_t @var{home_node}, uintptr_t @var{ptr}, uint32_t @var{count}, size_t @var{size})
+@deftypefun void starpu_vector_data_register ({starpu_data_handle_t *}@var{handle}, uint32_t @var{home_node}, uintptr_t @var{ptr}, uint32_t @var{count}, size_t @var{size})
 Register the @var{count} @var{size}-byte elements pointed to by
 @var{ptr} and initialize @var{handle} to represent it.
 
 @example
 float vector[NX];
-starpu_data_handle vector_handle;
+starpu_data_handle_t vector_handle;
 starpu_vector_data_register(&vector_handle, 0, (uintptr_t)vector, NX,
                             sizeof(vector[0]));
 @end example
 @end deftypefun
 
-@deftypefun void starpu_matrix_data_register ({starpu_data_handle *}@var{handle}, uint32_t @var{home_node}, uintptr_t @var{ptr}, uint32_t @var{ld}, uint32_t @var{nx}, uint32_t @var{ny}, size_t @var{size})
+@deftypefun void starpu_matrix_data_register ({starpu_data_handle_t *}@var{handle}, uint32_t @var{home_node}, uintptr_t @var{ptr}, uint32_t @var{ld}, uint32_t @var{nx}, uint32_t @var{ny}, size_t @var{size})
 Register the @var{nx}x@var{ny} 2D matrix of @var{size}-byte elements
 pointed by @var{ptr} and initialize @var{handle} to represent it.
 @var{ld} specifies the number of extra elements present at the end of
@@ -482,14 +482,14 @@ alignment purposes.
 
 @example
 float *matrix;
-starpu_data_handle matrix_handle;
+starpu_data_handle_t matrix_handle;
 matrix = (float*)malloc(width * height * sizeof(float));
 starpu_matrix_data_register(&matrix_handle, 0, (uintptr_t)matrix,
                             width, width, height, sizeof(float));
 @end example
 @end deftypefun
 
-@deftypefun void starpu_block_data_register ({starpu_data_handle *}@var{handle}, uint32_t @var{home_node}, uintptr_t @var{ptr}, uint32_t @var{ldy}, uint32_t @var{ldz}, uint32_t @var{nx}, uint32_t @var{ny}, uint32_t @var{nz}, size_t @var{size})
+@deftypefun void starpu_block_data_register ({starpu_data_handle_t *}@var{handle}, uint32_t @var{home_node}, uintptr_t @var{ptr}, uint32_t @var{ldy}, uint32_t @var{ldz}, uint32_t @var{nx}, uint32_t @var{ny}, uint32_t @var{nz}, size_t @var{size})
 Register the @var{nx}x@var{ny}x@var{nz} 3D matrix of @var{size}-byte
 elements pointed by @var{ptr} and initialize @var{handle} to represent
 it.  Again, @var{ldy} and @var{ldz} specify the number of extra elements
@@ -497,26 +497,26 @@ present at the end of each row or column.
 
 @example
 float *block;
-starpu_data_handle block_handle;
+starpu_data_handle_t block_handle;
 block = (float*)malloc(nx*ny*nz*sizeof(float));
 starpu_block_data_register(&block_handle, 0, (uintptr_t)block,
                            nx, nx*ny, nx, ny, nz, sizeof(float));
 @end example
 @end deftypefun
 
-@deftypefun void starpu_bcsr_data_register (starpu_data_handle *@var{handle}, uint32_t @var{home_node}, uint32_t @var{nnz}, uint32_t @var{nrow}, uintptr_t @var{nzval}, uint32_t *@var{colind}, uint32_t *@var{rowptr}, uint32_t @var{firstentry}, uint32_t @var{r}, uint32_t @var{c}, size_t @var{elemsize})
+@deftypefun void starpu_bcsr_data_register (starpu_data_handle_t *@var{handle}, uint32_t @var{home_node}, uint32_t @var{nnz}, uint32_t @var{nrow}, uintptr_t @var{nzval}, uint32_t *@var{colind}, uint32_t *@var{rowptr}, uint32_t @var{firstentry}, uint32_t @var{r}, uint32_t @var{c}, size_t @var{elemsize})
 This variant of @code{starpu_data_register} uses the BCSR (Blocked
 Compressed Sparse Row Representation) sparse matrix interface.
 TODO
 @end deftypefun
 
-@deftypefun void starpu_csr_data_register (starpu_data_handle *@var{handle}, uint32_t @var{home_node}, uint32_t @var{nnz}, uint32_t @var{nrow}, uintptr_t @var{nzval}, uint32_t *@var{colind}, uint32_t *@var{rowptr}, uint32_t @var{firstentry}, size_t @var{elemsize})
+@deftypefun void starpu_csr_data_register (starpu_data_handle_t *@var{handle}, uint32_t @var{home_node}, uint32_t @var{nnz}, uint32_t @var{nrow}, uintptr_t @var{nzval}, uint32_t *@var{colind}, uint32_t *@var{rowptr}, uint32_t @var{firstentry}, size_t @var{elemsize})
 This variant of @code{starpu_data_register} uses the CSR (Compressed
 Sparse Row Representation) sparse matrix interface.
 TODO
 @end deftypefun
 
-@deftypefun {void *} starpu_data_get_interface_on_node (starpu_data_handle @var{handle}, unsigned @var{memory_node})
+@deftypefun {void *} starpu_data_get_interface_on_node (starpu_data_handle_t @var{handle}, unsigned @var{memory_node})
 todo
 @end deftypefun
 
@@ -555,29 +555,29 @@ The different values are:
 @node Accessing Handle
 @subsubsection Accessing Handle
 
-@deftypefun {void *}starpu_handle_to_pointer (starpu_data_handle @var{handle}, uint32_t @var{node})
+@deftypefun {void *}starpu_handle_to_pointer (starpu_data_handle_t @var{handle}, uint32_t @var{node})
 Return the pointer associated with @var{handle} on node @var{node} or
 @code{NULL} if @var{handle}'s interface does not support this
 operation or data for this handle is not allocated on that node.
 @end deftypefun
 
-@deftypefun {void *} starpu_handle_get_local_ptr (starpu_data_handle @var{handle})
+@deftypefun {void *} starpu_handle_get_local_ptr (starpu_data_handle_t @var{handle})
 Return the local pointer associated with @var{handle} or @code{NULL}
 if @var{handle}'s interface does not have data allocated locally
 @end deftypefun
 
-@deftypefun {enum starpu_data_interface_id} starpu_get_handle_interface_id (starpu_data_handle @var{handle})
+@deftypefun {enum starpu_data_interface_id} starpu_get_handle_interface_id (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
 @node Accessing Variable Data Interfaces
 @subsubsection Accessing Variable Data Interfaces
 
-@deftypefun size_t starpu_variable_get_elemsize (starpu_data_handle @var{handle})
+@deftypefun size_t starpu_variable_get_elemsize (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun uintptr_t starpu_variable_get_local_ptr (starpu_data_handle @var{handle})
+@deftypefun uintptr_t starpu_variable_get_local_ptr (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
@@ -592,15 +592,15 @@ todo
 @node Accessing Vector Data Interfaces
 @subsubsection Vector Data Interfaces
 
-@deftypefun uint32_t starpu_vector_get_nx (starpu_data_handle @var{handle})
+@deftypefun uint32_t starpu_vector_get_nx (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun size_t starpu_vector_get_elemsize (starpu_data_handle @var{handle})
+@deftypefun size_t starpu_vector_get_elemsize (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun uintptr_t starpu_vector_get_local_ptr (starpu_data_handle @var{handle})
+@deftypefun uintptr_t starpu_vector_get_local_ptr (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
@@ -619,23 +619,23 @@ todo
 @node Accessing Matrix Data Interfaces
 @subsubsection Matrix Data Interfaces
 
-@deftypefun uint32_t starpu_matrix_get_nx (starpu_data_handle @var{handle})
+@deftypefun uint32_t starpu_matrix_get_nx (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun uint32_t starpu_matrix_get_ny (starpu_data_handle @var{handle})
+@deftypefun uint32_t starpu_matrix_get_ny (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun uint32_t starpu_matrix_get_local_ld (starpu_data_handle @var{handle})
+@deftypefun uint32_t starpu_matrix_get_local_ld (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun uintptr_t starpu_matrix_get_local_ptr (starpu_data_handle @var{handle})
+@deftypefun uintptr_t starpu_matrix_get_local_ptr (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun size_t starpu_matrix_get_elemsize (starpu_data_handle @var{handle})
+@deftypefun size_t starpu_matrix_get_elemsize (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
@@ -662,31 +662,31 @@ todo
 @node Accessing Block Data Interfaces
 @subsubsection Block Data Interfaces
 
-@deftypefun uint32_t starpu_block_get_nx (starpu_data_handle @var{handle})
+@deftypefun uint32_t starpu_block_get_nx (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun uint32_t starpu_block_get_ny (starpu_data_handle @var{handle})
+@deftypefun uint32_t starpu_block_get_ny (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun uint32_t starpu_block_get_nz (starpu_data_handle @var{handle})
+@deftypefun uint32_t starpu_block_get_nz (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun uint32_t starpu_block_get_local_ldy (starpu_data_handle @var{handle})
+@deftypefun uint32_t starpu_block_get_local_ldy (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun uint32_t starpu_block_get_local_ldz (starpu_data_handle @var{handle})
+@deftypefun uint32_t starpu_block_get_local_ldz (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun uintptr_t starpu_block_get_local_ptr (starpu_data_handle @var{handle})
+@deftypefun uintptr_t starpu_block_get_local_ptr (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun size_t starpu_block_get_elemsize (starpu_data_handle @var{handle})
+@deftypefun size_t starpu_block_get_elemsize (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
@@ -721,39 +721,39 @@ todo
 @node Accessing BCSR Data Interfaces
 @subsubsection BCSR Data Interfaces
 
-@deftypefun uint32_t starpu_bcsr_get_nnz (starpu_data_handle @var{handle})
+@deftypefun uint32_t starpu_bcsr_get_nnz (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun uint32_t starpu_bcsr_get_nrow (starpu_data_handle @var{handle})
+@deftypefun uint32_t starpu_bcsr_get_nrow (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun uint32_t starpu_bcsr_get_firstentry (starpu_data_handle @var{handle})
+@deftypefun uint32_t starpu_bcsr_get_firstentry (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun uintptr_t starpu_bcsr_get_local_nzval (starpu_data_handle @var{handle})
+@deftypefun uintptr_t starpu_bcsr_get_local_nzval (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun {uint32_t *} starpu_bcsr_get_local_colind (starpu_data_handle @var{handle})
+@deftypefun {uint32_t *} starpu_bcsr_get_local_colind (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun {uint32_t *} starpu_bcsr_get_local_rowptr (starpu_data_handle @var{handle})
+@deftypefun {uint32_t *} starpu_bcsr_get_local_rowptr (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun uint32_t starpu_bcsr_get_r (starpu_data_handle @var{handle})
+@deftypefun uint32_t starpu_bcsr_get_r (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun uint32_t starpu_bcsr_get_c (starpu_data_handle @var{handle})
+@deftypefun uint32_t starpu_bcsr_get_c (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun size_t starpu_bcsr_get_elemsize (starpu_data_handle @var{handle})
+@deftypefun size_t starpu_bcsr_get_elemsize (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
@@ -761,31 +761,31 @@ todo
 @node Accessing CSR Data Interfaces
 @subsubsection CSR Data Interfaces
 
-@deftypefun uint32_t starpu_csr_get_nnz (starpu_data_handle @var{handle})
+@deftypefun uint32_t starpu_csr_get_nnz (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun uint32_t starpu_csr_get_nrow (starpu_data_handle @var{handle})
+@deftypefun uint32_t starpu_csr_get_nrow (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun uint32_t starpu_csr_get_firstentry (starpu_data_handle @var{handle})
+@deftypefun uint32_t starpu_csr_get_firstentry (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun uintptr_t starpu_csr_get_local_nzval (starpu_data_handle @var{handle})
+@deftypefun uintptr_t starpu_csr_get_local_nzval (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun {uint32_t *} starpu_csr_get_local_colind (starpu_data_handle @var{handle})
+@deftypefun {uint32_t *} starpu_csr_get_local_colind (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun {uint32_t *} starpu_csr_get_local_rowptr (starpu_data_handle @var{handle})
+@deftypefun {uint32_t *} starpu_csr_get_local_rowptr (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
-@deftypefun size_t starpu_csr_get_elemsize (starpu_data_handle @var{handle})
+@deftypefun size_t starpu_csr_get_elemsize (starpu_data_handle_t @var{handle})
 todo
 @end deftypefun
 
@@ -843,7 +843,7 @@ This is the number of parts to partition the data into.
 This returns the number of children. This can be used instead of @code{nchildren} when the number of
 children depends on the actual data (e.g. the number of blocks in a sparse
 matrix).
-@code{unsigned (*get_nchildren)(struct starpu_data_filter *, starpu_data_handle initial_handle);}
+@code{unsigned (*get_nchildren)(struct starpu_data_filter *, starpu_data_handle_t initial_handle);}
 @item @code{get_child_ops}
 In case the resulting children use a different data interface, this function
 returns which interface is used by child number @code{id}.
@@ -856,7 +856,7 @@ this is usually unused.
 @end table
 @end deftp
 
-@deftypefun void starpu_data_partition (starpu_data_handle @var{initial_handle}, {struct starpu_data_filter *}@var{f})
+@deftypefun void starpu_data_partition (starpu_data_handle_t @var{initial_handle}, {struct starpu_data_filter *}@var{f})
 @anchor{starpu_data_partition}
 This requests partitioning one StarPU data @var{initial_handle} into several
 subdata according to the filter @var{f}, as shown in the following example:
@@ -874,7 +874,7 @@ starpu_data_partition(A_handle, &f);
 @end cartouche
 @end deftypefun
 
-@deftypefun void starpu_data_unpartition (starpu_data_handle @var{root_data}, uint32_t @var{gathering_node})
+@deftypefun void starpu_data_unpartition (starpu_data_handle_t @var{root_data}, uint32_t @var{gathering_node})
 This unapplies one filter, thus unpartitioning the data. The pieces of data are
 collected back into one big piece in the @var{gathering_node} (usually 0).
 @cartouche
@@ -884,15 +884,15 @@ starpu_data_unpartition(A_handle, 0);
 @end cartouche
 @end deftypefun
 
-@deftypefun int starpu_data_get_nb_children (starpu_data_handle @var{handle})
+@deftypefun int starpu_data_get_nb_children (starpu_data_handle_t @var{handle})
 This function returns the number of children.
 @end deftypefun
 
-@deftypefun starpu_data_handle starpu_data_get_child (starpu_data_handle @var{handle}, unsigned @var{i})
+@deftypefun starpu_data_handle_t starpu_data_get_child (starpu_data_handle_t @var{handle}, unsigned @var{i})
 todo
 @end deftypefun
 
-@deftypefun starpu_data_handle starpu_data_get_sub_data (starpu_data_handle @var{root_data}, unsigned @var{depth}, ... )
+@deftypefun starpu_data_handle_t starpu_data_get_sub_data (starpu_data_handle_t @var{root_data}, unsigned @var{depth}, ... )
 After partitioning a StarPU data by applying a filter,
 @code{starpu_data_get_sub_data} can be used to get handles for each of
 the data portions. @var{root_data} is the parent data that was
@@ -908,16 +908,16 @@ h = starpu_data_get_sub_data(A_handle, 1, taskx);
 @end cartouche
 @end deftypefun
 
-@deftypefun starpu_data_handle starpu_data_vget_sub_data (starpu_data_handle @var{root_data}, unsigned @var{depth}, va_list @var{pa})
+@deftypefun starpu_data_handle_t starpu_data_vget_sub_data (starpu_data_handle_t @var{root_data}, unsigned @var{depth}, va_list @var{pa})
 This function is similar to @code{starpu_data_get_sub_data} but uses a
 va_list for the parameter list.
 @end deftypefun
 
-@deftypefun void starpu_data_map_filters (starpu_data_handle @var{root_data}, unsigned @var{nfilters}, ...)
+@deftypefun void starpu_data_map_filters (starpu_data_handle_t @var{root_data}, unsigned @var{nfilters}, ...)
 todo
 @end deftypefun
 
-@deftypefun void starpu_data_vmap_filters (starpu_data_handle @var{root_data}, unsigned @var{nfilters}, va_list @var{pa})
+@deftypefun void starpu_data_vmap_filters (starpu_data_handle_t @var{root_data}, unsigned @var{nfilters}, va_list @var{pa})
 todo
 @end deftypefun
 
@@ -1393,7 +1393,7 @@ Return the default sequential consistency flag
 This function returns the current default sequential consistency flag.
 @end deftypefun
 
-@deftypefun void starpu_data_set_sequential_consistency_flag (starpu_data_handle @var{handle}, unsigned @var{flag})
+@deftypefun void starpu_data_set_sequential_consistency_flag (starpu_data_handle_t @var{handle}, unsigned @var{flag})
 Sets the data consistency mode associated to a data handle. The consistency
 mode set using this function has the priority over the default mode which can
 be set with @code{starpu_data_set_sequential_consistency_flag}.
@@ -1691,7 +1691,7 @@ nothing yet.
 @node Miscellaneous helpers
 @section Miscellaneous helpers
 
-@deftypefun int starpu_data_cpy (starpu_data_handle @var{dst_handle}, starpu_data_handle @var{src_handle}, int @var{asynchronous}, void (*@var{callback_func})(void*), void *@var{callback_arg})
+@deftypefun int starpu_data_cpy (starpu_data_handle_t @var{dst_handle}, starpu_data_handle_t @var{src_handle}, int @var{asynchronous}, void (*@var{callback_func})(void*), void *@var{callback_arg})
 Copy the content of the @var{src_handle} into the @var{dst_handle} handle.
 The @var{asynchronous} parameter indicates whether the function should 
 block or not. In the case of an asynchronous call, it is possible to

doc/chapters/basic-examples.texi

@@ -258,7 +258,7 @@ The following lines show how to declare an array of @code{NX} elements of type
 @smallexample
 float vector[NX];
 
-starpu_data_handle vector_handle;
+starpu_data_handle_t vector_handle;
 starpu_vector_data_register(&vector_handle, 0, (uintptr_t)vector, NX,
                             sizeof(vector[0]));
 @end smallexample
@@ -512,7 +512,7 @@ int main(int argc, char **argv)
     int i, ret;
     float factor=3.0;
     struct starpu_task *task;
-    starpu_data_handle vector_handle;
+    starpu_data_handle_t vector_handle;
 
     starpu_init(NULL);                            /* @b{Initialising StarPU} */
 

doc/chapters/mpi-support.texi

@@ -13,7 +13,7 @@ The integration of MPI transfers within task parallelism is done in a
 very natural way by the means of asynchronous interactions between the
 application and StarPU.  This is implemented in a separate libstarpumpi library
 which basically provides "StarPU" equivalents of @code{MPI_*} functions, where
-@code{void *} buffers are replaced with @code{starpu_data_handle}s, and all
+@code{void *} buffers are replaced with @code{starpu_data_handle_t}s, and all
 GPU-RAM-NIC transfers are handled efficiently by StarPU-MPI.  The user has to
 use the usual @code{mpirun} command of the MPI implementation to start StarPU on
 the different MPI nodes.
@@ -67,23 +67,23 @@ by calling @code{starpu_mpi_initialize_extended}.
 
 @subsection Communication
 
-@deftypefun int starpu_mpi_send (starpu_data_handle @var{data_handle}, int @var{dest}, int @var{mpi_tag}, MPI_Comm @var{comm})
+@deftypefun int starpu_mpi_send (starpu_data_handle_t @var{data_handle}, int @var{dest}, int @var{mpi_tag}, MPI_Comm @var{comm})
 @end deftypefun
 
-@deftypefun int starpu_mpi_recv (starpu_data_handle @var{data_handle}, int @var{source}, int @var{mpi_tag}, MPI_Comm @var{comm}, MPI_Status *@var{status})
+@deftypefun int starpu_mpi_recv (starpu_data_handle_t @var{data_handle}, int @var{source}, int @var{mpi_tag}, MPI_Comm @var{comm}, MPI_Status *@var{status})
 @end deftypefun
 
-@deftypefun int starpu_mpi_isend (starpu_data_handle @var{data_handle}, starpu_mpi_req *@var{req}, int @var{dest}, int @var{mpi_tag}, MPI_Comm @var{comm})
+@deftypefun int starpu_mpi_isend (starpu_data_handle_t @var{data_handle}, starpu_mpi_req *@var{req}, int @var{dest}, int @var{mpi_tag}, MPI_Comm @var{comm})
 
 @end deftypefun
 
-@deftypefun int starpu_mpi_irecv (starpu_data_handle @var{data_handle}, starpu_mpi_req *@var{req}, int @var{source}, int @var{mpi_tag}, MPI_Comm @var{comm})
+@deftypefun int starpu_mpi_irecv (starpu_data_handle_t @var{data_handle}, starpu_mpi_req *@var{req}, int @var{source}, int @var{mpi_tag}, MPI_Comm @var{comm})
 @end deftypefun
 
-@deftypefun int starpu_mpi_isend_detached (starpu_data_handle @var{data_handle}, int @var{dest}, int @var{mpi_tag}, MPI_Comm @var{comm}, void (*@var{callback})(void *), void *@var{arg})
+@deftypefun int starpu_mpi_isend_detached (starpu_data_handle_t @var{data_handle}, int @var{dest}, int @var{mpi_tag}, MPI_Comm @var{comm}, void (*@var{callback})(void *), void *@var{arg})
 @end deftypefun
 
-@deftypefun int starpu_mpi_irecv_detached (starpu_data_handle @var{data_handle}, int @var{source}, int @var{mpi_tag}, MPI_Comm @var{comm}, void (*@var{callback})(void *), void *@var{arg})
+@deftypefun int starpu_mpi_irecv_detached (starpu_data_handle_t @var{data_handle}, int @var{source}, int @var{mpi_tag}, MPI_Comm @var{comm}, void (*@var{callback})(void *), void *@var{arg})
 @end deftypefun
 
 @deftypefun int starpu_mpi_wait (starpu_mpi_req *@var{req}, MPI_Status *@var{status})
@@ -95,19 +95,19 @@ by calling @code{starpu_mpi_initialize_extended}.
 @deftypefun int starpu_mpi_barrier (MPI_Comm @var{comm})
 @end deftypefun
 
-@deftypefun int starpu_mpi_isend_detached_unlock_tag (starpu_data_handle @var{data_handle}, int @var{dest}, int @var{mpi_tag}, MPI_Comm @var{comm}, starpu_tag @var{tag})
+@deftypefun int starpu_mpi_isend_detached_unlock_tag (starpu_data_handle_t @var{data_handle}, int @var{dest}, int @var{mpi_tag}, MPI_Comm @var{comm}, starpu_tag @var{tag})
 When the transfer is completed, the tag is unlocked
 @end deftypefun
 
-@deftypefun int starpu_mpi_irecv_detached_unlock_tag (starpu_data_handle @var{data_handle}, int @var{source}, int @var{mpi_tag}, MPI_Comm @var{comm}, starpu_tag @var{tag})
+@deftypefun int starpu_mpi_irecv_detached_unlock_tag (starpu_data_handle_t @var{data_handle}, int @var{source}, int @var{mpi_tag}, MPI_Comm @var{comm}, starpu_tag @var{tag})
 @end deftypefun
 
-@deftypefun int starpu_mpi_isend_array_detached_unlock_tag (unsigned @var{array_size}, starpu_data_handle *@var{data_handle}, int *@var{dest}, int *@var{mpi_tag}, MPI_Comm *@var{comm}, starpu_tag @var{tag})
+@deftypefun int starpu_mpi_isend_array_detached_unlock_tag (unsigned @var{array_size}, starpu_data_handle_t *@var{data_handle}, int *@var{dest}, int *@var{mpi_tag}, MPI_Comm *@var{comm}, starpu_tag @var{tag})
 Asynchronously send an array of buffers, and unlocks the tag once all
 of them are transmitted.
 @end deftypefun
 
-@deftypefun int starpu_mpi_irecv_array_detached_unlock_tag (unsigned @var{array_size}, starpu_data_handle *@var{data_handle}, int *@var{source}, int *@var{mpi_tag}, MPI_Comm *@var{comm}, starpu_tag @var{tag})
+@deftypefun int starpu_mpi_irecv_array_detached_unlock_tag (unsigned @var{array_size}, starpu_data_handle_t *@var{data_handle}, int *@var{source}, int *@var{mpi_tag}, MPI_Comm *@var{comm}, starpu_tag @var{tag})
 @end deftypefun
 
 @page
@@ -208,21 +208,21 @@ data. All MPI nodes then process the whole task graph, and StarPU automatically
 determines which node actually execute which task, as well as the required MPI
 transfers.
 
-@deftypefun int starpu_data_set_tag (starpu_data_handle @var{handle}, int @var{tag})
+@deftypefun int starpu_data_set_tag (starpu_data_handle_t @var{handle}, int @var{tag})
 Tell StarPU-MPI which MPI tag to use when exchanging the data.
 @end deftypefun
 
-@deftypefun int starpu_data_get_tag (starpu_data_handle @var{handle})
+@deftypefun int starpu_data_get_tag (starpu_data_handle_t @var{handle})
 Returns the MPI tag to be used when exchanging the data.
 @end deftypefun
 
-@deftypefun int starpu_data_set_rank (starpu_data_handle @var{handle}, int @var{mpi_rank})
+@deftypefun int starpu_data_set_rank (starpu_data_handle_t @var{handle}, int @var{mpi_rank})
 Tell StarPU-MPI which MPI node "owns" a given data, that is, the node which will
 always keep an up-to-date value, and will by default execute tasks which write
 to it.
 @end deftypefun
 
-@deftypefun int starpu_data_get_rank (starpu_data_handle @var{handle})
+@deftypefun int starpu_data_get_rank (starpu_data_handle_t @var{handle})
 Returns the last value set by @code{starpu_data_set_rank}.
 @end deftypefun
 
@@ -259,7 +259,7 @@ data twice to the same MPI node, unless the data has been modified.
 
 @end deftypefun
 
-@deftypefun void starpu_mpi_get_data_on_node (MPI_Comm @var{comm}, starpu_data_handle @var{data_handle}, int @var{node})
+@deftypefun void starpu_mpi_get_data_on_node (MPI_Comm @var{comm}, starpu_data_handle_t @var{data_handle}, int @var{node})
 todo
 @end deftypefun
 
@@ -298,7 +298,7 @@ data which will be needed by the tasks that we will execute.
 @cartouche
 @smallexample
     unsigned matrix[X][Y];
-    starpu_data_handle data_handles[X][Y];
+    starpu_data_handle_t data_handles[X][Y];
 
     for(x = 0; x < X; x++) @{
         for (y = 0; y < Y; y++) @{
@@ -349,14 +349,14 @@ automatically send the required data.
 @node MPI Collective Operations
 @section MPI Collective Operations
 
-@deftypefun int starpu_mpi_scatter_detached (starpu_data_handle *@var{data_handles}, int @var{count}, int @var{root}, MPI_Comm @var{comm})
+@deftypefun int starpu_mpi_scatter_detached (starpu_data_handle_t *@var{data_handles}, int @var{count}, int @var{root}, MPI_Comm @var{comm})
 Scatter data among processes of the communicator based on the ownership of
 the data. For each data of the array @var{data_handles}, the
 process @var{root} sends the data to the process owning this data.
 Processes receiving data must have valid data handles to receive them.
 @end deftypefun
 
-@deftypefun int starpu_mpi_gather_detached (starpu_data_handle *@var{data_handles}, int @var{count}, int @var{root}, MPI_Comm @var{comm})
+@deftypefun int starpu_mpi_gather_detached (starpu_data_handle_t *@var{data_handles}, int @var{count}, int @var{root}, MPI_Comm @var{comm})
 Gather data from the different processes of the communicator onto the
 process @var{root}. Each process owning data handle in the array
 @var{data_handles} will send them to the process @var{root}. The
@@ -377,7 +377,7 @@ if (rank == root)
 @}
 
 /* Allocate data handles and register data to StarPU */
-data_handles = malloc(nblocks*sizeof(starpu_data_handle *));
+data_handles = malloc(nblocks*sizeof(starpu_data_handle_t *));
 for(x = 0; x < nblocks ;  x++)
 @{
     int mpi_rank = my_distrib(x, nodes);

doc/chapters/vector_scal_c.texi

@@ -75,7 +75,7 @@ int main(int argc, char **argv)
      *  - the fourth argument is the number of elements in the vector
      *  - the fifth argument is the size of each element.
      */
-    starpu_data_handle vector_handle;
+    starpu_data_handle_t vector_handle;
     starpu_vector_data_register(&vector_handle, 0, (uintptr_t)vector,
                                 NX, sizeof(vector[0]));
 

doc/tutorial/vector_scal.c

@@ -94,7 +94,7 @@ int main(int argc, char **argv)
      *  - the fourth argument is the number of elements in the vector
      *  - the fifth argument is the size of each element.
      */
-    starpu_data_handle vector_handle;
+    starpu_data_handle_t vector_handle;
     starpu_vector_data_register(&vector_handle, 0, (uintptr_t)vector,
                                 NX, sizeof(vector[0]));
 

examples/audio/starpu_audio_processing.c

@@ -57,7 +57,7 @@ unsigned length_data;
 /* buffer containing input WAV data */
 float *A;
 
-starpu_data_handle A_handle;
+starpu_data_handle_t A_handle;
 
 /* For performance evaluation */
 static struct timeval start;

examples/axpy/axpy.c

@@ -41,7 +41,7 @@
 TYPE *vec_x, *vec_y;
 
 /* descriptors for StarPU */
-starpu_data_handle handle_y, handle_x;
+starpu_data_handle_t handle_y, handle_x;
 
 void axpy_cpu(void *descr[], __attribute__((unused)) void *arg)
 {

examples/basic_examples/block.c

@@ -36,7 +36,7 @@ typedef void (*device_func)(void **, void *);
 int execute_on(uint32_t where, device_func func, float *block, int pnx, int pny, int pnz, float multiplier)
 {
 	starpu_codelet cl = {};
-	starpu_data_handle block_handle;
+	starpu_data_handle_t block_handle;
         int i;
 
 	starpu_block_data_register(&block_handle, 0, (uintptr_t)block, pnx, pnx*pny, pnx, pny, pnz, sizeof(float));

examples/basic_examples/mult.c

@@ -41,7 +41,7 @@
 #include <starpu.h>
 
 static float *A, *B, *C;
-static starpu_data_handle A_handle, B_handle, C_handle;
+static starpu_data_handle_t A_handle, B_handle, C_handle;
 
 static unsigned nslicesx = 4;
 static unsigned nslicesy = 4;

examples/basic_examples/multiformat.c

@@ -20,7 +20,7 @@
 #include "multiformat_types.h"
 
 static struct point array_of_structs[N_ELEMENTS];
-static starpu_data_handle array_of_structs_handle;
+static starpu_data_handle_t array_of_structs_handle;
 
 static void
 multiformat_scal_cpu_func(void *buffers[], void *args)

examples/basic_examples/variable.c

@@ -38,7 +38,7 @@ int main(int argc, char **argv)
 {
 	unsigned i;
         float foo;
-	starpu_data_handle float_array_handle;
+	starpu_data_handle_t float_array_handle;
 	starpu_codelet cl = {};
 
 	starpu_init(NULL);

examples/basic_examples/vector_scal.c

@@ -113,7 +113,7 @@ int main(int argc, char **argv)
 	 *  - the fourth argument is the number of elements in the vector
 	 *  - the fifth argument is the size of each element.
 	 */
-	starpu_data_handle vector_handle;
+	starpu_data_handle_t vector_handle;
 	starpu_vector_data_register(&vector_handle, 0, (uintptr_t)vector, NX, sizeof(vector[0]));
 
 	float factor = 3.14;

examples/basic_examples/vector_scal_c.c

@@ -70,7 +70,7 @@ void compute_(int *F_NX, float *vector)
 	 *  - the fourth argument is the number of elements in the vector
 	 *  - the fifth argument is the size of each element.
 	 */
-	starpu_data_handle vector_handle;
+	starpu_data_handle_t vector_handle;
 	starpu_vector_data_register(&vector_handle, 0, (uintptr_t)vector, NX, sizeof(vector[0]));
 
 	float factor = 3.14;

examples/callback/callback.c

@@ -21,7 +21,7 @@
 
 #define FPRINTF(ofile, fmt, args ...) do { if (!getenv("STARPU_SSILENT")) {fprintf(ofile, fmt, ##args); }} while(0)
 
-starpu_data_handle handle;
+starpu_data_handle_t handle;
 
 void cpu_codelet(void *descr[], __attribute__ ((unused)) void *_args)
 {

examples/cg/cg.c

@@ -72,16 +72,16 @@ static int long long n = 1024;
 static int nblocks = 8;
 static int use_reduction = 1;
 
-static starpu_data_handle A_handle, b_handle, x_handle;
+static starpu_data_handle_t A_handle, b_handle, x_handle;
 static TYPE *A, *b, *x;
 
 static int i_max = 4000;
 static double eps = (10e-14);
 
-static starpu_data_handle r_handle, d_handle, q_handle;
+static starpu_data_handle_t r_handle, d_handle, q_handle;
 static TYPE *r, *d, *q;
 
-static starpu_data_handle dtq_handle, rtr_handle;
+static starpu_data_handle_t dtq_handle, rtr_handle;
 static TYPE dtq, rtr;
 
 extern starpu_codelet accumulate_variable_cl;
@@ -208,7 +208,7 @@ static void partition_data(void)
  */
 
 #if 0
-static void display_vector(starpu_data_handle handle, TYPE *ptr)
+static void display_vector(starpu_data_handle_t handle, TYPE *ptr)
 {
 	unsigned block_size = n / nblocks;
 

examples/cg/cg.h

@@ -57,29 +57,29 @@
 #define cublasscal	cublasSscal
 #endif
 
-void dot_kernel(starpu_data_handle v1,
-                starpu_data_handle v2,
-                starpu_data_handle s,
+void dot_kernel(starpu_data_handle_t v1,
+                starpu_data_handle_t v2,
+                starpu_data_handle_t s,
 		unsigned nblocks,
 		int use_reduction);
 
-void gemv_kernel(starpu_data_handle v1,
-                starpu_data_handle matrix, 
-                starpu_data_handle v2,
+void gemv_kernel(starpu_data_handle_t v1,
+                starpu_data_handle_t matrix, 
+                starpu_data_handle_t v2,
                 TYPE p1, TYPE p2,
 		unsigned nblocks,
 		int use_reduction);
 
-void axpy_kernel(starpu_data_handle v1,
-		starpu_data_handle v2, TYPE p1,
+void axpy_kernel(starpu_data_handle_t v1,
+		starpu_data_handle_t v2, TYPE p1,
 		unsigned nblocks);
 
-void scal_axpy_kernel(starpu_data_handle v1, TYPE p1,
-			starpu_data_handle v2, TYPE p2,
+void scal_axpy_kernel(starpu_data_handle_t v1, TYPE p1,
+			starpu_data_handle_t v2, TYPE p2,
 			unsigned nblocks);
 
-void copy_handle(starpu_data_handle dst,
-		starpu_data_handle src,
+void copy_handle(starpu_data_handle_t dst,
+		starpu_data_handle_t src,
 		unsigned nblocks);
 
 #endif /* __STARPU_EXAMPLE_CG_H__ */

examples/cg/cg_kernels.c

@@ -245,9 +245,9 @@ static starpu_codelet dot_kernel_cl = {
 	.model = &dot_kernel_model
 };
 
-void dot_kernel(starpu_data_handle v1,
-		starpu_data_handle v2,
-		starpu_data_handle s,
+void dot_kernel(starpu_data_handle_t v1,
+		starpu_data_handle_t v2,
+		starpu_data_handle_t s,
 		unsigned nblocks,
 		int use_reduction)
 {
@@ -385,9 +385,9 @@ static starpu_codelet gemv_kernel_cl = {
 	.model = &gemv_kernel_model
 };
 
-void gemv_kernel(starpu_data_handle v1,
-		starpu_data_handle matrix,
-		starpu_data_handle v2,
+void gemv_kernel(starpu_data_handle_t v1,
+		starpu_data_handle_t matrix,
+		starpu_data_handle_t v2,
 		TYPE p1, TYPE p2,
 		unsigned nblocks,
 		int use_reduction)
@@ -475,8 +475,8 @@ static starpu_codelet scal_axpy_kernel_cl = {
 	.model = &scal_axpy_kernel_model
 };
 
-void scal_axpy_kernel(starpu_data_handle v1, TYPE p1,
-			starpu_data_handle v2, TYPE p2,
+void scal_axpy_kernel(starpu_data_handle_t v1, TYPE p1,
+			starpu_data_handle_t v2, TYPE p2,
 			unsigned nblocks)
 {
 	unsigned b;
@@ -543,8 +543,8 @@ static starpu_codelet axpy_kernel_cl = {
 	.model = &axpy_kernel_model
 };
 
-void axpy_kernel(starpu_data_handle v1,
-		starpu_data_handle v2, TYPE p1,
+void axpy_kernel(starpu_data_handle_t v1,
+		starpu_data_handle_t v2, TYPE p1,
 		unsigned nblocks)
 {
 	unsigned b;
@@ -603,7 +603,7 @@ static starpu_codelet copy_handle_cl = {
 	.model = &copy_handle_model
 };
 
-void copy_handle(starpu_data_handle dst, starpu_data_handle src, unsigned nblocks)
+void copy_handle(starpu_data_handle_t dst, starpu_data_handle_t src, unsigned nblocks)
 {
 	unsigned b;
 	for (b = 0; b < nblocks; b++)

examples/cholesky/cholesky_grain_tag.c

@@ -47,7 +47,7 @@ static starpu_codelet cl11 =
 	.model = &chol_model_11
 };
 
-static struct starpu_task * create_task_11(starpu_data_handle dataA, unsigned k, unsigned reclevel)
+static struct starpu_task * create_task_11(starpu_data_handle_t dataA, unsigned k, unsigned reclevel)
 {
 /*	FPRINTF(stdout, "task 11 k = %d TAG = %llx\n", k, (TAG11(k))); */
 
@@ -81,7 +81,7 @@ static starpu_codelet cl21 =
 	.model = &chol_model_21
 };
 
-static void create_task_21(starpu_data_handle dataA, unsigned k, unsigned j, unsigned reclevel)
+static void create_task_21(starpu_data_handle_t dataA, unsigned k, unsigned j, unsigned reclevel)
 {
 	struct starpu_task *task = create_task(TAG21_AUX(k, j, reclevel));
 
@@ -119,7 +119,7 @@ static starpu_codelet cl22 =
 	.model = &chol_model_22
 };
 
-static void create_task_22(starpu_data_handle dataA, unsigned k, unsigned i, unsigned j, unsigned reclevel)
+static void create_task_22(starpu_data_handle_t dataA, unsigned k, unsigned i, unsigned j, unsigned reclevel)
 {
 /*	FPRINTF(stdout, "task 22 k,i,j = %d,%d,%d TAG = %llx\n", k,i,j, TAG22_AUX(k,i,j)); */
 
@@ -165,7 +165,7 @@ static void cholesky_grain_rec(float *matA, unsigned size, unsigned ld, unsigned
 	/* create all the DAG nodes */
 	unsigned i,j,k;
 
-	starpu_data_handle dataA;
+	starpu_data_handle_t dataA;
 
 	/* monitor and partition the A matrix into blocks :
 	 * one block is now determined by 2 unsigned (i,j) */

examples/cholesky/cholesky_implicit.c

@@ -69,7 +69,7 @@ static void callback_turn_spmd_on(void *arg __attribute__ ((unused)))
 	cl22.type = STARPU_SPMD;
 }
 
-static void _cholesky(starpu_data_handle dataA, unsigned nblocks)
+static void _cholesky(starpu_data_handle_t dataA, unsigned nblocks)
 {
 	struct timeval start;
 	struct timeval end;
@@ -85,7 +85,7 @@ static void _cholesky(starpu_data_handle dataA, unsigned nblocks)
 	/* create all the DAG nodes */
 	for (k = 0; k < nblocks; k++)
 	{
-                starpu_data_handle sdatakk = starpu_data_get_sub_data(dataA, 2, k, k);
+                starpu_data_handle_t sdatakk = starpu_data_get_sub_data(dataA, 2, k, k);
 
                 starpu_insert_task(&cl11,
                                    STARPU_PRIORITY, prio_level,
@@ -95,7 +95,7 @@ static void _cholesky(starpu_data_handle dataA, unsigned nblocks)
 
 		for (j = k+1; j<nblocks; j++)
 		{
-                        starpu_data_handle sdatakj = starpu_data_get_sub_data(dataA, 2, k, j);
+                        starpu_data_handle_t sdatakj = starpu_data_get_sub_data(dataA, 2, k, j);
 
                         starpu_insert_task(&cl21,
                                            STARPU_PRIORITY, (j == k+1)?prio_level:STARPU_DEFAULT_PRIO,
@@ -107,8 +107,8 @@ static void _cholesky(starpu_data_handle dataA, unsigned nblocks)
 			{
 				if (i <= j)
                                 {
-					starpu_data_handle sdataki = starpu_data_get_sub_data(dataA, 2, k, i);
-					starpu_data_handle sdataij = starpu_data_get_sub_data(dataA, 2, i, j);
+					starpu_data_handle_t sdataki = starpu_data_get_sub_data(dataA, 2, k, i);
+					starpu_data_handle_t sdataij = starpu_data_get_sub_data(dataA, 2, i, j);
 					
 					starpu_insert_task(&cl22,
                                                            STARPU_PRIORITY, ((i == k+1) && (j == k+1))?prio_level:STARPU_DEFAULT_PRIO,
@@ -146,7 +146,7 @@ static void _cholesky(starpu_data_handle dataA, unsigned nblocks)
 
 static void cholesky(float *matA, unsigned size, unsigned ld, unsigned nblocks)
 {
-	starpu_data_handle dataA;
+	starpu_data_handle_t dataA;
 
 	/* monitor and partition the A matrix into blocks :
 	 * one block is now determined by 2 unsigned (i,j) */

examples/cholesky/cholesky_tag.c

@@ -47,7 +47,7 @@ static starpu_codelet cl11 =
 	.model = &chol_model_11
 };
 
-static struct starpu_task * create_task_11(starpu_data_handle dataA, unsigned k)
+static struct starpu_task * create_task_11(starpu_data_handle_t dataA, unsigned k)
 {
 /*	FPRINTF(stdout, "task 11 k = %d TAG = %llx\n", k, (TAG11(k))); */
 
@@ -82,7 +82,7 @@ static starpu_codelet cl21 =
 	.model = &chol_model_21
 };
 
-static void create_task_21(starpu_data_handle dataA, unsigned k, unsigned j)
+static void create_task_21(starpu_data_handle_t dataA, unsigned k, unsigned j)
 {
 	struct starpu_task *task = create_task(TAG21(k, j));
 
@@ -125,7 +125,7 @@ static starpu_codelet cl22 =
 	.model = &chol_model_22
 };
 
-static void create_task_22(starpu_data_handle dataA, unsigned k, unsigned i, unsigned j)
+static void create_task_22(starpu_data_handle_t dataA, unsigned k, unsigned i, unsigned j)
 {
 /*	FPRINTF(stdout, "task 22 k,i,j = %d,%d,%d TAG = %llx\n", k,i,j, TAG22(k,i,j)); */
 
@@ -167,7 +167,7 @@ static void create_task_22(starpu_data_handle dataA, unsigned k, unsigned i, uns
  *	and construct the DAG
  */
 
-static void _cholesky(starpu_data_handle dataA, unsigned nblocks)
+static void _cholesky(starpu_data_handle_t dataA, unsigned nblocks)
 {
 	struct timeval start;
 	struct timeval end;
@@ -250,7 +250,7 @@ static void initialize_system(float **A, unsigned dim, unsigned pinned)
 
 static void cholesky(float *matA, unsigned size, unsigned ld, unsigned nblocks)
 {
-	starpu_data_handle dataA;
+	starpu_data_handle_t dataA;
 
 	/* monitor and partition the A matrix into blocks :
 	 * one block is now determined by 2 unsigned (i,j) */

examples/cholesky/cholesky_tile_tag.c

@@ -19,7 +19,7 @@
 
 /* A [ y ] [ x ] */
 float *A[NMAXBLOCKS][NMAXBLOCKS];
-starpu_data_handle A_state[NMAXBLOCKS][NMAXBLOCKS];
+starpu_data_handle_t A_state[NMAXBLOCKS][NMAXBLOCKS];
 
 /*
  *	Some useful functions

examples/filters/fblock.c

@@ -51,7 +51,7 @@ void print_block(int *block, int nx, int ny, int nz, unsigned ldy, unsigned ldz)
         FPRINTF(stderr,"\n");
 }
 
-void print_data(starpu_data_handle block_handle)
+void print_data(starpu_data_handle_t block_handle)
 {
 	int *block = (int *)starpu_block_get_local_ptr(block_handle);
 	int nx = starpu_block_get_nx(block_handle);
@@ -82,7 +82,7 @@ int main(int argc, char **argv)
                 }
         }
 
-	starpu_data_handle handle;
+	starpu_data_handle_t handle;
 	starpu_codelet cl =
 	{
                 .where = STARPU_CPU|STARPU_CUDA|STARPU_OPENCL,
@@ -118,7 +118,7 @@ int main(int argc, char **argv)
 
         for(i=0 ; i<starpu_data_get_nb_children(handle) ; i++)
         {
-                starpu_data_handle sblock = starpu_data_get_sub_data(handle, 1, i);
+                starpu_data_handle_t sblock = starpu_data_get_sub_data(handle, 1, i);
                 FPRINTF(stderr, "Sub block %d\n", i);
                 print_data(sblock);
         }

examples/filters/fmatrix.c

@@ -55,7 +55,7 @@ int main(int argc, char **argv)
         }
         FPRINTF(stderr,"\n");
 
-        starpu_data_handle handle;
+        starpu_data_handle_t handle;
         starpu_codelet cl = {
                 .where = STARPU_CPU,
                 .cpu_func = cpu_func,

examples/filters/fvector.c

@@ -39,7 +39,7 @@ int main(int argc, char **argv)
 {
 	unsigned i;
         int vector[NX];
-        starpu_data_handle handle;
+        starpu_data_handle_t handle;
         int factor=1;
 
         starpu_codelet cl = {
@@ -69,7 +69,7 @@ int main(int argc, char **argv)
         /* Submit a task on each sub-vector */
 	for (i=0; i<starpu_data_get_nb_children(handle); i++)
 	{
-                starpu_data_handle sub_handle = starpu_data_get_sub_data(handle, 1, i);
+                starpu_data_handle_t sub_handle = starpu_data_get_sub_data(handle, 1, i);
                 struct starpu_task *task = starpu_task_create();
 
                 factor *= 10;

examples/heat/dw_factolu.c

@@ -590,7 +590,7 @@ void dw_callback_codelet_update_u12_21(void *argcb)
  *	code to bootstrap the factorization 
  */
 
-void dw_codelet_facto(starpu_data_handle dataA, unsigned nblocks)
+void dw_codelet_facto(starpu_data_handle_t dataA, unsigned nblocks)
 {
 	cl_args *args = malloc(sizeof(cl_args));
 
@@ -632,7 +632,7 @@ void dw_codelet_facto(starpu_data_handle dataA, unsigned nblocks)
 	FPRINTF(stderr, "Synthetic GFlops : %2.2f\n", (flop/timing/1000.0f));
 }
 
-void dw_codelet_facto_v2(starpu_data_handle dataA, unsigned nblocks)
+void dw_codelet_facto_v2(starpu_data_handle_t dataA, unsigned nblocks)
 {
 
 	advance_11 = calloc(nblocks, sizeof(uint8_t));
@@ -723,7 +723,7 @@ void dw_factoLU(float *matA, unsigned size,
 
 	no_prio = _no_prio;
 
-	starpu_data_handle dataA;
+	starpu_data_handle_t dataA;
 
 	/* monitor and partition the A matrix into blocks :
 	 * one block is now determined by 2 unsigned (i,j) */

examples/heat/dw_factolu.h

@@ -42,7 +42,7 @@
         (2*((uint64_t)n1)*((uint64_t)n2)*((uint64_t)n3))
 
 typedef struct {
-	starpu_data_handle dataA;
+	starpu_data_handle_t dataA;
 	unsigned i;
 	unsigned j;
 	unsigned k;

examples/heat/dw_factolu_grain.c

@@ -52,7 +52,7 @@ static starpu_codelet cl11 = {
 	.model = &model_11
 };
 
-static struct starpu_task *create_task_11(starpu_data_handle dataA, unsigned k, unsigned tag_prefix)
+static struct starpu_task *create_task_11(starpu_data_handle_t dataA, unsigned k, unsigned tag_prefix)
 {
 /*	FPRINTF(stdout, "task 11 k = %d TAG = %llx\n", k, (TAG11(k))); */
 
@@ -85,7 +85,7 @@ static starpu_codelet cl12 = {
 	.model = &model_12
 };
 
-static void create_task_12(starpu_data_handle dataA, unsigned k, unsigned i, unsigned tag_prefix)
+static void create_task_12(starpu_data_handle_t dataA, unsigned k, unsigned i, unsigned tag_prefix)
 {
 /*	FPRINTF(stdout, "task 12 k,i = %d,%d TAG = %llx\n", k,i, TAG12(k,i)); */
 
@@ -124,7 +124,7 @@ static starpu_codelet cl21 = {
 	.model = &model_21
 };
 
-static void create_task_21(starpu_data_handle dataA, unsigned k, unsigned j, unsigned tag_prefix)
+static void create_task_21(starpu_data_handle_t dataA, unsigned k, unsigned j, unsigned tag_prefix)
 {
 	struct starpu_task *task = create_task(TAG21(k, j, tag_prefix));
 
@@ -161,7 +161,7 @@ static starpu_codelet cl22 = {
 	.model = &model_22
 };
 
-static void create_task_22(starpu_data_handle dataA, unsigned k, unsigned i, unsigned j, unsigned tag_prefix)
+static void create_task_22(starpu_data_handle_t dataA, unsigned k, unsigned i, unsigned j, unsigned tag_prefix)
 {
 /*	FPRINTF(stdout, "task 22 k,i,j = %d,%d,%d TAG = %llx\n", k,i,j, TAG22(k,i,j)); */
 
@@ -198,7 +198,7 @@ static void dw_factoLU_grain_inner(float *matA, unsigned size, unsigned inner_si
 	/*
 	 * (re)partition data
 	 */
-	starpu_data_handle dataA;
+	starpu_data_handle_t dataA;
 	starpu_matrix_data_register(&dataA, 0, (uintptr_t)matA, ld, size, size, sizeof(float));
 
 	STARPU_ASSERT((size % blocksize) == 0);

examples/heat/dw_factolu_tag.c

@@ -54,7 +54,7 @@ static starpu_codelet cl11 = {
 	.model = &model_11
 };
 
-static struct starpu_task *create_task_11(starpu_data_handle dataA, unsigned k)
+static struct starpu_task *create_task_11(starpu_data_handle_t dataA, unsigned k)
 {
 /*	printf("task 11 k = %d TAG = %llx\n", k, (TAG11(k))); */
 
@@ -88,7 +88,7 @@ static starpu_codelet cl12 = {
 	.model = &model_12
 };
 
-static void create_task_12(starpu_data_handle dataA, unsigned k, unsigned i)
+static void create_task_12(starpu_data_handle_t dataA, unsigned k, unsigned i)
 {
 /*	printf("task 12 k,i = %d,%d TAG = %llx\n", k,i, TAG12(k,i)); */
 
@@ -127,7 +127,7 @@ static starpu_codelet cl21 = {
 	.model = &model_21
 };
 
-static void create_task_21(starpu_data_handle dataA, unsigned k, unsigned j)
+static void create_task_21(starpu_data_handle_t dataA, unsigned k, unsigned j)
 {
 	struct starpu_task *task = create_task(TAG21(k, j));
 
@@ -164,7 +164,7 @@ static starpu_codelet cl22 = {
 	.model = &model_22
 };
 
-static void create_task_22(starpu_data_handle dataA, unsigned k, unsigned i, unsigned j)
+static void create_task_22(starpu_data_handle_t dataA, unsigned k, unsigned i, unsigned j)
 {
 /*	printf("task 22 k,i,j = %d,%d,%d TAG = %llx\n", k,i,j, TAG22(k,i,j)); */
 
@@ -199,7 +199,7 @@ static void create_task_22(starpu_data_handle dataA, unsigned k, unsigned i, uns
  *	code to bootstrap the factorization 
  */
 
-static void dw_codelet_facto_v3(starpu_data_handle dataA, unsigned nblocks)
+static void dw_codelet_facto_v3(starpu_data_handle_t dataA, unsigned nblocks)
 {
 	struct timeval start;
 	struct timeval end;
@@ -274,7 +274,7 @@ void dw_factoLU_tag(float *matA, unsigned size, unsigned ld, unsigned nblocks, u
 
 	no_prio = _no_prio;
 
-	starpu_data_handle dataA;
+	starpu_data_handle_t dataA;
 
 	/* monitor and partition the A matrix into blocks :
 	 * one block is now determined by 2 unsigned (i,j) */

examples/heat/dw_sparse_cg.c

@@ -329,9 +329,9 @@ void conjugate_gradient(float *nzvalA, float *vecb, float *vecx, uint32_t nnz,
 {
 	/* first register all the data structures to StarPU */
 
-	starpu_data_handle ds_matrixA;
-	starpu_data_handle ds_vecx, ds_vecb;
-	starpu_data_handle ds_vecr, ds_vecd, ds_vecq; 
+	starpu_data_handle_t ds_matrixA;
+	starpu_data_handle_t ds_vecx, ds_vecb;
+	starpu_data_handle_t ds_vecr, ds_vecd, ds_vecq; 
 
 	/* first the user-allocated data */
 	starpu_csr_data_register(&ds_matrixA, 0, nnz, nrow, 

examples/heat/dw_sparse_cg.h

@@ -47,12 +47,12 @@ static unsigned blocks = 512;
 static unsigned grids  = 8;
 
 struct cg_problem {
-	starpu_data_handle ds_matrixA;
-	starpu_data_handle ds_vecx;
-	starpu_data_handle ds_vecb;
-	starpu_data_handle ds_vecr;
-	starpu_data_handle ds_vecd;
-	starpu_data_handle ds_vecq;
+	starpu_data_handle_t ds_matrixA;
+	starpu_data_handle_t ds_vecx;
+	starpu_data_handle_t ds_vecb;
+	starpu_data_handle_t ds_vecr;
+	starpu_data_handle_t ds_vecd;
+	starpu_data_handle_t ds_vecq;
 
 	sem_t *sem;
 	

examples/incrementer/incrementer.c

@@ -53,7 +53,7 @@ int main(int argc, char **argv)
 
 	float float_array[4] __attribute__ ((aligned (16))) = { 0.0f, 0.0f, 0.0f, 0.0f};
 
-	starpu_data_handle float_array_handle;
+	starpu_data_handle_t float_array_handle;
 	starpu_vector_data_register(&float_array_handle, 0 /* home node */,
 			(uintptr_t)&float_array, 4, sizeof(float));
 

examples/lu/xlu.c

@@ -48,7 +48,7 @@ static struct starpu_task *create_task(starpu_tag id)
 	return task;
 }
 
-static struct starpu_task *create_task_11(starpu_data_handle dataA, unsigned k)
+static struct starpu_task *create_task_11(starpu_data_handle_t dataA, unsigned k)
 {
 /*	printf("task 11 k = %d TAG = %llx\n", k, (TAG11(k))); */
 
@@ -72,7 +72,7 @@ static struct starpu_task *create_task_11(starpu_data_handle dataA, unsigned k)
 	return task;
 }
 
-static void create_task_12(starpu_data_handle dataA, unsigned k, unsigned j)
+static void create_task_12(starpu_data_handle_t dataA, unsigned k, unsigned j)
 {
 /*	printf("task 12 k,i = %d,%d TAG = %llx\n", k,i, TAG12(k,i)); */
 
@@ -101,7 +101,7 @@ static void create_task_12(starpu_data_handle dataA, unsigned k, unsigned j)
 	starpu_task_submit(task);
 }
 
-static void create_task_21(starpu_data_handle dataA, unsigned k, unsigned i)
+static void create_task_21(starpu_data_handle_t dataA, unsigned k, unsigned i)
 {
 	struct starpu_task *task = create_task(TAG21(k, i));
 
@@ -128,7 +128,7 @@ static void create_task_21(starpu_data_handle dataA, unsigned k, unsigned i)
 	starpu_task_submit(task);
 }
 
-static void create_task_22(starpu_data_handle dataA, unsigned k, unsigned i, unsigned j)
+static void create_task_22(starpu_data_handle_t dataA, unsigned k, unsigned i, unsigned j)
 {
 /*	printf("task 22 k,i,j = %d,%d,%d TAG = %llx\n", k,i,j, TAG22(k,i,j)); */
 
@@ -163,7 +163,7 @@ static void create_task_22(starpu_data_handle dataA, unsigned k, unsigned i, uns
  *	code to bootstrap the factorization 
  */
 
-static void dw_codelet_facto_v3(starpu_data_handle dataA, unsigned nblocks)
+static void dw_codelet_facto_v3(starpu_data_handle_t dataA, unsigned nblocks)
 {
 	struct timeval start;
 	struct timeval end;
@@ -227,7 +227,7 @@ static void dw_codelet_facto_v3(starpu_data_handle dataA, unsigned nblocks)
 
 void STARPU_LU(lu_decomposition)(TYPE *matA, unsigned size, unsigned ld, unsigned nblocks)
 {
-	starpu_data_handle dataA;
+	starpu_data_handle_t dataA;
 
 	/* monitor and partition the A matrix into blocks :
 	 * one block is now determined by 2 unsigned (i,j) */

examples/lu/xlu_implicit.c

@@ -21,7 +21,7 @@
 
 static unsigned no_prio = 0;
 
-static void create_task_11(starpu_data_handle dataA, unsigned k)
+static void create_task_11(starpu_data_handle_t dataA, unsigned k)
 {
 	struct starpu_task *task = starpu_task_create();
 	task->cl = &cl11;
@@ -37,7 +37,7 @@ static void create_task_11(starpu_data_handle dataA, unsigned k)
 	starpu_task_submit(task);
 }
 
-static void create_task_12(starpu_data_handle dataA, unsigned k, unsigned j)
+static void create_task_12(starpu_data_handle_t dataA, unsigned k, unsigned j)
 {
 	struct starpu_task *task = starpu_task_create();
 	task->cl = &cl12;
@@ -54,7 +54,7 @@ static void create_task_12(starpu_data_handle dataA, unsigned k, unsigned j)
 	starpu_task_submit(task);
 }
 
-static void create_task_21(starpu_data_handle dataA, unsigned k, unsigned i)
+static void create_task_21(starpu_data_handle_t dataA, unsigned k, unsigned i)
 {
 	struct starpu_task *task = starpu_task_create();
 
@@ -72,7 +72,7 @@ static void create_task_21(starpu_data_handle dataA, unsigned k, unsigned i)
 	starpu_task_submit(task);
 }
 
-static void create_task_22(starpu_data_handle dataA, unsigned k, unsigned i, unsigned j)
+static void create_task_22(starpu_data_handle_t dataA, unsigned k, unsigned i, unsigned j)
 {
 	struct starpu_task *task = starpu_task_create();
 
@@ -96,7 +96,7 @@ static void create_task_22(starpu_data_handle dataA, unsigned k, unsigned i, uns
  *	code to bootstrap the factorization 
  */
 
-static void dw_codelet_facto_v3(starpu_data_handle dataA, unsigned nblocks)
+static void dw_codelet_facto_v3(starpu_data_handle_t dataA, unsigned nblocks)
 {
 	struct timeval start;
 	struct timeval end;
@@ -137,7 +137,7 @@ static void dw_codelet_facto_v3(starpu_data_handle dataA, unsigned nblocks)
 
 void STARPU_LU(lu_decomposition)(TYPE *matA, unsigned size, unsigned ld, unsigned nblocks)
 {
-	starpu_data_handle dataA;
+	starpu_data_handle_t dataA;
 
 	/* monitor and partition the A matrix into blocks :
 	 * one block is now determined by 2 unsigned (i,j) */

examples/lu/xlu_implicit_pivot.c

@@ -25,10 +25,10 @@ static unsigned no_prio = 0;
  *	Construct the DAG
  */
 
-static void create_task_pivot(starpu_data_handle *dataAp, unsigned nblocks,
+static void create_task_pivot(starpu_data_handle_t *dataAp, unsigned nblocks,
 					struct piv_s *piv_description,
 					unsigned k, unsigned i,
-					starpu_data_handle (* get_block)(starpu_data_handle *, unsigned, unsigned, unsigned))
+					starpu_data_handle_t (* get_block)(starpu_data_handle_t *, unsigned, unsigned, unsigned))
 {
 	struct starpu_task *task = starpu_task_create();
 
@@ -47,9 +47,9 @@ static void create_task_pivot(starpu_data_handle *dataAp, unsigned nblocks,
 	starpu_task_submit(task);
 }
 
-static void create_task_11_pivot(starpu_data_handle *dataAp, unsigned nblocks,
+static void create_task_11_pivot(starpu_data_handle_t *dataAp, unsigned nblocks,
 					unsigned k, struct piv_s *piv_description,
-					starpu_data_handle (* get_block)(starpu_data_handle *, unsigned, unsigned, unsigned))
+					starpu_data_handle_t (* get_block)(starpu_data_handle_t *, unsigned, unsigned, unsigned))
 {
 	struct starpu_task *task = starpu_task_create();
 
@@ -68,8 +68,8 @@ static void create_task_11_pivot(starpu_data_handle *dataAp, unsigned nblocks,
 	starpu_task_submit(task);
 }
 
-static void create_task_12(starpu_data_handle *dataAp, unsigned nblocks, unsigned k, unsigned j,
-		starpu_data_handle (* get_block)(starpu_data_handle *, unsigned, unsigned, unsigned))
+static void create_task_12(starpu_data_handle_t *dataAp, unsigned nblocks, unsigned k, unsigned j,
+		starpu_data_handle_t (* get_block)(starpu_data_handle_t *, unsigned, unsigned, unsigned))
 {
 	struct starpu_task *task = starpu_task_create();
 	
@@ -87,8 +87,8 @@ static void create_task_12(starpu_data_handle *dataAp, unsigned nblocks, unsigne
 	starpu_task_submit(task);
 }
 
-static void create_task_21(starpu_data_handle *dataAp, unsigned nblocks, unsigned k, unsigned i,
-				starpu_data_handle (* get_block)(starpu_data_handle *, unsigned, unsigned, unsigned))
+static void create_task_21(starpu_data_handle_t *dataAp, unsigned nblocks, unsigned k, unsigned i,
+				starpu_data_handle_t (* get_block)(starpu_data_handle_t *, unsigned, unsigned, unsigned))
 {
 	struct starpu_task *task = starpu_task_create();
 
@@ -106,8 +106,8 @@ static void create_task_21(starpu_data_handle *dataAp, unsigned nblocks, unsigne
 	starpu_task_submit(task);
 }
 
-static void create_task_22(starpu_data_handle *dataAp, unsigned nblocks, unsigned k, unsigned i, unsigned j,
-				starpu_data_handle (* get_block)(starpu_data_handle *, unsigned, unsigned, unsigned))
+static void create_task_22(starpu_data_handle_t *dataAp, unsigned nblocks, unsigned k, unsigned i, unsigned j,
+				starpu_data_handle_t (* get_block)(starpu_data_handle_t *, unsigned, unsigned, unsigned))
 {
 	struct starpu_task *task = starpu_task_create();
 
@@ -131,10 +131,10 @@ static void create_task_22(starpu_data_handle *dataAp, unsigned nblocks, unsigne
  *	code to bootstrap the factorization 
  */
 
-static double dw_codelet_facto_pivot(starpu_data_handle *dataAp,
+static double dw_codelet_facto_pivot(starpu_data_handle_t *dataAp,
 					struct piv_s *piv_description,
 					unsigned nblocks,
-					starpu_data_handle (* get_block)(starpu_data_handle *, unsigned, unsigned, unsigned))
+					starpu_data_handle_t (* get_block)(starpu_data_handle_t *, unsigned, unsigned, unsigned))
 {
 	struct timeval start;
 	struct timeval end;
@@ -173,7 +173,7 @@ static double dw_codelet_facto_pivot(starpu_data_handle *dataAp,
 	return timing;
 }
 
-starpu_data_handle get_block_with_striding(starpu_data_handle *dataAp,
+starpu_data_handle_t get_block_with_striding(starpu_data_handle_t *dataAp,
 			unsigned nblocks __attribute__((unused)), unsigned j, unsigned i)
 {
 	/* we use filters */
@@ -183,7 +183,7 @@ starpu_data_handle get_block_with_striding(starpu_data_handle *dataAp,
 
 void STARPU_LU(lu_decomposition_pivot)(TYPE *matA, unsigned *ipiv, unsigned size, unsigned ld, unsigned nblocks)
 {
-	starpu_data_handle dataA;
+	starpu_data_handle_t dataA;
 
 	/* monitor and partition the A matrix into blocks :
 	 * one block is now determined by 2 unsigned (i,j) */
@@ -230,7 +230,7 @@ void STARPU_LU(lu_decomposition_pivot)(TYPE *matA, unsigned *ipiv, unsigned size
 }
 
 
-starpu_data_handle get_block_with_no_striding(starpu_data_handle *dataAp, unsigned nblocks, unsigned j, unsigned i)
+starpu_data_handle_t get_block_with_no_striding(starpu_data_handle_t *dataAp, unsigned nblocks, unsigned j, unsigned i)
 {
 	/* dataAp is an array of data handle */
 	return dataAp[i+j*nblocks];
@@ -238,7 +238,7 @@ starpu_data_handle get_block_with_no_striding(starpu_data_handle *dataAp, unsign
 
 void STARPU_LU(lu_decomposition_pivot_no_stride)(TYPE **matA, unsigned *ipiv, unsigned size, unsigned ld, unsigned nblocks)
 {
-	starpu_data_handle *dataAp = malloc(nblocks*nblocks*sizeof(starpu_data_handle));
+	starpu_data_handle_t *dataAp = malloc(nblocks*nblocks*sizeof(starpu_data_handle_t));
 
 	/* monitor and partition the A matrix into blocks :
 	 * one block is now determined by 2 unsigned (i,j) */

examples/lu/xlu_pivot.c

@@ -46,10 +46,10 @@ static struct starpu_task *create_task(starpu_tag id)
 	return task;
 }
 
-static void create_task_pivot(starpu_data_handle *dataAp, unsigned nblocks,
+static void create_task_pivot(starpu_data_handle_t *dataAp, unsigned nblocks,
 					struct piv_s *piv_description,
 					unsigned k, unsigned i,
-					starpu_data_handle (* get_block)(starpu_data_handle *, unsigned, unsigned, unsigned))
+					starpu_data_handle_t (* get_block)(starpu_data_handle_t *, unsigned, unsigned, unsigned))
 {
 	struct starpu_task *task = create_task(PIVOT(k, i));
 
@@ -92,9 +92,9 @@ static void create_task_pivot(starpu_data_handle *dataAp, unsigned nblocks,
 	starpu_task_submit(task);
 }
 
-static struct starpu_task *create_task_11_pivot(starpu_data_handle *dataAp, unsigned nblocks,
+static struct starpu_task *create_task_11_pivot(starpu_data_handle_t *dataAp, unsigned nblocks,
 					unsigned k, struct piv_s *piv_description,
-					starpu_data_handle (* get_block)(starpu_data_handle *, unsigned, unsigned, unsigned))
+					starpu_data_handle_t (* get_block)(starpu_data_handle_t *, unsigned, unsigned, unsigned))
 {
 	struct starpu_task *task = create_task(TAG11(k));
 
@@ -118,8 +118,8 @@ static struct starpu_task *create_task_11_pivot(starpu_data_handle *dataAp, unsi
 	return task;
 }
 
-static void create_task_12(starpu_data_handle *dataAp, unsigned nblocks, unsigned k, unsigned j,
-		starpu_data_handle (* get_block)(starpu_data_handle *, unsigned, unsigned, unsigned))
+static void create_task_12(starpu_data_handle_t *dataAp, unsigned nblocks, unsigned k, unsigned j,
+		starpu_data_handle_t (* get_block)(starpu_data_handle_t *, unsigned, unsigned, unsigned))
 {
 /*	printf("task 12 k,i = %d,%d TAG = %llx\n", k,i, TAG12(k,i)); */
 
@@ -153,8 +153,8 @@ static void create_task_12(starpu_data_handle *dataAp, unsigned nblocks, unsigne
 	starpu_task_submit(task);
 }
 
-static void create_task_21(starpu_data_handle *dataAp, unsigned nblocks, unsigned k, unsigned i,
-				starpu_data_handle (* get_block)(starpu_data_handle *, unsigned, unsigned, unsigned))
+static void create_task_21(starpu_data_handle_t *dataAp, unsigned nblocks, unsigned k, unsigned i,
+				starpu_data_handle_t (* get_block)(starpu_data_handle_t *, unsigned, unsigned, unsigned))
 {
 	struct starpu_task *task = create_task(TAG21(k, i));
 
@@ -178,8 +178,8 @@ static void create_task_21(starpu_data_handle *dataAp, unsigned nblocks, unsigne
 	starpu_task_submit(task);
 }
 
-static void create_task_22(starpu_data_handle *dataAp, unsigned nblocks, unsigned k, unsigned i, unsigned j,
-				starpu_data_handle (* get_block)(starpu_data_handle *, unsigned, unsigned, unsigned))
+static void create_task_22(starpu_data_handle_t *dataAp, unsigned nblocks, unsigned k, unsigned i, unsigned j,
+				starpu_data_handle_t (* get_block)(starpu_data_handle_t *, unsigned, unsigned, unsigned))
 {
 /*	printf("task 22 k,i,j = %d,%d,%d TAG = %llx\n", k,i,j, TAG22(k,i,j)); */
 
@@ -216,10 +216,10 @@ static void create_task_22(starpu_data_handle *dataAp, unsigned nblocks, unsigne
  *	code to bootstrap the factorization 
  */
 
-static double dw_codelet_facto_pivot(starpu_data_handle *dataAp,
+static double dw_codelet_facto_pivot(starpu_data_handle_t *dataAp,
 					struct piv_s *piv_description,
 					unsigned nblocks,
-					starpu_data_handle (* get_block)(starpu_data_handle *, unsigned, unsigned, unsigned))
+					starpu_data_handle_t (* get_block)(starpu_data_handle_t *, unsigned, unsigned, unsigned))
 {
 	struct timeval start;
 	struct timeval end;
@@ -295,7 +295,7 @@ static double dw_codelet_facto_pivot(starpu_data_handle *dataAp,
 	return timing;
 }
 
-starpu_data_handle get_block_with_striding(starpu_data_handle *dataAp,
+starpu_data_handle_t get_block_with_striding(starpu_data_handle_t *dataAp,
 			unsigned nblocks __attribute__((unused)), unsigned j, unsigned i)
 {
 	/* we use filters */
@@ -305,7 +305,7 @@ starpu_data_handle get_block_with_striding(starpu_data_handle *dataAp,
 
 void STARPU_LU(lu_decomposition_pivot)(TYPE *matA, unsigned *ipiv, unsigned size, unsigned ld, unsigned nblocks)
 {
-	starpu_data_handle dataA;
+	starpu_data_handle_t dataA;
 
 	/* monitor and partition the A matrix into blocks :
 	 * one block is now determined by 2 unsigned (i,j) */
@@ -363,7 +363,7 @@ void STARPU_LU(lu_decomposition_pivot)(TYPE *matA, unsigned *ipiv, unsigned size
 }
 
 
-starpu_data_handle get_block_with_no_striding(starpu_data_handle *dataAp, unsigned nblocks, unsigned j, unsigned i)
+starpu_data_handle_t get_block_with_no_striding(starpu_data_handle_t *dataAp, unsigned nblocks, unsigned j, unsigned i)
 {
 	/* dataAp is an array of data handle */
 	return dataAp[i+j*nblocks];
@@ -371,7 +371,7 @@ starpu_data_handle get_block_with_no_striding(starpu_data_handle *dataAp, unsign
 
 void STARPU_LU(lu_decomposition_pivot_no_stride)(TYPE **matA, unsigned *ipiv, unsigned size, unsigned ld, unsigned nblocks)
 {
-	starpu_data_handle *dataAp = malloc(nblocks*nblocks*sizeof(starpu_data_handle));
+	starpu_data_handle_t *dataAp = malloc(nblocks*nblocks*sizeof(starpu_data_handle_t));
 
 	/* monitor and partition the A matrix into blocks :
 	 * one block is now determined by 2 unsigned (i,j) */

examples/mandelbrot/mandelbrot.c

@@ -481,7 +481,7 @@ int main(int argc, char **argv)
 	starpu_opencl_load_opencl_from_string(mandelbrot_opencl_src, &opencl_programs, NULL);
 #endif
 
-	starpu_data_handle block_handles[nblocks];
+	starpu_data_handle_t block_handles[nblocks];
 	
 	int iby;
 	for (iby = 0; iby < nblocks; iby++)

examples/matvecmult/matvecmult.c

@@ -132,7 +132,7 @@ int main(int argc, char **argv)
         float *correctResult;
         unsigned int mem_size_matrix, mem_size_vector, mem_size_mult;
 
-	starpu_data_handle matrix_handle, vector_handle, mult_handle;
+	starpu_data_handle_t matrix_handle, vector_handle, mult_handle;
 	int ret, submit;
 
         ret = starpu_init(&conf);

examples/mult/xgemm.c

@@ -40,7 +40,7 @@ static unsigned zdim = 64;
 static unsigned check = 0;
 
 static TYPE *A, *B, *C;
-static starpu_data_handle A_handle, B_handle, C_handle;
+static starpu_data_handle_t A_handle, B_handle, C_handle;
 
 #define FPRINTF(ofile, fmt, args ...) do { if (!getenv("STARPU_SSILENT")) {fprintf(ofile, fmt, ##args); }} while(0)
 

examples/openmp/vector_scal.c

@@ -75,7 +75,7 @@ int main(int argc, char **argv)
 
 	starpu_init(&conf);
 
-	starpu_data_handle vector_handle;
+	starpu_data_handle_t vector_handle;
 	starpu_vector_data_register(&vector_handle, 0, (uintptr_t)vector, NX, sizeof(vector[0]));
 
 	float factor = 3.14;

examples/opt/pi/pi.c

@@ -87,13 +87,13 @@ int main(int argc, char **argv)
 	initSobolDirectionVectors(n_dimensions, sobol_qrng_directions);
 
 	/* Any worker may use that array now */
-	starpu_data_handle sobol_qrng_direction_handle;
+	starpu_data_handle_t sobol_qrng_direction_handle;
 	starpu_vector_data_register(&sobol_qrng_direction_handle, 0,
 		(uintptr_t)sobol_qrng_directions, n_dimensions*n_directions, sizeof(unsigned));
 
 	unsigned *cnt_array = malloc(ntasks*sizeof(unsigned));
 	STARPU_ASSERT(cnt_array);
-	starpu_data_handle cnt_array_handle;
+	starpu_data_handle_t cnt_array_handle;
 	starpu_vector_data_register(&cnt_array_handle, 0, (uintptr_t)cnt_array, ntasks, sizeof(unsigned));
 
 	/* Use a write-through policy : when the data is modified on an

examples/opt/pi/pi_redux.c

@@ -284,7 +284,7 @@ int main(int argc, char **argv)
 	starpu_execute_on_each_worker(init_rng, NULL, STARPU_CPU|STARPU_CUDA);
 
 	/* Create a scratchpad data */
-	starpu_data_handle xy_scratchpad_handle;
+	starpu_data_handle_t xy_scratchpad_handle;
 	starpu_vector_data_register(&xy_scratchpad_handle, -1, (uintptr_t)NULL,
 		2*NSHOT_PER_TASK, sizeof(float));
 
@@ -292,7 +292,7 @@ int main(int argc, char **argv)
 	 * that actually hit the unit circle when shooting randomly in
 	 * [-1,1]^2. */
 	unsigned long shot_cnt = 0;
-	starpu_data_handle shot_cnt_handle;
+	starpu_data_handle_t shot_cnt_handle;
 	starpu_variable_data_register(&shot_cnt_handle, 0,
 			(uintptr_t)&shot_cnt, sizeof(shot_cnt));
 

examples/ppm_downscaler/yuv_downscaler.c

@@ -136,13 +136,13 @@ int main(int argc, char **argv)
 
 	fread(yuv_in_buffer, FRAMESIZE, nframes, f_in);
 
-	starpu_data_handle *frame_y_handle = (starpu_data_handle *)  calloc(nframes, sizeof(starpu_data_handle));
-	starpu_data_handle *frame_u_handle = (starpu_data_handle *)  calloc(nframes, sizeof(starpu_data_handle));
-	starpu_data_handle *frame_v_handle = (starpu_data_handle *)  calloc(nframes, sizeof(starpu_data_handle));
+	starpu_data_handle_t *frame_y_handle = (starpu_data_handle_t *)  calloc(nframes, sizeof(starpu_data_handle_t));
+	starpu_data_handle_t *frame_u_handle = (starpu_data_handle_t *)  calloc(nframes, sizeof(starpu_data_handle_t));
+	starpu_data_handle_t *frame_v_handle = (starpu_data_handle_t *)  calloc(nframes, sizeof(starpu_data_handle_t));
 
-	starpu_data_handle *new_frame_y_handle = (starpu_data_handle *)  calloc(nframes, sizeof(starpu_data_handle));
-	starpu_data_handle *new_frame_u_handle = (starpu_data_handle *)  calloc(nframes, sizeof(starpu_data_handle));
-	starpu_data_handle *new_frame_v_handle = (starpu_data_handle *)  calloc(nframes, sizeof(starpu_data_handle));
+	starpu_data_handle_t *new_frame_y_handle = (starpu_data_handle_t *)  calloc(nframes, sizeof(starpu_data_handle_t));
+	starpu_data_handle_t *new_frame_u_handle = (starpu_data_handle_t *)  calloc(nframes, sizeof(starpu_data_handle_t));
+	starpu_data_handle_t *new_frame_v_handle = (starpu_data_handle_t *)  calloc(nframes, sizeof(starpu_data_handle_t));
 
 	starpu_init(NULL);
 

examples/reductions/dot_product.c

@@ -26,8 +26,8 @@
 
 static float *x;
 static float *y;
-static starpu_data_handle *x_handles;
-static starpu_data_handle *y_handles;
+static starpu_data_handle_t *x_handles;
+static starpu_data_handle_t *y_handles;
 
 static unsigned nblocks = 4096;
 static unsigned entries_per_block = 1024;
@@ -35,7 +35,7 @@ static unsigned entries_per_block = 1024;
 #define DOT_TYPE double
 
 static DOT_TYPE dot = 0.0f;
-static starpu_data_handle dot_handle;
+static starpu_data_handle_t dot_handle;
 
 /*
  *	Codelet to create a neutral element
@@ -167,8 +167,8 @@ int main(int argc, char **argv)
 	x = (float *) malloc(size);
 	y = (float *) malloc(size);
 
-	x_handles = (starpu_data_handle *) calloc(nblocks, sizeof(starpu_data_handle));
-	y_handles = (starpu_data_handle *) calloc(nblocks, sizeof(starpu_data_handle));
+	x_handles = (starpu_data_handle_t *) calloc(nblocks, sizeof(starpu_data_handle_t));
+	y_handles = (starpu_data_handle_t *) calloc(nblocks, sizeof(starpu_data_handle_t));
 
 	assert(x && y);
 

examples/reductions/minmax_reduction.c

@@ -29,11 +29,11 @@ static unsigned entries_per_bock = 1024;
 #define TYPE_MIN	DBL_MIN
 
 static TYPE *x;
-static starpu_data_handle *x_handles;
+static starpu_data_handle_t *x_handles;
 
 /* The first element (resp. second) stores the min element (resp. max). */
 static TYPE minmax[2];
-static starpu_data_handle minmax_handle;
+static starpu_data_handle_t minmax_handle;
 
 /*
  *	Codelet to create a neutral element
@@ -130,7 +130,7 @@ int main(int argc, char **argv)
 	size_t size = nelems*sizeof(TYPE);
 
 	x = (TYPE *) malloc(size);
-	x_handles = (starpu_data_handle *) calloc(nblocks, sizeof(starpu_data_handle));
+	x_handles = (starpu_data_handle_t *) calloc(nblocks, sizeof(starpu_data_handle_t));
 	
 	assert(x && x_handles);
 

examples/spmv/dw_block_spmv.c

@@ -30,8 +30,8 @@ unsigned r = 256;
 
 unsigned remainingtasks = -1;
 
-starpu_data_handle sparse_matrix;
-starpu_data_handle vector_in, vector_out;
+starpu_data_handle_t sparse_matrix;
+starpu_data_handle_t vector_in, vector_out;
 
 uint32_t size;
 char *inputfile;
@@ -100,7 +100,7 @@ void init_problem_callback(void *arg)
 	}
 }
 
-unsigned get_bcsr_nchildren(__attribute__((unused)) struct starpu_data_filter *f, starpu_data_handle handle)
+unsigned get_bcsr_nchildren(__attribute__((unused)) struct starpu_data_filter *f, starpu_data_handle_t handle)
 {
   return (unsigned)starpu_bcsr_get_nnz(handle);
 }

examples/spmv/spmv.c

@@ -21,8 +21,8 @@
 unsigned nblocks = 4;
 uint32_t size = 4*1024*1024;
 
-starpu_data_handle sparse_matrix;
-starpu_data_handle vector_in, vector_out;
+starpu_data_handle_t sparse_matrix;
+starpu_data_handle_t vector_in, vector_out;
 
 static void parse_args(int argc, char **argv)
 {

examples/starpufft/starpufftx.c

@@ -77,7 +77,7 @@ struct STARPUFFT(plan) {
 	int sign;
 
 	STARPUFFT(complex) *roots[2];
-	starpu_data_handle roots_handle[2];
+	starpu_data_handle_t roots_handle[2];
 
 	/* For each worker, we need some data */
 	struct {
@@ -100,7 +100,7 @@ struct STARPUFFT(plan) {
 	STARPUFFT(complex) *in, *twisted1, *fft1, *twisted2, *fft2, *out;
 
 	/* corresponding starpu DSM handles */
-	starpu_data_handle in_handle, *twisted1_handle, *fft1_handle, *twisted2_handle, *fft2_handle;
+	starpu_data_handle_t in_handle, *twisted1_handle, *fft1_handle, *twisted2_handle, *fft2_handle;
 
 	/* Tasks */
 	struct starpu_task **twist1_tasks, **fft1_tasks, **twist2_tasks, **fft2_tasks, **twist3_tasks;

examples/stencil/stencil-blocks.c

@@ -242,7 +242,7 @@ void assign_blocks_to_mpi_nodes(int world_size)
 
 static size_t allocated = 0;
 
-static void allocate_block_on_node(starpu_data_handle *handleptr, TYPE **ptr, unsigned nx, unsigned ny, unsigned nz)
+static void allocate_block_on_node(starpu_data_handle_t *handleptr, TYPE **ptr, unsigned nx, unsigned ny, unsigned nz)
 {
 	int ret;
 	size_t block_size = nx*ny*nz*sizeof(TYPE);

examples/stencil/stencil-tasks.c

@@ -93,8 +93,8 @@ static void create_task_save_mpi_send(unsigned iter, unsigned z, int dir, unsign
 	STARPU_ASSERT(neighbour->mpi_node != local_rank);
 
 	/* Send neighbour's border copy to the neighbour */
-	starpu_data_handle handle0 = neighbour->boundaries_handle[(1-dir)/2][0];
-	starpu_data_handle handle1 = neighbour->boundaries_handle[(1-dir)/2][1];
+	starpu_data_handle_t handle0 = neighbour->boundaries_handle[(1-dir)/2][0];
+	starpu_data_handle_t handle1 = neighbour->boundaries_handle[(1-dir)/2][1];
 
 	starpu_mpi_isend_detached(handle0, dest, MPI_TAG0(z, iter, dir), MPI_COMM_WORLD, send_done, (void*)(uintptr_t)z);
 	starpu_mpi_isend_detached(handle1, dest, MPI_TAG1(z, iter, dir), MPI_COMM_WORLD, send_done, (void*)(uintptr_t)z);
@@ -119,8 +119,8 @@ static void create_task_save_mpi_recv(unsigned iter, unsigned z, int dir, unsign
 	STARPU_ASSERT(neighbour->mpi_node == local_rank);
 
 	/* Receive our neighbour's border in our neighbour copy */
-	starpu_data_handle handle0 = neighbour->boundaries_handle[(1-dir)/2][0];
-	starpu_data_handle handle1 = neighbour->boundaries_handle[(1-dir)/2][1];
+	starpu_data_handle_t handle0 = neighbour->boundaries_handle[(1-dir)/2][0];
+	starpu_data_handle_t handle1 = neighbour->boundaries_handle[(1-dir)/2][1];
 
 	starpu_mpi_irecv_detached(handle0, source, MPI_TAG0(z, iter, dir), MPI_COMM_WORLD, recv_done, (void*)(uintptr_t)z);
 	starpu_mpi_irecv_detached(handle1, source, MPI_TAG1(z, iter, dir), MPI_COMM_WORLD, recv_done, (void*)(uintptr_t)z);

examples/stencil/stencil.h

@@ -71,13 +71,13 @@ struct block_description {
 	/* This is the computation buffer for this block, it includes
 	 * neighbours' border to make computation easier */
 	TYPE *layers[2];
-	starpu_data_handle layers_handle[2];
+	starpu_data_handle_t layers_handle[2];
 
 	/* This is the "save" buffer, i.e. a copy of our neighbour's border.
 	 * This one is used for CPU/GPU or MPI communication (rather than the
 	 * whole domain block) */
 	TYPE *boundaries[NDIRS][2];
-	starpu_data_handle boundaries_handle[NDIRS][2];
+	starpu_data_handle_t boundaries_handle[NDIRS][2];
 
 	/* Shortcut pointer to the neighbours */
 	struct block_description *boundary_blocks[NDIRS];

gcc-plugin/tests/mocks.h

@@ -99,7 +99,7 @@ starpu_insert_task (starpu_codelet *cl, ...)
 	case STARPU_R:
 	case STARPU_W:
 	  {
-	    starpu_data_handle handle;
+	    starpu_data_handle_t handle;
 	    handle = starpu_data_lookup (expected->pointer);
 	    assert (va_arg (args, void *) == handle);
 	    break;
@@ -172,14 +172,14 @@ starpu_unpack_cl_args (void *cl_raw_arg, ...)
      int_as_pointer (~pointer_as_int (h));	\
    })
 
-starpu_data_handle
+starpu_data_handle_t
 starpu_data_lookup (const void *ptr)
 {
   return dummy_pointer_to_handle (ptr);
 }
 
 void *
-starpu_handle_get_local_ptr (starpu_data_handle handle)
+starpu_handle_get_local_ptr (starpu_data_handle_t handle)
 {
   return dummy_handle_to_pointer (handle);
 }
@@ -207,7 +207,7 @@ static unsigned int data_register_calls;
 struct data_register_arguments expected_register_arguments;
 
 void
-starpu_vector_data_register (starpu_data_handle *handle,
+starpu_vector_data_register (starpu_data_handle_t *handle,
 			     uint32_t home_node, uintptr_t ptr,
 			     uint32_t count, size_t elemsize)
 {
@@ -235,7 +235,7 @@ static unsigned int data_acquire_calls;
 struct data_acquire_arguments expected_acquire_arguments;
 
 int
-starpu_data_acquire (starpu_data_handle handle, enum starpu_access_mode mode)
+starpu_data_acquire (starpu_data_handle_t handle, enum starpu_access_mode mode)
 {
   /* XXX: Currently only `STARPU_RW'.  */
   assert (mode == STARPU_RW);
@@ -263,7 +263,7 @@ static unsigned int data_unregister_calls;
 struct data_unregister_arguments expected_unregister_arguments;
 
 void
-starpu_data_unregister (starpu_data_handle handle)
+starpu_data_unregister (starpu_data_handle_t handle)
 {
   assert (dummy_handle_to_pointer (handle)
 	  == expected_unregister_arguments.pointer);

include/starpu_data.h

@@ -23,7 +23,7 @@
 #include <starpu_config.h>
 
 struct _starpu_data_state;
-typedef struct _starpu_data_state* starpu_data_handle;
+typedef struct _starpu_data_state* starpu_data_handle_t;
 
 #include <starpu_data_interfaces.h>
 #include <starpu_data_filters.h>
@@ -41,7 +41,7 @@ enum starpu_access_mode {
 };
 
 struct starpu_buffer_descr {
-	starpu_data_handle handle;
+	starpu_data_handle_t handle;
 	enum starpu_access_mode mode;
 };
 
@@ -50,17 +50,17 @@ struct starpu_data_interface_ops;
 /* Destroy the data handle, in case we don't need to update the value of the
  * data in the home node, we can use starpu_data_unregister_no_coherency
  * instead. */
-void starpu_data_unregister(starpu_data_handle handle);
-void starpu_data_unregister_no_coherency(starpu_data_handle handle);
+void starpu_data_unregister(starpu_data_handle_t handle);
+void starpu_data_unregister_no_coherency(starpu_data_handle_t handle);
 
 /* Destroy all data replicates. After data invalidation, the first access to
  * the handle must be performed in write-only mode. */
-void starpu_data_invalidate(starpu_data_handle);
+void starpu_data_invalidate(starpu_data_handle_t);
 
-void starpu_data_advise_as_important(starpu_data_handle handle, unsigned is_important);
+void starpu_data_advise_as_important(starpu_data_handle_t handle, unsigned is_important);
 
-int starpu_data_acquire(starpu_data_handle handle, enum starpu_access_mode mode);
-int starpu_data_acquire_cb(starpu_data_handle handle,
+int starpu_data_acquire(starpu_data_handle_t handle, enum starpu_access_mode mode);
+int starpu_data_acquire_cb(starpu_data_handle_t handle,
 			   enum starpu_access_mode mode, void (*callback)(void *), void *arg);
 #ifdef __GCC__
 #  define STARPU_DATA_ACQUIRE_CB(handle, mode, code) do { \
@@ -72,7 +72,7 @@ int starpu_data_acquire_cb(starpu_data_handle handle,
 } while(0)
 #endif
 
-void starpu_data_release(starpu_data_handle handle);
+void starpu_data_release(starpu_data_handle_t handle);
 
 int starpu_malloc(void **A, size_t dim);
 int starpu_free(void *A);
@@ -86,9 +86,9 @@ void _starpu_free_unref(void *p);
 #define starpu_data_malloc_pinned_if_possible	starpu_malloc
 #define starpu_data_free_pinned_if_possible	starpu_free
 
-int starpu_data_request_allocation(starpu_data_handle handle, uint32_t node);
+int starpu_data_request_allocation(starpu_data_handle_t handle, uint32_t node);
 
-int starpu_data_prefetch_on_node(starpu_data_handle handle, unsigned node, unsigned async);
+int starpu_data_prefetch_on_node(starpu_data_handle_t handle, unsigned node, unsigned async);
 
 unsigned starpu_worker_get_memory_node(unsigned workerid);
 
@@ -96,26 +96,26 @@ unsigned starpu_worker_get_memory_node(unsigned workerid);
  * that when it is modified, it is automatically transfered into those memory
  * node. For instance a (1<<0) write-through mask means that the CUDA workers will
  * commit their changes in main memory (node 0). */
-void starpu_data_set_wt_mask(starpu_data_handle handle, uint32_t wt_mask);
+void starpu_data_set_wt_mask(starpu_data_handle_t handle, uint32_t wt_mask);
 
-void starpu_data_set_sequential_consistency_flag(starpu_data_handle handle, unsigned flag);
+void starpu_data_set_sequential_consistency_flag(starpu_data_handle_t handle, unsigned flag);
 unsigned starpu_data_get_default_sequential_consistency_flag(void);
 void starpu_data_set_default_sequential_consistency_flag(unsigned flag);
 
 /* Query the status of the handle on the specified memory node. */
-void starpu_data_query_status(starpu_data_handle handle, int memory_node, int *is_allocated, int *is_valid, int *is_requested);
+void starpu_data_query_status(starpu_data_handle_t handle, int memory_node, int *is_allocated, int *is_valid, int *is_requested);
 
 struct starpu_codelet_t;
 
-void starpu_data_set_reduction_methods(starpu_data_handle handle,
+void starpu_data_set_reduction_methods(starpu_data_handle_t handle,
 					struct starpu_codelet_t *redux_cl,
 					struct starpu_codelet_t *init_cl);
 
-int starpu_data_set_rank(starpu_data_handle handle, int rank);
-int starpu_data_get_rank(starpu_data_handle handle);
+int starpu_data_set_rank(starpu_data_handle_t handle, int rank);
+int starpu_data_get_rank(starpu_data_handle_t handle);
 
-int starpu_data_set_tag(starpu_data_handle handle, int tag);
-int starpu_data_get_tag(starpu_data_handle handle);
+int starpu_data_set_tag(starpu_data_handle_t handle, int tag);
+int starpu_data_get_tag(starpu_data_handle_t handle);
 
 #ifdef __cplusplus
 }

include/starpu_data_filters.h

@@ -33,28 +33,28 @@ struct starpu_data_interface_ops;
 
 struct starpu_data_filter {
 	void (*filter_func)(void *father_interface, void *child_interface, struct starpu_data_filter *, unsigned id, unsigned nparts);
-        unsigned (*get_nchildren)(struct starpu_data_filter *, starpu_data_handle initial_handle);
+        unsigned (*get_nchildren)(struct starpu_data_filter *, starpu_data_handle_t initial_handle);
         struct starpu_data_interface_ops *(*get_child_ops)(struct starpu_data_filter *, unsigned id);
         unsigned filter_arg;
         unsigned nchildren;
         void *filter_arg_ptr;
 };
 
-void starpu_data_partition(starpu_data_handle initial_handle, struct starpu_data_filter *f);
-void starpu_data_unpartition(starpu_data_handle root_data, uint32_t gathering_node);
+void starpu_data_partition(starpu_data_handle_t initial_handle, struct starpu_data_filter *f);
+void starpu_data_unpartition(starpu_data_handle_t root_data, uint32_t gathering_node);
 
-int starpu_data_get_nb_children(starpu_data_handle handle);
-starpu_data_handle starpu_data_get_child(starpu_data_handle handle, unsigned i);
+int starpu_data_get_nb_children(starpu_data_handle_t handle);
+starpu_data_handle_t starpu_data_get_child(starpu_data_handle_t handle, unsigned i);
 
 /* unsigned list */
-starpu_data_handle starpu_data_get_sub_data(starpu_data_handle root_data, unsigned depth, ... );
+starpu_data_handle_t starpu_data_get_sub_data(starpu_data_handle_t root_data, unsigned depth, ... );
 /* Same, but using va_list */
-starpu_data_handle starpu_data_vget_sub_data(starpu_data_handle root_data, unsigned depth, va_list pa );
+starpu_data_handle_t starpu_data_vget_sub_data(starpu_data_handle_t root_data, unsigned depth, va_list pa );
 
 /* struct starpu_data_filter * list */
-void starpu_data_map_filters(starpu_data_handle root_data, unsigned nfilters, ...);
+void starpu_data_map_filters(starpu_data_handle_t root_data, unsigned nfilters, ...);
 /* Same, but using va_list */
-void starpu_data_vmap_filters(starpu_data_handle root_data, unsigned nfilters, va_list pa);
+void starpu_data_vmap_filters(starpu_data_handle_t root_data, unsigned nfilters, va_list pa);
 
 /* a few examples of filters */
 

include/starpu_data_interfaces.h

@@ -102,7 +102,7 @@ enum starpu_data_interface_id {
 
 struct starpu_data_interface_ops {
 	/* Register an existing interface into a data handle. */
-	void (*register_data_handle)(starpu_data_handle handle,
+	void (*register_data_handle)(starpu_data_handle_t handle,
 					uint32_t home_node, void *data_interface);
 	/* Allocate data for the interface on a given node. */
 	starpu_ssize_t (*allocate_data_on_node)(void *data_interface, uint32_t node);
@@ -111,15 +111,15 @@ struct starpu_data_interface_ops {
 	/* ram/cuda/spu/opencl synchronous and asynchronous transfer methods */
 	const struct starpu_data_copy_methods *copy_methods;
 	/* Return the current pointer (if any) for the handle on the given node. */
-	void * (*handle_to_pointer)(starpu_data_handle handle, uint32_t node);
+	void * (*handle_to_pointer)(starpu_data_handle_t handle, uint32_t node);
 	/* Return an estimation of the size of data, for performance models */
-	size_t (*get_size)(starpu_data_handle handle);
+	size_t (*get_size)(starpu_data_handle_t handle);
 	/* Return a 32bit footprint which characterizes the data size */
-	uint32_t (*footprint)(starpu_data_handle handle);
+	uint32_t (*footprint)(starpu_data_handle_t handle);
 	/* Compare the data size of two interfaces */
 	int (*compare)(void *data_interface_a, void *data_interface_b);
 	/* Dump the sizes of a handle to a file */
-	void (*display)(starpu_data_handle handle, FILE *f);
+	void (*display)(starpu_data_handle_t handle, FILE *f);
 #ifdef STARPU_USE_GORDON
 	/* Convert the data size to the spu size format */
 	int (*convert_to_gordon)(void *data_interface, uint64_t *ptr, gordon_strideSize_t *ss); 
@@ -130,18 +130,18 @@ struct starpu_data_interface_ops {
 	size_t interface_size;
 };
 
-void starpu_data_register(starpu_data_handle *handleptr, uint32_t home_node,
+void starpu_data_register(starpu_data_handle_t *handleptr, uint32_t home_node,
 				void *data_interface,
 				struct starpu_data_interface_ops *ops);
 
 /* Return the pointer associated with HANDLE on node NODE or NULL if HANDLE's
  * interface does not support this operation or data for this handle is not
  * allocated on that node. */
-void *starpu_handle_to_pointer(starpu_data_handle handle, uint32_t node);
+void *starpu_handle_to_pointer(starpu_data_handle_t handle, uint32_t node);
 
 /* Return the local pointer associated with HANDLE or NULL if HANDLE's
  * interface does not have data allocated locally */
-void *starpu_handle_get_local_ptr(starpu_data_handle handle);
+void *starpu_handle_get_local_ptr(starpu_data_handle_t handle);
 
 /* "node" means memory node: 0 for main RAM, then 1, 2, etc. for various GPUs,
  * etc.
@@ -150,7 +150,7 @@ void *starpu_handle_get_local_ptr(starpu_data_handle handle);
  * case 0 should be passed.
  */
 
-void *starpu_data_get_interface_on_node(starpu_data_handle handle, unsigned memory_node);
+void *starpu_data_get_interface_on_node(starpu_data_handle_t handle, unsigned memory_node);
 
 /* Matrix interface for dense matrices */
 struct starpu_matrix_interface {
@@ -163,14 +163,14 @@ struct starpu_matrix_interface {
 	size_t elemsize;
 };
 
-void starpu_matrix_data_register(starpu_data_handle *handle, uint32_t home_node,
+void starpu_matrix_data_register(starpu_data_handle_t *handle, uint32_t home_node,
                         uintptr_t ptr, uint32_t ld, uint32_t nx,
                         uint32_t ny, size_t elemsize);
-uint32_t starpu_matrix_get_nx(starpu_data_handle handle);
-uint32_t starpu_matrix_get_ny(starpu_data_handle handle);
-uint32_t starpu_matrix_get_local_ld(starpu_data_handle handle);
-uintptr_t starpu_matrix_get_local_ptr(starpu_data_handle handle);
-size_t starpu_matrix_get_elemsize(starpu_data_handle handle);
+uint32_t starpu_matrix_get_nx(starpu_data_handle_t handle);
+uint32_t starpu_matrix_get_ny(starpu_data_handle_t handle);
+uint32_t starpu_matrix_get_local_ld(starpu_data_handle_t handle);
+uintptr_t starpu_matrix_get_local_ptr(starpu_data_handle_t handle);
+size_t starpu_matrix_get_elemsize(starpu_data_handle_t handle);
 
 /* helper methods */
 #define STARPU_MATRIX_GET_PTR(interface)	(((struct starpu_matrix_interface *)(interface))->ptr)
@@ -194,16 +194,16 @@ struct starpu_block_interface {
 	size_t elemsize;
 };
 
-void starpu_block_data_register(starpu_data_handle *handle, uint32_t home_node,
+void starpu_block_data_register(starpu_data_handle_t *handle, uint32_t home_node,
                         uintptr_t ptr, uint32_t ldy, uint32_t ldz, uint32_t nx,
                         uint32_t ny, uint32_t nz, size_t elemsize);
-uint32_t starpu_block_get_nx(starpu_data_handle handle);
-uint32_t starpu_block_get_ny(starpu_data_handle handle);
-uint32_t starpu_block_get_nz(starpu_data_handle handle);
-uint32_t starpu_block_get_local_ldy(starpu_data_handle handle);
-uint32_t starpu_block_get_local_ldz(starpu_data_handle handle);
-uintptr_t starpu_block_get_local_ptr(starpu_data_handle handle);
-size_t starpu_block_get_elemsize(starpu_data_handle handle);
+uint32_t starpu_block_get_nx(starpu_data_handle_t handle);
+uint32_t starpu_block_get_ny(starpu_data_handle_t handle);
+uint32_t starpu_block_get_nz(starpu_data_handle_t handle);
+uint32_t starpu_block_get_local_ldy(starpu_data_handle_t handle);
+uint32_t starpu_block_get_local_ldz(starpu_data_handle_t handle);
+uintptr_t starpu_block_get_local_ptr(starpu_data_handle_t handle);
+size_t starpu_block_get_elemsize(starpu_data_handle_t handle);
 
 /* helper methods */
 #define STARPU_BLOCK_GET_PTR(interface)	(((struct starpu_block_interface *)(interface))->ptr)
@@ -223,11 +223,11 @@ struct starpu_vector_interface {
 	size_t elemsize;
 };
 
-void starpu_vector_data_register(starpu_data_handle *handle, uint32_t home_node,
+void starpu_vector_data_register(starpu_data_handle_t *handle, uint32_t home_node,
                         uintptr_t ptr, uint32_t nx, size_t elemsize);
-uint32_t starpu_vector_get_nx(starpu_data_handle handle);
-size_t starpu_vector_get_elemsize(starpu_data_handle handle);
-uintptr_t starpu_vector_get_local_ptr(starpu_data_handle handle);
+uint32_t starpu_vector_get_nx(starpu_data_handle_t handle);
+size_t starpu_vector_get_elemsize(starpu_data_handle_t handle);
+uintptr_t starpu_vector_get_local_ptr(starpu_data_handle_t handle);
 
 /* helper methods */
 #define STARPU_VECTOR_GET_PTR(interface)	(((struct starpu_vector_interface *)(interface))->ptr)
@@ -240,10 +240,10 @@ struct starpu_variable_interface {
 	size_t elemsize;
 };
 
-void starpu_variable_data_register(starpu_data_handle *handle, uint32_t home_node,
+void starpu_variable_data_register(starpu_data_handle_t *handle, uint32_t home_node,
                         uintptr_t ptr, size_t elemsize);
-size_t starpu_variable_get_elemsize(starpu_data_handle handle);
-uintptr_t starpu_variable_get_local_ptr(starpu_data_handle handle);
+size_t starpu_variable_get_elemsize(starpu_data_handle_t handle);
+uintptr_t starpu_variable_get_local_ptr(starpu_data_handle_t handle);
 
 /* helper methods */
 #define STARPU_VARIABLE_GET_PTR(interface)	(((struct starpu_variable_interface *)(interface))->ptr)
@@ -254,7 +254,7 @@ uintptr_t starpu_variable_get_local_ptr(starpu_data_handle handle);
  * abstract piece of data that is managed by the application internally: this
  * makes it possible to forbid the concurrent execution of different tasks
  * accessing the same "void" data in read-write concurrently. */
-void starpu_void_data_register(starpu_data_handle *handleptr);
+void starpu_void_data_register(starpu_data_handle_t *handleptr);
 
 /* CSR interface for sparse matrices (compressed sparse row representation) */
 struct starpu_csr_interface {
@@ -271,15 +271,15 @@ struct starpu_csr_interface {
 	size_t elemsize;
 };
 
-void starpu_csr_data_register(starpu_data_handle *handle, uint32_t home_node, uint32_t nnz, uint32_t nrow,
+void starpu_csr_data_register(starpu_data_handle_t *handle, uint32_t home_node, uint32_t nnz, uint32_t nrow,
 		uintptr_t nzval, uint32_t *colind, uint32_t *rowptr, uint32_t firstentry, size_t elemsize);
-uint32_t starpu_csr_get_nnz(starpu_data_handle handle);
-uint32_t starpu_csr_get_nrow(starpu_data_handle handle);
-uint32_t starpu_csr_get_firstentry(starpu_data_handle handle);
-uintptr_t starpu_csr_get_local_nzval(starpu_data_handle handle);
-uint32_t *starpu_csr_get_local_colind(starpu_data_handle handle);
-uint32_t *starpu_csr_get_local_rowptr(starpu_data_handle handle);
-size_t starpu_csr_get_elemsize(starpu_data_handle handle);
+uint32_t starpu_csr_get_nnz(starpu_data_handle_t handle);
+uint32_t starpu_csr_get_nrow(starpu_data_handle_t handle);
+uint32_t starpu_csr_get_firstentry(starpu_data_handle_t handle);
+uintptr_t starpu_csr_get_local_nzval(starpu_data_handle_t handle);
+uint32_t *starpu_csr_get_local_colind(starpu_data_handle_t handle);
+uint32_t *starpu_csr_get_local_rowptr(starpu_data_handle_t handle);
+size_t starpu_csr_get_elemsize(starpu_data_handle_t handle);
 
 #define STARPU_CSR_GET_NNZ(interface)	(((struct starpu_csr_interface *)(interface))->nnz)
 #define STARPU_CSR_GET_NROW(interface)	(((struct starpu_csr_interface *)(interface))->nrow)
@@ -311,19 +311,19 @@ struct starpu_bcsr_interface {
 	size_t elemsize;
 };
 
-void starpu_bcsr_data_register(starpu_data_handle *handle, uint32_t home_node, uint32_t nnz, uint32_t nrow,
+void starpu_bcsr_data_register(starpu_data_handle_t *handle, uint32_t home_node, uint32_t nnz, uint32_t nrow,
 		uintptr_t nzval, uint32_t *colind, uint32_t *rowptr, uint32_t firstentry, uint32_t r, uint32_t c, size_t elemsize);
 
 
-uint32_t starpu_bcsr_get_nnz(starpu_data_handle handle);
-uint32_t starpu_bcsr_get_nrow(starpu_data_handle handle);
-uint32_t starpu_bcsr_get_firstentry(starpu_data_handle handle);
-uintptr_t starpu_bcsr_get_local_nzval(starpu_data_handle handle);
-uint32_t *starpu_bcsr_get_local_colind(starpu_data_handle handle);
-uint32_t *starpu_bcsr_get_local_rowptr(starpu_data_handle handle);
-uint32_t starpu_bcsr_get_r(starpu_data_handle handle);
-uint32_t starpu_bcsr_get_c(starpu_data_handle handle);
-size_t starpu_bcsr_get_elemsize(starpu_data_handle handle);
+uint32_t starpu_bcsr_get_nnz(starpu_data_handle_t handle);
+uint32_t starpu_bcsr_get_nrow(starpu_data_handle_t handle);
+uint32_t starpu_bcsr_get_firstentry(starpu_data_handle_t handle);
+uintptr_t starpu_bcsr_get_local_nzval(starpu_data_handle_t handle);
+uint32_t *starpu_bcsr_get_local_colind(starpu_data_handle_t handle);
+uint32_t *starpu_bcsr_get_local_rowptr(starpu_data_handle_t handle);
+uint32_t starpu_bcsr_get_r(starpu_data_handle_t handle);
+uint32_t starpu_bcsr_get_c(starpu_data_handle_t handle);
+size_t starpu_bcsr_get_elemsize(starpu_data_handle_t handle);
 
 /*
  * Multiformat interface
@@ -357,7 +357,7 @@ struct starpu_multiformat_interface {
 	double conversion_time;
 };
 
-void starpu_multiformat_data_register(starpu_data_handle *handle,
+void starpu_multiformat_data_register(starpu_data_handle_t *handle,
 				      uint32_t home_node,
 				      void *ptr,
 				      uint32_t nobjects,
@@ -375,10 +375,10 @@ void starpu_multiformat_data_register(starpu_data_handle *handle,
 
 #define STARPU_MULTIFORMAT_GET_NX(interface)  (((struct starpu_multiformat_interface *)(interface))->nx)
 
-enum starpu_data_interface_id starpu_get_handle_interface_id(starpu_data_handle handle);
+enum starpu_data_interface_id starpu_get_handle_interface_id(starpu_data_handle_t handle);
 
 /* Lookup a ram pointer into a StarPU handle */
-extern starpu_data_handle starpu_data_lookup(const void *ptr);
+extern starpu_data_handle_t starpu_data_lookup(const void *ptr);
 
 #ifdef __cplusplus
 }

include/starpu_scheduler.h

@@ -179,7 +179,7 @@ double starpu_worker_get_relative_speedup(enum starpu_perf_archtype perf_archtyp
 /* Returns expected data transfer time in µs */
 double starpu_task_expected_data_transfer_time(uint32_t memory_node, struct starpu_task *task);
 /* Predict the transfer time (in µs) to move a handle to a memory node */
-double starpu_data_expected_transfer_time(starpu_data_handle handle, unsigned memory_node, enum starpu_access_mode mode);
+double starpu_data_expected_transfer_time(starpu_data_handle_t handle, unsigned memory_node, enum starpu_access_mode mode);
 /* Returns expected power consumption in J */
 double starpu_task_expected_power(struct starpu_task *task, enum starpu_perf_archtype arch, unsigned nimpl);
 /* Returns expected conversion time in ms (multiformat interface only) */

include/starpu_util.h

@@ -228,7 +228,7 @@ void starpu_create_sync_task(starpu_tag sync_tag, unsigned ndeps, starpu_tag *de
  * (if enabled) or by calling starpu_task_wait_for_all(). If callback_func is
  * not NULL, this callback function is executed after the handle has been
  * copied, and it is given the callback_arg pointer as argument.*/
-int starpu_data_cpy(starpu_data_handle dst_handle, starpu_data_handle src_handle,
+int starpu_data_cpy(starpu_data_handle_t dst_handle, starpu_data_handle_t src_handle,
 			int asynchronous, void (*callback_func)(void*), void *callback_arg);
 
 /* Constants used by the starpu_insert_task helper to determine the different types of argument */

mpi/examples/cholesky/mpi_cholesky.c

@@ -70,14 +70,14 @@ static void dw_cholesky(float ***matA, unsigned size, unsigned ld, unsigned nblo
 {
 	struct timeval start;
 	struct timeval end;
-        starpu_data_handle **data_handles;
+        starpu_data_handle_t **data_handles;
         int x, y;
 
 	/* create all the DAG nodes */
 	unsigned i,j,k;
 
-        data_handles = malloc(nblocks*sizeof(starpu_data_handle *));
-        for(x=0 ; x<nblocks ; x++) data_handles[x] = malloc(nblocks*sizeof(starpu_data_handle));
+        data_handles = malloc(nblocks*sizeof(starpu_data_handle_t *));
+        for(x=0 ; x<nblocks ; x++) data_handles[x] = malloc(nblocks*sizeof(starpu_data_handle_t));
 
         for(x = 0; x < nblocks ;  x++) {
                 for (y = 0; y < nblocks; y++) {

mpi/examples/cholesky/mpi_cholesky_distributed.c

@@ -70,14 +70,14 @@ static void dw_cholesky(float ***matA, unsigned size, unsigned ld, unsigned nblo
 {
 	struct timeval start;
 	struct timeval end;
-        starpu_data_handle **data_handles;
+        starpu_data_handle_t **data_handles;
         int x, y;
 
 	/* create all the DAG nodes */
 	unsigned i,j,k;
 
-        data_handles = malloc(nblocks*sizeof(starpu_data_handle *));
-        for(x=0 ; x<nblocks ; x++) data_handles[x] = malloc(nblocks*sizeof(starpu_data_handle));
+        data_handles = malloc(nblocks*sizeof(starpu_data_handle_t *));
+        for(x=0 ; x<nblocks ; x++) data_handles[x] = malloc(nblocks*sizeof(starpu_data_handle_t));
 
 	starpu_mpi_barrier(MPI_COMM_WORLD);
 	gettimeofday(&start, NULL);

mpi/examples/mpi_lu/plu_example.c

@@ -40,27 +40,27 @@ static unsigned numa = 0;
 static size_t allocated_memory = 0;
 static size_t allocated_memory_extra = 0;
 
-static starpu_data_handle *dataA_handles;
+static starpu_data_handle_t *dataA_handles;
 static TYPE **dataA;
 
 /* In order to implement the distributed LU decomposition, we allocate
  * temporary buffers */
 #ifdef SINGLE_TMP11
-static starpu_data_handle tmp_11_block_handle;
+static starpu_data_handle_t tmp_11_block_handle;
 static TYPE *tmp_11_block;
 #else
-static starpu_data_handle *tmp_11_block_handles;
+static starpu_data_handle_t *tmp_11_block_handles;
 static TYPE **tmp_11_block;
 #endif
 #ifdef SINGLE_TMP1221
-static starpu_data_handle *tmp_12_block_handles;
+static starpu_data_handle_t *tmp_12_block_handles;
 static TYPE **tmp_12_block;
-static starpu_data_handle *tmp_21_block_handles;
+static starpu_data_handle_t *tmp_21_block_handles;
 static TYPE **tmp_21_block;
 #else
-static starpu_data_handle *(tmp_12_block_handles[2]);
+static starpu_data_handle_t *(tmp_12_block_handles[2]);
 static TYPE **(tmp_12_block[2]);
-static starpu_data_handle *(tmp_21_block_handles[2]);
+static starpu_data_handle_t *(tmp_21_block_handles[2]);
 static TYPE **(tmp_21_block[2]);
 #endif
 
@@ -127,34 +127,34 @@ static void fill_block_with_random(TYPE *blockptr, unsigned size, unsigned nbloc
 }
 
 #ifdef SINGLE_TMP11
-starpu_data_handle STARPU_PLU(get_tmp_11_block_handle)(void)
+starpu_data_handle_t STARPU_PLU(get_tmp_11_block_handle)(void)
 {
 	return tmp_11_block_handle;
 }
 #else
-starpu_data_handle STARPU_PLU(get_tmp_11_block_handle)(unsigned k)
+starpu_data_handle_t STARPU_PLU(get_tmp_11_block_handle)(unsigned k)
 {
 	return tmp_11_block_handles[k];
 }
 #endif
 
 #ifdef SINGLE_TMP1221
-starpu_data_handle STARPU_PLU(get_tmp_12_block_handle)(unsigned j)
+starpu_data_handle_t STARPU_PLU(get_tmp_12_block_handle)(unsigned j)
 {
 	return tmp_12_block_handles[j];
 }
 
-starpu_data_handle STARPU_PLU(get_tmp_21_block_handle)(unsigned i)
+starpu_data_handle_t STARPU_PLU(get_tmp_21_block_handle)(unsigned i)
 {
 	return tmp_21_block_handles[i];
 }
 #else
-starpu_data_handle STARPU_PLU(get_tmp_12_block_handle)(unsigned j, unsigned k)
+starpu_data_handle_t STARPU_PLU(get_tmp_12_block_handle)(unsigned j, unsigned k)
 {
 	return tmp_12_block_handles[k%2][j];
 }
 
-starpu_data_handle STARPU_PLU(get_tmp_21_block_handle)(unsigned i, unsigned k)
+starpu_data_handle_t STARPU_PLU(get_tmp_21_block_handle)(unsigned i, unsigned k)
 {
 	return tmp_21_block_handles[k%2][i];
 }
@@ -203,9 +203,9 @@ static void init_matrix(int rank)
 #endif
 
 	/* Allocate a grid of data handles, not all of them have to be allocated later on */
-	dataA_handles = calloc(nblocks*nblocks, sizeof(starpu_data_handle));
+	dataA_handles = calloc(nblocks*nblocks, sizeof(starpu_data_handle_t));
 	dataA = calloc(nblocks*nblocks, sizeof(TYPE *));
-	allocated_memory_extra += nblocks*nblocks*(sizeof(starpu_data_handle) + sizeof(TYPE *));
+	allocated_memory_extra += nblocks*nblocks*(sizeof(starpu_data_handle_t) + sizeof(TYPE *));
 
 	size_t blocksize = (size_t)(size/nblocks)*(size/nblocks)*sizeof(TYPE);
 
@@ -216,8 +216,8 @@ static void init_matrix(int rank)
 		for (i = 0; i < nblocks; i++)
 		{
 			TYPE **blockptr = &dataA[j+i*nblocks];
-//			starpu_data_handle *handleptr = &dataA_handles[j+nblocks*i];
-			starpu_data_handle *handleptr = &dataA_handles[j+nblocks*i];
+//			starpu_data_handle_t *handleptr = &dataA_handles[j+nblocks*i];
+			starpu_data_handle_t *handleptr = &dataA_handles[j+nblocks*i];
 
 			if (get_block_rank(i, j) == rank)
 			{
@@ -261,9 +261,9 @@ static void init_matrix(int rank)
 	starpu_matrix_data_register(&tmp_11_block_handle, 0, (uintptr_t)tmp_11_block,
 			size/nblocks, size/nblocks, size/nblocks, sizeof(TYPE));
 #else
-	tmp_11_block_handles = calloc(nblocks, sizeof(starpu_data_handle));
+	tmp_11_block_handles = calloc(nblocks, sizeof(starpu_data_handle_t));
 	tmp_11_block = calloc(nblocks, sizeof(TYPE *));
-	allocated_memory_extra += nblocks*(sizeof(starpu_data_handle) + sizeof(TYPE *));
+	allocated_memory_extra += nblocks*(sizeof(starpu_data_handle_t) + sizeof(TYPE *));
 
 	for (k = 0; k < nblocks; k++)
 	{
@@ -282,20 +282,20 @@ static void init_matrix(int rank)
 
 	/* tmp buffers 12 and 21 */
 #ifdef SINGLE_TMP1221
-	tmp_12_block_handles = calloc(nblocks, sizeof(starpu_data_handle));
-	tmp_21_block_handles = calloc(nblocks, sizeof(starpu_data_handle));
+	tmp_12_block_handles = calloc(nblocks, sizeof(starpu_data_handle_t));
+	tmp_21_block_handles = calloc(nblocks, sizeof(starpu_data_handle_t));
 	tmp_12_block = calloc(nblocks, sizeof(TYPE *));
 	tmp_21_block = calloc(nblocks, sizeof(TYPE *));
 
-	allocated_memory_extra += 2*nblocks*(sizeof(starpu_data_handle) + sizeof(TYPE *));
+	allocated_memory_extra += 2*nblocks*(sizeof(starpu_data_handle_t) + sizeof(TYPE *));
 #else
 	for (i = 0; i < 2; i++) {
-		tmp_12_block_handles[i] = calloc(nblocks, sizeof(starpu_data_handle));
-		tmp_21_block_handles[i] = calloc(nblocks, sizeof(starpu_data_handle));
+		tmp_12_block_handles[i] = calloc(nblocks, sizeof(starpu_data_handle_t));
+		tmp_21_block_handles[i] = calloc(nblocks, sizeof(starpu_data_handle_t));
 		tmp_12_block[i] = calloc(nblocks, sizeof(TYPE *));
 		tmp_21_block[i] = calloc(nblocks, sizeof(TYPE *));
 
-		allocated_memory_extra += 2*nblocks*(sizeof(starpu_data_handle) + sizeof(TYPE *));
+		allocated_memory_extra += 2*nblocks*(sizeof(starpu_data_handle_t) + sizeof(TYPE *));
 	}
 #endif
 	
@@ -365,7 +365,7 @@ int get_block_rank(unsigned i, unsigned j)
 	return (j % q) * p + (i % p);
 }
 
-starpu_data_handle STARPU_PLU(get_block_handle)(unsigned i, unsigned j)
+starpu_data_handle_t STARPU_PLU(get_block_handle)(unsigned i, unsigned j)
 {
 	return dataA_handles[j+i*nblocks];
 }
@@ -385,7 +385,7 @@ static void display_grid(int rank, unsigned nblocks)
 			for (i = 0; i < nblocks; i++)
 			{
 				TYPE *blockptr = STARPU_PLU(get_block)(i, j);
-				starpu_data_handle handle = STARPU_PLU(get_block_handle)(i, j);
+				starpu_data_handle_t handle = STARPU_PLU(get_block_handle)(i, j);
 
 				fprintf(stderr, "%d (data %p handle %p)", get_block_rank(i, j), blockptr, handle);
 			}

mpi/examples/mpi_lu/pxlu.c

@@ -90,7 +90,7 @@ static struct starpu_task *create_task(starpu_tag id)
 
 /* Send handle to every node appearing in the mask, and unlock tag once the
  * transfers are done. */
-static void send_data_to_mask(starpu_data_handle handle, int *rank_mask, int mpi_tag, starpu_tag tag)
+static void send_data_to_mask(starpu_data_handle_t handle, int *rank_mask, int mpi_tag, starpu_tag tag)
 {
 	unsigned cnt = 0;
 
@@ -99,7 +99,7 @@ static void send_data_to_mask(starpu_data_handle handle, int *rank_mask, int mpi
 	int rank_array[world_size];
 	MPI_Comm comm_array[world_size];
 	int mpi_tag_array[world_size];
-	starpu_data_handle handle_array[world_size];
+	starpu_data_handle_t handle_array[world_size];
 
 	unsigned r;
 	for (r = 0; r < world_size; r++)
@@ -132,7 +132,7 @@ static void send_data_to_mask(starpu_data_handle handle, int *rank_mask, int mpi
 struct recv_when_done_callback_arg {
 	int source;
 	int mpi_tag;
-	starpu_data_handle handle;
+	starpu_data_handle_t handle;
 	starpu_tag unlocked_tag;
 };
 
@@ -148,7 +148,7 @@ static void callback_receive_when_done(void *_arg)
 
 static void receive_when_deps_are_done(unsigned ndeps, starpu_tag *deps_tags,
 				int source, int mpi_tag,
-				starpu_data_handle handle,
+				starpu_data_handle_t handle,
 				starpu_tag partial_tag,
 				starpu_tag unlocked_tag)
 {
@@ -206,9 +206,9 @@ static void create_task_11_recv(unsigned k)
 	
 	int source = get_block_rank(k, k);
 #ifdef SINGLE_TMP11
-	starpu_data_handle block_handle = STARPU_PLU(get_tmp_11_block_handle)();
+	starpu_data_handle_t block_handle = STARPU_PLU(get_tmp_11_block_handle)();
 #else
-	starpu_data_handle block_handle = STARPU_PLU(get_tmp_11_block_handle)(k);
+	starpu_data_handle_t block_handle = STARPU_PLU(get_tmp_11_block_handle)(k);
 #endif
 	int mpi_tag = MPI_TAG11(k);
 	starpu_tag partial_tag = TAG11_SAVE_PARTIAL(k);
@@ -250,7 +250,7 @@ static void callback_task_11_real(void *_arg)
 	rank_mask[rank] = 0;
 
 	/* Send the block to those nodes */
-	starpu_data_handle block_handle = STARPU_PLU(get_block_handle)(k, k);
+	starpu_data_handle_t block_handle = STARPU_PLU(get_block_handle)(k, k);
 	starpu_tag tag = TAG11_SAVE(k);
 	int mpi_tag = MPI_TAG11(k);
 	send_data_to_mask(block_handle, rank_mask, mpi_tag, tag);
@@ -357,9 +357,9 @@ static void create_task_12_recv(unsigned k, unsigned j)
 	
 	int source = get_block_rank(k, j);
 #ifdef SINGLE_TMP1221
-	starpu_data_handle block_handle = STARPU_PLU(get_tmp_12_block_handle)(j);
+	starpu_data_handle_t block_handle = STARPU_PLU(get_tmp_12_block_handle)(j);
 #else
-	starpu_data_handle block_handle = STARPU_PLU(get_tmp_12_block_handle)(j,k);
+	starpu_data_handle_t block_handle = STARPU_PLU(get_tmp_12_block_handle)(j,k);
 #endif
 	int mpi_tag = MPI_TAG12(k, j);
 	starpu_tag partial_tag = TAG12_SAVE_PARTIAL(k, j);
@@ -394,7 +394,7 @@ static void callback_task_12_real(void *_arg)
 	rank_mask[rank] = 0;
 
 	/* Send the block to those nodes */
-	starpu_data_handle block_handle = STARPU_PLU(get_block_handle)(k, j);
+	starpu_data_handle_t block_handle = STARPU_PLU(get_block_handle)(k, j);
 	starpu_tag tag = TAG12_SAVE(k, j);
 	int mpi_tag = MPI_TAG12(k, j);
 	send_data_to_mask(block_handle, rank_mask, mpi_tag, tag);
@@ -417,7 +417,7 @@ static void create_task_12_real(unsigned k, unsigned j)
 	starpu_tag tag_11_dep; 
 
 	/* which sub-data is manipulated ? */
-	starpu_data_handle diag_block;
+	starpu_data_handle_t diag_block;
 	if (diag_block_is_local)
 	{
 		diag_block = STARPU_PLU(get_block_handle)(k, k);
@@ -529,9 +529,9 @@ static void create_task_21_recv(unsigned k, unsigned i)
 
 	int source = get_block_rank(i, k);
 #ifdef SINGLE_TMP1221
-	starpu_data_handle block_handle = STARPU_PLU(get_tmp_21_block_handle)(i);
+	starpu_data_handle_t block_handle = STARPU_PLU(get_tmp_21_block_handle)(i);
 #else
-	starpu_data_handle block_handle = STARPU_PLU(get_tmp_21_block_handle)(i, k);
+	starpu_data_handle_t block_handle = STARPU_PLU(get_tmp_21_block_handle)(i, k);
 #endif
 	int mpi_tag = MPI_TAG21(k, i);
 	starpu_tag partial_tag = TAG21_SAVE_PARTIAL(k, i);
@@ -567,7 +567,7 @@ static void callback_task_21_real(void *_arg)
 	rank_mask[rank] = 0;
 
 	/* Send the block to those nodes */
-	starpu_data_handle block_handle = STARPU_PLU(get_block_handle)(i, k);
+	starpu_data_handle_t block_handle = STARPU_PLU(get_block_handle)(i, k);
 	starpu_tag tag = TAG21_SAVE(k, i);
 	int mpi_tag = MPI_TAG21(k, i);
 	send_data_to_mask(block_handle, rank_mask, mpi_tag, tag);
@@ -590,7 +590,7 @@ static void create_task_21_real(unsigned k, unsigned i)
 	starpu_tag tag_11_dep; 
 	
 	/* which sub-data is manipulated ? */
-	starpu_data_handle diag_block;
+	starpu_data_handle_t diag_block;
 	if (diag_block_is_local)
 	{
 		diag_block = STARPU_PLU(get_block_handle)(k, k);
@@ -685,7 +685,7 @@ static void create_task_22_real(unsigned k, unsigned i, unsigned j)
 	unsigned block21_is_local = (get_block_rank(i, k) == rank);
 	starpu_tag tag_21_dep;
 
-	starpu_data_handle block21;
+	starpu_data_handle_t block21;
 	if (block21_is_local)
 	{
 		block21 = STARPU_PLU(get_block_handle)(i, k);
@@ -705,7 +705,7 @@ static void create_task_22_real(unsigned k, unsigned i, unsigned j)
 	unsigned block12_is_local = (get_block_rank(k, j) == rank);
 	starpu_tag tag_12_dep;
 
-	starpu_data_handle block12;
+	starpu_data_handle_t block12;
 	if (block12_is_local)
 	{
 	//	block12 = STARPU_PLU(get_block_handle)(j, k);
@@ -768,7 +768,7 @@ static void create_task_22(unsigned k, unsigned i, unsigned j)
 //	}
 }
 
-static void wait_tag_and_fetch_handle(starpu_tag tag, starpu_data_handle handle)
+static void wait_tag_and_fetch_handle(starpu_tag tag, starpu_data_handle_t handle)
 {
 	STARPU_ASSERT(handle != STARPU_POISON_PTR);
 
@@ -788,7 +788,7 @@ static void wait_termination(void)
 		/* Wait task 11k if needed */
 		if (get_block_rank(k, k) == rank)
 		{
-			starpu_data_handle diag_block = STARPU_PLU(get_block_handle)(k, k);
+			starpu_data_handle_t diag_block = STARPU_PLU(get_block_handle)(k, k);
 			wait_tag_and_fetch_handle(TAG11_SAVE(k), diag_block);
 		}
 		
@@ -798,8 +798,8 @@ static void wait_termination(void)
 			/* Wait task 21ki if needed */
 			if (get_block_rank(i, k) == rank)
 			{
-				starpu_data_handle block21 = STARPU_PLU(get_block_handle)(i, k);
-				//starpu_data_handle block21 = STARPU_PLU(get_block_handle)(k, i);
+				starpu_data_handle_t block21 = STARPU_PLU(get_block_handle)(i, k);
+				//starpu_data_handle_t block21 = STARPU_PLU(get_block_handle)(k, i);
 				//fprintf(stderr, "BLOCK21 i %d k %d -> handle %p\n", i, k, block21);
 				wait_tag_and_fetch_handle(TAG21_SAVE(k, i), block21);
 			}
@@ -810,8 +810,8 @@ static void wait_termination(void)
 			/* Wait task 12kj if needed */
 			if (get_block_rank(k, j) == rank)
 			{
-				//starpu_data_handle block12 = STARPU_PLU(get_block_handle)(j, k);
-				starpu_data_handle block12 = STARPU_PLU(get_block_handle)(k, j);
+				//starpu_data_handle_t block12 = STARPU_PLU(get_block_handle)(j, k);
+				starpu_data_handle_t block12 = STARPU_PLU(get_block_handle)(k, j);
 				//fprintf(stderr, "BLOCK12 j %d k %d -> handle %p\n", j, k, block12);
 				wait_tag_and_fetch_handle(TAG12_SAVE(k, j), block12);
 			}

mpi/examples/mpi_lu/pxlu.h

@@ -48,19 +48,19 @@ unsigned STARPU_PLU(display_flag)(void);
 
 void STARPU_PLU(compute_ax)(unsigned size, TYPE *x, TYPE *y, unsigned nblocks, int rank);
 void STARPU_PLU(compute_lux)(unsigned size, TYPE *x, TYPE *y, unsigned nblocks, int rank);
-starpu_data_handle STARPU_PLU(get_block_handle)(unsigned i, unsigned j);
+starpu_data_handle_t STARPU_PLU(get_block_handle)(unsigned i, unsigned j);
 TYPE *STARPU_PLU(get_block)(unsigned i, unsigned j);
 #ifdef SINGLE_TMP11
-starpu_data_handle STARPU_PLU(get_tmp_11_block_handle)(void);
+starpu_data_handle_t STARPU_PLU(get_tmp_11_block_handle)(void);
 #else
-starpu_data_handle STARPU_PLU(get_tmp_11_block_handle)(unsigned k);
+starpu_data_handle_t STARPU_PLU(get_tmp_11_block_handle)(unsigned k);
 #endif
 #ifdef SINGLE_TMP1221
-starpu_data_handle STARPU_PLU(get_tmp_12_block_handle)(unsigned j);
-starpu_data_handle STARPU_PLU(get_tmp_21_block_handle)(unsigned i);
+starpu_data_handle_t STARPU_PLU(get_tmp_12_block_handle)(unsigned j);
+starpu_data_handle_t STARPU_PLU(get_tmp_21_block_handle)(unsigned i);
 #else
-starpu_data_handle STARPU_PLU(get_tmp_12_block_handle)(unsigned j, unsigned k);
-starpu_data_handle STARPU_PLU(get_tmp_21_block_handle)(unsigned i, unsigned k);
+starpu_data_handle_t STARPU_PLU(get_tmp_12_block_handle)(unsigned j, unsigned k);
+starpu_data_handle_t STARPU_PLU(get_tmp_21_block_handle)(unsigned i, unsigned k);
 #endif
 
 void STARPU_PLU(display_data_content)(TYPE *data, unsigned blocksize);

mpi/examples/scatter_gather/mpi_scatter_gather.c

@@ -56,7 +56,7 @@ int main(int argc, char **argv)
 {
         int rank, nodes;
 	float ***bmat;
-        starpu_data_handle *data_handles;
+        starpu_data_handle_t *data_handles;
 
 	unsigned i,j,x,y;
 
@@ -117,7 +117,7 @@ int main(int argc, char **argv)
 #endif
 
 	/* Allocate data handles and register data to StarPU */
-        data_handles = malloc(nblocks*nblocks*sizeof(starpu_data_handle *));
+        data_handles = malloc(nblocks*nblocks*sizeof(starpu_data_handle_t *));
         for(x = 0; x < nblocks ;  x++)
 	{
                 for (y = 0; y < nblocks; y++)

mpi/examples/stencil/stencil5.c

@@ -68,7 +68,7 @@ int main(int argc, char **argv)
         int my_rank, size, x, y, loop;
         int value=0, mean=0;
         unsigned matrix[X][Y];
-        starpu_data_handle data_handles[X][Y];
+        starpu_data_handle_t data_handles[X][Y];
 
 	starpu_init(NULL);
 	starpu_mpi_initialize_extended(&my_rank, &size);

mpi/starpu_mpi.c

@@ -73,7 +73,7 @@ static void starpu_mpi_isend_func(struct starpu_mpi_req_s *req)
         _STARPU_MPI_LOG_OUT();
 }
 
-static struct starpu_mpi_req_s *_starpu_mpi_isend_common(starpu_data_handle data_handle,
+static struct starpu_mpi_req_s *_starpu_mpi_isend_common(starpu_data_handle_t data_handle,
 				int dest, int mpi_tag, MPI_Comm comm,
 				unsigned detached, void (*callback)(void *), void *arg)
 {
@@ -111,7 +111,7 @@ static struct starpu_mpi_req_s *_starpu_mpi_isend_common(starpu_data_handle data
 	return req;
 }
 
-int starpu_mpi_isend(starpu_data_handle data_handle, starpu_mpi_req *public_req, int dest, int mpi_tag, MPI_Comm comm)
+int starpu_mpi_isend(starpu_data_handle_t data_handle, starpu_mpi_req *public_req, int dest, int mpi_tag, MPI_Comm comm)
 {
         _STARPU_MPI_LOG_IN();
 	STARPU_ASSERT(public_req);
@@ -130,7 +130,7 @@ int starpu_mpi_isend(starpu_data_handle data_handle, starpu_mpi_req *public_req,
  *	Isend (detached)
  */
 
-int starpu_mpi_isend_detached(starpu_data_handle data_handle,
+int starpu_mpi_isend_detached(starpu_data_handle_t data_handle,
 				int dest, int mpi_tag, MPI_Comm comm, void (*callback)(void *), void *arg)
 {
         _STARPU_MPI_LOG_IN();
@@ -165,7 +165,7 @@ static void starpu_mpi_irecv_func(struct starpu_mpi_req_s *req)
         _STARPU_MPI_LOG_OUT();
 }
 
-static struct starpu_mpi_req_s *_starpu_mpi_irecv_common(starpu_data_handle data_handle, int source, int mpi_tag, MPI_Comm comm, unsigned detached, void (*callback)(void *), void *arg)
+static struct starpu_mpi_req_s *_starpu_mpi_irecv_common(starpu_data_handle_t data_handle, int source, int mpi_tag, MPI_Comm comm, unsigned detached, void (*callback)(void *), void *arg)
 {
         _STARPU_MPI_LOG_IN();
 	struct starpu_mpi_req_s *req = calloc(1, sizeof(struct starpu_mpi_req_s));
@@ -200,7 +200,7 @@ static struct starpu_mpi_req_s *_starpu_mpi_irecv_common(starpu_data_handle data
 	return req;
 }
 
-int starpu_mpi_irecv(starpu_data_handle data_handle, starpu_mpi_req *public_req, int source, int mpi_tag, MPI_Comm comm)
+int starpu_mpi_irecv(starpu_data_handle_t data_handle, starpu_mpi_req *public_req, int source, int mpi_tag, MPI_Comm comm)
 {
         _STARPU_MPI_LOG_IN();
 	STARPU_ASSERT(public_req);
@@ -219,7 +219,7 @@ int starpu_mpi_irecv(starpu_data_handle data_handle, starpu_mpi_req *public_req,
  *	Irecv (detached)
  */
 
-int starpu_mpi_irecv_detached(starpu_data_handle data_handle, int source, int mpi_tag, MPI_Comm comm, void (*callback)(void *), void *arg)
+int starpu_mpi_irecv_detached(starpu_data_handle_t data_handle, int source, int mpi_tag, MPI_Comm comm, void (*callback)(void *), void *arg)
 {
         _STARPU_MPI_LOG_IN();
 	_starpu_mpi_irecv_common(data_handle, source, mpi_tag, comm, 1, callback, arg);
@@ -233,7 +233,7 @@ int starpu_mpi_irecv_detached(starpu_data_handle data_handle, int source, int mp
  *	Recv
  */
 
-int starpu_mpi_recv(starpu_data_handle data_handle, int source, int mpi_tag, MPI_Comm comm, MPI_Status *status)
+int starpu_mpi_recv(starpu_data_handle_t data_handle, int source, int mpi_tag, MPI_Comm comm, MPI_Status *status)
 {
 	starpu_mpi_req req;
 
@@ -249,7 +249,7 @@ int starpu_mpi_recv(starpu_data_handle data_handle, int source, int mpi_tag, MPI
  *	Send
  */
 
-int starpu_mpi_send(starpu_data_handle data_handle, int dest, int mpi_tag, MPI_Comm comm)
+int starpu_mpi_send(starpu_data_handle_t data_handle, int dest, int mpi_tag, MPI_Comm comm)
 {
 	starpu_mpi_req req;
 	MPI_Status status;

mpi/starpu_mpi.h

@@ -27,12 +27,12 @@ extern "C" {
 
 typedef void *starpu_mpi_req;
 
-int starpu_mpi_isend(starpu_data_handle data_handle, starpu_mpi_req *req, int dest, int mpi_tag, MPI_Comm comm);
-int starpu_mpi_irecv(starpu_data_handle data_handle, starpu_mpi_req *req, int source, int mpi_tag, MPI_Comm comm);
-int starpu_mpi_send(starpu_data_handle data_handle, int dest, int mpi_tag, MPI_Comm comm);
-int starpu_mpi_recv(starpu_data_handle data_handle, int source, int mpi_tag, MPI_Comm comm, MPI_Status *status);
-int starpu_mpi_isend_detached(starpu_data_handle data_handle, int dest, int mpi_tag, MPI_Comm comm, void (*callback)(void *), void *arg);
-int starpu_mpi_irecv_detached(starpu_data_handle data_handle, int source, int mpi_tag, MPI_Comm comm, void (*callback)(void *), void *arg);
+int starpu_mpi_isend(starpu_data_handle_t data_handle, starpu_mpi_req *req, int dest, int mpi_tag, MPI_Comm comm);
+int starpu_mpi_irecv(starpu_data_handle_t data_handle, starpu_mpi_req *req, int source, int mpi_tag, MPI_Comm comm);
+int starpu_mpi_send(starpu_data_handle_t data_handle, int dest, int mpi_tag, MPI_Comm comm);
+int starpu_mpi_recv(starpu_data_handle_t data_handle, int source, int mpi_tag, MPI_Comm comm, MPI_Status *status);
+int starpu_mpi_isend_detached(starpu_data_handle_t data_handle, int dest, int mpi_tag, MPI_Comm comm, void (*callback)(void *), void *arg);
+int starpu_mpi_irecv_detached(starpu_data_handle_t data_handle, int source, int mpi_tag, MPI_Comm comm, void (*callback)(void *), void *arg);
 int starpu_mpi_wait(starpu_mpi_req *req, MPI_Status *status);
 int starpu_mpi_test(starpu_mpi_req *req, int *flag, MPI_Status *status);
 int starpu_mpi_barrier(MPI_Comm comm);
@@ -41,24 +41,24 @@ int starpu_mpi_initialize_extended(int *rank, int *world_size);
 int starpu_mpi_shutdown(void);
 
 int starpu_mpi_insert_task(MPI_Comm comm, starpu_codelet *codelet, ...);
-void starpu_mpi_get_data_on_node(MPI_Comm comm, starpu_data_handle data_handle, int node);
+void starpu_mpi_get_data_on_node(MPI_Comm comm, starpu_data_handle_t data_handle, int node);
 
-int starpu_mpi_scatter_detached(starpu_data_handle *data_handles, int count, int root, MPI_Comm comm);
-int starpu_mpi_gather_detached(starpu_data_handle *data_handles, int count, int root, MPI_Comm comm);
+int starpu_mpi_scatter_detached(starpu_data_handle_t *data_handles, int count, int root, MPI_Comm comm);
+int starpu_mpi_gather_detached(starpu_data_handle_t *data_handles, int count, int root, MPI_Comm comm);
 
 /* Some helper functions */
 
 /* When the transfer is completed, the tag is unlocked */
-int starpu_mpi_isend_detached_unlock_tag(starpu_data_handle data_handle, int dest, int mpi_tag, MPI_Comm comm, starpu_tag tag);
-int starpu_mpi_irecv_detached_unlock_tag(starpu_data_handle data_handle, int source, int mpi_tag, MPI_Comm comm, starpu_tag tag);
+int starpu_mpi_isend_detached_unlock_tag(starpu_data_handle_t data_handle, int dest, int mpi_tag, MPI_Comm comm, starpu_tag tag);
+int starpu_mpi_irecv_detached_unlock_tag(starpu_data_handle_t data_handle, int source, int mpi_tag, MPI_Comm comm, starpu_tag tag);
 
 /* Asynchronously send an array of buffers, and unlocks the tag once all of
  * them are transmitted. */
 int starpu_mpi_isend_array_detached_unlock_tag(unsigned array_size,
-		starpu_data_handle *data_handle, int *dest, int *mpi_tag,
+		starpu_data_handle_t *data_handle, int *dest, int *mpi_tag,
 		MPI_Comm *comm, starpu_tag tag);
 int starpu_mpi_irecv_array_detached_unlock_tag(unsigned array_size,
-		starpu_data_handle *data_handle, int *source, int *mpi_tag,
+		starpu_data_handle_t *data_handle, int *source, int *mpi_tag,
 		MPI_Comm *comm, starpu_tag tag);
 
 #ifdef __cplusplus

mpi/starpu_mpi_collective.c

@@ -18,7 +18,7 @@
 #include <starpu.h>
 #include <starpu_mpi.h>
 
-int starpu_mpi_scatter_detached(starpu_data_handle *data_handles, int count, int root, MPI_Comm comm)
+int starpu_mpi_scatter_detached(starpu_data_handle_t *data_handles, int count, int root, MPI_Comm comm)
 {
 	int rank;
 	int x;
@@ -47,7 +47,7 @@ int starpu_mpi_scatter_detached(starpu_data_handle *data_handles, int count, int
 	return 0;
 }
 
-int starpu_mpi_gather_detached(starpu_data_handle *data_handles, int count, int root, MPI_Comm comm)
+int starpu_mpi_gather_detached(starpu_data_handle_t *data_handles, int count, int root, MPI_Comm comm)
 {
 	int rank;
 	int x;

mpi/starpu_mpi_datatype.c

@@ -22,14 +22,14 @@
  *	a datatype and the datatype itself, so we need to provide both.
  */
 
-typedef int (*handle_to_datatype_func)(starpu_data_handle, MPI_Datatype *);
-typedef void *(*handle_to_ptr_func)(starpu_data_handle);
+typedef int (*handle_to_datatype_func)(starpu_data_handle_t, MPI_Datatype *);
+typedef void *(*handle_to_ptr_func)(starpu_data_handle_t);
 
 /*
  * 	Matrix
  */
 
-static int handle_to_datatype_matrix(starpu_data_handle data_handle, MPI_Datatype *datatype)
+static int handle_to_datatype_matrix(starpu_data_handle_t data_handle, MPI_Datatype *datatype)
 {
 	int ret;
 
@@ -51,7 +51,7 @@ static int handle_to_datatype_matrix(starpu_data_handle data_handle, MPI_Datatyp
  * 	Block
  */
 
-static int handle_to_datatype_block(starpu_data_handle data_handle, MPI_Datatype *datatype)
+static int handle_to_datatype_block(starpu_data_handle_t data_handle, MPI_Datatype *datatype)
 {
 	int ret;
 
@@ -82,7 +82,7 @@ static int handle_to_datatype_block(starpu_data_handle data_handle, MPI_Datatype
  * 	Vector
  */
 
-static int handle_to_datatype_vector(starpu_data_handle data_handle, MPI_Datatype *datatype)
+static int handle_to_datatype_vector(starpu_data_handle_t data_handle, MPI_Datatype *datatype)
 {
 	int ret;
 
@@ -102,7 +102,7 @@ static int handle_to_datatype_vector(starpu_data_handle data_handle, MPI_Datatyp
  * 	Variable
  */
 
-static int handle_to_datatype_variable(starpu_data_handle data_handle, MPI_Datatype *datatype)
+static int handle_to_datatype_variable(starpu_data_handle_t data_handle, MPI_Datatype *datatype)
 {
 	int ret;
 
@@ -131,7 +131,7 @@ static handle_to_datatype_func handle_to_datatype_funcs[STARPU_NINTERFACES_ID] =
 };
 
 
-int starpu_mpi_handle_to_datatype(starpu_data_handle data_handle, MPI_Datatype *datatype)
+int starpu_mpi_handle_to_datatype(starpu_data_handle_t data_handle, MPI_Datatype *datatype)
 {
 	unsigned id = starpu_get_handle_interface_id(data_handle);
 
@@ -142,7 +142,7 @@ int starpu_mpi_handle_to_datatype(starpu_data_handle data_handle, MPI_Datatype *
 	return func(data_handle, datatype);
 }
 
-void *starpu_mpi_handle_to_ptr(starpu_data_handle data_handle)
+void *starpu_mpi_handle_to_ptr(starpu_data_handle_t data_handle)
 {
 	return (void*) starpu_handle_get_local_ptr(data_handle);
 }

mpi/starpu_mpi_datatype.h

@@ -24,8 +24,8 @@
 extern "C" {
 #endif
 
-int starpu_mpi_handle_to_datatype(starpu_data_handle data_handle, MPI_Datatype *datatype);
-void *starpu_mpi_handle_to_ptr(starpu_data_handle data_handle);
+int starpu_mpi_handle_to_datatype(starpu_data_handle_t data_handle, MPI_Datatype *datatype);
+void *starpu_mpi_handle_to_ptr(starpu_data_handle_t data_handle);
 
 #ifdef __cplusplus
 }

mpi/starpu_mpi_helper.c

@@ -26,7 +26,7 @@ static void starpu_mpi_unlock_tag_callback(void *arg)
 	free(tagptr);
 }
 
-int starpu_mpi_isend_detached_unlock_tag(starpu_data_handle data_handle,
+int starpu_mpi_isend_detached_unlock_tag(starpu_data_handle_t data_handle,
 				int dest, int mpi_tag, MPI_Comm comm, starpu_tag tag)
 {
 	starpu_tag *tagptr = malloc(sizeof(starpu_tag));
@@ -37,7 +37,7 @@ int starpu_mpi_isend_detached_unlock_tag(starpu_data_handle data_handle,
 }
 
 
-int starpu_mpi_irecv_detached_unlock_tag(starpu_data_handle data_handle, int source, int mpi_tag, MPI_Comm comm, starpu_tag tag)
+int starpu_mpi_irecv_detached_unlock_tag(starpu_data_handle_t data_handle, int source, int mpi_tag, MPI_Comm comm, starpu_tag tag)
 {
 	starpu_tag *tagptr = malloc(sizeof(starpu_tag));
 	*tagptr = tag;
@@ -65,7 +65,7 @@ static void starpu_mpi_array_unlock_callback(void *_arg)
 }
 
 int starpu_mpi_isend_array_detached_unlock_tag(unsigned array_size,
-		starpu_data_handle *data_handle, int *dest, int *mpi_tag,
+		starpu_data_handle_t *data_handle, int *dest, int *mpi_tag,
 		MPI_Comm *comm, starpu_tag tag)
 {
 	struct arg_array *arg = malloc(sizeof(struct arg_array));
@@ -85,7 +85,7 @@ int starpu_mpi_isend_array_detached_unlock_tag(unsigned array_size,
 }
 
 
-int starpu_mpi_irecv_array_detached_unlock_tag(unsigned array_size, starpu_data_handle *data_handle, int *source, int *mpi_tag, MPI_Comm *comm, starpu_tag tag)
+int starpu_mpi_irecv_array_detached_unlock_tag(unsigned array_size, starpu_data_handle_t *data_handle, int *source, int *mpi_tag, MPI_Comm *comm, starpu_tag tag)
 {
 	struct arg_array *arg = malloc(sizeof(struct arg_array));
 

mpi/starpu_mpi_insert_task.c

@@ -49,7 +49,7 @@ static void _starpu_mpi_task_init(int nb_nodes)
 }
 
 typedef struct _starpu_mpi_clear_cache_s {
-        starpu_data_handle data;
+        starpu_data_handle_t data;
         int rank;
         int mode;
 } _starpu_mpi_clear_cache_t;
@@ -74,7 +74,7 @@ void _starpu_mpi_clear_cache_callback(void *callback_arg)
         free(clear_cache);
 }
 
-void _starpu_mpi_clear_cache_request(starpu_data_handle data_handle, int rank, int mode)
+void _starpu_mpi_clear_cache_request(starpu_data_handle_t data_handle, int rank, int mode)
 {
         struct starpu_task *task = starpu_task_create();
         task->cl = NULL;
@@ -93,7 +93,7 @@ void _starpu_mpi_clear_cache_request(starpu_data_handle data_handle, int rank, i
 }
 #endif
 
-void _starpu_data_deallocate(starpu_data_handle data_handle)
+void _starpu_data_deallocate(starpu_data_handle_t data_handle)
 {
 #ifdef STARPU_DEVEL
 #warning _starpu_data_deallocate not implemented yet
@@ -136,11 +136,11 @@ int starpu_mpi_insert_task(MPI_Comm comm, starpu_codelet *codelet, ...)
                         execute = va_arg(varg_list, int);
                 }
 		else if (arg_type==STARPU_EXECUTE_ON_DATA) {
-			starpu_data_handle data = va_arg(varg_list, starpu_data_handle);
+			starpu_data_handle_t data = va_arg(varg_list, starpu_data_handle_t);
                         execute = starpu_data_get_rank(data);
                 }
 		else if (arg_type==STARPU_R || arg_type==STARPU_W || arg_type==STARPU_RW || arg_type == STARPU_SCRATCH) {
-                        va_arg(varg_list, starpu_data_handle);
+                        va_arg(varg_list, starpu_data_handle_t);
                 }
 		else if (arg_type==STARPU_VALUE) {
 			va_arg(varg_list, void *);
@@ -168,7 +168,7 @@ int starpu_mpi_insert_task(MPI_Comm comm, starpu_codelet *codelet, ...)
 	va_start(varg_list, codelet);
 	while ((arg_type = va_arg(varg_list, int)) != 0) {
 		if (arg_type==STARPU_R || arg_type==STARPU_W || arg_type==STARPU_RW || arg_type == STARPU_SCRATCH) {
-                        starpu_data_handle data = va_arg(varg_list, starpu_data_handle);
+                        starpu_data_handle_t data = va_arg(varg_list, starpu_data_handle_t);
                         if (arg_type & STARPU_W) {
                                 if (!data) {
                                         /* We don't have anything allocated for this.
@@ -250,7 +250,7 @@ int starpu_mpi_insert_task(MPI_Comm comm, starpu_codelet *codelet, ...)
 	va_start(varg_list, codelet);
 	while ((arg_type = va_arg(varg_list, int)) != 0) {
 		if (arg_type==STARPU_R || arg_type==STARPU_W || arg_type==STARPU_RW || arg_type == STARPU_SCRATCH) {
-                        starpu_data_handle data = va_arg(varg_list, starpu_data_handle);
+                        starpu_data_handle_t data = va_arg(varg_list, starpu_data_handle_t);
                         if (data && arg_type & STARPU_R) {
                                 int mpi_rank = starpu_data_get_rank(data);
 				int mpi_tag = starpu_data_get_tag(data);
@@ -315,7 +315,7 @@ int starpu_mpi_insert_task(MPI_Comm comm, starpu_codelet *codelet, ...)
 			va_arg(varg_list, int);
 		}
 		else if (arg_type==STARPU_EXECUTE_ON_DATA) {
-			va_arg(varg_list, starpu_data_handle);
+			va_arg(varg_list, starpu_data_handle_t);
 		}
         }
 	va_end(varg_list);
@@ -333,7 +333,7 @@ int starpu_mpi_insert_task(MPI_Comm comm, starpu_codelet *codelet, ...)
                 va_start(varg_list, codelet);
                 while ((arg_type = va_arg(varg_list, int)) != 0) {
                         if (arg_type==STARPU_R || arg_type==STARPU_W || arg_type==STARPU_RW || arg_type == STARPU_SCRATCH) {
-                                starpu_data_handle data = va_arg(varg_list, starpu_data_handle);
+                                starpu_data_handle_t data = va_arg(varg_list, starpu_data_handle_t);
                                 if (arg_type & STARPU_W) {
                                         int mpi_rank = starpu_data_get_rank(data);
 					int mpi_tag = starpu_data_get_tag(data);
@@ -371,7 +371,7 @@ int starpu_mpi_insert_task(MPI_Comm comm, starpu_codelet *codelet, ...)
                                 va_arg(varg_list, int);
                         }
                         else if (arg_type==STARPU_EXECUTE_ON_DATA) {
-                                va_arg(varg_list, starpu_data_handle);
+                                va_arg(varg_list, starpu_data_handle_t);
                         }
                 }
                 va_end(varg_list);
@@ -380,7 +380,7 @@ int starpu_mpi_insert_task(MPI_Comm comm, starpu_codelet *codelet, ...)
 	va_start(varg_list, codelet);
 	while ((arg_type = va_arg(varg_list, int)) != 0) {
 		if (arg_type==STARPU_R || arg_type==STARPU_W || arg_type==STARPU_RW || arg_type == STARPU_SCRATCH) {
-                        starpu_data_handle data = va_arg(varg_list, starpu_data_handle);
+                        starpu_data_handle_t data = va_arg(varg_list, starpu_data_handle_t);
 #ifdef MPI_CACHE
                         if (arg_type & STARPU_W) {
                                 uint32_t key = _starpu_crc32_be((uintptr_t)data, 0);
@@ -439,7 +439,7 @@ int starpu_mpi_insert_task(MPI_Comm comm, starpu_codelet *codelet, ...)
 			va_arg(varg_list, int);
 		}
 		else if (arg_type==STARPU_EXECUTE_ON_DATA) {
-			va_arg(varg_list, starpu_data_handle);
+			va_arg(varg_list, starpu_data_handle_t);
 		}
         }
 	va_end(varg_list);
@@ -447,7 +447,7 @@ int starpu_mpi_insert_task(MPI_Comm comm, starpu_codelet *codelet, ...)
         return 0;
 }
 
-void starpu_mpi_get_data_on_node(MPI_Comm comm, starpu_data_handle data_handle, int node)
+void starpu_mpi_get_data_on_node(MPI_Comm comm, starpu_data_handle_t data_handle, int node)
 {
         int me, rank;
 

mpi/starpu_mpi_private.h

@@ -62,7 +62,7 @@
 
 LIST_TYPE(starpu_mpi_req,
 	/* description of the data at StarPU level */
-	starpu_data_handle data_handle;
+	starpu_data_handle_t data_handle;
 
 	/* description of the data to be sent/received */
 	MPI_Datatype datatype;

mpi/tests/block_interface.c

@@ -57,7 +57,7 @@ int main(int argc, char **argv)
 	 * their blocks. */
 
 	float *block;
-	starpu_data_handle block_handle;
+	starpu_data_handle_t block_handle;
 
 	if (rank == 0)
 	{

mpi/tests/block_interface_pinned.c

@@ -57,7 +57,7 @@ int main(int argc, char **argv)
 	 * their blocks. */
 
 	float *block;
-	starpu_data_handle block_handle;
+	starpu_data_handle_t block_handle;
 
 	if (rank == 0)
 	{

mpi/tests/insert_task.c

@@ -46,7 +46,7 @@ int main(int argc, char **argv)
         int rank, size, x, y;
         int value=0;
         unsigned matrix[X][Y];
-        starpu_data_handle data_handles[X][Y];
+        starpu_data_handle_t data_handles[X][Y];
 
 	starpu_init(NULL);
 	starpu_mpi_initialize_extended(&rank, &size);

mpi/tests/insert_task_block.c

@@ -59,7 +59,7 @@ int main(int argc, char **argv)
         int rank, size, x, y;
         int value=0;
         unsigned matrix[SIZE*SIZE];
-        starpu_data_handle data_handles[SIZE][SIZE];
+        starpu_data_handle_t data_handles[SIZE][SIZE];
 
 	starpu_init(NULL);
 	starpu_mpi_initialize_extended(&rank, &size);

mpi/tests/insert_task_cache.c

@@ -46,7 +46,7 @@ int main(int argc, char **argv)
         int rank, size, x, y;
         int value=0;
         unsigned matrix[X][Y];
-        starpu_data_handle data_handles[X][Y];
+        starpu_data_handle_t data_handles[X][Y];
 
 	starpu_init(NULL);
 	starpu_mpi_initialize_extended(&rank, &size);

mpi/tests/insert_task_owner.c

@@ -49,8 +49,8 @@ int main(int argc, char **argv)
 {
         int rank, size, err;
         int x0=0, x1=0, vx0[2] = {x0, x0}, vx1[2]={x1,x1};
-        starpu_data_handle data_handlesx0;
-        starpu_data_handle data_handlesx1;
+        starpu_data_handle_t data_handlesx0;
+        starpu_data_handle_t data_handlesx1;
 
 	starpu_init(NULL);
 	starpu_mpi_initialize_extended(&rank, &size);

mpi/tests/insert_task_owner2.c

@@ -49,7 +49,7 @@ int main(int argc, char **argv)
         int rank, size, err;
         int x[3], y=0;
         int i;
-        starpu_data_handle data_handles[4];
+        starpu_data_handle_t data_handles[4];
 
 	starpu_init(NULL);
 	starpu_mpi_initialize_extended(&rank, &size);

mpi/tests/insert_task_owner_data.c

@@ -38,7 +38,7 @@ int main(int argc, char **argv)
         int rank, size, err;
         int x[2];
         int i;
-        starpu_data_handle data_handles[2];
+        starpu_data_handle_t data_handles[2];
 	int values[2];
 
 	starpu_init(NULL);

mpi/tests/mpi_detached_tag.c

@@ -21,7 +21,7 @@
 #define SIZE	16
 
 float *tab;
-starpu_data_handle tab_handle;
+starpu_data_handle_t tab_handle;
 
 int main(int argc, char **argv)
 {

mpi/tests/mpi_irecv.c

@@ -21,7 +21,7 @@
 #define SIZE	16
 
 float *tab;
-starpu_data_handle tab_handle;
+starpu_data_handle_t tab_handle;
 
 int main(int argc, char **argv)
 {

mpi/tests/mpi_irecv_detached.c

@@ -22,7 +22,7 @@
 #define SIZE	16
 
 float *tab;
-starpu_data_handle tab_handle;
+starpu_data_handle_t tab_handle;
 
 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

mpi/tests/mpi_isend.c

@@ -21,7 +21,7 @@
 #define SIZE	16
 
 float *tab;
-starpu_data_handle tab_handle;
+starpu_data_handle_t tab_handle;
 
 int main(int argc, char **argv)
 {

mpi/tests/mpi_isend_detached.c

@@ -23,7 +23,7 @@
 #define SIZE	16
 
 static float *tab;
-static starpu_data_handle tab_handle;
+static starpu_data_handle_t tab_handle;
 
 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

mpi/tests/mpi_test.c

@@ -21,7 +21,7 @@
 #define SIZE	16
 
 float *tab;
-starpu_data_handle tab_handle;
+starpu_data_handle_t tab_handle;
 
 int main(int argc, char **argv)
 {

mpi/tests/multiple_send.c

@@ -24,8 +24,8 @@ int main(int argc, char **argv)
         unsigned send[2] = {42, 11};
         unsigned recv[2] = {33, 33};
         starpu_mpi_req req[2];
-        starpu_data_handle send_handle[2];
-        starpu_data_handle recv_handle[2];
+        starpu_data_handle_t send_handle[2];
+        starpu_data_handle_t recv_handle[2];
 
 	starpu_init(NULL);
 	starpu_mpi_initialize_extended(&rank, &size);

mpi/tests/pingpong.c

@@ -21,7 +21,7 @@
 #define SIZE	16
 
 float *tab;
-starpu_data_handle tab_handle;
+starpu_data_handle_t tab_handle;
 
 int main(int argc, char **argv)
 {

mpi/tests/ring.c

@@ -20,7 +20,7 @@
 #define NITER	2048
 
 unsigned token = 42;
-starpu_data_handle token_handle;
+starpu_data_handle_t token_handle;
 
 #ifdef STARPU_USE_CUDA
 extern void increment_cuda(void *descr[], __attribute__ ((unused)) void *_args);

mpi/tests/ring_async.c

@@ -20,7 +20,7 @@
 #define NITER	2048
 
 unsigned token = 42;
-starpu_data_handle token_handle;
+starpu_data_handle_t token_handle;
 
 #ifdef STARPU_USE_CUDA
 extern void increment_cuda(void *descr[], __attribute__ ((unused)) void *_args);

mpi/tests/ring_async_implicit.c

@@ -20,7 +20,7 @@
 #define NITER	2048
 
 unsigned token = 42;
-starpu_data_handle token_handle;
+starpu_data_handle_t token_handle;
 
 #ifdef STARPU_USE_CUDA
 extern void increment_cuda(void *descr[], __attribute__ ((unused)) void *_args);

socl/src/socl.h

@@ -186,7 +186,7 @@ struct _cl_mem {
   CL_ENTITY;
 
   /* StarPU handle */
-  starpu_data_handle handle;
+  starpu_data_handle_t handle;
 
   /* Pointer to data in host memory */
   void *ptr;    

src/core/dependencies/data_concurrency.c

@@ -31,7 +31,7 @@
  */
 
 /* the header lock must be taken by the caller */
-static starpu_data_requester_t may_unlock_data_req_list_head(starpu_data_handle handle)
+static starpu_data_requester_t may_unlock_data_req_list_head(starpu_data_handle_t handle)
 {
 	starpu_data_requester_list_t req_list;
 
@@ -78,7 +78,7 @@ static starpu_data_requester_t may_unlock_data_req_list_head(starpu_data_handle
  * with the current mode, the request is put in the per-handle list of
  * "requesters", and this function returns 1. */
 static unsigned _starpu_attempt_to_submit_data_request(unsigned request_from_codelet,
-						       starpu_data_handle handle, enum starpu_access_mode mode,
+						       starpu_data_handle_t handle, enum starpu_access_mode mode,
 						       void (*callback)(void *), void *argcb,
 						       starpu_job_t j, unsigned buffer_index)
 {
@@ -179,7 +179,7 @@ static unsigned _starpu_attempt_to_submit_data_request(unsigned request_from_cod
 }
 
 
-unsigned _starpu_attempt_to_submit_data_request_from_apps(starpu_data_handle handle, enum starpu_access_mode mode,
+unsigned _starpu_attempt_to_submit_data_request_from_apps(starpu_data_handle_t handle, enum starpu_access_mode mode,
 						void (*callback)(void *), void *argcb)
 {
 	return _starpu_attempt_to_submit_data_request(0, handle, mode, callback, argcb, NULL, 0);
@@ -189,7 +189,7 @@ static unsigned attempt_to_submit_data_request_from_job(starpu_job_t j, unsigned
 {
 	/* Note that we do not access j->task->buffers, but j->ordered_buffers
 	 * which is a sorted copy of it. */
-	starpu_data_handle handle = j->ordered_buffers[buffer_index].handle;
+	starpu_data_handle_t handle = j->ordered_buffers[buffer_index].handle;
 	enum starpu_access_mode mode = j->ordered_buffers[buffer_index].mode;
 
 	return _starpu_attempt_to_submit_data_request(1, handle, mode, NULL, NULL, j, buffer_index);
@@ -248,7 +248,7 @@ static unsigned unlock_one_requester(starpu_data_requester_t r)
 }
 
 /* The header lock must already be taken by the caller */
-void _starpu_notify_data_dependencies(starpu_data_handle handle)
+void _starpu_notify_data_dependencies(starpu_data_handle_t handle)
 {
 	/* A data access has finished so we remove a reference. */
 	STARPU_ASSERT(handle->refcnt > 0);

src/core/dependencies/data_concurrency.h

@@ -22,9 +22,9 @@
 
 unsigned _starpu_submit_job_enforce_data_deps(starpu_job_t j);
 
-void _starpu_notify_data_dependencies(starpu_data_handle handle);
+void _starpu_notify_data_dependencies(starpu_data_handle_t handle);
 
-unsigned _starpu_attempt_to_submit_data_request_from_apps(starpu_data_handle handle,
+unsigned _starpu_attempt_to_submit_data_request_from_apps(starpu_data_handle_t handle,
 							  enum starpu_access_mode mode,
 							  void (*callback)(void *), void *argcb);
 

src/core/dependencies/implicit_data_deps.c

@@ -28,7 +28,7 @@
 #endif
 
 /* Read after Write (RAW) or Read after Read (RAR) */
-static void _starpu_add_reader_after_writer(starpu_data_handle handle, struct starpu_task *pre_sync_task, struct starpu_task *post_sync_task)
+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));
@@ -66,7 +66,7 @@ static void _starpu_add_reader_after_writer(starpu_data_handle handle, struct st
 }
 
 /* Write after Read (WAR) */
-static void _starpu_add_writer_after_readers(starpu_data_handle handle, struct starpu_task *pre_sync_task, struct starpu_task *post_sync_task)
+static void _starpu_add_writer_after_readers(starpu_data_handle_t handle, struct starpu_task *pre_sync_task, struct starpu_task *post_sync_task)
 {
 	/* Count the readers */
 	unsigned nreaders = 0;
@@ -121,7 +121,7 @@ static void _starpu_add_writer_after_readers(starpu_data_handle handle, struct s
 	starpu_task_declare_deps_array(pre_sync_task, nreaders, task_array);
 }
 /* Write after Write (WAW) */
-static void _starpu_add_writer_after_writer(starpu_data_handle handle, struct starpu_task *pre_sync_task, struct starpu_task *post_sync_task)
+static void _starpu_add_writer_after_writer(starpu_data_handle_t handle, struct starpu_task *pre_sync_task, struct starpu_task *post_sync_task)
 {
 	/* (Read) Write */
 	/* This task depends on the previous writer */
@@ -162,7 +162,7 @@ static void _starpu_add_writer_after_writer(starpu_data_handle handle, struct st
 
 static void disable_last_writer_callback(void *cl_arg)
 {
-	starpu_data_handle handle = (starpu_data_handle) cl_arg;
+	starpu_data_handle_t handle = (starpu_data_handle_t) cl_arg;
 	
 	/* NB: we don't take the handle->sequential_consistency_mutex mutex
 	 * because the empty task that is used for synchronization is going to
@@ -182,7 +182,7 @@ static void disable_last_writer_callback(void *cl_arg)
  * */
 /* NB : handle->sequential_consistency_mutex must be hold by the caller */
 void _starpu_detect_implicit_data_deps_with_handle(struct starpu_task *pre_sync_task, struct starpu_task *post_sync_task,
-						   starpu_data_handle handle, enum starpu_access_mode mode)
+						   starpu_data_handle_t handle, enum starpu_access_mode mode)
 {
 	STARPU_ASSERT(!(mode & STARPU_SCRATCH));
         _STARPU_LOG_IN();
@@ -289,7 +289,7 @@ void _starpu_detect_implicit_data_deps(struct starpu_task *task)
 	unsigned buffer;
 	for (buffer = 0; buffer < nbuffers; buffer++)
 	{
-		starpu_data_handle handle = task->buffers[buffer].handle;
+		starpu_data_handle_t handle = task->buffers[buffer].handle;
 		enum starpu_access_mode mode = task->buffers[buffer].mode;
 
 		/* Scratch memory does not introduce any deps */
@@ -311,7 +311,7 @@ void _starpu_detect_implicit_data_deps(struct starpu_task *task)
  * sequence, f(Ar) g(Ar) h(Aw), we expect to have h depend on both f and g, but
  * if h is submitted after the termination of f or g, StarPU will not create a
  * dependency as this is not needed anymore. */
-void _starpu_release_data_enforce_sequential_consistency(struct starpu_task *task, starpu_data_handle handle)
+void _starpu_release_data_enforce_sequential_consistency(struct starpu_task *task, starpu_data_handle_t handle)
 {
 	_STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
 
@@ -394,7 +394,7 @@ void _starpu_release_data_enforce_sequential_consistency(struct starpu_task *tas
 	_STARPU_PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
 }
 
-void _starpu_add_post_sync_tasks(struct starpu_task *post_sync_task, starpu_data_handle handle)
+void _starpu_add_post_sync_tasks(struct starpu_task *post_sync_task, starpu_data_handle_t handle)
 {
         _STARPU_LOG_IN();
 	_STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
@@ -413,7 +413,7 @@ void _starpu_add_post_sync_tasks(struct starpu_task *post_sync_task, starpu_data
         _STARPU_LOG_OUT();
 }
 
-void _starpu_unlock_post_sync_tasks(starpu_data_handle handle)
+void _starpu_unlock_post_sync_tasks(starpu_data_handle_t handle)
 {
 	struct starpu_task_wrapper_list *post_sync_tasks = NULL;
 	unsigned do_submit_tasks = 0;
@@ -453,7 +453,7 @@ void _starpu_unlock_post_sync_tasks(starpu_data_handle handle)
 
 /* If sequential consistency mode is enabled, this function blocks until the
  * handle is available in the requested access mode. */
-int _starpu_data_wait_until_available(starpu_data_handle handle, enum starpu_access_mode mode)
+int _starpu_data_wait_until_available(starpu_data_handle_t handle, enum starpu_access_mode mode)
 {
 	/* If sequential consistency is enabled, wait until data is available */
 	_STARPU_PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);

src/core/dependencies/implicit_data_deps.h

@@ -22,15 +22,15 @@
 #include <common/config.h>
 
 void _starpu_detect_implicit_data_deps_with_handle(struct starpu_task *pre_sync_task, struct starpu_task *post_sync_task,
-						   starpu_data_handle handle, enum starpu_access_mode mode);
+						   starpu_data_handle_t handle, enum starpu_access_mode mode);
 void _starpu_detect_implicit_data_deps(struct starpu_task *task);
-void _starpu_release_data_enforce_sequential_consistency(struct starpu_task *task, starpu_data_handle handle);
+void _starpu_release_data_enforce_sequential_consistency(struct starpu_task *task, starpu_data_handle_t handle);
 
-void _starpu_add_post_sync_tasks(struct starpu_task *post_sync_task, starpu_data_handle handle);
-void _starpu_unlock_post_sync_tasks(starpu_data_handle handle);
+void _starpu_add_post_sync_tasks(struct starpu_task *post_sync_task, starpu_data_handle_t handle);
+void _starpu_unlock_post_sync_tasks(starpu_data_handle_t handle);
 
 /* This function blocks until the handle is available in the requested mode */
-int _starpu_data_wait_until_available(starpu_data_handle handle, enum starpu_access_mode mode);
+int _starpu_data_wait_until_available(starpu_data_handle_t handle, enum starpu_access_mode mode);
 
 #endif // __IMPLICIT_DATA_DEPS_H__
 

src/core/jobs.c

@@ -38,7 +38,7 @@ size_t _starpu_job_get_data_size(starpu_job_t j)
 	unsigned buffer;
 	for (buffer = 0; buffer < nbuffers; buffer++)
 	{
-		starpu_data_handle handle = task->buffers[buffer].handle;
+		starpu_data_handle_t handle = task->buffers[buffer].handle;
 		size += _starpu_data_get_size(handle);
 	}
 

src/core/perfmodel/perfmodel.c

@@ -206,7 +206,7 @@ double starpu_task_expected_conversion_time(struct starpu_task *task, enum starp
 }
 
 /* Predict the transfer time (in µs) to move a handle to a memory node */
-double starpu_data_expected_transfer_time(starpu_data_handle handle, unsigned memory_node, enum starpu_access_mode mode)
+double starpu_data_expected_transfer_time(starpu_data_handle_t handle, unsigned memory_node, enum starpu_access_mode mode)
 {
 	/* If we don't need to read the content of the handle */
 	if (!(mode & STARPU_R))
@@ -238,7 +238,7 @@ double starpu_task_expected_data_transfer_time(uint32_t memory_node, struct star
 
 	for (buffer = 0; buffer < nbuffers; buffer++)
 	{
-		starpu_data_handle handle = task->buffers[buffer].handle;
+		starpu_data_handle_t handle = task->buffers[buffer].handle;
 		enum starpu_access_mode mode = task->buffers[buffer].mode;
 
 		penalty += starpu_data_expected_transfer_time(handle, memory_node, mode);