Type renaming:

     s/\bstarpu_block_interface_t/struct starpu_block_interface/g
     s/\bstarpu_matrix_interface_t/struct starpu_matrix_interface/g
     s/\bstarpu_vector_interface_t/struct starpu_vector_interface/g
     s/\bstarpu_variable_interface_t/struct starpu_variable_interface/g
     s/\bstarpu_csr_interface_t/struct starpu_csr_interface/g
     s/\bstarpu_bcsr_interface_t/struct starpu_bcsr_interface/g
     s/\bstarpu_multiformat_interface_t/struct starpu_multiformat_interface/g

doc/chapters/basic-api.texi

@@ -1043,7 +1043,7 @@ least one function pointer, and at most @code{STARPU_MAXIMPLEMENTATIONS}.
 @item @code{opencl_func} (optional)
 Is a function pointer to the OpenCL implementation of the codelet. Its
 prototype must be:
-@code{void opencl_func(starpu_data_interface_t *descr, void *arg);}.
+@code{void opencl_func(void *buffers[], void *cl_arg);}.
 This pointer is ignored if @code{STARPU_OPENCL} does not appear in the
 @code{where} field, it must be non-null otherwise. When multiple OpenCL
 implementations are used, this field must be set to

doc/chapters/vector_scal_cpu.texi

@@ -20,12 +20,12 @@ void scal_cpu_func(void *buffers[], void *cl_arg)
      * task->buffers[0].handle is a handle that corresponds to a data with
      * vector "interface", so that the first entry of the array in the
      * codelet  is a pointer to a structure describing such a vector (ie.
-     * struct starpu_vector_interface_s *). Here, we therefore manipulate
+     * struct starpu_vector_interface *). Here, we therefore manipulate
      * the buffers[0] element as a vector: nx gives the number of elements
      * in the array, ptr gives the location of the array (that was possibly
      * migrated/replicated), and elemsize gives the size of each elements.
      */
-    starpu_vector_interface_t *vector = buffers[0];
+    struct starpu_vector_interface *vector = buffers[0];
 
     /* length of the vector */
     unsigned n = STARPU_VECTOR_GET_NX(vector);

doc/tutorial/vector_scal_cpu.c

@@ -41,12 +41,12 @@ void scal_cpu_func(void *buffers[], void *cl_arg)
      * task->buffers[0].handle is a handle that corresponds to a data with
      * vector "interface", so that the first entry of the array in the
      * codelet  is a pointer to a structure describing such a vector (ie.
-     * struct starpu_vector_interface_s *). Here, we therefore manipulate
+     * struct starpu_vector_interface *). Here, we therefore manipulate
      * the buffers[0] element as a vector: nx gives the number of elements
      * in the array, ptr gives the location of the array (that was possibly
      * migrated/replicated), and elemsize gives the size of each elements.
      */
-    starpu_vector_interface_t *vector = buffers[0];
+    struct starpu_vector_interface *vector = buffers[0];
 
     /* length of the vector */
     unsigned n = STARPU_VECTOR_GET_NX(vector);

examples/basic_examples/vector_scal_cpu.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
  *
  * StarPU is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -34,13 +34,13 @@ void scal_cpu_func(void *buffers[], void *cl_arg)
 	 * task->buffers[0].handle is a handle that corresponds to a data with
 	 * vector "interface", so that the first entry of the array in the
 	 * codelet  is a pointer to a structure describing such a vector (ie.
-	 * struct starpu_vector_interface_s *). Here, we therefore manipulate
+	 * struct starpu_vector_interface *). Here, we therefore manipulate
 	 * the buffers[0] element as a vector: nx gives the number of elements
 	 * in the array, ptr gives the location of the array (that was possibly
 	 * migrated/replicated), and elemsize gives the size of each elements.
 	 */
 
-	starpu_vector_interface_t *vector = (starpu_vector_interface_t *) buffers[0];
+	struct starpu_vector_interface *vector = (struct starpu_vector_interface *) buffers[0];
 
 	/* length of the vector */
 	unsigned n = STARPU_VECTOR_GET_NX(vector);

examples/openmp/vector_scal.c

@@ -31,7 +31,7 @@
 void scal_cpu_func(void *buffers[], void *_args) {
 	unsigned i;
 	float *factor = _args;
-	starpu_vector_interface_t *vector = buffers[0];
+	struct starpu_vector_interface *vector = buffers[0];
 	unsigned n = STARPU_VECTOR_GET_NX(vector);
 	float *val = (float *)STARPU_VECTOR_GET_PTR(vector);
 

examples/spmv/spmv.c

@@ -44,8 +44,8 @@ static void parse_args(int argc, char **argv)
  * same number of non-zero entries. */
 static void csr_filter_func(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts)
 {
-	starpu_csr_interface_t *csr_father = (starpu_csr_interface_t *) father_interface;
-	starpu_csr_interface_t *csr_child = (starpu_csr_interface_t *) child_interface;
+	struct starpu_csr_interface *csr_father = (struct starpu_csr_interface *) father_interface;
+	struct starpu_csr_interface *csr_child = (struct starpu_csr_interface *) child_interface;
 
 	uint32_t nrow = csr_father->nrow;
 	size_t elemsize = csr_father->elemsize;

examples/stencil/stencil-kernels.c

@@ -149,7 +149,7 @@ static void record_who_runs_what(struct block_description *block)
 		who_runs_what[block->bz + (who_runs_what_index[block->bz]++) * get_nbz()] = global_workerid(workerid);
 }
 
-static void check_load(starpu_block_interface_t *block, starpu_block_interface_t *boundary)
+static void check_load(struct starpu_block_interface *block, struct starpu_block_interface *boundary)
 {
 	/* Sanity checks */
 	STARPU_ASSERT(block->nx == boundary->nx);
@@ -169,8 +169,8 @@ static void load_subblock_from_buffer_cpu(void *_block,
 					void *_boundary,
 					unsigned firstz)
 {
-	starpu_block_interface_t *block = (starpu_block_interface_t *)_block;
-	starpu_block_interface_t *boundary = (starpu_block_interface_t *)_boundary;
+	struct starpu_block_interface *block = (struct starpu_block_interface *)_block;
+	struct starpu_block_interface *boundary = (struct starpu_block_interface *)_boundary;
 	check_load(block, boundary);
 
 	/* We do a contiguous memory transfer */
@@ -190,8 +190,8 @@ static void load_subblock_from_buffer_cuda(void *_block,
 					void *_boundary,
 					unsigned firstz)
 {
-	starpu_block_interface_t *block = (starpu_block_interface_t *)_block;
-	starpu_block_interface_t *boundary = (starpu_block_interface_t *)_boundary;
+	struct starpu_block_interface *block = (struct starpu_block_interface *)_block;
+	struct starpu_block_interface *boundary = (struct starpu_block_interface *)_boundary;
 	check_load(block, boundary);
 
 	/* We do a contiguous memory transfer */
@@ -248,7 +248,7 @@ fprintf(stderr,"!!! DO update_func_cuda z %d CUDA%d !!!\n", block->bz, workerid)
 
 	for (i=1; i<=K; i++)
 	{
-		starpu_block_interface_t *oldb = descr[i%2], *newb = descr[(i+1)%2];
+		struct starpu_block_interface *oldb = descr[i%2], *newb = descr[(i+1)%2];
 		TYPE *old = (void*) oldb->ptr, *newer = (void*) newb->ptr;
 
 		/* Shadow data */
@@ -275,8 +275,8 @@ fprintf(stderr,"!!! DO update_func_cuda z %d CUDA%d !!!\n", block->bz, workerid)
  * Load a neighbour's boundary into block, OpenCL version
  */
 #ifdef STARPU_USE_OPENCL
-static void load_subblock_from_buffer_opencl(starpu_block_interface_t *block,
-					starpu_block_interface_t *boundary,
+static void load_subblock_from_buffer_opencl(struct starpu_block_interface *block,
+					struct starpu_block_interface *boundary,
 					unsigned firstz)
 {
 	check_load(block, boundary);
@@ -341,7 +341,7 @@ fprintf(stderr,"!!! DO update_func_opencl z %d OPENCL%d !!!\n", block->bz, worke
 
 	for (i=1; i<=K; i++)
 	{
-		starpu_block_interface_t *oldb = descr[i%2], *newb = descr[(i+1)%2];
+		struct starpu_block_interface *oldb = descr[i%2], *newb = descr[(i+1)%2];
 		TYPE *old = (void*) oldb->ptr, *newer = (void*) newb->ptr;
 
 		/* Shadow data */
@@ -409,7 +409,7 @@ fprintf(stderr,"!!! DO update_func_cpu z %d CPU%d !!!\n", block->bz, workerid);
 
 	for (i=1; i<=K; i++)
 	{
-		starpu_block_interface_t *oldb = (starpu_block_interface_t *) descr[i%2], *newb = (starpu_block_interface_t *) descr[(i+1)%2];
+		struct starpu_block_interface *oldb = (struct starpu_block_interface *) descr[i%2], *newb = (struct starpu_block_interface *) descr[(i+1)%2];
 		TYPE *old = (TYPE*) oldb->ptr, *newer = (TYPE*) newb->ptr;
 
 		/* Shadow data */
@@ -473,8 +473,8 @@ static void load_subblock_into_buffer_cpu(void *_block,
 					void *_boundary,
 					unsigned firstz)
 {
-	starpu_block_interface_t *block = (starpu_block_interface_t *)_block;
-	starpu_block_interface_t *boundary = (starpu_block_interface_t *)_boundary;
+	struct starpu_block_interface *block = (struct starpu_block_interface *)_block;
+	struct starpu_block_interface *boundary = (struct starpu_block_interface *)_boundary;
 	check_load(block, boundary);
 
 	/* We do a contiguous memory transfer */
@@ -492,8 +492,8 @@ static void load_subblock_into_buffer_cuda(void *_block,
 					void *_boundary,
 					unsigned firstz)
 {
-	starpu_block_interface_t *block = (starpu_block_interface_t *)_block;
-	starpu_block_interface_t *boundary = (starpu_block_interface_t *)_boundary;
+	struct starpu_block_interface *block = (struct starpu_block_interface *)_block;
+	struct starpu_block_interface *boundary = (struct starpu_block_interface *)_boundary;
 	check_load(block, boundary);
 
 	/* We do a contiguous memory transfer */
@@ -508,8 +508,8 @@ static void load_subblock_into_buffer_cuda(void *_block,
 
 /* OPENCL version */
 #ifdef STARPU_USE_OPENCL
-static void load_subblock_into_buffer_opencl(starpu_block_interface_t *block,
-					starpu_block_interface_t *boundary,
+static void load_subblock_into_buffer_opencl(struct starpu_block_interface *block,
+					struct starpu_block_interface *boundary,
 					unsigned firstz)
 {
 	check_load(block, boundary);

gcc-plugin/src/starpu.c

@@ -1112,10 +1112,10 @@ build_codelet_wrapper_definition (tree task_impl)
 
 	    /* Below we assume (1) that pointer arguments are registered as
 	       StarPU vector handles, and (2) that the `ptr' field is at
-	       offset 0 of `starpu_vector_interface_s'.  The latter allows us
+	       offset 0 of `struct starpu_vector_interface'.  The latter allows us
 	       to use a simple pointer dereference instead of expanding
 	       `STARPU_VECTOR_GET_PTR'.  */
-	    assert (offsetof (struct starpu_vector_interface_s, ptr) == 0);
+	    assert (offsetof (struct starpu_vector_interface, ptr) == 0);
 
 	    /* Compute `type *PTR = *(type **) VDESC;'.  */
 	    tree ptr = build1 (INDIRECT_REF,

include/starpu_data_interfaces.h

@@ -153,7 +153,7 @@ void *starpu_handle_get_local_ptr(starpu_data_handle handle);
 void *starpu_data_get_interface_on_node(starpu_data_handle handle, unsigned memory_node);
 
 /* Matrix interface for dense matrices */
-typedef struct starpu_matrix_interface_s {
+struct starpu_matrix_interface {
 	uintptr_t ptr;
         uintptr_t dev_handle;
         size_t offset;
@@ -161,7 +161,7 @@ typedef struct starpu_matrix_interface_s {
 	uint32_t ny;
 	uint32_t ld;
 	size_t elemsize;
-} starpu_matrix_interface_t;
+};
 
 void starpu_matrix_data_register(starpu_data_handle *handle, uint32_t home_node,
                         uintptr_t ptr, uint32_t ld, uint32_t nx,
@@ -173,16 +173,16 @@ uintptr_t starpu_matrix_get_local_ptr(starpu_data_handle handle);
 size_t starpu_matrix_get_elemsize(starpu_data_handle handle);
 
 /* helper methods */
-#define STARPU_MATRIX_GET_PTR(interface)	(((starpu_matrix_interface_t *)(interface))->ptr)
-#define STARPU_MATRIX_GET_NX(interface)	(((starpu_matrix_interface_t *)(interface))->nx)
-#define STARPU_MATRIX_GET_NY(interface)	(((starpu_matrix_interface_t *)(interface))->ny)
-#define STARPU_MATRIX_GET_LD(interface)	(((starpu_matrix_interface_t *)(interface))->ld)
-#define STARPU_MATRIX_GET_ELEMSIZE(interface)	(((starpu_matrix_interface_t *)(interface))->elemsize)
+#define STARPU_MATRIX_GET_PTR(interface)	(((struct starpu_matrix_interface *)(interface))->ptr)
+#define STARPU_MATRIX_GET_NX(interface)	(((struct starpu_matrix_interface *)(interface))->nx)
+#define STARPU_MATRIX_GET_NY(interface)	(((struct starpu_matrix_interface *)(interface))->ny)
+#define STARPU_MATRIX_GET_LD(interface)	(((struct starpu_matrix_interface *)(interface))->ld)
+#define STARPU_MATRIX_GET_ELEMSIZE(interface)	(((struct starpu_matrix_interface *)(interface))->elemsize)
 
 
 /* BLOCK interface for 3D dense blocks */
 /* TODO: rename to 3dmatrix? */
-typedef struct starpu_block_interface_s {
+struct starpu_block_interface {
 	uintptr_t ptr;
         uintptr_t dev_handle;
         size_t offset;
@@ -192,7 +192,7 @@ typedef struct starpu_block_interface_s {
 	uint32_t ldy;	/* number of elements between two lines */
 	uint32_t ldz;	/* number of elements between two planes */
 	size_t elemsize;
-} starpu_block_interface_t;
+};
 
 void starpu_block_data_register(starpu_data_handle *handle, uint32_t home_node,
                         uintptr_t ptr, uint32_t ldy, uint32_t ldz, uint32_t nx,
@@ -206,22 +206,22 @@ uintptr_t starpu_block_get_local_ptr(starpu_data_handle handle);
 size_t starpu_block_get_elemsize(starpu_data_handle handle);
 
 /* helper methods */
-#define STARPU_BLOCK_GET_PTR(interface)	(((starpu_block_interface_t *)(interface))->ptr)
-#define STARPU_BLOCK_GET_NX(interface)	(((starpu_block_interface_t *)(interface))->nx)
-#define STARPU_BLOCK_GET_NY(interface)	(((starpu_block_interface_t *)(interface))->ny)
-#define STARPU_BLOCK_GET_NZ(interface)	(((starpu_block_interface_t *)(interface))->nz)
-#define STARPU_BLOCK_GET_LDY(interface)	(((starpu_block_interface_t *)(interface))->ldy)
-#define STARPU_BLOCK_GET_LDZ(interface)	(((starpu_block_interface_t *)(interface))->ldz)
-#define STARPU_BLOCK_GET_ELEMSIZE(interface)	(((starpu_block_interface_t *)(interface))->elemsize)
+#define STARPU_BLOCK_GET_PTR(interface)	(((struct starpu_block_interface *)(interface))->ptr)
+#define STARPU_BLOCK_GET_NX(interface)	(((struct starpu_block_interface *)(interface))->nx)
+#define STARPU_BLOCK_GET_NY(interface)	(((struct starpu_block_interface *)(interface))->ny)
+#define STARPU_BLOCK_GET_NZ(interface)	(((struct starpu_block_interface *)(interface))->nz)
+#define STARPU_BLOCK_GET_LDY(interface)	(((struct starpu_block_interface *)(interface))->ldy)
+#define STARPU_BLOCK_GET_LDZ(interface)	(((struct starpu_block_interface *)(interface))->ldz)
+#define STARPU_BLOCK_GET_ELEMSIZE(interface)	(((struct starpu_block_interface *)(interface))->elemsize)
 
 /* vector interface for contiguous (non-strided) buffers */
-typedef struct starpu_vector_interface_s {
+struct starpu_vector_interface {
 	uintptr_t ptr;
         uintptr_t dev_handle;
         size_t offset;
 	uint32_t nx;
 	size_t elemsize;
-} starpu_vector_interface_t;
+};
 
 void starpu_vector_data_register(starpu_data_handle *handle, uint32_t home_node,
                         uintptr_t ptr, uint32_t nx, size_t elemsize);
@@ -230,15 +230,15 @@ size_t starpu_vector_get_elemsize(starpu_data_handle handle);
 uintptr_t starpu_vector_get_local_ptr(starpu_data_handle handle);
 
 /* helper methods */
-#define STARPU_VECTOR_GET_PTR(interface)	(((starpu_vector_interface_t *)(interface))->ptr)
-#define STARPU_VECTOR_GET_NX(interface)	(((starpu_vector_interface_t *)(interface))->nx)
-#define STARPU_VECTOR_GET_ELEMSIZE(interface)	(((starpu_vector_interface_t *)(interface))->elemsize)
+#define STARPU_VECTOR_GET_PTR(interface)	(((struct starpu_vector_interface *)(interface))->ptr)
+#define STARPU_VECTOR_GET_NX(interface)	(((struct starpu_vector_interface *)(interface))->nx)
+#define STARPU_VECTOR_GET_ELEMSIZE(interface)	(((struct starpu_vector_interface *)(interface))->elemsize)
 
 /* variable interface for a single data (not a vector, a matrix, a list, ...) */
-typedef struct starpu_variable_interface_s {
+struct starpu_variable_interface {
 	uintptr_t ptr;
 	size_t elemsize;
-} starpu_variable_interface_t;
+};
 
 void starpu_variable_data_register(starpu_data_handle *handle, uint32_t home_node,
                         uintptr_t ptr, size_t elemsize);
@@ -246,8 +246,8 @@ size_t starpu_variable_get_elemsize(starpu_data_handle handle);
 uintptr_t starpu_variable_get_local_ptr(starpu_data_handle handle);
 
 /* helper methods */
-#define STARPU_VARIABLE_GET_PTR(interface)	(((starpu_variable_interface_t *)(interface))->ptr)
-#define STARPU_VARIABLE_GET_ELEMSIZE(interface)	(((starpu_variable_interface_t *)(interface))->elemsize)
+#define STARPU_VARIABLE_GET_PTR(interface)	(((struct starpu_variable_interface *)(interface))->ptr)
+#define STARPU_VARIABLE_GET_ELEMSIZE(interface)	(((struct starpu_variable_interface *)(interface))->elemsize)
 
 /* void interface. There is no data really associated to that interface, but it
  * may be used as a synchronization mechanism. It also permits to express an
@@ -257,7 +257,7 @@ uintptr_t starpu_variable_get_local_ptr(starpu_data_handle handle);
 void starpu_void_data_register(starpu_data_handle *handleptr);
 
 /* CSR interface for sparse matrices (compressed sparse row representation) */
-typedef struct starpu_csr_interface_s {
+struct starpu_csr_interface {
 	uint32_t nnz; /* number of non-zero entries */
 	uint32_t nrow; /* number of rows */
 	uintptr_t nzval; /* non-zero values */
@@ -269,7 +269,7 @@ typedef struct starpu_csr_interface_s {
         uint32_t firstentry;
 
 	size_t elemsize;
-} starpu_csr_interface_t;
+};
 
 void starpu_csr_data_register(starpu_data_handle *handle, uint32_t home_node, uint32_t nnz, uint32_t nrow,
 		uintptr_t nzval, uint32_t *colind, uint32_t *rowptr, uint32_t firstentry, size_t elemsize);
@@ -281,17 +281,17 @@ uint32_t *starpu_csr_get_local_colind(starpu_data_handle handle);
 uint32_t *starpu_csr_get_local_rowptr(starpu_data_handle handle);
 size_t starpu_csr_get_elemsize(starpu_data_handle handle);
 
-#define STARPU_CSR_GET_NNZ(interface)	(((starpu_csr_interface_t *)(interface))->nnz)
-#define STARPU_CSR_GET_NROW(interface)	(((starpu_csr_interface_t *)(interface))->nrow)
-#define STARPU_CSR_GET_NZVAL(interface)	(((starpu_csr_interface_t *)(interface))->nzval)
-#define STARPU_CSR_GET_COLIND(interface)	(((starpu_csr_interface_t *)(interface))->colind)
-#define STARPU_CSR_GET_ROWPTR(interface)	(((starpu_csr_interface_t *)(interface))->rowptr)
-#define STARPU_CSR_GET_FIRSTENTRY(interface)	(((starpu_csr_interface_t *)(interface))->firstentry)
-#define STARPU_CSR_GET_ELEMSIZE(interface)	(((starpu_csr_interface_t *)(interface))->elemsize)
+#define STARPU_CSR_GET_NNZ(interface)	(((struct starpu_csr_interface *)(interface))->nnz)
+#define STARPU_CSR_GET_NROW(interface)	(((struct starpu_csr_interface *)(interface))->nrow)
+#define STARPU_CSR_GET_NZVAL(interface)	(((struct starpu_csr_interface *)(interface))->nzval)
+#define STARPU_CSR_GET_COLIND(interface)	(((struct starpu_csr_interface *)(interface))->colind)
+#define STARPU_CSR_GET_ROWPTR(interface)	(((struct starpu_csr_interface *)(interface))->rowptr)
+#define STARPU_CSR_GET_FIRSTENTRY(interface)	(((struct starpu_csr_interface *)(interface))->firstentry)
+#define STARPU_CSR_GET_ELEMSIZE(interface)	(((struct starpu_csr_interface *)(interface))->elemsize)
 
 /* BCSR interface for sparse matrices (blocked compressed sparse row
  * representation) */
-typedef struct starpu_bcsr_interface_s {
+struct starpu_bcsr_interface {
 	uint32_t nnz; /* number of non-zero BLOCKS */
 	uint32_t nrow; /* number of rows (in terms of BLOCKS) */
 
@@ -309,7 +309,7 @@ typedef struct starpu_bcsr_interface_s {
 	uint32_t c;
 
 	size_t elemsize;
-} starpu_bcsr_interface_t;
+};
 
 void starpu_bcsr_data_register(starpu_data_handle *handle, uint32_t home_node, uint32_t nnz, uint32_t nrow,
 		uintptr_t nzval, uint32_t *colind, uint32_t *rowptr, uint32_t firstentry, uint32_t r, uint32_t c, size_t elemsize);
@@ -342,7 +342,7 @@ struct starpu_multiformat_data_interface_ops {
 #endif
 };
 
-typedef struct starpu_multiformat_interface_s {
+struct starpu_multiformat_interface {
 	void *cpu_ptr;
 #ifdef STARPU_USE_CUDA
 	void *cuda_ptr;
@@ -355,7 +355,7 @@ typedef struct starpu_multiformat_interface_s {
 	uint32_t nx;
 	struct starpu_multiformat_data_interface_ops *ops;
 	double conversion_time;
-} starpu_multiformat_interface_t;
+};
 
 void starpu_multiformat_data_register(starpu_data_handle *handle,
 				      uint32_t home_node,
@@ -363,17 +363,17 @@ void starpu_multiformat_data_register(starpu_data_handle *handle,
 				      uint32_t nobjects,
 				      struct starpu_multiformat_data_interface_ops *format_ops);
 
-#define STARPU_MULTIFORMAT_GET_PTR(interface)  (((starpu_multiformat_interface_t *)(interface))->cpu_ptr)
+#define STARPU_MULTIFORMAT_GET_PTR(interface)  (((struct starpu_multiformat_interface *)(interface))->cpu_ptr)
 
 #ifdef STARPU_USE_CUDA
-#define STARPU_MULTIFORMAT_GET_CUDA_PTR(interface) (((starpu_multiformat_interface_t *)(interface))->cuda_ptr)
+#define STARPU_MULTIFORMAT_GET_CUDA_PTR(interface) (((struct starpu_multiformat_interface *)(interface))->cuda_ptr)
 #endif
 
 #ifdef STARPU_USE_OPENCL
-#define STARPU_MULTIFORMAT_GET_OPENCL_PTR(interface) (((starpu_multiformat_interface_t *)(interface))->opencl_ptr)
+#define STARPU_MULTIFORMAT_GET_OPENCL_PTR(interface) (((struct starpu_multiformat_interface *)(interface))->opencl_ptr)
 #endif
 
-#define STARPU_MULTIFORMAT_GET_NX(interface)  (((starpu_multiformat_interface_t *)(interface))->nx)
+#define STARPU_MULTIFORMAT_GET_NX(interface)  (((struct starpu_multiformat_interface *)(interface))->nx)
 
 enum starpu_data_interface_id starpu_get_handle_interface_id(starpu_data_handle handle);
 

src/core/task.c

@@ -442,7 +442,7 @@ double _starpu_task_get_conversion_time(struct starpu_task *task)
 		starpu_data_handle handle = task->buffers[i].handle;
 		enum starpu_data_interface_id id = starpu_get_handle_interface_id(handle);
 		if (id == STARPU_MULTIFORMAT_INTERFACE_ID) {
-			starpu_multiformat_interface_t *tmp;
+			struct starpu_multiformat_interface *tmp;
 			uint32_t node = starpu_worker_get_memory_node(task->workerid);
 			tmp = starpu_data_get_interface_on_node(handle, node);
 			conversion_time += tmp->conversion_time;

src/datawizard/interfaces/bcsr_filters.c

@@ -22,9 +22,9 @@
 
 void starpu_canonical_block_filter_bcsr(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, STARPU_ATTRIBUTE_UNUSED unsigned nparts)
 {
-	struct starpu_bcsr_interface_s *bcsr_father = (struct starpu_bcsr_interface_s *) father_interface;
+	struct starpu_bcsr_interface *bcsr_father = (struct starpu_bcsr_interface *) father_interface;
 	/* each chunk becomes a small dense matrix */
-	starpu_matrix_interface_t *matrix_child = (starpu_matrix_interface_t *) child_interface;
+	struct starpu_matrix_interface *matrix_child = (struct starpu_matrix_interface *) child_interface;
 	
 	size_t elemsize = bcsr_father->elemsize;
 	uint32_t firstentry = bcsr_father->firstentry;

src/datawizard/interfaces/bcsr_interface.c

@@ -75,19 +75,19 @@ static struct starpu_data_interface_ops interface_bcsr_ops = {
 	.copy_methods = &bcsr_copy_data_methods_s,
 	.get_size = bcsr_interface_get_size,
 	.interfaceid = STARPU_BCSR_INTERFACE_ID,
-	.interface_size = sizeof(starpu_bcsr_interface_t),
+	.interface_size = sizeof(struct starpu_bcsr_interface),
 	.footprint = footprint_bcsr_interface_crc32,
 	.compare = bcsr_compare
 };
 
 static void register_bcsr_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface)
 {
-	starpu_bcsr_interface_t *bcsr_interface = (starpu_bcsr_interface_t *) data_interface;
+	struct starpu_bcsr_interface *bcsr_interface = (struct starpu_bcsr_interface *) data_interface;
 
 	unsigned node;
 	for (node = 0; node < STARPU_MAXNODES; node++)
 	{
-		starpu_bcsr_interface_t *local_interface = (starpu_bcsr_interface_t *)
+		struct starpu_bcsr_interface *local_interface = (struct starpu_bcsr_interface *)
 			starpu_data_get_interface_on_node(handle, node);
 
 		if (node == home_node) {
@@ -115,7 +115,7 @@ void starpu_bcsr_data_register(starpu_data_handle *handleptr, uint32_t home_node
 		uint32_t *rowptr, uint32_t firstentry,
 		uint32_t r, uint32_t c, size_t elemsize)
 {
-	starpu_bcsr_interface_t bcsr_interface = {
+	struct starpu_bcsr_interface bcsr_interface = {
 		.nzval = nzval,
 		.colind = colind,
 		.rowptr = rowptr,
@@ -143,8 +143,8 @@ static uint32_t footprint_bcsr_interface_crc32(starpu_data_handle handle)
 
 static int bcsr_compare(void *data_interface_a, void *data_interface_b)
 {
-	starpu_bcsr_interface_t *bcsr_a = (starpu_bcsr_interface_t *) data_interface_a;
-	starpu_bcsr_interface_t *bcsr_b = (starpu_bcsr_interface_t *) data_interface_b;
+	struct starpu_bcsr_interface *bcsr_a = (struct starpu_bcsr_interface *) data_interface_a;
+	struct starpu_bcsr_interface *bcsr_b = (struct starpu_bcsr_interface *) data_interface_b;
 
 	/* Two matricess are considered compatible if they have the same size */
 	return ((bcsr_a->nnz == bcsr_b->nnz)
@@ -157,7 +157,7 @@ static int bcsr_compare(void *data_interface_a, void *data_interface_b)
 /* offer an access to the data parameters */
 uint32_t starpu_bcsr_get_nnz(starpu_data_handle handle)
 {
-	starpu_bcsr_interface_t *data_interface = (starpu_bcsr_interface_t *)
+	struct starpu_bcsr_interface *data_interface = (struct starpu_bcsr_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return data_interface->nnz;
@@ -165,7 +165,7 @@ uint32_t starpu_bcsr_get_nnz(starpu_data_handle handle)
 
 uint32_t starpu_bcsr_get_nrow(starpu_data_handle handle)
 {
-	starpu_bcsr_interface_t *data_interface = (starpu_bcsr_interface_t *)
+	struct starpu_bcsr_interface *data_interface = (struct starpu_bcsr_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return data_interface->nrow;
@@ -173,7 +173,7 @@ uint32_t starpu_bcsr_get_nrow(starpu_data_handle handle)
 
 uint32_t starpu_bcsr_get_firstentry(starpu_data_handle handle)
 {
-	starpu_bcsr_interface_t *data_interface = (starpu_bcsr_interface_t *)
+	struct starpu_bcsr_interface *data_interface = (struct starpu_bcsr_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return data_interface->firstentry;
@@ -181,7 +181,7 @@ uint32_t starpu_bcsr_get_firstentry(starpu_data_handle handle)
 
 uint32_t starpu_bcsr_get_r(starpu_data_handle handle)
 {
-	starpu_bcsr_interface_t *data_interface = (starpu_bcsr_interface_t *)
+	struct starpu_bcsr_interface *data_interface = (struct starpu_bcsr_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return data_interface->r;
@@ -189,7 +189,7 @@ uint32_t starpu_bcsr_get_r(starpu_data_handle handle)
 
 uint32_t starpu_bcsr_get_c(starpu_data_handle handle)
 {
-	starpu_bcsr_interface_t *data_interface = (starpu_bcsr_interface_t *)
+	struct starpu_bcsr_interface *data_interface = (struct starpu_bcsr_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return data_interface->c;
@@ -197,7 +197,7 @@ uint32_t starpu_bcsr_get_c(starpu_data_handle handle)
 
 size_t starpu_bcsr_get_elemsize(starpu_data_handle handle)
 {
-	starpu_bcsr_interface_t *data_interface = (starpu_bcsr_interface_t *)
+	struct starpu_bcsr_interface *data_interface = (struct starpu_bcsr_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return data_interface->elemsize;
@@ -210,7 +210,7 @@ uintptr_t starpu_bcsr_get_local_nzval(starpu_data_handle handle)
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
-	starpu_bcsr_interface_t *data_interface = (starpu_bcsr_interface_t *)
+	struct starpu_bcsr_interface *data_interface = (struct starpu_bcsr_interface *)
 		starpu_data_get_interface_on_node(handle, node);
 	
 	return data_interface->nzval;
@@ -219,7 +219,7 @@ uintptr_t starpu_bcsr_get_local_nzval(starpu_data_handle handle)
 uint32_t *starpu_bcsr_get_local_colind(starpu_data_handle handle)
 {
 	/* XXX 0 */
-	starpu_bcsr_interface_t *data_interface = (starpu_bcsr_interface_t *)
+	struct starpu_bcsr_interface *data_interface = (struct starpu_bcsr_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return data_interface->colind;
@@ -228,7 +228,7 @@ uint32_t *starpu_bcsr_get_local_colind(starpu_data_handle handle)
 uint32_t *starpu_bcsr_get_local_rowptr(starpu_data_handle handle)
 {
 	/* XXX 0 */
-	starpu_bcsr_interface_t *data_interface = (starpu_bcsr_interface_t *)
+	struct starpu_bcsr_interface *data_interface = (struct starpu_bcsr_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return data_interface->rowptr;
@@ -261,7 +261,7 @@ static ssize_t allocate_bcsr_buffer_on_node(void *data_interface_, uint32_t dst_
 	ssize_t allocated_memory;
 
 	/* we need the 3 arrays to be allocated */
-	starpu_bcsr_interface_t *bcsr_interface = (starpu_bcsr_interface_t *) data_interface_;
+	struct starpu_bcsr_interface *bcsr_interface = (struct starpu_bcsr_interface *) data_interface_;
 
 	uint32_t nnz = bcsr_interface->nnz;
 	uint32_t nrow = bcsr_interface->nrow;
@@ -383,7 +383,7 @@ fail_nzval:
 
 static void free_bcsr_buffer_on_node(void *data_interface, uint32_t node)
 {
-	starpu_bcsr_interface_t *bcsr_interface = (starpu_bcsr_interface_t *) data_interface;
+	struct starpu_bcsr_interface *bcsr_interface = (struct starpu_bcsr_interface *) data_interface;
 
 	starpu_node_kind kind = _starpu_get_node_kind(node);
 	switch(kind) {
@@ -414,8 +414,8 @@ static void free_bcsr_buffer_on_node(void *data_interface, uint32_t node)
 #ifdef STARPU_USE_CUDA
 static int copy_cuda_common(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, enum cudaMemcpyKind kind)
 {
-	starpu_bcsr_interface_t *src_bcsr = src_interface;
-	starpu_bcsr_interface_t *dst_bcsr = dst_interface;
+	struct starpu_bcsr_interface *src_bcsr = src_interface;
+	struct starpu_bcsr_interface *dst_bcsr = dst_interface;
 
 	uint32_t nnz = src_bcsr->nnz;
 	uint32_t nrow = src_bcsr->nrow;
@@ -462,8 +462,8 @@ static int copy_cuda_to_cuda(void *src_interface, unsigned src_node STARPU_ATTRI
 #ifdef STARPU_USE_OPENCL
 static int copy_opencl_to_ram(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED)
 {
-	starpu_bcsr_interface_t *src_bcsr = src_interface;
-	starpu_bcsr_interface_t *dst_bcsr = dst_interface;
+	struct starpu_bcsr_interface *src_bcsr = src_interface;
+	struct starpu_bcsr_interface *dst_bcsr = dst_interface;
 
 	uint32_t nnz = src_bcsr->nnz;
 	uint32_t nrow = src_bcsr->nrow;
@@ -493,8 +493,8 @@ static int copy_opencl_to_ram(void *src_interface, unsigned src_node STARPU_ATTR
 
 static int copy_ram_to_opencl(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED)
 {
-	starpu_bcsr_interface_t *src_bcsr = src_interface;
-	starpu_bcsr_interface_t *dst_bcsr = dst_interface;
+	struct starpu_bcsr_interface *src_bcsr = src_interface;
+	struct starpu_bcsr_interface *dst_bcsr = dst_interface;
 
 	uint32_t nnz = src_bcsr->nnz;
 	uint32_t nrow = src_bcsr->nrow;
@@ -526,8 +526,8 @@ static int copy_ram_to_opencl(void *src_interface, unsigned src_node STARPU_ATTR
 /* as not all platform easily have a BLAS lib installed ... */
 static int copy_ram_to_ram(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED)
 {
-	starpu_bcsr_interface_t *src_bcsr = (starpu_bcsr_interface_t *) src_interface;
-	starpu_bcsr_interface_t *dst_bcsr = (starpu_bcsr_interface_t *) dst_interface;
+	struct starpu_bcsr_interface *src_bcsr = (struct starpu_bcsr_interface *) src_interface;
+	struct starpu_bcsr_interface *dst_bcsr = (struct starpu_bcsr_interface *) dst_interface;
 
 	uint32_t nnz = src_bcsr->nnz;
 	uint32_t nrow = src_bcsr->nrow;

src/datawizard/interfaces/block_filters.c

@@ -21,8 +21,8 @@
 void starpu_block_filter_func_block(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f,
                                     unsigned id, unsigned nparts)
 {
-        starpu_block_interface_t *block_father = (starpu_block_interface_t *) father_interface;
-        starpu_block_interface_t *block_child = (starpu_block_interface_t *) child_interface;
+        struct starpu_block_interface *block_father = (struct starpu_block_interface *) father_interface;
+        struct starpu_block_interface *block_child = (struct starpu_block_interface *) child_interface;
 
 	uint32_t nx = block_father->nx;
         uint32_t ny = block_father->ny;

src/datawizard/interfaces/block_interface.c

@@ -90,7 +90,7 @@ static struct starpu_data_interface_ops interface_block_ops = {
 	.convert_to_gordon = convert_block_to_gordon,
 #endif
 	.interfaceid = STARPU_BLOCK_INTERFACE_ID, 
-	.interface_size = sizeof(starpu_block_interface_t),
+	.interface_size = sizeof(struct starpu_block_interface),
 	.display = display_block_interface
 };
 
@@ -108,7 +108,7 @@ static void *block_handle_to_pointer(starpu_data_handle handle, uint32_t node)
 {
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
-	starpu_block_interface_t *block_interface = (starpu_block_interface_t *)
+	struct starpu_block_interface *block_interface = (struct starpu_block_interface *)
 		starpu_data_get_interface_on_node(handle, node);
 
 	return (void*) block_interface->ptr;
@@ -116,12 +116,12 @@ static void *block_handle_to_pointer(starpu_data_handle handle, uint32_t node)
 
 static void register_block_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface)
 {
-	starpu_block_interface_t *block_interface = (starpu_block_interface_t *) data_interface;
+	struct starpu_block_interface *block_interface = (struct starpu_block_interface *) data_interface;
 
 	unsigned node;
 	for (node = 0; node < STARPU_MAXNODES; node++)
 	{
-		starpu_block_interface_t *local_interface = (starpu_block_interface_t *)
+		struct starpu_block_interface *local_interface = (struct starpu_block_interface *)
 			starpu_data_get_interface_on_node(handle, node);
 
 		if (node == home_node) {
@@ -151,7 +151,7 @@ void starpu_block_data_register(starpu_data_handle *handleptr, uint32_t home_nod
 			uintptr_t ptr, uint32_t ldy, uint32_t ldz, uint32_t nx,
 			uint32_t ny, uint32_t nz, size_t elemsize)
 {
-	starpu_block_interface_t block_interface = {
+	struct starpu_block_interface block_interface = {
 		.ptr = ptr,
                 .dev_handle = ptr,
                 .offset = 0,
@@ -179,8 +179,8 @@ static uint32_t footprint_block_interface_crc32(starpu_data_handle handle)
 
 static int block_compare(void *data_interface_a, void *data_interface_b)
 {
-	starpu_block_interface_t *block_a = (starpu_block_interface_t *) data_interface_a;
-	starpu_block_interface_t *block_b = (starpu_block_interface_t *) data_interface_b;
+	struct starpu_block_interface *block_a = (struct starpu_block_interface *) data_interface_a;
+	struct starpu_block_interface *block_b = (struct starpu_block_interface *) data_interface_b;
 
 	/* Two matricess are considered compatible if they have the same size */
 	return ((block_a->nx == block_b->nx)
@@ -191,9 +191,9 @@ static int block_compare(void *data_interface_a, void *data_interface_b)
 
 static void display_block_interface(starpu_data_handle handle, FILE *f)
 {
-	starpu_block_interface_t *block_interface;
+	struct starpu_block_interface *block_interface;
 
-	block_interface = (starpu_block_interface_t *) starpu_data_get_interface_on_node(handle, 0);
+	block_interface = (struct starpu_block_interface *) starpu_data_get_interface_on_node(handle, 0);
 
 	fprintf(f, "%u\t%u\t%u\t", block_interface->nx, block_interface->ny, block_interface->nz);
 }
@@ -201,9 +201,9 @@ static void display_block_interface(starpu_data_handle handle, FILE *f)
 static size_t block_interface_get_size(starpu_data_handle handle)
 {
 	size_t size;
-	starpu_block_interface_t *block_interface;
+	struct starpu_block_interface *block_interface;
 
-	block_interface = (starpu_block_interface_t *) starpu_data_get_interface_on_node(handle, 0);
+	block_interface = (struct starpu_block_interface *) starpu_data_get_interface_on_node(handle, 0);
 
 	size = block_interface->nx*block_interface->ny*block_interface->nz*block_interface->elemsize; 
 
@@ -213,7 +213,7 @@ static size_t block_interface_get_size(starpu_data_handle handle)
 /* offer an access to the data parameters */
 uint32_t starpu_block_get_nx(starpu_data_handle handle)
 {
-	starpu_block_interface_t *block_interface = (starpu_block_interface_t *)
+	struct starpu_block_interface *block_interface = (struct starpu_block_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return block_interface->nx;
@@ -221,7 +221,7 @@ uint32_t starpu_block_get_nx(starpu_data_handle handle)
 
 uint32_t starpu_block_get_ny(starpu_data_handle handle)
 {
-	starpu_block_interface_t *block_interface = (starpu_block_interface_t *)
+	struct starpu_block_interface *block_interface = (struct starpu_block_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return block_interface->ny;
@@ -229,7 +229,7 @@ uint32_t starpu_block_get_ny(starpu_data_handle handle)
 
 uint32_t starpu_block_get_nz(starpu_data_handle handle)
 {
-	starpu_block_interface_t *block_interface = (starpu_block_interface_t *)
+	struct starpu_block_interface *block_interface = (struct starpu_block_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return block_interface->nz;
@@ -242,7 +242,7 @@ uint32_t starpu_block_get_local_ldy(starpu_data_handle handle)
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 	
-	starpu_block_interface_t *block_interface = (starpu_block_interface_t *)
+	struct starpu_block_interface *block_interface = (struct starpu_block_interface *)
 		starpu_data_get_interface_on_node(handle, node);
 
 	return block_interface->ldy;
@@ -255,7 +255,7 @@ uint32_t starpu_block_get_local_ldz(starpu_data_handle handle)
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
-	starpu_block_interface_t *block_interface = (starpu_block_interface_t *)
+	struct starpu_block_interface *block_interface = (struct starpu_block_interface *)
 		starpu_data_get_interface_on_node(handle, node);
 
 	return block_interface->ldz;
@@ -268,7 +268,7 @@ uintptr_t starpu_block_get_local_ptr(starpu_data_handle handle)
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
-	starpu_block_interface_t *block_interface = (starpu_block_interface_t *)
+	struct starpu_block_interface *block_interface = (struct starpu_block_interface *)
 		starpu_data_get_interface_on_node(handle, node);
 
 	return block_interface->ptr;
@@ -276,7 +276,7 @@ uintptr_t starpu_block_get_local_ptr(starpu_data_handle handle)
 
 size_t starpu_block_get_elemsize(starpu_data_handle handle)
 {
-	starpu_block_interface_t *block_interface = (starpu_block_interface_t *)
+	struct starpu_block_interface *block_interface = (struct starpu_block_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return block_interface->elemsize;
@@ -295,7 +295,7 @@ static ssize_t allocate_block_buffer_on_node(void *data_interface_, uint32_t dst
 #ifdef STARPU_USE_CUDA
 	cudaError_t status;
 #endif
-	starpu_block_interface_t *dst_block = (starpu_block_interface_t *) data_interface_;
+	struct starpu_block_interface *dst_block = (struct starpu_block_interface *) data_interface_;
 
 	uint32_t nx = dst_block->nx;
 	uint32_t ny = dst_block->ny;
@@ -364,7 +364,7 @@ static ssize_t allocate_block_buffer_on_node(void *data_interface_, uint32_t dst
 
 static void free_block_buffer_on_node(void *data_interface, uint32_t node)
 {
-	starpu_block_interface_t *block_interface = (starpu_block_interface_t *) data_interface;
+	struct starpu_block_interface *block_interface = (struct starpu_block_interface *) data_interface;
 
 #ifdef STARPU_USE_CUDA
 	cudaError_t status;
@@ -396,8 +396,8 @@ static void free_block_buffer_on_node(void *data_interface, uint32_t node)
 #ifdef STARPU_USE_CUDA
 static int copy_cuda_common(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, enum cudaMemcpyKind kind)
 {
-	starpu_block_interface_t *src_block = src_interface;
-	starpu_block_interface_t *dst_block = dst_interface;
+	struct starpu_block_interface *src_block = src_interface;
+	struct starpu_block_interface *dst_block = dst_interface;
 
 	uint32_t nx = src_block->nx;
 	uint32_t ny = src_block->ny;
@@ -449,8 +449,8 @@ static int copy_cuda_common(void *src_interface, unsigned src_node STARPU_ATTRIB
 
 static int copy_cuda_async_common(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, cudaStream_t stream, enum cudaMemcpyKind kind)
 {
-	starpu_block_interface_t *src_block = src_interface;
-	starpu_block_interface_t *dst_block = dst_interface;
+	struct starpu_block_interface *src_block = src_interface;
+	struct starpu_block_interface *dst_block = dst_interface;
 
 	uint32_t nx = src_block->nx;
 	uint32_t ny = src_block->ny;
@@ -589,8 +589,8 @@ static int copy_ram_to_cuda_async(void *src_interface, unsigned src_node STARPU_
 #ifdef STARPU_USE_OPENCL
 static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, void *_event)
 {
-	starpu_block_interface_t *src_block = src_interface;
-	starpu_block_interface_t *dst_block = dst_interface;
+	struct starpu_block_interface *src_block = src_interface;
+	struct starpu_block_interface *dst_block = dst_interface;
         int err, ret = 0;
 
 	uint32_t nx = src_block->nx;
@@ -656,8 +656,8 @@ static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node STARP
 
 static int copy_opencl_to_ram_async(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, void *_event)
 {
-	starpu_block_interface_t *src_block = src_interface;
-	starpu_block_interface_t *dst_block = dst_interface;
+	struct starpu_block_interface *src_block = src_interface;
+	struct starpu_block_interface *dst_block = dst_interface;
         int err, ret = 0;
 
 	/* We may have a contiguous buffer for the entire block, or contiguous
@@ -730,8 +730,8 @@ static int copy_opencl_to_ram(void *src_interface, unsigned src_node STARPU_ATTR
 /* as not all platform easily have a BLAS lib installed ... */
 static int copy_ram_to_ram(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED)
 {
-	starpu_block_interface_t *src_block = (starpu_block_interface_t *) src_interface;
-	starpu_block_interface_t *dst_block = (starpu_block_interface_t *) dst_interface;
+	struct starpu_block_interface *src_block = (struct starpu_block_interface *) src_interface;
+	struct starpu_block_interface *dst_block = (struct starpu_block_interface *) dst_interface;
 
 	uint32_t nx = dst_block->nx;
 	uint32_t ny = dst_block->ny;

src/datawizard/interfaces/csr_filters.c

@@ -22,8 +22,8 @@
 
 void starpu_vertical_block_filter_func_csr(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, unsigned nchunks)
 {
-	starpu_csr_interface_t *csr_father = (starpu_csr_interface_t *) father_interface;
-	starpu_csr_interface_t *csr_child = (starpu_csr_interface_t *) child_interface;
+	struct starpu_csr_interface *csr_father = (struct starpu_csr_interface *) father_interface;
+	struct starpu_csr_interface *csr_child = (struct starpu_csr_interface *) child_interface;
 
 	uint32_t nrow = csr_father->nrow;
 	size_t elemsize = csr_father->elemsize;

src/datawizard/interfaces/csr_interface.c

@@ -77,19 +77,19 @@ static struct starpu_data_interface_ops interface_csr_ops = {
 	.copy_methods = &csr_copy_data_methods_s,
 	.get_size = csr_interface_get_size,
 	.interfaceid = STARPU_CSR_INTERFACE_ID,
-	.interface_size = sizeof(starpu_csr_interface_t),
+	.interface_size = sizeof(struct starpu_csr_interface),
 	.footprint = footprint_csr_interface_crc32,
 	.compare = csr_compare
 };
 
 static void register_csr_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface)
 {
-	starpu_csr_interface_t *csr_interface = (starpu_csr_interface_t *) data_interface;
+	struct starpu_csr_interface *csr_interface = (struct starpu_csr_interface *) data_interface;
 
 	unsigned node;
 	for (node = 0; node < STARPU_MAXNODES; node++)
 	{
-		starpu_csr_interface_t *local_interface = (starpu_csr_interface_t *)
+		struct starpu_csr_interface *local_interface = (struct starpu_csr_interface *)
 			starpu_data_get_interface_on_node(handle, node);
 
 		if (node == home_node) {
@@ -114,7 +114,7 @@ static void register_csr_handle(starpu_data_handle handle, uint32_t home_node, v
 void starpu_csr_data_register(starpu_data_handle *handleptr, uint32_t home_node,
 		uint32_t nnz, uint32_t nrow, uintptr_t nzval, uint32_t *colind, uint32_t *rowptr, uint32_t firstentry, size_t elemsize)
 {
-	starpu_csr_interface_t csr_interface = {
+	struct starpu_csr_interface csr_interface = {
 		.nnz = nnz,
 		.nrow = nrow,
 		.nzval = nzval,
@@ -134,8 +134,8 @@ static uint32_t footprint_csr_interface_crc32(starpu_data_handle handle)
 
 static int csr_compare(void *data_interface_a, void *data_interface_b)
 {
-	starpu_csr_interface_t *csr_a = (starpu_csr_interface_t *) data_interface_a;
-	starpu_csr_interface_t *csr_b = (starpu_csr_interface_t *) data_interface_b;
+	struct starpu_csr_interface *csr_a = (struct starpu_csr_interface *) data_interface_a;
+	struct starpu_csr_interface *csr_b = (struct starpu_csr_interface *) data_interface_b;
 
 	/* Two matricess are considered compatible if they have the same size */
 	return ((csr_a->nnz == csr_b->nnz)
@@ -146,7 +146,7 @@ static int csr_compare(void *data_interface_a, void *data_interface_b)
 /* offer an access to the data parameters */
 uint32_t starpu_csr_get_nnz(starpu_data_handle handle)
 {
-	starpu_csr_interface_t *csr_interface = (starpu_csr_interface_t *)
+	struct starpu_csr_interface *csr_interface = (struct starpu_csr_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return csr_interface->nnz;
@@ -154,7 +154,7 @@ uint32_t starpu_csr_get_nnz(starpu_data_handle handle)
 
 uint32_t starpu_csr_get_nrow(starpu_data_handle handle)
 {
-	starpu_csr_interface_t *csr_interface = (starpu_csr_interface_t *)
+	struct starpu_csr_interface *csr_interface = (struct starpu_csr_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return csr_interface->nrow;
@@ -162,7 +162,7 @@ uint32_t starpu_csr_get_nrow(starpu_data_handle handle)
 
 uint32_t starpu_csr_get_firstentry(starpu_data_handle handle)
 {
-	starpu_csr_interface_t *csr_interface = (starpu_csr_interface_t *)
+	struct starpu_csr_interface *csr_interface = (struct starpu_csr_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return csr_interface->firstentry;
@@ -170,7 +170,7 @@ uint32_t starpu_csr_get_firstentry(starpu_data_handle handle)
 
 size_t starpu_csr_get_elemsize(starpu_data_handle handle)
 {
-	starpu_csr_interface_t *csr_interface = (starpu_csr_interface_t *)
+	struct starpu_csr_interface *csr_interface = (struct starpu_csr_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return csr_interface->elemsize;
@@ -183,7 +183,7 @@ uintptr_t starpu_csr_get_local_nzval(starpu_data_handle handle)
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
-	starpu_csr_interface_t *csr_interface = (starpu_csr_interface_t *)
+	struct starpu_csr_interface *csr_interface = (struct starpu_csr_interface *)
 		starpu_data_get_interface_on_node(handle, node);
 
 	return csr_interface->nzval;
@@ -196,7 +196,7 @@ uint32_t *starpu_csr_get_local_colind(starpu_data_handle handle)
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
-	starpu_csr_interface_t *csr_interface = (starpu_csr_interface_t *)
+	struct starpu_csr_interface *csr_interface = (struct starpu_csr_interface *)
 		starpu_data_get_interface_on_node(handle, node);
 
 	return csr_interface->colind;
@@ -209,7 +209,7 @@ uint32_t *starpu_csr_get_local_rowptr(starpu_data_handle handle)
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
-	starpu_csr_interface_t *csr_interface = (starpu_csr_interface_t *)
+	struct starpu_csr_interface *csr_interface = (struct starpu_csr_interface *)
 		starpu_data_get_interface_on_node(handle, node);
 
 	return csr_interface->rowptr;
@@ -238,7 +238,7 @@ static ssize_t allocate_csr_buffer_on_node(void *data_interface_, uint32_t dst_n
 	ssize_t allocated_memory;
 
 	/* we need the 3 arrays to be allocated */
-	starpu_csr_interface_t *csr_interface = (starpu_csr_interface_t *) data_interface_;
+	struct starpu_csr_interface *csr_interface = (struct starpu_csr_interface *) data_interface_;
 
 	uint32_t nnz = csr_interface->nnz;
 	uint32_t nrow = csr_interface->nrow;
@@ -357,7 +357,7 @@ fail_nzval:
 
 static void free_csr_buffer_on_node(void *data_interface, uint32_t node)
 {
-	starpu_csr_interface_t *csr_interface = (starpu_csr_interface_t *) data_interface;
+	struct starpu_csr_interface *csr_interface = (struct starpu_csr_interface *) data_interface;
 
 	starpu_node_kind kind = _starpu_get_node_kind(node);
 	switch(kind) {
@@ -388,8 +388,8 @@ static void free_csr_buffer_on_node(void *data_interface, uint32_t node)
 #ifdef STARPU_USE_CUDA
 static int copy_cuda_common(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, enum cudaMemcpyKind kind)
 {
-	starpu_csr_interface_t *src_csr = src_interface;
-	starpu_csr_interface_t *dst_csr = dst_interface;
+	struct starpu_csr_interface *src_csr = src_interface;
+	struct starpu_csr_interface *dst_csr = dst_interface;
 
 	uint32_t nnz = src_csr->nnz;
 	uint32_t nrow = src_csr->nrow;
@@ -416,8 +416,8 @@ static int copy_cuda_common(void *src_interface, unsigned src_node STARPU_ATTRIB
 
 static int copy_cuda_common_async(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, enum cudaMemcpyKind kind, cudaStream_t stream)
 {
-	starpu_csr_interface_t *src_csr = src_interface;
-	starpu_csr_interface_t *dst_csr = dst_interface;
+	struct starpu_csr_interface *src_csr = src_interface;
+	struct starpu_csr_interface *dst_csr = dst_interface;
 
 	uint32_t nnz = src_csr->nnz;
 	uint32_t nrow = src_csr->nrow;
@@ -480,8 +480,8 @@ static int copy_cuda_common_async(void *src_interface, unsigned src_node STARPU_
 static int copy_cuda_peer(void *src_interface STARPU_ATTRIBUTE_UNUSED, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface STARPU_ATTRIBUTE_UNUSED, unsigned dst_node STARPU_ATTRIBUTE_UNUSED)
 {
 #ifdef HAVE_CUDA_MEMCPY_PEER
-	starpu_csr_interface_t *src_csr = src_interface;
-	starpu_csr_interface_t *dst_csr = dst_interface;
+	struct starpu_csr_interface *src_csr = src_interface;
+	struct starpu_csr_interface *dst_csr = dst_interface;
 
 	uint32_t nnz = src_csr->nnz;
 	uint32_t nrow = src_csr->nrow;
@@ -517,8 +517,8 @@ static int copy_cuda_peer_async(void *src_interface STARPU_ATTRIBUTE_UNUSED, uns
 				void *dst_interface STARPU_ATTRIBUTE_UNUSED, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, cudaStream_t stream STARPU_ATTRIBUTE_UNUSED)
 {
 #ifdef HAVE_CUDA_MEMCPY_PEER
-	starpu_csr_interface_t *src_csr = src_interface;
-	starpu_csr_interface_t *dst_csr = dst_interface;
+	struct starpu_csr_interface *src_csr = src_interface;
+	struct starpu_csr_interface *dst_csr = dst_interface;
 
 	uint32_t nnz = src_csr->nnz;
 	uint32_t nrow = src_csr->nrow;
@@ -627,8 +627,8 @@ static int copy_cuda_to_cuda_async(void *src_interface, unsigned src_node, void
 #ifdef STARPU_USE_OPENCL
 static int copy_opencl_to_ram(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED)
 {
-	starpu_csr_interface_t *src_csr = src_interface;
-	starpu_csr_interface_t *dst_csr = dst_interface;
+	struct starpu_csr_interface *src_csr = src_interface;
+	struct starpu_csr_interface *dst_csr = dst_interface;
 
 	uint32_t nnz = src_csr->nnz;
 	uint32_t nrow = src_csr->nrow;
@@ -655,8 +655,8 @@ static int copy_opencl_to_ram(void *src_interface, unsigned src_node STARPU_ATTR
 
 static int copy_ram_to_opencl(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED)
 {
-	starpu_csr_interface_t *src_csr = src_interface;
-	starpu_csr_interface_t *dst_csr = dst_interface;
+	struct starpu_csr_interface *src_csr = src_interface;
+	struct starpu_csr_interface *dst_csr = dst_interface;
 
 	uint32_t nnz = src_csr->nnz;
 	uint32_t nrow = src_csr->nrow;
@@ -685,8 +685,8 @@ static int copy_ram_to_opencl(void *src_interface, unsigned src_node STARPU_ATTR
 /* as not all platform easily have a BLAS lib installed ... */
 static int copy_ram_to_ram(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED)
 {
-	starpu_csr_interface_t *src_csr = (starpu_csr_interface_t *) src_interface;
-	starpu_csr_interface_t *dst_csr = (starpu_csr_interface_t *) dst_interface;
+	struct starpu_csr_interface *src_csr = (struct starpu_csr_interface *) src_interface;
+	struct starpu_csr_interface *dst_csr = (struct starpu_csr_interface *) dst_interface;
 
 	uint32_t nnz = src_csr->nnz;
 	uint32_t nrow = src_csr->nrow;

src/datawizard/interfaces/matrix_filters.c

@@ -25,8 +25,8 @@
  */
 void starpu_block_filter_func(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, unsigned nchunks)
 {
-       starpu_matrix_interface_t *matrix_father = (starpu_matrix_interface_t *) father_interface;
-       starpu_matrix_interface_t *matrix_child = (starpu_matrix_interface_t *) child_interface;
+       struct starpu_matrix_interface *matrix_father = (struct starpu_matrix_interface *) father_interface;
+       struct starpu_matrix_interface *matrix_child = (struct starpu_matrix_interface *) child_interface;
   
 	uint32_t nx = matrix_father->nx;
 	uint32_t ny = matrix_father->ny;
@@ -56,8 +56,8 @@ void starpu_block_filter_func(void *father_interface, void *child_interface, STA
 
 void starpu_vertical_block_filter_func(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, unsigned nchunks)
 {
-        starpu_matrix_interface_t *matrix_father = (starpu_matrix_interface_t *) father_interface;
-        starpu_matrix_interface_t *matrix_child = (starpu_matrix_interface_t *) child_interface;
+        struct starpu_matrix_interface *matrix_father = (struct starpu_matrix_interface *) father_interface;
+        struct starpu_matrix_interface *matrix_child = (struct starpu_matrix_interface *) child_interface;
 
 	uint32_t nx = matrix_father->nx;
 	uint32_t ny = matrix_father->ny;

src/datawizard/interfaces/matrix_interface.c

@@ -96,7 +96,7 @@ struct starpu_data_interface_ops _starpu_interface_matrix_ops = {
 	.convert_to_gordon = convert_matrix_to_gordon,
 #endif
 	.interfaceid = STARPU_MATRIX_INTERFACE_ID, 
-	.interface_size = sizeof(starpu_matrix_interface_t),
+	.interface_size = sizeof(struct starpu_matrix_interface),
 	.display = display_matrix_interface
 };
 
@@ -120,12 +120,12 @@ static int convert_matrix_to_gordon(void *data_interface, uint64_t *ptr, gordon_
 
 static void register_matrix_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface)
 {
-	starpu_matrix_interface_t *matrix_interface = (starpu_matrix_interface_t *) data_interface;
+	struct starpu_matrix_interface *matrix_interface = (struct starpu_matrix_interface *) data_interface;
 
 	unsigned node;
 	for (node = 0; node < STARPU_MAXNODES; node++)
 	{
-		starpu_matrix_interface_t *local_interface = (starpu_matrix_interface_t *)
+		struct starpu_matrix_interface *local_interface = (struct starpu_matrix_interface *)
 			starpu_data_get_interface_on_node(handle, node);
 
 		if (node == home_node) {
@@ -151,7 +151,7 @@ static void *matrix_handle_to_pointer(starpu_data_handle handle, uint32_t node)
 {
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
-	starpu_matrix_interface_t *matrix_interface = (starpu_matrix_interface_t *)
+	struct starpu_matrix_interface *matrix_interface = (struct starpu_matrix_interface *)
 		starpu_data_get_interface_on_node(handle, node);
 
 	return (void*) matrix_interface->ptr;
@@ -163,7 +163,7 @@ void starpu_matrix_data_register(starpu_data_handle *handleptr, uint32_t home_no
 			uintptr_t ptr, uint32_t ld, uint32_t nx,
 			uint32_t ny, size_t elemsize)
 {
-	starpu_matrix_interface_t matrix_interface = {
+	struct starpu_matrix_interface matrix_interface = {
 		.ptr = ptr,
 		.ld = ld,
 		.nx = nx,
@@ -183,8 +183,8 @@ static uint32_t footprint_matrix_interface_crc32(starpu_data_handle handle)
 
 static int matrix_compare(void *data_interface_a, void *data_interface_b)
 {
-	starpu_matrix_interface_t *matrix_a = (starpu_matrix_interface_t *) data_interface_a;
-	starpu_matrix_interface_t *matrix_b = (starpu_matrix_interface_t *) data_interface_b;
+	struct starpu_matrix_interface *matrix_a = (struct starpu_matrix_interface *) data_interface_a;
+	struct starpu_matrix_interface *matrix_b = (struct starpu_matrix_interface *) data_interface_b;
 
 	/* Two matricess are considered compatible if they have the same size */
 	return ((matrix_a->nx == matrix_b->nx)
@@ -194,7 +194,7 @@ static int matrix_compare(void *data_interface_a, void *data_interface_b)
 
 static void display_matrix_interface(starpu_data_handle handle, FILE *f)
 {
-	starpu_matrix_interface_t *matrix_interface = (starpu_matrix_interface_t *)
+	struct starpu_matrix_interface *matrix_interface = (struct starpu_matrix_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	fprintf(f, "%u\t%u\t", matrix_interface->nx, matrix_interface->ny);
@@ -202,7 +202,7 @@ static void display_matrix_interface(starpu_data_handle handle, FILE *f)
 
 static size_t matrix_interface_get_size(starpu_data_handle handle)
 {
-	starpu_matrix_interface_t *matrix_interface = (starpu_matrix_interface_t *)
+	struct starpu_matrix_interface *matrix_interface = (struct starpu_matrix_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	size_t size;
@@ -214,7 +214,7 @@ static size_t matrix_interface_get_size(starpu_data_handle handle)
 /* offer an access to the data parameters */
 uint32_t starpu_matrix_get_nx(starpu_data_handle handle)
 {
-	starpu_matrix_interface_t *matrix_interface = (starpu_matrix_interface_t *)
+	struct starpu_matrix_interface *matrix_interface = (struct starpu_matrix_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return matrix_interface->nx;
@@ -222,7 +222,7 @@ uint32_t starpu_matrix_get_nx(starpu_data_handle handle)
 
 uint32_t starpu_matrix_get_ny(starpu_data_handle handle)
 {
-	starpu_matrix_interface_t *matrix_interface = (starpu_matrix_interface_t *)
+	struct starpu_matrix_interface *matrix_interface = (struct starpu_matrix_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return matrix_interface->ny;
@@ -235,7 +235,7 @@ uint32_t starpu_matrix_get_local_ld(starpu_data_handle handle)
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
-	starpu_matrix_interface_t *matrix_interface = (starpu_matrix_interface_t *)
+	struct starpu_matrix_interface *matrix_interface = (struct starpu_matrix_interface *)
 		starpu_data_get_interface_on_node(handle, node);
 
 	return matrix_interface->ld;
@@ -248,7 +248,7 @@ uintptr_t starpu_matrix_get_local_ptr(starpu_data_handle handle)
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
-	starpu_matrix_interface_t *matrix_interface = (starpu_matrix_interface_t *)
+	struct starpu_matrix_interface *matrix_interface = (struct starpu_matrix_interface *)
 		starpu_data_get_interface_on_node(handle, node);
 
 	return matrix_interface->ptr;
@@ -256,7 +256,7 @@ uintptr_t starpu_matrix_get_local_ptr(starpu_data_handle handle)
 
 size_t starpu_matrix_get_elemsize(starpu_data_handle handle)
 {
-	starpu_matrix_interface_t *matrix_interface = (starpu_matrix_interface_t *)
+	struct starpu_matrix_interface *matrix_interface = (struct starpu_matrix_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return matrix_interface->elemsize;
@@ -275,7 +275,7 @@ static ssize_t allocate_matrix_buffer_on_node(void *data_interface_, uint32_t ds
 	cudaError_t status;
 #endif
 
-	starpu_matrix_interface_t *matrix_interface = (starpu_matrix_interface_t *) data_interface_;
+	struct starpu_matrix_interface *matrix_interface = (struct starpu_matrix_interface *) data_interface_;
 
 	uint32_t nx = matrix_interface->nx;
 	uint32_t ny = matrix_interface->ny;
@@ -342,7 +342,7 @@ static ssize_t allocate_matrix_buffer_on_node(void *data_interface_, uint32_t ds
 
 static void free_matrix_buffer_on_node(void *data_interface, uint32_t node)
 {
-	starpu_matrix_interface_t *matrix_interface = (starpu_matrix_interface_t *) data_interface;
+	struct starpu_matrix_interface *matrix_interface = (struct starpu_matrix_interface *) data_interface;
 
 #ifdef STARPU_USE_CUDA
 	cudaError_t status;
@@ -374,8 +374,8 @@ static void free_matrix_buffer_on_node(void *data_interface, uint32_t node)
 #ifdef STARPU_USE_CUDA
 static int copy_cuda_common(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, enum cudaMemcpyKind kind, int is_async, cudaStream_t stream)
 {
-	starpu_matrix_interface_t *src_matrix = src_interface;
-	starpu_matrix_interface_t *dst_matrix = dst_interface;
+	struct starpu_matrix_interface *src_matrix = src_interface;
+	struct starpu_matrix_interface *dst_matrix = dst_interface;
 
 	size_t elemsize = src_matrix->elemsize;
 	cudaError_t cures;
@@ -430,8 +430,8 @@ static int copy_cuda_common(void *src_interface, unsigned src_node STARPU_ATTRIB
 #ifdef NO_STRIDE
 static int copy_cuda_peer(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, int is_async, cudaStream_t stream)
 {
-	starpu_matrix_interface_t *src_matrix = src_interface;
-	starpu_matrix_interface_t *dst_matrix = dst_interface;
+	struct starpu_matrix_interface *src_matrix = src_interface;
+	struct starpu_matrix_interface *dst_matrix = dst_interface;
 
 	size_t elemsize = src_matrix->elemsize;
 	cudaError_t cures;
@@ -589,8 +589,8 @@ static int copy_cuda_to_cuda_async(void *src_interface, unsigned src_node STARPU
 #ifdef STARPU_USE_OPENCL
 static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, void *_event)
 {
-	starpu_matrix_interface_t *src_matrix = src_interface;
-	starpu_matrix_interface_t *dst_matrix = dst_interface;
+	struct starpu_matrix_interface *src_matrix = src_interface;
+	struct starpu_matrix_interface *dst_matrix = dst_interface;
         int err,ret;
 
 	/* XXX non contiguous matrices are not supported with OpenCL yet ! (TODO) */
@@ -609,8 +609,8 @@ static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node STARP
 
 static int copy_opencl_to_ram_async(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, void *_event)
 {
-	starpu_matrix_interface_t *src_matrix = src_interface;
-	starpu_matrix_interface_t *dst_matrix = dst_interface;
+	struct starpu_matrix_interface *src_matrix = src_interface;
+	struct starpu_matrix_interface *dst_matrix = dst_interface;
         int err, ret;
 
 	/* XXX non contiguous matrices are not supported with OpenCL yet ! (TODO) */
@@ -643,8 +643,8 @@ static int copy_opencl_to_ram(void *src_interface, unsigned src_node STARPU_ATTR
 /* as not all platform easily have a  lib installed ... */
 static int copy_ram_to_ram(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED)
 {
-	starpu_matrix_interface_t *src_matrix = (starpu_matrix_interface_t *) src_interface;
-	starpu_matrix_interface_t *dst_matrix = (starpu_matrix_interface_t *) dst_interface;
+	struct starpu_matrix_interface *src_matrix = (struct starpu_matrix_interface *) src_interface;
+	struct starpu_matrix_interface *dst_matrix = (struct starpu_matrix_interface *) dst_interface;
 
 	unsigned y;
 	uint32_t nx = dst_matrix->nx;

src/datawizard/interfaces/multiformat_interface.c

@@ -91,14 +91,14 @@ static struct starpu_data_interface_ops interface_multiformat_ops = {
 	.convert_to_gordon     = NULL,
 #endif
 	.interfaceid           = STARPU_MULTIFORMAT_INTERFACE_ID,
-	.interface_size        = sizeof(starpu_multiformat_interface_t),
+	.interface_size        = sizeof(struct starpu_multiformat_interface),
 	.display               = display_multiformat_interface
 };
 
 static void *multiformat_handle_to_pointer(starpu_data_handle handle, uint32_t node)
 {
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
-	starpu_multiformat_interface_t *multiformat_interface = 
+	struct starpu_multiformat_interface *multiformat_interface = 
 		starpu_data_get_interface_on_node(handle, node);
 
 	switch(_starpu_get_node_kind(node)) {
@@ -119,12 +119,12 @@ static void *multiformat_handle_to_pointer(starpu_data_handle handle, uint32_t n
 
 static void register_multiformat_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface)
 {
-	starpu_multiformat_interface_t *multiformat_interface;
-	multiformat_interface = (starpu_multiformat_interface_t *) data_interface;
+	struct starpu_multiformat_interface *multiformat_interface;
+	multiformat_interface = (struct starpu_multiformat_interface *) data_interface;
 
 	unsigned node;
 	for (node = 0; node < STARPU_MAXNODES; node++) {
-		starpu_multiformat_interface_t *local_interface =
+		struct starpu_multiformat_interface *local_interface =
 			starpu_data_get_interface_on_node(handle, node);
 
 		if (node == home_node) {
@@ -161,7 +161,7 @@ void starpu_multiformat_data_register(starpu_data_handle *handleptr,
 				      uint32_t nobjects,
 				      struct starpu_multiformat_data_interface_ops *format_ops)
 {
-	starpu_multiformat_interface_t multiformat = {
+	struct starpu_multiformat_interface multiformat = {
 		.cpu_ptr    = ptr,
 #ifdef STARPU_USE_CUDA
 		.cuda_ptr   = NULL,
@@ -184,8 +184,8 @@ static uint32_t footprint_multiformat_interface_crc32(starpu_data_handle handle)
 
 static int multiformat_compare(void *data_interface_a, void *data_interface_b)
 {
-	starpu_multiformat_interface_t *multiformat_a = data_interface_a;
-	starpu_multiformat_interface_t *multiformat_b = data_interface_b;
+	struct starpu_multiformat_interface *multiformat_a = data_interface_a;
+	struct starpu_multiformat_interface *multiformat_b = data_interface_b;
 
 	return ((multiformat_a->nx == multiformat_b->nx)
 			&& (multiformat_a->ops->cpu_elemsize == multiformat_b->ops->cpu_elemsize)
@@ -201,8 +201,8 @@ static int multiformat_compare(void *data_interface_a, void *data_interface_b)
 static void display_multiformat_interface(starpu_data_handle handle, FILE *f)
 {
 	/* TODO */
-	starpu_multiformat_interface_t *multiformat_interface;
-	multiformat_interface = (starpu_multiformat_interface_t *)
+	struct starpu_multiformat_interface *multiformat_interface;
+	multiformat_interface = (struct starpu_multiformat_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	fprintf(f, "%u\t", multiformat_interface->nx);
@@ -212,7 +212,7 @@ static void display_multiformat_interface(starpu_data_handle handle, FILE *f)
 static size_t multiformat_interface_get_size(starpu_data_handle handle)
 {
 	size_t size;
-	starpu_multiformat_interface_t *multiformat_interface;
+	struct starpu_multiformat_interface *multiformat_interface;
 	multiformat_interface = starpu_data_get_interface_on_node(handle, 0);
 	size = multiformat_interface->nx * multiformat_interface->ops->cpu_elemsize;
 	return size;
@@ -220,15 +220,15 @@ static size_t multiformat_interface_get_size(starpu_data_handle handle)
 
 uint32_t starpu_multiformat_get_nx(starpu_data_handle handle)
 {
-	starpu_multiformat_interface_t *multiformat_interface;
+	struct starpu_multiformat_interface *multiformat_interface;
 	multiformat_interface = starpu_data_get_interface_on_node(handle, 0);
 	return multiformat_interface->nx;
 }
 
 static void free_multiformat_buffer_on_node(void *data_interface, uint32_t node)
 {
-	starpu_multiformat_interface_t *multiformat_interface;
-	multiformat_interface = (starpu_multiformat_interface_t *) data_interface;
+	struct starpu_multiformat_interface *multiformat_interface;
+	multiformat_interface = (struct starpu_multiformat_interface *) data_interface;
 	starpu_node_kind kind = _starpu_get_node_kind(node);
 
 	switch(kind) {
@@ -254,8 +254,8 @@ static void free_multiformat_buffer_on_node(void *data_interface, uint32_t node)
 
 static ssize_t allocate_multiformat_buffer_on_node(void *data_interface_, uint32_t dst_node)
 {
-	starpu_multiformat_interface_t *multiformat_interface;
-	multiformat_interface = (starpu_multiformat_interface_t *) data_interface_;
+	struct starpu_multiformat_interface *multiformat_interface;
+	multiformat_interface = (struct starpu_multiformat_interface *) data_interface_;
 	unsigned fail = 0;
 	uintptr_t addr = 0;
 	ssize_t allocated_memory;
@@ -328,11 +328,11 @@ static ssize_t allocate_multiformat_buffer_on_node(void *data_interface_, uint32
 static int copy_ram_to_ram(void *src_interface, unsigned src_node,
 			   void *dst_interface, unsigned dst_node)
 {
-	starpu_multiformat_interface_t *src_multiformat;
-	starpu_multiformat_interface_t *dst_multiformat;
+	struct starpu_multiformat_interface *src_multiformat;
+	struct starpu_multiformat_interface *dst_multiformat;
 
-	src_multiformat = (starpu_multiformat_interface_t *) src_interface;
-	dst_multiformat = (starpu_multiformat_interface_t *) dst_interface;
+	src_multiformat = (struct starpu_multiformat_interface *) src_interface;
+	dst_multiformat = (struct starpu_multiformat_interface *) dst_interface;
 
 	STARPU_ASSERT(src_multiformat != NULL);
 	STARPU_ASSERT(dst_multiformat != NULL);
@@ -349,11 +349,11 @@ static int copy_cuda_common(void *src_interface, unsigned src_node,
 			    void *dst_interface, unsigned dst_node,
 			    enum cudaMemcpyKind kind)
 {
-	starpu_multiformat_interface_t *src_multiformat;
-	starpu_multiformat_interface_t *dst_multiformat;
+	struct starpu_multiformat_interface *src_multiformat;
+	struct starpu_multiformat_interface *dst_multiformat;
 
-	src_multiformat = (starpu_multiformat_interface_t *) src_interface;
-	dst_multiformat = (starpu_multiformat_interface_t *) dst_interface;
+	src_multiformat = (struct starpu_multiformat_interface *) src_interface;
+	dst_multiformat = (struct starpu_multiformat_interface *) dst_interface;
 
 	size_t size;
 
@@ -423,11 +423,11 @@ static int copy_cuda_to_ram(void *src_interface, unsigned src_node STARPU_ATTRIB
 
 static int copy_cuda_common_async(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, cudaStream_t stream, enum cudaMemcpyKind kind)
 {
-	starpu_multiformat_interface_t *src_multiformat;
-	starpu_multiformat_interface_t *dst_multiformat;
+	struct starpu_multiformat_interface *src_multiformat;
+	struct starpu_multiformat_interface *dst_multiformat;
 
-	src_multiformat = (starpu_multiformat_interface_t *) src_interface;
-	dst_multiformat = (starpu_multiformat_interface_t *) dst_interface;
+	src_multiformat = (struct starpu_multiformat_interface *) src_interface;
+	dst_multiformat = (struct starpu_multiformat_interface *) dst_interface;
 
 	size_t size;
 	cudaError_t status;
@@ -502,11 +502,11 @@ static int copy_cuda_peer_common(void *src_interface, unsigned src_node,
 				void *dst_interface, unsigned dst_node,
 				cudaStream_t stream)
 {
-	starpu_multiformat_interface_t *src_multiformat;
-	starpu_multiformat_interface_t *dst_multiformat;
+	struct starpu_multiformat_interface *src_multiformat;
+	struct starpu_multiformat_interface *dst_multiformat;
 
-	src_multiformat = (starpu_multiformat_interface_t *) src_interface;
-	dst_multiformat = (starpu_multiformat_interface_t *) dst_interface;
+	src_multiformat = (struct starpu_multiformat_interface *) src_interface;
+	dst_multiformat = (struct starpu_multiformat_interface *) dst_interface;
 
 	STARPU_ASSERT(src_multiformat != NULL);
 	STARPU_ASSERT(dst_multiformat != NULL);
@@ -591,11 +591,11 @@ static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node,
 {
 	int err, ret;
 	size_t size;
-	starpu_multiformat_interface_t *src_multiformat;
-	starpu_multiformat_interface_t *dst_multiformat;
+	struct starpu_multiformat_interface *src_multiformat;
+	struct starpu_multiformat_interface *dst_multiformat;
 
-	src_multiformat = (starpu_multiformat_interface_t *) src_interface;
-	dst_multiformat = (starpu_multiformat_interface_t *) dst_interface;
+	src_multiformat = (struct starpu_multiformat_interface *) src_interface;
+	dst_multiformat = (struct starpu_multiformat_interface *) dst_interface;
 
 	STARPU_ASSERT(src_multiformat != NULL);
 	STARPU_ASSERT(dst_multiformat != NULL);
@@ -641,11 +641,11 @@ static int copy_opencl_to_ram_async(void *src_interface, unsigned src_node,
 {
 	int err, ret;
 	size_t size;
-	starpu_multiformat_interface_t *src_multiformat;
-	starpu_multiformat_interface_t *dst_multiformat;
+	struct starpu_multiformat_interface *src_multiformat;
+	struct starpu_multiformat_interface *dst_multiformat;
 
-	src_multiformat = (starpu_multiformat_interface_t *) src_interface;
-	dst_multiformat = (starpu_multiformat_interface_t *) dst_interface;
+	src_multiformat = (struct starpu_multiformat_interface *) src_interface;
+	dst_multiformat = (struct starpu_multiformat_interface *) dst_interface;
 
 	STARPU_ASSERT(src_multiformat != NULL);
 	STARPU_ASSERT(dst_multiformat != NULL);

src/datawizard/interfaces/variable_interface.c

@@ -91,7 +91,7 @@ static struct starpu_data_interface_ops interface_variable_ops = {
 	.convert_to_gordon = convert_variable_to_gordon,
 #endif
 	.interfaceid = STARPU_VARIABLE_INTERFACE_ID,
-	.interface_size = sizeof(starpu_variable_interface_t), 
+	.interface_size = sizeof(struct starpu_variable_interface), 
 	.display = display_variable_interface
 };
 
@@ -107,7 +107,7 @@ static void register_variable_handle(starpu_data_handle handle, uint32_t home_no
 	unsigned node;
 	for (node = 0; node < STARPU_MAXNODES; node++)
 	{
-		starpu_variable_interface_t *local_interface = (starpu_variable_interface_t *)
+		struct starpu_variable_interface *local_interface = (struct starpu_variable_interface *)
 			starpu_data_get_interface_on_node(handle, node);
 
 		if (node == home_node) {
@@ -135,7 +135,7 @@ int convert_variable_to_gordon(void *data_interface, uint64_t *ptr, gordon_strid
 void starpu_variable_data_register(starpu_data_handle *handleptr, uint32_t home_node,
                         uintptr_t ptr, size_t elemsize)
 {
-	starpu_variable_interface_t variable = {
+	struct starpu_variable_interface variable = {
 		.ptr = ptr,
 		.elemsize = elemsize
 	};	
@@ -151,8 +151,8 @@ static uint32_t footprint_variable_interface_crc32(starpu_data_handle handle)
 
 static int variable_compare(void *data_interface_a, void *data_interface_b)
 {
-	starpu_variable_interface_t *variable_a = (starpu_variable_interface_t *) data_interface_a;
-	starpu_variable_interface_t *variable_b = (starpu_variable_interface_t *) data_interface_b;
+	struct starpu_variable_interface *variable_a = (struct starpu_variable_interface *) data_interface_a;
+	struct starpu_variable_interface *variable_b = (struct starpu_variable_interface *) data_interface_b;
 
 	/* Two variables are considered compatible if they have the same size */
 	return (variable_a->elemsize == variable_b->elemsize);
@@ -160,7 +160,7 @@ static int variable_compare(void *data_interface_a, void *data_interface_b)
 
 static void display_variable_interface(starpu_data_handle handle, FILE *f)
 {
-	starpu_variable_interface_t *variable_interface = (starpu_variable_interface_t *)
+	struct starpu_variable_interface *variable_interface = (struct starpu_variable_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	fprintf(f, "%ld\t", (long)variable_interface->elemsize);
@@ -168,7 +168,7 @@ static void display_variable_interface(starpu_data_handle handle, FILE *f)
 
 static size_t variable_interface_get_size(starpu_data_handle handle)
 {
-	starpu_variable_interface_t *variable_interface = (starpu_variable_interface_t *)
+	struct starpu_variable_interface *variable_interface = (struct starpu_variable_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return variable_interface->elemsize;
@@ -194,7 +194,7 @@ size_t starpu_variable_get_elemsize(starpu_data_handle handle)
 /* returns the size of the allocated area */
 static ssize_t allocate_variable_buffer_on_node(void *data_interface_, uint32_t dst_node)
 {
-	starpu_variable_interface_t *variable_interface = (starpu_variable_interface_t *) data_interface_;
+	struct starpu_variable_interface *variable_interface = (struct starpu_variable_interface *) data_interface_;
 
 	unsigned fail = 0;
 	uintptr_t addr = 0;
@@ -281,8 +281,8 @@ static void free_variable_buffer_on_node(void *data_interface, uint32_t node)
 static int copy_cuda_common(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED,
 				void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, enum cudaMemcpyKind kind)
 {
-	starpu_variable_interface_t *src_variable = src_interface;
-	starpu_variable_interface_t *dst_variable = dst_interface;
+	struct starpu_variable_interface *src_variable = src_interface;
+	struct starpu_variable_interface *dst_variable = dst_interface;
 
 	cudaError_t cures;
 	cures = cudaMemcpy((char *)dst_variable->ptr, (char *)src_variable->ptr, src_variable->elemsize, kind);
@@ -320,8 +320,8 @@ static int copy_cuda_to_cuda(void *src_interface, unsigned src_node STARPU_ATTRI
 		int src_dev = starpu_memory_node_to_devid(src_node);
 		int dst_dev = starpu_memory_node_to_devid(dst_node);
 
-		starpu_variable_interface_t *src_variable = src_interface;
-		starpu_variable_interface_t *dst_variable = dst_interface;
+		struct starpu_variable_interface *src_variable = src_interface;
+		struct starpu_variable_interface *dst_variable = dst_interface;
 
 		cudaError_t cures;
 		cures = cudaMemcpyPeer((char *)dst_variable->ptr, dst_dev, (char *)src_variable->ptr, src_dev, src_variable->elemsize);
@@ -342,8 +342,8 @@ static int copy_cuda_async_common(void *src_interface, unsigned src_node STARPU_
 					void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED,
 					cudaStream_t stream, enum cudaMemcpyKind kind)
 {
-	starpu_variable_interface_t *src_variable = src_interface;
-	starpu_variable_interface_t *dst_variable = dst_interface;
+	struct starpu_variable_interface *src_variable = src_interface;
+	struct starpu_variable_interface *dst_variable = dst_interface;
 
 	cudaError_t cures;
 	STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
@@ -389,8 +389,8 @@ static int copy_cuda_to_cuda_async(void *src_interface, unsigned src_node,					v
 		int src_dev = starpu_memory_node_to_devid(src_node);
 		int dst_dev = starpu_memory_node_to_devid(dst_node);
 
-		starpu_variable_interface_t *src_variable = src_interface;
-		starpu_variable_interface_t *dst_variable = dst_interface;
+		struct starpu_variable_interface *src_variable = src_interface;
+		struct starpu_variable_interface *dst_variable = dst_interface;
 
 		size_t length = src_variable->elemsize;
 
@@ -426,8 +426,8 @@ static int copy_cuda_to_cuda_async(void *src_interface, unsigned src_node,					v
 static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface,
                                     unsigned dst_node STARPU_ATTRIBUTE_UNUSED, void *_event)
 {
-	starpu_variable_interface_t *src_variable = src_interface;
-	starpu_variable_interface_t *dst_variable = dst_interface;
+	struct starpu_variable_interface *src_variable = src_interface;
+	struct starpu_variable_interface *dst_variable = dst_interface;
         int err,ret;
 
         err = _starpu_opencl_copy_ram_to_opencl_async_sync((void*)src_variable->ptr, src_node, (cl_mem)dst_variable->ptr, dst_node, src_variable->elemsize,
@@ -442,8 +442,8 @@ static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node STARP
 
 static int copy_opencl_to_ram_async(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, void *_event)
 {
-	starpu_variable_interface_t *src_variable = src_interface;
-	starpu_variable_interface_t *dst_variable = dst_interface;
+	struct starpu_variable_interface *src_variable = src_interface;
+	struct starpu_variable_interface *dst_variable = dst_interface;
         int err, ret;
 
 	err = _starpu_opencl_copy_opencl_to_ram_async_sync((cl_mem)src_variable->ptr, src_node, (void*)dst_variable->ptr, dst_node, src_variable->elemsize,
@@ -471,8 +471,8 @@ static int copy_opencl_to_opencl(void *src_interface, unsigned src_node STARPU_A
 {
 	cl_int err;
 
-	starpu_variable_interface_t *src_variable = src_interface;
-	starpu_variable_interface_t *dst_variable = dst_interface;
+	struct starpu_variable_interface *src_variable = src_interface;
+	struct starpu_variable_interface *dst_variable = dst_interface;
 
 	cl_mem src_ptr = (cl_mem)src_variable->ptr;
 	cl_mem dst_ptr = (cl_mem)dst_variable->ptr;
@@ -494,8 +494,8 @@ static int copy_opencl_to_opencl(void *src_interface, unsigned src_node STARPU_A
 
 static int copy_ram_to_ram(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED)
 {
-	starpu_variable_interface_t *src_variable = (starpu_variable_interface_t *) src_interface;
-	starpu_variable_interface_t *dst_variable = (starpu_variable_interface_t *) dst_interface;
+	struct starpu_variable_interface *src_variable = (struct starpu_variable_interface *) src_interface;
+	struct starpu_variable_interface *dst_variable = (struct starpu_variable_interface *) dst_interface;
 
 	size_t elemsize = dst_variable->elemsize;
 

src/datawizard/interfaces/vector_filters.c

@@ -22,8 +22,8 @@
 
 void starpu_block_filter_func_vector(void *father_interface, void *child_interface, STARPU_ATTRIBUTE_UNUSED struct starpu_data_filter *f, unsigned id, unsigned nchunks)
 {
-        starpu_vector_interface_t *vector_father = (starpu_vector_interface_t *) father_interface;
-        starpu_vector_interface_t *vector_child = (starpu_vector_interface_t *) child_interface;
+        struct starpu_vector_interface *vector_father = (struct starpu_vector_interface *) father_interface;
+        struct starpu_vector_interface *vector_child = (struct starpu_vector_interface *) child_interface;
 	
 	uint32_t nx = vector_father->nx;
 	size_t elemsize = vector_father->elemsize;
@@ -52,8 +52,8 @@ void starpu_vector_divide_in_2_filter_func(void *father_interface, void *child_i
         /* there cannot be more than 2 chunks */
         STARPU_ASSERT(id < 2);
 	
-	starpu_vector_interface_t *vector_father = (starpu_vector_interface_t *) father_interface;
-	starpu_vector_interface_t *vector_child = (starpu_vector_interface_t *) child_interface;
+	struct starpu_vector_interface *vector_father = (struct starpu_vector_interface *) father_interface;
+	struct starpu_vector_interface *vector_child = (struct starpu_vector_interface *) child_interface;
 
 	uint32_t length_first = f->filter_arg;
 
@@ -90,8 +90,8 @@ void starpu_vector_divide_in_2_filter_func(void *father_interface, void *child_i
 
 void starpu_vector_list_filter_func(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, STARPU_ATTRIBUTE_UNUSED unsigned nchunks)
 {
-        starpu_vector_interface_t *vector_father = (starpu_vector_interface_t *) father_interface;
-        starpu_vector_interface_t *vector_child = (starpu_vector_interface_t *) child_interface;
+        struct starpu_vector_interface *vector_father = (struct starpu_vector_interface *) father_interface;
+        struct starpu_vector_interface *vector_child = (struct starpu_vector_interface *) child_interface;
 
         uint32_t *length_tab = (uint32_t *) f->filter_arg_ptr;
 

src/datawizard/interfaces/vector_interface.c

@@ -91,7 +91,7 @@ static struct starpu_data_interface_ops interface_vector_ops = {
 	.convert_to_gordon = convert_vector_to_gordon,
 #endif
 	.interfaceid = STARPU_VECTOR_INTERFACE_ID,
-	.interface_size = sizeof(starpu_vector_interface_t), 
+	.interface_size = sizeof(struct starpu_vector_interface), 
 	.display = display_vector_interface
 };
 
@@ -99,7 +99,7 @@ static void *vector_handle_to_pointer(starpu_data_handle handle, uint32_t node)
 {
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
-	starpu_vector_interface_t *vector_interface = (starpu_vector_interface_t *)
+	struct starpu_vector_interface *vector_interface = (struct starpu_vector_interface *)
 		starpu_data_get_interface_on_node(handle, node);
 
 	return (void*) vector_interface->ptr;
@@ -107,12 +107,12 @@ static void *vector_handle_to_pointer(starpu_data_handle handle, uint32_t node)
 
 static void register_vector_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface)
 {
-	starpu_vector_interface_t *vector_interface = (starpu_vector_interface_t *) data_interface;
+	struct starpu_vector_interface *vector_interface = (struct starpu_vector_interface *) data_interface;
 
 	unsigned node;
 	for (node = 0; node < STARPU_MAXNODES; node++)
 	{
-		starpu_vector_interface_t *local_interface = (starpu_vector_interface_t *)
+		struct starpu_vector_interface *local_interface = (struct starpu_vector_interface *)
 			starpu_data_get_interface_on_node(handle, node);
 
 		if (node == home_node) {
@@ -134,7 +134,7 @@ static void register_vector_handle(starpu_data_handle handle, uint32_t home_node
 #ifdef STARPU_USE_GORDON
 int convert_vector_to_gordon(void *data_interface, uint64_t *ptr, gordon_strideSize_t *ss) 
 {
-	starpu_vector_interface_t *vector_interface = interface;
+	struct starpu_vector_interface *vector_interface = interface;
 	
 	*ptr = vector_interface->ptr;
 	(*ss).size = vector_interface->nx * vector_interface->elemsize;
@@ -147,7 +147,7 @@ int convert_vector_to_gordon(void *data_interface, uint64_t *ptr, gordon_strideS
 void starpu_vector_data_register(starpu_data_handle *handleptr, uint32_t home_node,
                         uintptr_t ptr, uint32_t nx, size_t elemsize)
 {
-	starpu_vector_interface_t vector = {
+	struct starpu_vector_interface vector = {
 		.ptr = ptr,
 		.nx = nx,
 		.elemsize = elemsize,
@@ -166,8 +166,8 @@ static uint32_t footprint_vector_interface_crc32(starpu_data_handle handle)
 
 static int vector_compare(void *data_interface_a, void *data_interface_b)
 {
-	starpu_vector_interface_t *vector_a = (starpu_vector_interface_t *) data_interface_a;
-	starpu_vector_interface_t *vector_b = (starpu_vector_interface_t *) data_interface_b;
+	struct starpu_vector_interface *vector_a = (struct starpu_vector_interface *) data_interface_a;
+	struct starpu_vector_interface *vector_b = (struct starpu_vector_interface *) data_interface_b;
 
 	/* Two vectors are considered compatible if they have the same size */
 	return ((vector_a->nx == vector_b->nx)
@@ -176,7 +176,7 @@ static int vector_compare(void *data_interface_a, void *data_interface_b)
 
 static void display_vector_interface(starpu_data_handle handle, FILE *f)
 {
-	starpu_vector_interface_t *vector_interface = (starpu_vector_interface_t *)
+	struct starpu_vector_interface *vector_interface = (struct starpu_vector_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	fprintf(f, "%u\t", vector_interface->nx);
@@ -185,7 +185,7 @@ static void display_vector_interface(starpu_data_handle handle, FILE *f)
 static size_t vector_interface_get_size(starpu_data_handle handle)
 {
 	size_t size;
-	starpu_vector_interface_t *vector_interface = (starpu_vector_interface_t *)
+	struct starpu_vector_interface *vector_interface = (struct starpu_vector_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	size = vector_interface->nx*vector_interface->elemsize;
@@ -196,7 +196,7 @@ static size_t vector_interface_get_size(starpu_data_handle handle)
 /* offer an access to the data parameters */
 uint32_t starpu_vector_get_nx(starpu_data_handle handle)
 {
-	starpu_vector_interface_t *vector_interface = (starpu_vector_interface_t *)
+	struct starpu_vector_interface *vector_interface = (struct starpu_vector_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return vector_interface->nx;
@@ -209,7 +209,7 @@ uintptr_t starpu_vector_get_local_ptr(starpu_data_handle handle)
 
 	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
 
-	starpu_vector_interface_t *vector_interface = (starpu_vector_interface_t *)
+	struct starpu_vector_interface *vector_interface = (struct starpu_vector_interface *)
 		starpu_data_get_interface_on_node(handle, node);
 
 	return vector_interface->ptr;
@@ -217,7 +217,7 @@ uintptr_t starpu_vector_get_local_ptr(starpu_data_handle handle)
 
 size_t starpu_vector_get_elemsize(starpu_data_handle handle)
 {
-	starpu_vector_interface_t *vector_interface = (starpu_vector_interface_t *)
+	struct starpu_vector_interface *vector_interface = (struct starpu_vector_interface *)
 		starpu_data_get_interface_on_node(handle, 0);
 
 	return vector_interface->elemsize;
@@ -228,7 +228,7 @@ size_t starpu_vector_get_elemsize(starpu_data_handle handle)
 /* returns the size of the allocated area */
 static ssize_t allocate_vector_buffer_on_node(void *data_interface_, uint32_t dst_node)
 {
-	starpu_vector_interface_t *vector_interface = (starpu_vector_interface_t *) data_interface_;
+	struct starpu_vector_interface *vector_interface = (struct starpu_vector_interface *) data_interface_;
 
 	unsigned fail = 0;
 	uintptr_t addr = 0;
@@ -294,7 +294,7 @@ static ssize_t allocate_vector_buffer_on_node(void *data_interface_, uint32_t ds
 
 static void free_vector_buffer_on_node(void *data_interface, uint32_t node)
 {
-	starpu_vector_interface_t *vector_interface = (starpu_vector_interface_t *) data_interface;
+	struct starpu_vector_interface *vector_interface = (struct starpu_vector_interface *) data_interface;
 
 #ifdef STARPU_USE_CUDA
 	cudaError_t cures;
@@ -325,8 +325,8 @@ static void free_vector_buffer_on_node(void *data_interface, uint32_t node)
 static int copy_cuda_common(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED,
 				void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, enum cudaMemcpyKind kind)
 {
-	starpu_vector_interface_t *src_vector = src_interface;
-	starpu_vector_interface_t *dst_vector = dst_interface;
+	struct starpu_vector_interface *src_vector = src_interface;
+	struct starpu_vector_interface *dst_vector = dst_interface;
 
 	cudaError_t cures;
 
@@ -346,8 +346,8 @@ static int copy_cuda_peer_common(void *src_interface, unsigned src_node,
 {
 	cudaError_t cures;
 
-	starpu_vector_interface_t *src_vector = src_interface;
-	starpu_vector_interface_t *dst_vector = dst_interface;
+	struct starpu_vector_interface *src_vector = src_interface;
+	struct starpu_vector_interface *dst_vector = dst_interface;
 
 	size_t length = src_vector->nx*src_vector->elemsize;
 
@@ -410,8 +410,8 @@ static int copy_cuda_async_common(void *src_interface, unsigned src_node STARPU_
 					void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED,
 					cudaStream_t stream, enum cudaMemcpyKind kind)
 {
-	starpu_vector_interface_t *src_vector = src_interface;
-	starpu_vector_interface_t *dst_vector = dst_interface;
+	struct starpu_vector_interface *src_vector = src_interface;
+	struct starpu_vector_interface *dst_vector = dst_interface;
 
 	cudaError_t cures;
 
@@ -468,8 +468,8 @@ static int copy_ram_to_cuda_async(void *src_interface, unsigned src_node STARPU_
 static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED,
                                     void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, void *_event)
 {
-	starpu_vector_interface_t *src_vector = src_interface;
-	starpu_vector_interface_t *dst_vector = dst_interface;
+	struct starpu_vector_interface *src_vector = src_interface;
+	struct starpu_vector_interface *dst_vector = dst_interface;
         int err, ret;
 
 	err = _starpu_opencl_copy_ram_to_opencl_async_sync((void*)src_vector->ptr, src_node, (cl_mem)dst_vector->dev_handle, dst_node,
@@ -486,8 +486,8 @@ static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node STARP
 static int copy_opencl_to_ram_async(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED,
                                     void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, void *_event)
 {
-	starpu_vector_interface_t *src_vector = src_interface;
-	starpu_vector_interface_t *dst_vector = dst_interface;
+	struct starpu_vector_interface *src_vector = src_interface;
+	struct starpu_vector_interface *dst_vector = dst_interface;
         int err, ret;
 
 	err = _starpu_opencl_copy_opencl_to_ram_async_sync((cl_mem)src_vector->dev_handle, src_node, (void*)dst_vector->ptr, dst_node, src_vector->nx*src_vector->elemsize,
@@ -517,8 +517,8 @@ static int copy_opencl_to_opencl(void *src_interface, unsigned src_node STARPU_A
 {
         int err;
 
-	starpu_vector_interface_t *src_vector = src_interface;
-	starpu_vector_interface_t *dst_vector = dst_interface;
+	struct starpu_vector_interface *src_vector = src_interface;
+	struct starpu_vector_interface *dst_vector = dst_interface;
 
 	cl_command_queue cq;
 	starpu_opencl_get_current_queue(&cq);
@@ -540,8 +540,8 @@ static int copy_opencl_to_opencl(void *src_interface, unsigned src_node STARPU_A
 static int copy_ram_to_ram(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED,
 					void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED)
 {
-	starpu_vector_interface_t *src_vector = (starpu_vector_interface_t *) src_interface;
-	starpu_vector_interface_t *dst_vector = (starpu_vector_interface_t *) dst_interface;
+	struct starpu_vector_interface *src_vector = (struct starpu_vector_interface *) src_interface;
+	struct starpu_vector_interface *dst_vector = (struct starpu_vector_interface *) dst_interface;
 
 	uint32_t nx = dst_vector->nx;
 	size_t elemsize = dst_vector->elemsize;

tools/dev/rename.sed

@@ -14,6 +14,13 @@
 #
 # See the GNU Lesser General Public License in COPYING.LGPL for more details.
 
+s/\bstarpu_block_interface_t/struct starpu_block_interface/g
+s/\bstarpu_matrix_interface_t/struct starpu_matrix_interface/g
+s/\bstarpu_vector_interface_t/struct starpu_vector_interface/g
+s/\bstarpu_variable_interface_t/struct starpu_variable_interface/g
+s/\bstarpu_csr_interface_t/struct starpu_csr_interface/g
+s/\bstarpu_bcsr_interface_t/struct starpu_bcsr_interface/g
+s/\bstarpu_multiformat_interface_t/struct starpu_multiformat_interface/g
 s/\bstarpu_machine_topology_s\b/starpu_machine_topology/g
 s/\bstarpu_htbl32_node_s\b/starpu_htbl32_node/g
 s/\bstarpu_history_list_t\b/starpu_history_list/g