Datatypes renaming

	  starpu_perfmodel_t	      -> starpu_perfmodel
	  starpu_tag_t		      -> starpu_tag
	  starpu_sched_policy_s	      -> starpu_sched_policy
	  starpu_data_interface_ops_t -> starpu_data_interface_ops

doc/starpu.texi

@@ -1338,9 +1338,9 @@ Partitioning can be applied several times, see
 
 To achieve good scheduling, StarPU scheduling policies need to be able to
 estimate in advance the duration of a task. This is done by giving to codelets
-a performance model, by defining a @code{starpu_perfmodel_t} structure and
+a performance model, by defining a @code{starpu_perfmodel} structure and
 providing its address in the @code{model} field of the @code{starpu_codelet}
-structure. The @code{symbol} and @code{type} fields of @code{starpu_perfmodel_t}
+structure. The @code{symbol} and @code{type} fields of @code{starpu_perfmodel}
 are mandatory, to give a name to the model, and the type of the model, since
 there are several kinds of performance models.
 
@@ -1371,7 +1371,7 @@ submitting any task using it.
 
 @cartouche
 @smallexample
-static struct starpu_perfmodel_t mult_perf_model = @{
+static struct starpu_perfmodel mult_perf_model = @{
     .type = STARPU_HISTORY_BASED,
     .symbol = "mult_perf_model"
 @};
@@ -2359,19 +2359,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_t @var{tag})
+@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})
 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_t @var{tag})
+@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})
 @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_t @var{tag})
+@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})
 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_t @var{tag})
+@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})
 @end deftypefun
 
 @page
@@ -3667,12 +3667,12 @@ 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_t} *@var{ops})
+@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})
 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
 describing the different methods used to manipulate this type of interface. See
-@ref{struct starpu_data_interface_ops_t} for more details on this structure.
+@ref{struct starpu_data_interface_ops} for more details on this structure.
 
 If @code{home_node} is -1, StarPU will automatically
 allocate the memory when it is used for the
@@ -3881,7 +3881,7 @@ matrix).
 @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}.
-@code{struct starpu_data_interface_ops_t *(*get_child_ops)(struct starpu_data_filter *, unsigned id);}
+@code{struct starpu_data_interface_ops *(*get_child_ops)(struct starpu_data_filter *, unsigned id);}
 @item @code{filter_arg}
 Some filters take an addition parameter, but this is usually unused.
 @item @code{filter_arg_ptr}
@@ -4294,7 +4294,7 @@ same task, in this case, the dependencies are added. It is possible to have
 redundancy in the task dependencies.
 @end deftypefun
 
-@deftp {Data Type} {starpu_tag_t}
+@deftp {Data Type} {starpu_tag}
 This type defines a task logical identifer. It is possible to associate a task with a unique ``tag'' chosen by the application, and to express
 dependencies between tasks by the means of those tags. To do so, fill the
 @code{tag_id} field of the @code{starpu_task} structure with a tag number (can
@@ -4305,7 +4305,7 @@ not be started until the tasks which holds the declared dependency tags are
 completed.
 @end deftp
 
-@deftypefun void starpu_tag_declare_deps (starpu_tag_t @var{id}, unsigned @var{ndeps}, ...)
+@deftypefun void starpu_tag_declare_deps (starpu_tag @var{id}, unsigned @var{ndeps}, ...)
 Specify the dependencies of the task identified by tag @code{id}. The first
 argument specifies the tag which is configured, the second argument gives the
 number of tag(s) on which @code{id} depends. The following arguments are the
@@ -4315,33 +4315,33 @@ This function must be called before the associated task is submitted to StarPU
 with @code{starpu_task_submit}.
 
 Because of the variable arity of @code{starpu_tag_declare_deps}, note that the
-last arguments @emph{must} be of type @code{starpu_tag_t}: constant values
+last arguments @emph{must} be of type @code{starpu_tag}: constant values
 typically need to be explicitly casted. Using the
 @code{starpu_tag_declare_deps_array} function avoids this hazard.
 
 @cartouche
 @example
 /*  Tag 0x1 depends on tags 0x32 and 0x52 */
-starpu_tag_declare_deps((starpu_tag_t)0x1,
-        2, (starpu_tag_t)0x32, (starpu_tag_t)0x52);
+starpu_tag_declare_deps((starpu_tag)0x1,
+        2, (starpu_tag)0x32, (starpu_tag)0x52);
 @end example
 @end cartouche
 @end deftypefun
 
-@deftypefun void starpu_tag_declare_deps_array (starpu_tag_t @var{id}, unsigned @var{ndeps}, {starpu_tag_t *}@var{array})
+@deftypefun void starpu_tag_declare_deps_array (starpu_tag @var{id}, unsigned @var{ndeps}, {starpu_tag *}@var{array})
 This function is similar to @code{starpu_tag_declare_deps}, except
 that its does not take a variable number of arguments but an array of
 tags of size @code{ndeps}.
 @cartouche
 @example
 /*  Tag 0x1 depends on tags 0x32 and 0x52 */
-starpu_tag_t tag_array[2] = @{0x32, 0x52@};
-starpu_tag_declare_deps_array((starpu_tag_t)0x1, 2, tag_array);
+starpu_tag tag_array[2] = @{0x32, 0x52@};
+starpu_tag_declare_deps_array((starpu_tag)0x1, 2, tag_array);
 @end example
 @end cartouche
 @end deftypefun
 
-@deftypefun void starpu_tag_wait (starpu_tag_t @var{id})
+@deftypefun void starpu_tag_wait (starpu_tag @var{id})
 This function blocks until the task associated to tag @var{id} has been
 executed. This is a blocking call which must therefore not be called within
 tasks or callbacks, but only from the application directly.  It is possible to
@@ -4352,19 +4352,19 @@ data structure was freed (e.g. if the @code{destroy} flag of the
 @code{starpu_task} was enabled).
 @end deftypefun
 
-@deftypefun void starpu_tag_wait_array (unsigned @var{ntags}, starpu_tag_t *@var{id})
+@deftypefun void starpu_tag_wait_array (unsigned @var{ntags}, starpu_tag *@var{id})
 This function is similar to @code{starpu_tag_wait} except that it blocks until
 @emph{all} the @var{ntags} tags contained in the @var{id} array are
 terminated.
 @end deftypefun
 
-@deftypefun void starpu_tag_remove (starpu_tag_t @var{id})
+@deftypefun void starpu_tag_remove (starpu_tag @var{id})
 This function releases the resources associated to tag @var{id}. It can be
 called once the corresponding task has been executed and when there is
 no other tag that depend on this tag anymore.
 @end deftypefun
 
-@deftypefun void starpu_tag_notify_from_apps (starpu_tag_t @var{id})
+@deftypefun void starpu_tag_notify_from_apps (starpu_tag @var{id})
 This function explicitly unlocks tag @var{id}. It may be useful in the
 case of applications which execute part of their computation outside StarPU
 tasks (e.g. third-party libraries).  It is also provided as a
@@ -4417,15 +4417,15 @@ The different values are:
 @end table
 @end deftp
 
-@deftp {Data Type} {struct starpu_perfmodel_t}
+@deftp {Data Type} {struct starpu_perfmodel}
 TODO
 @end deftp
 
-@deftypefun int starpu_load_history_debug ({const char} *@var{symbol}, {struct starpu_perfmodel_t} *@var{model})
+@deftypefun int starpu_load_history_debug ({const char} *@var{symbol}, {struct starpu_perfmodel} *@var{model})
 TODO
 @end deftypefun
 
-@deftypefun void starpu_perfmodel_debugfilepath ({struct starpu_perfmodel_t} *@var{model}, {enum starpu_perf_archtype} @var{arch}, char *@var{path}, size_t @var{maxlen})
+@deftypefun void starpu_perfmodel_debugfilepath ({struct starpu_perfmodel} *@var{model}, {enum starpu_perf_archtype} @var{arch}, char *@var{path}, size_t @var{maxlen})
 TODO
 @end deftypefun
 
@@ -4724,8 +4724,8 @@ instance.
 @subsection Data Interface API
 @c void *starpu_data_get_interface_on_node(starpu_data_handle handle, unsigned memory_node); TODO
 
-@deftp {Data Type} {struct starpu_data_interface_ops_t}
-@anchor{struct starpu_data_interface_ops_t}
+@deftp {Data Type} {struct starpu_data_interface_ops}
+@anchor{struct starpu_data_interface_ops}
 Defines the per-interface methods. TODO describe all the different fields
 @end deftp
 
@@ -4822,7 +4822,7 @@ the StarPU sources in the directory @code{examples/scheduler/}.
 @node Scheduling Policy API
 @subsection Scheduling Policy API
 
-@deftp {Data Type} {struct starpu_sched_policy_s}
+@deftp {Data Type} {struct starpu_sched_policy}
 This structure contains all the methods that implement a scheduling policy.  An
 application may specify which scheduling strategy in the @code{sched_policy}
 field of the @code{starpu_conf} structure passed to the @code{starpu_init}
@@ -4905,7 +4905,7 @@ a FIFO ordering.
 
 @cartouche
 @smallexample
-static struct starpu_sched_policy_s dummy_sched_policy = @{
+static struct starpu_sched_policy dummy_sched_policy = @{
     .init_sched = init_dummy_sched,
     .deinit_sched = deinit_dummy_sched,
     .push_task = push_task_dummy,

examples/audio/starpu_audio_processing.c

@@ -268,7 +268,7 @@ static void band_filter_kernel_cpu(void *descr[], __attribute__((unused)) void *
 		localA[i] /= nsamples;
 }
 
-struct starpu_perfmodel_t band_filter_model = {
+struct starpu_perfmodel band_filter_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "FFT_band_filter"
 };

examples/basic_examples/mult.c

@@ -27,7 +27,7 @@
  *  - how to unpartition data (starpu_data_unpartition) and how to stop
  *    monitoring data (starpu_data_unregister)
  *  - how to manipulate subsets of data (starpu_data_get_sub_data)
- *  - how to construct an autocalibrated performance model (starpu_perfmodel_t)
+ *  - how to construct an autocalibrated performance model (starpu_perfmodel)
  *  - how to submit asynchronous tasks
  */
 
@@ -246,7 +246,7 @@ static void partition_mult_data(void)
 	starpu_data_map_filters(C_handle, 2, &vert, &horiz);
 }
 
-static struct starpu_perfmodel_t mult_perf_model = {
+static struct starpu_perfmodel mult_perf_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "mult_perf_model"
 };

examples/basic_examples/multiformat.c

@@ -68,7 +68,7 @@ extern void multiformat_scal_cuda_func(void *buffers[], void *arg);
 extern void multiformat_scal_opencl_func(void *buffers[], void *arg);
 #endif
 
-static struct starpu_perfmodel_t conversion_model = {
+static struct starpu_perfmodel conversion_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "multiformat_conversion_model"
 };

examples/basic_examples/vector_scal.c

@@ -35,12 +35,12 @@ extern void scal_sse_func(void *buffers[], void *_args);
 extern void scal_cuda_func(void *buffers[], void *_args);
 extern void scal_opencl_func(void *buffers[], void *_args);
 
-static struct starpu_perfmodel_t vector_scal_model = {
+static struct starpu_perfmodel vector_scal_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "vector_scale"
 };
 
-static struct starpu_perfmodel_t vector_scal_power_model = {
+static struct starpu_perfmodel vector_scal_power_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "vector_scale_power"
 };

examples/basic_examples/vector_scal_c.c

@@ -33,7 +33,7 @@
 extern void scal_cpu_func(void *buffers[], void *_args);
 extern void scal_cuda_func(void *buffers[], void *_args);
 
-static struct starpu_perfmodel_t vector_scal_model = {
+static struct starpu_perfmodel vector_scal_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "vector_scale_model"
 };

examples/cg/cg_kernels.c

@@ -68,7 +68,7 @@ static void accumulate_variable_cpu(void *descr[], void *cl_arg)
 	*v_dst = *v_dst + *v_src;
 }
 
-static struct starpu_perfmodel_t accumulate_variable_model = {
+static struct starpu_perfmodel accumulate_variable_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "accumulate_variable"
 };
@@ -104,7 +104,7 @@ static void accumulate_vector_cpu(void *descr[], void *cl_arg)
 	AXPY(n, (TYPE)1.0, v_src, 1, v_dst, 1);
 }
 
-static struct starpu_perfmodel_t accumulate_vector_model = {
+static struct starpu_perfmodel accumulate_vector_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "accumulate_vector"
 };
@@ -142,7 +142,7 @@ static void bzero_variable_cpu(void *descr[], void *cl_arg)
 	*v = (TYPE)0.0;
 }
 
-static struct starpu_perfmodel_t bzero_variable_model = {
+static struct starpu_perfmodel bzero_variable_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "bzero_variable"
 };
@@ -177,7 +177,7 @@ static void bzero_vector_cpu(void *descr[], void *cl_arg)
 	memset(v, 0, n*sizeof(TYPE));
 }
 
-static struct starpu_perfmodel_t bzero_vector_model = {
+static struct starpu_perfmodel bzero_vector_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "bzero_vector"
 };
@@ -230,7 +230,7 @@ static void dot_kernel_cpu(void *descr[], void *cl_arg)
 	*dot = *dot + local_dot;
 }
 
-static struct starpu_perfmodel_t dot_kernel_model = {
+static struct starpu_perfmodel dot_kernel_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "dot_kernel"
 };
@@ -297,7 +297,7 @@ static void scal_kernel_cpu(void *descr[], void *cl_arg)
 	SCAL(n, alpha, v1, 1);
 }
 
-static struct starpu_perfmodel_t scal_kernel_model = {
+static struct starpu_perfmodel scal_kernel_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "scal_kernel"
 };
@@ -368,7 +368,7 @@ static void gemv_kernel_cpu(void *descr[], void *cl_arg)
 	GEMV("N", nx, ny, alpha, M, ld, v2, 1, beta, v1, 1);
 }
 
-static struct starpu_perfmodel_t gemv_kernel_model = {
+static struct starpu_perfmodel gemv_kernel_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "gemv_kernel"
 };
@@ -460,7 +460,7 @@ static void scal_axpy_kernel_cpu(void *descr[], void *cl_arg)
 	AXPY(nx, p2, v2, 1, v1, 1);
 }
 
-static struct starpu_perfmodel_t scal_axpy_kernel_model = {
+static struct starpu_perfmodel scal_axpy_kernel_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "scal_axpy_kernel"
 };
@@ -528,7 +528,7 @@ static void axpy_kernel_cpu(void *descr[], void *cl_arg)
 	AXPY(nx, p1, v2, 1, v1, 1);
 }
 
-static struct starpu_perfmodel_t axpy_kernel_model = {
+static struct starpu_perfmodel axpy_kernel_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "axpy_kernel"
 };
@@ -588,7 +588,7 @@ static void copy_handle_cuda(void *descr[], void *cl_arg)
 }
 #endif
 
-static struct starpu_perfmodel_t copy_handle_model = {
+static struct starpu_perfmodel copy_handle_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "copy_handle"
 };

examples/cholesky/cholesky.h

@@ -35,18 +35,18 @@
 #define FPRINTF(ofile, fmt, args ...) do { if (!getenv("STARPU_SSILENT")) {fprintf(ofile, fmt, ##args); }} while(0)
 #define NMAXBLOCKS	32
 
-#define TAG11(k)	((starpu_tag_t)( (1ULL<<60) | (unsigned long long)(k)))
-#define TAG21(k,j)	((starpu_tag_t)(((3ULL<<60) | (((unsigned long long)(k))<<32)	\
+#define TAG11(k)	((starpu_tag)( (1ULL<<60) | (unsigned long long)(k)))
+#define TAG21(k,j)	((starpu_tag)(((3ULL<<60) | (((unsigned long long)(k))<<32)	\
 					| (unsigned long long)(j))))
-#define TAG22(k,i,j)	((starpu_tag_t)(((4ULL<<60) | ((unsigned long long)(k)<<32) 	\
+#define TAG22(k,i,j)	((starpu_tag)(((4ULL<<60) | ((unsigned long long)(k)<<32) 	\
 					| ((unsigned long long)(i)<<16)	\
 					| (unsigned long long)(j))))
 
-#define TAG11_AUX(k, prefix)	((starpu_tag_t)( (((unsigned long long)(prefix))<<60)  |  (1ULL<<56) | (unsigned long long)(k)))
-#define TAG21_AUX(k,j, prefix)	((starpu_tag_t)( (((unsigned long long)(prefix))<<60)  			\
+#define TAG11_AUX(k, prefix)	((starpu_tag)( (((unsigned long long)(prefix))<<60)  |  (1ULL<<56) | (unsigned long long)(k)))
+#define TAG21_AUX(k,j, prefix)	((starpu_tag)( (((unsigned long long)(prefix))<<60)  			\
 					|  ((3ULL<<56) | (((unsigned long long)(k))<<32)	\
 					| (unsigned long long)(j))))
-#define TAG22_AUX(k,i,j, prefix)    ((starpu_tag_t)(  (((unsigned long long)(prefix))<<60)	\
+#define TAG22_AUX(k,i,j, prefix)    ((starpu_tag)(  (((unsigned long long)(prefix))<<60)	\
 					|  ((4ULL<<56) | ((unsigned long long)(k)<<32)  	\
 					| ((unsigned long long)(i)<<16) 			\
 					| (unsigned long long)(j))))
@@ -74,9 +74,9 @@ void chol_cublas_codelet_update_u21(void *descr[], void *_args);
 void chol_cublas_codelet_update_u22(void *descr[], void *_args);
 #endif
 
-extern struct starpu_perfmodel_t chol_model_11;
-extern struct starpu_perfmodel_t chol_model_21;
-extern struct starpu_perfmodel_t chol_model_22;
+extern struct starpu_perfmodel chol_model_11;
+extern struct starpu_perfmodel chol_model_21;
+extern struct starpu_perfmodel chol_model_22;
 
 static void __attribute__((unused)) parse_args(int argc, char **argv)
 {

examples/cholesky/cholesky_grain_tag.c

@@ -22,7 +22,7 @@
  *	Some useful functions
  */
 
-static struct starpu_task *create_task(starpu_tag_t id)
+static struct starpu_task *create_task(starpu_tag id)
 {
 	struct starpu_task *task = starpu_task_create();
 		task->cl_arg = NULL;
@@ -227,7 +227,7 @@ static void cholesky_grain_rec(float *matA, unsigned size, unsigned ld, unsigned
 		STARPU_ASSERT(reclevel == 0);
 		unsigned ndeps_tags = (nblocks - nbigblocks)*(nblocks - nbigblocks);
 
-		starpu_tag_t *tag_array = malloc(ndeps_tags*sizeof(starpu_tag_t));
+		starpu_tag *tag_array = malloc(ndeps_tags*sizeof(starpu_tag));
 		STARPU_ASSERT(tag_array);
 
 		unsigned ind = 0;

examples/cholesky/cholesky_models.c

@@ -126,7 +126,7 @@ static double cuda_chol_task_22_cost(starpu_buffer_descr *descr)
 	return PERTURBATE(cost);
 }
 
-struct starpu_perfmodel_t chol_model_11 = {
+struct starpu_perfmodel chol_model_11 = {
 	.per_arch = {
 		[STARPU_CPU_DEFAULT][0] = { .cost_model = cpu_chol_task_11_cost },
 		[STARPU_CUDA_DEFAULT][0] = { .cost_model = cuda_chol_task_11_cost }
@@ -135,7 +135,7 @@ struct starpu_perfmodel_t chol_model_11 = {
 	.symbol = "chol_model_11"
 };
 
-struct starpu_perfmodel_t chol_model_21 = {
+struct starpu_perfmodel chol_model_21 = {
 	.per_arch = {
 		[STARPU_CPU_DEFAULT][0] = { .cost_model = cpu_chol_task_21_cost },
 		[STARPU_CUDA_DEFAULT][0] = { .cost_model = cuda_chol_task_21_cost }
@@ -144,7 +144,7 @@ struct starpu_perfmodel_t chol_model_21 = {
 	.symbol = "chol_model_21"
 };
 
-struct starpu_perfmodel_t chol_model_22 = {
+struct starpu_perfmodel chol_model_22 = {
 	.per_arch = {
 		[STARPU_CPU_DEFAULT][0] = { .cost_model = cpu_chol_task_22_cost },
 		[STARPU_CUDA_DEFAULT][0] = { .cost_model = cuda_chol_task_22_cost }

examples/cholesky/cholesky_tag.c

@@ -22,7 +22,7 @@
  *	Some useful functions
  */
 
-static struct starpu_task *create_task(starpu_tag_t id)
+static struct starpu_task *create_task(starpu_tag id)
 {
 	struct starpu_task *task = starpu_task_create();
 		task->cl_arg = NULL;

examples/cholesky/cholesky_tile_tag.c

@@ -25,7 +25,7 @@ starpu_data_handle A_state[NMAXBLOCKS][NMAXBLOCKS];
  *	Some useful functions
  */
 
-static struct starpu_task *create_task(starpu_tag_t id)
+static struct starpu_task *create_task(starpu_tag id)
 {
 	struct starpu_task *task = starpu_task_create();
 		task->cl_arg = NULL;

examples/common/blas_model.h

@@ -22,7 +22,7 @@
 
 double gemm_cost(starpu_buffer_descr *descr);
 
-static struct starpu_perfmodel_t starpu_sgemm_model = {
+static struct starpu_perfmodel starpu_sgemm_model = {
 	.type = STARPU_HISTORY_BASED,
 #ifdef STARPU_ATLAS
 	.symbol = "sgemm_atlas"
@@ -33,12 +33,12 @@ static struct starpu_perfmodel_t starpu_sgemm_model = {
 #endif
 };
 
-static struct starpu_perfmodel_t starpu_sgemm_model_common = {
+static struct starpu_perfmodel starpu_sgemm_model_common = {
 	.cost_model = gemm_cost,
 	.type = STARPU_COMMON,
 };
 
-static struct starpu_perfmodel_t starpu_dgemm_model = {
+static struct starpu_perfmodel starpu_dgemm_model = {
 	.type = STARPU_HISTORY_BASED,
 #ifdef STARPU_ATLAS
 	.symbol = "dgemm_atlas"
@@ -49,7 +49,7 @@ static struct starpu_perfmodel_t starpu_dgemm_model = {
 #endif
 };
 
-static struct starpu_perfmodel_t starpu_dgemm_model_common = {
+static struct starpu_perfmodel starpu_dgemm_model_common = {
 	.cost_model = gemm_cost,
 	.type = STARPU_COMMON,
 };

examples/heat/dw_factolu.h

@@ -208,9 +208,9 @@ void dw_callback_v2_codelet_update_u12(void *);
 void dw_callback_v2_codelet_update_u21(void *);
 void dw_callback_v2_codelet_update_u22(void *);
 
-extern struct starpu_perfmodel_t model_11;
-extern struct starpu_perfmodel_t model_12;
-extern struct starpu_perfmodel_t model_21;
-extern struct starpu_perfmodel_t model_22;
+extern struct starpu_perfmodel model_11;
+extern struct starpu_perfmodel model_12;
+extern struct starpu_perfmodel model_21;
+extern struct starpu_perfmodel model_22;
 
 #endif /* __DW_FACTO_LU_H__ */

examples/heat/dw_factolu_grain.c

@@ -18,12 +18,12 @@
 
 #include "dw_factolu.h"
 
-#define TAG11(k, prefix)	((starpu_tag_t)( (((unsigned long long)(prefix))<<60)  |  (1ULL<<56) | (unsigned long long)(k)))
-#define TAG12(k,i, prefix)	((starpu_tag_t)((((unsigned long long)(prefix))<<60)  | ((2ULL<<56) | (((unsigned long long)(k))<<32)	\
+#define TAG11(k, prefix)	((starpu_tag)( (((unsigned long long)(prefix))<<60)  |  (1ULL<<56) | (unsigned long long)(k)))
+#define TAG12(k,i, prefix)	((starpu_tag)((((unsigned long long)(prefix))<<60)  | ((2ULL<<56) | (((unsigned long long)(k))<<32)	\
 					| (unsigned long long)(i))))
-#define TAG21(k,j, prefix)	((starpu_tag_t)( (((unsigned long long)(prefix))<<60)  |  ((3ULL<<56) | (((unsigned long long)(k))<<32)	\
+#define TAG21(k,j, prefix)	((starpu_tag)( (((unsigned long long)(prefix))<<60)  |  ((3ULL<<56) | (((unsigned long long)(k))<<32)	\
 					| (unsigned long long)(j))))
-#define TAG22(k,i,j, prefix)	((starpu_tag_t)(  (((unsigned long long)(prefix))<<60)  |  ((4ULL<<56) | ((unsigned long long)(k)<<32) 	\
+#define TAG22(k,i,j, prefix)	((starpu_tag)(  (((unsigned long long)(prefix))<<60)  |  ((4ULL<<56) | ((unsigned long long)(k)<<32) 	\
 					| ((unsigned long long)(i)<<16)	\
 					| (unsigned long long)(j))))
 
@@ -31,7 +31,7 @@
  *	Construct the DAG
  */
 
-static struct starpu_task *create_task(starpu_tag_t id)
+static struct starpu_task *create_task(starpu_tag id)
 {
 	struct starpu_task *task = starpu_task_create();
 		task->cl_arg = NULL;
@@ -278,7 +278,7 @@ static void dw_factoLU_grain_inner(float *matA, unsigned size, unsigned inner_si
 		 */
 
 		unsigned ndeps_tags = (nblocks - maxk)*(nblocks - maxk);
-		starpu_tag_t *tag_array = malloc(ndeps_tags*sizeof(starpu_tag_t));
+		starpu_tag *tag_array = malloc(ndeps_tags*sizeof(starpu_tag));
 		STARPU_ASSERT(tag_array);
 
 		unsigned ind = 0;

examples/heat/dw_factolu_tag.c

@@ -18,12 +18,12 @@
 
 #include "dw_factolu.h"
 
-#define TAG11(k)	((starpu_tag_t)( (1ULL<<60) | (unsigned long long)(k)))
-#define TAG12(k,i)	((starpu_tag_t)(((2ULL<<60) | (((unsigned long long)(k))<<32)	\
+#define TAG11(k)	((starpu_tag)( (1ULL<<60) | (unsigned long long)(k)))
+#define TAG12(k,i)	((starpu_tag)(((2ULL<<60) | (((unsigned long long)(k))<<32)	\
 					| (unsigned long long)(i))))
-#define TAG21(k,j)	((starpu_tag_t)(((3ULL<<60) | (((unsigned long long)(k))<<32)	\
+#define TAG21(k,j)	((starpu_tag)(((3ULL<<60) | (((unsigned long long)(k))<<32)	\
 					| (unsigned long long)(j))))
-#define TAG22(k,i,j)	((starpu_tag_t)(((4ULL<<60) | ((unsigned long long)(k)<<32) 	\
+#define TAG22(k,i,j)	((starpu_tag)(((4ULL<<60) | ((unsigned long long)(k)<<32) 	\
 					| ((unsigned long long)(i)<<16)	\
 					| (unsigned long long)(j))))
 
@@ -33,7 +33,7 @@ static unsigned no_prio = 0;
  *	Construct the DAG
  */
 
-static struct starpu_task *create_task(starpu_tag_t id)
+static struct starpu_task *create_task(starpu_tag id)
 {
 	struct starpu_task *task = starpu_task_create();
 		task->cl_arg = NULL;

examples/heat/dw_sparse_cg.c

@@ -22,7 +22,7 @@
 #include "dw_sparse_cg.h"
 #define FPRINTF(ofile, fmt, args ...) do { if (!getenv("STARPU_SSILENT")) {fprintf(ofile, fmt, ##args); }} while(0)
 
-static struct starpu_task *create_task(starpu_tag_t id)
+static struct starpu_task *create_task(starpu_tag id)
 {
 	starpu_codelet *cl = calloc(1,sizeof(starpu_codelet));
 
@@ -156,7 +156,7 @@ void init_cg(struct cg_problem *problem)
 		task2->buffers[1].handle = problem->ds_vecr;
 		task2->buffers[1].mode = STARPU_R;
 	
-	starpu_tag_declare_deps((starpu_tag_t)2UL, 1, (starpu_tag_t)1UL);
+	starpu_tag_declare_deps((starpu_tag)2UL, 1, (starpu_tag)1UL);
 
 	/* delta_new = trans(r) r */
 	struct starpu_task *task3 = create_task(3UL);
@@ -174,7 +174,7 @@ void init_cg(struct cg_problem *problem)
 	task3->callback_arg = problem;
 	
 	/* XXX 3 should only depend on 1 ... */
-	starpu_tag_declare_deps((starpu_tag_t)3UL, 1, (starpu_tag_t)2UL);
+	starpu_tag_declare_deps((starpu_tag)3UL, 1, (starpu_tag)2UL);
 
 	/* launch the computation now */
 	starpu_task_submit(task1);
@@ -219,7 +219,7 @@ void launch_new_cg_iteration(struct cg_problem *problem)
 		task5->buffers[1].handle = problem->ds_vecq;
 		task5->buffers[1].mode = STARPU_R;
 
-	starpu_tag_declare_deps((starpu_tag_t)(maskiter | 5UL), 1, (starpu_tag_t)(maskiter | 4UL));
+	starpu_tag_declare_deps((starpu_tag)(maskiter | 5UL), 1, (starpu_tag)(maskiter | 4UL));
 
 	/* x = x + alpha d */
 	struct starpu_task *task6 = create_task(maskiter | 6UL);
@@ -235,7 +235,7 @@ void launch_new_cg_iteration(struct cg_problem *problem)
 		task6->buffers[1].handle = problem->ds_vecd;
 		task6->buffers[1].mode = STARPU_R;
 
-	starpu_tag_declare_deps((starpu_tag_t)(maskiter | 6UL), 1, (starpu_tag_t)(maskiter | 5UL));
+	starpu_tag_declare_deps((starpu_tag)(maskiter | 6UL), 1, (starpu_tag)(maskiter | 5UL));
 
 	/* r = r - alpha q */
 	struct starpu_task *task7 = create_task(maskiter | 7UL);
@@ -251,7 +251,7 @@ void launch_new_cg_iteration(struct cg_problem *problem)
 		task7->buffers[1].handle = problem->ds_vecq;
 		task7->buffers[1].mode = STARPU_R;
 
-	starpu_tag_declare_deps((starpu_tag_t)(maskiter | 7UL), 1, (starpu_tag_t)(maskiter | 6UL));
+	starpu_tag_declare_deps((starpu_tag)(maskiter | 7UL), 1, (starpu_tag)(maskiter | 6UL));
 
 	/* update delta_* and compute beta */
 	struct starpu_task *task8 = create_task(maskiter | 8UL);
@@ -265,7 +265,7 @@ void launch_new_cg_iteration(struct cg_problem *problem)
 		task8->buffers[0].handle = problem->ds_vecr;
 		task8->buffers[0].mode = STARPU_R;
 
-	starpu_tag_declare_deps((starpu_tag_t)(maskiter | 8UL), 1, (starpu_tag_t)(maskiter | 7UL));
+	starpu_tag_declare_deps((starpu_tag)(maskiter | 8UL), 1, (starpu_tag)(maskiter | 7UL));
 
 	/* d = r + beta d */
 	struct starpu_task *task9 = create_task(maskiter | 9UL);
@@ -281,7 +281,7 @@ void launch_new_cg_iteration(struct cg_problem *problem)
 		task9->buffers[1].handle = problem->ds_vecr;
 		task9->buffers[1].mode = STARPU_R;
 
-	starpu_tag_declare_deps((starpu_tag_t)(maskiter | 9UL), 1, (starpu_tag_t)(maskiter | 8UL));
+	starpu_tag_declare_deps((starpu_tag)(maskiter | 9UL), 1, (starpu_tag)(maskiter | 8UL));
 
 	task9->callback_func = iteration_cg;
 	task9->callback_arg = problem;

examples/heat/lu_kernels_model.c

@@ -214,7 +214,7 @@ double task_22_cost_cpu(starpu_buffer_descr *descr)
 	return PERTURBATE(cost);
 }
 
-struct starpu_perfmodel_t model_11 = {
+struct starpu_perfmodel model_11 = {
 	.cost_model = task_11_cost,
 	.per_arch = {
 		[STARPU_CPU_DEFAULT][0] = { .cost_model = task_11_cost_cpu },
@@ -230,7 +230,7 @@ struct starpu_perfmodel_t model_11 = {
 #endif
 };
 
-struct starpu_perfmodel_t model_12 = {
+struct starpu_perfmodel model_12 = {
 	.cost_model = task_12_cost,
 	.per_arch = {
 		[STARPU_CPU_DEFAULT][0] = { .cost_model = task_12_cost_cpu },
@@ -246,7 +246,7 @@ struct starpu_perfmodel_t model_12 = {
 #endif
 };
 
-struct starpu_perfmodel_t model_21 = {
+struct starpu_perfmodel model_21 = {
 	.cost_model = task_21_cost,
 	.per_arch = {
 		[STARPU_CPU_DEFAULT][0] = { .cost_model = task_21_cost_cpu },
@@ -262,7 +262,7 @@ struct starpu_perfmodel_t model_21 = {
 #endif
 };
 
-struct starpu_perfmodel_t model_22 = {
+struct starpu_perfmodel model_22 = {
 	.cost_model = task_22_cost,
 	.per_arch = {
 		[STARPU_CPU_DEFAULT][0] = { .cost_model = task_22_cost_cpu },

examples/lu/xlu.c

@@ -19,12 +19,12 @@
 #include "xlu.h"
 #include "xlu_kernels.h"
 
-#define TAG11(k)	((starpu_tag_t)( (1ULL<<60) | (unsigned long long)(k)))
-#define TAG12(k,i)	((starpu_tag_t)(((2ULL<<60) | (((unsigned long long)(k))<<32)	\
+#define TAG11(k)	((starpu_tag)( (1ULL<<60) | (unsigned long long)(k)))
+#define TAG12(k,i)	((starpu_tag)(((2ULL<<60) | (((unsigned long long)(k))<<32)	\
 					| (unsigned long long)(i))))
-#define TAG21(k,j)	((starpu_tag_t)(((3ULL<<60) | (((unsigned long long)(k))<<32)	\
+#define TAG21(k,j)	((starpu_tag)(((3ULL<<60) | (((unsigned long long)(k))<<32)	\
 					| (unsigned long long)(j))))
-#define TAG22(k,i,j)	((starpu_tag_t)(((4ULL<<60) | ((unsigned long long)(k)<<32) 	\
+#define TAG22(k,i,j)	((starpu_tag)(((4ULL<<60) | ((unsigned long long)(k)<<32) 	\
 					| ((unsigned long long)(i)<<16)	\
 					| (unsigned long long)(j))))
 
@@ -37,7 +37,7 @@ static unsigned no_prio = 0;
  *	Construct the DAG
  */
 
-static struct starpu_task *create_task(starpu_tag_t id)
+static struct starpu_task *create_task(starpu_tag id)
 {
 	struct starpu_task *task = starpu_task_create();
 		task->cl_arg = NULL;

examples/lu/xlu.h

@@ -101,10 +101,10 @@ void dw_callback_v2_codelet_update_u12(void *);
 void dw_callback_v2_codelet_update_u21(void *);
 void dw_callback_v2_codelet_update_u22(void *);
 
-extern struct starpu_perfmodel_t model_11;
-extern struct starpu_perfmodel_t model_12;
-extern struct starpu_perfmodel_t model_21;
-extern struct starpu_perfmodel_t model_22;
+extern struct starpu_perfmodel model_11;
+extern struct starpu_perfmodel model_12;
+extern struct starpu_perfmodel model_21;
+extern struct starpu_perfmodel model_22;
 
 struct piv_s {
 	unsigned *piv; /* complete pivot array */

examples/lu/xlu_kernels.c

@@ -92,7 +92,7 @@ void STARPU_LU(cublas_u22)(void *descr[], void *_args)
 }
 #endif /* STARPU_USE_CUDA */
 
-static struct starpu_perfmodel_t STARPU_LU(model_22) = {
+static struct starpu_perfmodel STARPU_LU(model_22) = {
 	.type = STARPU_HISTORY_BASED,
 #ifdef STARPU_ATLAS
 	.symbol = STARPU_LU_STR(lu_model_22_atlas)
@@ -175,7 +175,7 @@ void STARPU_LU(cublas_u12)(void *descr[], void *_args)
 }
 #endif /* STARPU_USE_CUDA */
 
-static struct starpu_perfmodel_t STARPU_LU(model_12) = {
+static struct starpu_perfmodel STARPU_LU(model_12) = {
 	.type = STARPU_HISTORY_BASED,
 #ifdef STARPU_ATLAS
 	.symbol = STARPU_LU_STR(lu_model_12_atlas)
@@ -255,7 +255,7 @@ void STARPU_LU(cublas_u21)(void *descr[], void *_args)
 }
 #endif 
 
-static struct starpu_perfmodel_t STARPU_LU(model_21) = {
+static struct starpu_perfmodel STARPU_LU(model_21) = {
 	.type = STARPU_HISTORY_BASED,
 #ifdef STARPU_ATLAS
 	.symbol = STARPU_LU_STR(lu_model_21_atlas)
@@ -350,7 +350,7 @@ void STARPU_LU(cublas_u11)(void *descr[], void *_args)
 }
 #endif /* STARPU_USE_CUDA */
 
-static struct starpu_perfmodel_t STARPU_LU(model_11) = {
+static struct starpu_perfmodel STARPU_LU(model_11) = {
 	.type = STARPU_HISTORY_BASED,
 #ifdef STARPU_ATLAS
 	.symbol = STARPU_LU_STR(lu_model_11_atlas)
@@ -486,7 +486,7 @@ void STARPU_LU(cublas_u11_pivot)(void *descr[], void *_args)
 }
 #endif /* STARPU_USE_CUDA */
 
-static struct starpu_perfmodel_t STARPU_LU(model_11_pivot) = {
+static struct starpu_perfmodel STARPU_LU(model_11_pivot) = {
 	.type = STARPU_HISTORY_BASED,
 #ifdef STARPU_ATLAS
 	.symbol = STARPU_LU_STR(lu_model_11_pivot_atlas)
@@ -571,7 +571,7 @@ void STARPU_LU(cublas_pivot)(void *descr[], void *_args)
 
 #endif /* STARPU_USE_CUDA */
 
-static struct starpu_perfmodel_t STARPU_LU(model_pivot) = {
+static struct starpu_perfmodel STARPU_LU(model_pivot) = {
 	.type = STARPU_HISTORY_BASED,
 #ifdef STARPU_ATLAS
 	.symbol = STARPU_LU_STR(lu_model_pivot_atlas)

examples/lu/xlu_pivot.c

@@ -18,15 +18,15 @@
 #include "xlu.h"
 #include "xlu_kernels.h"
 
-#define TAG11(k)	((starpu_tag_t)( (1ULL<<60) | (unsigned long long)(k)))
-#define TAG12(k,i)	((starpu_tag_t)(((2ULL<<60) | (((unsigned long long)(k))<<32)	\
+#define TAG11(k)	((starpu_tag)( (1ULL<<60) | (unsigned long long)(k)))
+#define TAG12(k,i)	((starpu_tag)(((2ULL<<60) | (((unsigned long long)(k))<<32)	\
 					| (unsigned long long)(i))))
-#define TAG21(k,j)	((starpu_tag_t)(((3ULL<<60) | (((unsigned long long)(k))<<32)	\
+#define TAG21(k,j)	((starpu_tag)(((3ULL<<60) | (((unsigned long long)(k))<<32)	\
 					| (unsigned long long)(j))))
-#define TAG22(k,i,j)	((starpu_tag_t)(((4ULL<<60) | ((unsigned long long)(k)<<32) 	\
+#define TAG22(k,i,j)	((starpu_tag)(((4ULL<<60) | ((unsigned long long)(k)<<32) 	\
 					| ((unsigned long long)(i)<<16)	\
 					| (unsigned long long)(j))))
-#define PIVOT(k,i)	((starpu_tag_t)(((5ULL<<60) | (((unsigned long long)(k))<<32)	\
+#define PIVOT(k,i)	((starpu_tag)(((5ULL<<60) | (((unsigned long long)(k))<<32)	\
 					| (unsigned long long)(i))))
 
 static unsigned no_prio = 0;
@@ -35,7 +35,7 @@ static unsigned no_prio = 0;
  *	Construct the DAG
  */
 
-static struct starpu_task *create_task(starpu_tag_t id)
+static struct starpu_task *create_task(starpu_tag id)
 {
 	struct starpu_task *task = starpu_task_create();
 		task->cl_arg = NULL;
@@ -75,7 +75,7 @@ static void create_task_pivot(starpu_data_handle *dataAp, unsigned nblocks,
 			starpu_tag_declare_deps(PIVOT(k, i), 2, TAG11(k), TAG22(k-1, i, k));
 		}
 		else {
-			starpu_tag_t *tags = malloc((nblocks - k)*sizeof(starpu_tag_t));
+			starpu_tag *tags = malloc((nblocks - k)*sizeof(starpu_tag));
 			
 			tags[0] = TAG11(k);
 			unsigned ind, ind2;
@@ -263,7 +263,7 @@ static double dw_codelet_facto_pivot(starpu_data_handle *dataAp,
 	}
 
 	/* we wait the last task (TAG11(nblocks - 1)) and all the pivot tasks */
-	starpu_tag_t *tags = malloc(nblocks*nblocks*sizeof(starpu_tag_t));
+	starpu_tag *tags = malloc(nblocks*nblocks*sizeof(starpu_tag));
 	unsigned ndeps = 0;
 
 	tags[ndeps++] = TAG11(nblocks - 1);

examples/mult/xgemm.c

@@ -176,7 +176,7 @@ static void cpu_mult(void *descr[], __attribute__((unused))  void *arg)
 	mult_kernel_common(descr, STARPU_CPU);
 }
 
-static struct starpu_perfmodel_t starpu_gemm_model = {
+static struct starpu_perfmodel starpu_gemm_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = STARPU_GEMM_STR(gemm)
 };

examples/openmp/vector_scal.c

@@ -42,7 +42,7 @@ void scal_cpu_func(void *buffers[], void *_args) {
 		val[i] *= *factor;
 }
 
-static struct starpu_perfmodel_t vector_scal_model = {
+static struct starpu_perfmodel vector_scal_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "vector_scale_parallel"
 };

examples/opt/pi/pi.c

@@ -108,7 +108,7 @@ int main(int argc, char **argv)
 	
 	starpu_data_partition(cnt_array_handle, &f);
 
-	static struct starpu_perfmodel_t model = {
+	static struct starpu_perfmodel model = {
 		.type = STARPU_HISTORY_BASED,
 		.symbol = "monte_carlo_pi"
 	};

examples/scheduler/dummy_sched.c

@@ -27,7 +27,7 @@ static pthread_cond_t sched_cond;
 static pthread_mutex_t sched_mutex;
 
 static void init_dummy_sched(struct starpu_machine_topology_s *topology,
-			struct starpu_sched_policy_s *policy)
+			struct starpu_sched_policy *policy)
 {
 	/* Create a linked-list of tasks and a condition variable to protect it */
 	starpu_task_list_init(&sched_list);
@@ -43,7 +43,7 @@ static void init_dummy_sched(struct starpu_machine_topology_s *topology,
 }
 
 static void deinit_dummy_sched(struct starpu_machine_topology_s *topology,
-				struct starpu_sched_policy_s *policy)
+				struct starpu_sched_policy *policy)
 {
 	STARPU_ASSERT(starpu_task_list_empty(&sched_list));
 
@@ -77,7 +77,7 @@ static struct starpu_task *pop_task_dummy(void)
 	return starpu_task_list_pop_back(&sched_list);
 }
 
-static struct starpu_sched_policy_s dummy_sched_policy = {
+static struct starpu_sched_policy dummy_sched_policy = {
 	.init_sched = init_dummy_sched,
 	.deinit_sched = deinit_dummy_sched,
 	.push_task = push_task_dummy,

examples/spmv/dw_block_spmv.c

@@ -105,7 +105,7 @@ unsigned get_bcsr_nchildren(__attribute__((unused)) struct starpu_data_filter *f
   return (unsigned)starpu_bcsr_get_nnz(handle);
 }
 
-struct starpu_data_interface_ops_t *get_bcsr_child_ops(__attribute__((unused)) struct starpu_data_filter *f, __attribute__((unused)) unsigned child) 
+struct starpu_data_interface_ops *get_bcsr_child_ops(__attribute__((unused)) struct starpu_data_filter *f, __attribute__((unused)) unsigned child) 
 {
   return &_starpu_interface_matrix_ops;
 }
@@ -219,7 +219,7 @@ void launch_spmv_codelets(void)
 				if (index != rowptr[row & ~0x3])
 				{
 					/* this is not the first task in the row */
-					starpu_tag_declare_deps((starpu_tag_t)taskid, 1, (starpu_tag_t)(taskid-1));
+					starpu_tag_declare_deps((starpu_tag)taskid, 1, (starpu_tag)(taskid-1));
 
 					is_entry_tab[taskid] = 0;
 				}

examples/starpufft/starpufft.h

@@ -40,7 +40,7 @@ void *starpufft(malloc)(size_t n); \
 void starpufft(free)(void *p); \
 \
 void starpufft(execute)(starpufft(plan) p, void *in, void *out); \
-starpu_tag_t starpufft(start)(starpufft(plan) p, void *in, void *out); \
+starpu_tag starpufft(start)(starpufft(plan) p, void *in, void *out); \
 \
 void starpufft(destroy_plan)(starpufft(plan) p); \
 \

examples/starpufft/starpufftx.c

@@ -40,7 +40,7 @@ enum steps {
 #define STEP_BITS 3
 #define STEP_SHIFT (NUMBER_SHIFT - STEP_BITS)
 
-#define _STEP_TAG(plan, step, i) (((starpu_tag_t) plan->number << NUMBER_SHIFT) | ((starpu_tag_t)(step) << STEP_SHIFT) | (starpu_tag_t) (i))
+#define _STEP_TAG(plan, step, i) (((starpu_tag) plan->number << NUMBER_SHIFT) | ((starpu_tag)(step) << STEP_SHIFT) | (starpu_tag) (i))
 
 
 #define I_BITS STEP_SHIFT
@@ -158,10 +158,10 @@ compute_roots(STARPUFFT(plan) plan)
 #include "starpufftx1d.c"
 #include "starpufftx2d.c"
 
-starpu_tag_t
+starpu_tag
 STARPUFFT(start)(STARPUFFT(plan) plan, void *_in, void *_out)
 {
-	starpu_tag_t tag;
+	starpu_tag tag;
 	int z;
 
 	plan->in = _in;
@@ -209,7 +209,7 @@ STARPUFFT(execute)(STARPUFFT(plan) plan, void *in, void *out)
 
 	gettimeofday(&start, NULL);
 
-	starpu_tag_t tag = STARPUFFT(start)(plan, in, out);
+	starpu_tag tag = STARPUFFT(start)(plan, in, out);
 	gettimeofday(&submit_tasks, NULL);
 	starpu_tag_wait(tag);
 

examples/starpufft/starpufftx1d.c

@@ -288,27 +288,27 @@ STARPUFFT(twist3_1d_kernel_cpu)(void *descr[], void *_args)
 }
 
 /* Performance models for the 5 kinds of tasks */
-static struct starpu_perfmodel_t STARPUFFT(twist1_1d_model) = {
+static struct starpu_perfmodel STARPUFFT(twist1_1d_model) = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = TYPE"twist1_1d"
 };
 
-static struct starpu_perfmodel_t STARPUFFT(fft1_1d_model) = {
+static struct starpu_perfmodel STARPUFFT(fft1_1d_model) = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = TYPE"fft1_1d"
 };
 
-static struct starpu_perfmodel_t STARPUFFT(twist2_1d_model) = {
+static struct starpu_perfmodel STARPUFFT(twist2_1d_model) = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = TYPE"twist2_1d"
 };
 
-static struct starpu_perfmodel_t STARPUFFT(fft2_1d_model) = {
+static struct starpu_perfmodel STARPUFFT(fft2_1d_model) = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = TYPE"fft2_1d"
 };
 
-static struct starpu_perfmodel_t STARPUFFT(twist3_1d_model) = {
+static struct starpu_perfmodel STARPUFFT(twist3_1d_model) = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = TYPE"twist3_1d"
 };
@@ -672,7 +672,7 @@ STARPUFFT(plan_dft_1d)(int n, int sign, unsigned flags)
 }
 
 /* Actually submit all the tasks. */
-static starpu_tag_t
+static starpu_tag
 STARPUFFT(start1dC2C)(STARPUFFT(plan) plan)
 {
 	STARPU_ASSERT(plan->type == C2C);

examples/starpufft/starpufftx2d.c

@@ -21,7 +21,7 @@
 #define I_SHIFT (I_BITS/2)
 #define J_BITS I_SHIFT
 
-#define STEP_TAG_2D(plan, step, i, j) _STEP_TAG(plan, step, ((starpu_tag_t) i << I_SHIFT) | (starpu_tag_t) j)
+#define STEP_TAG_2D(plan, step, i, j) _STEP_TAG(plan, step, ((starpu_tag) i << I_SHIFT) | (starpu_tag) j)
 
 #ifdef STARPU_USE_CUDA
 /* Twist the full vector into a n2,m2 chunk */
@@ -272,27 +272,27 @@ STARPUFFT(twist3_2d_kernel_cpu)(void *descr[], void *_args)
 	}
 }
 
-struct starpu_perfmodel_t STARPUFFT(twist1_2d_model) = {
+struct starpu_perfmodel STARPUFFT(twist1_2d_model) = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = TYPE"twist1_2d"
 };
 
-struct starpu_perfmodel_t STARPUFFT(fft1_2d_model) = {
+struct starpu_perfmodel STARPUFFT(fft1_2d_model) = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = TYPE"fft1_2d"
 };
 
-struct starpu_perfmodel_t STARPUFFT(twist2_2d_model) = {
+struct starpu_perfmodel STARPUFFT(twist2_2d_model) = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = TYPE"twist2_2d"
 };
 
-struct starpu_perfmodel_t STARPUFFT(fft2_2d_model) = {
+struct starpu_perfmodel STARPUFFT(fft2_2d_model) = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = TYPE"fft2_2d"
 };
 
-struct starpu_perfmodel_t STARPUFFT(twist3_2d_model) = {
+struct starpu_perfmodel STARPUFFT(twist3_2d_model) = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = TYPE"twist3_2d"
 };
@@ -657,7 +657,7 @@ STARPUFFT(plan_dft_2d)(int n, int m, int sign, unsigned flags)
 	return plan;
 }
 
-static starpu_tag_t
+static starpu_tag
 STARPUFFT(start2dC2C)(STARPUFFT(plan) plan)
 {
 	STARPU_ASSERT(plan->type == C2C);

examples/stencil/stencil-blocks.c

@@ -31,26 +31,26 @@ static unsigned *block_sizes_z;
 /*
  * common tag format:
  */
-static starpu_tag_t tag_common(int z, int dir, int type)
+static starpu_tag tag_common(int z, int dir, int type)
 {
-	return (((((starpu_tag_t)type) << 4) | ((dir+1)/2)) << 32)|(starpu_tag_t)z;
+	return (((((starpu_tag)type) << 4) | ((dir+1)/2)) << 32)|(starpu_tag)z;
 }
 
 /* Completion of last update tasks */
-starpu_tag_t TAG_FINISH(int z)
+starpu_tag TAG_FINISH(int z)
 {
 	z = (z + nbz)%nbz;
 
-	starpu_tag_t tag = tag_common(z, 0, 1);
+	starpu_tag tag = tag_common(z, 0, 1);
 	return tag;
 }
 
 /* Completion of the save codelet for MPI send/recv */
-starpu_tag_t TAG_START(int z, int dir)
+starpu_tag TAG_START(int z, int dir)
 {
 	z = (z + nbz)%nbz;
 
-	starpu_tag_t tag = tag_common(z, dir, 2);
+	starpu_tag tag = tag_common(z, dir, 2);
 	return tag;
 }
 

examples/stencil/stencil-kernels.c

@@ -439,7 +439,7 @@ fprintf(stderr,"!!! DO update_func_cpu z %d CPU%d !!!\n", block->bz, workerid);
 }
 
 /* Performance model and codelet structure */
-static struct starpu_perfmodel_t cl_update_model = {
+static struct starpu_perfmodel cl_update_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "cl_update" 
 };
@@ -634,12 +634,12 @@ static void dummy_func_bottom_opencl(void *descr[] __attribute__((unused)), void
 #endif /* STARPU_USE_OPENCL */
 
 /* Performance models and codelet for save */
-static struct starpu_perfmodel_t save_cl_bottom_model = {
+static struct starpu_perfmodel save_cl_bottom_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "save_cl_bottom" 
 };
 
-static struct starpu_perfmodel_t save_cl_top_model = {
+static struct starpu_perfmodel save_cl_top_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "save_cl_top" 
 };

examples/stencil/stencil-tasks.c

@@ -232,7 +232,7 @@ void create_start_task(int z, int dir) {
 	   before we start measuring time */
 	struct starpu_task *wait_init = starpu_task_create();
 	struct block_description *descr = get_block_description(z);
-	starpu_tag_t tag_init = TAG_INIT_TASK;
+	starpu_tag tag_init = TAG_INIT_TASK;
 	wait_init->cl = &null;
 	wait_init->use_tag = 1;
 	wait_init->tag_id = TAG_START(z, dir);

examples/stencil/stencil.h

@@ -83,10 +83,10 @@ struct block_description {
 	struct block_description *boundary_blocks[NDIRS];
 };
 
-#define TAG_INIT_TASK			((starpu_tag_t)1)
+#define TAG_INIT_TASK			((starpu_tag)1)
 
-starpu_tag_t TAG_FINISH(int z);
-starpu_tag_t TAG_START(int z, int dir);
+starpu_tag TAG_FINISH(int z);
+starpu_tag TAG_START(int z, int dir);
 int MPI_TAG0(int z, int iter, int dir);
 int MPI_TAG1(int z, int iter, int dir);
 

examples/tag_example/tag_example.c

@@ -28,7 +28,7 @@
 #endif
 
 #define FPRINTF(ofile, fmt, args ...) do { if (!getenv("STARPU_SSILENT")) {fprintf(ofile, fmt, ##args); }} while(0)
-#define TAG(i, j, iter)	((starpu_tag_t) ( ((uint64_t)(iter)<<48) |  ((uint64_t)(j)<<24) | (i)) )
+#define TAG(i, j, iter)	((starpu_tag) ( ((uint64_t)(iter)<<48) |  ((uint64_t)(j)<<24) | (i)) )
 
 starpu_codelet cl = {};
 

examples/tag_example/tag_example2.c

@@ -28,7 +28,7 @@
 #endif
 
 #define FPRINTF(ofile, fmt, args ...) do { if (!getenv("STARPU_SSILENT")) {fprintf(ofile, fmt, ##args); }} while(0)
-#define TAG(i, iter)	((starpu_tag_t)  (((uint64_t)iter)<<32 | (i)) )
+#define TAG(i, iter)	((starpu_tag)  (((uint64_t)iter)<<32 | (i)) )
 
 starpu_codelet cl = {};
 

examples/tag_example/tag_example3.c

@@ -28,7 +28,7 @@
 #endif
 
 #define FPRINTF(ofile, fmt, args ...) do { if (!getenv("STARPU_SSILENT")) {fprintf(ofile, fmt, ##args); }} while(0)
-#define TAG(i, iter)	((starpu_tag_t)  (((uint64_t)iter)<<32 | (i)) )
+#define TAG(i, iter)	((starpu_tag)  (((uint64_t)iter)<<32 | (i)) )
 
 starpu_codelet cl = {};
 

examples/tag_example/tag_restartable.c

@@ -33,7 +33,7 @@
 #define SLEEP 1
 
 #define FPRINTF(ofile, fmt, args ...) do { if (!getenv("STARPU_SSILENT")) {fprintf(ofile, fmt, ##args); }} while(0)
-#define TAG(i, iter)	((starpu_tag_t)  (((uint64_t)((iter)%Nrolls))<<32 | (i)) )
+#define TAG(i, iter)	((starpu_tag)  (((uint64_t)((iter)%Nrolls))<<32 | (i)) )
 
 starpu_codelet cl = {};
 

gcc-plugin/examples/cholesky/cholesky_models.c

@@ -24,17 +24,17 @@
  *	Number of flops of Gemm 
  */
 
-struct starpu_perfmodel_t chol_model_11 = {
+struct starpu_perfmodel chol_model_11 = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "chol_model_11"
 };
 
-struct starpu_perfmodel_t chol_model_21 = {
+struct starpu_perfmodel chol_model_21 = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "chol_model_21"
 };
 
-struct starpu_perfmodel_t chol_model_22 = {
+struct starpu_perfmodel chol_model_22 = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "chol_model_22"
 };

include/starpu.h

@@ -50,7 +50,7 @@ extern "C" {
 struct starpu_conf {
 	/* which scheduling policy should be used ? (NULL for default) */
 	const char *sched_policy_name;
-	struct starpu_sched_policy_s *sched_policy;
+	struct starpu_sched_policy *sched_policy;
 
 	/* number of CPU workers (-1 for default) */
 	int ncpus;

include/starpu_data.h

@@ -43,7 +43,7 @@ typedef struct starpu_buffer_descr_t {
 	starpu_access_mode mode;
 } starpu_buffer_descr;
 
-struct starpu_data_interface_ops_t;
+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

include/starpu_data_filters.h

@@ -28,12 +28,12 @@
 extern "C" {
 #endif
 
-struct starpu_data_interface_ops_t;
+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);
-        struct starpu_data_interface_ops_t *(*get_child_ops)(struct starpu_data_filter *, unsigned id);
+        struct starpu_data_interface_ops *(*get_child_ops)(struct starpu_data_filter *, unsigned id);
         unsigned filter_arg;
         unsigned nchildren;
         void *filter_arg_ptr;

include/starpu_data_interfaces.h

@@ -87,7 +87,7 @@ struct starpu_data_copy_methods {
 #endif
 };
 
-struct starpu_data_interface_ops_t {
+struct starpu_data_interface_ops {
 	/* Register an existing interface into a data handle. */
 	void (*register_data_handle)(starpu_data_handle handle,
 					uint32_t home_node, void *data_interface);
@@ -119,7 +119,7 @@ struct starpu_data_interface_ops_t {
 
 void starpu_data_register(starpu_data_handle *handleptr, uint32_t home_node,
 				void *data_interface,
-				struct starpu_data_interface_ops_t *ops);
+				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
@@ -130,7 +130,7 @@ void *starpu_handle_to_pointer(starpu_data_handle handle, uint32_t node);
  * interface does not have data allocated locally */
 void *starpu_handle_get_local_ptr(starpu_data_handle handle);
 
-extern struct starpu_data_interface_ops_t _starpu_interface_matrix_ops;
+extern struct starpu_data_interface_ops _starpu_interface_matrix_ops;
 
 /* "node" means memory node: 0 for main RAM, then 1, 2, etc. for various GPUs,
  * etc.

include/starpu_perfmodel.h

@@ -97,7 +97,7 @@ typedef enum {
 	STARPU_NL_REGRESSION_BASED	/* Automatic non-linear regression-based cost model (a * size ^ b + c) */
 } starpu_perfmodel_type;
 
-struct starpu_perfmodel_t {
+struct starpu_perfmodel {
 	/* which model is used for that task ? */
 	starpu_perfmodel_type type;
 
@@ -125,8 +125,8 @@ enum starpu_perf_archtype starpu_worker_get_perf_archtype(int workerid);
 
 /* This function is intended to be used by external tools that should read the
  * performance model files */
-int starpu_load_history_debug(const char *symbol, struct starpu_perfmodel_t *model);
-void starpu_perfmodel_debugfilepath(struct starpu_perfmodel_t *model,
+int starpu_load_history_debug(const char *symbol, struct starpu_perfmodel *model);
+void starpu_perfmodel_debugfilepath(struct starpu_perfmodel *model,
 		enum starpu_perf_archtype arch, char *path, size_t maxlen, unsigned nimpl);
 void starpu_perfmodel_get_arch_name(enum starpu_perf_archtype arch,	char *archname, size_t maxlen, unsigned nimpl);
 int starpu_list_models(void);

include/starpu_scheduler.h

@@ -69,12 +69,12 @@ struct starpu_machine_topology_s {
 /* This structure contains all the methods that implement a scheduling policy.
  * An application may specify which scheduling strategy in the "sched_policy"
  * field of the starpu_conf structure passed to the starpu_init function. */
-struct starpu_sched_policy_s {
+struct starpu_sched_policy {
 	/* Initialize the scheduling policy. */
-	void (*init_sched)(struct starpu_machine_topology_s *, struct starpu_sched_policy_s *);
+	void (*init_sched)(struct starpu_machine_topology_s *, struct starpu_sched_policy *);
 
 	/* Cleanup the scheduling policy. */
-	void (*deinit_sched)(struct starpu_machine_topology_s *, struct starpu_sched_policy_s *);
+	void (*deinit_sched)(struct starpu_machine_topology_s *, struct starpu_sched_policy *);
 
 	/* Insert a task into the scheduler. */
 	int (*push_task)(struct starpu_task *);

include/starpu_task.h

@@ -55,7 +55,7 @@
 extern "C" {
 #endif
 
-typedef uint64_t starpu_tag_t;
+typedef uint64_t starpu_tag;
 
 
 typedef void (*starpu_cpu_func_t)(void **, void*);    /* CPU core */
@@ -94,13 +94,13 @@ typedef struct starpu_codelet_t {
 	unsigned nbuffers;
 
 	/* performance model of the codelet */
-	struct starpu_perfmodel_t *model;
+	struct starpu_perfmodel *model;
 	/* consumption model of the codelet.
 	 * In the case of parallel codelets, accounts for all units. */
-	struct starpu_perfmodel_t *power_model;
+	struct starpu_perfmodel *power_model;
 
 	/* Conversion model of the codelet */
-	struct starpu_perfmodel_t *conversion_model;
+	struct starpu_perfmodel *conversion_model;
 
 	/* statistics collected at runtime: this is filled by StarPU and should
 	 * not be accessed directly (use the starpu_display_codelet_stats
@@ -125,7 +125,7 @@ struct starpu_task {
 	void *callback_arg;
 
 	unsigned use_tag;
-	starpu_tag_t tag_id;
+	starpu_tag tag_id;
 
 	/* options for the task execution */
 	unsigned synchronous; /* if set, a call to push is blocking */
@@ -223,27 +223,27 @@ struct starpu_task {
 /*
  * WARNING ! use with caution ...
  *  In case starpu_tag_declare_deps is passed constant arguments, the caller
- *  must make sure that the constants are casted to starpu_tag_t. Otherwise,
+ *  must make sure that the constants are casted to starpu_tag. Otherwise,
  *  due to integer sizes and argument passing on the stack, the C compiler
  *  might consider the tag *  0x200000003 instead of 0x2 and 0x3 when calling:
  *      "starpu_tag_declare_deps(0x1, 2, 0x2, 0x3)"
  *  Using starpu_tag_declare_deps_array is a way to avoid this problem.
  */
 /* make id depend on the list of ids */
-void starpu_tag_declare_deps(starpu_tag_t id, unsigned ndeps, ...);
-void starpu_tag_declare_deps_array(starpu_tag_t id, unsigned ndeps, starpu_tag_t *array);
+void starpu_tag_declare_deps(starpu_tag id, unsigned ndeps, ...);
+void starpu_tag_declare_deps_array(starpu_tag id, unsigned ndeps, starpu_tag *array);
 
 /* task depends on the tasks in task array */
 void starpu_task_declare_deps_array(struct starpu_task *task, unsigned ndeps, struct starpu_task *task_array[]);
 
-int starpu_tag_wait(starpu_tag_t id);
-int starpu_tag_wait_array(unsigned ntags, starpu_tag_t *id);
+int starpu_tag_wait(starpu_tag id);
+int starpu_tag_wait_array(unsigned ntags, starpu_tag *id);
 
 /* The application can feed a tag explicitely */
-void starpu_tag_notify_from_apps(starpu_tag_t id);
+void starpu_tag_notify_from_apps(starpu_tag id);
 
 /* To release resources, tags should be freed after use */
-void starpu_tag_remove(starpu_tag_t id);
+void starpu_tag_remove(starpu_tag id);
 
 /* Initialize a task structure with default values. */
 void starpu_task_init(struct starpu_task *task);

include/starpu_util.h

@@ -218,7 +218,7 @@ void starpu_execute_on_each_worker(void (*func)(void *), void *arg, uint32_t whe
 
 /* This creates (and submits) an empty task that unlocks a tag once all its
  * dependencies are fulfilled. */
-void starpu_create_sync_task(starpu_tag_t sync_tag, unsigned ndeps, starpu_tag_t *deps,
+void starpu_create_sync_task(starpu_tag sync_tag, unsigned ndeps, starpu_tag *deps,
 				void (*callback)(void *), void *callback_arg);
 
 /* Copy the content of the src_handle into the dst_handle handle.  The

mpi/examples/cholesky/mpi_cholesky_models.c

@@ -21,17 +21,17 @@
  *	Number of flops of Gemm 
  */
 
-struct starpu_perfmodel_t chol_model_11 = {
+struct starpu_perfmodel chol_model_11 = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "chol_model_11"
 };
 
-struct starpu_perfmodel_t chol_model_21 = {
+struct starpu_perfmodel chol_model_21 = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "chol_model_21"
 };
 
-struct starpu_perfmodel_t chol_model_22 = {
+struct starpu_perfmodel chol_model_22 = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "chol_model_22"
 };

mpi/examples/cholesky/mpi_cholesky_models.h

@@ -20,8 +20,8 @@
 
 #include <starpu.h>
 
-extern struct starpu_perfmodel_t chol_model_11;
-extern struct starpu_perfmodel_t chol_model_21;
-extern struct starpu_perfmodel_t chol_model_22;
+extern struct starpu_perfmodel chol_model_11;
+extern struct starpu_perfmodel chol_model_21;
+extern struct starpu_perfmodel chol_model_22;
 
 #endif // __DW_CHOLESKY_MODELS_H__

mpi/examples/mpi_lu/pxlu.c

@@ -26,27 +26,27 @@
 // 11 21
 // 12 22
 
-#define TAG11(k)	((starpu_tag_t)( (1ULL<<50) | (unsigned long long)(k)))
-#define TAG12(k,j)	((starpu_tag_t)(((2ULL<<50) | (((unsigned long long)(k))<<32)	\
+#define TAG11(k)	((starpu_tag)( (1ULL<<50) | (unsigned long long)(k)))
+#define TAG12(k,j)	((starpu_tag)(((2ULL<<50) | (((unsigned long long)(k))<<32)	\
 					| (unsigned long long)(j))))
-#define TAG21(k,i)	((starpu_tag_t)(((3ULL<<50) | (((unsigned long long)(k))<<32)	\
+#define TAG21(k,i)	((starpu_tag)(((3ULL<<50) | (((unsigned long long)(k))<<32)	\
 					| (unsigned long long)(i))))
-#define TAG22(k,i,j)	((starpu_tag_t)(((4ULL<<50) | ((unsigned long long)(k)<<32) 	\
+#define TAG22(k,i,j)	((starpu_tag)(((4ULL<<50) | ((unsigned long long)(k)<<32) 	\
 					| ((unsigned long long)(i)<<16)	\
 					| (unsigned long long)(j))))
-#define TAG11_SAVE(k)	((starpu_tag_t)( (5ULL<<50) | (unsigned long long)(k)))
-#define TAG12_SAVE(k,j)	((starpu_tag_t)(((6ULL<<50) | (((unsigned long long)(k))<<32)	\
+#define TAG11_SAVE(k)	((starpu_tag)( (5ULL<<50) | (unsigned long long)(k)))
+#define TAG12_SAVE(k,j)	((starpu_tag)(((6ULL<<50) | (((unsigned long long)(k))<<32)	\
 					| (unsigned long long)(j))))
-#define TAG21_SAVE(k,i)	((starpu_tag_t)(((7ULL<<50) | (((unsigned long long)(k))<<32)	\
+#define TAG21_SAVE(k,i)	((starpu_tag)(((7ULL<<50) | (((unsigned long long)(k))<<32)	\
 					| (unsigned long long)(i))))
 
-#define TAG11_SAVE_PARTIAL(k)	((starpu_tag_t)( (8ULL<<50) | (unsigned long long)(k)))
-#define TAG12_SAVE_PARTIAL(k,j)	((starpu_tag_t)(((9ULL<<50) | (((unsigned long long)(k))<<32)	\
+#define TAG11_SAVE_PARTIAL(k)	((starpu_tag)( (8ULL<<50) | (unsigned long long)(k)))
+#define TAG12_SAVE_PARTIAL(k,j)	((starpu_tag)(((9ULL<<50) | (((unsigned long long)(k))<<32)	\
 					| (unsigned long long)(j))))
-#define TAG21_SAVE_PARTIAL(k,i)	((starpu_tag_t)(((10ULL<<50) | (((unsigned long long)(k))<<32)	\
+#define TAG21_SAVE_PARTIAL(k,i)	((starpu_tag)(((10ULL<<50) | (((unsigned long long)(k))<<32)	\
 					| (unsigned long long)(i))))
 
-#define STARPU_TAG_INIT	((starpu_tag_t)(11ULL<<50))
+#define STARPU_TAG_INIT	((starpu_tag)(11ULL<<50))
 
 //#define VERBOSE_INIT	1
 
@@ -77,7 +77,7 @@ static struct debug_info *create_debug_info(unsigned i, unsigned j, unsigned k)
 	return info;
 }
 
-static struct starpu_task *create_task(starpu_tag_t id)
+static struct starpu_task *create_task(starpu_tag id)
 {
 	struct starpu_task *task = starpu_task_create();
 		task->cl_arg = NULL;
@@ -90,7 +90,7 @@ static struct starpu_task *create_task(starpu_tag_t 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_t tag)
+static void send_data_to_mask(starpu_data_handle handle, int *rank_mask, int mpi_tag, starpu_tag tag)
 {
 	unsigned cnt = 0;
 
@@ -133,7 +133,7 @@ struct recv_when_done_callback_arg {
 	int source;
 	int mpi_tag;
 	starpu_data_handle handle;
-	starpu_tag_t unlocked_tag;
+	starpu_tag unlocked_tag;
 };
 
 static void callback_receive_when_done(void *_arg)
@@ -146,11 +146,11 @@ static void callback_receive_when_done(void *_arg)
 	free(arg);
 }
 
-static void receive_when_deps_are_done(unsigned ndeps, starpu_tag_t *deps_tags,
+static void receive_when_deps_are_done(unsigned ndeps, starpu_tag *deps_tags,
 				int source, int mpi_tag,
 				starpu_data_handle handle,
-				starpu_tag_t partial_tag,
-				starpu_tag_t unlocked_tag)
+				starpu_tag partial_tag,
+				starpu_tag unlocked_tag)
 {
 	STARPU_ASSERT(handle != STARPU_POISON_PTR);
 
@@ -185,7 +185,7 @@ static void create_task_11_recv(unsigned k)
 	 * temporary buffer is done : 11_(k-1) can be used by 12_(k-1)j and
 	 * 21(k-1)i with i,j >= k */
 	unsigned ndeps = 0;
-	starpu_tag_t tag_array[2*nblocks];
+	starpu_tag tag_array[2*nblocks];
 	
 #ifdef SINGLE_TMP11
 	unsigned i, j;
@@ -211,8 +211,8 @@ static void create_task_11_recv(unsigned k)
 	starpu_data_handle block_handle = STARPU_PLU(get_tmp_11_block_handle)(k);
 #endif
 	int mpi_tag = MPI_TAG11(k);
-	starpu_tag_t partial_tag = TAG11_SAVE_PARTIAL(k);
-	starpu_tag_t unlocked_tag = TAG11_SAVE(k);
+	starpu_tag partial_tag = TAG11_SAVE_PARTIAL(k);
+	starpu_tag unlocked_tag = TAG11_SAVE(k);
 
 //	fprintf(stderr, "NODE %d - 11 (%d) - recv when done ndeps %d - tag array %lx\n", rank, k, ndeps, tag_array[0]);
 	receive_when_deps_are_done(ndeps, tag_array, source, mpi_tag, block_handle, partial_tag, unlocked_tag);
@@ -251,7 +251,7 @@ static void callback_task_11_real(void *_arg)
 
 	/* Send the block to those nodes */
 	starpu_data_handle block_handle = STARPU_PLU(get_block_handle)(k, k);
-	starpu_tag_t tag = TAG11_SAVE(k);
+	starpu_tag tag = TAG11_SAVE(k);
 	int mpi_tag = MPI_TAG11(k);
 	send_data_to_mask(block_handle, rank_mask, mpi_tag, tag);
 	
@@ -337,7 +337,7 @@ static void create_task_12_recv(unsigned k, unsigned j)
 	 * temporary buffer is done : 12_(k-1)j can be used by 22_(k-1)ij with
 	 * i >= k */
 	unsigned ndeps = 0;
-	starpu_tag_t tag_array[nblocks];
+	starpu_tag tag_array[nblocks];
 	
 #ifdef SINGLE_TMP1221
 	if (k > 0)
@@ -362,8 +362,8 @@ static void create_task_12_recv(unsigned k, unsigned j)
 	starpu_data_handle block_handle = STARPU_PLU(get_tmp_12_block_handle)(j,k);
 #endif
 	int mpi_tag = MPI_TAG12(k, j);
-	starpu_tag_t partial_tag = TAG12_SAVE_PARTIAL(k, j);
-	starpu_tag_t unlocked_tag = TAG12_SAVE(k, j);
+	starpu_tag partial_tag = TAG12_SAVE_PARTIAL(k, j);
+	starpu_tag unlocked_tag = TAG12_SAVE(k, j);
 
 	receive_when_deps_are_done(ndeps, tag_array, source, mpi_tag, block_handle, partial_tag, unlocked_tag);
 }
@@ -395,7 +395,7 @@ static void callback_task_12_real(void *_arg)
 
 	/* Send the block to those nodes */
 	starpu_data_handle block_handle = STARPU_PLU(get_block_handle)(k, j);
-	starpu_tag_t tag = TAG12_SAVE(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);
 	
@@ -414,7 +414,7 @@ static void create_task_12_real(unsigned k, unsigned j)
 
 	unsigned diag_block_is_local = (get_block_rank(k, k) == rank);
 
-	starpu_tag_t tag_11_dep; 
+	starpu_tag tag_11_dep; 
 
 	/* which sub-data is manipulated ? */
 	starpu_data_handle diag_block;
@@ -509,7 +509,7 @@ static void create_task_21_recv(unsigned k, unsigned i)
 	 * temporary buffer is done : 21_(k-1)i can be used by 22_(k-1)ij with
 	 * j >= k */
 	unsigned ndeps = 0;
-	starpu_tag_t tag_array[nblocks];
+	starpu_tag tag_array[nblocks];
 	
 #ifdef SINGLE_TMP1221
 	if (k > 0)
@@ -534,8 +534,8 @@ static void create_task_21_recv(unsigned k, unsigned i)
 	starpu_data_handle block_handle = STARPU_PLU(get_tmp_21_block_handle)(i, k);
 #endif
 	int mpi_tag = MPI_TAG21(k, i);
-	starpu_tag_t partial_tag = TAG21_SAVE_PARTIAL(k, i);
-	starpu_tag_t unlocked_tag = TAG21_SAVE(k, i);
+	starpu_tag partial_tag = TAG21_SAVE_PARTIAL(k, i);
+	starpu_tag unlocked_tag = TAG21_SAVE(k, i);
 
 //	fprintf(stderr, "NODE %d - 21 (%d, %d) - recv when done ndeps %d - tag array %lx\n", rank, k, i, ndeps, tag_array[0]);
 	receive_when_deps_are_done(ndeps, tag_array, source, mpi_tag, block_handle, partial_tag, unlocked_tag);
@@ -568,7 +568,7 @@ static void callback_task_21_real(void *_arg)
 
 	/* Send the block to those nodes */
 	starpu_data_handle block_handle = STARPU_PLU(get_block_handle)(i, k);
-	starpu_tag_t tag = TAG21_SAVE(k, i);
+	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);
 	
@@ -587,7 +587,7 @@ static void create_task_21_real(unsigned k, unsigned i)
 
 	unsigned diag_block_is_local = (get_block_rank(k, k) == rank);
 
-	starpu_tag_t tag_11_dep; 
+	starpu_tag tag_11_dep; 
 	
 	/* which sub-data is manipulated ? */
 	starpu_data_handle diag_block;
@@ -683,7 +683,7 @@ static void create_task_22_real(unsigned k, unsigned i, unsigned j)
 
 	/* produced by TAG21_SAVE(k, i) */ 
 	unsigned block21_is_local = (get_block_rank(i, k) == rank);
-	starpu_tag_t tag_21_dep;
+	starpu_tag tag_21_dep;
 
 	starpu_data_handle block21;
 	if (block21_is_local)
@@ -703,7 +703,7 @@ static void create_task_22_real(unsigned k, unsigned i, unsigned j)
 
 	/* produced by TAG12_SAVE(k, j) */
 	unsigned block12_is_local = (get_block_rank(k, j) == rank);
-	starpu_tag_t tag_12_dep;
+	starpu_tag tag_12_dep;
 
 	starpu_data_handle block12;
 	if (block12_is_local)
@@ -768,7 +768,7 @@ static void create_task_22(unsigned k, unsigned i, unsigned j)
 //	}
 }
 
-static void wait_tag_and_fetch_handle(starpu_tag_t tag, starpu_data_handle handle)
+static void wait_tag_and_fetch_handle(starpu_tag tag, starpu_data_handle handle)
 {
 	STARPU_ASSERT(handle != STARPU_POISON_PTR);
 

mpi/examples/mpi_lu/pxlu_kernels.c

@@ -96,7 +96,7 @@ static void STARPU_PLU(cublas_u22)(void *descr[], void *_args)
 }
 #endif// STARPU_USE_CUDA
 
-static struct starpu_perfmodel_t STARPU_PLU(model_22) = {
+static struct starpu_perfmodel STARPU_PLU(model_22) = {
 	.type = STARPU_HISTORY_BASED,
 #ifdef STARPU_ATLAS
 	.symbol = STARPU_PLU_STR(lu_model_22_atlas)
@@ -203,7 +203,7 @@ static void STARPU_PLU(cublas_u12)(void *descr[], void *_args)
 }
 #endif // STARPU_USE_CUDA
 
-static struct starpu_perfmodel_t STARPU_PLU(model_12) = {
+static struct starpu_perfmodel STARPU_PLU(model_12) = {
 	.type = STARPU_HISTORY_BASED,
 #ifdef STARPU_ATLAS
 	.symbol = STARPU_PLU_STR(lu_model_12_atlas)
@@ -311,7 +311,7 @@ static void STARPU_PLU(cublas_u21)(void *descr[], void *_args)
 }
 #endif 
 
-static struct starpu_perfmodel_t STARPU_PLU(model_21) = {
+static struct starpu_perfmodel STARPU_PLU(model_21) = {
 	.type = STARPU_HISTORY_BASED,
 #ifdef STARPU_ATLAS
 	.symbol = STARPU_PLU_STR(lu_model_21_atlas)
@@ -416,7 +416,7 @@ static void STARPU_PLU(cublas_u11)(void *descr[], void *_args)
 }
 #endif// STARPU_USE_CUDA
 
-static struct starpu_perfmodel_t STARPU_PLU(model_11) = {
+static struct starpu_perfmodel STARPU_PLU(model_11) = {
 	.type = STARPU_HISTORY_BASED,
 #ifdef STARPU_ATLAS
 	.symbol = STARPU_PLU_STR(lu_model_11_atlas)

mpi/starpu_mpi.h

@@ -49,17 +49,17 @@ int starpu_mpi_gather_detached(starpu_data_handle *data_handles, int count, int
 /* 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_t tag);
-int starpu_mpi_irecv_detached_unlock_tag(starpu_data_handle data_handle, int source, int mpi_tag, MPI_Comm comm, starpu_tag_t tag);
+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);
 
 /* 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,
-		MPI_Comm *comm, starpu_tag_t 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,
-		MPI_Comm *comm, starpu_tag_t tag);
+		MPI_Comm *comm, starpu_tag tag);
 
 #ifdef __cplusplus
 }

mpi/starpu_mpi_helper.c

@@ -19,7 +19,7 @@
 
 static void starpu_mpi_unlock_tag_callback(void *arg)
 {
-	starpu_tag_t *tagptr = arg;
+	starpu_tag *tagptr = arg;
 
 	starpu_tag_notify_from_apps(*tagptr);
 
@@ -27,9 +27,9 @@ static void starpu_mpi_unlock_tag_callback(void *arg)
 }
 
 int starpu_mpi_isend_detached_unlock_tag(starpu_data_handle data_handle,
-				int dest, int mpi_tag, MPI_Comm comm, starpu_tag_t tag)
+				int dest, int mpi_tag, MPI_Comm comm, starpu_tag tag)
 {
-	starpu_tag_t *tagptr = malloc(sizeof(starpu_tag_t));
+	starpu_tag *tagptr = malloc(sizeof(starpu_tag));
 	*tagptr = tag;
 	
 	return starpu_mpi_isend_detached(data_handle, dest, mpi_tag, comm,
@@ -37,9 +37,9 @@ 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_t tag)
+int starpu_mpi_irecv_detached_unlock_tag(starpu_data_handle data_handle, int source, int mpi_tag, MPI_Comm comm, starpu_tag tag)
 {
-	starpu_tag_t *tagptr = malloc(sizeof(starpu_tag_t));
+	starpu_tag *tagptr = malloc(sizeof(starpu_tag));
 	*tagptr = tag;
 	
 	return starpu_mpi_irecv_detached(data_handle, source, mpi_tag, comm,
@@ -48,7 +48,7 @@ int starpu_mpi_irecv_detached_unlock_tag(starpu_data_handle data_handle, int sou
 
 struct arg_array {
 	int array_size;
-	starpu_tag_t tag;
+	starpu_tag tag;
 };
 
 static void starpu_mpi_array_unlock_callback(void *_arg)
@@ -66,7 +66,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,
-		MPI_Comm *comm, starpu_tag_t 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_t tag)
+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)
 {
 	struct arg_array *arg = malloc(sizeof(struct arg_array));
 

mpi/tests/mpi_detached_tag.c

@@ -55,7 +55,7 @@ int main(int argc, char **argv)
 
 	for (loop = 0; loop < nloops; loop++)
 	{
-		starpu_tag_t tag = (starpu_tag_t)loop;
+		starpu_tag tag = (starpu_tag)loop;
 
 		if ((loop % 2) == rank)
 		{

socl/src/cl_enqueuendrangekernel.c

@@ -102,7 +102,7 @@ static void cleaning_task_callback(void *args) {
 	free(co);
 }
 
-static struct starpu_perfmodel_t perf_model = {
+static struct starpu_perfmodel perf_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "perf_model"
 };

socl/src/task.c

@@ -69,7 +69,7 @@ void task_depends_on(starpu_task task, cl_uint num_events, cl_event *events) {
 	if (num_events != 0) {
 		cl_uint i;
 
-		starpu_tag_t * tags = malloc(num_events * sizeof(starpu_tag_t));	
+		starpu_tag * tags = malloc(num_events * sizeof(starpu_tag));	
 
 		if (num_events != 0)
 			DEBUG_MSG("Tag %d depends on %u tags:", task->tag_id, num_events);

src/core/dependencies/htable.c

@@ -18,13 +18,13 @@
 #include <core/dependencies/htable.h>
 #include <string.h>
 
-void *_starpu_htbl_search_tag(starpu_htbl_node_t *htbl, starpu_tag_t tag)
+void *_starpu_htbl_search_tag(starpu_htbl_node_t *htbl, starpu_tag tag)
 {
 	unsigned currentbit;
 	starpu_htbl_node_t *current_htbl = htbl;
 
 	/* 000000000001111 with STARPU_HTBL_NODE_SIZE 1's */
-	starpu_tag_t mask = (1<<STARPU_HTBL_NODE_SIZE)-1;
+	starpu_tag mask = (1<<STARPU_HTBL_NODE_SIZE)-1;
 
 	for(currentbit = 0; currentbit < STARPU_TAG_SIZE; currentbit+=STARPU_HTBL_NODE_SIZE)
 	{
@@ -41,7 +41,7 @@ void *_starpu_htbl_search_tag(starpu_htbl_node_t *htbl, starpu_tag_t tag)
 
 		unsigned last_currentbit = 
 			STARPU_TAG_SIZE - (currentbit + STARPU_HTBL_NODE_SIZE);
-		starpu_tag_t offloaded_mask = mask << last_currentbit;
+		starpu_tag offloaded_mask = mask << last_currentbit;
 		unsigned current_index = 
 			(tag & (offloaded_mask)) >> (last_currentbit);
 
@@ -55,7 +55,7 @@ void *_starpu_htbl_search_tag(starpu_htbl_node_t *htbl, starpu_tag_t tag)
  * returns the previous value of the tag, or NULL else
  */
 
-void *_starpu_htbl_insert_tag(starpu_htbl_node_t **htbl, starpu_tag_t tag, void *entry)
+void *_starpu_htbl_insert_tag(starpu_htbl_node_t **htbl, starpu_tag tag, void *entry)
 {
 
 	unsigned currentbit;
@@ -63,7 +63,7 @@ void *_starpu_htbl_insert_tag(starpu_htbl_node_t **htbl, starpu_tag_t tag, void
 	starpu_htbl_node_t *previous_htbl_ptr = NULL;
 
 	/* 000000000001111 with STARPU_HTBL_NODE_SIZE 1's */
-	starpu_tag_t mask = (1<<STARPU_HTBL_NODE_SIZE)-1;
+	starpu_tag mask = (1<<STARPU_HTBL_NODE_SIZE)-1;
 
 	for(currentbit = 0; currentbit < STARPU_TAG_SIZE; currentbit+=STARPU_HTBL_NODE_SIZE)
 	{
@@ -84,7 +84,7 @@ void *_starpu_htbl_insert_tag(starpu_htbl_node_t **htbl, starpu_tag_t tag, void
 
 		unsigned last_currentbit = 
 			STARPU_TAG_SIZE - (currentbit + STARPU_HTBL_NODE_SIZE);
-		starpu_tag_t offloaded_mask = mask << last_currentbit;
+		starpu_tag offloaded_mask = mask << last_currentbit;
 		unsigned current_index = 
 			(tag & (offloaded_mask)) >> (last_currentbit);
 
@@ -106,7 +106,7 @@ void *_starpu_htbl_insert_tag(starpu_htbl_node_t **htbl, starpu_tag_t tag, void
 }
 
 /* returns the entry corresponding to the tag and remove it from the htbl */
-void *_starpu_htbl_remove_tag(starpu_htbl_node_t *htbl, starpu_tag_t tag)
+void *_starpu_htbl_remove_tag(starpu_htbl_node_t *htbl, starpu_tag tag)
 {
 	/* NB : if the entry is "NULL", we assume this means it is not present XXX */
 	unsigned currentbit;
@@ -116,7 +116,7 @@ void *_starpu_htbl_remove_tag(starpu_htbl_node_t *htbl, starpu_tag_t tag)
 	starpu_htbl_node_t *path[(STARPU_TAG_SIZE + STARPU_HTBL_NODE_SIZE - 1)/(STARPU_HTBL_NODE_SIZE)];
 
 	/* 000000000001111 with STARPU_HTBL_NODE_SIZE 1's */
-	starpu_tag_t mask = (1<<STARPU_HTBL_NODE_SIZE)-1;
+	starpu_tag mask = (1<<STARPU_HTBL_NODE_SIZE)-1;
 	int level, maxlevel;
 	unsigned tag_is_present = 1;
 
@@ -137,7 +137,7 @@ void *_starpu_htbl_remove_tag(starpu_htbl_node_t *htbl, starpu_tag_t tag)
 
 		unsigned last_currentbit = 
 			STARPU_TAG_SIZE - (currentbit + STARPU_HTBL_NODE_SIZE);
-		starpu_tag_t offloaded_mask = mask << last_currentbit;
+		starpu_tag offloaded_mask = mask << last_currentbit;
 		unsigned current_index = 
 			(tag & (offloaded_mask)) >> (last_currentbit);
 		

src/core/dependencies/htable.h

@@ -35,9 +35,9 @@ typedef struct starpu_htbl_node_s {
 	struct starpu_htbl_node_s *children[1<<STARPU_HTBL_NODE_SIZE];
 } starpu_htbl_node_t;
 
-void *_starpu_htbl_search_tag(starpu_htbl_node_t *htbl, starpu_tag_t tag);
-void *_starpu_htbl_insert_tag(starpu_htbl_node_t **htbl, starpu_tag_t tag, void *entry);
-void *_starpu_htbl_remove_tag(starpu_htbl_node_t *htbl, starpu_tag_t tag);
+void *_starpu_htbl_search_tag(starpu_htbl_node_t *htbl, starpu_tag tag);
+void *_starpu_htbl_insert_tag(starpu_htbl_node_t **htbl, starpu_tag tag, void *entry);
+void *_starpu_htbl_remove_tag(starpu_htbl_node_t *htbl, starpu_tag tag);
 
 
 #endif

src/core/dependencies/tags.c

@@ -60,7 +60,7 @@ static starpu_cg_t *create_cg_tag(unsigned ntags, struct starpu_tag_s *tag)
 	return cg;
 }
 
-static struct starpu_tag_s *_starpu_tag_init(starpu_tag_t id)
+static struct starpu_tag_s *_starpu_tag_init(starpu_tag id)
 {
 	struct starpu_tag_s *tag;
 	tag = (struct starpu_tag_s *) malloc(sizeof(struct starpu_tag_s));
@@ -80,7 +80,7 @@ static struct starpu_tag_s *_starpu_tag_init(starpu_tag_t id)
 	return tag;
 }
 
-void starpu_tag_remove(starpu_tag_t id)
+void starpu_tag_remove(starpu_tag id)
 {
 	struct starpu_tag_s *tag;
 
@@ -118,7 +118,7 @@ void starpu_tag_remove(starpu_tag_t id)
 	free(tag);
 }
 
-static struct starpu_tag_s *gettag_struct(starpu_tag_t id)
+static struct starpu_tag_s *gettag_struct(starpu_tag id)
 {
 	pthread_rwlock_wrlock(&tag_global_rwlock);
 
@@ -190,14 +190,14 @@ void _starpu_notify_tag_dependencies(struct starpu_tag_s *tag)
 	_starpu_spin_unlock(&tag->lock);
 }
 
-void starpu_tag_notify_from_apps(starpu_tag_t id)
+void starpu_tag_notify_from_apps(starpu_tag id)
 {
 	struct starpu_tag_s *tag = gettag_struct(id);
 
 	_starpu_notify_tag_dependencies(tag);
 }
 
-void _starpu_tag_declare(starpu_tag_t id, struct starpu_job_s *job)
+void _starpu_tag_declare(starpu_tag id, struct starpu_job_s *job)
 {
 	STARPU_TRACE_TAG(id, job);
 	job->task->use_tag = 1;
@@ -214,7 +214,7 @@ void _starpu_tag_declare(starpu_tag_t id, struct starpu_job_s *job)
 	_starpu_spin_unlock(&tag->lock);
 }
 
-void starpu_tag_declare_deps_array(starpu_tag_t id, unsigned ndeps, starpu_tag_t *array)
+void starpu_tag_declare_deps_array(starpu_tag id, unsigned ndeps, starpu_tag *array)
 {
 	unsigned i;
 
@@ -229,7 +229,7 @@ void starpu_tag_declare_deps_array(starpu_tag_t id, unsigned ndeps, starpu_tag_t
 	
 	for (i = 0; i < ndeps; i++)
 	{
-		starpu_tag_t dep_id = array[i];
+		starpu_tag dep_id = array[i];
 		
 		/* id depends on dep_id
 		 * so cg should be among dep_id's successors*/
@@ -245,7 +245,7 @@ void starpu_tag_declare_deps_array(starpu_tag_t id, unsigned ndeps, starpu_tag_t
 	_starpu_spin_unlock(&tag_child->lock);
 }
 
-void starpu_tag_declare_deps(starpu_tag_t id, unsigned ndeps, ...)
+void starpu_tag_declare_deps(starpu_tag id, unsigned ndeps, ...)
 {
 	unsigned i;
 	
@@ -262,8 +262,8 @@ void starpu_tag_declare_deps(starpu_tag_t id, unsigned ndeps, ...)
 	va_start(pa, ndeps);
 	for (i = 0; i < ndeps; i++)
 	{
-		starpu_tag_t dep_id;
-		dep_id = va_arg(pa, starpu_tag_t);
+		starpu_tag dep_id;
+		dep_id = va_arg(pa, starpu_tag);
 	
 		/* id depends on dep_id
 		 * so cg should be among dep_id's successors*/
@@ -281,7 +281,7 @@ void starpu_tag_declare_deps(starpu_tag_t id, unsigned ndeps, ...)
 }
 
 /* this function may be called by the application (outside callbacks !) */
-int starpu_tag_wait_array(unsigned ntags, starpu_tag_t *id)
+int starpu_tag_wait_array(unsigned ntags, starpu_tag *id)
 {
 	unsigned i;
 	unsigned current;
@@ -347,7 +347,7 @@ int starpu_tag_wait_array(unsigned ntags, starpu_tag_t *id)
 	return 0;
 }
 
-int starpu_tag_wait(starpu_tag_t id)
+int starpu_tag_wait(starpu_tag id)
 {
 	return starpu_tag_wait_array(1, &id);
 }

src/core/dependencies/tags.h

@@ -23,7 +23,7 @@
 #include <common/starpu_spinlock.h>
 #include <core/dependencies/cg.h>
 
-#define STARPU_TAG_SIZE        (sizeof(starpu_tag_t)*8)
+#define STARPU_TAG_SIZE        (sizeof(starpu_tag)*8)
 
 typedef enum {
 	/* this tag is not declared by any task */
@@ -46,7 +46,7 @@ struct starpu_job_s;
 
 struct starpu_tag_s {
 	starpu_spinlock_t lock;
-	starpu_tag_t id; /* an identifier for the task */
+	starpu_tag id; /* an identifier for the task */
 	starpu_tag_state state;
 
 	struct starpu_cg_list_s tag_successors;
@@ -57,12 +57,12 @@ struct starpu_tag_s {
 	unsigned is_submitted;
 };
 
-void starpu_tag_declare_deps(starpu_tag_t id, unsigned ndeps, ...);
+void starpu_tag_declare_deps(starpu_tag id, unsigned ndeps, ...);
 
 void _starpu_notify_dependencies(struct starpu_job_s *j);
 void _starpu_notify_tag_dependencies(struct starpu_tag_s *tag);
 
-void _starpu_tag_declare(starpu_tag_t id, struct starpu_job_s *job);
+void _starpu_tag_declare(starpu_tag id, struct starpu_job_s *job);
 void _starpu_tag_set_ready(struct starpu_tag_s *tag);
 
 unsigned _starpu_submit_job_enforce_task_deps(struct starpu_job_s *j);

src/core/perfmodel/perfmodel.c

@@ -68,7 +68,7 @@ enum starpu_perf_archtype starpu_worker_get_perf_archtype(int workerid)
  * PER ARCH model
  */
 
-static double per_arch_task_expected_perf(struct starpu_perfmodel_t *model, enum starpu_perf_archtype arch, struct starpu_task *task, unsigned nimpl)
+static double per_arch_task_expected_perf(struct starpu_perfmodel *model, enum starpu_perf_archtype arch, struct starpu_task *task, unsigned nimpl)
 {
 	double exp = -1.0;
 	double (*per_arch_cost_model)(struct starpu_buffer_descr_t *);
@@ -110,7 +110,7 @@ double starpu_worker_get_relative_speedup(enum starpu_perf_archtype perf_archtyp
 	return -1.0;
 }
 
-static double common_task_expected_perf(struct starpu_perfmodel_t *model, enum starpu_perf_archtype arch, struct starpu_task *task)
+static double common_task_expected_perf(struct starpu_perfmodel *model, enum starpu_perf_archtype arch, struct starpu_task *task)
 {
 	double exp;
 	double alpha;
@@ -127,7 +127,7 @@ static double common_task_expected_perf(struct starpu_perfmodel_t *model, enum s
 	return -1.0;
 }
 
-void _starpu_load_perfmodel(struct starpu_perfmodel_t *model)
+void _starpu_load_perfmodel(struct starpu_perfmodel *model)
 {
 	if (!model || model->is_loaded)
 		return;
@@ -158,7 +158,7 @@ void _starpu_load_perfmodel(struct starpu_perfmodel_t *model)
 	model->is_loaded = 1;
 }
 
-static double starpu_model_expected_perf(struct starpu_task *task, struct starpu_perfmodel_t *model, enum starpu_perf_archtype arch,  unsigned nimpl)
+static double starpu_model_expected_perf(struct starpu_task *task, struct starpu_perfmodel *model, enum starpu_perf_archtype arch,  unsigned nimpl)
 {
 	if (model) {
 		starpu_job_t j = _starpu_get_job_associated_to_task(task);

src/core/perfmodel/perfmodel.h

@@ -75,7 +75,7 @@ struct starpu_history_list_t {
 
 struct starpu_model_list_t {
 	struct starpu_model_list_t *next;
-	struct starpu_perfmodel_t *model;
+	struct starpu_perfmodel *model;
 };
 
 //
@@ -92,18 +92,18 @@ void _starpu_get_perf_model_dir_codelets(char *path, size_t maxlen);
 void _starpu_get_perf_model_dir_bus(char *path, size_t maxlen);
 void _starpu_get_perf_model_dir_debug(char *path, size_t maxlen);
 
-double _starpu_history_based_job_expected_perf(struct starpu_perfmodel_t *model, enum starpu_perf_archtype arch, struct starpu_job_s *j, unsigned nimpl);
-int _starpu_register_model(struct starpu_perfmodel_t *model);
-void _starpu_load_history_based_model(struct starpu_perfmodel_t *model, unsigned scan_history);
-void _starpu_load_perfmodel(struct starpu_perfmodel_t *model);
+double _starpu_history_based_job_expected_perf(struct starpu_perfmodel *model, enum starpu_perf_archtype arch, struct starpu_job_s *j, unsigned nimpl);
+int _starpu_register_model(struct starpu_perfmodel *model);
+void _starpu_load_history_based_model(struct starpu_perfmodel *model, unsigned scan_history);
+void _starpu_load_perfmodel(struct starpu_perfmodel *model);
 void _starpu_initialize_registered_performance_models(void);
 void _starpu_deinitialize_registered_performance_models(void);
 
-double _starpu_regression_based_job_expected_perf(struct starpu_perfmodel_t *model,
+double _starpu_regression_based_job_expected_perf(struct starpu_perfmodel *model,
 					enum starpu_perf_archtype arch, struct starpu_job_s *j, unsigned nimpl);
-double _starpu_non_linear_regression_based_job_expected_perf(struct starpu_perfmodel_t *model,
+double _starpu_non_linear_regression_based_job_expected_perf(struct starpu_perfmodel *model,
 					enum starpu_perf_archtype arch, struct starpu_job_s *j, unsigned nimpl);
-void _starpu_update_perfmodel_history(struct starpu_job_s *j, struct starpu_perfmodel_t *model, enum starpu_perf_archtype arch,
+void _starpu_update_perfmodel_history(struct starpu_job_s *j, struct starpu_perfmodel *model, enum starpu_perf_archtype arch,
 				unsigned cpuid, double measured, unsigned nimpl);
 
 void _starpu_create_sampling_directory_if_needed(void);

src/core/perfmodel/perfmodel_history.c

@@ -58,7 +58,7 @@ static void insert_history_entry(struct starpu_history_entry_t *entry, struct st
 }
 
 
-static void dump_reg_model(FILE *f, struct starpu_perfmodel_t *model, unsigned arch, unsigned nimpl)
+static void dump_reg_model(FILE *f, struct starpu_perfmodel *model, unsigned arch, unsigned nimpl)
 {
 	struct starpu_per_arch_perfmodel_t *per_arch_model;
 
@@ -204,7 +204,7 @@ static void parse_per_arch_model_file(FILE *f, struct starpu_per_arch_perfmodel_
 	}
 }
 
-static void parse_arch(FILE *f, struct starpu_perfmodel_t *model, unsigned scan_history, unsigned archmin, unsigned archmax, int skiparch)
+static void parse_arch(FILE *f, struct starpu_perfmodel *model, unsigned scan_history, unsigned archmin, unsigned archmax, int skiparch)
 {
 	struct starpu_per_arch_perfmodel_t dummy;
 	int nimpls, implmax, skipimpl, impl;
@@ -246,7 +246,7 @@ static void parse_arch(FILE *f, struct starpu_perfmodel_t *model, unsigned scan_
 	}
 }
 
-static void parse_model_file(FILE *f, struct starpu_perfmodel_t *model, unsigned scan_history)
+static void parse_model_file(FILE *f, struct starpu_perfmodel *model, unsigned scan_history)
 {
 	unsigned ret;
 	unsigned archmin = 0;
@@ -316,7 +316,7 @@ static void parse_model_file(FILE *f, struct starpu_perfmodel_t *model, unsigned
 }
 
 
-static void dump_per_arch_model_file(FILE *f, struct starpu_perfmodel_t *model, unsigned arch, unsigned nimpl)
+static void dump_per_arch_model_file(FILE *f, struct starpu_perfmodel *model, unsigned arch, unsigned nimpl)
 {
 	struct starpu_per_arch_perfmodel_t *per_arch_model;
 
@@ -359,7 +359,7 @@ static void dump_per_arch_model_file(FILE *f, struct starpu_perfmodel_t *model,
 	fprintf(f, "\n##################\n");
 }
 
-static unsigned get_n_entries(struct starpu_perfmodel_t *model, unsigned arch, unsigned impl)
+static unsigned get_n_entries(struct starpu_perfmodel *model, unsigned arch, unsigned impl)
 {
 	struct starpu_per_arch_perfmodel_t *per_arch_model;
 	per_arch_model = &model->per_arch[arch][impl];
@@ -379,7 +379,7 @@ static unsigned get_n_entries(struct starpu_perfmodel_t *model, unsigned arch, u
 	return nentries;
 }
 
-static void dump_model_file(FILE *f, struct starpu_perfmodel_t *model)
+static void dump_model_file(FILE *f, struct starpu_perfmodel *model)
 {
 	unsigned number_of_archs[4] = { 0, 0, 0, 0};
 	unsigned arch;
@@ -482,7 +482,7 @@ static void initialize_per_arch_model(struct starpu_per_arch_perfmodel_t *per_ar
 	per_arch_model->list = NULL;
 }
 
-static void initialize_model(struct starpu_perfmodel_t *model)
+static void initialize_model(struct starpu_perfmodel *model)
 {
 	unsigned arch;
 	unsigned nimpl;
@@ -495,7 +495,7 @@ static void initialize_model(struct starpu_perfmodel_t *model)
 	}
 }
 
-static void get_model_debug_path(struct starpu_perfmodel_t *model, const char *arch, char *path, size_t maxlen)
+static void get_model_debug_path(struct starpu_perfmodel *model, const char *arch, char *path, size_t maxlen)
 {
 	STARPU_ASSERT(path);
 
@@ -518,7 +518,7 @@ static void get_model_debug_path(struct starpu_perfmodel_t *model, const char *a
 /*
  * Returns 0 is the model was already loaded, 1 otherwise.
  */
-int _starpu_register_model(struct starpu_perfmodel_t *model)
+int _starpu_register_model(struct starpu_perfmodel *model)
 {
 	/* If the model has already been loaded, there is nothing to do */
 	PTHREAD_RWLOCK_RDLOCK(&registered_models_rwlock);
@@ -566,7 +566,7 @@ int _starpu_register_model(struct starpu_perfmodel_t *model)
 	return 1;
 }
 
-static void get_model_path(struct starpu_perfmodel_t *model, char *path, size_t maxlen)
+static void get_model_path(struct starpu_perfmodel *model, char *path, size_t maxlen)
 {
 	_starpu_get_perf_model_dir_codelets(path, maxlen);
 	strncat(path, model->symbol, maxlen);
@@ -581,7 +581,7 @@ static void get_model_path(struct starpu_perfmodel_t *model, char *path, size_t
 	strncat(path, hostname, maxlen);
 }
 
-static void save_history_based_model(struct starpu_perfmodel_t *model)
+static void save_history_based_model(struct starpu_perfmodel *model)
 {
 	STARPU_ASSERT(model);
 	STARPU_ASSERT(model->symbol);
@@ -642,7 +642,7 @@ void _starpu_deinitialize_registered_performance_models(void)
  * was loaded or not (this is very likely to have been already loaded). If the
  * model was not loaded yet, we take the lock in write mode, and if the model
  * is still not loaded once we have the lock, we do load it.  */
-void _starpu_load_history_based_model(struct starpu_perfmodel_t *model, unsigned scan_history)
+void _starpu_load_history_based_model(struct starpu_perfmodel *model, unsigned scan_history)
 {
 
 	STARPU_ASSERT(model);
@@ -756,7 +756,7 @@ int starpu_list_models(void)
 
 /* This function is intended to be used by external tools that should read the
  * performance model files */
-int starpu_load_history_debug(const char *symbol, struct starpu_perfmodel_t *model)
+int starpu_load_history_debug(const char *symbol, struct starpu_perfmodel *model)
 {
 	model->symbol = strdup(symbol);
 
@@ -832,7 +832,7 @@ void starpu_perfmodel_get_arch_name(enum starpu_perf_archtype arch, char *archna
 	}
 }
 
-void starpu_perfmodel_debugfilepath(struct starpu_perfmodel_t *model,
+void starpu_perfmodel_debugfilepath(struct starpu_perfmodel *model,
 		enum starpu_perf_archtype arch, char *path, size_t maxlen, unsigned nimpl)
 {
 	char archname[32];
@@ -843,7 +843,7 @@ void starpu_perfmodel_debugfilepath(struct starpu_perfmodel_t *model,
 	get_model_debug_path(model, archname, path, maxlen);
 }
 
-double _starpu_regression_based_job_expected_perf(struct starpu_perfmodel_t *model, enum starpu_perf_archtype arch, struct starpu_job_s *j, unsigned nimpl)
+double _starpu_regression_based_job_expected_perf(struct starpu_perfmodel *model, enum starpu_perf_archtype arch, struct starpu_job_s *j, unsigned nimpl)
 {
 	double exp = -1.0;
 	size_t size = _starpu_job_get_data_size(j);
@@ -857,7 +857,7 @@ double _starpu_regression_based_job_expected_perf(struct starpu_perfmodel_t *mod
 	return exp;
 }
 
-double _starpu_non_linear_regression_based_job_expected_perf(struct starpu_perfmodel_t *model, enum starpu_perf_archtype arch, struct starpu_job_s *j,unsigned nimpl)
+double _starpu_non_linear_regression_based_job_expected_perf(struct starpu_perfmodel *model, enum starpu_perf_archtype arch, struct starpu_job_s *j,unsigned nimpl)
 {
 	double exp = -1.0;
 	size_t size = _starpu_job_get_data_size(j);
@@ -871,7 +871,7 @@ double _starpu_non_linear_regression_based_job_expected_perf(struct starpu_perfm
 	return exp;
 }
 
-double _starpu_history_based_job_expected_perf(struct starpu_perfmodel_t *model, enum starpu_perf_archtype arch, struct starpu_job_s *j,unsigned nimpl)
+double _starpu_history_based_job_expected_perf(struct starpu_perfmodel *model, enum starpu_perf_archtype arch, struct starpu_job_s *j,unsigned nimpl)
 {
 	double exp;
 	struct starpu_per_arch_perfmodel_t *per_arch_model;
@@ -907,7 +907,7 @@ double _starpu_history_based_job_expected_perf(struct starpu_perfmodel_t *model,
 	return exp;
 }
 
-void _starpu_update_perfmodel_history(starpu_job_t j, struct starpu_perfmodel_t *model, enum starpu_perf_archtype arch, unsigned cpuid STARPU_ATTRIBUTE_UNUSED, double measured, unsigned nimpl)
+void _starpu_update_perfmodel_history(starpu_job_t j, struct starpu_perfmodel *model, enum starpu_perf_archtype arch, unsigned cpuid STARPU_ATTRIBUTE_UNUSED, double measured, unsigned nimpl)
 {
 	if (model)
 	{

src/core/sched_policy.c

@@ -24,7 +24,7 @@
 #include <profiling/profiling.h>
 #include <common/barrier.h>
 
-static struct starpu_sched_policy_s policy;
+static struct starpu_sched_policy policy;
 
 static int use_prefetch = 0;
 
@@ -37,19 +37,19 @@ int starpu_get_prefetch_flag(void)
  *	Predefined policies
  */
 
-extern struct starpu_sched_policy_s _starpu_sched_ws_policy;
-extern struct starpu_sched_policy_s _starpu_sched_prio_policy;
-extern struct starpu_sched_policy_s _starpu_sched_random_policy;
-extern struct starpu_sched_policy_s _starpu_sched_dm_policy;
-extern struct starpu_sched_policy_s _starpu_sched_dmda_policy;
-extern struct starpu_sched_policy_s _starpu_sched_dmda_ready_policy;
-extern struct starpu_sched_policy_s _starpu_sched_dmda_sorted_policy;
-extern struct starpu_sched_policy_s _starpu_sched_eager_policy;
-extern struct starpu_sched_policy_s _starpu_sched_parallel_heft_policy;
-extern struct starpu_sched_policy_s _starpu_sched_pgreedy_policy;
-extern struct starpu_sched_policy_s heft_policy;
-
-static struct starpu_sched_policy_s *predefined_policies[] = {
+extern struct starpu_sched_policy _starpu_sched_ws_policy;
+extern struct starpu_sched_policy _starpu_sched_prio_policy;
+extern struct starpu_sched_policy _starpu_sched_random_policy;
+extern struct starpu_sched_policy _starpu_sched_dm_policy;
+extern struct starpu_sched_policy _starpu_sched_dmda_policy;
+extern struct starpu_sched_policy _starpu_sched_dmda_ready_policy;
+extern struct starpu_sched_policy _starpu_sched_dmda_sorted_policy;
+extern struct starpu_sched_policy _starpu_sched_eager_policy;
+extern struct starpu_sched_policy _starpu_sched_parallel_heft_policy;
+extern struct starpu_sched_policy _starpu_sched_pgreedy_policy;
+extern struct starpu_sched_policy heft_policy;
+
+static struct starpu_sched_policy *predefined_policies[] = {
 	&_starpu_sched_ws_policy,
 	&_starpu_sched_prio_policy,
 	&_starpu_sched_dm_policy,
@@ -63,7 +63,7 @@ static struct starpu_sched_policy_s *predefined_policies[] = {
 	&_starpu_sched_pgreedy_policy
 };
 
-struct starpu_sched_policy_s *_starpu_get_sched_policy(void)
+struct starpu_sched_policy *_starpu_get_sched_policy(void)
 {
 	return &policy;
 }
@@ -72,7 +72,7 @@ struct starpu_sched_policy_s *_starpu_get_sched_policy(void)
  *	Methods to initialize the scheduling policy
  */
 
-static void load_sched_policy(struct starpu_sched_policy_s *sched_policy)
+static void load_sched_policy(struct starpu_sched_policy *sched_policy)
 {
 	STARPU_ASSERT(sched_policy);
 
@@ -96,7 +96,7 @@ static void load_sched_policy(struct starpu_sched_policy_s *sched_policy)
 	policy.pop_every_task = sched_policy->pop_every_task;
 }
 
-static struct starpu_sched_policy_s *find_sched_policy_from_name(const char *policy_name)
+static struct starpu_sched_policy *find_sched_policy_from_name(const char *policy_name)
 {
 
 	if (!policy_name)
@@ -105,7 +105,7 @@ static struct starpu_sched_policy_s *find_sched_policy_from_name(const char *pol
 	unsigned i;
 	for (i = 0; i < sizeof(predefined_policies)/sizeof(predefined_policies[0]); i++)
 	{
-		struct starpu_sched_policy_s *p;
+		struct starpu_sched_policy *p;
 		p = predefined_policies[i];
 		if (p->policy_name)
 		{
@@ -131,16 +131,16 @@ static void display_sched_help_message(void)
 		unsigned i;
 		for (i = 0; i < sizeof(predefined_policies)/sizeof(predefined_policies[0]); i++)
 		{
-			struct starpu_sched_policy_s *p;
+			struct starpu_sched_policy *p;
 			p = predefined_policies[i];
 			fprintf(stderr, "%s\t-> %s\n", p->policy_name, p->policy_description);
 		}
 	 }
 }
 
-static struct starpu_sched_policy_s *select_sched_policy(struct starpu_machine_config_s *config)
+static struct starpu_sched_policy *select_sched_policy(struct starpu_machine_config_s *config)
 {
-	struct starpu_sched_policy_s *selected_policy = NULL;
+	struct starpu_sched_policy *selected_policy = NULL;
 	struct starpu_conf *user_conf = config->user_conf;
 
 	/* First, we check whether the application explicitely gave a scheduling policy or not */
@@ -191,7 +191,7 @@ void _starpu_init_sched_policy(struct starpu_machine_config_s *config)
 
 	_starpu_set_calibrate_flag(do_calibrate);
 
-	struct starpu_sched_policy_s *selected_policy;
+	struct starpu_sched_policy *selected_policy;
 	selected_policy = select_sched_policy(config);
 
 	load_sched_policy(selected_policy);

src/core/sched_policy.h

@@ -23,7 +23,7 @@
 #include <starpu_scheduler.h>
 
 struct starpu_machine_config_s;
-struct starpu_sched_policy_s *_starpu_get_sched_policy(void);
+struct starpu_sched_policy *_starpu_get_sched_policy(void);
 
 void _starpu_init_sched_policy(struct starpu_machine_config_s *config);
 void _starpu_deinit_sched_policy(struct starpu_machine_config_s *config);

src/datawizard/coherency.h

@@ -127,7 +127,7 @@ struct starpu_data_state_t {
 	struct starpu_data_replicate_s per_node[STARPU_MAXNODES];
 	struct starpu_data_replicate_s per_worker[STARPU_NMAXWORKERS];
 
-	struct starpu_data_interface_ops_t *ops;
+	struct starpu_data_interface_ops *ops;
 
 	/* To avoid recomputing data size all the time, we store it directly. */
 	size_t data_size;

src/datawizard/filters.c

@@ -359,7 +359,7 @@ static void starpu_data_create_children(starpu_data_handle handle, unsigned nchi
 	{
 		starpu_data_handle handle_child = &handle->children[child];
 		
-		struct starpu_data_interface_ops_t *ops;
+		struct starpu_data_interface_ops *ops;
 		
 		/* what's this child's interface ? */
 		if (f->get_child_ops)

src/datawizard/interfaces/bcsr_interface.c

@@ -68,7 +68,7 @@ static int bcsr_compare(void *data_interface_a, void *data_interface_b);
 static uint32_t footprint_bcsr_interface_crc32(starpu_data_handle handle);
 
 
-static struct starpu_data_interface_ops_t interface_bcsr_ops = {
+static struct starpu_data_interface_ops interface_bcsr_ops = {
 	.register_data_handle = register_bcsr_handle,
 	.allocate_data_on_node = allocate_bcsr_buffer_on_node,
 	.free_data_on_node = free_bcsr_buffer_on_node,

src/datawizard/interfaces/block_interface.c

@@ -77,7 +77,7 @@ static void display_block_interface(starpu_data_handle handle, FILE *f);
 static int convert_block_to_gordon(void *data_interface, uint64_t *ptr, gordon_strideSize_t *ss);
 #endif
 
-static struct starpu_data_interface_ops_t interface_block_ops = {
+static struct starpu_data_interface_ops interface_block_ops = {
 	.register_data_handle = register_block_handle,
 	.allocate_data_on_node = allocate_block_buffer_on_node,
 	.handle_to_pointer = block_handle_to_pointer,

src/datawizard/interfaces/csr_interface.c

@@ -70,7 +70,7 @@ static size_t csr_interface_get_size(starpu_data_handle handle);
 static int csr_compare(void *data_interface_a, void *data_interface_b);
 static uint32_t footprint_csr_interface_crc32(starpu_data_handle handle);
 
-static struct starpu_data_interface_ops_t interface_csr_ops = {
+static struct starpu_data_interface_ops interface_csr_ops = {
 	.register_data_handle = register_csr_handle,
 	.allocate_data_on_node = allocate_csr_buffer_on_node,
 	.free_data_on_node = free_csr_buffer_on_node,

src/datawizard/interfaces/data_interface.c

@@ -216,7 +216,7 @@ static void _starpu_register_new_data(starpu_data_handle handle,
 	}
 }
 
-static starpu_data_handle _starpu_data_handle_allocate(struct starpu_data_interface_ops_t *interface_ops)
+static starpu_data_handle _starpu_data_handle_allocate(struct starpu_data_interface_ops *interface_ops)
 {
 	starpu_data_handle handle = (starpu_data_handle)
 		calloc(1, sizeof(struct starpu_data_state_t));
@@ -268,7 +268,7 @@ static starpu_data_handle _starpu_data_handle_allocate(struct starpu_data_interf
 
 void starpu_data_register(starpu_data_handle *handleptr, uint32_t home_node,
 				void *data_interface,
-				struct starpu_data_interface_ops_t *ops)
+				struct starpu_data_interface_ops *ops)
 {
 	starpu_data_handle handle =
 		_starpu_data_handle_allocate(ops);

src/datawizard/interfaces/data_interface.h

@@ -22,7 +22,7 @@
 #include <common/config.h>
 
 /* Some data interfaces or filters use this interface internally */
-extern struct starpu_data_interface_ops_t _starpu_interface_matrix_ops;
+extern struct starpu_data_interface_ops _starpu_interface_matrix_ops;
 void _starpu_data_free_interfaces(starpu_data_handle handle)
 	STARPU_ATTRIBUTE_INTERNAL;
 

src/datawizard/interfaces/matrix_interface.c

@@ -83,7 +83,7 @@ static void display_matrix_interface(starpu_data_handle handle, FILE *f);
 static int convert_matrix_to_gordon(void *data_interface, uint64_t *ptr, gordon_strideSize_t *ss); 
 #endif
 
-struct starpu_data_interface_ops_t _starpu_interface_matrix_ops = {
+struct starpu_data_interface_ops _starpu_interface_matrix_ops = {
 	.register_data_handle = register_matrix_handle,
 	.allocate_data_on_node = allocate_matrix_buffer_on_node,
 	.handle_to_pointer = matrix_handle_to_pointer,

src/datawizard/interfaces/multiformat_interface.c

@@ -78,7 +78,7 @@ static int convert_multiformat_to_gordon(void *data_interface, uint64_t *ptr, go
 #endif
 
 
-static struct starpu_data_interface_ops_t interface_multiformat_ops = {
+static struct starpu_data_interface_ops interface_multiformat_ops = {
 	.register_data_handle  = register_multiformat_handle,
 	.allocate_data_on_node = allocate_multiformat_buffer_on_node,
 	.handle_to_pointer     = multiformat_handle_to_pointer,

src/datawizard/interfaces/variable_interface.c

@@ -78,7 +78,7 @@ static void display_variable_interface(starpu_data_handle handle, FILE *f);
 static int convert_variable_to_gordon(void *data_interface, uint64_t *ptr, gordon_strideSize_t *ss); 
 #endif
 
-static struct starpu_data_interface_ops_t interface_variable_ops = {
+static struct starpu_data_interface_ops interface_variable_ops = {
 	.register_data_handle = register_variable_handle,
 	.allocate_data_on_node = allocate_variable_buffer_on_node,
 	.handle_to_pointer = variable_handle_to_pointer,

src/datawizard/interfaces/vector_interface.c

@@ -78,7 +78,7 @@ static void display_vector_interface(starpu_data_handle handle, FILE *f);
 static int convert_vector_to_gordon(void *data_interface, uint64_t *ptr, gordon_strideSize_t *ss); 
 #endif
 
-static struct starpu_data_interface_ops_t interface_vector_ops = {
+static struct starpu_data_interface_ops interface_vector_ops = {
 	.register_data_handle = register_vector_handle,
 	.allocate_data_on_node = allocate_vector_buffer_on_node,
 	.handle_to_pointer = vector_handle_to_pointer,

src/datawizard/interfaces/void_interface.c

@@ -64,7 +64,7 @@ static uint32_t footprint_void_interface_crc32(starpu_data_handle handle);
 static int void_compare(void *data_interface_a, void *data_interface_b);
 static void display_void_interface(starpu_data_handle handle, FILE *f);
 
-static struct starpu_data_interface_ops_t interface_void_ops = {
+static struct starpu_data_interface_ops interface_void_ops = {
 	.register_data_handle = register_void_handle,
 	.allocate_data_on_node = allocate_void_buffer_on_node,
 	.free_data_on_node = free_void_buffer_on_node,

src/datawizard/memalloc.c

@@ -426,8 +426,8 @@ static unsigned try_to_reuse_mem_chunk(starpu_mem_chunk_t mc, unsigned node, sta
 	return success;
 }
 
-static int _starpu_data_interface_compare(void *data_interface_a, struct starpu_data_interface_ops_t *ops_a,
-                                          void *data_interface_b, struct starpu_data_interface_ops_t *ops_b)
+static int _starpu_data_interface_compare(void *data_interface_a, struct starpu_data_interface_ops *ops_a,
+                                          void *data_interface_b, struct starpu_data_interface_ops *ops_b)
 {
 	if (ops_a->interfaceid != ops_b->interfaceid)
 		return -1;

src/datawizard/memalloc.h

@@ -40,7 +40,7 @@ LIST_TYPE(starpu_mem_chunk,
 	 * the data interface) to stay on the safe side. We make a copy of
 	 * because when a data is deleted, the memory chunk remains.
 	 */
-	struct starpu_data_interface_ops_t *ops;
+	struct starpu_data_interface_ops *ops;
 	void *chunk_interface;
 	unsigned automatically_allocated;
 	unsigned data_was_deleted;

src/drivers/gordon/driver_gordon.c

@@ -205,7 +205,7 @@ static void gordon_callback_list_func(void *arg)
 		starpu_job_t j = starpu_job_list_pop_back(wrapper_list);
 
 		struct gordon_ppu_job_s * gordon_task = &task_wrapper->gordon_job[task_cnt];
-		struct starpu_perfmodel_t *model = j->task->cl->model;
+		struct starpu_perfmodel *model = j->task->cl->model;
 		if (model && model->benchmarking)
 		{
 			double measured = (double)gordon_task->measured;
@@ -315,7 +315,7 @@ int inject_task_list(struct starpu_job_list_s *list, struct starpu_worker_s *wor
 
 		gordon_jobs[index].index = task->cl->gordon_func;
 
-		struct starpu_perfmodel_t *model = j->task->cl->model;
+		struct starpu_perfmodel *model = j->task->cl->model;
 		if (model && model->benchmarking)
 			gordon_jobs[index].flags.sampling = 1;
 

src/profiling/bound.c

@@ -81,7 +81,7 @@ struct bound_task {
 	/* Unique ID */
 	unsigned long id;
 	/* Tag ID, if any */
-	starpu_tag_t tag_id;
+	starpu_tag tag_id;
 	int use_tag;
 	/* Which codelet has been executed */
 	struct starpu_codelet_t *cl;
@@ -101,8 +101,8 @@ struct bound_task {
 };
 
 struct bound_tag_dep {
-	starpu_tag_t tag;
-	starpu_tag_t dep_tag;
+	starpu_tag tag;
+	starpu_tag dep_tag;
 	struct bound_tag_dep *next;
 };
 
@@ -232,7 +232,7 @@ void _starpu_bound_record(starpu_job_t j)
 	PTHREAD_MUTEX_UNLOCK(&mutex);
 }
 
-void _starpu_bound_tag_dep(starpu_tag_t id, starpu_tag_t dep_id)
+void _starpu_bound_tag_dep(starpu_tag id, starpu_tag dep_id)
 {
 	struct bound_tag_dep *td;
 

src/profiling/bound.h

@@ -28,7 +28,7 @@ extern int _starpu_bound_recording;
 extern void _starpu_bound_record(starpu_job_t j);
 
 /* Record tag dependency: id depends on dep_id */
-extern void _starpu_bound_tag_dep(starpu_tag_t id, starpu_tag_t dep_id);
+extern void _starpu_bound_tag_dep(starpu_tag id, starpu_tag dep_id);
 
 /* Record task dependency: j depends on dep_j */
 extern void _starpu_bound_task_dep(starpu_job_t j, starpu_job_t dep_j);

src/sched_policies/deque_modeling_policy_data_aware.c

@@ -570,7 +570,7 @@ static int dmda_push_task(struct starpu_task *task)
 }
 
 static void initialize_dmda_policy(struct starpu_machine_topology_s *topology, 
-	 __attribute__ ((unused)) struct starpu_sched_policy_s *_policy) 
+	 __attribute__ ((unused)) struct starpu_sched_policy *_policy) 
 {
 	nworkers = topology->nworkers;
 
@@ -603,7 +603,7 @@ static void initialize_dmda_policy(struct starpu_machine_topology_s *topology,
 }
 
 static void initialize_dmda_sorted_policy(struct starpu_machine_topology_s *topology,
-					struct starpu_sched_policy_s *_policy)
+					struct starpu_sched_policy *_policy)
 {
 	initialize_dmda_policy(topology, _policy);
 
@@ -613,7 +613,7 @@ static void initialize_dmda_sorted_policy(struct starpu_machine_topology_s *topo
 }
 
 static void deinitialize_dmda_policy(struct starpu_machine_topology_s *topology, 
-	 __attribute__ ((unused)) struct starpu_sched_policy_s *_policy) 
+	 __attribute__ ((unused)) struct starpu_sched_policy *_policy) 
 {
 	unsigned workerid;
 	for (workerid = 0; workerid < topology->nworkers; workerid++)
@@ -623,7 +623,7 @@ static void deinitialize_dmda_policy(struct starpu_machine_topology_s *topology,
 }
 
 /* TODO: use post_exec_hook to fix the expected start */
-struct starpu_sched_policy_s _starpu_sched_dm_policy = {
+struct starpu_sched_policy _starpu_sched_dm_policy = {
 	.init_sched = initialize_dmda_policy,
 	.deinit_sched = deinitialize_dmda_policy,
 	.push_task = dm_push_task, 
@@ -634,7 +634,7 @@ struct starpu_sched_policy_s _starpu_sched_dm_policy = {
 	.policy_description = "performance model"
 };
 
-struct starpu_sched_policy_s _starpu_sched_dmda_policy = {
+struct starpu_sched_policy _starpu_sched_dmda_policy = {
 	.init_sched = initialize_dmda_policy,
 	.deinit_sched = deinitialize_dmda_policy,
 	.push_task = dmda_push_task, 
@@ -645,7 +645,7 @@ struct starpu_sched_policy_s _starpu_sched_dmda_policy = {
 	.policy_description = "data-aware performance model"
 };
 
-struct starpu_sched_policy_s _starpu_sched_dmda_sorted_policy = {
+struct starpu_sched_policy _starpu_sched_dmda_sorted_policy = {
 	.init_sched = initialize_dmda_sorted_policy,
 	.deinit_sched = deinitialize_dmda_policy,
 	.push_task = dmda_push_sorted_task, 
@@ -656,7 +656,7 @@ struct starpu_sched_policy_s _starpu_sched_dmda_sorted_policy = {
 	.policy_description = "data-aware performance model (sorted)"
 };
 
-struct starpu_sched_policy_s _starpu_sched_dmda_ready_policy = {
+struct starpu_sched_policy _starpu_sched_dmda_ready_policy = {
 	.init_sched = initialize_dmda_policy,
 	.deinit_sched = deinitialize_dmda_policy,
 	.push_task = dmda_push_task, 

src/sched_policies/eager_central_policy.c

@@ -30,7 +30,7 @@ static pthread_cond_t sched_cond;
 static pthread_mutex_t sched_mutex;
 
 static void initialize_eager_center_policy(struct starpu_machine_topology_s *topology, 
-		   __attribute__ ((unused)) struct starpu_sched_policy_s *_policy) 
+		   __attribute__ ((unused)) struct starpu_sched_policy *_policy) 
 {
 	/* there is only a single queue in that trivial design */
 	fifo = _starpu_create_fifo();
@@ -44,7 +44,7 @@ static void initialize_eager_center_policy(struct starpu_machine_topology_s *top
 }
 
 static void deinitialize_eager_center_policy(__attribute__ ((unused)) struct starpu_machine_topology_s *topology, 
-		   __attribute__ ((unused)) struct starpu_sched_policy_s *_policy) 
+		   __attribute__ ((unused)) struct starpu_sched_policy *_policy) 
 {
 	/* TODO check that there is no task left in the queue */
 
@@ -67,7 +67,7 @@ static struct starpu_task *pop_task_eager_policy(void)
 	return _starpu_fifo_pop_task(fifo, starpu_worker_get_id());
 }
 
-struct starpu_sched_policy_s _starpu_sched_eager_policy = {
+struct starpu_sched_policy _starpu_sched_eager_policy = {
 	.init_sched = initialize_eager_center_policy,
 	.deinit_sched = deinitialize_eager_center_policy,
 	.push_task = push_task_eager_policy,

src/sched_policies/eager_central_priority_policy.c

@@ -75,7 +75,7 @@ static void _starpu_destroy_priority_taskq(struct starpu_priority_taskq_s *prior
 }
 
 static void initialize_eager_center_priority_policy(struct starpu_machine_topology_s *topology, 
-			__attribute__ ((unused))	struct starpu_sched_policy_s *_policy) 
+			__attribute__ ((unused))	struct starpu_sched_policy *_policy) 
 {
 	/* In this policy, we support more than two levels of priority. */
 	starpu_sched_set_min_priority(MIN_LEVEL);
@@ -93,7 +93,7 @@ static void initialize_eager_center_priority_policy(struct starpu_machine_topolo
 }
 
 static void deinitialize_eager_center_priority_policy(struct starpu_machine_topology_s *topology __attribute__ ((unused)),
-		   __attribute__ ((unused)) struct starpu_sched_policy_s *_policy) 
+		   __attribute__ ((unused)) struct starpu_sched_policy *_policy) 
 {
 	/* TODO check that there is no task left in the queue */
 
@@ -156,7 +156,7 @@ static struct starpu_task *_starpu_priority_pop_task(void)
 	return task;
 }
 
-struct starpu_sched_policy_s _starpu_sched_prio_policy = {
+struct starpu_sched_policy _starpu_sched_prio_policy = {
 	.init_sched = initialize_eager_center_priority_policy,
 	.deinit_sched = deinitialize_eager_center_priority_policy,
 	/* we always use priorities in that policy */

src/sched_policies/heft.c

@@ -58,7 +58,7 @@ static void param_modified(struct starputop_param_t* d){
 }
 
 static void heft_init(struct starpu_machine_topology_s *topology, 
-	 __attribute__ ((unused)) struct starpu_sched_policy_s *_policy) 
+	 __attribute__ ((unused)) struct starpu_sched_policy *_policy) 
 {
 	nworkers = topology->nworkers;
 
@@ -439,7 +439,7 @@ static int heft_push_task(struct starpu_task *task)
 }
 
 static void heft_deinit(__attribute__ ((unused)) struct starpu_machine_topology_s *topology, 
-                        __attribute__ ((unused)) struct starpu_sched_policy_s *_policy) 
+                        __attribute__ ((unused)) struct starpu_sched_policy *_policy) 
 {
 	unsigned workerid;
 	for (workerid = 0; workerid < nworkers; workerid++)
@@ -449,7 +449,7 @@ static void heft_deinit(__attribute__ ((unused)) struct starpu_machine_topology_
 	}
 }
 
-struct starpu_sched_policy_s heft_policy = {
+struct starpu_sched_policy heft_policy = {
 	.init_sched = heft_init,
 	.deinit_sched = heft_deinit,
 	.push_task = heft_push_task, 

src/sched_policies/parallel_greedy.c

@@ -38,7 +38,7 @@ static int possible_combinations[STARPU_NMAXWORKERS][10];
 static int possible_combinations_size[STARPU_NMAXWORKERS][10];
 
 static void initialize_pgreedy_policy(struct starpu_machine_topology_s *topology, 
-		   __attribute__ ((unused)) struct starpu_sched_policy_s *_policy) 
+		   __attribute__ ((unused)) struct starpu_sched_policy *_policy) 
 {
 	/* masters pick tasks from that queue */
 	fifo = _starpu_create_fifo();
@@ -129,7 +129,7 @@ static void initialize_pgreedy_policy(struct starpu_machine_topology_s *topology
 }
 
 static void deinitialize_pgreedy_policy(__attribute__ ((unused)) struct starpu_machine_topology_s *topology, 
-		   __attribute__ ((unused)) struct starpu_sched_policy_s *_policy) 
+		   __attribute__ ((unused)) struct starpu_sched_policy *_policy) 
 {
 	/* TODO check that there is no task left in the queue */
 
@@ -232,7 +232,7 @@ static struct starpu_task *pop_task_pgreedy_policy(void)
 	}
 }
 
-struct starpu_sched_policy_s _starpu_sched_pgreedy_policy = {
+struct starpu_sched_policy _starpu_sched_pgreedy_policy = {
 	.init_sched = initialize_pgreedy_policy,
 	.deinit_sched = deinitialize_pgreedy_policy,
 	.push_task = push_task_pgreedy_policy,

src/sched_policies/parallel_heft.c

@@ -374,7 +374,7 @@ static int parallel_heft_push_task(struct starpu_task *task)
 }
 
 static void initialize_parallel_heft_policy(struct starpu_machine_topology_s *topology, 
-	 __attribute__ ((unused)) struct starpu_sched_policy_s *_policy) 
+	 __attribute__ ((unused)) struct starpu_sched_policy *_policy) 
 {
 	nworkers = topology->nworkers;
 
@@ -437,7 +437,7 @@ static void initialize_parallel_heft_policy(struct starpu_machine_topology_s *to
 }
 
 /* TODO: use post_exec_hook to fix the expected start */
-struct starpu_sched_policy_s _starpu_sched_parallel_heft_policy = {
+struct starpu_sched_policy _starpu_sched_parallel_heft_policy = {
 	.init_sched = initialize_parallel_heft_policy,
 	.deinit_sched = NULL,
 	.push_task = parallel_heft_push_task, 

src/sched_policies/random_policy.c

@@ -68,7 +68,7 @@ static int random_push_task(struct starpu_task *task)
 }
 
 static void initialize_random_policy(struct starpu_machine_topology_s *topology, 
-	 __attribute__ ((unused)) struct starpu_sched_policy_s *_policy) 
+	 __attribute__ ((unused)) struct starpu_sched_policy *_policy) 
 {
 	starpu_srand48(time(NULL));
 
@@ -84,7 +84,7 @@ static void initialize_random_policy(struct starpu_machine_topology_s *topology,
 	}
 }
 
-struct starpu_sched_policy_s _starpu_sched_random_policy = {
+struct starpu_sched_policy _starpu_sched_random_policy = {
 	.init_sched = initialize_random_policy,
 	.deinit_sched = NULL,
 	.push_task = random_push_task,

src/sched_policies/work_stealing_policy.c

@@ -195,7 +195,7 @@ static int ws_push_task(struct starpu_task *task)
 }
 
 static void initialize_ws_policy(struct starpu_machine_topology_s *topology, 
-				__attribute__ ((unused)) struct starpu_sched_policy_s *_policy) 
+				__attribute__ ((unused)) struct starpu_sched_policy *_policy) 
 {
 	nworkers = topology->nworkers;
 	rr_worker = 0;
@@ -211,7 +211,7 @@ static void initialize_ws_policy(struct starpu_machine_topology_s *topology,
 	}
 }
 
-struct starpu_sched_policy_s _starpu_sched_ws_policy = {
+struct starpu_sched_policy _starpu_sched_ws_policy = {
 	.init_sched = initialize_ws_policy,
 	.deinit_sched = NULL,
 	.push_task = ws_push_task,

src/util/malloc.c

@@ -52,7 +52,7 @@ static void malloc_pinned_cuda_codelet(void *buffers[] STARPU_ATTRIBUTE_UNUSED,
 #endif
 
 #if defined(STARPU_USE_CUDA)// || defined(STARPU_USE_OPENCL)
-static struct starpu_perfmodel_t malloc_pinned_model = {
+static struct starpu_perfmodel malloc_pinned_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "malloc_pinned"
 };
@@ -151,7 +151,7 @@ static void free_pinned_cuda_codelet(void *buffers[] STARPU_ATTRIBUTE_UNUSED, vo
 //#endif
 
 #if defined(STARPU_USE_CUDA) // || defined(STARPU_USE_OPENCL)
-static struct starpu_perfmodel_t free_pinned_model = {
+static struct starpu_perfmodel free_pinned_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "free_pinned"
 };

src/util/starpu_create_sync_task.c

@@ -22,7 +22,7 @@
  * dependencies are fulfilled. */
 /* TODO it would be nice to have such a function without sync_tag in case we
  * just want to execute the callback. */
-void starpu_create_sync_task(starpu_tag_t sync_tag, unsigned ndeps, starpu_tag_t *deps,
+void starpu_create_sync_task(starpu_tag sync_tag, unsigned ndeps, starpu_tag *deps,
 				void (*callback)(void *), void *callback_arg)
 {
 	starpu_tag_declare_deps_array(sync_tag, ndeps, deps);

src/util/starpu_data_cpy.c

@@ -49,7 +49,7 @@ static void data_cpy_func(void *descr[], void *cl_arg)
 
 }
 
-struct starpu_perfmodel_t copy_model = {
+struct starpu_perfmodel copy_model = {
 	.type = STARPU_HISTORY_BASED,
 	.symbol = "starpu_data_cpy"
 };

tests/core/empty_task_sync_point.c

@@ -23,12 +23,12 @@
 #include <starpu.h>
 #include "../common/helper.h"
 
-static starpu_tag_t tagA = 0x0042;
-static starpu_tag_t tagB = 0x1042;
-static starpu_tag_t tagC = 0x2042;
-static starpu_tag_t tagD = 0x3042;
-static starpu_tag_t tagE = 0x4042;
-static starpu_tag_t tagF = 0x5042;
+static starpu_tag tagA = 0x0042;
+static starpu_tag tagB = 0x1042;
+static starpu_tag tagC = 0x2042;
+static starpu_tag tagD = 0x3042;
+static starpu_tag tagE = 0x4042;
+static starpu_tag tagF = 0x5042;
 
 static void dummy_func(void *descr[] __attribute__ ((unused)), void *arg __attribute__ ((unused)))
 {
@@ -92,7 +92,7 @@ int main(int argc, char **argv)
 	ret = starpu_task_submit(taskE); STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
 	ret = starpu_task_submit(taskF); STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
 
-	starpu_tag_t tag_array[2] = {tagE, tagF};
+	starpu_tag tag_array[2] = {tagE, tagF};
 	ret = starpu_tag_wait_array(2, tag_array);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_tag_wait_array");
 

tests/core/static_restartable_tag.c

@@ -23,7 +23,7 @@
 #include "../common/helper.h"
 
 static unsigned ntasks = 65536;
-static starpu_tag_t tag = 0x32;
+static starpu_tag tag = 0x32;
 
 static void dummy_func(void *descr[] __attribute__ ((unused)), void *arg __attribute__ ((unused)))
 {

tests/core/tag_wait_api.c

@@ -43,7 +43,7 @@ static void callback(void *tag)
 //	fflush(stderr);
 }
 
-static struct starpu_task *create_dummy_task(starpu_tag_t tag)
+static struct starpu_task *create_dummy_task(starpu_tag tag)
 {
 	struct starpu_task *task = starpu_task_create();
 
@@ -58,20 +58,20 @@ static struct starpu_task *create_dummy_task(starpu_tag_t tag)
 	return task;
 }
 
-#define tagA	((starpu_tag_t)0x42)
-#define tagB	((starpu_tag_t)0x12300)
+#define tagA	((starpu_tag)0x42)
+#define tagB	((starpu_tag)0x12300)
 
-#define tagC	((starpu_tag_t)0x32)
-#define tagD	((starpu_tag_t)0x52)
-#define tagE	((starpu_tag_t)0x19999)
-#define tagF	((starpu_tag_t)0x2312)
-#define tagG	((starpu_tag_t)0x1985)
+#define tagC	((starpu_tag)0x32)
+#define tagD	((starpu_tag)0x52)
+#define tagE	((starpu_tag)0x19999)
+#define tagF	((starpu_tag)0x2312)
+#define tagG	((starpu_tag)0x1985)
 
-#define tagH	((starpu_tag_t)0x32234)
-#define tagI	((starpu_tag_t)0x5234)
-#define tagJ	((starpu_tag_t)0x199)
-#define tagK	((starpu_tag_t)0x231234)
-#define tagL	((starpu_tag_t)0x2345)
+#define tagH	((starpu_tag)0x32234)
+#define tagI	((starpu_tag)0x5234)
+#define tagJ	((starpu_tag)0x199)
+#define tagK	((starpu_tag)0x231234)
+#define tagL	((starpu_tag)0x2345)
 
 int main(int argc, char **argv)
 {
@@ -131,7 +131,7 @@ int main(int argc, char **argv)
 	starpu_tag_declare_deps(tagK, 2, tagH, tagI);
 	starpu_tag_declare_deps(tagL, 2, tagH, tagI);
 
-	starpu_tag_t tagJKL[3] = {tagJ, tagK, tagL};
+	starpu_tag tagJKL[3] = {tagJ, tagK, tagL};
 
 	ret = starpu_task_submit(taskH); STARPU_CHECK_RETURN_VALUE(ret, "starpu_submit");
 	ret = starpu_task_submit(taskI); STARPU_CHECK_RETURN_VALUE(ret, "starpu_submit");

tests/helper/starpu_create_sync_task.c

@@ -34,7 +34,7 @@ static starpu_codelet dummy_codelet =
 	.nbuffers = 0
 };
 
-static int create_dummy_task(starpu_tag_t tag)
+static int create_dummy_task(starpu_tag tag)
 {
 	struct starpu_task *task = starpu_task_create();
 
@@ -53,17 +53,17 @@ int main(int argc, char **argv)
 	ret = starpu_init(NULL);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
 
-	starpu_tag_t sync_tags[NITER];
+	starpu_tag sync_tags[NITER];
 
 	unsigned iter;
 	for (iter = 0; iter < NITER; iter++)
 	{
-		starpu_tag_t sync_tag = (starpu_tag_t)iter*100;
+		starpu_tag sync_tag = (starpu_tag)iter*100;
 
 		sync_tags[iter] = sync_tag;
 
 		unsigned ndeps = 10;
-		starpu_tag_t deps[ndeps];
+		starpu_tag deps[ndeps];
 
 		unsigned d;
 		for (d = 0; d < ndeps; d++)

tests/microbenchs/tasks_overhead.c

@@ -115,7 +115,7 @@ int main(int argc, char **argv)
 		tasks[i].cl_arg = NULL;
 		tasks[i].synchronous = 0;
 		tasks[i].use_tag = 1;
-		tasks[i].tag_id = (starpu_tag_t)i;
+		tasks[i].tag_id = (starpu_tag)i;
 
 		/* we have 8 buffers at most */
 		for (buffer = 0; buffer < nbuffers; buffer++)
@@ -128,7 +128,7 @@ int main(int argc, char **argv)
 	gettimeofday(&start_submit, NULL);
 	for (i = 1; i < ntasks; i++)
 	{
-		starpu_tag_declare_deps((starpu_tag_t)i, 1, (starpu_tag_t)(i-1));
+		starpu_tag_declare_deps((starpu_tag)i, 1, (starpu_tag)(i-1));
 
 		ret = starpu_task_submit(&tasks[i]);
 		if (ret == -ENODEV) goto enodev;
@@ -144,7 +144,7 @@ int main(int argc, char **argv)
 
 	/* wait for the execution of the tasks */
 	gettimeofday(&start_exec, NULL);
-	ret = starpu_tag_wait((starpu_tag_t)(ntasks - 1));
+	ret = starpu_tag_wait((starpu_tag)(ntasks - 1));
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_tag_wait");
 	gettimeofday(&end_exec, NULL);