]>
Commit | Line | Data |
---|---|---|
b8d89b03 | 1 | /* HSA runtime API 1.0.1 representation description. |
a5544970 | 2 | Copyright (C) 2016-2019 Free Software Foundation, Inc. |
b8d89b03 ML |
3 | |
4 | This file is part of GCC. | |
5 | ||
6 | GCC is free software; you can redistribute it and/or modify | |
7 | it under the terms of the GNU General Public License as published by | |
8 | the Free Software Foundation; either version 3, or (at your option) | |
9 | any later version. | |
10 | ||
11 | GCC is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
15 | ||
d190d5c0 JJ |
16 | Under Section 7 of GPL version 3, you are granted additional |
17 | permissions described in the GCC Runtime Library Exception, version | |
18 | 3.1, as published by the Free Software Foundation. | |
19 | ||
20 | You should have received a copy of the GNU General Public License and | |
21 | a copy of the GCC Runtime Library Exception along with this program; | |
22 | see the files COPYING3 and COPYING.RUNTIME respectively. If not, see | |
b8d89b03 ML |
23 | <http://www.gnu.org/licenses/>. |
24 | ||
25 | The contents of the file was created by extracting data structures, enum, | |
26 | typedef and other definitions from HSA Runtime Programmer’s Reference Manual | |
27 | Version 1.0 (http://www.hsafoundation.com/standards/). | |
28 | ||
29 | HTML version is provided on the following link: | |
30 | http://www.hsafoundation.com/html/Content/Runtime/Topics/Runtime_title_page.htm | |
31 | */ | |
32 | ||
33 | #ifndef _HSA_H | |
34 | #define _HSA_H 1 | |
35 | ||
36 | #define HSA_LARGE_MODEL 1 | |
37 | ||
38 | typedef struct hsa_signal_s { uint64_t handle; } hsa_signal_t; | |
39 | typedef enum { | |
40 | HSA_QUEUE_TYPE_MULTI = 0, | |
41 | HSA_QUEUE_TYPE_SINGLE = 1 | |
42 | } hsa_queue_type_t; | |
43 | ||
44 | typedef enum { HSA_PROFILE_BASE = 0, HSA_PROFILE_FULL = 1 } hsa_profile_t; | |
45 | typedef struct hsa_region_s { uint64_t handle; } hsa_region_t; | |
46 | typedef enum { | |
47 | HSA_EXECUTABLE_SYMBOL_INFO_TYPE = 0, | |
48 | HSA_EXECUTABLE_SYMBOL_INFO_NAME_LENGTH = 1, | |
49 | HSA_EXECUTABLE_SYMBOL_INFO_NAME = 2, | |
50 | HSA_EXECUTABLE_SYMBOL_INFO_MODULE_NAME_LENGTH = 3, | |
51 | HSA_EXECUTABLE_SYMBOL_INFO_MODULE_NAME = 4, | |
52 | HSA_EXECUTABLE_SYMBOL_INFO_AGENT = 20, | |
53 | HSA_EXECUTABLE_SYMBOL_INFO_VARIABLE_ADDRESS = 21, | |
54 | HSA_EXECUTABLE_SYMBOL_INFO_LINKAGE = 5, | |
55 | HSA_EXECUTABLE_SYMBOL_INFO_IS_DEFINITION = 17, | |
56 | HSA_EXECUTABLE_SYMBOL_INFO_VARIABLE_ALLOCATION = 6, | |
57 | HSA_EXECUTABLE_SYMBOL_INFO_VARIABLE_SEGMENT = 7, | |
58 | HSA_EXECUTABLE_SYMBOL_INFO_VARIABLE_ALIGNMENT = 8, | |
59 | HSA_EXECUTABLE_SYMBOL_INFO_VARIABLE_SIZE = 9, | |
60 | HSA_EXECUTABLE_SYMBOL_INFO_VARIABLE_IS_CONST = 10, | |
61 | HSA_EXECUTABLE_SYMBOL_INFO_KERNEL_OBJECT = 22, | |
62 | HSA_EXECUTABLE_SYMBOL_INFO_KERNEL_KERNARG_SEGMENT_SIZE = 11, | |
63 | HSA_EXECUTABLE_SYMBOL_INFO_KERNEL_KERNARG_SEGMENT_ALIGNMENT = 12, | |
64 | HSA_EXECUTABLE_SYMBOL_INFO_KERNEL_GROUP_SEGMENT_SIZE = 13, | |
65 | HSA_EXECUTABLE_SYMBOL_INFO_KERNEL_PRIVATE_SEGMENT_SIZE = 14, | |
66 | HSA_EXECUTABLE_SYMBOL_INFO_KERNEL_DYNAMIC_CALLSTACK = 15, | |
67 | HSA_EXECUTABLE_SYMBOL_INFO_INDIRECT_FUNCTION_OBJECT = 23, | |
68 | HSA_EXECUTABLE_SYMBOL_INFO_INDIRECT_FUNCTION_CALL_CONVENTION = 16 | |
69 | } hsa_executable_symbol_info_t; | |
70 | typedef enum { | |
71 | HSA_REGION_GLOBAL_FLAG_KERNARG = 1, | |
72 | HSA_REGION_GLOBAL_FLAG_FINE_GRAINED = 2, | |
73 | HSA_REGION_GLOBAL_FLAG_COARSE_GRAINED = 4 | |
74 | } hsa_region_global_flag_t; | |
75 | typedef struct hsa_code_object_s { uint64_t handle; } hsa_code_object_t; | |
76 | typedef enum { | |
77 | HSA_KERNEL_DISPATCH_PACKET_SETUP_WIDTH_DIMENSIONS = 2 | |
78 | } hsa_kernel_dispatch_packet_setup_width_t; | |
79 | typedef enum { | |
80 | HSA_DEVICE_TYPE_CPU = 0, | |
81 | HSA_DEVICE_TYPE_GPU = 1, | |
82 | HSA_DEVICE_TYPE_DSP = 2 | |
83 | } hsa_device_type_t; | |
84 | typedef enum { | |
85 | HSA_STATUS_SUCCESS = 0x0, | |
86 | HSA_STATUS_INFO_BREAK = 0x1, | |
87 | HSA_STATUS_ERROR = 0x1000, | |
88 | HSA_STATUS_ERROR_INVALID_ARGUMENT = 0x1001, | |
89 | HSA_STATUS_ERROR_INVALID_QUEUE_CREATION = 0x1002, | |
90 | HSA_STATUS_ERROR_INVALID_ALLOCATION = 0x1003, | |
91 | HSA_STATUS_ERROR_INVALID_AGENT = 0x1004, | |
92 | HSA_STATUS_ERROR_INVALID_REGION = 0x1005, | |
93 | HSA_STATUS_ERROR_INVALID_SIGNAL = 0x1006, | |
94 | HSA_STATUS_ERROR_INVALID_QUEUE = 0x1007, | |
95 | HSA_STATUS_ERROR_OUT_OF_RESOURCES = 0x1008, | |
96 | HSA_STATUS_ERROR_INVALID_PACKET_FORMAT = 0x1009, | |
97 | HSA_STATUS_ERROR_RESOURCE_FREE = 0x100A, | |
98 | HSA_STATUS_ERROR_NOT_INITIALIZED = 0x100B, | |
99 | HSA_STATUS_ERROR_REFCOUNT_OVERFLOW = 0x100C, | |
100 | HSA_STATUS_ERROR_INCOMPATIBLE_ARGUMENTS = 0x100D, | |
101 | HSA_STATUS_ERROR_INVALID_INDEX = 0x100E, | |
102 | HSA_STATUS_ERROR_INVALID_ISA = 0x100F, | |
103 | HSA_STATUS_ERROR_INVALID_ISA_NAME = 0x1017, | |
104 | HSA_STATUS_ERROR_INVALID_CODE_OBJECT = 0x1010, | |
105 | HSA_STATUS_ERROR_INVALID_EXECUTABLE = 0x1011, | |
106 | HSA_STATUS_ERROR_FROZEN_EXECUTABLE = 0x1012, | |
107 | HSA_STATUS_ERROR_INVALID_SYMBOL_NAME = 0x1013, | |
108 | HSA_STATUS_ERROR_VARIABLE_ALREADY_DEFINED = 0x1014, | |
109 | HSA_STATUS_ERROR_VARIABLE_UNDEFINED = 0x1015, | |
110 | HSA_STATUS_ERROR_EXCEPTION = 0x1016 | |
111 | } hsa_status_t; | |
112 | typedef enum { | |
113 | HSA_EXTENSION_FINALIZER = 0, | |
114 | HSA_EXTENSION_IMAGES = 1 | |
115 | } hsa_extension_t; | |
116 | typedef struct hsa_queue_s { | |
117 | hsa_queue_type_t type; | |
118 | uint32_t features; | |
119 | ||
120 | #ifdef HSA_LARGE_MODEL | |
121 | void *base_address; | |
122 | #elif defined HSA_LITTLE_ENDIAN | |
123 | void *base_address; | |
124 | uint32_t reserved0; | |
125 | #else | |
126 | uint32_t reserved0; | |
127 | void *base_address; | |
128 | #endif | |
129 | ||
130 | hsa_signal_t doorbell_signal; | |
131 | uint32_t size; | |
132 | uint32_t reserved1; | |
133 | uint64_t id; | |
134 | } hsa_queue_t; | |
135 | typedef struct hsa_agent_dispatch_packet_s { | |
136 | uint16_t header; | |
137 | uint16_t type; | |
138 | uint32_t reserved0; | |
139 | ||
140 | #ifdef HSA_LARGE_MODEL | |
141 | void *return_address; | |
142 | #elif defined HSA_LITTLE_ENDIAN | |
143 | void *return_address; | |
144 | uint32_t reserved1; | |
145 | #else | |
146 | uint32_t reserved1; | |
147 | void *return_address; | |
148 | #endif | |
149 | uint64_t arg[4]; | |
150 | uint64_t reserved2; | |
151 | hsa_signal_t completion_signal; | |
152 | } hsa_agent_dispatch_packet_t; | |
153 | typedef enum { | |
154 | HSA_CODE_SYMBOL_INFO_TYPE = 0, | |
155 | HSA_CODE_SYMBOL_INFO_NAME_LENGTH = 1, | |
156 | HSA_CODE_SYMBOL_INFO_NAME = 2, | |
157 | HSA_CODE_SYMBOL_INFO_MODULE_NAME_LENGTH = 3, | |
158 | HSA_CODE_SYMBOL_INFO_MODULE_NAME = 4, | |
159 | HSA_CODE_SYMBOL_INFO_LINKAGE = 5, | |
160 | HSA_CODE_SYMBOL_INFO_IS_DEFINITION = 17, | |
161 | HSA_CODE_SYMBOL_INFO_VARIABLE_ALLOCATION = 6, | |
162 | HSA_CODE_SYMBOL_INFO_VARIABLE_SEGMENT = 7, | |
163 | HSA_CODE_SYMBOL_INFO_VARIABLE_ALIGNMENT = 8, | |
164 | HSA_CODE_SYMBOL_INFO_VARIABLE_SIZE = 9, | |
165 | HSA_CODE_SYMBOL_INFO_VARIABLE_IS_CONST = 10, | |
166 | HSA_CODE_SYMBOL_INFO_KERNEL_KERNARG_SEGMENT_SIZE = 11, | |
167 | HSA_CODE_SYMBOL_INFO_KERNEL_KERNARG_SEGMENT_ALIGNMENT = 12, | |
168 | HSA_CODE_SYMBOL_INFO_KERNEL_GROUP_SEGMENT_SIZE = 13, | |
169 | HSA_CODE_SYMBOL_INFO_KERNEL_PRIVATE_SEGMENT_SIZE = 14, | |
170 | HSA_CODE_SYMBOL_INFO_KERNEL_DYNAMIC_CALLSTACK = 15, | |
171 | HSA_CODE_SYMBOL_INFO_INDIRECT_FUNCTION_CALL_CONVENTION = 16 | |
172 | } hsa_code_symbol_info_t; | |
173 | typedef enum { | |
174 | HSA_QUEUE_FEATURE_KERNEL_DISPATCH = 1, | |
175 | HSA_QUEUE_FEATURE_AGENT_DISPATCH = 2 | |
176 | } hsa_queue_feature_t; | |
177 | typedef enum { | |
178 | HSA_VARIABLE_ALLOCATION_AGENT = 0, | |
179 | HSA_VARIABLE_ALLOCATION_PROGRAM = 1 | |
180 | } hsa_variable_allocation_t; | |
181 | typedef enum { | |
182 | HSA_FENCE_SCOPE_NONE = 0, | |
183 | HSA_FENCE_SCOPE_AGENT = 1, | |
184 | HSA_FENCE_SCOPE_SYSTEM = 2 | |
185 | } hsa_fence_scope_t; | |
186 | typedef struct hsa_agent_s { uint64_t handle; } hsa_agent_t; | |
187 | typedef enum { HSA_CODE_OBJECT_TYPE_PROGRAM = 0 } hsa_code_object_type_t; | |
188 | typedef enum { | |
189 | HSA_SIGNAL_CONDITION_EQ = 0, | |
190 | HSA_SIGNAL_CONDITION_NE = 1, | |
191 | HSA_SIGNAL_CONDITION_LT = 2, | |
192 | HSA_SIGNAL_CONDITION_GTE = 3 | |
193 | } hsa_signal_condition_t; | |
194 | typedef enum { | |
195 | HSA_EXECUTABLE_STATE_UNFROZEN = 0, | |
196 | HSA_EXECUTABLE_STATE_FROZEN = 1 | |
197 | } hsa_executable_state_t; | |
198 | typedef enum { | |
199 | HSA_ENDIANNESS_LITTLE = 0, | |
200 | HSA_ENDIANNESS_BIG = 1 | |
201 | } hsa_endianness_t; | |
202 | typedef enum { | |
203 | HSA_MACHINE_MODEL_SMALL = 0, | |
204 | HSA_MACHINE_MODEL_LARGE = 1 | |
205 | } hsa_machine_model_t; | |
206 | typedef enum { | |
207 | HSA_AGENT_INFO_NAME = 0, | |
208 | HSA_AGENT_INFO_VENDOR_NAME = 1, | |
209 | HSA_AGENT_INFO_FEATURE = 2, | |
210 | HSA_AGENT_INFO_MACHINE_MODEL = 3, | |
211 | HSA_AGENT_INFO_PROFILE = 4, | |
212 | HSA_AGENT_INFO_DEFAULT_FLOAT_ROUNDING_MODE = 5, | |
213 | HSA_AGENT_INFO_BASE_PROFILE_DEFAULT_FLOAT_ROUNDING_MODES = 23, | |
214 | HSA_AGENT_INFO_FAST_F16_OPERATION = 24, | |
215 | HSA_AGENT_INFO_WAVEFRONT_SIZE = 6, | |
216 | HSA_AGENT_INFO_WORKGROUP_MAX_DIM = 7, | |
217 | HSA_AGENT_INFO_WORKGROUP_MAX_SIZE = 8, | |
218 | HSA_AGENT_INFO_GRID_MAX_DIM = 9, | |
219 | HSA_AGENT_INFO_GRID_MAX_SIZE = 10, | |
220 | HSA_AGENT_INFO_FBARRIER_MAX_SIZE = 11, | |
221 | HSA_AGENT_INFO_QUEUES_MAX = 12, | |
222 | HSA_AGENT_INFO_QUEUE_MIN_SIZE = 13, | |
223 | HSA_AGENT_INFO_QUEUE_MAX_SIZE = 14, | |
224 | HSA_AGENT_INFO_QUEUE_TYPE = 15, | |
225 | HSA_AGENT_INFO_NODE = 16, | |
226 | HSA_AGENT_INFO_DEVICE = 17, | |
227 | HSA_AGENT_INFO_CACHE_SIZE = 18, | |
228 | HSA_AGENT_INFO_ISA = 19, | |
229 | HSA_AGENT_INFO_EXTENSIONS = 20, | |
230 | HSA_AGENT_INFO_VERSION_MAJOR = 21, | |
231 | HSA_AGENT_INFO_VERSION_MINOR = 22 | |
232 | } hsa_agent_info_t; | |
233 | typedef struct hsa_barrier_and_packet_s { | |
234 | uint16_t header; | |
235 | uint16_t reserved0; | |
236 | uint32_t reserved1; | |
237 | hsa_signal_t dep_signal[5]; | |
238 | uint64_t reserved2; | |
239 | hsa_signal_t completion_signal; | |
240 | } hsa_barrier_and_packet_t; | |
241 | typedef struct hsa_dim3_s { | |
242 | uint32_t x; | |
243 | uint32_t y; | |
244 | uint32_t z; | |
245 | } hsa_dim3_t; | |
246 | typedef enum { | |
247 | HSA_ACCESS_PERMISSION_RO = 1, | |
248 | HSA_ACCESS_PERMISSION_WO = 2, | |
249 | HSA_ACCESS_PERMISSION_RW = 3 | |
250 | } hsa_access_permission_t; | |
251 | typedef enum { | |
252 | HSA_AGENT_FEATURE_KERNEL_DISPATCH = 1, | |
253 | HSA_AGENT_FEATURE_AGENT_DISPATCH = 2 | |
254 | } hsa_agent_feature_t; | |
255 | typedef enum { | |
256 | HSA_WAIT_STATE_BLOCKED = 0, | |
257 | HSA_WAIT_STATE_ACTIVE = 1 | |
258 | } hsa_wait_state_t; | |
259 | typedef struct hsa_executable_s { uint64_t handle; } hsa_executable_t; | |
260 | typedef enum { | |
261 | HSA_REGION_SEGMENT_GLOBAL = 0, | |
262 | HSA_REGION_SEGMENT_READONLY = 1, | |
263 | HSA_REGION_SEGMENT_PRIVATE = 2, | |
264 | HSA_REGION_SEGMENT_GROUP = 3 | |
265 | } hsa_region_segment_t; | |
266 | typedef enum { | |
267 | HSA_REGION_INFO_SEGMENT = 0, | |
268 | HSA_REGION_INFO_GLOBAL_FLAGS = 1, | |
269 | HSA_REGION_INFO_SIZE = 2, | |
270 | HSA_REGION_INFO_ALLOC_MAX_SIZE = 4, | |
271 | HSA_REGION_INFO_RUNTIME_ALLOC_ALLOWED = 5, | |
272 | HSA_REGION_INFO_RUNTIME_ALLOC_GRANULE = 6, | |
273 | HSA_REGION_INFO_RUNTIME_ALLOC_ALIGNMENT = 7 | |
274 | } hsa_region_info_t; | |
275 | typedef enum { | |
276 | HSA_ISA_INFO_NAME_LENGTH = 0, | |
277 | HSA_ISA_INFO_NAME = 1, | |
278 | HSA_ISA_INFO_CALL_CONVENTION_COUNT = 2, | |
279 | HSA_ISA_INFO_CALL_CONVENTION_INFO_WAVEFRONT_SIZE = 3, | |
280 | HSA_ISA_INFO_CALL_CONVENTION_INFO_WAVEFRONTS_PER_COMPUTE_UNIT = 4 | |
281 | } hsa_isa_info_t; | |
282 | typedef enum { | |
283 | HSA_VARIABLE_SEGMENT_GLOBAL = 0, | |
284 | HSA_VARIABLE_SEGMENT_READONLY = 1 | |
285 | } hsa_variable_segment_t; | |
286 | typedef struct hsa_callback_data_s { uint64_t handle; } hsa_callback_data_t; | |
287 | typedef enum { | |
288 | HSA_SYMBOL_KIND_VARIABLE = 0, | |
289 | HSA_SYMBOL_KIND_KERNEL = 1, | |
290 | HSA_SYMBOL_KIND_INDIRECT_FUNCTION = 2 | |
291 | } hsa_symbol_kind_t; | |
292 | typedef struct hsa_kernel_dispatch_packet_s { | |
293 | uint16_t header; | |
294 | uint16_t setup; | |
295 | uint16_t workgroup_size_x; | |
296 | uint16_t workgroup_size_y; | |
297 | uint16_t workgroup_size_z; | |
298 | uint16_t reserved0; | |
299 | uint32_t grid_size_x; | |
300 | uint32_t grid_size_y; | |
301 | uint32_t grid_size_z; | |
302 | uint32_t private_segment_size; | |
303 | uint32_t group_segment_size; | |
304 | uint64_t kernel_object; | |
305 | ||
306 | #ifdef HSA_LARGE_MODEL | |
307 | void *kernarg_address; | |
308 | #elif defined HSA_LITTLE_ENDIAN | |
309 | void *kernarg_address; | |
310 | uint32_t reserved1; | |
311 | #else | |
312 | uint32_t reserved1; | |
313 | void *kernarg_address; | |
314 | #endif | |
315 | uint64_t reserved2; | |
316 | hsa_signal_t completion_signal; | |
317 | } hsa_kernel_dispatch_packet_t; | |
318 | typedef enum { | |
319 | HSA_PACKET_TYPE_VENDOR_SPECIFIC = 0, | |
320 | HSA_PACKET_TYPE_INVALID = 1, | |
321 | HSA_PACKET_TYPE_KERNEL_DISPATCH = 2, | |
322 | HSA_PACKET_TYPE_BARRIER_AND = 3, | |
323 | HSA_PACKET_TYPE_AGENT_DISPATCH = 4, | |
324 | HSA_PACKET_TYPE_BARRIER_OR = 5 | |
325 | } hsa_packet_type_t; | |
326 | typedef enum { | |
327 | HSA_PACKET_HEADER_TYPE = 0, | |
328 | HSA_PACKET_HEADER_BARRIER = 8, | |
329 | HSA_PACKET_HEADER_ACQUIRE_FENCE_SCOPE = 9, | |
330 | HSA_PACKET_HEADER_RELEASE_FENCE_SCOPE = 11 | |
331 | } hsa_packet_header_t; | |
332 | typedef struct hsa_isa_s { uint64_t handle; } hsa_isa_t; | |
333 | typedef enum { | |
334 | HSA_DEFAULT_FLOAT_ROUNDING_MODE_DEFAULT = 0, | |
335 | HSA_DEFAULT_FLOAT_ROUNDING_MODE_ZERO = 1, | |
336 | HSA_DEFAULT_FLOAT_ROUNDING_MODE_NEAR = 2 | |
337 | } hsa_default_float_rounding_mode_t; | |
338 | typedef struct hsa_code_symbol_s { uint64_t handle; } hsa_code_symbol_t; | |
339 | typedef struct hsa_executable_symbol_s { | |
340 | uint64_t handle; | |
341 | } hsa_executable_symbol_t; | |
342 | #ifdef HSA_LARGE_MODEL | |
343 | typedef int64_t hsa_signal_value_t; | |
344 | #else | |
345 | typedef int32_t hsa_signal_value_t; | |
346 | #endif | |
347 | typedef enum { | |
348 | HSA_EXCEPTION_POLICY_BREAK = 1, | |
349 | HSA_EXCEPTION_POLICY_DETECT = 2 | |
350 | } hsa_exception_policy_t; | |
351 | typedef enum { | |
352 | HSA_SYSTEM_INFO_VERSION_MAJOR = 0, | |
353 | HSA_SYSTEM_INFO_VERSION_MINOR = 1, | |
354 | HSA_SYSTEM_INFO_TIMESTAMP = 2, | |
355 | HSA_SYSTEM_INFO_TIMESTAMP_FREQUENCY = 3, | |
356 | HSA_SYSTEM_INFO_SIGNAL_MAX_WAIT = 4, | |
357 | HSA_SYSTEM_INFO_ENDIANNESS = 5, | |
358 | HSA_SYSTEM_INFO_MACHINE_MODEL = 6, | |
359 | HSA_SYSTEM_INFO_EXTENSIONS = 7 | |
360 | } hsa_system_info_t; | |
361 | typedef enum { | |
362 | HSA_EXECUTABLE_INFO_PROFILE = 1, | |
363 | HSA_EXECUTABLE_INFO_STATE = 2 | |
364 | } hsa_executable_info_t; | |
365 | typedef enum { | |
366 | HSA_KERNEL_DISPATCH_PACKET_SETUP_DIMENSIONS = 0 | |
367 | } hsa_kernel_dispatch_packet_setup_t; | |
368 | typedef enum { | |
369 | HSA_PACKET_HEADER_WIDTH_TYPE = 8, | |
370 | HSA_PACKET_HEADER_WIDTH_BARRIER = 1, | |
371 | HSA_PACKET_HEADER_WIDTH_ACQUIRE_FENCE_SCOPE = 2, | |
372 | HSA_PACKET_HEADER_WIDTH_RELEASE_FENCE_SCOPE = 2 | |
373 | } hsa_packet_header_width_t; | |
374 | typedef enum { | |
375 | HSA_CODE_OBJECT_INFO_VERSION = 0, | |
376 | HSA_CODE_OBJECT_INFO_TYPE = 1, | |
377 | HSA_CODE_OBJECT_INFO_ISA = 2, | |
378 | HSA_CODE_OBJECT_INFO_MACHINE_MODEL = 3, | |
379 | HSA_CODE_OBJECT_INFO_PROFILE = 4, | |
380 | HSA_CODE_OBJECT_INFO_DEFAULT_FLOAT_ROUNDING_MODE = 5 | |
381 | } hsa_code_object_info_t; | |
382 | typedef struct hsa_barrier_or_packet_s { | |
383 | uint16_t header; | |
384 | uint16_t reserved0; | |
385 | uint32_t reserved1; | |
386 | hsa_signal_t dep_signal[5]; | |
387 | uint64_t reserved2; | |
388 | hsa_signal_t completion_signal; | |
389 | } hsa_barrier_or_packet_t; | |
390 | typedef enum { | |
391 | HSA_SYMBOL_KIND_LINKAGE_MODULE = 0, | |
392 | HSA_SYMBOL_KIND_LINKAGE_PROGRAM = 1, | |
393 | } hsa_symbol_kind_linkage_t; | |
394 | hsa_status_t hsa_executable_validate(hsa_executable_t executable, | |
395 | uint32_t *result); | |
396 | uint64_t hsa_queue_add_write_index_acq_rel(const hsa_queue_t *queue, | |
397 | uint64_t value); | |
398 | ||
399 | uint64_t hsa_queue_add_write_index_acquire(const hsa_queue_t *queue, | |
400 | uint64_t value); | |
401 | ||
402 | uint64_t hsa_queue_add_write_index_relaxed(const hsa_queue_t *queue, | |
403 | uint64_t value); | |
404 | ||
405 | uint64_t hsa_queue_add_write_index_release(const hsa_queue_t *queue, | |
406 | uint64_t value); | |
407 | hsa_status_t hsa_shut_down(); | |
408 | void hsa_signal_add_acq_rel(hsa_signal_t signal, hsa_signal_value_t value); | |
409 | ||
410 | void hsa_signal_add_acquire(hsa_signal_t signal, hsa_signal_value_t value); | |
411 | ||
412 | void hsa_signal_add_relaxed(hsa_signal_t signal, hsa_signal_value_t value); | |
413 | ||
414 | void hsa_signal_add_release(hsa_signal_t signal, hsa_signal_value_t value); | |
415 | hsa_status_t hsa_executable_readonly_variable_define( | |
416 | hsa_executable_t executable, hsa_agent_t agent, const char *variable_name, | |
417 | void *address); | |
418 | hsa_status_t hsa_agent_extension_supported(uint16_t extension, | |
419 | hsa_agent_t agent, | |
420 | uint16_t version_major, | |
421 | uint16_t version_minor, | |
422 | bool *result); | |
423 | hsa_signal_value_t hsa_signal_load_acquire(hsa_signal_t signal); | |
424 | ||
425 | hsa_signal_value_t hsa_signal_load_relaxed(hsa_signal_t signal); | |
426 | hsa_status_t hsa_executable_get_info(hsa_executable_t executable, | |
427 | hsa_executable_info_t attribute, | |
428 | void *value); | |
429 | hsa_status_t hsa_iterate_agents(hsa_status_t (*callback)(hsa_agent_t agent, | |
430 | void *data), | |
431 | void *data); | |
432 | void hsa_signal_subtract_acq_rel(hsa_signal_t signal, hsa_signal_value_t value); | |
433 | ||
434 | void hsa_signal_subtract_acquire(hsa_signal_t signal, hsa_signal_value_t value); | |
435 | ||
436 | void hsa_signal_subtract_relaxed(hsa_signal_t signal, hsa_signal_value_t value); | |
437 | ||
438 | void hsa_signal_subtract_release(hsa_signal_t signal, hsa_signal_value_t value); | |
439 | hsa_status_t | |
440 | hsa_executable_symbol_get_info(hsa_executable_symbol_t executable_symbol, | |
441 | hsa_executable_symbol_info_t attribute, | |
442 | void *value); | |
443 | void hsa_signal_xor_acq_rel(hsa_signal_t signal, hsa_signal_value_t value); | |
444 | ||
445 | void hsa_signal_xor_acquire(hsa_signal_t signal, hsa_signal_value_t value); | |
446 | ||
447 | void hsa_signal_xor_relaxed(hsa_signal_t signal, hsa_signal_value_t value); | |
448 | ||
449 | void hsa_signal_xor_release(hsa_signal_t signal, hsa_signal_value_t value); | |
450 | hsa_status_t hsa_code_object_get_info(hsa_code_object_t code_object, | |
451 | hsa_code_object_info_t attribute, | |
452 | void *value); | |
453 | hsa_status_t hsa_code_object_deserialize(void *serialized_code_object, | |
454 | size_t serialized_code_object_size, | |
455 | const char *options, | |
456 | hsa_code_object_t *code_object); | |
457 | hsa_status_t hsa_status_string(hsa_status_t status, const char **status_string); | |
458 | hsa_status_t hsa_code_object_get_symbol(hsa_code_object_t code_object, | |
459 | const char *symbol_name, | |
460 | hsa_code_symbol_t *symbol); | |
461 | void hsa_signal_store_relaxed(hsa_signal_t signal, hsa_signal_value_t value); | |
462 | ||
463 | void hsa_signal_store_release(hsa_signal_t signal, hsa_signal_value_t value); | |
464 | hsa_status_t hsa_signal_destroy(hsa_signal_t signal); | |
465 | hsa_status_t hsa_system_get_extension_table(uint16_t extension, | |
466 | uint16_t version_major, | |
467 | uint16_t version_minor, | |
468 | void *table); | |
469 | hsa_status_t hsa_agent_iterate_regions( | |
470 | hsa_agent_t agent, | |
471 | hsa_status_t (*callback)(hsa_region_t region, void *data), void *data); | |
472 | hsa_status_t hsa_executable_agent_global_variable_define( | |
473 | hsa_executable_t executable, hsa_agent_t agent, const char *variable_name, | |
474 | void *address); | |
475 | hsa_status_t hsa_queue_create(hsa_agent_t agent, uint32_t size, | |
476 | hsa_queue_type_t type, | |
477 | void (*callback)(hsa_status_t status, | |
478 | hsa_queue_t *source, void *data), | |
479 | void *data, uint32_t private_segment_size, | |
480 | uint32_t group_segment_size, hsa_queue_t **queue); | |
481 | hsa_status_t hsa_isa_compatible(hsa_isa_t code_object_isa, hsa_isa_t agent_isa, | |
482 | bool *result); | |
483 | hsa_status_t hsa_code_object_serialize( | |
484 | hsa_code_object_t code_object, | |
485 | hsa_status_t (*alloc_callback)(size_t size, hsa_callback_data_t data, | |
486 | void **address), | |
487 | hsa_callback_data_t callback_data, const char *options, | |
488 | void **serialized_code_object, size_t *serialized_code_object_size); | |
489 | hsa_status_t hsa_region_get_info(hsa_region_t region, | |
490 | hsa_region_info_t attribute, void *value); | |
491 | hsa_status_t hsa_executable_freeze(hsa_extension_t executable, | |
492 | const char *options); | |
493 | hsa_status_t hsa_system_extension_supported(uint16_t extension, | |
494 | uint16_t version_major, | |
495 | uint16_t version_minor, | |
496 | bool *result); | |
497 | hsa_signal_value_t hsa_signal_wait_acquire(hsa_signal_t signal, | |
498 | hsa_signal_condition_t condition, | |
499 | hsa_signal_value_t compare_value, | |
500 | uint64_t timeout_hint, | |
501 | hsa_wait_state_t wait_state_hint); | |
502 | ||
503 | hsa_signal_value_t hsa_signal_wait_relaxed(hsa_signal_t signal, | |
504 | hsa_signal_condition_t condition, | |
505 | hsa_signal_value_t compare_value, | |
506 | uint64_t timeout_hint, | |
507 | hsa_wait_state_t wait_state_hint); | |
508 | hsa_status_t hsa_memory_copy(void *dst, const void *src, size_t size); | |
509 | hsa_status_t hsa_memory_free(void *ptr); | |
510 | hsa_status_t hsa_queue_destroy(hsa_queue_t *queue); | |
511 | hsa_status_t hsa_isa_from_name(const char *name, hsa_isa_t *isa); | |
512 | hsa_status_t hsa_isa_get_info(hsa_isa_t isa, hsa_isa_info_t attribute, | |
513 | uint32_t index, void *value); | |
514 | hsa_status_t hsa_signal_create(hsa_signal_value_t initial_value, | |
515 | uint32_t num_consumers, | |
516 | const hsa_agent_t *consumers, | |
517 | hsa_signal_t *signal); | |
518 | hsa_status_t hsa_code_symbol_get_info(hsa_code_symbol_t code_symbol, | |
519 | hsa_code_symbol_info_t attribute, | |
520 | void *value); | |
521 | hsa_signal_value_t hsa_signal_cas_acq_rel(hsa_signal_t signal, | |
522 | hsa_signal_value_t expected, | |
523 | hsa_signal_value_t value); | |
524 | ||
525 | hsa_signal_value_t hsa_signal_cas_acquire(hsa_signal_t signal, | |
526 | hsa_signal_value_t expected, | |
527 | hsa_signal_value_t value); | |
528 | ||
529 | hsa_signal_value_t hsa_signal_cas_relaxed(hsa_signal_t signal, | |
530 | hsa_signal_value_t expected, | |
531 | hsa_signal_value_t value); | |
532 | ||
533 | hsa_signal_value_t hsa_signal_cas_release(hsa_signal_t signal, | |
534 | hsa_signal_value_t expected, | |
535 | hsa_signal_value_t value); | |
536 | hsa_status_t hsa_code_object_iterate_symbols( | |
537 | hsa_code_object_t code_object, | |
538 | hsa_status_t (*callback)(hsa_code_object_t code_object, | |
539 | hsa_code_symbol_t symbol, void *data), | |
540 | void *data); | |
541 | void hsa_queue_store_read_index_relaxed(const hsa_queue_t *queue, | |
542 | uint64_t value); | |
543 | ||
544 | void hsa_queue_store_read_index_release(const hsa_queue_t *queue, | |
545 | uint64_t value); | |
546 | hsa_status_t hsa_memory_assign_agent(void *ptr, hsa_agent_t agent, | |
547 | hsa_access_permission_t access); | |
548 | hsa_status_t hsa_queue_inactivate(hsa_queue_t *queue); | |
549 | hsa_status_t hsa_executable_get_symbol(hsa_executable_t executable, | |
550 | const char *module_name, | |
551 | const char *symbol_name, | |
552 | hsa_agent_t agent, | |
553 | int32_t call_convention, | |
554 | hsa_executable_symbol_t *symbol); | |
555 | uint64_t hsa_queue_cas_write_index_acq_rel(const hsa_queue_t *queue, | |
556 | uint64_t expected, uint64_t value); | |
557 | ||
558 | uint64_t hsa_queue_cas_write_index_acquire(const hsa_queue_t *queue, | |
559 | uint64_t expected, uint64_t value); | |
560 | ||
561 | uint64_t hsa_queue_cas_write_index_relaxed(const hsa_queue_t *queue, | |
562 | uint64_t expected, uint64_t value); | |
563 | ||
564 | uint64_t hsa_queue_cas_write_index_release(const hsa_queue_t *queue, | |
565 | uint64_t expected, uint64_t value); | |
566 | void hsa_signal_and_acq_rel(hsa_signal_t signal, hsa_signal_value_t value); | |
567 | ||
568 | void hsa_signal_and_acquire(hsa_signal_t signal, hsa_signal_value_t value); | |
569 | ||
570 | void hsa_signal_and_relaxed(hsa_signal_t signal, hsa_signal_value_t value); | |
571 | ||
572 | void hsa_signal_and_release(hsa_signal_t signal, hsa_signal_value_t value); | |
573 | uint64_t hsa_queue_load_read_index_acquire(const hsa_queue_t *queue); | |
574 | ||
575 | uint64_t hsa_queue_load_read_index_relaxed(const hsa_queue_t *queue); | |
576 | hsa_status_t hsa_executable_load_code_object(hsa_executable_t executable, | |
577 | hsa_agent_t agent, | |
578 | hsa_code_object_t code_object, | |
579 | const char *options); | |
580 | uint64_t hsa_queue_load_write_index_acquire(const hsa_queue_t *queue); | |
581 | ||
582 | uint64_t hsa_queue_load_write_index_relaxed(const hsa_queue_t *queue); | |
583 | hsa_status_t hsa_agent_get_exception_policies(hsa_agent_t agent, | |
584 | hsa_profile_t profile, | |
585 | uint16_t *mask); | |
586 | hsa_status_t hsa_memory_deregister(void *ptr, size_t size); | |
587 | void hsa_signal_or_acq_rel(hsa_signal_t signal, hsa_signal_value_t value); | |
588 | ||
589 | void hsa_signal_or_acquire(hsa_signal_t signal, hsa_signal_value_t value); | |
590 | ||
591 | void hsa_signal_or_relaxed(hsa_signal_t signal, hsa_signal_value_t value); | |
592 | ||
593 | void hsa_signal_or_release(hsa_signal_t signal, hsa_signal_value_t value); | |
594 | hsa_status_t hsa_soft_queue_create(hsa_region_t region, uint32_t size, | |
595 | hsa_queue_type_t type, uint32_t features, | |
596 | hsa_signal_t doorbell_signal, | |
597 | hsa_queue_t **queue); | |
598 | hsa_status_t hsa_executable_iterate_symbols( | |
599 | hsa_executable_t executable, | |
600 | hsa_status_t (*callback)(hsa_executable_t executable, | |
601 | hsa_executable_symbol_t symbol, void *data), | |
602 | void *data); | |
603 | hsa_status_t hsa_memory_register(void *ptr, size_t size); | |
604 | void hsa_queue_store_write_index_relaxed(const hsa_queue_t *queue, | |
605 | uint64_t value); | |
606 | ||
607 | void hsa_queue_store_write_index_release(const hsa_queue_t *queue, | |
608 | uint64_t value); | |
609 | hsa_status_t hsa_executable_global_variable_define(hsa_executable_t executable, | |
610 | const char *variable_name, | |
611 | void *address); | |
612 | hsa_status_t hsa_executable_destroy(hsa_executable_t executable); | |
613 | hsa_status_t hsa_code_object_destroy(hsa_code_object_t code_object); | |
614 | hsa_status_t hsa_memory_allocate(hsa_region_t region, size_t size, void **ptr); | |
615 | hsa_signal_value_t hsa_signal_exchange_acq_rel(hsa_signal_t signal, | |
616 | hsa_signal_value_t value); | |
617 | ||
618 | hsa_signal_value_t hsa_signal_exchange_acquire(hsa_signal_t signal, | |
619 | hsa_signal_value_t value); | |
620 | ||
621 | hsa_signal_value_t hsa_signal_exchange_relaxed(hsa_signal_t signal, | |
622 | hsa_signal_value_t value); | |
623 | ||
624 | hsa_signal_value_t hsa_signal_exchange_release(hsa_signal_t signal, | |
625 | hsa_signal_value_t value); | |
626 | hsa_status_t hsa_agent_get_info(hsa_agent_t agent, hsa_agent_info_t attribute, | |
627 | void *value); | |
628 | hsa_status_t hsa_init(); | |
629 | hsa_status_t hsa_system_get_info(hsa_system_info_t attribute, void *value); | |
630 | hsa_status_t hsa_executable_create(hsa_profile_t profile, | |
631 | hsa_executable_state_t executable_state, | |
632 | const char *options, | |
633 | hsa_executable_t *executable); | |
634 | ||
635 | #endif /* _HSA_H */ |