File: build_nd_range.cl

package info (click to toggle)
intel-graphics-compiler 1.0.12504.6-1%2Bdeb12u1
  • links: PTS, VCS
  • area: main
  • in suites: bookworm
  • size: 83,912 kB
  • sloc: cpp: 910,147; lisp: 202,655; ansic: 15,197; python: 4,025; yacc: 2,241; lex: 1,570; pascal: 244; sh: 104; makefile: 25
file content (69 lines) | stat: -rw-r--r-- 4,978 bytes parent folder | download | duplicates (3)
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
/*========================== begin_copyright_notice ============================

Copyright (C) 2017-2021 Intel Corporation

SPDX-License-Identifier: MIT

============================= end_copyright_notice ===========================*/

// Device-Side Enqueue Instructions dependent on pointer size
#if (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)

void __builtin_IB_copyNDRangeTondrange(ndrange_t* out, Ndrange_t* in)
{
    out->workDimension       = in->dim;
    out->globalWorkOffset[0] = in->globalWorkOffset[0];
    out->globalWorkOffset[1] = in->globalWorkOffset[1];
    out->globalWorkOffset[2] = in->globalWorkOffset[2];
    out->globalWorkSize[0]   = in->globalWorkSize[0];
    out->globalWorkSize[1]   = in->globalWorkSize[1];
    out->globalWorkSize[2]   = in->globalWorkSize[2];
    out->localWorkSize[0]    = in->localWorkSize[0];
    out->localWorkSize[1]    = in->localWorkSize[1];
    out->localWorkSize[2]    = in->localWorkSize[2];
}

#define DEF_BUILD_NDRANGE_1D(TYPE, MANGLING)                                                                                                \
Ndrange_t SPIRV_OVERLOADABLE SPIRV_BUILTIN(BuildNDRange, MANGLING, _1D)(TYPE GlobalWorkSize, TYPE LocalWorkSize, TYPE GlobalWorkOffset)     \
{                                                                                                                                           \
  Ndrange_t range = { 1, {GlobalWorkOffset, 0, 0}, {GlobalWorkSize, 1, 1}, {LocalWorkSize, 0, 0} };                                         \
  return range;                                                                                                                             \
}

#define DEF_BUILD_NDRANGE_2D(TYPE, MANGLING)                                                                                                      \
Ndrange_t SPIRV_OVERLOADABLE SPIRV_BUILTIN(BuildNDRange, MANGLING, _2D)(TYPE GlobalWorkSize[2], TYPE LocalWorkSize[2], TYPE GlobalWorkOffset[2])  \
{                                                                                                                                                 \
  Ndrange_t range = {                                                                                                                             \
    2,                                                                                                                                            \
    {GlobalWorkOffset[0], GlobalWorkOffset[1], 0},                                                                                                \
    {GlobalWorkSize[0], GlobalWorkSize[1], 1},                                                                                                    \
    {LocalWorkSize[0], LocalWorkSize[1], 0}                                                                                                       \
  };                                                                                                                                              \
  return range;                                                                                                                                   \
}

#define DEF_BUILD_NDRANGE_3D(TYPE, MANGLING)                                                                                                      \
Ndrange_t SPIRV_OVERLOADABLE SPIRV_BUILTIN(BuildNDRange, MANGLING, _3D)(TYPE GlobalWorkSize[3], TYPE LocalWorkSize[3], TYPE GlobalWorkOffset[3])  \
{                                                                                                                                                 \
  Ndrange_t range = {                                                                                                                             \
    3,                                                                                                                                            \
    {GlobalWorkOffset[0], GlobalWorkOffset[1], GlobalWorkOffset[2]},                                                                              \
    {GlobalWorkSize[0], GlobalWorkSize[1], GlobalWorkSize[2]},                                                                                    \
    {LocalWorkSize[0], LocalWorkSize[1], LocalWorkSize[2]}                                                                                        \
  };                                                                                                                                              \
  return range;                                                                                                                                   \
}

#if __32bit__ > 0
DEF_BUILD_NDRANGE_1D(int, _i32_i32_i32)
DEF_BUILD_NDRANGE_2D(int, _a2i32_a2i32_a2i32)
DEF_BUILD_NDRANGE_3D(int, _a3i32_a3i32_a3i32)
#else
DEF_BUILD_NDRANGE_1D(long, _i64_i64_i64)
DEF_BUILD_NDRANGE_2D(long, _a2i64_a2i64_a2i64)
DEF_BUILD_NDRANGE_3D(long, _a3i64_a3i64_a3i64)
#endif


#endif // __OPENCL_C_VERSION__ >= CL_VERSION_2_0