examples: delete un-needed mult-fpga.c file

examples/Makefile.am

@@ -538,11 +538,6 @@ nobase_STARPU_OPENCL_DATA_DATA += 		\
 	basic_examples/block_opencl_kernel.cl
 endif
 
-if STARPU_USE_FPGA
-basic_examples_mmult_SOURCES =                                    \
-	basic_examples/mult-fpga.c
-endif
-
 ####################
 # Variable example #
 ####################

examples/basic_examples/mult-fpga.c

@@ -1,396 +0,0 @@
-/* StarPU --- Runtime system for heterogeneous multicore architectures.
- *
- * Copyright (C) 2010-2020  Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
- * Copyright (C) 2010       Mehdi Juhoor <mjuhoor@gmail.com>
- *
- * StarPU is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; either version 2.1 of the License, or (at
- * your option) any later version.
- *
- * StarPU is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * See the GNU Lesser General Public License in COPYING.LGPL for more details.
- */
-
-/*
- * This example shows a simple implementation of a blocked matrix
- * multiplication. Note that this is NOT intended to be an efficient
- * implementation of sgemm! In this example, we show:
- *  - how to declare dense matrices (starpu_matrix_data_register)
- *  - how to manipulate matrices within codelets (eg. descr[0].blas.ld)
- *  - how to use filters to partition the matrices into blocks
- *    (starpu_data_partition and starpu_data_map_filters)
- *  - how to unpartition data (starpu_data_unpartition) and how to stop
- *    monitoring data (starpu_data_unregister)
- *  - how to manipulate subsets of data (starpu_data_get_sub_data)
- *  - how to construct an autocalibrated performance model (starpu_perfmodel)
- *  - how to submit asynchronous tasks
- */
-
-#include <string.h>
-#include <math.h>
-#include <sys/types.h>
-#include <signal.h>
-
-#include <starpu.h>
-
-static float *A, *B, *C;
-static starpu_data_handle_t A_handle, B_handle, C_handle;
-
-static unsigned nslicesx = 4;
-static unsigned nslicesy = 4;
-#ifdef STARPU_QUICK_CHECK
-static unsigned xdim = 512;
-static unsigned ydim = 512;
-static unsigned zdim = 256;
-#else
-static unsigned xdim = 1024;
-static unsigned ydim = 1024;
-static unsigned zdim = 512;
-#endif
-
-
-/*
- * That program should compute C = A * B 
- * 
- *   A of size (z,y)
- *   B of size (x,z)
- *   C of size (x,y)
-
-              |---------------|
-            z |       B       |
-              |---------------|
-       z              x
-     |----|   |---------------|
-     |    |   |               |
-     |    |   |               |
-     | A  | y |       C       |
-     |    |   |               |
-     |    |   |               |
-     |----|   |---------------|
-
- */
-
-/*
- * The codelet is passed 3 matrices, the "descr" union-type field gives a
- * description of the layout of those 3 matrices in the local memory (ie. RAM
- * in the case of CPU, GPU frame buffer in the case of GPU etc.). Since we have
- * registered data with the "matrix" data interface, we use the matrix macros.
- */
-
-void cpu_mult(void *descr[], STARPU_ATTRIBUTE_UNUSED  void *arg)
-{
-	float *subA, *subB, *subC;
-	uint32_t nxC, nyC, nyA;
-	uint32_t ldA, ldB, ldC;
-
-	/* .blas.ptr gives a pointer to the first element of the local copy */
-	subA = (float *)STARPU_MATRIX_GET_PTR(descr[0]);
-	subB = (float *)STARPU_MATRIX_GET_PTR(descr[1]);
-	subC = (float *)STARPU_MATRIX_GET_PTR(descr[2]);
-
-	/* .blas.nx is the number of rows (consecutive elements) and .blas.ny
-	 * is the number of lines that are separated by .blas.ld elements (ld
-	 * stands for leading dimension).
-	 * NB: in case some filters were used, the leading dimension is not
-	 * guaranteed to be the same in main memory (on the original matrix)
-	 * and on the accelerator! */
-	nxC = STARPU_MATRIX_GET_NX(descr[2]);
-	nyC = STARPU_MATRIX_GET_NY(descr[2]);
-	nyA = STARPU_MATRIX_GET_NY(descr[0]);
-
-	ldA = STARPU_MATRIX_GET_LD(descr[0]);
-	ldB = STARPU_MATRIX_GET_LD(descr[1]);
-	ldC = STARPU_MATRIX_GET_LD(descr[2]);
-
-	/* we assume a FORTRAN-ordering! */
-	unsigned i,j,k;
-	for (i = 0; i < nyC; i++)
-	{
-		for (j = 0; j < nxC; j++)
-		{
-			float sum = 0.0;
-
-			for (k = 0; k < nyA; k++)
-			{
-				sum += subA[j+k*ldA]*subB[k+i*ldB];
-			}
-
-			subC[j + i*ldC] = sum;
-		}
-	}
-}
-
-static void init_problem_data(void)
-{
-	unsigned i,j;
-
-	/* we initialize matrices A, B and C in the usual way */
-
-	A = (float *) malloc(zdim*ydim*sizeof(float));
-	B = (float *) malloc(xdim*zdim*sizeof(float));
-	C = (float *) malloc(xdim*ydim*sizeof(float));
-
-	/* fill the A and B matrices */
-	srand(2009);
-	for (j=0; j < ydim; j++)
-	{
-		for (i=0; i < zdim; i++)
-		{
-			A[j+i*ydim] = (float)(starpu_drand48());
-		}
-	}
-
-	for (j=0; j < zdim; j++)
-	{
-		for (i=0; i < xdim; i++)
-		{
-			B[j+i*zdim] = (float)(starpu_drand48());
-		}
-	}
-
-	for (j=0; j < ydim; j++)
-	{
-		for (i=0; i < xdim; i++)
-		{
-			C[j+i*ydim] = (float)(0);
-		}
-	}
-}
-
-static void partition_mult_data(void)
-{
-	/* note that we assume a FORTRAN ordering here! */
-
-	/* The BLAS data interface is described by 4 parameters: 
-	 *  - the location of the first element of the matrix to monitor (3rd
-	 *    argument)
-	 *  - the number of elements between columns, aka leading dimension
-	 *    (4th arg)
-	 *  - the number of (contiguous) elements per column, ie. contiguous
-	 *  elements (5th arg)
-	 *  - the number of columns (6th arg)
-	 * The first elements is a pointer to the data_handle that will be
-	 * associated to the matrix, and the second elements gives the memory
-	 * node in which resides the matrix: 0 means that the 3rd argument is
-	 * an adress in main memory.
-	 */
-	starpu_matrix_data_register(&A_handle, STARPU_MAIN_RAM, (uintptr_t)A, 
-		ydim, ydim, zdim, sizeof(float));
-	starpu_matrix_data_register(&B_handle, STARPU_MAIN_RAM, (uintptr_t)B, 
-		zdim, zdim, xdim, sizeof(float));
-	starpu_matrix_data_register(&C_handle, STARPU_MAIN_RAM, (uintptr_t)C, 
-		ydim, ydim, xdim, sizeof(float));
-
-	/* A filter is a method to partition a data into disjoint chunks, it is
-	 * described by the means of the "struct starpu_data_filter" structure that
-	 * contains a function that is applied on a data handle to partition it
-	 * into smaller chunks, and an argument that is passed to the function
-	 * (eg. the number of blocks to create here).
-	 */
-
-	/* StarPU supplies some basic filters such as the partition of a matrix
-	 * into blocks, note that we are using a FORTRAN ordering so that the
-	 * name of the filters are a bit misleading */
-	struct starpu_data_filter vert =
-	{
-		.filter_func = starpu_matrix_filter_vertical_block,
-		.nchildren = nslicesx
-	};
-
-	struct starpu_data_filter horiz =
-	{
-		.filter_func = starpu_matrix_filter_block,
-		.nchildren = nslicesy
-	};
-
-/*
- *	Illustration with nslicex = 4 and nslicey = 2, it is possible to access
- *	sub-data by using the "starpu_data_get_sub_data" method, which takes a data handle,
- *	the number of filters to apply, and the indexes for each filters, for
- *	instance:
- *
- *		A' handle is starpu_data_get_sub_data(A_handle, 1, 1); 
- *		B' handle is starpu_data_get_sub_data(B_handle, 1, 2); 
- *		C' handle is starpu_data_get_sub_data(C_handle, 2, 2, 1); 
- *
- *	Note that here we applied 2 filters recursively onto C.
- *
- *	"starpu_data_get_sub_data(C_handle, 1, 3)" would return a handle to the 4th column
- *	of blocked matrix C for example.
- *
- *		              |---|---|---|---|
- *		              |   |   | B'|   | B
- *		              |---|---|---|---|
- *		                0   1   2   3
- *		     |----|   |---|---|---|---|
- *		     |    |   |   |   |   |   |
- *		     |    | 0 |   |   |   |   |
- *		     |----|   |---|---|---|---|
- *		     | A' |   |   |   | C'|   |
- *		     |    |   |   |   |   |   |
- *		     |----|   |---|---|---|---|
- *		       A              C
- *
- *	IMPORTANT: applying filters is equivalent to partitionning a piece of
- *	data in a hierarchical manner, so that memory consistency is enforced
- *	for each of the elements independantly. The tasks should therefore NOT
- *	access inner nodes (eg. one column of C or the whole C) but only the
- *	leafs of the tree (ie. blocks here). Manipulating inner nodes is only
- *	possible by disapplying the filters (using starpu_data_unpartition), to
- *	enforce memory consistency.
- */
-
-	starpu_data_partition(B_handle, &vert);
-	starpu_data_partition(A_handle, &horiz);
-
-	/* starpu_data_map_filters is a variable-arity function, the first argument
-	 * is the handle of the data to partition, the second argument is the
-	 * number of filters to apply recursively. Filters are applied in the
-	 * same order as the arguments.
-	 * This would be equivalent to starpu_data_partition(C_handle, &vert) and
-	 * then applying horiz on each sub-data (ie. each column of C)
-	 */
-	starpu_data_map_filters(C_handle, 2, &vert, &horiz);
-}
-
-static struct starpu_perfmodel mult_perf_model =
-{
-	.type = STARPU_HISTORY_BASED,
-	.symbol = "mult_perf_model"
-};
-
-static struct starpu_codelet cl =
-{
-        /* we can only execute that kernel on a CPU yet */
-        /* CPU implementation of the codelet */
-        .cpu_funcs = {cpu_mult},
-        .cpu_funcs_name = {"cpu_mult"},
-        /* the codelet manipulates 3 buffers that are managed by the
-         * DSM */
-        .nbuffers = 3,
-	.modes = {STARPU_R, STARPU_R, STARPU_W},
-        /* in case the scheduling policy may use performance models */
-        .model = &mult_perf_model
-};
-
-static int launch_tasks(void)
-{
-	int ret;
-	/* partition the work into slices */
-	unsigned taskx, tasky;
-
-	for (taskx = 0; taskx < nslicesx; taskx++) 
-	{
-		for (tasky = 0; tasky < nslicesy; tasky++)
-		{
-			/* C[taskx, tasky] = A[tasky] B[taskx] */
-
-			/* by default, starpu_task_create() returns an
- 			 * asynchronous task (ie. task->synchronous = 0) */
-			struct starpu_task *task = starpu_task_create();
-
-			/* this task implements codelet "cl" */
-			task->cl = &cl;
-
-			/*
-			 *              |---|---|---|---|
-			 *              |   | * |   |   | B
-			 *              |---|---|---|---|
-			 *                    X 
-			 *     |----|   |---|---|---|---|
-			 *     |****| Y |   |***|   |   |
-			 *     |****|   |   |***|   |   |
-			 *     |----|   |---|---|---|---|
-			 *     |    |   |   |   |   |   |
-			 *     |    |   |   |   |   |   |
-			 *     |----|   |---|---|---|---|
-			 *       A              C
-			 */
-
-			/* there was a single filter applied to matrices A
-			 * (respectively B) so we grab the handle to the chunk
-			 * identified by "tasky" (respectively "taskx). The "1"
-			 * tells StarPU that there is a single argument to the
-			 * variable-arity function starpu_data_get_sub_data */
-			task->handles[0] = starpu_data_get_sub_data(A_handle, 1, tasky);
-			task->handles[1] = starpu_data_get_sub_data(B_handle, 1, taskx);
-
-			/* 2 filters were applied on matrix C, so we give
-			 * starpu_data_get_sub_data 2 arguments. The order of the arguments
-			 * must match the order in which the filters were
-			 * applied.
-			 * NB: starpu_data_get_sub_data(C_handle, 1, k) would have returned
-			 * a handle to the column number k of matrix C.
-			 * NB2: starpu_data_get_sub_data(C_handle, 2, taskx, tasky) is
-			 * equivalent to
-			 * starpu_data_get_sub_data(starpu_data_get_sub_data(C_handle, 1, taskx), 1, tasky)*/
-			task->handles[2] = starpu_data_get_sub_data(C_handle, 2, taskx, tasky);
-
-			/* this is not a blocking call since task->synchronous = 0 */
-			ret = starpu_task_submit(task);
-			if (ret == -ENODEV) return ret;
-			STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
-		}
-	}
-	return 0;
-}
-
-int main(STARPU_ATTRIBUTE_UNUSED int argc, 
-	 STARPU_ATTRIBUTE_UNUSED char **argv)
-{
-	int ret;
-
-	/* start the runtime */
-	ret = starpu_init(NULL);
-	if (ret == -ENODEV)
-		return 77;
-	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
-
-	/* initialize matrices A, B and C and register them to StarPU */
-	init_problem_data();
-
-	/* partition matrices into blocks that can be manipulated by the
- 	 * codelets */
-	partition_mult_data();
-
-	/* submit all tasks in an asynchronous fashion */
-	ret = launch_tasks();
-	if (ret == -ENODEV) goto enodev;
-
-	/* wait for termination */
-        starpu_task_wait_for_all();
-
-	/* remove the filters applied by the means of starpu_data_map_filters; now
- 	 * it's not possible to manipulate a subset of C using starpu_data_get_sub_data until
-	 * starpu_data_map_filters is called again on C_handle.
-	 * The second argument is the memory node where the different subsets
-	 * should be reassembled, 0 = main memory (RAM) */
-	starpu_data_unpartition(A_handle, STARPU_MAIN_RAM);
-	starpu_data_unpartition(B_handle, STARPU_MAIN_RAM);
-	starpu_data_unpartition(C_handle, STARPU_MAIN_RAM);
-
-	/* stop monitoring matrix C : after this, it is not possible to pass C 
-	 * (or any subset of C) as a codelet input/output. This also implements
-	 * a barrier so that the piece of data is put back into main memory in
-	 * case it was only available on a GPU for instance. */
-	starpu_data_unregister(A_handle);
-	starpu_data_unregister(B_handle);
-	starpu_data_unregister(C_handle);
-
-	free(A);
-	free(B);
-	free(C);
-
-	starpu_shutdown();
-
-	return 0;
-
-enodev:
-	starpu_shutdown();
-	return 77;
-}
-