1 /* Copyright Statement:
2 *
3 * This software/firmware and related documentation ("MediaTek Software") are
4 * protected under relevant copyright laws. The information contained herein
5 * is confidential and proprietary to MediaTek Inc. and/or its licensors.
6 * Without the prior written permission of MediaTek inc. and/or its licensors,
7 * any reproduction, modification, use or disclosure of MediaTek Software,
8 * and information contained herein, in whole or in part, shall be strictly
9 * prohibited.
10 */
11 /* MediaTek Inc. (C) 2020. All rights reserved.
12 *
13 * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
14 * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
15 * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON
16 * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
17 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
19 * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
20 * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
21 * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
22 * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY
23 * ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY
24 * THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK
25 * SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO
26 * RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN
27 * FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
28 * CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER
29 * WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT
30 * ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER
31 * TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
32 *
33 * The following software/firmware and/or related documentation ("MediaTek
34 * Software") have been modified by MediaTek Inc. All revisions are subject to
35 * any receiver's applicable license agreements with MediaTek Inc.
36 */
37
38 #pragma once
39
40 #include <android/log.h>
41 #include <dlfcn.h>
42 #include "NeuronAdapter.h"
43
44 #define LOAD_ADAPTER_FUNCTION(name) \
45 static name##_fn fn = reinterpret_cast<name##_fn>(loadAdapterFunction(#name));
46
47 #define EXECUTE_ADAPTER_FUNCTION(...) \
48 if (fn != nullptr) { \
49 fn(__VA_ARGS__); \
50 }
51
52 #define EXECUTE_ADAPTER_FUNCTION_RETURN_INT(...) \
53 return fn != nullptr ? fn(__VA_ARGS__) : -1;
54
55 #define EXECUTE_ADAPTER_FUNCTION_RETURN_BOOL(...) \
56 return fn != nullptr ? fn(__VA_ARGS__) : false;
57
58 static void* sHandle = nullptr;
loadAdapterLibrary(const char * name)59 inline void* loadAdapterLibrary(const char* name) {
60 sHandle = dlopen(name, RTLD_LAZY | RTLD_LOCAL);
61 if (sHandle == nullptr) {
62 __android_log_print(
63 ANDROID_LOG_ERROR, "AdapterShimApi", "Unable to open library %s", name);
64 }
65 return sHandle;
66 }
67
getAdapterLibraryHandle()68 inline void* getAdapterLibraryHandle() {
69 if (sHandle == nullptr) {
70 sHandle = loadAdapterLibrary("libneuronusdk_adapter.mtk.so");
71 }
72 if (sHandle == nullptr) {
73 sHandle = loadAdapterLibrary("libneuron_adapter_mgvi.so");
74 }
75 if (sHandle == nullptr) {
76 sHandle = loadAdapterLibrary("libneuron_adapter.so");
77 }
78 return sHandle;
79 }
80
loadAdapterFunction(const char * name)81 inline void* loadAdapterFunction(const char* name) {
82 void* fn = nullptr;
83 if (getAdapterLibraryHandle() != nullptr) {
84 fn = dlsym(getAdapterLibraryHandle(), name);
85 }
86
87 if (fn == nullptr) {
88 __android_log_print(
89 ANDROID_LOG_ERROR,
90 "AdapterShimApi",
91 "Unable to open function %s",
92 name);
93 }
94
95 return fn;
96 }
97
98 /*************************************************************************************************/
99 typedef int (*Neuron_getVersion_fn)(NeuronRuntimeVersion* version);
100
101 typedef int (*Neuron_getFeatureSupportedStatus_fn)(
102 NeuronFeatureType type,
103 bool* supported);
104
105 typedef int (*Neuron_getNeuroPilotMagicNumber_fn)(int32_t* magic);
106
107 typedef int (*Neuron_getL1MemorySizeKb_fn)(uint32_t* sizeKb);
108
109 typedef int (*NeuronModel_create_fn)(NeuronModel** model);
110
111 typedef void (*NeuronModel_free_fn)(NeuronModel* model);
112
113 typedef int (*NeuronModel_finish_fn)(NeuronModel* model);
114
115 typedef int (*NeuronModel_addOperand_fn)(
116 NeuronModel* model,
117 const NeuronOperandType* type);
118
119 typedef int (*NeuronModel_setOperandValue_fn)(
120 NeuronModel* model,
121 int32_t index,
122 const void* buffer,
123 size_t length);
124
125 typedef int (*NeuronModel_setOperandValueFromModel_fn)(
126 NeuronModel* model,
127 int32_t index,
128 const NeuronModel* value);
129
130 typedef int (*NeuronModel_setOperandSymmPerChannelQuantParams_fn)(
131 NeuronModel* model,
132 int32_t index,
133 const NeuronSymmPerChannelQuantParams* channelQuant);
134
135 typedef int (*NeuronModel_setOperandPerChannelQuantParams_fn)(
136 NeuronModel* model,
137 int32_t index,
138 const NeuronPerChannelQuantParams* channelQuant);
139
140 typedef int (*NeuronModel_addOperation_fn)(
141 NeuronModel* model,
142 NeuronOperationType type,
143 uint32_t inputCount,
144 const uint32_t* inputs,
145 uint32_t outputCount,
146 const uint32_t* outputs);
147
148 typedef int (*NeuronModel_addOperationExtension_fn)(
149 NeuronModel* model,
150 const char* name,
151 const char* vendor,
152 const NeuronDevice* device,
153 uint32_t inputCount,
154 const uint32_t* inputs,
155 uint32_t outputCount,
156 const uint32_t* outputs);
157
158 typedef int (*NeuronModel_identifyInputsAndOutputs_fn)(
159 NeuronModel* model,
160 uint32_t inputCount,
161 const uint32_t* inputs,
162 uint32_t outputCount,
163 const uint32_t* outputs);
164
165 typedef int (*NeuronModel_getSupportedOperations_fn)(
166 NeuronModel* model,
167 bool* supported,
168 uint32_t operationCount);
169
170 typedef int (*NeuronModel_getSupportedOperationsForDevices_fn)(
171 const NeuronModel* model,
172 const NeuronDevice* const* devices,
173 uint32_t numDevices,
174 bool* supportedOps);
175
176 typedef int (*NeuronModel_relaxComputationFloat32toFloat16_fn)(
177 NeuronModel* model,
178 bool allow);
179
180 typedef int (
181 *NeuronModel_suppressInputConversion_fn)(NeuronModel* model, bool suppress);
182
183 typedef int (*NeuronModel_suppressOutputConversion_fn)(
184 NeuronModel* model,
185 bool suppress);
186
187 typedef int (*NeuronModel_restoreFromCompiledNetwork_fn)(
188 NeuronModel** model,
189 NeuronCompilation** compilation,
190 const void* buffer,
191 const size_t size);
192
193 typedef int (*NeuronCompilation_create_fn)(
194 NeuronModel* model,
195 NeuronCompilation** compilation);
196
197 typedef int (*NeuronCompilation_createV2_fn)(
198 NeuronModel* model,
199 CompilationType type,
200 const char* options,
201 NeuronCompilation** compilation);
202
203 typedef int (*NeuronCompilation_createForDevices_fn)(
204 NeuronModel* model,
205 const NeuronDevice* const* devices,
206 uint32_t numDevices,
207 NeuronCompilation** compilation);
208
209 typedef int (*NeuronCompilation_createForDebug_fn)(
210 NeuronModel* model,
211 NeuronCompilation** compilation);
212
213 typedef void (*NeuronCompilation_free_fn)(NeuronCompilation* compilation);
214
215 typedef int (*NeuronCompilation_finish_fn)(NeuronCompilation* compilation);
216
217 typedef int (*NeuronCompilation_getSupportedOperations_fn)(
218 NeuronCompilation* compilation,
219 uint32_t operationCount,
220 bool* supported);
221
222 typedef int (*NeuronCompilation_setCaching_fn)(
223 NeuronCompilation* compilation,
224 const char* cacheDir,
225 const uint8_t* token);
226
227 typedef int (*NeuronCompilation_setPreference_fn)(
228 NeuronCompilation* compilation,
229 int32_t preference);
230
231 typedef int (*NeuronCompilation_setPriority_fn)(
232 NeuronCompilation* compilation,
233 int32_t priority);
234
235 typedef int (*NeuronCompilation_getInputPaddedDimensions_fn)(
236 NeuronCompilation* compilation,
237 int32_t index,
238 uint32_t* dimensions);
239
240 typedef int (*NeuronCompilation_getOutputPaddedDimensions_fn)(
241 NeuronCompilation* compilation,
242 int32_t index,
243 uint32_t* dimensions);
244
245 typedef int (*NeuronCompilation_getInputPaddedSize_fn)(
246 NeuronCompilation* compilation,
247 int32_t index,
248 size_t* size);
249
250 typedef int (*NeuronCompilation_getOutputPaddedSize_fn)(
251 NeuronCompilation* compilation,
252 int32_t index,
253 size_t* size);
254
255 typedef int (*NeuronCompilation_getCompiledNetworkSize_fn)(
256 NeuronCompilation* compilation,
257 size_t* size);
258
259 typedef int (*NeuronCompilation_storeCompiledNetwork_fn)(
260 NeuronCompilation* compilation,
261 void* buffer,
262 const size_t size);
263
264 typedef int (*NeuronCompilation_setOptimizationHint_fn)(
265 NeuronCompilation* compilation,
266 uint32_t optimizationCode);
267
268 typedef int (*NeuronCompilation_setOptimizationString_fn)(
269 NeuronCompilation* compilation,
270 const char* optimizationString);
271
272 typedef int (*NeuronCompilation_setTrimIOAlignment_fn)(
273 NeuronCompilation* compilation,
274 bool enable);
275
276 typedef int (*NeuronCompilation_setSWDilatedConv_fn)(
277 NeuronCompilation* compilation,
278 bool enable);
279
280 typedef int (*NeuronExecution_create_fn)(
281 NeuronCompilation* compilation,
282 NeuronExecution** execution);
283
284 typedef void (*NeuronExecution_free_fn)(NeuronExecution* execution);
285
286 typedef int (*NeuronExecution_setInput_fn)(
287 NeuronExecution* execution,
288 int32_t index,
289 const NeuronOperandType* type,
290 const void* buffer,
291 size_t length);
292
293 typedef int (*NeuronExecution_setOutput_fn)(
294 NeuronExecution* execution,
295 int32_t index,
296 const NeuronOperandType* type,
297 void* buffer,
298 size_t length);
299
300 typedef int (*NeuronExecution_setInputFromMemory_fn)(
301 NeuronExecution* execution,
302 uint32_t index,
303 const NeuronOperandType* type,
304 const NeuronMemory* memory,
305 size_t offset,
306 size_t length);
307
308 typedef int (*NeuronExecution_setOutputFromMemory_fn)(
309 NeuronExecution* execution,
310 uint32_t index,
311 const NeuronOperandType* type,
312 const NeuronMemory* memory,
313 size_t offset,
314 size_t length);
315
316 typedef int (*NeuronMemory_createFromFd_fn)(
317 size_t size,
318 int protect,
319 int fd,
320 size_t offset,
321 NeuronMemory** memory);
322
323 typedef int (*NeuronMemory_createFromAHardwareBuffer_fn)(
324 const AHardwareBuffer* ahwb,
325 NeuronMemory** memory);
326
327 typedef void (*NeuronMemory_free_fn)(NeuronMemory* memory);
328
329 typedef int (*NeuronExecution_compute_fn)(NeuronExecution* execution);
330
331 typedef int (*NeuronExecution_startComputeWithDependencies_fn)(
332 NeuronExecution* execution,
333 const NeuronEvent* const* dependencies,
334 uint32_t num_dependencies,
335 uint64_t duration,
336 NeuronEvent** event);
337
338 typedef int (
339 *NeuronEvent_getSyncFenceFd_fn)(const NeuronEvent* event, int* syncFenceFd);
340
341 typedef int (*NeuronEvent_wait_fn)(NeuronEvent* event);
342
343 typedef void (*NeuronEvent_free_fn)(NeuronEvent* event);
344
345 typedef int (*NeuronExecution_setLoopTimeout_fn)(
346 NeuronExecution* execution,
347 uint64_t duration);
348
349 typedef int (*NeuronExecution_setBoostHint_fn)(
350 NeuronExecution* execution,
351 uint8_t boostValue);
352
353 typedef int (*NeuronCompilation_createForMultiExecutions_fn)(
354 NeuronModel* model,
355 NeuronCompilation** compilation);
356
357 typedef int (
358 *NeuronDebug_setReportPath_fn)(NeuronModel* model, const char* path);
359
360 typedef int (*Neuron_getDeviceCount_fn)(uint32_t* numDevices);
361
362 typedef int (*Neuron_getDevice_fn)(uint32_t devIndex, NeuronDevice** device);
363
364 typedef int (
365 *NeuronDevice_getName_fn)(const NeuronDevice* device, const char** name);
366
367 typedef int (*NeuronDevice_getDescription_fn)(
368 const NeuronDevice* device,
369 const char** description);
370
371 typedef int (*NeuronDevice_getExtensionSupport_fn)(
372 const char* extensionName,
373 bool* isExtensionSupported);
374
375 typedef int (*NeuronModel_getExtensionOperandType_fn)(
376 NeuronModel* model,
377 const char* extensionName,
378 uint16_t operandCodeWithinExtension,
379 int32_t* type);
380
381 typedef int (*NeuronModel_getExtensionOperationType_fn)(
382 NeuronModel* model,
383 const char* extensionName,
384 uint16_t operationCodeWithinExtension,
385 int32_t* type);
386
387 typedef int (*NeuronModel_setOperandExtensionData_fn)(
388 NeuronModel* model,
389 int32_t index,
390 const void* data,
391 size_t length);
392
393 typedef int (*NeuronCompilation_createForBatch_fn)(
394 NeuronModel* model,
395 NeuronCompilation** compilation);
396
397 typedef int (*NeuronModel_restoreFromCompiledNetworkV2_fn)(
398 NeuronModel** model,
399 NeuronCompilation** compilation,
400 const void* buffer,
401 const size_t size,
402 const CompilationType& type);
403
404 typedef int (*NeuronExecution_setRunnerPoolSize_fn)(
405 NeuronExecution* execution,
406 uint8_t numRunners);
407
408 typedef int (*NeuronExecution_setBatchDone_fn)(NeuronExecution* execution);
409
410 typedef int (
411 *NeuronExecution_setIODone_fn)(NeuronExecution* execution, int idx);
412
413 typedef int (*NeuronCompilation_createWithOptions_fn)(
414 NeuronModel* model,
415 NeuronCompilation** compilation,
416 const char* options);
417 /*************************************************************************************************/
418
Neuron_getVersion(NeuronRuntimeVersion * version)419 inline int Neuron_getVersion(NeuronRuntimeVersion* version) {
420 LOAD_ADAPTER_FUNCTION(Neuron_getVersion);
421 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(version);
422 }
423
Neuron_getFeatureSupportedStatus(NeuronFeatureType type,bool * supported)424 inline int Neuron_getFeatureSupportedStatus(
425 NeuronFeatureType type,
426 bool* supported) {
427 LOAD_ADAPTER_FUNCTION(Neuron_getFeatureSupportedStatus);
428 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(type, supported);
429 }
430
Neuron_getNeuroPilotMagicNumber(int32_t * magic)431 inline int Neuron_getNeuroPilotMagicNumber(int32_t* magic) {
432 LOAD_ADAPTER_FUNCTION(Neuron_getNeuroPilotMagicNumber);
433 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(magic);
434 }
435
Neuron_getL1MemorySizeKb(uint32_t * sizeKb)436 inline int Neuron_getL1MemorySizeKb(uint32_t* sizeKb) {
437 LOAD_ADAPTER_FUNCTION(Neuron_getL1MemorySizeKb);
438 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(sizeKb);
439 }
440
NeuronModel_create(NeuronModel ** model)441 inline int NeuronModel_create(NeuronModel** model) {
442 LOAD_ADAPTER_FUNCTION(NeuronModel_create);
443 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model);
444 }
445
NeuronModel_free(NeuronModel * model)446 inline void NeuronModel_free(NeuronModel* model) {
447 LOAD_ADAPTER_FUNCTION(NeuronModel_free);
448 EXECUTE_ADAPTER_FUNCTION(model);
449 }
450
NeuronModel_finish(NeuronModel * model)451 inline int NeuronModel_finish(NeuronModel* model) {
452 LOAD_ADAPTER_FUNCTION(NeuronModel_finish);
453 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model);
454 }
455
NeuronModel_addOperand(NeuronModel * model,const NeuronOperandType * type)456 inline int NeuronModel_addOperand(
457 NeuronModel* model,
458 const NeuronOperandType* type) {
459 LOAD_ADAPTER_FUNCTION(NeuronModel_addOperand);
460 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, type);
461 }
462
NeuronModel_setOperandValue(NeuronModel * model,int32_t index,const void * buffer,size_t length)463 inline int NeuronModel_setOperandValue(
464 NeuronModel* model,
465 int32_t index,
466 const void* buffer,
467 size_t length) {
468 LOAD_ADAPTER_FUNCTION(NeuronModel_setOperandValue);
469 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, index, buffer, length);
470 }
471
NeuronModel_setOperandValueFromModel(NeuronModel * model,int32_t index,const NeuronModel * value)472 inline int NeuronModel_setOperandValueFromModel(
473 NeuronModel* model,
474 int32_t index,
475 const NeuronModel* value) {
476 LOAD_ADAPTER_FUNCTION(NeuronModel_setOperandValueFromModel);
477 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, index, value);
478 }
479
NeuronModel_setOperandSymmPerChannelQuantParams(NeuronModel * model,int32_t index,const NeuronSymmPerChannelQuantParams * channelQuant)480 inline int NeuronModel_setOperandSymmPerChannelQuantParams(
481 NeuronModel* model,
482 int32_t index,
483 const NeuronSymmPerChannelQuantParams* channelQuant) {
484 LOAD_ADAPTER_FUNCTION(NeuronModel_setOperandSymmPerChannelQuantParams);
485 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, index, channelQuant);
486 }
487
NeuronModel_setOperandPerChannelQuantParams(NeuronModel * model,int32_t index,const NeuronPerChannelQuantParams * channelQuant)488 inline int NeuronModel_setOperandPerChannelQuantParams(
489 NeuronModel* model,
490 int32_t index,
491 const NeuronPerChannelQuantParams* channelQuant) {
492 LOAD_ADAPTER_FUNCTION(NeuronModel_setOperandPerChannelQuantParams);
493 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, index, channelQuant);
494 }
495
NeuronModel_addOperation(NeuronModel * model,NeuronOperationType type,uint32_t inputCount,const uint32_t * inputs,uint32_t outputCount,const uint32_t * outputs)496 inline int NeuronModel_addOperation(
497 NeuronModel* model,
498 NeuronOperationType type,
499 uint32_t inputCount,
500 const uint32_t* inputs,
501 uint32_t outputCount,
502 const uint32_t* outputs) {
503 LOAD_ADAPTER_FUNCTION(NeuronModel_addOperation);
504 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(
505 model, type, inputCount, inputs, outputCount, outputs);
506 }
507
NeuronModel_addOperationExtension(NeuronModel * model,const char * name,const char * vendor,const NeuronDevice * device,uint32_t inputCount,const uint32_t * inputs,uint32_t outputCount,const uint32_t * outputs)508 inline int NeuronModel_addOperationExtension(
509 NeuronModel* model,
510 const char* name,
511 const char* vendor,
512 const NeuronDevice* device,
513 uint32_t inputCount,
514 const uint32_t* inputs,
515 uint32_t outputCount,
516 const uint32_t* outputs) {
517 LOAD_ADAPTER_FUNCTION(NeuronModel_addOperationExtension);
518 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(
519 model, name, vendor, device, inputCount, inputs, outputCount, outputs);
520 }
521
NeuronModel_identifyInputsAndOutputs(NeuronModel * model,uint32_t inputCount,const uint32_t * inputs,uint32_t outputCount,const uint32_t * outputs)522 inline int NeuronModel_identifyInputsAndOutputs(
523 NeuronModel* model,
524 uint32_t inputCount,
525 const uint32_t* inputs,
526 uint32_t outputCount,
527 const uint32_t* outputs) {
528 LOAD_ADAPTER_FUNCTION(NeuronModel_identifyInputsAndOutputs);
529 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(
530 model, inputCount, inputs, outputCount, outputs);
531 }
532
NeuronModel_getSupportedOperations(NeuronModel * model,bool * supported,uint32_t operationCount)533 inline int NeuronModel_getSupportedOperations(
534 NeuronModel* model,
535 bool* supported,
536 uint32_t operationCount) {
537 LOAD_ADAPTER_FUNCTION(NeuronModel_getSupportedOperations);
538 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, supported, operationCount);
539 }
540
NeuronModel_getSupportedOperationsForDevices(const NeuronModel * model,const NeuronDevice * const * devices,uint32_t numDevices,bool * supportedOps)541 inline int NeuronModel_getSupportedOperationsForDevices(
542 const NeuronModel* model,
543 const NeuronDevice* const* devices,
544 uint32_t numDevices,
545 bool* supportedOps) {
546 LOAD_ADAPTER_FUNCTION(NeuronModel_getSupportedOperationsForDevices);
547 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, devices, numDevices, supportedOps);
548 }
549
NeuronCompilation_getSupportedOperations(NeuronCompilation * compilation,uint32_t operationCount,bool * supported)550 inline int NeuronCompilation_getSupportedOperations(
551 NeuronCompilation* compilation,
552 uint32_t operationCount,
553 bool* supported) {
554 LOAD_ADAPTER_FUNCTION(NeuronCompilation_getSupportedOperations);
555 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(compilation, operationCount, supported);
556 }
557
NeuronModel_relaxComputationFloat32toFloat16(NeuronModel * model,bool allow)558 inline int NeuronModel_relaxComputationFloat32toFloat16(
559 NeuronModel* model,
560 bool allow) {
561 LOAD_ADAPTER_FUNCTION(NeuronModel_relaxComputationFloat32toFloat16);
562 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, allow);
563 }
564
NeuronModel_suppressInputConversion(NeuronModel * model,bool suppress)565 inline int NeuronModel_suppressInputConversion(
566 NeuronModel* model,
567 bool suppress) {
568 LOAD_ADAPTER_FUNCTION(NeuronModel_suppressInputConversion);
569 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, suppress);
570 }
571
NeuronModel_suppressOutputConversion(NeuronModel * model,bool suppress)572 inline int NeuronModel_suppressOutputConversion(
573 NeuronModel* model,
574 bool suppress) {
575 LOAD_ADAPTER_FUNCTION(NeuronModel_suppressOutputConversion);
576 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, suppress);
577 }
578
NeuronModel_restoreFromCompiledNetwork(NeuronModel ** model,NeuronCompilation ** compilation,const void * buffer,const size_t size)579 inline int NeuronModel_restoreFromCompiledNetwork(
580 NeuronModel** model,
581 NeuronCompilation** compilation,
582 const void* buffer,
583 const size_t size) {
584 LOAD_ADAPTER_FUNCTION(NeuronModel_restoreFromCompiledNetwork);
585 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, compilation, buffer, size);
586 }
587
NeuronCompilation_create(NeuronModel * model,NeuronCompilation ** compilation)588 inline int NeuronCompilation_create(
589 NeuronModel* model,
590 NeuronCompilation** compilation) {
591 LOAD_ADAPTER_FUNCTION(NeuronCompilation_create);
592 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, compilation);
593 }
594
NeuronCompilation_createV2(NeuronModel * model,CompilationType type,const char * options,NeuronCompilation ** compilation)595 inline int NeuronCompilation_createV2(
596 NeuronModel* model,
597 CompilationType type,
598 const char* options,
599 NeuronCompilation** compilation) {
600 LOAD_ADAPTER_FUNCTION(NeuronCompilation_createV2);
601 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, type, options, compilation);
602 }
603
NeuronCompilation_createForDevices(NeuronModel * model,const NeuronDevice * const * devices,uint32_t numDevices,NeuronCompilation ** compilation)604 inline int NeuronCompilation_createForDevices(
605 NeuronModel* model,
606 const NeuronDevice* const* devices,
607 uint32_t numDevices,
608 NeuronCompilation** compilation) {
609 LOAD_ADAPTER_FUNCTION(NeuronCompilation_createForDevices);
610 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, devices, numDevices, compilation);
611 }
612
NeuronCompilation_createForDebug(NeuronModel * model,NeuronCompilation ** compilation)613 inline int NeuronCompilation_createForDebug(
614 NeuronModel* model,
615 NeuronCompilation** compilation) {
616 LOAD_ADAPTER_FUNCTION(NeuronCompilation_createForDebug);
617 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, compilation);
618 }
619
NeuronCompilation_free(NeuronCompilation * compilation)620 inline void NeuronCompilation_free(NeuronCompilation* compilation) {
621 LOAD_ADAPTER_FUNCTION(NeuronCompilation_free);
622 EXECUTE_ADAPTER_FUNCTION(compilation);
623 }
624
NeuronCompilation_finish(NeuronCompilation * compilation)625 inline int NeuronCompilation_finish(NeuronCompilation* compilation) {
626 LOAD_ADAPTER_FUNCTION(NeuronCompilation_finish);
627 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(compilation);
628 }
629
NeuronCompilation_setCaching(NeuronCompilation * compilation,const char * cacheDir,const uint8_t * token)630 inline int NeuronCompilation_setCaching(
631 NeuronCompilation* compilation,
632 const char* cacheDir,
633 const uint8_t* token) {
634 LOAD_ADAPTER_FUNCTION(NeuronCompilation_setCaching);
635 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(compilation, cacheDir, token);
636 }
637
NeuronCompilation_setPreference(NeuronCompilation * compilation,int32_t preference)638 inline int NeuronCompilation_setPreference(
639 NeuronCompilation* compilation,
640 int32_t preference) {
641 LOAD_ADAPTER_FUNCTION(NeuronCompilation_setPreference);
642 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(compilation, preference);
643 }
644
NeuronCompilation_setPriority(NeuronCompilation * compilation,int32_t priority)645 inline int NeuronCompilation_setPriority(
646 NeuronCompilation* compilation,
647 int32_t priority) {
648 LOAD_ADAPTER_FUNCTION(NeuronCompilation_setPriority);
649 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(compilation, priority);
650 }
651
NeuronCompilation_getInputPaddedDimensions(NeuronCompilation * compilation,int32_t index,uint32_t * dimensions)652 inline int NeuronCompilation_getInputPaddedDimensions(
653 NeuronCompilation* compilation,
654 int32_t index,
655 uint32_t* dimensions) {
656 LOAD_ADAPTER_FUNCTION(NeuronCompilation_getInputPaddedDimensions);
657 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(compilation, index, dimensions);
658 }
659
NeuronCompilation_getOutputPaddedDimensions(NeuronCompilation * compilation,int32_t index,uint32_t * dimensions)660 inline int NeuronCompilation_getOutputPaddedDimensions(
661 NeuronCompilation* compilation,
662 int32_t index,
663 uint32_t* dimensions) {
664 LOAD_ADAPTER_FUNCTION(NeuronCompilation_getOutputPaddedDimensions);
665 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(compilation, index, dimensions);
666 }
667
NeuronCompilation_getInputPaddedSize(NeuronCompilation * compilation,int32_t index,size_t * size)668 inline int NeuronCompilation_getInputPaddedSize(
669 NeuronCompilation* compilation,
670 int32_t index,
671 size_t* size) {
672 LOAD_ADAPTER_FUNCTION(NeuronCompilation_getInputPaddedSize);
673 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(compilation, index, size);
674 }
675
NeuronCompilation_getOutputPaddedSize(NeuronCompilation * compilation,int32_t index,size_t * size)676 inline int NeuronCompilation_getOutputPaddedSize(
677 NeuronCompilation* compilation,
678 int32_t index,
679 size_t* size) {
680 LOAD_ADAPTER_FUNCTION(NeuronCompilation_getOutputPaddedSize);
681 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(compilation, index, size);
682 }
683
NeuronCompilation_getCompiledNetworkSize(NeuronCompilation * compilation,size_t * size)684 inline int NeuronCompilation_getCompiledNetworkSize(
685 NeuronCompilation* compilation,
686 size_t* size) {
687 LOAD_ADAPTER_FUNCTION(NeuronCompilation_getCompiledNetworkSize);
688 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(compilation, size);
689 }
690
NeuronCompilation_storeCompiledNetwork(NeuronCompilation * compilation,void * buffer,const size_t size)691 inline int NeuronCompilation_storeCompiledNetwork(
692 NeuronCompilation* compilation,
693 void* buffer,
694 const size_t size) {
695 LOAD_ADAPTER_FUNCTION(NeuronCompilation_storeCompiledNetwork);
696 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(compilation, buffer, size);
697 }
698
NeuronCompilation_setOptimizationHint(NeuronCompilation * compilation,uint32_t optimizationCode)699 inline int NeuronCompilation_setOptimizationHint(
700 NeuronCompilation* compilation,
701 uint32_t optimizationCode) {
702 LOAD_ADAPTER_FUNCTION(NeuronCompilation_setOptimizationHint);
703 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(compilation, optimizationCode);
704 }
705
NeuronCompilation_setOptimizationString(NeuronCompilation * compilation,const char * optimizationString)706 inline int NeuronCompilation_setOptimizationString(
707 NeuronCompilation* compilation,
708 const char* optimizationString) {
709 LOAD_ADAPTER_FUNCTION(NeuronCompilation_setOptimizationString);
710 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(compilation, optimizationString);
711 }
712
NeuronCompilation_setTrimIOAlignment(NeuronCompilation * compilation,bool enable)713 inline int NeuronCompilation_setTrimIOAlignment(
714 NeuronCompilation* compilation,
715 bool enable) {
716 LOAD_ADAPTER_FUNCTION(NeuronCompilation_setTrimIOAlignment);
717 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(compilation, enable);
718 }
719
NeuronCompilation_setSWDilatedConv(NeuronCompilation * compilation,bool enable)720 inline int NeuronCompilation_setSWDilatedConv(
721 NeuronCompilation* compilation,
722 bool enable) {
723 LOAD_ADAPTER_FUNCTION(NeuronCompilation_setSWDilatedConv);
724 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(compilation, enable);
725 }
726
NeuronExecution_create(NeuronCompilation * compilation,NeuronExecution ** execution)727 inline int NeuronExecution_create(
728 NeuronCompilation* compilation,
729 NeuronExecution** execution) {
730 LOAD_ADAPTER_FUNCTION(NeuronExecution_create);
731 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(compilation, execution);
732 }
733
NeuronExecution_free(NeuronExecution * execution)734 inline void NeuronExecution_free(NeuronExecution* execution) {
735 LOAD_ADAPTER_FUNCTION(NeuronExecution_free);
736 EXECUTE_ADAPTER_FUNCTION(execution);
737 }
738
NeuronExecution_setInput(NeuronExecution * execution,int32_t index,const NeuronOperandType * type,const void * buffer,size_t length)739 inline int NeuronExecution_setInput(
740 NeuronExecution* execution,
741 int32_t index,
742 const NeuronOperandType* type,
743 const void* buffer,
744 size_t length) {
745 LOAD_ADAPTER_FUNCTION(NeuronExecution_setInput);
746 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(execution, index, type, buffer, length);
747 }
748
NeuronExecution_setInputFromMemory(NeuronExecution * execution,uint32_t index,const NeuronOperandType * type,const NeuronMemory * memory,size_t offset,size_t length)749 inline int NeuronExecution_setInputFromMemory(
750 NeuronExecution* execution,
751 uint32_t index,
752 const NeuronOperandType* type,
753 const NeuronMemory* memory,
754 size_t offset,
755 size_t length) {
756 LOAD_ADAPTER_FUNCTION(NeuronExecution_setInputFromMemory);
757 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(
758 execution, index, type, memory, offset, length);
759 }
760
NeuronExecution_setOutput(NeuronExecution * execution,int32_t index,const NeuronOperandType * type,void * buffer,size_t length)761 inline int NeuronExecution_setOutput(
762 NeuronExecution* execution,
763 int32_t index,
764 const NeuronOperandType* type,
765 void* buffer,
766 size_t length) {
767 LOAD_ADAPTER_FUNCTION(NeuronExecution_setOutput);
768 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(execution, index, type, buffer, length);
769 }
770
NeuronExecution_setOutputFromMemory(NeuronExecution * execution,uint32_t index,const NeuronOperandType * type,const NeuronMemory * memory,size_t offset,size_t length)771 inline int NeuronExecution_setOutputFromMemory(
772 NeuronExecution* execution,
773 uint32_t index,
774 const NeuronOperandType* type,
775 const NeuronMemory* memory,
776 size_t offset,
777 size_t length) {
778 LOAD_ADAPTER_FUNCTION(NeuronExecution_setOutputFromMemory);
779 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(
780 execution, index, type, memory, offset, length);
781 }
782
NeuronMemory_createFromFd(size_t size,int protect,int fd,size_t offset,NeuronMemory ** memory)783 inline int NeuronMemory_createFromFd(
784 size_t size,
785 int protect,
786 int fd,
787 size_t offset,
788 NeuronMemory** memory) {
789 LOAD_ADAPTER_FUNCTION(NeuronMemory_createFromFd);
790 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(size, protect, fd, offset, memory);
791 }
792
NeuronMemory_createFromAHardwareBuffer(const AHardwareBuffer * ahwb,NeuronMemory ** memory)793 inline int NeuronMemory_createFromAHardwareBuffer(
794 const AHardwareBuffer* ahwb,
795 NeuronMemory** memory) {
796 LOAD_ADAPTER_FUNCTION(NeuronMemory_createFromAHardwareBuffer);
797 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(ahwb, memory);
798 }
799
NeuronMemory_free(NeuronMemory * memory)800 inline void NeuronMemory_free(NeuronMemory* memory) {
801 LOAD_ADAPTER_FUNCTION(NeuronMemory_free);
802 EXECUTE_ADAPTER_FUNCTION(memory);
803 }
804
NeuronExecution_compute(NeuronExecution * execution)805 inline int NeuronExecution_compute(NeuronExecution* execution) {
806 LOAD_ADAPTER_FUNCTION(NeuronExecution_compute);
807 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(execution);
808 }
809
NeuronExecution_startComputeWithDependencies(NeuronExecution * execution,const NeuronEvent * const * dependencies,uint32_t num_dependencies,uint64_t duration,NeuronEvent ** event)810 inline int NeuronExecution_startComputeWithDependencies(
811 NeuronExecution* execution,
812 const NeuronEvent* const* dependencies,
813 uint32_t num_dependencies,
814 uint64_t duration,
815 NeuronEvent** event) {
816 LOAD_ADAPTER_FUNCTION(NeuronExecution_startComputeWithDependencies);
817 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(
818 execution, dependencies, num_dependencies, duration, event);
819 }
820
NeuronEvent_getSyncFenceFd(const NeuronEvent * event,int * syncFenceFd)821 inline int NeuronEvent_getSyncFenceFd(
822 const NeuronEvent* event,
823 int* syncFenceFd) {
824 LOAD_ADAPTER_FUNCTION(NeuronEvent_getSyncFenceFd);
825 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(event, syncFenceFd);
826 }
827
NeuronEvent_wait(NeuronEvent * event)828 inline int NeuronEvent_wait(NeuronEvent* event) {
829 LOAD_ADAPTER_FUNCTION(NeuronEvent_wait);
830 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(event);
831 }
832
NeuronEvent_free(NeuronEvent * event)833 inline void NeuronEvent_free(NeuronEvent* event) {
834 LOAD_ADAPTER_FUNCTION(NeuronEvent_free);
835 EXECUTE_ADAPTER_FUNCTION(event);
836 }
837
NeuronExecution_setLoopTimeout(NeuronExecution * execution,uint64_t duration)838 inline int NeuronExecution_setLoopTimeout(
839 NeuronExecution* execution,
840 uint64_t duration) {
841 LOAD_ADAPTER_FUNCTION(NeuronExecution_setLoopTimeout);
842 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(execution, duration);
843 }
844
NeuronExecution_setBoostHint(NeuronExecution * execution,uint8_t boostValue)845 inline int NeuronExecution_setBoostHint(
846 NeuronExecution* execution,
847 uint8_t boostValue) {
848 LOAD_ADAPTER_FUNCTION(NeuronExecution_setBoostHint);
849 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(execution, boostValue);
850 }
851
NeuronCompilation_createForMultiExecutions(NeuronModel * model,NeuronCompilation ** compilation)852 inline int NeuronCompilation_createForMultiExecutions(
853 NeuronModel* model,
854 NeuronCompilation** compilation) {
855 LOAD_ADAPTER_FUNCTION(NeuronCompilation_createForMultiExecutions);
856 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, compilation);
857 }
858
NeuronDebug_setReportPath(NeuronModel * model,const char * path)859 inline int NeuronDebug_setReportPath(NeuronModel* model, const char* path) {
860 LOAD_ADAPTER_FUNCTION(NeuronDebug_setReportPath);
861 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, path);
862 }
863
Neuron_getDeviceCount(uint32_t * numDevices)864 inline int Neuron_getDeviceCount(uint32_t* numDevices) {
865 LOAD_ADAPTER_FUNCTION(Neuron_getDeviceCount);
866 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(numDevices);
867 }
868
Neuron_getDevice(uint32_t devIndex,NeuronDevice ** device)869 inline int Neuron_getDevice(uint32_t devIndex, NeuronDevice** device) {
870 LOAD_ADAPTER_FUNCTION(Neuron_getDevice);
871 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(devIndex, device);
872 }
873
NeuronDevice_getName(const NeuronDevice * device,const char ** name)874 inline int NeuronDevice_getName(const NeuronDevice* device, const char** name) {
875 LOAD_ADAPTER_FUNCTION(NeuronDevice_getName);
876 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(device, name);
877 }
878
NeuronDevice_getDescription(const NeuronDevice * device,const char ** description)879 inline int NeuronDevice_getDescription(
880 const NeuronDevice* device,
881 const char** description) {
882 LOAD_ADAPTER_FUNCTION(NeuronDevice_getDescription);
883 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(device, description);
884 }
885
NeuronDevice_getExtensionSupport(const char * extensionName,bool * isExtensionSupported)886 inline int NeuronDevice_getExtensionSupport(
887 const char* extensionName,
888 bool* isExtensionSupported) {
889 LOAD_ADAPTER_FUNCTION(NeuronDevice_getExtensionSupport);
890 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(extensionName, isExtensionSupported);
891 }
892
NeuronModel_getExtensionOperandType(NeuronModel * model,const char * extensionName,uint16_t operandCodeWithinExtension,int32_t * type)893 inline int NeuronModel_getExtensionOperandType(
894 NeuronModel* model,
895 const char* extensionName,
896 uint16_t operandCodeWithinExtension,
897 int32_t* type) {
898 LOAD_ADAPTER_FUNCTION(NeuronModel_getExtensionOperandType);
899 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(
900 model, extensionName, operandCodeWithinExtension, type);
901 }
902
NeuronModel_getExtensionOperationType(NeuronModel * model,const char * extensionName,uint16_t operationCodeWithinExtension,int32_t * type)903 inline int NeuronModel_getExtensionOperationType(
904 NeuronModel* model,
905 const char* extensionName,
906 uint16_t operationCodeWithinExtension,
907 int32_t* type) {
908 LOAD_ADAPTER_FUNCTION(NeuronModel_getExtensionOperationType);
909 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(
910 model, extensionName, operationCodeWithinExtension, type);
911 }
912
NeuronModel_setOperandExtensionData(NeuronModel * model,int32_t index,const void * data,size_t length)913 inline int NeuronModel_setOperandExtensionData(
914 NeuronModel* model,
915 int32_t index,
916 const void* data,
917 size_t length) {
918 LOAD_ADAPTER_FUNCTION(NeuronModel_setOperandExtensionData);
919 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, index, data, length);
920 }
921
NeuronCompilation_createForBatch(NeuronModel * model,NeuronCompilation ** compilation)922 inline int NeuronCompilation_createForBatch(
923 NeuronModel* model,
924 NeuronCompilation** compilation) {
925 LOAD_ADAPTER_FUNCTION(NeuronCompilation_createForBatch);
926 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, compilation);
927 }
928
NeuronModel_restoreFromCompiledNetworkV2(NeuronModel ** model,NeuronCompilation ** compilation,const void * buffer,const size_t size,const CompilationType & type)929 inline int NeuronModel_restoreFromCompiledNetworkV2(
930 NeuronModel** model,
931 NeuronCompilation** compilation,
932 const void* buffer,
933 const size_t size,
934 const CompilationType& type) {
935 LOAD_ADAPTER_FUNCTION(NeuronModel_restoreFromCompiledNetworkV2);
936 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, compilation, buffer, size, type);
937 }
938
NeuronExecution_setRunnerPoolSize(NeuronExecution * execution,uint8_t numRunners)939 inline int NeuronExecution_setRunnerPoolSize(
940 NeuronExecution* execution,
941 uint8_t numRunners) {
942 LOAD_ADAPTER_FUNCTION(NeuronExecution_setRunnerPoolSize);
943 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(execution, numRunners);
944 }
945
NeuronExecution_setBatchDone(NeuronExecution * execution)946 inline int NeuronExecution_setBatchDone(NeuronExecution* execution) {
947 LOAD_ADAPTER_FUNCTION(NeuronExecution_setBatchDone);
948 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(execution);
949 }
950
NeuronExecution_setIODone(NeuronExecution * execution,int idx)951 inline int NeuronExecution_setIODone(NeuronExecution* execution, int idx) {
952 LOAD_ADAPTER_FUNCTION(NeuronExecution_setIODone);
953 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(execution, idx);
954 }
955
NeuronCompilation_createWithOptions(NeuronModel * model,NeuronCompilation ** compilation,const char * options)956 inline int NeuronCompilation_createWithOptions(
957 NeuronModel* model,
958 NeuronCompilation** compilation,
959 const char* options) {
960 LOAD_ADAPTER_FUNCTION(NeuronCompilation_createWithOptions);
961 EXECUTE_ADAPTER_FUNCTION_RETURN_INT(model, compilation, options);
962 }
963