Rename all starpu_monitor_foo functions into starpu_register_foo.

doc/starpu.texi

@@ -527,7 +527,7 @@ modified by a task, and StarPU makes sure that when a computational kernel start
 somewhere (eg. on a GPU), its data are available locally.
 
 Before submitting those tasks, the programmer first needs to declare the
-different pieces of data to StarPU using the @code{starpu_monitor_*_data}
+different pieces of data to StarPU using the @code{starpu_register_*_data}
 functions. To ease the development of applications for StarPU, it is possible
 to describe multiple types of data layout. A type of data layout is called an
 @b{interface}. By default, there are different interfaces available in StarPU:
@@ -539,7 +539,7 @@ The following lines show how to declare an array of @code{n} elements of type
 float tab[n];
 
 starpu_data_handle tab_handle;
-starpu_monitor_vector_data(&tab_handle, 0, tab, n, sizeof(float));
+starpu_register_vector_data(&tab_handle, 0, tab, n, sizeof(float));
 @end example
 
 The first argument, called the @b{data handle} is an opaque pointer which

examples/cholesky/dw_cholesky.c

@@ -233,7 +233,7 @@ void dw_cholesky(float *matA, unsigned size, unsigned ld, unsigned nblocks)
 
 	/* monitor and partition the A matrix into blocks :
 	 * one block is now determined by 2 unsigned (i,j) */
-	starpu_monitor_blas_data(&dataA, 0, (uintptr_t)matA, ld, size, size, sizeof(float));
+	starpu_register_blas_data(&dataA, 0, (uintptr_t)matA, ld, size, size, sizeof(float));
 
 	starpu_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;

examples/cholesky/dw_cholesky_no_stride.c

@@ -308,7 +308,7 @@ int main(int argc, char **argv)
 	for (x = 0; x < nblocks; x++)
 	{
 		if (x <= y) {
-			starpu_monitor_blas_data(&A_state[y][x], 0, (uintptr_t)A[y][x], 
+			starpu_register_blas_data(&A_state[y][x], 0, (uintptr_t)A[y][x], 
 				BLOCKSIZE, BLOCKSIZE, BLOCKSIZE, sizeof(float));
 		}
 	}

examples/heat/dw_factolu.c

@@ -715,7 +715,7 @@ void dw_factoLU(float *matA, unsigned size,
 
 	/* monitor and partition the A matrix into blocks :
 	 * one block is now determined by 2 unsigned (i,j) */
-	starpu_monitor_blas_data(&dataA, 0, (uintptr_t)matA, ld, 
+	starpu_register_blas_data(&dataA, 0, (uintptr_t)matA, ld, 
 			size, size, sizeof(float));
 
 	starpu_filter f;

examples/heat/dw_factolu_tag.c

@@ -264,7 +264,7 @@ void dw_factoLU_tag(float *matA, unsigned size, unsigned ld, unsigned nblocks)
 
 	/* monitor and partition the A matrix into blocks :
 	 * one block is now determined by 2 unsigned (i,j) */
-	starpu_monitor_blas_data(&dataA, 0, (uintptr_t)matA, ld, size, size, sizeof(float));
+	starpu_register_blas_data(&dataA, 0, (uintptr_t)matA, ld, size, size, sizeof(float));
 
 	starpu_filter f;
 		f.filter_func = starpu_vertical_block_filter_func;

examples/heat/dw_sparse_cg.c

@@ -368,10 +368,10 @@ void conjugate_gradient(float *nzvalA, float *vecb, float *vecx, uint32_t nnz,
 	starpu_data_handle ds_vecr, ds_vecd, ds_vecq; 
 
 	/* first the user-allocated data */
-	starpu_monitor_csr_data(&ds_matrixA, 0, nnz, nrow, 
+	starpu_register_csr_data(&ds_matrixA, 0, nnz, nrow, 
 			(uintptr_t)nzvalA, colind, rowptr, 0, sizeof(float));
-	starpu_monitor_vector_data(&ds_vecx, 0, (uintptr_t)vecx, nrow, sizeof(float));
-	starpu_monitor_vector_data(&ds_vecb, 0, (uintptr_t)vecb, nrow, sizeof(float));
+	starpu_register_vector_data(&ds_vecx, 0, (uintptr_t)vecx, nrow, sizeof(float));
+	starpu_register_vector_data(&ds_vecb, 0, (uintptr_t)vecb, nrow, sizeof(float));
 
 	/* then allocate the algorithm intern data */
 	float *ptr_vecr, *ptr_vecd, *ptr_vecq;
@@ -391,9 +391,9 @@ void conjugate_gradient(float *nzvalA, float *vecb, float *vecx, uint32_t nnz,
 	printf("nrow = %d \n", nrow);
 
 	/* and declare them as well */
-	starpu_monitor_vector_data(&ds_vecr, 0, (uintptr_t)ptr_vecr, nrow, sizeof(float));
-	starpu_monitor_vector_data(&ds_vecd, 0, (uintptr_t)ptr_vecd, nrow, sizeof(float));
-	starpu_monitor_vector_data(&ds_vecq, 0, (uintptr_t)ptr_vecq, nrow, sizeof(float));
+	starpu_register_vector_data(&ds_vecr, 0, (uintptr_t)ptr_vecr, nrow, sizeof(float));
+	starpu_register_vector_data(&ds_vecd, 0, (uintptr_t)ptr_vecd, nrow, sizeof(float));
+	starpu_register_vector_data(&ds_vecq, 0, (uintptr_t)ptr_vecq, nrow, sizeof(float));
 
 	/* we now have the complete problem */
 	struct cg_problem problem;

examples/incrementer/incrementer.c

@@ -100,10 +100,10 @@ void initialize_cuda(void)
 
 void init_data(void)
 {
-	starpu_monitor_vector_data(&my_float_state, 0 /* home node */,
+	starpu_register_vector_data(&my_float_state, 0 /* home node */,
 			(uintptr_t)&my_lovely_float, 3, sizeof(float));
 
-	starpu_monitor_vector_data(&unity_state, 0 /* home node */,
+	starpu_register_vector_data(&unity_state, 0 /* home node */,
 			(uintptr_t)&unity, 3, sizeof(float));
 }
 

examples/incrementer/incrementer_runtime.c

@@ -60,7 +60,7 @@ int main(int argc, char **argv)
 	float float_array[3] __attribute__ ((aligned (16))) = { 0.0f, 0.0f, 0.0f}; 
 
 	starpu_data_handle float_array_handle;
-	starpu_monitor_vector_data(&float_array_handle, 0 /* home node */,
+	starpu_register_vector_data(&float_array_handle, 0 /* home node */,
 			(uintptr_t)&float_array, 3, sizeof(float));
 
 	starpu_codelet cl =

examples/mult/dw_mult.c

@@ -228,11 +228,11 @@ static void partition_mult_data(void)
 {
 	gettimeofday(&start, NULL);
 
-	starpu_monitor_blas_data(&A_handle, 0, (uintptr_t)A, 
+	starpu_register_blas_data(&A_handle, 0, (uintptr_t)A, 
 		ydim, ydim, zdim, sizeof(float));
-	starpu_monitor_blas_data(&B_handle, 0, (uintptr_t)B, 
+	starpu_register_blas_data(&B_handle, 0, (uintptr_t)B, 
 		zdim, zdim, xdim, sizeof(float));
-	starpu_monitor_blas_data(&C_handle, 0, (uintptr_t)C, 
+	starpu_register_blas_data(&C_handle, 0, (uintptr_t)C, 
 		ydim, ydim, xdim, sizeof(float));
 
 	conf.k = zdim;

examples/mult/dw_mult_no_stride.c

@@ -248,7 +248,7 @@ static void init_problem_data(void)
 	{
 		for (z = 0; z < nslicesz; z++)
 		{
-			starpu_monitor_blas_data(&A_state[y][z], 0, (uintptr_t)A[y][z], 
+			starpu_register_blas_data(&A_state[y][z], 0, (uintptr_t)A[y][z], 
 				BLOCKSIZEY, BLOCKSIZEY, BLOCKSIZEZ, sizeof(float));
 		}
 	}
@@ -257,7 +257,7 @@ static void init_problem_data(void)
 	{
 		for (x = 0; x < nslicesx; x++)
 		{
-			starpu_monitor_blas_data(&B_state[z][x], 0, (uintptr_t)B[z][x], 
+			starpu_register_blas_data(&B_state[z][x], 0, (uintptr_t)B[z][x], 
 				BLOCKSIZEZ, BLOCKSIZEZ, BLOCKSIZEX, sizeof(float));
 		}
 	}
@@ -266,7 +266,7 @@ static void init_problem_data(void)
 	{
 		for (x = 0; x < nslicesx; x++)
 		{
-			starpu_monitor_blas_data(&C_state[y][x], 0, (uintptr_t)C[y][x], 
+			starpu_register_blas_data(&C_state[y][x], 0, (uintptr_t)C[y][x], 
 				BLOCKSIZEY, BLOCKSIZEY, BLOCKSIZEX, sizeof(float));
 		}
 	}

examples/mult/dw_mult_no_stride_no_tag.c

@@ -246,7 +246,7 @@ static void init_problem_data(void)
 	{
 		for (z = 0; z < nslicesz; z++)
 		{
-			starpu_monitor_blas_data(&A_state[y][z], 0, (uintptr_t)A[y][z], 
+			starpu_register_blas_data(&A_state[y][z], 0, (uintptr_t)A[y][z], 
 				BLOCKSIZEY, BLOCKSIZEY, BLOCKSIZEZ, sizeof(float));
 		}
 	}
@@ -255,7 +255,7 @@ static void init_problem_data(void)
 	{
 		for (x = 0; x < nslicesx; x++)
 		{
-			starpu_monitor_blas_data(&B_state[z][x], 0, (uintptr_t)B[z][x], 
+			starpu_register_blas_data(&B_state[z][x], 0, (uintptr_t)B[z][x], 
 				BLOCKSIZEZ, BLOCKSIZEZ, BLOCKSIZEX, sizeof(float));
 		}
 	}
@@ -264,7 +264,7 @@ static void init_problem_data(void)
 	{
 		for (x = 0; x < nslicesx; x++)
 		{
-			starpu_monitor_blas_data(&C_state[y][x], 0, (uintptr_t)C[y][x], 
+			starpu_register_blas_data(&C_state[y][x], 0, (uintptr_t)C[y][x], 
 				BLOCKSIZEY, BLOCKSIZEY, BLOCKSIZEX, sizeof(float));
 		}
 	}

examples/pastix-wrappers/starpu-blas-wrapper.c

@@ -184,13 +184,13 @@ void STARPU_MONITOR_DATA(unsigned ncols)
 
 void STARPU_MONITOR_CBLK(unsigned col, float *data, unsigned stride, unsigned width)
 {
-	//void starpu_monitor_blas_data(struct starpu_data_state_t *state, uint32_t home_node,
+	//void starpu_register_blas_data(struct starpu_data_state_t *state, uint32_t home_node,
         //                uintptr_t ptr, uint32_t ld, uint32_t nx,
         //                uint32_t ny, size_t elemsize);
 
 	//fprintf(stderr, "col %d data %p stride %d width %d\n", col, data, stride, width);
 
-	starpu_monitor_blas_data(&cblktab[col], 0 /* home */,
+	starpu_register_blas_data(&cblktab[col], 0 /* home */,
 			(uintptr_t) data, stride, stride, width, sizeof(float));
 	
 }
@@ -225,8 +225,8 @@ void allocate_maxbloktab_on_cublas(starpu_data_interface_t *descr __attribute__(
 
 void STARPU_DECLARE_WORK_BLOCKS(float *maxbloktab1, float *maxbloktab2, unsigned solv_coefmax)
 {
-	starpu_monitor_vector_data(&work_block_1, 0 /* home */, (uintptr_t)maxbloktab1, solv_coefmax, sizeof(float));
-	starpu_monitor_vector_data(&work_block_2, 0 /* home */, (uintptr_t)maxbloktab2, solv_coefmax, sizeof(float));
+	starpu_register_vector_data(&work_block_1, 0 /* home */, (uintptr_t)maxbloktab1, solv_coefmax, sizeof(float));
+	starpu_register_vector_data(&work_block_2, 0 /* home */, (uintptr_t)maxbloktab2, solv_coefmax, sizeof(float));
 
 	starpu_codelet cl;
 	job_t j;
@@ -584,23 +584,23 @@ void STARPU_SGEMM (const char *transa, const char *transb, const int m,
 
 	if (toupper(*transa) == 'N')
 	{
-		starpu_monitor_blas_data(&A_state, 0, (uintptr_t)A, lda, m, k, sizeof(float));
+		starpu_register_blas_data(&A_state, 0, (uintptr_t)A, lda, m, k, sizeof(float));
 	}
 	else 
 	{
-		starpu_monitor_blas_data(&A_state, 0, (uintptr_t)A, lda, k, m, sizeof(float));
+		starpu_register_blas_data(&A_state, 0, (uintptr_t)A, lda, k, m, sizeof(float));
 	}
 
 	if (toupper(*transb) == 'N')
 	{
-		starpu_monitor_blas_data(&B_state, 0, (uintptr_t)B, ldb, k, n, sizeof(float));
+		starpu_register_blas_data(&B_state, 0, (uintptr_t)B, ldb, k, n, sizeof(float));
 	}
 	else 
 	{	
-		starpu_monitor_blas_data(&B_state, 0, (uintptr_t)B, ldb, n, k, sizeof(float));
+		starpu_register_blas_data(&B_state, 0, (uintptr_t)B, ldb, n, k, sizeof(float));
 	}
 
-	starpu_monitor_blas_data(&C_state, 0, (uintptr_t)C, ldc, m, n, sizeof(float));
+	starpu_register_blas_data(&C_state, 0, (uintptr_t)C, ldc, m, n, sizeof(float));
 
 	/* initialize codelet */
 	cl.where = CUBLAS;

examples/spmv/dw_block_spmv.c

@@ -43,7 +43,7 @@ void create_data(void)
 	bcsr_matrix = mm_file_to_bcsr(inputfile, c, r);
 
 	/* declare the corresponding block CSR to the runtime */
-	starpu_monitor_bcsr_data(&sparse_matrix, 0, bcsr_matrix->nnz_blocks, bcsr_matrix->nrows_blocks,
+	starpu_register_bcsr_data(&sparse_matrix, 0, bcsr_matrix->nnz_blocks, bcsr_matrix->nrows_blocks,
 	                (uintptr_t)bcsr_matrix->val, bcsr_matrix->colind, bcsr_matrix->rowptr, 
 			0, bcsr_matrix->r, bcsr_matrix->c, sizeof(float));
 
@@ -65,8 +65,8 @@ void create_data(void)
 		vector_out_ptr[ind] = 0.0f;
 	}
 
-	starpu_monitor_vector_data(&vector_in, 0, (uintptr_t)vector_in_ptr, size, sizeof(float));
-	starpu_monitor_vector_data(&vector_out, 0, (uintptr_t)vector_out_ptr, size, sizeof(float));
+	starpu_register_vector_data(&vector_in, 0, (uintptr_t)vector_in_ptr, size, sizeof(float));
+	starpu_register_vector_data(&vector_out, 0, (uintptr_t)vector_out_ptr, size, sizeof(float));
 }
 
 void init_problem_callback(void *arg)

examples/spmv/dw_spmv.c

@@ -203,7 +203,7 @@ void create_data(void)
 
 	rowptr[size] = nnz;
 	
-	starpu_monitor_csr_data(&sparse_matrix, 0, nnz, size, (uintptr_t)nzval, colind, rowptr, 0, sizeof(float));
+	starpu_register_csr_data(&sparse_matrix, 0, nnz, size, (uintptr_t)nzval, colind, rowptr, 0, sizeof(float));
 
 	sparse_matrix_nzval = nzval;
 	sparse_matrix_colind = colind;
@@ -225,8 +225,8 @@ void create_data(void)
 		outvec[ind] = 0.0f;
 	}
 
-	starpu_monitor_vector_data(&vector_in, 0, (uintptr_t)invec, size, sizeof(float));
-	starpu_monitor_vector_data(&vector_out, 0, (uintptr_t)outvec, size, sizeof(float));
+	starpu_register_vector_data(&vector_in, 0, (uintptr_t)invec, size, sizeof(float));
+	starpu_register_vector_data(&vector_out, 0, (uintptr_t)outvec, size, sizeof(float));
 
 	vector_in_ptr = invec;
 	vector_out_ptr = outvec;

examples/strassen/strassen.c

@@ -31,7 +31,7 @@ static starpu_data_handle create_tmp_matrix(starpu_data_handle M)
 	data = malloc(nx*ny*sizeof(float));
 	STARPU_ASSERT(data);
 
-	starpu_monitor_blas_data(&state, 0, (uintptr_t)data, nx, nx, ny, sizeof(float));
+	starpu_register_blas_data(&state, 0, (uintptr_t)data, nx, nx, ny, sizeof(float));
 	
 	return state;
 }

examples/strassen/test_strassen.c

@@ -156,11 +156,11 @@ void init_problem(void)
 		}
 	}
 
-	starpu_monitor_blas_data(&A_state, 0, (uintptr_t)A, 
+	starpu_register_blas_data(&A_state, 0, (uintptr_t)A, 
 		dim, dim, dim, sizeof(float));
-	starpu_monitor_blas_data(&B_state, 0, (uintptr_t)B, 
+	starpu_register_blas_data(&B_state, 0, (uintptr_t)B, 
 		dim, dim, dim, sizeof(float));
-	starpu_monitor_blas_data(&C_state, 0, (uintptr_t)C, 
+	starpu_register_blas_data(&C_state, 0, (uintptr_t)C, 
 		dim, dim, dim, sizeof(float));
 
 	gettimeofday(&start, NULL);

examples/strassen2/strassen2.c

@@ -176,7 +176,7 @@ starpu_data_handle allocate_tmp_matrix(unsigned size, unsigned reclevel)
 	memset(buffer, 0, size*size*sizeof(float));
 
 
-	starpu_monitor_blas_data(data, 0, (uintptr_t)buffer, size, size, size, sizeof(float));
+	starpu_register_blas_data(data, 0, (uintptr_t)buffer, size, size, size, sizeof(float));
 
 	/* we construct a starpu_filter tree of depth reclevel */
 	unsigned rec;
@@ -793,9 +793,9 @@ int main(int argc, char **argv)
 	memset(B, 0, size*size*sizeof(float));
 	memset(C, 0, size*size*sizeof(float));
 
-	starpu_monitor_blas_data(&data_A, 0, (uintptr_t)A, size, size, size, sizeof(float));
-	starpu_monitor_blas_data(&data_B, 0, (uintptr_t)B, size, size, size, sizeof(float));
-	starpu_monitor_blas_data(&data_C, 0, (uintptr_t)C, size, size, size, sizeof(float));
+	starpu_register_blas_data(&data_A, 0, (uintptr_t)A, size, size, size, sizeof(float));
+	starpu_register_blas_data(&data_B, 0, (uintptr_t)B, size, size, size, sizeof(float));
+	starpu_register_blas_data(&data_C, 0, (uintptr_t)C, size, size, size, sizeof(float));
 
 	unsigned rec;
 	for (rec = 0; rec < reclevel; rec++)

include/starpu-data-interfaces.h

@@ -29,7 +29,7 @@ typedef struct starpu_blas_interface_s {
 	size_t elemsize;
 } starpu_blas_interface_t;
 
-void starpu_monitor_blas_data(starpu_data_handle *handle, uint32_t home_node,
+void starpu_register_blas_data(starpu_data_handle *handle, uint32_t home_node,
                         uintptr_t ptr, uint32_t ld, uint32_t nx,
                         uint32_t ny, size_t elemsize);
 uint32_t starpu_get_blas_nx(starpu_data_handle handle);
@@ -44,7 +44,7 @@ typedef struct starpu_vector_interface_s {
 	size_t elemsize;
 } starpu_vector_interface_t;
 
-void starpu_monitor_vector_data(starpu_data_handle *handle, uint32_t home_node,
+void starpu_register_vector_data(starpu_data_handle *handle, uint32_t home_node,
                         uintptr_t ptr, uint32_t nx, size_t elemsize);
 uint32_t starpu_get_vector_nx(starpu_data_handle handle);
 uintptr_t starpu_get_vector_local_ptr(starpu_data_handle handle);
@@ -64,7 +64,7 @@ typedef struct starpu_csr_interface_s {
 	size_t elemsize;
 } starpu_csr_interface_t;
 
-void starpu_monitor_csr_data(starpu_data_handle *handle, uint32_t home_node, uint32_t nnz, uint32_t nrow,
+void starpu_register_csr_data(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);
 uint32_t starpu_get_csr_nnz(starpu_data_handle handle);
 uint32_t starpu_get_csr_nrow(starpu_data_handle handle);
@@ -108,7 +108,7 @@ typedef struct starpu_bcsr_interface_s {
 	size_t elemsize;
 } starpu_bcsr_interface_t;
 
-void starpu_monitor_bcsr_data(starpu_data_handle *handle, uint32_t home_node, uint32_t nnz, uint32_t nrow,
+void starpu_register_bcsr_data(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);
 
 

src/datawizard/hierarchy.c

@@ -40,7 +40,7 @@ void starpu_delete_data(data_state *state)
 #endif
 }
 
-void monitor_new_data(data_state *state, uint32_t home_node, uint32_t wb_mask)
+void register_new_data(data_state *state, uint32_t home_node, uint32_t wb_mask)
 {
 	STARPU_ASSERT(state);
 

src/datawizard/hierarchy.h

@@ -23,6 +23,6 @@
 
 #include <starpu.h>
 
-void monitor_new_data(struct starpu_data_state_t *state, uint32_t home_node, uint32_t wb_mask);
+void register_new_data(struct starpu_data_state_t *state, uint32_t home_node, uint32_t wb_mask);
 
 #endif

src/datawizard/interfaces/bcsr_interface.c

@@ -46,7 +46,7 @@ struct data_interface_ops_t interface_bcsr_ops = {
 	.footprint = footprint_bcsr_interface_crc32
 };
 
-void starpu_monitor_bcsr_data(struct starpu_data_state_t **handle, uint32_t home_node,
+void starpu_register_bcsr_data(struct starpu_data_state_t **handle, uint32_t home_node,
 		uint32_t nnz, uint32_t nrow, uintptr_t nzval, uint32_t *colind, uint32_t *rowptr, uint32_t firstentry,  uint32_t r, uint32_t c, size_t elemsize)
 {
 	struct starpu_data_state_t *state = calloc(1, sizeof(struct starpu_data_state_t));
@@ -81,7 +81,7 @@ void starpu_monitor_bcsr_data(struct starpu_data_state_t **handle, uint32_t home
 
 	state->ops = &interface_bcsr_ops;
 
-	monitor_new_data(state, home_node, 0);
+	register_new_data(state, home_node, 0);
 }
 
 static inline uint32_t footprint_bcsr_interface_generic(uint32_t (*hash_func)(uint32_t input, uint32_t hstate), data_state *state, uint32_t hstate)

src/datawizard/interfaces/blas_interface.c

@@ -74,7 +74,7 @@ int convert_blas_to_gordon(starpu_data_interface_t *interface, uint64_t *ptr, go
 #endif
 
 /* declare a new data with the BLAS interface */
-void starpu_monitor_blas_data(struct starpu_data_state_t **handle, uint32_t home_node,
+void starpu_register_blas_data(struct starpu_data_state_t **handle, uint32_t home_node,
 			uintptr_t ptr, uint32_t ld, uint32_t nx,
 			uint32_t ny, size_t elemsize)
 {
@@ -105,7 +105,7 @@ void starpu_monitor_blas_data(struct starpu_data_state_t **handle, uint32_t home
 
 	state->ops = &interface_blas_ops;
 
-	monitor_new_data(state, home_node, 0);
+	register_new_data(state, home_node, 0);
 }
 
 static inline uint32_t footprint_blas_interface_generic(uint32_t (*hash_func)(uint32_t input, uint32_t hstate), data_state *state, uint32_t hstate)

src/datawizard/interfaces/csr_interface.c

@@ -45,7 +45,7 @@ struct data_interface_ops_t interface_csr_ops = {
 };
 
 /* declare a new data with the BLAS interface */
-void starpu_monitor_csr_data(struct starpu_data_state_t **handle, uint32_t home_node,
+void starpu_register_csr_data(struct starpu_data_state_t **handle, uint32_t home_node,
 		uint32_t nnz, uint32_t nrow, uintptr_t nzval, uint32_t *colind, uint32_t *rowptr, uint32_t firstentry, size_t elemsize)
 {
 	struct starpu_data_state_t *state = calloc(1, sizeof(struct starpu_data_state_t));
@@ -79,7 +79,7 @@ void starpu_monitor_csr_data(struct starpu_data_state_t **handle, uint32_t home_
 
 	state->ops = &interface_csr_ops;
 
-	monitor_new_data(state, home_node, 0);
+	register_new_data(state, home_node, 0);
 }
 
 static inline uint32_t footprint_csr_interface_generic(uint32_t (*hash_func)(uint32_t input, uint32_t hstate), data_state *state, uint32_t hstate)

src/datawizard/interfaces/vector_interface.c

@@ -66,7 +66,7 @@ int convert_vector_to_gordon(starpu_data_interface_t *interface, uint64_t *ptr,
 #endif
 
 /* declare a new data with the BLAS interface */
-void starpu_monitor_vector_data(struct starpu_data_state_t **handle, uint32_t home_node,
+void starpu_register_vector_data(struct starpu_data_state_t **handle, uint32_t home_node,
                         uintptr_t ptr, uint32_t nx, size_t elemsize)
 {
 	struct starpu_data_state_t *state = calloc(1, sizeof(struct starpu_data_state_t));
@@ -93,7 +93,7 @@ void starpu_monitor_vector_data(struct starpu_data_state_t **handle, uint32_t ho
 
 	state->ops = &interface_vector_ops;
 
-	monitor_new_data(state, home_node, 0);
+	register_new_data(state, home_node, 0);
 }
 
 

tests/microbenchs/sync_and_notify_data.c

@@ -80,7 +80,7 @@ int main(int argc, char **argv)
 	fprintf(stderr, "kernel incA %d incC %d elf %d\n", kernel_incA_id, kernel_incC_id, elf_id);
 #endif
 	
-	starpu_monitor_vector_data(&v_handle, 0, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
+	starpu_register_vector_data(&v_handle, 0, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
 
 	unsigned iter;
 	for (iter = 0; iter < K; iter++)