Deprecate starpu_free() and add new function starpu_free_noflag() to specify allocated size

ChangeLog

@@ -60,6 +60,8 @@ Small features:
   * FxT is now automatically enabled at build-time, but not enabled at
     run-time by default any more, STARPU_FXT_TRACE needs to be explicitly set to
     1 to enable FxT trace recording.
+  * Deprecate starpu_free() and add new function starpu_free_noflag()
+    to specify allocated size.
 
 Small changes:
   * Add a synthetic energy efficiency testcase.

examples/axpy/axpy.c

@@ -231,8 +231,8 @@ enodev:
 	if (exit_value != 77)
 		exit_value = check();
 
-	starpu_free((void *)_vec_x);
-	starpu_free((void *)_vec_y);
+	starpu_free_noflag((void *)_vec_x, N*sizeof(TYPE));
+	starpu_free_noflag((void *)_vec_y, N*sizeof(TYPE));
 
 #ifdef STARPU_USE_OPENCL
         ret = starpu_opencl_unload_opencl(&opencl_program);

examples/cg/cg.c

@@ -125,12 +125,12 @@ static void generate_random_problem(void)
 
 static void free_data(void)
 {
-	starpu_free(A);
-	starpu_free(b);
-	starpu_free(x);
-	starpu_free(r);
-	starpu_free(d);
-	starpu_free(q);
+	starpu_free_noflag(A, n*n*sizeof(TYPE));
+	starpu_free_noflag(b, n*sizeof(TYPE));
+	starpu_free_noflag(x, n*sizeof(TYPE));
+	starpu_free_noflag(r, n*sizeof(TYPE));
+	starpu_free_noflag(d, n*sizeof(TYPE));
+	starpu_free_noflag(q, n*sizeof(TYPE));
 }
 
 static void register_data(void)

examples/heat/dw_factolu.c

@@ -797,12 +797,12 @@ void initialize_system(float **A, float **B, unsigned dim, unsigned pinned)
 	}
 }
 
-void free_system(float *A, float *B, unsigned pinned)
+void free_system(float *A, float *B, unsigned dim, unsigned pinned)
 {
 	if (pinned)
 	{
-		starpu_free(A);
-		starpu_free(B);
+		starpu_free_noflag(A, (size_t)dim*dim*sizeof(float));
+		starpu_free_noflag(B, (size_t)dim*sizeof(float));
 	}
 	else
 	{

examples/heat/heat.c

@@ -799,7 +799,7 @@ int main(int argc, char **argv)
 
 		starpu_cublas_shutdown();
 		starpu_shutdown();
-		free_system(A, B, pinned);
+		free_system(A, B, newsize, pinned);
 	}
 
 #ifdef STARPU_OPENGL_RENDER

examples/heat/heat.h

@@ -61,7 +61,7 @@ extern void dw_factoLU(float *matA, unsigned size, unsigned ld, unsigned nblocks
 extern void dw_factoLU_tag(float *matA, unsigned size, unsigned ld, unsigned nblocks, unsigned no_prio);
 extern void dw_factoLU_grain(float *matA, unsigned size, unsigned ld, unsigned nblocks, unsigned nbigblocks);
 extern void initialize_system(float **A, float **B, unsigned dim, unsigned pinned);
-extern void free_system(float *A, float *B, unsigned pinned);
+extern void free_system(float *A, float *B, unsigned dim, unsigned pinned);
 
 void display_stat_heat(void);
 

examples/lu/lu_example.c

@@ -154,7 +154,7 @@ void copy_blocks_into_matrix(void)
 				A_blocks[bi+nblocks*bj][i + j * blocksize];
 		}
 
-		starpu_free(A_blocks[bi+nblocks*bj]);
+		starpu_free_noflag(A_blocks[bi+nblocks*bj], (size_t)blocksize*blocksize*sizeof(TYPE));
 	}
 }
 

examples/sched_ctx/gpu_partition.c

@@ -244,8 +244,8 @@ enodev:
 
 	for(iter = 0; iter < NITER; iter++)
 	{
-		starpu_free((void *)_vec_x[iter]);
-		starpu_free((void *)_vec_y[iter]);
+		starpu_free_noflag((void *)_vec_x[iter], N*sizeof(float));
+		starpu_free_noflag((void *)_vec_y[iter], N*sizeof(float));
 	}
 
 	/* Stop StarPU */

examples/spmv/spmv.c

@@ -253,12 +253,12 @@ int main(int argc, char **argv)
 		}
 	}
 
-	starpu_free(nzval);
-	starpu_free(colind);
-	starpu_free(rowptr);
-	starpu_free(vector_in_ptr);
-	starpu_free(vector_out_ptr);
-	starpu_free(vector_exp_out_ptr);
+	starpu_free_noflag(nzval, nnz*sizeof(float));
+	starpu_free_noflag(colind, nnz*sizeof(uint32_t));
+	starpu_free_noflag(rowptr, (size+1)*sizeof(uint32_t));
+	starpu_free_noflag(vector_in_ptr, size*sizeof(float));
+	starpu_free_noflag(vector_out_ptr, size*sizeof(float));
+	starpu_free_noflag(vector_exp_out_ptr, size*sizeof(float));
 
 	/*
 	 *	Stop StarPU

include/starpu_stdlib.h

@@ -117,15 +117,17 @@ void starpu_malloc_set_align(size_t align);
    pin it in CUDA or OpenCL, so that data transfers from this buffer
    can be asynchronous, and thus permit data transfer and computation
    overlapping. The allocated buffer must be freed thanks to the
-   starpu_free() function.
+   starpu_free_noflag() function.
 */
 int starpu_malloc(void **A, size_t dim);
 
 /**
+   @deprecated
    Free memory which has previously been allocated with
-   starpu_malloc().
+   starpu_malloc(). This function is deprecated, one should use
+   starpu_free_noflag().
 */
-int starpu_free(void *A);
+int starpu_free(void *A) STARPU_DEPRECATED;
 
 /**
    Perform a memory allocation based on the constraints defined by the
@@ -140,6 +142,12 @@ int starpu_malloc_flags(void **A, size_t dim, int flags);
 */
 int starpu_free_flags(void *A, size_t dim, int flags);
 
+/**
+   Free memory by specifying its size. Should be used for memory
+   allocated with starpu_malloc().
+*/
+int starpu_free_noflag(void *A, size_t dim);
+
 typedef int (*starpu_malloc_hook)(unsigned dst_node, void **A, size_t dim, int flags);
 typedef int (*starpu_free_hook)(unsigned dst_node, void *A, size_t dim, int flags);
 

mpi/examples/cg/cg.c

@@ -152,15 +152,15 @@ static void free_data(void)
 
 		if (mpi_rank == rank || display_result)
 		{
-			starpu_free((void*) x[j]);
+			starpu_free_noflag((void*) x[j], block_size*sizeof(TYPE));
 		}
 
 		if (mpi_rank == rank)
 		{
-			starpu_free((void*) b[j]);
-			starpu_free((void*) r[j]);
-			starpu_free((void*) d[j]);
-			starpu_free((void*) q[j]);
+			starpu_free_noflag((void*) b[j], block_size*sizeof(TYPE));
+			starpu_free_noflag((void*) r[j], block_size*sizeof(TYPE));
+			starpu_free_noflag((void*) d[j], block_size*sizeof(TYPE));
+			starpu_free_noflag((void*) q[j], block_size*sizeof(TYPE));
 		}
 
 		for (i = 0; i < nblocks; i++)
@@ -168,7 +168,7 @@ static void free_data(void)
 			mpi_rank = my_distrib(j, i);
 			if (mpi_rank == rank)
 			{
-				starpu_free((void*) A[j][i]);
+				starpu_free_noflag((void*) A[j][i], block_size*block_size*sizeof(TYPE));
 			}
 		}
 

mpi/examples/matrix_decomposition/mpi_decomposition_matrix.c

@@ -120,7 +120,7 @@ void matrix_free(float ****bmat, int rank, int nodes, int alloc_everywhere)
 			int mpi_rank = my_distrib(m, n, nodes);
 			if (alloc_everywhere || (mpi_rank == rank))
 			{
-				starpu_free((void *)(*bmat)[m][n]);
+				starpu_free_noflag((void *)(*bmat)[m][n], BLOCKSIZE*BLOCKSIZE*sizeof(float));
 			}
 		}
 		free((*bmat)[m]);

mpi/examples/matrix_mult/mm.c

@@ -59,9 +59,9 @@ static void alloc_matrices(void)
 
 static void free_matrices(void)
 {
-	starpu_free(A);
-	starpu_free(B);
-	starpu_free(C);
+	starpu_free_noflag(A, N*N*sizeof(double));
+	starpu_free_noflag(B, N*N*sizeof(double));
+	starpu_free_noflag(C, N*N*sizeof(double));
 }
 
 static void init_matrices(void)

mpi/examples/mpi_lu/plu_example.c

@@ -606,6 +606,7 @@ int main(int argc, char **argv)
 	/*
 	 * 	Termination
 	 */
+	size_t blocksize = (size_t)(size/nblocks)*(size/nblocks)*sizeof(TYPE);
 	for (j = 0; j < nblocks; j++)
 	{
 		for (i = 0; i < nblocks; i++)
@@ -615,7 +616,7 @@ int main(int argc, char **argv)
 				starpu_data_unregister(handle);
 			TYPE *blockptr = dataA[j+i*nblocks];
 			if (blockptr != STARPU_POISON_PTR)
-				starpu_free(blockptr);
+				starpu_free_noflag(blockptr, blocksize);
 		}
 	}
 	free(dataA_handles);
@@ -623,14 +624,14 @@ int main(int argc, char **argv)
 
 #ifdef SINGLE_TMP11
 	starpu_data_unregister(tmp_11_block_handle);
-	starpu_free(tmp_11_block);
+	starpu_free_noflag(tmp_11_block, blocksize);
 #else
 	for (k = 0; k < nblocks; k++)
 	{
 		if (tmp_11_block_is_needed(rank, nblocks, k))
 		{
 			starpu_data_unregister(tmp_11_block_handles[k]);
-			starpu_free(tmp_11_block[k]);
+			starpu_free_noflag(tmp_11_block[k], blocksize);
 		}
 	}
 	free(tmp_11_block_handles);
@@ -643,13 +644,13 @@ int main(int argc, char **argv)
 		if (tmp_12_block_is_needed(rank, nblocks, k))
 		{
 			starpu_data_unregister(tmp_12_block_handles);
-			starpu_free(tmp_12_block[k]);
+			starpu_free_noflag(tmp_12_block[k], blocksize);
 		}
 
 		if (tmp_21_block_is_needed(rank, nblocks, k))
 		{
 			starpu_data_unregister(tmp_21_block_handles[k]);
-			starpu_free(tmp_21_block[k]);
+			starpu_free_noflag(tmp_21_block[k], blocksize);
 		}
 #else
 	for (i = 0; i < 2; i++)
@@ -657,13 +658,13 @@ int main(int argc, char **argv)
 		if (tmp_12_block_is_needed(rank, nblocks, k))
 		{
 			starpu_data_unregister(tmp_12_block_handles[i][k]);
-			starpu_free(tmp_12_block[i][k]);
+			starpu_free_noflag(tmp_12_block[i][k], blocksize);
 		}
 
 		if (tmp_21_block_is_needed(rank, nblocks, k))
 		{
 			starpu_data_unregister(tmp_21_block_handles[i][k]);
-			starpu_free(tmp_21_block[i][k]);
+			starpu_free_noflag(tmp_21_block[i][k], blocksize);
 		}
 	}
 #endif

mpi/examples/mpi_lu/plu_implicit_example.c

@@ -253,7 +253,6 @@ int main(int argc, char **argv)
 	int world_size;
 	int ret;
 	unsigned i, j;
-
 	starpu_srand48((long int)time(NULL));
 
 	parse_args(argc, argv);
@@ -380,6 +379,7 @@ int main(int argc, char **argv)
 	/*
 	 * 	Termination
 	 */
+	size_t blocksize = (size_t)(size/nblocks)*(size/nblocks)*sizeof(TYPE);
 	for (j = 0; j < nblocks; j++)
 	{
 		for (i = 0; i < nblocks; i++)
@@ -387,7 +387,7 @@ int main(int argc, char **argv)
 			starpu_data_unregister(dataA_handles[j+nblocks*i]);
 			TYPE *blockptr = dataA[j+i*nblocks];
 			if (blockptr != STARPU_POISON_PTR)
-				starpu_free(blockptr);
+				starpu_free_noflag(blockptr, blocksize);
 		}
 	}
 	free(dataA_handles);

mpi/tests/block_interface_pinned.c

@@ -61,8 +61,7 @@ int main(int argc, char **argv)
 
 	if (rank == 0)
 	{
-		starpu_malloc((void **)&block,
-				BIGSIZE*BIGSIZE*BIGSIZE*sizeof(float));
+		starpu_malloc((void **)&block, BIGSIZE*BIGSIZE*BIGSIZE*sizeof(float));
 		memset(block, 0, BIGSIZE*BIGSIZE*BIGSIZE*sizeof(float));
 
 		/* fill the inner block */
@@ -140,7 +139,7 @@ int main(int argc, char **argv)
 	if (rank == 0 || rank == 1)
 	{
 		starpu_data_unregister(block_handle);
-		starpu_free(block);
+		starpu_free_noflag(block, BIGSIZE*BIGSIZE*BIGSIZE*sizeof(float));
 	}
 
 	FPRINTF(stdout, "Rank %d is done\n", rank);

sc_hypervisor/examples/cholesky/cholesky_grain_tag.c

@@ -322,11 +322,11 @@ void cholesky_grain(float *matA, unsigned size, unsigned ld, unsigned nblocks, u
 
 }
 
-static void shutdown_system(float **matA, unsigned pinned)
+static void shutdown_system(float **matA, unsigned dim, unsigned pinned)
 {
 	if (pinned)
 	{
-	     starpu_free(*matA);
+	     starpu_free_noflag(*matA, dim*dim*sizeof(float));
 	}
 	else
 	{
@@ -428,6 +428,6 @@ int main(int argc, char **argv)
 	free(test_mat);
 #endif
 
-	shutdown_system(&mat, pinned);
+	shutdown_system(&mat, size, pinned);
 	return 0;
 }

sc_hypervisor/examples/cholesky/cholesky_implicit.c

@@ -329,7 +329,7 @@ static void execute_cholesky(unsigned size, unsigned nblocks)
 	        }
 		free(test_mat);
 	}
-	starpu_free(mat);
+	starpu_free_noflag(mat, (size_t)size*size*sizeof(float));
 }
 
 int main(int argc, char **argv)

sc_hypervisor/examples/cholesky/cholesky_tag.c

@@ -305,11 +305,11 @@ static void cholesky(float *matA, unsigned size, unsigned ld, unsigned nblocks)
 	starpu_data_unregister(dataA);
 }
 
-static void shutdown_system(float **matA, unsigned pinned)
+static void shutdown_system(float **matA, unsigned dim, unsigned pinned)
 {
 	if (pinned)
 	{
-		starpu_free(*matA);
+		starpu_free_noflag(*matA, (size_t)dim*dim*sizeof(float));
 	}
 	else
 	{
@@ -413,6 +413,6 @@ int main(int argc, char **argv)
 	free(test_mat);
 #endif
 
-	shutdown_system(&mat, pinned);
+	shutdown_system(&mat, size, pinned);
 	return 0;
 }

src/core/disk_ops/unistd/disk_unistd_global.c

@@ -621,7 +621,7 @@ static void * starpu_unistd_internal_thread(void * arg)
 				ret = pwrite(work->fd_dst, buf, work->len, work->off_dst);
 				STARPU_ASSERT_MSG(ret >= 0, "Writing failed (errno %d)", errno);
 				STARPU_ASSERT_MSG((size_t) ret == work->len, "Writing failed (value %ld instead of %ld)", (long)ret, (long)work->len);
-				starpu_free(buf);
+				starpu_free_noflag(buf, work->len);
 			}
 			else
 			{

src/datawizard/malloc.c

@@ -566,6 +566,11 @@ int starpu_free(void *A)
 	return starpu_free_flags(A, 0, STARPU_MALLOC_PINNED);
 }
 
+int starpu_free_noflag(void *A, size_t dim)
+{
+	return starpu_free_flags(A, dim, STARPU_MALLOC_PINNED);
+}
+
 static uintptr_t _starpu_malloc_on_node(unsigned dst_node, size_t size, int flags)
 {
 	uintptr_t addr = 0;

tests/datawizard/acquire_cb_insert.c

@@ -148,7 +148,7 @@ int main(int argc, char **argv)
 	    f[X*(N/M)+2] != 3 || f[X*(N/M)+3] != 4)
 		ret = EXIT_FAILURE;
 
-	starpu_free(f);
+	starpu_free_noflag(f, N * sizeof(*f));
 	starpu_shutdown();
 	return ret;
 

tests/datawizard/commute2.c

@@ -113,8 +113,8 @@ enodev:
 	starpu_data_unregister(res_handle);
 	starpu_data_unregister(a_handle);
 
-	starpu_free(res);
-	starpu_free(a);
+	starpu_free_noflag(res, n*sizeof(double));
+	starpu_free_noflag(a, n*sizeof(double));
 
 	starpu_shutdown();
 	return ret == -ENODEV ? STARPU_TEST_SKIPPED : EXIT_SUCCESS;

tests/datawizard/data_lookup.c

@@ -145,7 +145,7 @@ static void test_filters(void)
 	STARPU_ASSERT(starpu_data_lookup(ptr) == handle);
 
 	starpu_data_unregister(handle);
-	starpu_free(ptr);
+	starpu_free_noflag(ptr, VECTOR_SIZE * sizeof(*ptr));
 
 #undef CHILDREN_COUNT
 }
@@ -220,7 +220,7 @@ int main(int argc, char *argv[])
 
 		handle = starpu_data_lookup(variables[i]);
 		STARPU_ASSERT(handle == NULL);
-		starpu_free(variables[i]);
+		starpu_free_noflag(variables[i], sizeof(float));
 	}
 
 	for(i = 0; i < VECTOR_COUNT; i++)
@@ -229,7 +229,7 @@ int main(int argc, char *argv[])
 
 		handle = starpu_data_lookup(vectors[i]);
 		STARPU_ASSERT(handle == NULL);
-		starpu_free(vectors[i]);
+		starpu_free_noflag(vectors[i], VECTOR_SIZE * sizeof(float));
 	}
 
 	ret = test_lazy_allocation();

tests/datawizard/dsm_stress.c

@@ -249,8 +249,8 @@ int main(int argc, char **argv)
 
 	starpu_data_unregister(v_handle);
 	starpu_data_unregister(v_handle2);
-	starpu_free(v);
-	starpu_free(v2);
+	starpu_free_noflag(v, VECTORSIZE*sizeof(unsigned));
+	starpu_free_noflag(v2, VECTORSIZE*sizeof(unsigned));
 	starpu_shutdown();
 
 	return EXIT_SUCCESS;
@@ -258,8 +258,8 @@ int main(int argc, char **argv)
 enodev:
 	starpu_data_unregister(v_handle);
 	starpu_data_unregister(v_handle2);
-	starpu_free(v);
-	starpu_free(v2);
+	starpu_free_noflag(v, VECTORSIZE*sizeof(unsigned));
+	starpu_free_noflag(v2, VECTORSIZE*sizeof(unsigned));
 	starpu_shutdown();
 	fprintf(stderr, "WARNING: No one can execute this task\n");
 	/* yes, we do not perform the computation but we did detect that no one

tests/datawizard/handle_to_pointer.c

@@ -132,7 +132,7 @@ int main(int argc, char *argv[])
 	STARPU_ASSERT(starpu_data_pointer_is_inside(handle, STARPU_MAIN_RAM, pointer));
 	starpu_data_unregister(handle);
 
-	starpu_free(pointer);
+	starpu_free_noflag(pointer, count * sizeof(int));
 	pointer = NULL;
 
 	/* Lazy allocation.  */

tests/datawizard/sync_with_data_with_mem.c

@@ -126,7 +126,7 @@ int main(int argc, char **argv)
 	for (b = 0; b < nbuffers; b++)
 	{
 		starpu_data_unregister(v_handle[b]);
-		starpu_free(buffer[b]);
+		starpu_free_noflag(buffer[b], vectorsize);
 	}
 
 	starpu_shutdown();

tests/datawizard/sync_with_data_with_mem_non_blocking.c

@@ -159,7 +159,7 @@ int main(int argc, char **argv)
 	for (b = 0; b < nbuffers; b++)
 	{
 		starpu_data_unregister(v_handle[b]);
-		starpu_free(buffer[b]);
+		starpu_free_noflag(buffer[b], vectorsize);
 	}
 
 	starpu_shutdown();

tests/datawizard/sync_with_data_with_mem_non_blocking_implicit.c

@@ -160,7 +160,7 @@ int main(int argc, char **argv)
 	for (b = 0; b < nbuffers; b++)
 	{
 		starpu_data_unregister(v_handle[b]);
-		starpu_free(buffer[b]);
+		starpu_free_noflag(buffer[b], vectorsize);
 	}
 
 	starpu_shutdown();

tests/datawizard/unpartition.c

@@ -129,14 +129,14 @@ int main(int argc, char **argv)
 	}
 
 	starpu_data_unregister(v_handle);
-	starpu_free(buffer);
+	starpu_free_noflag(buffer, VECTORSIZE);
 	starpu_shutdown();
 
 	return EXIT_SUCCESS;
 
 enodev:
 	starpu_data_unregister(v_handle);
-	starpu_free(buffer);
+	starpu_free_noflag(buffer, VECTORSIZE);
 	starpu_shutdown();
 	fprintf(stderr, "WARNING: No one can execute this task\n");
 	/* yes, we do not perform the computation but we did detect that no one

tests/errorcheck/invalid_blocking_calls.c

@@ -115,7 +115,7 @@ int main(int argc, char **argv)
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait");
 	starpu_data_unregister(handle);
 
-	starpu_free(data);
+	starpu_free_noflag(data, sizeof(*data));
 
 	starpu_shutdown();
 

tests/helper/pinned_memory.c

@@ -40,7 +40,7 @@ int main(int argc, char **argv)
 	{
 		ret = starpu_malloc((void **)&data, SIZE);
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_malloc");
-		starpu_free(data);
+		starpu_free_noflag(data, SIZE);
 	}
 
 	starpu_shutdown();

tests/main/execute_on_a_specific_worker.c

@@ -163,14 +163,14 @@ int main(int argc, char **argv)
 	STARPU_PTHREAD_MUTEX_UNLOCK(&mutex);
 
 	starpu_data_unregister(v_handle);
-	starpu_free(v);
+	starpu_free_noflag(v, VECTORSIZE*sizeof(unsigned));
 	starpu_shutdown();
 
 	return EXIT_SUCCESS;
 
 enodev:
 	starpu_data_unregister(v_handle);
-	starpu_free(v);
+	starpu_free_noflag(v, VECTORSIZE*sizeof(unsigned));
 	starpu_shutdown();
 	fprintf(stderr, "WARNING: No one can execute this task\n");
 	/* yes, we do not perform the computation but we did detect that no one

tests/main/starpu_task_bundle.c

@@ -126,7 +126,7 @@ int main(int argc, char **argv)
 		starpu_data_unregister(handles[i]);
 	}
 
-		starpu_free(data);
+	starpu_free_noflag(data, sizeof(*data) * NB_BUNDLE);
 
 	starpu_shutdown();
 

tests/main/subgraph_repeat.c

@@ -135,7 +135,7 @@ int main(int argc, char **argv)
 
 	STARPU_ASSERT(*check_cnt == (4*loop_cnt));
 
-	starpu_free(check_cnt);
+	starpu_free_noflag(check_cnt, sizeof(*check_cnt));
 	starpu_data_unregister(check_data);
 
 	starpu_task_wait_for_all();

tests/main/subgraph_repeat_regenerate.c

@@ -159,7 +159,7 @@ int main(int argc, char **argv)
 
 	STARPU_ASSERT(*check_cnt == (4*niter));
 
-	starpu_free(check_cnt);
+	starpu_free_noflag(check_cnt, sizeof(*check_cnt));
 	starpu_data_unregister(check_data);
 
 	starpu_task_wait_for_all();

tests/main/subgraph_repeat_regenerate_tag.c

@@ -203,7 +203,7 @@ int main(int argc, char **argv)
 
 	STARPU_ASSERT(*check_cnt == (4*loop_cnt));
 
-	starpu_free(check_cnt);
+	starpu_free_noflag(check_cnt, sizeof(*check_cnt));
 
 	starpu_data_unregister(check_data);
 

tests/main/subgraph_repeat_regenerate_tag_cycle.c

@@ -201,7 +201,7 @@ int main(int argc, char **argv)
 
 	STARPU_ASSERT(*check_cnt == (4*loop_cnt));
 
-	starpu_free(check_cnt);
+	starpu_free_noflag(check_cnt, sizeof(*check_cnt));
 
 	starpu_data_unregister(check_data);
 

tests/main/subgraph_repeat_tag.c

@@ -166,7 +166,7 @@ int main(int argc, char **argv)
 
 	STARPU_ASSERT(*check_cnt == (4*loop_cnt));
 
-	starpu_free(check_cnt);
+	starpu_free_noflag(check_cnt, sizeof(*check_cnt));
 
 	starpu_data_unregister(check_data);
 

tests/microbenchs/async_tasks_overhead.c

@@ -204,7 +204,7 @@ int main(int argc, char **argv)
 	for (buffer = 0; buffer < nbuffers; buffer++)
 	{
 		starpu_data_unregister(data_handles[buffer]);
-		starpu_free((void*)buffers[buffer]);
+		starpu_free_noflag((void*)buffers[buffer], BUFFERSIZE*sizeof(float));
 	}
 
 	starpu_shutdown();

tests/microbenchs/local_pingpong.c

@@ -107,7 +107,7 @@ int main(int argc, char **argv)
 	fprintf(stderr, "Avg. transfer time : %f us\n", timing/(2*niter));
 
 	starpu_data_unregister(v_handle);
-	starpu_free(v);
+	starpu_free_noflag(v, vector_size);
 	starpu_shutdown();
 
 	return EXIT_SUCCESS;

tests/microbenchs/matrix_as_vector.c

@@ -180,7 +180,7 @@ int check_size(int nx, struct starpu_codelet *vector_codelet, struct starpu_code
 end:
 	if (ret == -ENODEV)
 		fprintf(stderr, "# Uh, ENODEV?!");
-	starpu_free(matrix);
+	starpu_free_noflag(matrix, nx*sizeof(matrix[0]));
 	starpu_task_wait_for_all();
 	return ret;
 }

tests/microbenchs/prefetch_data_on_node.c

@@ -167,13 +167,13 @@ int main(int argc, char **argv)
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait_for_all");
 
 	starpu_data_unregister(v_handle);
-	starpu_free(v);
+	starpu_free_noflag(v, VECTORSIZE*sizeof(unsigned));
 	starpu_shutdown();
 
 	return EXIT_SUCCESS;
 
 enodev:
-	starpu_free(v);
+	starpu_free_noflag(v, VECTORSIZE*sizeof(unsigned));
 	fprintf(stderr, "WARNING: No one can execute this task\n");
 	/* yes, we do not perform the computation but we did detect that no one
  	 * could perform the kernel, so this is not an error from StarPU */

tests/microbenchs/redundant_buffer.c

@@ -80,14 +80,14 @@ int main(int argc, char **argv)
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait_for_all");
 
 	starpu_data_unregister(v_handle);
-	starpu_free(v);
+	starpu_free_noflag(v, VECTORSIZE*sizeof(unsigned));
 	starpu_shutdown();
 
 	return EXIT_SUCCESS;
 
 enodev:
 	starpu_data_unregister(v_handle);
-	starpu_free(v);
+	starpu_free_noflag(v, VECTORSIZE*sizeof(unsigned));
 	fprintf(stderr, "WARNING: No one can execute this task\n");
 	/* yes, we do not perform the computation but we did detect that no one
  	 * could perform the kernel, so this is not an error from StarPU */

tests/microbenchs/sync_tasks_overhead.c

@@ -180,7 +180,7 @@ int main(int argc, char **argv)
 	for (buffer = 0; buffer < nbuffers; buffer++)
 	{
 		starpu_data_unregister(data_handles[buffer]);
-		starpu_free((void*)buffers[buffer]);
+		starpu_free_noflag((void*)buffers[buffer], BUFFERSIZE*sizeof(float));
 	}
 
 	starpu_shutdown();

tests/microbenchs/tasks_overhead.c

@@ -241,7 +241,7 @@ int main(int argc, char **argv)
 	for (buffer = 0; buffer < nbuffers; buffer++)
 	{
 		starpu_data_unregister(data_handles[buffer]);
-		starpu_free((void*)buffers[buffer]);
+		starpu_free_noflag((void*)buffers[buffer], BUFFERSIZE*sizeof(float));
 	}
 
 	starpu_shutdown();

tests/overlap/overlap.c

@@ -143,14 +143,14 @@ int main(int argc, char **argv)
 
 	starpu_data_unpartition(handle, STARPU_MAIN_RAM);
 	starpu_data_unregister(handle);
-	starpu_free(buffer);
+	starpu_free_noflag(buffer, NTASKS*VECTORSIZE*sizeof(char));
 	starpu_shutdown();
 
 	STARPU_RETURN(EXIT_SUCCESS);
 
 enodev:
 	starpu_data_unregister(handle);
-	starpu_free(buffer);
+	starpu_free_noflag(buffer, NTASKS*VECTORSIZE*sizeof(char));
 	fprintf(stderr, "WARNING: No one can execute this task\n");
 	/* yes, we do not perform the computation but we did detect that no one
  	 * could perform the kernel, so this is not an error from StarPU */

tests/parallel_tasks/explicit_combined_worker.c

@@ -106,14 +106,14 @@ int main(void)
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait_for_all");
 
 	starpu_data_unregister(v_handle);
-	starpu_free(v);
+	starpu_free_noflag(v, VECTORSIZE*sizeof(unsigned));
 	starpu_shutdown();
 
 	return EXIT_SUCCESS;
 
 enodev:
 	starpu_data_unregister(v_handle);
-	starpu_free(v);
+	starpu_free_noflag(v, VECTORSIZE*sizeof(unsigned));
 	fprintf(stderr, "WARNING: No one can execute the task on workerid %u\n", worker);
 	/* yes, we do not perform the computation but we did detect that no one
  	 * could perform the kernel, so this is not an error from StarPU */

tests/parallel_tasks/parallel_kernels.c

@@ -113,14 +113,14 @@ int main(void)
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait_for_all");
 
 	starpu_data_unregister(v_handle);
-	starpu_free(v);
+	starpu_free_noflag(v, VECTORSIZE*sizeof(unsigned));
 	starpu_shutdown();
 
 	STARPU_RETURN(EXIT_SUCCESS);
 
 enodev:
 	starpu_data_unregister(v_handle);
-	starpu_free(v);
+	starpu_free_noflag(v, VECTORSIZE*sizeof(unsigned));
 	fprintf(stderr, "WARNING: No one can execute this task\n");
 	/* yes, we do not perform the computation but we did detect that no one
  	 * could perform the kernel, so this is not an error from StarPU */

tests/parallel_tasks/parallel_kernels_spmd.c

@@ -116,13 +116,13 @@ int main(void)
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait_for_all");
 
 	starpu_data_unregister(v_handle);
-	starpu_free(v);
+	starpu_free_noflag(v, VECTORSIZE*sizeof(unsigned));
 	starpu_shutdown();
 	STARPU_RETURN(EXIT_SUCCESS);
 
 enodev:
 	starpu_data_unregister(v_handle);
-	starpu_free(v);
+	starpu_free_noflag(v, VECTORSIZE*sizeof(unsigned));
 	fprintf(stderr, "WARNING: No one can execute this task\n");
 	/* yes, we do not perform the computation but we did detect that no one
  	 * could perform the kernel, so this is not an error from StarPU */

tests/parallel_tasks/parallel_kernels_trivial.c

@@ -112,14 +112,14 @@ int main(void)
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait_for_all");
 
 	starpu_data_unregister(v_handle);
-	starpu_free(v);
+	starpu_free_noflag(v, VECTORSIZE*sizeof(unsigned));
 	starpu_shutdown();
 
 	STARPU_RETURN(EXIT_SUCCESS);
 
 enodev:
 	starpu_data_unregister(v_handle);
-	starpu_free(v);
+	starpu_free_noflag(v, VECTORSIZE*sizeof(unsigned));
 	fprintf(stderr, "WARNING: No one can execute this task\n");
 	/* yes, we do not perform the computation but we did detect that no one
  	 * could perform the kernel, so this is not an error from StarPU */

tests/parallel_tasks/spmd_peager.c

@@ -102,14 +102,14 @@ int main(void)
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait_for_all");
 
 	starpu_data_unregister(v_handle);
-	starpu_free(v);
+	starpu_free_noflag(v, VECTORSIZE*sizeof(unsigned));
 	starpu_shutdown();
 
 	return EXIT_SUCCESS;
 
 enodev:
 	starpu_data_unregister(v_handle);
-	starpu_free(v);
+	starpu_free_noflag(v, VECTORSIZE*sizeof(unsigned));
 	fprintf(stderr, "WARNING: No one can execute this task\n");
 	/* yes, we do not perform the computation but we did detect that no one
  	 * could perform the kernel, so this is not an error from StarPU */