File: common_driver.h

package info (click to toggle)
pocl 6.0-7
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid
  • size: 25,320 kB
  • sloc: lisp: 149,513; ansic: 103,778; cpp: 54,947; python: 1,513; sh: 949; ruby: 255; pascal: 226; tcl: 180; makefile: 175; java: 72; xml: 49
file content (178 lines) | stat: -rw-r--r-- 7,792 bytes parent folder | download | duplicates (2)
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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
#include "pocl_export.h"

#ifndef POCL_COMMON_DRIVER_H
#define POCL_COMMON_DRIVER_H

#ifdef __cplusplus
extern "C"
{
#endif

  typedef void (*gvar_init_callback_t)(cl_program program, cl_uint dev_i,
                                       _cl_command_node *fake_cmd);

POCL_EXPORT
  void pocl_driver_read (void *data, void *__restrict__ dst_host_ptr,
                         pocl_mem_identifier *src_mem_id, cl_mem src_buf,
                         size_t offset, size_t size);
POCL_EXPORT
  void pocl_driver_read_rect (void *data, void *__restrict__ dst_host_ptr,
                              pocl_mem_identifier *src_mem_id, cl_mem src_buf,
                              const size_t *buffer_origin,
                              const size_t *host_origin, const size_t *region,
                              size_t buffer_row_pitch,
                              size_t buffer_slice_pitch, size_t host_row_pitch,
                              size_t host_slice_pitch);
POCL_EXPORT
  void pocl_driver_write (void *data, const void *__restrict__ src_host_ptr,
                          pocl_mem_identifier *dst_mem_id, cl_mem dst_buf,
                          size_t offset, size_t size);
POCL_EXPORT
  void pocl_driver_write_rect (void *data,
                               const void *__restrict__ src_host_ptr,
                               pocl_mem_identifier *dst_mem_id, cl_mem dst_buf,
                               const size_t *buffer_origin,
                               const size_t *host_origin, const size_t *region,
                               size_t buffer_row_pitch,
                               size_t buffer_slice_pitch,
                               size_t host_row_pitch, size_t host_slice_pitch);
POCL_EXPORT
  void pocl_driver_copy (void *data, pocl_mem_identifier *dst_mem_id,
                         cl_mem dst_buf, pocl_mem_identifier *src_mem_id,
                         cl_mem src_buf, size_t dst_offset, size_t src_offset,
                         size_t size);

POCL_EXPORT
  void pocl_driver_copy_with_size (void *data,
                                   pocl_mem_identifier *dst_mem_id, cl_mem dst_buf,
                                   pocl_mem_identifier *src_mem_id, cl_mem src_buf,
                                   pocl_mem_identifier *content_size_buf_mem_id,
                                   cl_mem content_size_buf,
                                   size_t dst_offset, size_t src_offset, size_t size);

POCL_EXPORT
  void pocl_driver_copy_rect (void *data, pocl_mem_identifier *dst_mem_id,
                              cl_mem dst_buf, pocl_mem_identifier *src_mem_id,
                              cl_mem src_buf, const size_t *dst_origin,
                              const size_t *src_origin, const size_t *region,
                              size_t dst_row_pitch, size_t dst_slice_pitch,
                              size_t src_row_pitch, size_t src_slice_pitch);
POCL_EXPORT
  void pocl_driver_memfill (void *data, pocl_mem_identifier *dst_mem_id,
                            cl_mem dst_buf, size_t size, size_t offset,
                            const void *__restrict__ pattern,
                            size_t pattern_size);
POCL_EXPORT
  cl_int pocl_driver_map_mem (void *data, pocl_mem_identifier *src_mem_id,
                              cl_mem src_buf, mem_mapping_t *map);
POCL_EXPORT
  cl_int pocl_driver_unmap_mem (void *data, pocl_mem_identifier *dst_mem_id,
                                cl_mem dst_buf, mem_mapping_t *map);

  POCL_EXPORT
  cl_int pocl_driver_get_mapping_ptr (void *data, pocl_mem_identifier *mem_id,
                                      cl_mem mem, mem_mapping_t *map);

  POCL_EXPORT
  cl_int pocl_driver_free_mapping_ptr (void *data, pocl_mem_identifier *mem_id,
                                       cl_mem mem, mem_mapping_t *map);

POCL_EXPORT
cl_int
pocl_driver_alloc_mem_obj (cl_device_id device, cl_mem mem, void *host_ptr);

POCL_EXPORT
void pocl_driver_free (cl_device_id device, cl_mem mem);

POCL_EXPORT
void pocl_driver_svm_fill (cl_device_id dev,
                           void *__restrict__ svm_ptr,
                           size_t size,
                           void *__restrict__ pattern,
                           size_t pattern_size);

POCL_EXPORT
void pocl_driver_svm_copy (cl_device_id dev,
                           void *__restrict__ dst,
                           const void *__restrict__ src,
                           size_t size);

POCL_EXPORT
void pocl_driver_svm_fill_rect (cl_device_id dev,
                                void *__restrict__ svm_ptr,
                                const size_t *origin,
                                const size_t *region,
                                size_t row_pitch,
                                size_t slice_pitch,
                                void *__restrict__ pattern,
                                size_t pattern_size);

POCL_EXPORT
void pocl_driver_svm_copy_rect (cl_device_id dev,
                                void *__restrict__ dst_ptr,
                                const void *__restrict__ src_ptr,
                                const size_t *__restrict__ const dst_origin,
                                const size_t *__restrict__ const src_origin,
                                const size_t *__restrict__ const region,
                                size_t dst_row_pitch,
                                size_t dst_slice_pitch,
                                size_t src_row_pitch,
                                size_t src_slice_pitch);

POCL_EXPORT
int pocl_driver_build_source (cl_program program,
                              cl_uint device_i,
                              cl_uint num_input_headers,
                              const cl_program *input_headers,
                              const char **header_include_names,
                              int link_program);
POCL_EXPORT
int pocl_driver_build_binary (cl_program program,
                              cl_uint device_i,
                              int link_program,
                              int spir_build);
POCL_EXPORT
int pocl_driver_link_program (cl_program program,
                              cl_uint device_i,
                              cl_uint num_input_programs,
                              const cl_program *input_programs,
                              int create_library);
POCL_EXPORT
int pocl_driver_free_program (cl_device_id device,
                              cl_program program,
                              unsigned program_device_i);
POCL_EXPORT
int pocl_driver_setup_metadata (cl_device_id device,
                                cl_program program,
                                unsigned program_device_i);
POCL_EXPORT
int pocl_driver_supports_binary (cl_device_id device,
                                 size_t length,
                                 const char *binary);
POCL_EXPORT
int pocl_driver_build_poclbinary (cl_program program, cl_uint device_i);

POCL_EXPORT
int pocl_driver_build_opencl_builtins (cl_program program, cl_uint device_i);

POCL_EXPORT
void pocl_driver_build_gvar_init_kernel (cl_program program,
                                         cl_uint dev_i,
                                         cl_device_id device,
                                         gvar_init_callback_t callback);

POCL_EXPORT
void pocl_cpu_gvar_init_callback (cl_program program,
                                  cl_uint dev_i,
                                  _cl_command_node *fake_cmd);
POCL_EXPORT
cl_int pocl_driver_get_synchronized_timestamps (cl_device_id dev,
                                                cl_ulong *dev_timestamp,
                                                cl_ulong *host_timestamp);


#ifdef __cplusplus
}
#endif

#endif