change test and correct bug, not fix

src/core/disk.c

@@ -148,14 +148,14 @@ _starpu_disk_copy(unsigned node_src, void* obj_src, off_t offset_src, unsigned n
 }
 
 void * 
-_starpu_disk_open(unsigned node, void *pos, size_t size)
+starpu_disk_open(unsigned node, void *pos, size_t size)
 {
 	int position = get_location_with_node(node);
 	return disk_register_list[position]->functions->open(disk_register_list[position]->base, pos, size);
 }
 
 void 
-_starpu_disk_close(unsigned node, void *obj, size_t size)
+starpu_disk_close(unsigned node, void *obj, size_t size)
 {
 	int position = get_location_with_node(node);
 	disk_register_list[position]->functions->close(disk_register_list[position]->base, obj, size);	

tests/disk/disk_compute.c

@@ -23,105 +23,90 @@
 #include <stdio.h>
 #include <math.h>
 
-/* size of one vector */
-#define	NX	(30*1000000/sizeof(double))
-#define FPRINTF(ofile, fmt, ...) do { if (!getenv("STARPU_SSILENT")) {fprintf(ofile, fmt, ## __VA_ARGS__); }} while(0)
-
+#define NX (30*1000000/sizeof(int))
 
 int main(int argc, char **argv)
 {
-	double * A,*B,*C,*D,*E,*F;
-
-	/* limit main ram to force to push in disk */
-	putenv("STARPU_LIMIT_CPU_MEM=160");
-
 	/* Initialize StarPU with default configuration */
 	int ret = starpu_init(NULL);
 
 	if (ret == -ENODEV) goto enodev;
 
 	/* register a disk */
-	int new_dd = starpu_disk_register(&starpu_disk_stdio_ops, (void *) "/tmp/", 1024*1024*200);
+	int new_dd = starpu_disk_register(&starpu_disk_stdio_ops, (void *) "/tmp/", 1024*1024*40);
 	/* can't write on /tmp/ */
 	if (new_dd == -ENOENT) goto enoent;
 	
 	unsigned dd = (unsigned) new_dd;
 
-	/* allocate two memory spaces */
-	starpu_malloc_flags((void **)&A, NX*sizeof(double), STARPU_MALLOC_COUNT);
-	starpu_malloc_flags((void **)&F, NX*sizeof(double), STARPU_MALLOC_COUNT);
-
-	FPRINTF(stderr, "TEST DISK MEMORY \n");
+	printf("TEST DISK MEMORY \n");
 
+	/* Imagine, you want to compute datas */
+	int A[NX];
+	int C[NX];
 	unsigned int j;
-	/* initialization with bad values */
+	/* you register them in a vector */
 	for(j = 0; j < NX; ++j)
 	{
 		A[j] = j;
-		F[j] = -j;
 	}
 
-	/* Tell StaPU to associate the "vector" vector with the "vector_handle"
-	 * identifier. When a task needs to access a piece of data, it should
-	 * refer to the handle that is associated to it.
-	 * In the case of the "vector" data interface:
-	 *  - the first argument of the registration method is a pointer to the
-	 *    handle that should describe the data
-	 *  - the second argument is the memory node where the data (ie. "vector")
-	 *    resides initially: 0 stands for an address in main memory, as
-	 *    opposed to an adress on a GPU for instance.
-	 *  - the third argument is the adress of the vector in RAM
-	 *  - the fourth argument is the number of elements in the vector
-	 *  - the fifth argument is the size of each element.
-	 */
-	starpu_data_handle_t vector_handleA, vector_handleB, vector_handleC, vector_handleD, vector_handleE, vector_handleF;
+	/* you create a file to store the vector ON the disk */
+	FILE * f = fopen("/tmp/STARPU_DISK_COMPUTE_DATA", "rb+");
+	/* fail */
+	if (f == NULL)
+		goto enoent;
+
+
+	/* store it in the file */
+	fwrite((void *) A, sizeof(int), NX, f);
+
+	/* close the file */
+	fclose(f);
+
+	/* And now, you want to use your datas in StarPU */
+	/* Open the file ON the disk */
+	void * data = starpu_disk_open(dd, (void *) "STARPU_DISK_COMPUTE_DATA", NX*sizeof(int));
+
+	starpu_data_handle_t vector_handleA, vector_handleB;
 
 	/* register vector in starpu */
-	starpu_vector_data_register(&vector_handleA, 0, (uintptr_t)A, NX, sizeof(double));
-	starpu_vector_data_register(&vector_handleB, -1, (uintptr_t) NULL, NX, sizeof(double));	
-	starpu_vector_data_register(&vector_handleC, -1, (uintptr_t) NULL, NX, sizeof(double));
-	starpu_vector_data_register(&vector_handleD, -1, (uintptr_t) NULL, NX, sizeof(double));
-	starpu_vector_data_register(&vector_handleE, -1, (uintptr_t) NULL, NX, sizeof(double));
-	starpu_vector_data_register(&vector_handleF, 0, (uintptr_t)F, NX, sizeof(double));
-
-	/* copy vector A->B, B->C... */
-	starpu_data_cpy(vector_handleB, vector_handleA, 0, NULL, NULL);
-	starpu_data_cpy(vector_handleC, vector_handleB, 0, NULL, NULL);
-	starpu_data_cpy(vector_handleD, vector_handleC, 0, NULL, NULL);
-	starpu_data_cpy(vector_handleE, vector_handleD, 0, NULL, NULL);
-	starpu_data_cpy(vector_handleF, vector_handleE, 0, NULL, NULL);
+	starpu_vector_data_register(&vector_handleA, dd, (uintptr_t)A, NX, sizeof(int));
 
-	/* StarPU does not need to manipulate the array anymore so we can stop
- 	 * monitoring it */
+	/* and do what you want with it, here we copy it into an other vector */ 
+	starpu_vector_data_register(&vector_handleB, STARPU_MAIN_RAM, (uintptr_t) NULL, NX, sizeof(int));	
+
+	starpu_data_cpy(vector_handleB, vector_handleA, 0, NULL, NULL);
 
 	/* free them */
 	starpu_data_unregister(vector_handleA);
 	starpu_data_unregister(vector_handleB);
-	starpu_data_unregister(vector_handleC);
-	starpu_data_unregister(vector_handleD);
-	starpu_data_unregister(vector_handleE);
-	starpu_data_unregister(vector_handleF);
 
-	/* check if computation is correct */
+	/* close it in StarPU */
+	starpu_disk_close(dd, data, NX*sizeof(int));
+
+	/* check if it's correct */
+	f = fopen("/tmp/STARPU_DISK_COMPUTE_DATA", "rb+");
+	/* fail */
+	if (f == NULL)
+		goto enoent;
+	int size = fread(C, sizeof(int), NX, f);
+
 	int try = 1;
 	for (j = 0; j < NX; ++j)
-		if (A[j] != F[j])
+		if (A[j] != C[j])
 		{
-			printf("Fail A %f != F %f \n", A[j], F[j]);
+			printf("Fail A %d != C %d \n", A[j], C[j]);
 			try = 0;
 		}
 
-	/* free last vectors */
-	starpu_free_flags(A, NX*sizeof(double), STARPU_MALLOC_COUNT);
-	starpu_free_flags(F, NX*sizeof(double), STARPU_MALLOC_COUNT);
-
 	/* terminate StarPU, no task can be submitted after */
 	starpu_shutdown();
 
 	if(try)
-		FPRINTF(stderr, "TEST SUCCESS\n");
+		printf("TEST SUCCESS\n");
 	else
-		FPRINTF(stderr, "TEST FAIL\n");
+		printf("TEST FAIL\n");
 	return (try ? EXIT_SUCCESS : EXIT_FAILURE);
 
 enodev: