1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
/* StarPU --- Runtime system for heterogeneous multicore architectures.
*
* Copyright (C) 2010, 2014, 2016 Université de Bordeaux
* Copyright (C) 2012, 2013, 2015 CNRS
*
* 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.
*/
#include <config.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <starpu.h>
#include <stdlib.h>
#include "../helper.h"
/*
* Test using the specific_nodes field by forcing the data to main memory
* even if the task is run on a GPU (and actually doing the computation from
* the CPU driving the GPU). It mixes such accesses and normal accesses from
* the GPU
*/
starpu_data_handle_t data_handle;
unsigned data;
void specific_kernel(STARPU_ATTRIBUTE_UNUSED void *descr[], STARPU_ATTRIBUTE_UNUSED void *_args)
{
/* We do not protect this variable because it is only accessed when the
* "data_handle" piece of data is accessed. */
unsigned *dataptr = (unsigned*) STARPU_VARIABLE_GET_PTR(descr[0]);
STARPU_ASSERT(dataptr == &data);
(*dataptr)++;
}
static struct starpu_codelet specific_cl =
{
.cpu_funcs = {specific_kernel},
.cuda_funcs = {specific_kernel},
.opencl_funcs = {specific_kernel},
.nbuffers = 1,
.modes = {STARPU_RW},
.specific_nodes = 1,
.nodes = {STARPU_MAIN_RAM},
};
#ifdef STARPU_USE_CUDA
void cuda_codelet_unsigned_inc(void *descr[], STARPU_ATTRIBUTE_UNUSED void *cl_arg);
#endif
#ifdef STARPU_USE_OPENCL
void opencl_codelet_unsigned_inc(void *buffers[], void *args);
#endif
static struct starpu_codelet cl =
{
.cpu_funcs = {specific_kernel},
#ifdef STARPU_USE_CUDA
.cuda_funcs = {cuda_codelet_unsigned_inc},
.cuda_flags = {STARPU_CUDA_ASYNC},
#endif
#ifdef STARPU_USE_OPENCL
.opencl_funcs = {opencl_codelet_unsigned_inc},
.opencl_flags = {STARPU_OPENCL_ASYNC},
#endif
.nbuffers = 1,
.modes = {STARPU_RW},
};
#ifdef STARPU_USE_OPENCL
struct starpu_opencl_program opencl_program;
#endif
int main(STARPU_ATTRIBUTE_UNUSED int argc, STARPU_ATTRIBUTE_UNUSED char **argv)
{
#ifdef STARPU_QUICK_CHECK
unsigned ntasks = 10;
#else
unsigned ntasks = 1000;
#endif
int ret, ret2;
ret = starpu_init(NULL);
if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
#ifdef STARPU_USE_OPENCL
ret = starpu_opencl_load_opencl_from_file("tests/datawizard/opencl_codelet_unsigned_inc_kernel.cl",
&opencl_program, NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_opencl_load_opencl_from_file");
#endif
data = 0;
/* Create a void data which will be used as an exclusion mechanism. */
starpu_variable_data_register(&data_handle, STARPU_MAIN_RAM, (uintptr_t) &data, sizeof(data));
unsigned i;
for (i = 0; i < ntasks; i++)
{
struct starpu_task *task = starpu_task_create();
if (i%2)
task->cl = &specific_cl;
else
task->cl = &cl;
task->handles[0] = data_handle;
ret = starpu_task_submit(task);
if (ret == -ENODEV) goto enodev;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
}
starpu_data_unregister(data_handle);
ret = (data == ntasks) ? EXIT_SUCCESS : EXIT_FAILURE;
#ifdef STARPU_USE_OPENCL
ret2 = starpu_opencl_unload_opencl(&opencl_program);
STARPU_CHECK_RETURN_VALUE(ret2, "starpu_opencl_unload_opencl");
#endif
starpu_shutdown();
return ret;
enodev:
fprintf(stderr, "WARNING: No one can execute this task\n");
/* yes, we do not perform the computation but we did detect that no one
* could perform the kernel, so this is not an error from StarPU */
starpu_shutdown();
return STARPU_TEST_SKIPPED;
}
|
