|
111
|
1 /* HSA runtime API 1.0.1 representation description.
|
|
145
|
2 Copyright (C) 2016-2020 Free Software Foundation, Inc.
|
|
111
|
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
|
|
|
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
|
|
|
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 */
|
