src/datawizard/interfaces: define pack and unpack functions

ChangeLog

@@ -54,6 +54,8 @@ Changes:
   * Fix of the livelock issue discovered while executing applications
     on a CPU+GPU cluster of machines by adding a maximum trylock 
     threshold before a blocking lock.
+  * Data interfaces (variable, vector, matrix and block) now define
+    pack und unpack functions
 
 StarPU 1.1.0 (svn revision xxxx)
 ==============================================

src/datawizard/interfaces/block_interface.c

@@ -75,6 +75,8 @@ static size_t block_interface_get_size(starpu_data_handle_t handle);
 static uint32_t footprint_block_interface_crc32(starpu_data_handle_t handle);
 static int block_compare(void *data_interface_a, void *data_interface_b);
 static void display_block_interface(starpu_data_handle_t handle, FILE *f);
+static int pack_block_handle(starpu_data_handle_t handle, unsigned node, void **ptr, ssize_t *count);
+static int unpack_block_handle(starpu_data_handle_t handle, unsigned node, void *ptr, size_t count);
 
 struct starpu_data_interface_ops starpu_interface_block_ops =
 {
@@ -89,6 +91,8 @@ struct starpu_data_interface_ops starpu_interface_block_ops =
 	.interfaceid = STARPU_BLOCK_INTERFACE_ID,
 	.interface_size = sizeof(struct starpu_block_interface),
 	.display = display_block_interface,
+	.pack_data = pack_block_handle,
+	.unpack_data = unpack_block_handle
 };
 
 static void *block_handle_to_pointer(starpu_data_handle_t handle, unsigned node)
@@ -195,6 +199,67 @@ static void display_block_interface(starpu_data_handle_t handle, FILE *f)
 	fprintf(f, "%u\t%u\t%u\t", block_interface->nx, block_interface->ny, block_interface->nz);
 }
 
+static int pack_block_handle(starpu_data_handle_t handle, unsigned node, void **ptr, ssize_t *count)
+{
+	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
+
+	struct starpu_block_interface *block_interface = (struct starpu_block_interface *)
+		starpu_data_get_interface_on_node(handle, node);
+
+	*count = block_interface->nx*block_interface->ny*block_interface->nz*block_interface->elemsize;
+
+	if (ptr != NULL)
+	{
+		uint32_t z, y;
+		void *block = (void *)block_interface->ptr;
+
+		*ptr = malloc(*count);
+
+		void *cur = *ptr;
+		for(z=0 ; z<block_interface->nz ; z++)
+		{
+			void *block_z = block;
+			for(y=0 ; y<block_interface->ny ; y++)
+			{
+				memcpy(cur, block, block_interface->nx*block_interface->elemsize);
+				cur += block_interface->nx*block_interface->elemsize;
+				block += block_interface->ldy * block_interface->elemsize;
+			}
+			block = block_z + block_interface->ldz * block_interface->elemsize;
+		}
+	}
+
+	return 0;
+}
+
+static int unpack_block_handle(starpu_data_handle_t handle, unsigned node, void *ptr, size_t count)
+{
+	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
+
+	struct starpu_block_interface *block_interface = (struct starpu_block_interface *)
+		starpu_data_get_interface_on_node(handle, node);
+
+	STARPU_ASSERT(count == block_interface->elemsize * block_interface->nx * block_interface->ny * block_interface->nz);
+
+	uint32_t z, y;
+	void *cur = ptr;
+	void *block = (void *)block_interface->ptr;
+	for(z=0 ; z<block_interface->nz ; z++)
+	{
+		void *block_z = block;
+		for(y=0 ; y<block_interface->ny ; y++)
+		{
+			memcpy(block, cur, block_interface->nx*block_interface->elemsize);
+			cur += block_interface->nx*block_interface->elemsize;
+			block += block_interface->ldy * block_interface->elemsize;
+		}
+		block = block_z + block_interface->ldz * block_interface->elemsize;
+	}
+
+	return 0;
+}
+
+
 static size_t block_interface_get_size(starpu_data_handle_t handle)
 {
 	size_t size;

src/datawizard/interfaces/matrix_interface.c

@@ -88,6 +88,8 @@ static size_t matrix_interface_get_size(starpu_data_handle_t handle);
 static uint32_t footprint_matrix_interface_crc32(starpu_data_handle_t handle);
 static int matrix_compare(void *data_interface_a, void *data_interface_b);
 static void display_matrix_interface(starpu_data_handle_t handle, FILE *f);
+static int pack_matrix_handle(starpu_data_handle_t handle, unsigned node, void **ptr, ssize_t *count);
+static int unpack_matrix_handle(starpu_data_handle_t handle, unsigned node, void *ptr, size_t count);
 
 struct starpu_data_interface_ops starpu_interface_matrix_ops =
 {
@@ -102,6 +104,8 @@ struct starpu_data_interface_ops starpu_interface_matrix_ops =
 	.interfaceid = STARPU_MATRIX_INTERFACE_ID,
 	.interface_size = sizeof(struct starpu_matrix_interface),
 	.display = display_matrix_interface,
+	.pack_data = pack_matrix_handle,
+	.unpack_data = unpack_matrix_handle
 };
 
 static void register_matrix_handle(starpu_data_handle_t handle, unsigned home_node, void *data_interface)
@@ -196,6 +200,56 @@ static void display_matrix_interface(starpu_data_handle_t handle, FILE *f)
 	fprintf(f, "%u\t%u\t", matrix_interface->nx, matrix_interface->ny);
 }
 
+static int pack_matrix_handle(starpu_data_handle_t handle, unsigned node, void **ptr, ssize_t *count)
+{
+	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
+
+	struct starpu_matrix_interface *matrix_interface = (struct starpu_matrix_interface *)
+		starpu_data_get_interface_on_node(handle, node);
+
+	*count = matrix_interface->nx*matrix_interface->ny*matrix_interface->elemsize;
+
+	if (ptr != NULL)
+	{
+		uint32_t y;
+		void *matrix = (void *)matrix_interface->ptr;
+
+		*ptr = malloc(*count);
+
+		void *cur = *ptr;
+		for(y=0 ; y<matrix_interface->ny ; y++)
+		{
+			memcpy(cur, matrix, matrix_interface->nx*matrix_interface->elemsize);
+			cur += matrix_interface->nx*matrix_interface->elemsize;
+			matrix += matrix_interface->ld * matrix_interface->elemsize;
+		}
+	}
+
+	return 0;
+}
+
+static int unpack_matrix_handle(starpu_data_handle_t handle, unsigned node, void *ptr, size_t count)
+{
+	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
+
+	struct starpu_matrix_interface *matrix_interface = (struct starpu_matrix_interface *)
+		starpu_data_get_interface_on_node(handle, node);
+
+	STARPU_ASSERT(count == matrix_interface->elemsize * matrix_interface->nx * matrix_interface->ny);
+
+	uint32_t y;
+	void *cur = ptr;
+	void *matrix = (void *)matrix_interface->ptr;
+	for(y=0 ; y<matrix_interface->ny ; y++)
+	{
+		memcpy(matrix, cur, matrix_interface->nx*matrix_interface->elemsize);
+		cur += matrix_interface->nx*matrix_interface->elemsize;
+		matrix += matrix_interface->ld * matrix_interface->elemsize;
+	}
+
+	return 0;
+}
+
 static size_t matrix_interface_get_size(starpu_data_handle_t handle)
 {
 	struct starpu_matrix_interface *matrix_interface = (struct starpu_matrix_interface *)

src/datawizard/interfaces/variable_interface.c

@@ -42,6 +42,8 @@ static size_t variable_interface_get_size(starpu_data_handle_t handle);
 static uint32_t footprint_variable_interface_crc32(starpu_data_handle_t handle);
 static int variable_compare(void *data_interface_a, void *data_interface_b);
 static void display_variable_interface(starpu_data_handle_t handle, FILE *f);
+static int pack_variable_handle(starpu_data_handle_t handle, unsigned node, void **ptr, ssize_t *count);
+static int unpack_variable_handle(starpu_data_handle_t handle, unsigned node, void *ptr, size_t count);
 
 struct starpu_data_interface_ops starpu_interface_variable_ops =
 {
@@ -56,6 +58,8 @@ struct starpu_data_interface_ops starpu_interface_variable_ops =
 	.interfaceid = STARPU_VARIABLE_INTERFACE_ID,
 	.interface_size = sizeof(struct starpu_variable_interface),
 	.display = display_variable_interface,
+	.pack_data = pack_variable_handle,
+	.unpack_data = unpack_variable_handle
 };
 
 static void *variable_handle_to_pointer(starpu_data_handle_t handle, unsigned node)
@@ -136,6 +140,37 @@ static void display_variable_interface(starpu_data_handle_t handle, FILE *f)
 	fprintf(f, "%ld\t", (long)variable_interface->elemsize);
 }
 
+static int pack_variable_handle(starpu_data_handle_t handle, unsigned node, void **ptr, ssize_t *count)
+{
+	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
+
+	struct starpu_variable_interface *variable_interface = (struct starpu_variable_interface *)
+		starpu_data_get_interface_on_node(handle, node);
+
+	*count = variable_interface->elemsize;
+
+	if (ptr != NULL)
+	{
+		*ptr = malloc(*count);
+		memcpy(*ptr, (void*)variable_interface->ptr, variable_interface->elemsize);
+	}
+
+	return 0;
+}
+
+static int unpack_variable_handle(starpu_data_handle_t handle, unsigned node, void *ptr, size_t count)
+{
+	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
+
+	struct starpu_variable_interface *variable_interface = (struct starpu_variable_interface *)
+		starpu_data_get_interface_on_node(handle, node);
+
+	STARPU_ASSERT(count == variable_interface->elemsize);
+
+	memcpy((void*)variable_interface->ptr, ptr, variable_interface->elemsize);
+	return 0;
+}
+
 static size_t variable_interface_get_size(starpu_data_handle_t handle)
 {
 	struct starpu_variable_interface *variable_interface = (struct starpu_variable_interface *)

src/datawizard/interfaces/vector_interface.c

@@ -42,6 +42,8 @@ static size_t vector_interface_get_size(starpu_data_handle_t handle);
 static uint32_t footprint_vector_interface_crc32(starpu_data_handle_t handle);
 static int vector_compare(void *data_interface_a, void *data_interface_b);
 static void display_vector_interface(starpu_data_handle_t handle, FILE *f);
+static int pack_vector_handle(starpu_data_handle_t handle, unsigned node, void **ptr, ssize_t *count);
+static int unpack_vector_handle(starpu_data_handle_t handle, unsigned node, void *ptr, size_t count);
 
 struct starpu_data_interface_ops starpu_interface_vector_ops =
 {
@@ -56,6 +58,8 @@ struct starpu_data_interface_ops starpu_interface_vector_ops =
 	.interfaceid = STARPU_VECTOR_INTERFACE_ID,
 	.interface_size = sizeof(struct starpu_vector_interface),
 	.display = display_vector_interface,
+	.pack_data = pack_vector_handle,
+	.unpack_data = unpack_vector_handle
 };
 
 static void *vector_handle_to_pointer(starpu_data_handle_t handle, unsigned node)
@@ -142,6 +146,37 @@ static void display_vector_interface(starpu_data_handle_t handle, FILE *f)
 	fprintf(f, "%u\t", vector_interface->nx);
 }
 
+static int pack_vector_handle(starpu_data_handle_t handle, unsigned node, void **ptr, ssize_t *count)
+{
+	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
+
+	struct starpu_vector_interface *vector_interface = (struct starpu_vector_interface *)
+		starpu_data_get_interface_on_node(handle, node);
+
+	*count = vector_interface->nx*vector_interface->elemsize;
+
+	if (ptr != NULL)
+	{
+		*ptr = malloc(*count);
+		memcpy(*ptr, (void*)vector_interface->ptr, vector_interface->elemsize*vector_interface->nx);
+	}
+
+	return 0;
+}
+
+static int unpack_vector_handle(starpu_data_handle_t handle, unsigned node, void *ptr, size_t count)
+{
+	STARPU_ASSERT(starpu_data_test_if_allocated_on_node(handle, node));
+
+	struct starpu_vector_interface *vector_interface = (struct starpu_vector_interface *)
+		starpu_data_get_interface_on_node(handle, node);
+
+	STARPU_ASSERT(count == vector_interface->elemsize * vector_interface->nx);
+	memcpy((void*)vector_interface->ptr, ptr, count);
+
+	return 0;
+}
+
 static size_t vector_interface_get_size(starpu_data_handle_t handle)
 {
 	size_t size;