rename function parameter interface into data_interface (on windows, when including <windows.h>, one gets #define interface struct, ...)

include/starpu_data_interfaces.h

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010  Université de Bordeaux 1
- * Copyright (C) 2010  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
  *
  * StarPU is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -83,16 +83,16 @@ struct starpu_data_copy_methods {
 
 struct starpu_data_interface_ops_t {
 	void (*register_data_handle)(starpu_data_handle handle,
-					uint32_t home_node, void *interface);
-	ssize_t (*allocate_data_on_node)(void *interface, uint32_t node);
-	void (*free_data_on_node)(void *interface, uint32_t node);
+					uint32_t home_node, void *data_interface);
+	ssize_t (*allocate_data_on_node)(void *data_interface, uint32_t node);
+	void (*free_data_on_node)(void *data_interface, uint32_t node);
 	const struct starpu_data_copy_methods *copy_methods;
 	size_t (*get_size)(starpu_data_handle handle);
 	uint32_t (*footprint)(starpu_data_handle handle);
-	int (*compare)(void *interface_a, void *interface_b);
+	int (*compare)(void *data_interface_a, void *data_interface_b);
 	void (*display)(starpu_data_handle handle, FILE *f);
 #ifdef STARPU_USE_GORDON
-	int (*convert_to_gordon)(void *interface, uint64_t *ptr, gordon_strideSize_t *ss); 
+	int (*convert_to_gordon)(void *data_interface, uint64_t *ptr, gordon_strideSize_t *ss); 
 #endif
 	/* an identifier that is unique to each interface */
 	unsigned interfaceid;
@@ -100,7 +100,7 @@ struct starpu_data_interface_ops_t {
 };
 
 void starpu_data_register(starpu_data_handle *handleptr, uint32_t home_node,
-				void *interface,
+				void *data_interface,
 				struct starpu_data_interface_ops_t *ops);
 
 extern struct starpu_data_interface_ops_t _starpu_interface_matrix_ops;

src/datawizard/interfaces/bcsr_interface.c

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2009, 2010  Université de Bordeaux 1
- * Copyright (C) 2010  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
  *
  * StarPU is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -60,11 +60,11 @@ static const struct starpu_data_copy_methods bcsr_copy_data_methods_s = {
 	.spu_to_spu = NULL
 };
 
-static void register_bcsr_handle(starpu_data_handle handle, uint32_t home_node, void *interface);
-static ssize_t allocate_bcsr_buffer_on_node(void *interface, uint32_t dst_node);
-static void free_bcsr_buffer_on_node(void *interface, uint32_t node);
+static void register_bcsr_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface);
+static ssize_t allocate_bcsr_buffer_on_node(void *data_interface, uint32_t dst_node);
+static void free_bcsr_buffer_on_node(void *data_interface, uint32_t node);
 static size_t bcsr_interface_get_size(starpu_data_handle handle);
-static int bcsr_compare(void *interface_a, void *interface_b);
+static int bcsr_compare(void *data_interface_a, void *data_interface_b);
 static uint32_t footprint_bcsr_interface_crc32(starpu_data_handle handle);
 
 
@@ -80,9 +80,9 @@ static struct starpu_data_interface_ops_t interface_bcsr_ops = {
 	.compare = bcsr_compare
 };
 
-static void register_bcsr_handle(starpu_data_handle handle, uint32_t home_node, void *interface)
+static void register_bcsr_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface)
 {
-	starpu_bcsr_interface_t *bcsr_interface = interface;
+	starpu_bcsr_interface_t *bcsr_interface = data_interface;
 
 	unsigned node;
 	for (node = 0; node < STARPU_MAXNODES; node++)
@@ -141,10 +141,10 @@ static uint32_t footprint_bcsr_interface_crc32(starpu_data_handle handle)
 	return hash;
 }
 
-static int bcsr_compare(void *interface_a, void *interface_b)
+static int bcsr_compare(void *data_interface_a, void *data_interface_b)
 {
-	starpu_bcsr_interface_t *bcsr_a = interface_a;
-	starpu_bcsr_interface_t *bcsr_b = interface_b;
+	starpu_bcsr_interface_t *bcsr_a = data_interface_a;
+	starpu_bcsr_interface_t *bcsr_b = data_interface_b;
 
 	/* Two matricess are considered compatible if they have the same size */
 	return ((bcsr_a->nnz == bcsr_b->nnz)
@@ -254,14 +254,14 @@ static size_t bcsr_interface_get_size(starpu_data_handle handle)
 /* memory allocation/deallocation primitives for the BLAS interface */
 
 /* returns the size of the allocated area */
-static ssize_t allocate_bcsr_buffer_on_node(void *interface_, uint32_t dst_node)
+static ssize_t allocate_bcsr_buffer_on_node(void *data_interface_, uint32_t dst_node)
 {
 	uintptr_t addr_nzval;
 	uint32_t *addr_colind, *addr_rowptr;
 	ssize_t allocated_memory;
 
 	/* we need the 3 arrays to be allocated */
-	starpu_bcsr_interface_t *interface = interface_;
+	starpu_bcsr_interface_t *interface = data_interface_;
 
 	uint32_t nnz = interface->nnz;
 	uint32_t nrow = interface->nrow;
@@ -381,9 +381,9 @@ fail_nzval:
 	return -ENOMEM;
 }
 
-static void free_bcsr_buffer_on_node(void *interface, uint32_t node)
+static void free_bcsr_buffer_on_node(void *data_interface, uint32_t node)
 {
-	starpu_bcsr_interface_t *bcsr_interface = interface;	
+	starpu_bcsr_interface_t *bcsr_interface = data_interface;
 
 	starpu_node_kind kind = _starpu_get_node_kind(node);
 	switch(kind) {

src/datawizard/interfaces/block_interface.c

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2009, 2010  Université de Bordeaux 1
- * Copyright (C) 2010  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
  *
  * StarPU is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -65,15 +65,15 @@ static const struct starpu_data_copy_methods block_copy_data_methods_s = {
 };
 
 
-static void register_block_handle(starpu_data_handle handle, uint32_t home_node, void *interface);
-static ssize_t allocate_block_buffer_on_node(void *interface_, uint32_t dst_node);
-static void free_block_buffer_on_node(void *interface, uint32_t node);
+static void register_block_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface);
+static ssize_t allocate_block_buffer_on_node(void *data_interface_, uint32_t dst_node);
+static void free_block_buffer_on_node(void *data_interface, uint32_t node);
 static size_t block_interface_get_size(starpu_data_handle handle);
 static uint32_t footprint_block_interface_crc32(starpu_data_handle handle);
-static int block_compare(void *interface_a, void *interface_b);
+static int block_compare(void *data_interface_a, void *data_interface_b);
 static void display_block_interface(starpu_data_handle handle, FILE *f);
 #ifdef STARPU_USE_GORDON
-static int convert_block_to_gordon(void *interface, uint64_t *ptr, gordon_strideSize_t *ss);
+static int convert_block_to_gordon(void *data_interface, uint64_t *ptr, gordon_strideSize_t *ss);
 #endif
 
 static struct starpu_data_interface_ops_t interface_block_ops = {
@@ -93,7 +93,7 @@ static struct starpu_data_interface_ops_t interface_block_ops = {
 };
 
 #ifdef STARPU_USE_GORDON
-int convert_block_to_gordon(void *interface, uint64_t *ptr, gordon_strideSize_t *ss) 
+int convert_block_to_gordon(void *data_interface, uint64_t *ptr, gordon_strideSize_t *ss) 
 {
 	/* TODO */
 	STARPU_ABORT();
@@ -102,9 +102,9 @@ int convert_block_to_gordon(void *interface, uint64_t *ptr, gordon_strideSize_t
 }
 #endif
 
-static void register_block_handle(starpu_data_handle handle, uint32_t home_node, void *interface)
+static void register_block_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface)
 {
-	starpu_block_interface_t *block_interface = interface;
+	starpu_block_interface_t *block_interface = data_interface;
 
 	unsigned node;
 	for (node = 0; node < STARPU_MAXNODES; node++)
@@ -165,10 +165,10 @@ static uint32_t footprint_block_interface_crc32(starpu_data_handle handle)
 	return hash;
 }
 
-static int block_compare(void *interface_a, void *interface_b)
+static int block_compare(void *data_interface_a, void *data_interface_b)
 {
-	starpu_block_interface_t *block_a = interface_a;
-	starpu_block_interface_t *block_b = interface_b;
+	starpu_block_interface_t *block_a = data_interface_a;
+	starpu_block_interface_t *block_b = data_interface_b;
 
 	/* Two matricess are considered compatible if they have the same size */
 	return ((block_a->nx == block_b->nx)
@@ -274,7 +274,7 @@ size_t starpu_block_get_elemsize(starpu_data_handle handle)
 /* memory allocation/deallocation primitives for the BLOCK interface */
 
 /* returns the size of the allocated area */
-static ssize_t allocate_block_buffer_on_node(void *interface_, uint32_t dst_node)
+static ssize_t allocate_block_buffer_on_node(void *data_interface_, uint32_t dst_node)
 {
 	uintptr_t addr = 0;
 	unsigned fail = 0;
@@ -283,7 +283,7 @@ static ssize_t allocate_block_buffer_on_node(void *interface_, uint32_t dst_node
 #ifdef STARPU_USE_CUDA
 	cudaError_t status;
 #endif
-	starpu_block_interface_t *dst_block = interface_;
+	starpu_block_interface_t *dst_block = data_interface_;
 
 	uint32_t nx = dst_block->nx;
 	uint32_t ny = dst_block->ny;
@@ -350,9 +350,9 @@ static ssize_t allocate_block_buffer_on_node(void *interface_, uint32_t dst_node
 	return allocated_memory;
 }
 
-static void free_block_buffer_on_node(void *interface, uint32_t node)
+static void free_block_buffer_on_node(void *data_interface, uint32_t node)
 {
-	starpu_block_interface_t *block_interface = interface;
+	starpu_block_interface_t *block_interface = data_interface;
 
 #ifdef STARPU_USE_CUDA
 	cudaError_t status;

src/datawizard/interfaces/csr_interface.c

@@ -2,7 +2,7 @@
  *
  * Copyright (C) 2009, 2010  Université de Bordeaux 1
  * Copyright (C) 2010  Mehdi Juhoor <mjuhoor@gmail.com>
- * 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
@@ -57,11 +57,11 @@ static const struct starpu_data_copy_methods csr_copy_data_methods_s = {
 	.spu_to_spu = NULL
 };
 
-static void register_csr_handle(starpu_data_handle handle, uint32_t home_node, void *interface);
-static ssize_t allocate_csr_buffer_on_node(void *interface_, uint32_t dst_node);
-static void free_csr_buffer_on_node(void *interface, uint32_t node);
+static void register_csr_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface);
+static ssize_t allocate_csr_buffer_on_node(void *data_interface_, uint32_t dst_node);
+static void free_csr_buffer_on_node(void *data_interface, uint32_t node);
 static size_t csr_interface_get_size(starpu_data_handle handle);
-static int csr_compare(void *interface_a, void *interface_b);
+static int csr_compare(void *data_interface_a, void *data_interface_b);
 static uint32_t footprint_csr_interface_crc32(starpu_data_handle handle);
 
 static struct starpu_data_interface_ops_t interface_csr_ops = {
@@ -76,9 +76,9 @@ static struct starpu_data_interface_ops_t interface_csr_ops = {
 	.compare = csr_compare
 };
 
-static void register_csr_handle(starpu_data_handle handle, uint32_t home_node, void *interface)
+static void register_csr_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface)
 {
-	starpu_csr_interface_t *csr_interface = interface;
+	starpu_csr_interface_t *csr_interface = data_interface;
 
 	unsigned node;
 	for (node = 0; node < STARPU_MAXNODES; node++)
@@ -126,10 +126,10 @@ static uint32_t footprint_csr_interface_crc32(starpu_data_handle handle)
 	return _starpu_crc32_be(starpu_csr_get_nnz(handle), 0);
 }
 
-static int csr_compare(void *interface_a, void *interface_b)
+static int csr_compare(void *data_interface_a, void *data_interface_b)
 {
-	starpu_csr_interface_t *csr_a = interface_a;
-	starpu_csr_interface_t *csr_b = interface_b;
+	starpu_csr_interface_t *csr_a = data_interface_a;
+	starpu_csr_interface_t *csr_b = data_interface_b;
 
 	/* Two matricess are considered compatible if they have the same size */
 	return ((csr_a->nnz == csr_b->nnz)
@@ -225,14 +225,14 @@ static size_t csr_interface_get_size(starpu_data_handle handle)
 /* memory allocation/deallocation primitives for the BLAS interface */
 
 /* returns the size of the allocated area */
-static ssize_t allocate_csr_buffer_on_node(void *interface_, uint32_t dst_node)
+static ssize_t allocate_csr_buffer_on_node(void *data_interface_, uint32_t dst_node)
 {
 	uintptr_t addr_nzval;
 	uint32_t *addr_colind, *addr_rowptr;
 	ssize_t allocated_memory;
 
 	/* we need the 3 arrays to be allocated */
-	starpu_csr_interface_t *interface = interface_;
+	starpu_csr_interface_t *interface = data_interface_;
 
 	uint32_t nnz = interface->nnz;
 	uint32_t nrow = interface->nrow;
@@ -349,9 +349,9 @@ fail_nzval:
 	return -ENOMEM;
 }
 
-static void free_csr_buffer_on_node(void *interface, uint32_t node)
+static void free_csr_buffer_on_node(void *data_interface, uint32_t node)
 {
-	starpu_csr_interface_t *csr_interface = interface;	
+	starpu_csr_interface_t *csr_interface = data_interface;
 
 	starpu_node_kind kind = _starpu_get_node_kind(node);
 	switch(kind) {

src/datawizard/interfaces/data_interface.c

@@ -169,7 +169,7 @@ static starpu_data_handle _starpu_data_handle_allocate(struct starpu_data_interf
 }
 
 void starpu_data_register(starpu_data_handle *handleptr, uint32_t home_node,
-				void *interface,
+				void *data_interface,
 				struct starpu_data_interface_ops_t *ops)
 {
 	starpu_data_handle handle =
@@ -180,7 +180,7 @@ void starpu_data_register(starpu_data_handle *handleptr, uint32_t home_node,
 
 
 	/* fill the interface fields with the appropriate method */
-	ops->register_data_handle(handle, home_node, interface);
+	ops->register_data_handle(handle, home_node, data_interface);
 
 	_starpu_register_new_data(handle, home_node, 0);
 }

src/datawizard/interfaces/matrix_interface.c

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010  Université de Bordeaux 1
- * Copyright (C) 2010  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
  *
  * StarPU is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -62,15 +62,15 @@ static const struct starpu_data_copy_methods matrix_copy_data_methods_s = {
 	.spu_to_spu = NULL
 };
 
-static void register_matrix_handle(starpu_data_handle handle, uint32_t home_node, void *interface);
-static ssize_t allocate_matrix_buffer_on_node(void *interface_, uint32_t dst_node);
-static void free_matrix_buffer_on_node(void *interface, uint32_t node);
+static void register_matrix_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface);
+static ssize_t allocate_matrix_buffer_on_node(void *data_interface_, uint32_t dst_node);
+static void free_matrix_buffer_on_node(void *data_interface, uint32_t node);
 static size_t matrix_interface_get_size(starpu_data_handle handle);
 static uint32_t footprint_matrix_interface_crc32(starpu_data_handle handle);
-static int matrix_compare(void *interface_a, void *interface_b);
+static int matrix_compare(void *data_interface_a, void *data_interface_b);
 static void display_matrix_interface(starpu_data_handle handle, FILE *f);
 #ifdef STARPU_USE_GORDON
-static int convert_matrix_to_gordon(void *interface, uint64_t *ptr, gordon_strideSize_t *ss); 
+static int convert_matrix_to_gordon(void *data_interface, uint64_t *ptr, gordon_strideSize_t *ss); 
 #endif
 
 struct starpu_data_interface_ops_t _starpu_interface_matrix_ops = {
@@ -90,7 +90,7 @@ struct starpu_data_interface_ops_t _starpu_interface_matrix_ops = {
 };
 
 #ifdef STARPU_USE_GORDON
-static int convert_matrix_to_gordon(void *interface, uint64_t *ptr, gordon_strideSize_t *ss) 
+static int convert_matrix_to_gordon(void *data_interface, uint64_t *ptr, gordon_strideSize_t *ss) 
 {
 	size_t elemsize = GET_MATRIX_ELEMSIZE(interface);
 	uint32_t nx = STARPU_MATRIX_GET_NX(interface);
@@ -107,9 +107,9 @@ static int convert_matrix_to_gordon(void *interface, uint64_t *ptr, gordon_strid
 }
 #endif
 
-static void register_matrix_handle(starpu_data_handle handle, uint32_t home_node, void *interface)
+static void register_matrix_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface)
 {
-	starpu_matrix_interface_t *matrix_interface = interface;
+	starpu_matrix_interface_t *matrix_interface = data_interface;
 
 	unsigned node;
 	for (node = 0; node < STARPU_MAXNODES; node++)
@@ -159,10 +159,10 @@ static uint32_t footprint_matrix_interface_crc32(starpu_data_handle handle)
 	return _starpu_crc32_be(starpu_matrix_get_nx(handle), starpu_matrix_get_ny(handle));
 }
 
-static int matrix_compare(void *interface_a, void *interface_b)
+static int matrix_compare(void *data_interface_a, void *data_interface_b)
 {
-	starpu_matrix_interface_t *matrix_a = interface_a;
-	starpu_matrix_interface_t *matrix_b = interface_b;
+	starpu_matrix_interface_t *matrix_a = data_interface_a;
+	starpu_matrix_interface_t *matrix_b = data_interface_b;
 
 	/* Two matricess are considered compatible if they have the same size */
 	return ((matrix_a->nx == matrix_b->nx)
@@ -243,7 +243,7 @@ size_t starpu_matrix_get_elemsize(starpu_data_handle handle)
 /* memory allocation/deallocation primitives for the matrix interface */
 
 /* returns the size of the allocated area */
-static ssize_t allocate_matrix_buffer_on_node(void *interface_, uint32_t dst_node)
+static ssize_t allocate_matrix_buffer_on_node(void *data_interface_, uint32_t dst_node)
 {
 	uintptr_t addr = 0;
 	unsigned fail = 0;
@@ -253,7 +253,7 @@ static ssize_t allocate_matrix_buffer_on_node(void *interface_, uint32_t dst_nod
 	cudaError_t status;
 #endif
 
-	starpu_matrix_interface_t *interface = interface_;
+	starpu_matrix_interface_t *interface = data_interface_;
 
 	uint32_t nx = interface->nx;
 	uint32_t ny = interface->ny;
@@ -318,9 +318,9 @@ static ssize_t allocate_matrix_buffer_on_node(void *interface_, uint32_t dst_nod
 	return allocated_memory;
 }
 
-static void free_matrix_buffer_on_node(void *interface, uint32_t node)
+static void free_matrix_buffer_on_node(void *data_interface, uint32_t node)
 {
-	starpu_matrix_interface_t *matrix_interface = interface;
+	starpu_matrix_interface_t *matrix_interface = data_interface;
 
 #ifdef STARPU_USE_CUDA
 	cudaError_t status;

src/datawizard/interfaces/variable_interface.c

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010  Université de Bordeaux 1
- * Copyright (C) 2010  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
  *
  * StarPU is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -64,15 +64,15 @@ static const struct starpu_data_copy_methods variable_copy_data_methods_s = {
 	.spu_to_spu = NULL
 };
 
-static void register_variable_handle(starpu_data_handle handle, uint32_t home_node, void *interface);
-static ssize_t allocate_variable_buffer_on_node(void *interface_, uint32_t dst_node);
-static void free_variable_buffer_on_node(void *interface, uint32_t node);
+static void register_variable_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface);
+static ssize_t allocate_variable_buffer_on_node(void *data_interface_, uint32_t dst_node);
+static void free_variable_buffer_on_node(void *data_interface, uint32_t node);
 static size_t variable_interface_get_size(starpu_data_handle handle);
 static uint32_t footprint_variable_interface_crc32(starpu_data_handle handle);
-static int variable_compare(void *interface_a, void *interface_b);
+static int variable_compare(void *data_interface_a, void *data_interface_b);
 static void display_variable_interface(starpu_data_handle handle, FILE *f);
 #ifdef STARPU_USE_GORDON
-static int convert_variable_to_gordon(void *interface, uint64_t *ptr, gordon_strideSize_t *ss); 
+static int convert_variable_to_gordon(void *data_interface, uint64_t *ptr, gordon_strideSize_t *ss); 
 #endif
 
 static struct starpu_data_interface_ops_t interface_variable_ops = {
@@ -91,7 +91,7 @@ static struct starpu_data_interface_ops_t interface_variable_ops = {
 	.display = display_variable_interface
 };
 
-static void register_variable_handle(starpu_data_handle handle, uint32_t home_node, void *interface)
+static void register_variable_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface)
 {
 	unsigned node;
 	for (node = 0; node < STARPU_MAXNODES; node++)
@@ -100,18 +100,18 @@ static void register_variable_handle(starpu_data_handle handle, uint32_t home_no
 			starpu_data_get_interface_on_node(handle, node);
 
 		if (node == home_node) {
-			local_interface->ptr = STARPU_VARIABLE_GET_PTR(interface);
+			local_interface->ptr = STARPU_VARIABLE_GET_PTR(data_interface);
 		}
 		else {
 			local_interface->ptr = 0;
 		}
 
-		local_interface->elemsize = STARPU_VARIABLE_GET_ELEMSIZE(interface);
+		local_interface->elemsize = STARPU_VARIABLE_GET_ELEMSIZE(data_interface);
 	}
 }
 
 #ifdef STARPU_USE_GORDON
-int convert_variable_to_gordon(void *interface, uint64_t *ptr, gordon_strideSize_t *ss) 
+int convert_variable_to_gordon(void *data_interface, uint64_t *ptr, gordon_strideSize_t *ss) 
 {
 	*ptr = STARPU_VARIABLE_GET_PTR(interface);
 	(*ss).size = STARPU_VARIABLE_GET_ELEMSIZE(interface);
@@ -138,10 +138,10 @@ static uint32_t footprint_variable_interface_crc32(starpu_data_handle handle)
 	return _starpu_crc32_be(starpu_variable_get_elemsize(handle), 0);
 }
 
-static int variable_compare(void *interface_a, void *interface_b)
+static int variable_compare(void *data_interface_a, void *data_interface_b)
 {
-	starpu_variable_interface_t *variable_a = interface_a;
-	starpu_variable_interface_t *variable_b = interface_b;
+	starpu_variable_interface_t *variable_a = data_interface_a;
+	starpu_variable_interface_t *variable_b = data_interface_b;
 
 	/* Two variables are considered compatible if they have the same size */
 	return (variable_a->elemsize == variable_b->elemsize);
@@ -181,9 +181,9 @@ size_t starpu_variable_get_elemsize(starpu_data_handle handle)
 /* memory allocation/deallocation primitives for the variable interface */
 
 /* returns the size of the allocated area */
-static ssize_t allocate_variable_buffer_on_node(void *interface_, uint32_t dst_node)
+static ssize_t allocate_variable_buffer_on_node(void *data_interface_, uint32_t dst_node)
 {
-	starpu_variable_interface_t *interface = interface_;
+	starpu_variable_interface_t *interface = data_interface_;
 
 	unsigned fail = 0;
 	uintptr_t addr = 0;
@@ -244,21 +244,21 @@ static ssize_t allocate_variable_buffer_on_node(void *interface_, uint32_t dst_n
 	return allocated_memory;
 }
 
-static void free_variable_buffer_on_node(void *interface, uint32_t node)
+static void free_variable_buffer_on_node(void *data_interface, uint32_t node)
 {
 	starpu_node_kind kind = _starpu_get_node_kind(node);
 	switch(kind) {
 		case STARPU_CPU_RAM:
-			free((void*)STARPU_VARIABLE_GET_PTR(interface));
+			free((void*)STARPU_VARIABLE_GET_PTR(data_interface));
 			break;
 #ifdef STARPU_USE_CUDA
 		case STARPU_CUDA_RAM:
-			cudaFree((void*)STARPU_VARIABLE_GET_PTR(interface));
+			cudaFree((void*)STARPU_VARIABLE_GET_PTR(data_interface));
 			break;
 #endif
 #ifdef STARPU_USE_OPENCL
                 case STARPU_OPENCL_RAM:
-                        clReleaseMemObject((void*)STARPU_VARIABLE_GET_PTR(interface));
+                        clReleaseMemObject((void*)STARPU_VARIABLE_GET_PTR(data_interface));
                         break;
 #endif
 		default:

src/datawizard/interfaces/vector_interface.c

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2009, 2010  Université de Bordeaux 1
- * Copyright (C) 2010  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
  *
  * StarPU is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -64,15 +64,15 @@ static const struct starpu_data_copy_methods vector_copy_data_methods_s = {
 	.spu_to_spu = NULL
 };
 
-static void register_vector_handle(starpu_data_handle handle, uint32_t home_node, void *interface);
-static ssize_t allocate_vector_buffer_on_node(void *interface_, uint32_t dst_node);
-static void free_vector_buffer_on_node(void *interface, uint32_t node);
+static void register_vector_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface);
+static ssize_t allocate_vector_buffer_on_node(void *data_interface_, uint32_t dst_node);
+static void free_vector_buffer_on_node(void *data_interface, uint32_t node);
 static size_t vector_interface_get_size(starpu_data_handle handle);
 static uint32_t footprint_vector_interface_crc32(starpu_data_handle handle);
-static int vector_compare(void *interface_a, void *interface_b);
+static int vector_compare(void *data_interface_a, void *data_interface_b);
 static void display_vector_interface(starpu_data_handle handle, FILE *f);
 #ifdef STARPU_USE_GORDON
-static int convert_vector_to_gordon(void *interface, uint64_t *ptr, gordon_strideSize_t *ss); 
+static int convert_vector_to_gordon(void *data_interface, uint64_t *ptr, gordon_strideSize_t *ss); 
 #endif
 
 static struct starpu_data_interface_ops_t interface_vector_ops = {
@@ -91,9 +91,9 @@ static struct starpu_data_interface_ops_t interface_vector_ops = {
 	.display = display_vector_interface
 };
 
-static void register_vector_handle(starpu_data_handle handle, uint32_t home_node, void *interface)
+static void register_vector_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface)
 {
-	starpu_vector_interface_t *vector_interface = interface;
+	starpu_vector_interface_t *vector_interface = data_interface;
 
 	unsigned node;
 	for (node = 0; node < STARPU_MAXNODES; node++)
@@ -118,7 +118,7 @@ static void register_vector_handle(starpu_data_handle handle, uint32_t home_node
 }
 
 #ifdef STARPU_USE_GORDON
-int convert_vector_to_gordon(void *interface, uint64_t *ptr, gordon_strideSize_t *ss) 
+int convert_vector_to_gordon(void *data_interface, uint64_t *ptr, gordon_strideSize_t *ss) 
 {
 	starpu_vector_interface_t *vector_interface = interface;
 	
@@ -150,10 +150,10 @@ static uint32_t footprint_vector_interface_crc32(starpu_data_handle handle)
 	return _starpu_crc32_be(starpu_vector_get_nx(handle), 0);
 }
 
-static int vector_compare(void *interface_a, void *interface_b)
+static int vector_compare(void *data_interface_a, void *data_interface_b)
 {
-	starpu_vector_interface_t *vector_a = interface_a;
-	starpu_vector_interface_t *vector_b = interface_b;
+	starpu_vector_interface_t *vector_a = data_interface_a;
+	starpu_vector_interface_t *vector_b = data_interface_b;
 
 	/* Two vectors are considered compatible if they have the same size */
 	return ((vector_a->nx == vector_b->nx)
@@ -212,9 +212,9 @@ size_t starpu_vector_get_elemsize(starpu_data_handle handle)
 /* memory allocation/deallocation primitives for the vector interface */
 
 /* returns the size of the allocated area */
-static ssize_t allocate_vector_buffer_on_node(void *interface_, uint32_t dst_node)
+static ssize_t allocate_vector_buffer_on_node(void *data_interface_, uint32_t dst_node)
 {
-	starpu_vector_interface_t *interface = interface_;
+	starpu_vector_interface_t *interface = data_interface_;
 
 	unsigned fail = 0;
 	uintptr_t addr = 0;
@@ -278,9 +278,9 @@ static ssize_t allocate_vector_buffer_on_node(void *interface_, uint32_t dst_nod
 	return allocated_memory;
 }
 
-static void free_vector_buffer_on_node(void *interface, uint32_t node)
+static void free_vector_buffer_on_node(void *data_interface, uint32_t node)
 {
-	starpu_vector_interface_t *vector_interface = interface;
+	starpu_vector_interface_t *vector_interface = data_interface;
 
 	starpu_node_kind kind = _starpu_get_node_kind(node);
 	switch(kind) {

src/datawizard/interfaces/void_interface.c

@@ -1,6 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010  Université de Bordeaux 1
+ * Copyright (C) 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
@@ -54,12 +55,12 @@ static const struct starpu_data_copy_methods void_copy_data_methods_s = {
 	.spu_to_spu = dummy_copy
 };
 
-static void register_void_handle(starpu_data_handle handle, uint32_t home_node, void *interface);
-static ssize_t allocate_void_buffer_on_node(void *interface_, uint32_t dst_node);
-static void free_void_buffer_on_node(void *interface, uint32_t node);
+static void register_void_handle(starpu_data_handle handle, uint32_t home_node, void *data_interface);
+static ssize_t allocate_void_buffer_on_node(void *data_interface_, uint32_t dst_node);
+static void free_void_buffer_on_node(void *data_interface, uint32_t node);
 static size_t void_interface_get_size(starpu_data_handle handle);
 static uint32_t footprint_void_interface_crc32(starpu_data_handle handle);
-static int void_compare(void *interface_a, void *interface_b);
+static int void_compare(void *data_interface_a, void *data_interface_b);
 static void display_void_interface(starpu_data_handle handle, FILE *f);
 
 static struct starpu_data_interface_ops_t interface_void_ops = {
@@ -77,7 +78,7 @@ static struct starpu_data_interface_ops_t interface_void_ops = {
 
 static void register_void_handle(starpu_data_handle handle __attribute__((unused)),
 				uint32_t home_node __attribute__((unused)),
-				void *interface __attribute__((unused)))
+				void *data_interface __attribute__((unused)))
 {
 	/* Since there is no real data to register, we don't do anything */
 }
@@ -94,8 +95,8 @@ static uint32_t footprint_void_interface_crc32(starpu_data_handle handle __attri
 	return 0;
 }
 
-static int void_compare(void *interface_a __attribute__((unused)),
-			void *interface_b __attribute__((unused)))
+static int void_compare(void *data_interface_a __attribute__((unused)),
+			void *data_interface_b __attribute__((unused)))
 {
 	/* There is no allocation required, and therefore nothing to cache
 	 * anyway. */
@@ -115,14 +116,14 @@ static size_t void_interface_get_size(starpu_data_handle handle __attribute__((u
 /* memory allocation/deallocation primitives for the void interface */
 
 /* returns the size of the allocated area */
-static ssize_t allocate_void_buffer_on_node(void *interface __attribute__((unused)),
+static ssize_t allocate_void_buffer_on_node(void *data_interface __attribute__((unused)),
 					uint32_t dst_node __attribute__((unused)))
 {
 	/* Successfuly allocated 0 bytes */
 	return 0;
 }
 
-static void free_void_buffer_on_node(void *interface __attribute__((unused)) ,
+static void free_void_buffer_on_node(void *data_interface __attribute__((unused)) ,
 					uint32_t node __attribute__((unused)))
 {
 	/* There is no buffer actually */

src/datawizard/memalloc.c

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