← Back to branch summary

~ubuntu-branches/ubuntu/quantal/starpu-contrib/quantal

« back to all changes in this revision

Viewing changes to gcc-plugin/tests/mocks.h

  • Committer: Package Import Robot
  • Author(s): Samuel Thibault
  • Date: 2012-04-12 15:04:15 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20120412150415-gzp107thb5wknugm
Tags: 1.0.1-1
http://bugs.debian.org/667381
http://bugs.debian.org/670422
* New upstream release.
* Explicitly use gcc-4.6 to fix plugin build (Closes: Bug#667381).
* Use gcc-4.5 for starpu, as nvcc does not actually support all 4.6
  features, notably not __float128.
* patches/relax-gcc-plugin: Relax gcc-4.6 dependency for plugins to upstream
  release version (Closes: #670422)
* watch: Fix URL.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gcc-plugin/tests/mocks.h
78
78
   `starpu_insert_task' arguments.  */
79
79
const struct insert_task_argument *expected_insert_task_arguments;
80
80
 
 
81
/* Expected targets of the codelets submitted.  */
 
82
static int expected_insert_task_targets = STARPU_CPU | STARPU_OPENCL;
 
83
 
 
84
 
81
85
int
82
86
starpu_insert_task (struct starpu_codelet *cl, ...)
83
87
{
84
88
  assert (cl->name != NULL && strlen (cl->name) > 0);
85
 
  assert (cl->where == (STARPU_CPU | STARPU_OPENCL));
86
 
 
87
 
  /* TODO: Call `cpu_func' & co. and check whether they do the right
88
 
     thing.  */
89
 
 
90
 
  assert (cl->cpu_funcs[0] != NULL);
91
 
  assert (cl->opencl_funcs[0] != NULL);
92
 
  assert (cl->cuda_funcs[0] == NULL);
 
89
  assert (cl->where == expected_insert_task_targets);
 
90
 
 
91
  assert ((cl->where & STARPU_CPU) == 0
 
92
          ? cl->cpu_funcs[0] == NULL
 
93
          : cl->cpu_funcs[0] != NULL);
 
94
  assert ((cl->where & STARPU_OPENCL) == 0
 
95
          ? cl->opencl_funcs[0] == NULL
 
96
          : cl->opencl_funcs[0] != NULL);
 
97
  assert ((cl->where & STARPU_CUDA) == 0
 
98
          ? cl->cuda_funcs[0] == NULL
 
99
          : cl->cuda_funcs[0] != NULL);
93
100
 
94
101
  va_list args;
95
 
  size_t pointer_arg;
 
102
  size_t i, scalars, pointers, cl_args_offset;
 
103
  void *pointer_args[123];
 
104
  struct starpu_vector_interface pointer_args_ifaces[123];
 
105
  unsigned char cl_args[234];
96
106
 
97
107
  va_start (args, cl);
98
108
 
99
109
  const struct insert_task_argument *expected;
100
 
  for (expected = expected_insert_task_arguments, pointer_arg = 0;
 
110
  for (expected = expected_insert_task_arguments,
 
111
         cl_args_offset = 1, scalars = 0, pointers = 0;
101
112
       expected->type != 0;
102
113
       expected++)
103
114
    {
119
130
            assert (size == expected->size);
120
131
            assert (arg != NULL);
121
132
            assert (!memcmp (arg, expected->pointer, size));
 
133
 
 
134
            /* Pack ARG into CL_ARGS.  */
 
135
            assert (cl_args_offset + size + sizeof size < sizeof cl_args);
 
136
            memcpy (&cl_args[cl_args_offset], &size, sizeof size);
 
137
            cl_args_offset += sizeof size;
 
138
            memcpy (&cl_args[cl_args_offset], arg, size);
 
139
            cl_args_offset += size;
 
140
 
 
141
            scalars++;
122
142
            break;
123
143
          }
124
144
 
128
148
          {
129
149
            starpu_data_handle_t handle;
130
150
            handle = starpu_data_lookup (expected->pointer);
131
 
            assert (type == cl->modes[pointer_arg++]);
 
151
 
 
152
            assert (type == cl->modes[pointers]);
132
153
            assert (va_arg (args, void *) == handle);
 
154
            assert (pointers + 1
 
155
                    < sizeof pointer_args_ifaces / sizeof pointer_args_ifaces[0]);
 
156
 
 
157
            pointer_args_ifaces[pointers].ptr = (uintptr_t) expected->pointer;
 
158
            pointer_args_ifaces[pointers].dev_handle =
 
159
              (uintptr_t) expected->pointer;      /* for OpenCL */
 
160
            pointer_args_ifaces[pointers].elemsize = 1;
 
161
            pointer_args_ifaces[pointers].nx = 1;
 
162
            pointer_args_ifaces[pointers].offset = 0;
 
163
 
 
164
            pointers++;
133
165
            break;
134
166
          }
135
167
 
145
177
 
146
178
  tasks_submitted++;
147
179
 
 
180
  /* Finish packing the scalar arguments in CL_ARGS.  */
 
181
  cl_args[0] = (unsigned char) scalars;
 
182
  for (i = 0; i < pointers; i++)
 
183
    pointer_args[i] = &pointer_args_ifaces[i];
 
184
 
 
185
  /* Call the codelets.  */
 
186
  if (cl->where & STARPU_CPU)
 
187
    cl->cpu_funcs[0] (pointer_args, cl_args);
 
188
  if (cl->where & STARPU_OPENCL)
 
189
    cl->opencl_funcs[0] (pointer_args, cl_args);
 
190
  if (cl->where & STARPU_CUDA)
 
191
    cl->cuda_funcs[0] (pointer_args, cl_args);
 
192
 
148
193
  return 0;
149
194
}
150
195
 
164
209
 
165
210
  va_start (args, cl_raw_arg);
166
211
 
167
 
  for (arg = 0, offset = 1, size = 0;
 
212
  for (arg = 0, offset = 1;
168
213
       arg < nargs;
169
214
       arg++, offset += sizeof (size_t) + size)
170
215
    {
171
216
      void *argp;
172
217
 
173
218
      argp = va_arg (args, void *);
174
 
      size = *(size_t *) &cl_arg[size];
 
219
      size = *(size_t *) &cl_arg[offset];
175
220
 
176
 
      memcpy (argp, &cl_arg[offset], size);
 
221
      memcpy (argp, &cl_arg[offset + sizeof size], size);
177
222
    }
178
223
 
179
224
  va_end (args);
279
324
  void *pointer;
280
325
};
281
326
 
282
 
/* Number of `starpu_data_acquire' calls.  */
283
 
static unsigned int data_acquire_calls;
284
 
 
285
 
/* Variable describing the expected `starpu_data_acquire' arguments.  */
 
327
struct data_release_arguments
 
328
{
 
329
  /* Pointer to the data being released.  */
 
330
  void *pointer;
 
331
};
 
332
 
 
333
/* Number of `starpu_data_{acquire,release}' calls.  */
 
334
static unsigned int data_acquire_calls, data_release_calls;
 
335
 
 
336
/* Variable describing the expected `starpu_data_{acquire,release}'
 
337
   arguments.  */
286
338
struct data_acquire_arguments expected_acquire_arguments;
 
339
struct data_release_arguments expected_release_arguments;
287
340
 
288
341
int
289
342
starpu_data_acquire (starpu_data_handle_t handle, enum starpu_access_mode mode)
297
350
  return 0;
298
351
}
299
352
 
 
353
void
 
354
starpu_data_release (starpu_data_handle_t handle)
 
355
{
 
356
  assert (handle_to_pointer (handle) == expected_release_arguments.pointer);
 
357
  data_release_calls++;
 
358
}
 
359
 
300
360
 
301
361
/* Data acquisition.  */
302
362