Commit 5e8a2383 authored by Nathalie Furmento's avatar Nathalie Furmento
Browse files

website/tutorials/2014-05-PATC: add solution for vector_scal filer

git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/starpu/website@12976 176f6dd6-97d6-42f4-bd05-d3db9ad07c7a
parent 2df3dc92
/* StarPU --- Runtime system for heterogeneous multicore architectures.
*
* Copyright (C) 2010, 2011, 2012, 2013, 2014 Centre National de la Recherche Scientifique
* Copyright (C) 2010-2012, 2014 Université de Bordeaux 1
*
* 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 demonstrates how to use StarPU to scale an array by a factor.
* It shows how to manipulate data with StarPU's data management library.
* 1- how to declare a piece of data to StarPU (starpu_vector_data_register)
* 2- how to submit a task to StarPU
* 3- how a kernel can manipulate the data (buffers[0].vector.ptr)
*/
#include <starpu.h>
#define NX 2048
extern void vector_scal_cpu(void *buffers[], void *_args);
extern void vector_scal_cuda(void *buffers[], void *_args);
extern void vector_scal_opencl(void *buffers[], void *_args);
static struct starpu_codelet cl = {
/* CPU implementation of the codelet */
.cpu_funcs = {vector_scal_cpu, NULL},
#ifdef STARPU_USE_CUDA
/* CUDA implementation of the codelet */
.cuda_funcs = {vector_scal_cuda, NULL},
#endif
#ifdef STARPU_USE_OPENCL
/* OpenCL implementation of the codelet */
.opencl_funcs = {vector_scal_opencl, NULL},
#endif
.nbuffers = 1,
.modes = {STARPU_RW}
};
#ifdef STARPU_USE_OPENCL
struct starpu_opencl_program programs;
#endif
int main(int argc, char **argv)
{
/* We consider a vector of float that is initialized just as any of C
* data */
float *vector;
unsigned i;
starpu_malloc((void**)&vector, NX * sizeof(vector[0]));
for (i = 0; i < NX; i++)
vector[i] = 1.0f;
fprintf(stderr, "BEFORE : First element was %f\n", vector[0]);
/* Initialize StarPU with default configuration */
int ret = starpu_init(NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
#ifdef STARPU_USE_OPENCL
starpu_opencl_load_opencl_from_file("vector_scal_opencl_kernel.cl", &programs, NULL);
#endif
/* 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_handle;
starpu_vector_data_register(&vector_handle, 0, (uintptr_t)vector,
NX, sizeof(vector[0]));
#define N 10
struct starpu_data_filter filter;
memset(&filter, 0, sizeof(filter));
filter.filter_func = starpu_vector_filter_block;
filter.nchildren = N;
starpu_data_partition(vector_handle, &filter);
float factor = 3.14;
for (i = 0; i < N; i++)
{
ret = starpu_insert_task(&cl,
/* an argument is passed to the codelet, beware that this is a
* READ-ONLY buffer and that the codelet may be given a pointer to a
* COPY of the argument */
STARPU_VALUE, &factor, sizeof(factor),
/* the codelet manipulates one buffer in RW mode */
STARPU_RW, starpu_data_get_sub_data(vector_handle, 1, i),
0);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_insert_task");
}
/* Wait for tasks completion */
starpu_task_wait_for_all();
/* StarPU does not need to manipulate the array anymore so we can stop
* monitoring it */
starpu_data_unpartition(vector_handle, 0);
starpu_data_unregister(vector_handle);
#ifdef STARPU_USE_OPENCL
starpu_opencl_unload_opencl(&programs);
#endif
/* terminate StarPU, no task can be submitted after */
starpu_shutdown();
fprintf(stderr, "AFTER First element is %f\n", vector[0]);
return 0;
}
......@@ -414,8 +414,10 @@ have been easily ported to StarPU by simply using <tt>starpu_insert_task</tt>.
<p>
Take the vector example again, and add partitioning support to it, using the
matrix-matrix multiplication as an example. Here we will use the
<tt>starpu_vector_filter_block</tt> filter. Try to run it with various numbers
of tasks.
<a href="http://runtime.bordeaux.inria.fr/StarPU/doc/html/group__API__Data__Partition.html#ga212189d3b83dfa4e225609b5f2bf8461"><tt>starpu_vector_filter_block()</tt></a> filter function. You can see the list of
predefined filters provided by
StarPU <a href="http://runtime.bordeaux.inria.fr/StarPU/doc/html/starpu__data__filters_8h.html">here</a>.
Try to run it with various numbers of tasks.
</p>
</div>
</div>
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment