Make disk test actually test all backends. Partly revert r13785 which was using a union as a structure.

src/core/disk.c

@@ -134,15 +134,15 @@ _starpu_disk_read(unsigned src_node, unsigned dst_node STARPU_ATTRIBUTE_UNUSED,
 		else
 		{
 			channel->type = STARPU_DISK_RAM;
-			channel->event.memory_node = src_node;	
+			channel->event.disk_event.memory_node = src_node;	
 
 			_STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
-			channel->event.disk_event = disk_register_list[pos]->functions->async_read(disk_register_list[pos]->base, obj, buf, offset, size);
+			channel->event.disk_event.backend_event = disk_register_list[pos]->functions->async_read(disk_register_list[pos]->base, obj, buf, offset, size);
 			_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 		}
 	}
 	/* asynchronous request failed or synchronous request is asked */	
-	if (channel == NULL || !channel->event.disk_event)
+	if (channel == NULL || !channel->event.disk_event.backend_event)
 	{
 		disk_register_list[pos]->functions->read(disk_register_list[pos]->base, obj, buf, offset, size);
 		return 0;
@@ -163,15 +163,15 @@ _starpu_disk_write(unsigned src_node STARPU_ATTRIBUTE_UNUSED, unsigned dst_node,
 		else
                 {
 			channel->type = STARPU_DISK_RAM;
-			channel->event.memory_node = dst_node;
+			channel->event.disk_event.memory_node = dst_node;
 
 			_STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
-			channel->event.disk_event = disk_register_list[pos]->functions->async_write(disk_register_list[pos]->base, obj, buf, offset, size);
+			channel->event.disk_event.backend_event = disk_register_list[pos]->functions->async_write(disk_register_list[pos]->base, obj, buf, offset, size);
         		_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
 		}
         }
         /* asynchronous request failed or synchronous request is asked */
-	if (channel == NULL || !channel->event.disk_event)
+	if (channel == NULL || !channel->event.disk_event.backend_event)
         {
 		disk_register_list[pos]->functions->write(disk_register_list[pos]->base, obj, buf, offset, size);
         	return 0;
@@ -186,10 +186,11 @@ _starpu_disk_copy(unsigned node_src, void* obj_src, off_t offset_src, unsigned n
 	int pos_src = get_location_with_node(node_src);
 	int pos_dst = get_location_with_node(node_dst);
 	/* both nodes have same copy function */
-	channel->event.disk_event = disk_register_list[pos_src]->functions->copy(disk_register_list[pos_src]->base, obj_src, offset_src, 
+	channel->event.disk_event.memory_node = node_src;
+	channel->event.disk_event.backend_event = disk_register_list[pos_src]->functions->copy(disk_register_list[pos_src]->base, obj_src, offset_src, 
 						        disk_register_list[pos_dst]->base, obj_dst, offset_dst,
 							size);
-	STARPU_ASSERT(channel->event.disk_event);
+	STARPU_ASSERT(channel->event.disk_event.backend_event);
 	return -EAGAIN;
 }
 
@@ -221,21 +222,21 @@ starpu_disk_close(unsigned node, void *obj, size_t size)
 
 void starpu_disk_wait_request(struct _starpu_async_channel *async_channel)
 {
-	int position = get_location_with_node(async_channel->event.memory_node);
-	disk_register_list[position]->functions->wait_request(async_channel->event.disk_event);
+	int position = get_location_with_node(async_channel->event.disk_event.memory_node);
+	disk_register_list[position]->functions->wait_request(async_channel->event.disk_event.backend_event);
 }
 
 int starpu_disk_test_request(struct _starpu_async_channel *async_channel)
 {
-	int position = get_location_with_node(async_channel->event.memory_node);
-	return disk_register_list[position]->functions->test_request(async_channel->event.disk_event);
+	int position = get_location_with_node(async_channel->event.disk_event.memory_node);
+	return disk_register_list[position]->functions->test_request(async_channel->event.disk_event.backend_event);
 }	
 
 void starpu_disk_free_request(struct _starpu_async_channel *async_channel)
 {
-	int position = get_location_with_node(async_channel->event.memory_node);
-	if (async_channel->event.disk_event)
-		disk_register_list[position]->functions->free_request(async_channel->event.disk_event);
+	int position = get_location_with_node(async_channel->event.disk_event.memory_node);
+	if (async_channel->event.disk_event.backend_event)
+		disk_register_list[position]->functions->free_request(async_channel->event.disk_event.backend_event);
 }
 
 static void 

src/core/disk_ops/disk_leveldb.cpp

@@ -54,9 +54,9 @@ starpu_leveldb_alloc (void *base, size_t size)
 
         STARPU_PTHREAD_MUTEX_INIT(&obj->mutex, NULL);
 
-	char * key = (char *) malloc(256*sizeof(char));
-	strcpy(key, "STARPU");
-	strcat(key,(char *) obj);
+	size_t len = 6 + 1 + 2+sizeof(void*)*2 + 1;
+	char * key = (char *) malloc(len*sizeof(char));
+	snprintf(key, len, "STARPU-%p", (uintptr_t) obj);
 
 	/* create and add a key with a small memory */
 	leveldb::Status s = base_tmp->db->Put(leveldb::WriteOptions(), key, "a");
@@ -95,10 +95,7 @@ starpu_leveldb_open (void *base, void *pos, size_t size)
 
         STARPU_PTHREAD_MUTEX_INIT(&obj->mutex, NULL);
 
-	char * key = (char *) malloc((strlen((char *) pos)+1)*sizeof(char));
-	strcpy(key, (char *) pos);
-
-	obj->key = key;	
+	obj->key = strdup((char*) pos);
 	obj->size = size;
 
 	return (void *) obj;
@@ -162,25 +159,33 @@ starpu_leveldb_write (void *base, void *obj, const void *buf, off_t offset, size
 {
         struct starpu_leveldb_obj * tmp = (struct starpu_leveldb_obj *) obj;
         struct starpu_leveldb_base * base_tmp = (struct starpu_leveldb_base *) base;
+	void *buffer;
+	leveldb::Status s;
 
 	STARPU_PTHREAD_MUTEX_LOCK(&tmp->mutex);
 
-	uintptr_t buf_tmp = (uintptr_t) buf;
-	void * buffer = (void *) malloc((tmp->size > size) ? tmp->size : size);
+	if (offset == 0 && size >= tmp->size)
+	{
+		/* We overwrite everything, no need to get the old value */
+		buffer = (void*) buf;
+	}
+	else
+	{
+		uintptr_t buf_tmp = (uintptr_t) buf;
+		buffer = (void *) malloc((tmp->size > size) ? tmp->size : size);
 
-	/* we read the data */
-        std::string value;
+		/* we read the data */
+		std::string value;
 
-        leveldb::Status s = base_tmp->db->Get(leveldb::ReadOptions(), tmp->key, &value);
-        uintptr_t value_read = (uintptr_t)(value.c_str());
+		s = base_tmp->db->Get(leveldb::ReadOptions(), tmp->key, &value);
+		uintptr_t value_read = (uintptr_t)(value.c_str());
 
-        if(s.ok())
-                memcpy(buffer, (void *) value_read, tmp->size);
-        else
-                STARPU_ASSERT(s.ok());
+		STARPU_ASSERT(s.ok());
+		memcpy(buffer, (void *) value_read, tmp->size);
 
-	/* put the new data on their new place */
-	memcpy(buffer, (void *) (buf_tmp+offset), size); 
+		/* put the new data on their new place */
+		memcpy(buffer, (void *) (buf_tmp+offset), size); 
+	}
 
 	/* and write them */
 	s = base_tmp->db->Put(leveldb::WriteOptions(), tmp->key, (char *)buffer);
@@ -188,7 +193,8 @@ starpu_leveldb_write (void *base, void *obj, const void *buf, off_t offset, size
 
 	/* if the new size is higher than the old, we update it - first write after the alloc */
 	tmp->size = (tmp->size > size) ? tmp->size : size;
-	free(buffer);
+	if (buffer != buf)
+		free(buffer);
 	STARPU_PTHREAD_MUTEX_UNLOCK(&tmp->mutex);
 
 	return 0;

src/datawizard/copy_driver.c

@@ -356,7 +356,7 @@ static int copy_data_1_to_1_generic(starpu_data_handle_t handle,
 				STARPU_ASSERT(copy_methods->any_to_any);
 				ret = copy_methods->any_to_any(src_interface, src_node, dst_interface, dst_node, &req->async_channel);
 			}
-			_starpu_mic_init_event(&(req->async_channel.event), dst_node);
+			_starpu_mic_init_event(&(req->async_channel.event.mic_event), dst_node);
 		}
 		break;
 	case _STARPU_MEMORY_NODE_TUPLE(STARPU_MIC_RAM,STARPU_CPU_RAM):
@@ -381,7 +381,7 @@ static int copy_data_1_to_1_generic(starpu_data_handle_t handle,
 				STARPU_ASSERT(copy_methods->any_to_any);
 				ret = copy_methods->any_to_any(src_interface, src_node, dst_interface, dst_node, &req->async_channel);
 			}
-			_starpu_mic_init_event(&(req->async_channel.event), src_node);
+			_starpu_mic_init_event(&(req->async_channel.event.mic_event), src_node);
 		}
 		break;
 #endif
@@ -688,7 +688,7 @@ void _starpu_driver_wait_request_completion(struct _starpu_async_channel *async_
 #endif
 #ifdef STARPU_USE_MIC
 	case STARPU_MIC_RAM:
-		_starpu_mic_wait_request_completion(&(async_channel->event));
+		_starpu_mic_wait_request_completion(&(async_channel->event.mic_event));
 		break;
 #endif
 	case STARPU_MAIN_RAM:
@@ -746,7 +746,7 @@ unsigned _starpu_driver_test_request_completion(struct _starpu_async_channel *as
 #endif
 #ifdef STARPU_USE_MIC
 	case STARPU_MIC_RAM:
-		success = _starpu_mic_request_is_complete(&(async_channel->event));
+		success = _starpu_mic_request_is_complete(&(async_channel->event.mic_event));
 		break;
 #endif
 	case STARPU_DISK_RAM:

src/datawizard/copy_driver.h

@@ -51,18 +51,22 @@ struct _starpu_data_replicate;
  * signal is used to test asynchronous request. */
 struct _starpu_mic_async_event
 {
+	unsigned memory_node;
 	int mark;
 	uint64_t *signal;
 };
 #endif
 
+struct _starpu_disk_async_event
+{
+	unsigned memory_node;
+	void *backend_event;
+};
+
 /* this is a structure that can be queried to see whether an asynchronous
  * transfer has terminated or not */
 union _starpu_async_channel_event
 {
-	/* Only used for disks and mic atm */
-	unsigned memory_node;
-
 #ifdef STARPU_SIMGRID
 	struct {
 		unsigned finished;
@@ -79,7 +83,7 @@ union _starpu_async_channel_event
 #ifdef STARPU_USE_MIC
 	struct _starpu_mic_async_event mic_event;
 #endif
-	void *disk_event;
+	struct _starpu_disk_async_event disk_event;
 };
 
 struct _starpu_async_channel

src/drivers/mic/driver_mic_source.c

@@ -437,7 +437,7 @@ int _starpu_mic_copy_mic_to_ram_async(void *src, unsigned src_node, void *dst, u
 }
 
 /* Initialize a _starpu_mic_async_event. */
-int _starpu_mic_init_event(struct _starpu_async_channel_event *event, unsigned memory_node)
+int _starpu_mic_init_event(struct _starpu_mic_async_event *event, unsigned memory_node)
 {
 	const struct _starpu_mp_node *mp_node = _starpu_mic_src_get_mp_node_from_memory_node(memory_node);
 	scif_epd_t epd = mp_node->host_sink_dt_connection.mic_endpoint;
@@ -445,60 +445,60 @@ int _starpu_mic_init_event(struct _starpu_async_channel_event *event, unsigned m
 	event->memory_node = memory_node;
 
 	/* Address of allocation must be multiple of the page size. */
-	if (posix_memalign((void **)&(event->mic_event.signal), 0x1000, sizeof(*(event->mic_event.signal))) != 0)
+	if (posix_memalign((void **)&(event->signal), 0x1000, sizeof(*(event->signal))) != 0)
 		return -ENOMEM;
-	*(event->mic_event.signal) = 0;
+	*(event->signal) = 0;
 
 	/* The size pass to scif_register is 0x1000 because it should be a multiple of the page size. */
-	if (scif_register(epd, event->mic_event.signal, 0x1000, (off_t)(event->mic_event.signal), SCIF_PROT_WRITE, SCIF_MAP_FIXED) < 0)
+	if (scif_register(epd, event->signal, 0x1000, (off_t)(event->signal), SCIF_PROT_WRITE, SCIF_MAP_FIXED) < 0)
 		STARPU_MIC_SRC_REPORT_SCIF_ERROR(errno);
 
 	/* Mark for a futur wait. */
-	if (scif_fence_mark(epd, SCIF_FENCE_INIT_SELF, &(event->mic_event.mark)) < 0)
+	if (scif_fence_mark(epd, SCIF_FENCE_INIT_SELF, &(event->mark)) < 0)
 		STARPU_MIC_SRC_REPORT_SCIF_ERROR(errno);
 
-	/* Tell to scif to write STARPU_MIC_REQUEST_COMPLETE in event->mic_event.signal when the transfer is complete.
+	/* Tell to scif to write STARPU_MIC_REQUEST_COMPLETE in event->signal when the transfer is complete.
 	 * We use this for test the end of a transfer. */
-	if (scif_fence_signal(epd, (off_t)event->mic_event.signal, STARPU_MIC_REQUEST_COMPLETE, 0, 0, SCIF_FENCE_INIT_SELF | SCIF_SIGNAL_LOCAL) < 0)
+	if (scif_fence_signal(epd, (off_t)event->signal, STARPU_MIC_REQUEST_COMPLETE, 0, 0, SCIF_FENCE_INIT_SELF | SCIF_SIGNAL_LOCAL) < 0)
 		STARPU_MIC_SRC_REPORT_SCIF_ERROR(errno);
 
 	return 0;
 }
 
 /* Wait the end of the asynchronous request */
-void _starpu_mic_wait_request_completion(struct _starpu_async_channel_event *event)
+void _starpu_mic_wait_request_completion(struct _starpu_mic_async_event *event)
 {
-	if (event->mic_event.signal != NULL)
+	if (event->signal != NULL)
 	{
 		const struct _starpu_mp_node *mp_node = _starpu_mic_src_get_mp_node_from_memory_node(event->memory_node);
 		scif_epd_t epd = mp_node->host_sink_dt_connection.mic_endpoint;
 
-		if (scif_fence_wait(epd, event->mic_event.mark) < 0)
+		if (scif_fence_wait(epd, event->mark) < 0)
 			STARPU_MIC_SRC_REPORT_SCIF_ERROR(errno);
 
-		if (scif_unregister(epd, (off_t)(event->mic_event.signal), 0x1000) < 0)
+		if (scif_unregister(epd, (off_t)(event->signal), 0x1000) < 0)
 			STARPU_MIC_SRC_REPORT_SCIF_ERROR(errno);
 
-		free(event->mic_event.signal);
-		event->mic_event.signal = NULL;
+		free(event->signal);
+		event->signal = NULL;
 	}
 }
 
 /* Test if a asynchronous request is end.
  * Return 1 if is end, 0 else. */
-int _starpu_mic_request_is_complete(struct _starpu_async_channel_event *event)
+int _starpu_mic_request_is_complete(struct _starpu_mic_async_event *event)
 {
-	if (event->mic_event.signal != NULL && *(event->mic_event.signal) != STARPU_MIC_REQUEST_COMPLETE)
+	if (event->signal != NULL && *(event->signal) != STARPU_MIC_REQUEST_COMPLETE)
 		return 0;
 
 	const struct _starpu_mp_node *mp_node = _starpu_mic_src_get_mp_node_from_memory_node(event->memory_node);
 	scif_epd_t epd = mp_node->host_sink_dt_connection.mic_endpoint;
 
-	if (scif_unregister(epd, (off_t)(event->mic_event.signal), 0x1000) < 0)
+	if (scif_unregister(epd, (off_t)(event->signal), 0x1000) < 0)
 		STARPU_MIC_SRC_REPORT_SCIF_ERROR(errno);
 
-	free(event->mic_event.signal);
-	event->mic_event.signal = NULL;
+	free(event->signal);
+	event->signal = NULL;
 	return 1;
 }
 

src/drivers/mic/driver_mic_source.h

@@ -70,9 +70,9 @@ int _starpu_mic_copy_mic_to_ram(void *src, unsigned src_node, void *dst, unsigne
 int _starpu_mic_copy_ram_to_mic_async(void *src, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst, unsigned dst_node, size_t size);
 int _starpu_mic_copy_mic_to_ram_async(void *src, unsigned src_node, void *dst, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, size_t size);
 
-int _starpu_mic_init_event(struct _starpu_async_channel_event *event, unsigned memory_node);
-void _starpu_mic_wait_request_completion(struct _starpu_async_channel_event *event);
-int _starpu_mic_request_is_complete(struct _starpu_async_channel_event *event);
+int _starpu_mic_init_event(struct _starpu_mic_async_event *event, unsigned memory_node);
+void _starpu_mic_wait_request_completion(struct _starpu_mic_async_event *event);
+int _starpu_mic_request_is_complete(struct _starpu_mic_async_event *event);
 
 void *_starpu_mic_src_worker(void *arg);
 

tests/disk/disk_compute.c

@@ -26,6 +26,8 @@
 #include <sys/stat.h>
 #include <unistd.h>
 #include <math.h>
+#include <common/config.h>
+#include "../helper.h"
 
 #ifdef STARPU_HAVE_WINDOWS
         #include <io.h>
@@ -33,8 +35,10 @@
 
 #define NX (1024)
 
-int main(int argc, char **argv)
+int dotest(struct starpu_disk_ops *ops)
 {
+	int *A, *C;
+
 	/* Initialize StarPU with default configuration */
 	int ret = starpu_init(NULL);
 
@@ -62,21 +66,18 @@ int main(int argc, char **argv)
 
 
 	/* register a disk */
-	int new_dd = starpu_disk_register(&starpu_disk_stdio_ops, (void *) base, 1024*1024*1);
+	int new_dd = starpu_disk_register(ops, (void *) base, 1024*1024*1);
 	/* can't write on /tmp/ */
 	if (new_dd == -ENOENT) goto enoent;
 	
 	unsigned dd = (unsigned) new_dd;
 
-	printf("TEST DISK MEMORY \n");
-
-	/* Imagine, you want to compute datas */
-	int *A;
-	int *C;
-
+	/* allocate two memory spaces */
 	starpu_malloc_flags((void **)&A, NX*sizeof(int), STARPU_MALLOC_COUNT);
 	starpu_malloc_flags((void **)&C, NX*sizeof(int), STARPU_MALLOC_COUNT);
-	
+
+	FPRINTF(stderr, "TEST DISK MEMORY \n");
+
 	unsigned int j;
 	/* you register them in a vector */
 	for(j = 0; j < NX; ++j)
@@ -163,7 +164,7 @@ int main(int argc, char **argv)
 	for (j = 0; j < NX; ++j)
 		if (A[j] != C[j])
 		{
-			printf("Fail A %d != C %d \n", A[j], C[j]);
+			FPRINTF(stderr, "Fail A %d != C %d \n", A[j], C[j]);
 			try = 0;
 		}
 
@@ -180,13 +181,34 @@ int main(int argc, char **argv)
 	starpu_shutdown();
 
 	if(try)
-		printf("TEST SUCCESS\n");
+		FPRINTF(stderr, "TEST SUCCESS\n");
 	else
-		printf("TEST FAIL\n");
+		FPRINTF(stderr, "TEST FAIL\n");
 	return (try ? EXIT_SUCCESS : EXIT_FAILURE);
 
 enodev:
-	return 77;
+	return STARPU_TEST_SKIPPED;
 enoent:
-	return 77;
+	FPRINTF(stderr, "Couldn't write data: ENOENT\n");
+	starpu_shutdown();
+	return STARPU_TEST_SKIPPED;
+}
+
+static int merge_result(int old, int new)
+{
+	if (new == EXIT_FAILURE)
+		return EXIT_FAILURE;
+	if (old == 0)
+		return 0;
+	return new;
+}
+
+int main(void) {
+	int ret = 0;
+	ret = merge_result(ret, dotest(&starpu_disk_stdio_ops));
+	ret = merge_result(ret, dotest(&starpu_disk_unistd_ops));
+#ifdef STARPU_LINUX_SYS
+	ret = merge_result(ret, dotest(&starpu_disk_unistd_o_direct_ops));
+#endif
+	return ret;
 }

tests/disk/disk_copy.c

@@ -40,7 +40,7 @@ int main(int argc, char **argv)
 }
 #else
 
-int main(int argc, char **argv)
+int dotest(struct starpu_disk_ops *ops)
 {
 	double *A,*B,*C,*D,*E,*F;
 	int ret;
@@ -59,7 +59,7 @@ int main(int argc, char **argv)
 	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(ops, (void *) "/tmp", 1024*1024*200);
 	/* can't write on /tmp/ */
 	if (new_dd == -ENOENT) goto enoent;
 
@@ -132,6 +132,30 @@ int main(int argc, char **argv)
 enodev:
 	return STARPU_TEST_SKIPPED;
 enoent:
+	FPRINTF(stderr, "Couldn't write data: ENOENT\n");
+	starpu_shutdown();
 	return STARPU_TEST_SKIPPED;
 }
+
+static int merge_result(int old, int new)
+{
+	if (new == EXIT_FAILURE)
+		return EXIT_FAILURE;
+	if (old == 0)
+		return 0;
+	return new;
+}
+
+int main(void) {
+	int ret = 0;
+	ret = merge_result(ret, dotest(&starpu_disk_stdio_ops));
+	ret = merge_result(ret, dotest(&starpu_disk_unistd_ops));
+#ifdef STARPU_LINUX_SYS
+	ret = merge_result(ret, dotest(&starpu_disk_unistd_o_direct_ops));
+#endif
+#ifdef STARPU_HAVE_LEVELDB
+	ret = merge_result(ret, dotest(&starpu_disk_leveldb_ops));
+#endif
+	return ret;
+}
 #endif