1pub type __time_t = ::std::os::raw::c_long;
4pub type __syscall_slong_t = ::std::os::raw::c_long;
5#[repr(C)]
6#[derive(Debug, Copy, Clone)]
7pub struct timespec {
8 pub tv_sec: __time_t,
9 pub tv_nsec: __syscall_slong_t,
10}
11#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12const _: () = {
13 ["Size of timespec"][::std::mem::size_of::<timespec>() - 16usize];
14 ["Alignment of timespec"][::std::mem::align_of::<timespec>() - 8usize];
15 ["Offset of field: timespec::tv_sec"][::std::mem::offset_of!(timespec, tv_sec) - 0usize];
16 ["Offset of field: timespec::tv_nsec"][::std::mem::offset_of!(timespec, tv_nsec) - 8usize];
17};
18pub const dv_error_category_DV_ERROR_CATEGORY_SUCCESS: dv_error_category = 0;
19pub const dv_error_category_DV_ERROR_CATEGORY_RETRY: dv_error_category = 100;
20pub const dv_error_category_DV_ERROR_CATEGORY_INVALID: dv_error_category = 200;
21pub const dv_error_category_DV_ERROR_CATEGORY_SW_CLIENT_FATAL: dv_error_category = 300;
22pub const dv_error_category_DV_ERROR_CATEGORY_SW_SERVER_FATAL: dv_error_category = 400;
23pub const dv_error_category_DV_ERROR_CATEGORY_HW_FATAL: dv_error_category = 500;
24pub type dv_error_category = ::std::os::raw::c_uint;
25pub use self::dv_error_category as dv_error_category_t;
26pub const dv_status_code_DV_ERROR_CATEGORY_SUCCESS_START: dv_status_code = 0;
27pub const dv_status_code_DV_SUCCESS: dv_status_code = 0;
28pub const dv_status_code_DV_ERROR_CATEGORY_SUCCESS_END: dv_status_code = 0;
29pub const dv_status_code_DV_FAILURE_UNKOWN: dv_status_code = 1;
30pub const dv_status_code_DV_ERROR_CATEGORY_RETRY_START: dv_status_code = 100;
31pub const dv_status_code_DV_ENDPOINT_OUT_OF_MEMORY: dv_status_code = 100;
32pub const dv_status_code_DV_ERROR_CATEGORY_RETRY_END: dv_status_code = 199;
33pub const dv_status_code_DV_ERROR_CATEGORY_INVALID_START: dv_status_code = 200;
34pub const dv_status_code_DV_RESOURCE_NOT_FOUND: dv_status_code = 200;
35pub const dv_status_code_DV_INVALID_VALUE: dv_status_code = 201;
36pub const dv_status_code_DV_INVALID_HOST_PTR: dv_status_code = 202;
37pub const dv_status_code_DV_INVALID_OPERATION: dv_status_code = 203;
38pub const dv_status_code_DV_OPERATION_NOT_PERMITTED: dv_status_code = 204;
39pub const dv_status_code_DV_OPERATION_NOT_SUPPORTED: dv_status_code = 205;
40pub const dv_status_code_DV_SESSION_UNIX_SOCKET_FILE_TOO_LONG: dv_status_code = 220;
41pub const dv_status_code_DV_SESSION_INVALID_TCP_IPV4_ADDR: dv_status_code = 221;
42pub const dv_status_code_DV_SESSION_INVALID_TCP_IPV4_PORT: dv_status_code = 222;
43pub const dv_status_code_DV_SESSION_INVALID_HANDLE: dv_status_code = 223;
44pub const dv_status_code_DV_ENDPOINT_INVALID_HANDLE: dv_status_code = 230;
45pub const dv_status_code_DV_ENDPOINT_INVALID_PARAMS: dv_status_code = 231;
46pub const dv_status_code_DV_ENDPOINT_NOT_FOUND: dv_status_code = 232;
47pub const dv_status_code_DV_ENDPOINT_NOT_AVAILABLE: dv_status_code = 233;
48pub const dv_status_code_DV_ENDPOINT_GROUP_INVALID: dv_status_code = 234;
49pub const dv_status_code_DV_ENDPOINT_POWER_SWITCH_FAILURE: dv_status_code = 235;
50pub const dv_status_code_DV_ENDPOINT_POWER_GATED: dv_status_code = 236;
51pub const dv_status_code_DV_ENDPOINT_INVALID_POWER_STATE: dv_status_code = 237;
52pub const dv_status_code_DV_ENDPOINT_GET_LIST_FAILED: dv_status_code = 238;
53pub const dv_status_code_DV_ENDPOINT_GET_STATS_FAILED: dv_status_code = 239;
54pub const dv_status_code_DV_MODEL_INVALID_PARAMS: dv_status_code = 240;
55pub const dv_status_code_DV_MODEL_INVALID_HANDLE: dv_status_code = 241;
56pub const dv_status_code_DV_MODEL_INVALID_MODEL_FILE: dv_status_code = 242;
57pub const dv_status_code_DV_MODEL_PARSE_FAILURE: dv_status_code = 243;
58pub const dv_status_code_DV_MODEL_UNSUPPORTED_VERSION: dv_status_code = 244;
59pub const dv_status_code_DV_MODEL_CACHING_FAILURE: dv_status_code = 245;
60pub const dv_status_code_DV_MODEL_CACHE_FETCH_FAILURE: dv_status_code = 246;
61pub const dv_status_code_DV_MODEL_SET_LLM_CFG_PARAMS_FAILED: dv_status_code = 247;
62pub const dv_status_code_DV_SOFT_RESET_FAILURE: dv_status_code = 248;
63pub const dv_status_code_DV_SOFT_RESET_UNSUPPORTED: dv_status_code = 249;
64pub const dv_status_code_DV_INFER_INVALID_SHM_BUFFERS: dv_status_code = 250;
65pub const dv_status_code_DV_INFER_REQUEST_INVALID_HANDLE: dv_status_code = 251;
66pub const dv_status_code_DV_FIRMWARE_VERSION_INVALID: dv_status_code = 252;
67pub const dv_status_code_DV_MODEL_LOAD_SUBMITTED: dv_status_code = 253;
68pub const dv_status_code_DV_MODEL_ALREADY_LOADED: dv_status_code = 254;
69pub const dv_status_code_DV_MODEL_UNLOAD_SUBMITTED: dv_status_code = 255;
70pub const dv_status_code_DV_MODEL_LOAD_SUBMIT_FAILED: dv_status_code = 256;
71pub const dv_status_code_DV_MODEL_LOAD_ABORTED: dv_status_code = 257;
72pub const dv_status_code_DV_MODEL_UNLOAD_SUBMIT_FAILED: dv_status_code = 258;
73pub const dv_status_code_DV_ERROR_CATEGORY_INVALID_END: dv_status_code = 299;
74pub const dv_status_code_DV_ERROR_CATEGORY_SW_CLIENT_FATAL_START: dv_status_code = 300;
75pub const dv_status_code_DV_CLIENT_VERSION_MISMATCH: dv_status_code = 300;
76pub const dv_status_code_DV_CONNECTION_ERROR: dv_status_code = 301;
77pub const dv_status_code_DV_HIF_PUSH_FAILED: dv_status_code = 302;
78pub const dv_status_code_DV_HIF_ERROR: dv_status_code = 303;
79pub const dv_status_code_DV_HIF_TIMEOUT: dv_status_code = 304;
80pub const dv_status_code_DV_HIF_POP_FAILED: dv_status_code = 305;
81pub const dv_status_code_DV_HIF_DEVICE_IN_CONFIG: dv_status_code = 306;
82pub const dv_status_code_DV_ERROR_CATEGORY_SW_CLIENT_FATAL_END: dv_status_code = 399;
83pub const dv_status_code_DV_ERROR_CATEGORY_SW_SERVER_FATAL_START: dv_status_code = 400;
84pub const dv_status_code_DV_HOST_OUT_OF_MEMORY: dv_status_code = 400;
85pub const dv_status_code_DV_INTERNAL_ERROR: dv_status_code = 401;
86pub const dv_status_code_DV_REQUEST_TIMEDOUT: dv_status_code = 402;
87pub const dv_status_code_DV_SHMBUF_NOT_PERMITTED: dv_status_code = 403;
88pub const dv_status_code_DV_REQUEST_SEND_FAILED: dv_status_code = 404;
89pub const dv_status_code_DV_REQUEST_PROCESSING_FAILED: dv_status_code = 405;
90pub const dv_status_code_DV_ERROR_CATEGORY_SW_SERVER_FATAL_END: dv_status_code = 499;
91pub const dv_status_code_DV_ERROR_CATEGORY_HW_FATAL_START: dv_status_code = 500;
92pub const dv_status_code_DV_ENDPOINT_DMA_FAILED: dv_status_code = 500;
93pub const dv_status_code_DV_ENDPOINT_FIRMWARE_LOAD_FAILURE: dv_status_code = 501;
94pub const dv_status_code_DV_ENDPOINT_FIRMWARE_BOOT_FAILURE: dv_status_code = 502;
95pub const dv_status_code_DV_ENDPOINT_NO_FIRMWARE: dv_status_code = 503;
96pub const dv_status_code_DV_ENDPOINT_NOT_REACHABLE: dv_status_code = 504;
97pub const dv_status_code_DV_ENDPOINT_MODEL_BINDING_FAILURE: dv_status_code = 505;
98pub const dv_status_code_DV_TENSOR_FREE_ERROR: dv_status_code = 506;
99pub const dv_status_code_DV_MODEL_LOAD_FAILURE: dv_status_code = 520;
100pub const dv_status_code_DV_MODEL_RELOAD_FAILURE: dv_status_code = 521;
101pub const dv_status_code_DV_MODEL_UNLOAD_FAILURE: dv_status_code = 522;
102pub const dv_status_code_DV_PARTIAL_SUCCESS: dv_status_code = 523;
103pub const dv_status_code_DV_TENSOR_WRITE_FAILURE: dv_status_code = 541;
104pub const dv_status_code_DV_TENSOR_READ_FAILURE: dv_status_code = 542;
105pub const dv_status_code_DV_TENSOR_CREATE_FAILURE: dv_status_code = 543;
106pub const dv_status_code_DV_TENSOR_ALLOCTAION_FAILURE: dv_status_code = 545;
107pub const dv_status_code_DV_TENSOR_INTEGRITY_CHECK_FAILURE: dv_status_code = 546;
108pub const dv_status_code_DV_PROXY_DEVICE_INIT_FAILURE: dv_status_code = 551;
109pub const dv_status_code_DV_INFER_TIME_OUT: dv_status_code = 560;
110pub const dv_status_code_DV_INFER_FAILURE: dv_status_code = 561;
111pub const dv_status_code_DV_INFER_INVALID_INPUT: dv_status_code = 562;
112pub const dv_status_code_DV_INFER_QUEUE_FULL: dv_status_code = 563;
113pub const dv_status_code_DV_INFER_QUEUE_EMPTY: dv_status_code = 564;
114pub const dv_status_code_DV_INFER_MODEL_NOT_FOUND: dv_status_code = 565;
115pub const dv_status_code_DV_INFER_ABORTED: dv_status_code = 566;
116pub const dv_status_code_DV_INFER_SUBMIT_FAILURE: dv_status_code = 567;
117pub const dv_status_code_DV_INFER_TIME_OUT_THERMAL_RUNAWAY: dv_status_code = 568;
118pub const dv_status_code_DV_ERROR_CATEGORY_HW_FATAL_END: dv_status_code = 599;
119pub const dv_status_code_DV_CLIENT_TXRX_WRITE_FAILURE: dv_status_code = 600;
120pub const dv_status_code_DV_CLIENT_TXRX_READ_FAILURE: dv_status_code = 601;
121pub const dv_status_code_DV_CLIENT_TXRX_ASYNC_SEND_FAILURE: dv_status_code = 602;
122pub const dv_status_code_DV_CLIENT_TXRX_FD_COUNT_MISMATCH: dv_status_code = 603;
123pub const dv_status_code_DV_CLIENT_TXRX_DISCONNECT_ERROR: dv_status_code = 604;
124pub const dv_status_code_DV_CLIENT_RECEIVED_UNKNOWN_RESPONSE: dv_status_code = 605;
125pub const dv_status_code_DV_CLIENT_TO_TXRX_CONNECTION_ERROR: dv_status_code = 606;
126pub const dv_status_code_DV_FLOW_CREATE_FAILED: dv_status_code = 700;
127pub const dv_status_code_DV_FLOW_SUBMIT_FAILED: dv_status_code = 701;
128pub const dv_status_code_DV_FLOW_ABORTED: dv_status_code = 702;
129pub const dv_status_code_DV_CP_INDEX_ALLOC_FAILURE: dv_status_code = 800;
130pub const dv_status_code_DV_MMIO_READ_FAIL: dv_status_code = 900;
131pub const dv_status_code_DV_MMIO_WRITE_FAIL: dv_status_code = 901;
132pub type dv_status_code = ::std::os::raw::c_uint;
133pub use self::dv_status_code as dv_status_code_t;
134#[repr(C)]
135#[derive(Debug, Copy, Clone)]
136pub struct dv_infer_request_handle {
137 _unused: [u8; 0],
138}
139pub type dv_infer_request_handle_t = dv_infer_request_handle;
140#[repr(C)]
141#[derive(Debug, Copy, Clone)]
142pub struct dv_model_handle {
143 _unused: [u8; 0],
144}
145pub type dv_model_handle_t = dv_model_handle;
146#[doc = "< unix domain socket"]
147pub const DV_SESSION_SOCKET_TYPE_DV_SESSION_SOCKET_TYPE_UNIX: DV_SESSION_SOCKET_TYPE = 0;
148#[doc = "< tcp ipv4 socket"]
149pub const DV_SESSION_SOCKET_TYPE_DV_SESSION_SOCKET_TYPE_TCPIPv4: DV_SESSION_SOCKET_TYPE = 1;
150#[doc = " DV session socket type"]
151pub type DV_SESSION_SOCKET_TYPE = ::std::os::raw::c_uint;
152#[doc = " DV session socket type"]
153pub use self::DV_SESSION_SOCKET_TYPE as dv_session_socket_type_t;
154#[doc = "< host and dv connected via pcie interface"]
155pub const DV_ENDPOINT_HOST_INTERFACE_DV_ENDPOINT_HOST_INTERFACE_PCIE: DV_ENDPOINT_HOST_INTERFACE =
156 1;
157#[doc = "< host and dv connected via usb interface"]
158pub const DV_ENDPOINT_HOST_INTERFACE_DV_ENDPOINT_HOST_INTERFACE_USB: DV_ENDPOINT_HOST_INTERFACE = 2;
159#[doc = " DV Endpoint to host communication interface"]
160pub type DV_ENDPOINT_HOST_INTERFACE = ::std::os::raw::c_uint;
161#[doc = " DV Endpoint to host communication interface"]
162pub use self::DV_ENDPOINT_HOST_INTERFACE as dv_endpoint_host_interface_t;
163#[doc = "< default group for all the endpoint(s)\nconnected to inference proxy server"]
164pub const DV_ENDPOINT_DEFAULT_GROUP_DV_ENDPOINT_DEFAULT_GROUP_ALL: DV_ENDPOINT_DEFAULT_GROUP = 0;
165#[doc = "< default group for all the pcie endpoint(s) connected to inference\nproxy server"]
166pub const DV_ENDPOINT_DEFAULT_GROUP_DV_ENDPOINT_DEFAULT_GROUP_PCIE: DV_ENDPOINT_DEFAULT_GROUP = 1;
167#[doc = "< default group for all the usb endpoint(s) connected to inference\nproxy server"]
168pub const DV_ENDPOINT_DEFAULT_GROUP_DV_ENDPOINT_DEFAULT_GROUP_USB: DV_ENDPOINT_DEFAULT_GROUP = 2;
169pub type DV_ENDPOINT_DEFAULT_GROUP = ::std::os::raw::c_uint;
170pub use self::DV_ENDPOINT_DEFAULT_GROUP as dv_endpoint_default_group_t;
171#[doc = "< endpoint is in init state"]
172pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_INIT: DV_ENDPOINT_STATE = 0;
173#[doc = "< endpoint is in idle state"]
174pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_IDLE: DV_ENDPOINT_STATE = 1;
175#[doc = "< endpoint is in active state"]
176pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_ACTIVE: DV_ENDPOINT_STATE = 2;
177#[doc = "< endpoint is operating at reduced frequency"]
178pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_ACTIVE_SLOW: DV_ENDPOINT_STATE = 3;
179#[doc = "< endpoint is operating at reduced frequency"]
180pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_ACTIVE_BOOSTED: DV_ENDPOINT_STATE = 4;
181#[doc = "< endpoint is in thermal Inactive state"]
182pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_THERMAL_INACTIVE: DV_ENDPOINT_STATE = 5;
183#[doc = "< endpoint is in unown thermal state"]
184pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_THERMAL_UNKNOWN: DV_ENDPOINT_STATE = 6;
185#[doc = "< endpoint is in Inactive state"]
186pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_INACTIVE: DV_ENDPOINT_STATE = 7;
187#[doc = "< endpoint is in faulty state"]
188pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_FAULT: DV_ENDPOINT_STATE = 8;
189#[doc = "< [unsupported]"]
190pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_BAD_INTERFACE: DV_ENDPOINT_STATE = 1001;
191#[doc = "< [unsupported]"]
192pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_RECOVERY: DV_ENDPOINT_STATE = 1003;
193#[doc = "< [unsupported]"]
194pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_DEAD: DV_ENDPOINT_STATE = 1004;
195#[doc = "< [unsupported]"]
196pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_DRAIN: DV_ENDPOINT_STATE = 1005;
197#[doc = "< [unsupported]"]
198pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_POWER_GATED: DV_ENDPOINT_STATE = 1006;
199#[doc = "< [unsupported]"]
200pub const DV_ENDPOINT_STATE_DV_ENDPOINT_STATE_CLOSED: DV_ENDPOINT_STATE = 1007;
201#[doc = " Endpoint state"]
202pub type DV_ENDPOINT_STATE = ::std::os::raw::c_uint;
203#[doc = " Endpoint state"]
204pub use self::DV_ENDPOINT_STATE as dv_endpoint_state_t;
205#[doc = "< endpoint is in L0 state"]
206pub const DV_ENDPOINT_POWER_STATE_DV_POWER_STATE_L0: DV_ENDPOINT_POWER_STATE = 0;
207#[doc = "< endpoint is in L1 state"]
208pub const DV_ENDPOINT_POWER_STATE_DV_POWER_STATE_L1: DV_ENDPOINT_POWER_STATE = 1;
209#[doc = "< endpoint is in L1A state"]
210pub const DV_ENDPOINT_POWER_STATE_DV_POWER_STATE_L1A: DV_ENDPOINT_POWER_STATE = 2;
211#[doc = "< endpoint is in L2 state"]
212pub const DV_ENDPOINT_POWER_STATE_DV_POWER_STATE_L2: DV_ENDPOINT_POWER_STATE = 3;
213#[doc = " Endpoint Power State [currently unsupported]"]
214pub type DV_ENDPOINT_POWER_STATE = ::std::os::raw::c_uint;
215#[doc = " Endpoint Power State [currently unsupported]"]
216pub use self::DV_ENDPOINT_POWER_STATE as dv_endpoint_power_state_t;
217#[doc = "< endpoint group type none"]
218pub const DV_ENDPOINT_GROUP_TYPE_DV_ENDPOINT_GROUP_TYPE_NONE: DV_ENDPOINT_GROUP_TYPE = 0;
219#[doc = "< endpoint group type all"]
220pub const DV_ENDPOINT_GROUP_TYPE_DV_ENDPOINT_GROUP_TYPE_ALL: DV_ENDPOINT_GROUP_TYPE = 1;
221#[doc = "< endpoint group type pcie"]
222pub const DV_ENDPOINT_GROUP_TYPE_DV_ENDPOINT_GROUP_TYPE_PCIE: DV_ENDPOINT_GROUP_TYPE = 2;
223#[doc = "< endpoint group type usb"]
224pub const DV_ENDPOINT_GROUP_TYPE_DV_ENDPOINT_GROUP_TYPE_USB: DV_ENDPOINT_GROUP_TYPE = 3;
225#[doc = "< endpoint group type custom"]
226pub const DV_ENDPOINT_GROUP_TYPE_DV_ENDPOINT_GROUP_TYPE_CUSTOM: DV_ENDPOINT_GROUP_TYPE = 4;
227pub type DV_ENDPOINT_GROUP_TYPE = ::std::os::raw::c_uint;
228pub use self::DV_ENDPOINT_GROUP_TYPE as dv_endpoint_group_type_t;
229#[doc = "< represents classification type of network"]
230pub const DV_LAYER_OUTPUT_TYPE_DV_LAYER_OUTPUT_TYPE_CLASSIFICATION: DV_LAYER_OUTPUT_TYPE = 0;
231#[doc = "< represents detection type of network"]
232pub const DV_LAYER_OUTPUT_TYPE_DV_LAYER_OUTPUT_TYPE_DETECTION: DV_LAYER_OUTPUT_TYPE = 1;
233#[doc = "< represents semantic segmentation type of network"]
234pub const DV_LAYER_OUTPUT_TYPE_DV_LAYER_OUTPUT_TYPE_SEMANTIC_SEGMENTATION: DV_LAYER_OUTPUT_TYPE = 2;
235#[doc = "< represents all other network types which can't be determined"]
236pub const DV_LAYER_OUTPUT_TYPE_DV_LAYER_OUTPUT_TYPE_RAW: DV_LAYER_OUTPUT_TYPE = 3;
237#[doc = " Model Network type"]
238pub type DV_LAYER_OUTPUT_TYPE = ::std::os::raw::c_uint;
239#[doc = " Model Network type"]
240pub use self::DV_LAYER_OUTPUT_TYPE as dv_layer_output_type_t;
241#[doc = "< model priority low"]
242pub const DV_MODEL_PRIORITY_LEVEL_DV_MODEL_PRIORITY_LEVEL_LOW: DV_MODEL_PRIORITY_LEVEL = 0;
243#[doc = "< model priority medium"]
244pub const DV_MODEL_PRIORITY_LEVEL_DV_MODEL_PRIORITY_LEVEL_MEDIUM: DV_MODEL_PRIORITY_LEVEL = 1;
245#[doc = "< model priority default"]
246pub const DV_MODEL_PRIORITY_LEVEL_DV_MODEL_PRIORITY_LEVEL_DEFAULT: DV_MODEL_PRIORITY_LEVEL = 1;
247#[doc = "< model priority high"]
248pub const DV_MODEL_PRIORITY_LEVEL_DV_MODEL_PRIORITY_LEVEL_HIGH: DV_MODEL_PRIORITY_LEVEL = 2;
249#[doc = " Priority level of model"]
250pub type DV_MODEL_PRIORITY_LEVEL = ::std::os::raw::c_uint;
251#[doc = " Priority level of model"]
252pub use self::DV_MODEL_PRIORITY_LEVEL as dv_model_priority_level_t;
253#[doc = "< Inference is in queued state"]
254pub const DV_INFERENCE_STATUS_DV_INFERENCE_STATUS_QUEUED: DV_INFERENCE_STATUS = 0;
255#[doc = "< Inference is in running/executing state"]
256pub const DV_INFERENCE_STATUS_DV_INFERENCE_STATUS_RUNNING: DV_INFERENCE_STATUS = 1;
257#[doc = "< Inference is in completed state"]
258pub const DV_INFERENCE_STATUS_DV_INFERENCE_STATUS_COMPLETED: DV_INFERENCE_STATUS = 2;
259#[doc = "< Inference is in failed state"]
260pub const DV_INFERENCE_STATUS_DV_INFERENCE_STATUS_FAILED: DV_INFERENCE_STATUS = 4;
261#[doc = "< Inference information is not available"]
262pub const DV_INFERENCE_STATUS_DV_INFERENCE_STATUS_UNKNOWN: DV_INFERENCE_STATUS = 5;
263#[doc = " Inference status"]
264pub type DV_INFERENCE_STATUS = ::std::os::raw::c_uint;
265#[doc = " Inference status"]
266pub use self::DV_INFERENCE_STATUS as dv_inference_status_t;
267#[doc = "< represents blob backed by raw pointer"]
268pub const DV_BLOB_TYPE_DV_BLOB_TYPE_RAW_POINTER: DV_BLOB_TYPE = 0;
269#[doc = "< represents blob backed by registered shared memory descriptor"]
270pub const DV_BLOB_TYPE_DV_BLOB_TYPE_SHM_DESCRIPTOR: DV_BLOB_TYPE = 1;
271#[doc = "< represents blob backed by non-registered file descriptor"]
272pub const DV_BLOB_TYPE_DV_BLOB_TYPE_FD: DV_BLOB_TYPE = 2;
273#[doc = " Blob types"]
274pub type DV_BLOB_TYPE = ::std::os::raw::c_uint;
275#[doc = " Blob types"]
276pub use self::DV_BLOB_TYPE as dv_blob_type_t;
277pub const DV_PRODUCT_TYPE_INVALID_PRODUCT: DV_PRODUCT_TYPE = -1;
278pub const DV_PRODUCT_TYPE_PROXY: DV_PRODUCT_TYPE = 0;
279pub const DV_PRODUCT_TYPE_PCI_DRIVER: DV_PRODUCT_TYPE = 1;
280pub const DV_PRODUCT_TYPE_FIRMWARE: DV_PRODUCT_TYPE = 2;
281pub const DV_PRODUCT_TYPE_CNN_MODEL: DV_PRODUCT_TYPE = 3;
282pub const DV_PRODUCT_TYPE_LLM_MODEL: DV_PRODUCT_TYPE = 4;
283pub const DV_PRODUCT_TYPE_CLIENT_LIB: DV_PRODUCT_TYPE = 5;
284pub const DV_PRODUCT_TYPE_SYSAPI: DV_PRODUCT_TYPE = 6;
285pub type DV_PRODUCT_TYPE = ::std::os::raw::c_int;
286pub use self::DV_PRODUCT_TYPE as dv_product_type_t;
287#[repr(C)]
288#[derive(Debug, Copy, Clone)]
289pub struct dv_version {
290 pub major: u8,
291 pub minor: u8,
292 pub patch: u8,
293 pub patch_minor: u8,
294}
295#[allow(clippy::unnecessary_operation, clippy::identity_op)]
296const _: () = {
297 ["Size of dv_version"][::std::mem::size_of::<dv_version>() - 4usize];
298 ["Alignment of dv_version"][::std::mem::align_of::<dv_version>() - 1usize];
299 ["Offset of field: dv_version::major"][::std::mem::offset_of!(dv_version, major) - 0usize];
300 ["Offset of field: dv_version::minor"][::std::mem::offset_of!(dv_version, minor) - 1usize];
301 ["Offset of field: dv_version::patch"][::std::mem::offset_of!(dv_version, patch) - 2usize];
302 ["Offset of field: dv_version::patch_minor"]
303 [::std::mem::offset_of!(dv_version, patch_minor) - 3usize];
304};
305pub type dv_version_t = dv_version;
306#[repr(C)]
307#[derive(Debug, Copy, Clone)]
308pub struct dv_product_version {
309 pub product_type: dv_product_type_t,
310 pub product_version: dv_version_t,
311}
312#[allow(clippy::unnecessary_operation, clippy::identity_op)]
313const _: () = {
314 ["Size of dv_product_version"][::std::mem::size_of::<dv_product_version>() - 8usize];
315 ["Alignment of dv_product_version"][::std::mem::align_of::<dv_product_version>() - 4usize];
316 ["Offset of field: dv_product_version::product_type"]
317 [::std::mem::offset_of!(dv_product_version, product_type) - 0usize];
318 ["Offset of field: dv_product_version::product_version"]
319 [::std::mem::offset_of!(dv_product_version, product_version) - 4usize];
320};
321pub type dv_product_version_t = dv_product_version;
322#[repr(C)]
323#[derive(Debug, Copy, Clone)]
324pub struct dv_blob {
325 #[doc = "< blob handle (raw pointer or shared file descriptor returned\nby server)"]
326 pub handle: *mut ::std::os::raw::c_void,
327 #[doc = "< blob offset"]
328 pub offset: u64,
329 #[doc = "< blob size"]
330 pub size: u64,
331 #[doc = "< blob type as represented in enum DV_BLOB_TYPE"]
332 pub blob_type: dv_blob_type_t,
333}
334#[allow(clippy::unnecessary_operation, clippy::identity_op)]
335const _: () = {
336 ["Size of dv_blob"][::std::mem::size_of::<dv_blob>() - 32usize];
337 ["Alignment of dv_blob"][::std::mem::align_of::<dv_blob>() - 8usize];
338 ["Offset of field: dv_blob::handle"][::std::mem::offset_of!(dv_blob, handle) - 0usize];
339 ["Offset of field: dv_blob::offset"][::std::mem::offset_of!(dv_blob, offset) - 8usize];
340 ["Offset of field: dv_blob::size"][::std::mem::offset_of!(dv_blob, size) - 16usize];
341 ["Offset of field: dv_blob::blob_type"][::std::mem::offset_of!(dv_blob, blob_type) - 24usize];
342};
343pub type dv_blob_t = dv_blob;
344#[doc = " Default session wide parameters that are to be passed to dv_session_create_via_*_with_options"]
345#[repr(C)]
346#[derive(Debug, Copy, Clone)]
347pub struct dv_session_options {
348 #[doc = "< global default timeout"]
349 pub timeout_ms: ::std::os::raw::c_int,
350}
351#[allow(clippy::unnecessary_operation, clippy::identity_op)]
352const _: () = {
353 ["Size of dv_session_options"][::std::mem::size_of::<dv_session_options>() - 4usize];
354 ["Alignment of dv_session_options"][::std::mem::align_of::<dv_session_options>() - 4usize];
355 ["Offset of field: dv_session_options::timeout_ms"]
356 [::std::mem::offset_of!(dv_session_options, timeout_ms) - 0usize];
357};
358#[doc = " Default session wide parameters that are to be passed to dv_session_create_via_*_with_options"]
359pub type dv_session_options_t = dv_session_options;
360#[doc = " Session object with parameters"]
361#[repr(C)]
362#[derive(Debug, Copy, Clone)]
363pub struct dv_session {
364 #[doc = "< session private handle, managed by client library"]
365 pub handle: *mut ::std::os::raw::c_void,
366 #[doc = "< NULL terminated socket connection string"]
367 pub socket_str: *mut ::std::os::raw::c_char,
368 #[doc = "< socket types: Unix domain socket/TCPIPv4"]
369 pub socket_type: dv_session_socket_type_t,
370}
371#[allow(clippy::unnecessary_operation, clippy::identity_op)]
372const _: () = {
373 ["Size of dv_session"][::std::mem::size_of::<dv_session>() - 24usize];
374 ["Alignment of dv_session"][::std::mem::align_of::<dv_session>() - 8usize];
375 ["Offset of field: dv_session::handle"][::std::mem::offset_of!(dv_session, handle) - 0usize];
376 ["Offset of field: dv_session::socket_str"]
377 [::std::mem::offset_of!(dv_session, socket_str) - 8usize];
378 ["Offset of field: dv_session::socket_type"]
379 [::std::mem::offset_of!(dv_session, socket_type) - 16usize];
380};
381#[doc = " Session object with parameters"]
382pub type dv_session_t = dv_session;
383#[doc = " Shared memory decriptor generated after registering fd to server"]
384#[repr(C)]
385#[derive(Debug, Copy, Clone)]
386pub struct dv_shm_descriptor {
387 #[doc = "< shared mem handle, managed by client library"]
388 pub handle: *mut ::std::os::raw::c_void,
389 #[doc = "< session handle on which shared memory is registered"]
390 pub session: *mut dv_session_t,
391 #[doc = "< file fd for which shared memory is registered"]
392 pub fd: ::std::os::raw::c_int,
393 #[doc = "< size to map"]
394 pub size: usize,
395 #[doc = "< offset in file"]
396 pub offset: usize,
397 #[doc = "< type of fd shared (reserved)"]
398 pub fd_type: ::std::os::raw::c_int,
399}
400#[allow(clippy::unnecessary_operation, clippy::identity_op)]
401const _: () = {
402 ["Size of dv_shm_descriptor"][::std::mem::size_of::<dv_shm_descriptor>() - 48usize];
403 ["Alignment of dv_shm_descriptor"][::std::mem::align_of::<dv_shm_descriptor>() - 8usize];
404 ["Offset of field: dv_shm_descriptor::handle"]
405 [::std::mem::offset_of!(dv_shm_descriptor, handle) - 0usize];
406 ["Offset of field: dv_shm_descriptor::session"]
407 [::std::mem::offset_of!(dv_shm_descriptor, session) - 8usize];
408 ["Offset of field: dv_shm_descriptor::fd"]
409 [::std::mem::offset_of!(dv_shm_descriptor, fd) - 16usize];
410 ["Offset of field: dv_shm_descriptor::size"]
411 [::std::mem::offset_of!(dv_shm_descriptor, size) - 24usize];
412 ["Offset of field: dv_shm_descriptor::offset"]
413 [::std::mem::offset_of!(dv_shm_descriptor, offset) - 32usize];
414 ["Offset of field: dv_shm_descriptor::fd_type"]
415 [::std::mem::offset_of!(dv_shm_descriptor, fd_type) - 40usize];
416};
417#[doc = " Shared memory decriptor generated after registering fd to server"]
418pub type dv_shm_descriptor_t = dv_shm_descriptor;
419#[repr(C)]
420#[derive(Debug, Copy, Clone)]
421pub struct dv_endpoint_chip_info {
422 #[doc = "< dv chip id"]
423 pub id: *mut ::std::os::raw::c_char,
424 #[doc = "< dv chip revision"]
425 pub rev: *mut ::std::os::raw::c_char,
426 #[doc = "< dv chip control processor count"]
427 pub control_processor_count: ::std::os::raw::c_int,
428 #[doc = "< dv chip neural processor count"]
429 pub neural_processor_count: ::std::os::raw::c_int,
430 #[doc = "< dv chip internal L2 memory size in bytes"]
431 pub l2_memory_size: u32,
432}
433#[allow(clippy::unnecessary_operation, clippy::identity_op)]
434const _: () = {
435 ["Size of dv_endpoint_chip_info"][::std::mem::size_of::<dv_endpoint_chip_info>() - 32usize];
436 ["Alignment of dv_endpoint_chip_info"]
437 [::std::mem::align_of::<dv_endpoint_chip_info>() - 8usize];
438 ["Offset of field: dv_endpoint_chip_info::id"]
439 [::std::mem::offset_of!(dv_endpoint_chip_info, id) - 0usize];
440 ["Offset of field: dv_endpoint_chip_info::rev"]
441 [::std::mem::offset_of!(dv_endpoint_chip_info, rev) - 8usize];
442 ["Offset of field: dv_endpoint_chip_info::control_processor_count"]
443 [::std::mem::offset_of!(dv_endpoint_chip_info, control_processor_count) - 16usize];
444 ["Offset of field: dv_endpoint_chip_info::neural_processor_count"]
445 [::std::mem::offset_of!(dv_endpoint_chip_info, neural_processor_count) - 20usize];
446 ["Offset of field: dv_endpoint_chip_info::l2_memory_size"]
447 [::std::mem::offset_of!(dv_endpoint_chip_info, l2_memory_size) - 24usize];
448};
449pub type dv_endpoint_chip_info_t = dv_endpoint_chip_info;
450#[repr(C)]
451#[derive(Debug, Copy, Clone)]
452pub struct dv_endpoint_dram_info {
453 #[doc = "< dv dram vendor id"]
454 pub vendor_id: u32,
455 #[doc = "< dv dram vendor name"]
456 pub vendor_name: *mut ::std::os::raw::c_char,
457 #[doc = "< dv dram memory size in bytes"]
458 pub size: u32,
459 #[doc = "< dv dram revision id 1"]
460 pub rev_id1: u8,
461 #[doc = "< dv dram revision id 2"]
462 pub rev_id2: u8,
463 #[doc = "< dv dram density"]
464 pub density: u8,
465 #[doc = "< dv dram io width"]
466 pub io_width: u8,
467}
468#[allow(clippy::unnecessary_operation, clippy::identity_op)]
469const _: () = {
470 ["Size of dv_endpoint_dram_info"][::std::mem::size_of::<dv_endpoint_dram_info>() - 24usize];
471 ["Alignment of dv_endpoint_dram_info"]
472 [::std::mem::align_of::<dv_endpoint_dram_info>() - 8usize];
473 ["Offset of field: dv_endpoint_dram_info::vendor_id"]
474 [::std::mem::offset_of!(dv_endpoint_dram_info, vendor_id) - 0usize];
475 ["Offset of field: dv_endpoint_dram_info::vendor_name"]
476 [::std::mem::offset_of!(dv_endpoint_dram_info, vendor_name) - 8usize];
477 ["Offset of field: dv_endpoint_dram_info::size"]
478 [::std::mem::offset_of!(dv_endpoint_dram_info, size) - 16usize];
479 ["Offset of field: dv_endpoint_dram_info::rev_id1"]
480 [::std::mem::offset_of!(dv_endpoint_dram_info, rev_id1) - 20usize];
481 ["Offset of field: dv_endpoint_dram_info::rev_id2"]
482 [::std::mem::offset_of!(dv_endpoint_dram_info, rev_id2) - 21usize];
483 ["Offset of field: dv_endpoint_dram_info::density"]
484 [::std::mem::offset_of!(dv_endpoint_dram_info, density) - 22usize];
485 ["Offset of field: dv_endpoint_dram_info::io_width"]
486 [::std::mem::offset_of!(dv_endpoint_dram_info, io_width) - 23usize];
487};
488pub type dv_endpoint_dram_info_t = dv_endpoint_dram_info;
489#[doc = " DV Endpoint interface information"]
490#[repr(C)]
491#[derive(Copy, Clone)]
492pub struct dv_endpoint_iface_info {
493 #[doc = "< dv module physical interface (pcie, usb) with host"]
494 pub type_: dv_endpoint_host_interface_t,
495 #[doc = "< host interface bus number on which dv device is connected"]
496 pub bus_num: ::std::os::raw::c_int,
497 #[doc = "< host interface device number on which dv device is\nconnected"]
498 pub device_num: ::std::os::raw::c_int,
499 pub sysfs_path: dv_endpoint_iface_info__bindgen_ty_1,
500 #[doc = "< port on which device is connected"]
501 pub port_num: ::std::os::raw::c_int,
502}
503#[repr(C)]
504#[derive(Copy, Clone)]
505pub union dv_endpoint_iface_info__bindgen_ty_1 {
506 #[doc = "< \\since r5.3 path to the pcie sysfs entry for a PCIE\ninterface device"]
507 pub pcie_dir: *mut ::std::os::raw::c_char,
508}
509#[allow(clippy::unnecessary_operation, clippy::identity_op)]
510const _: () = {
511 ["Size of dv_endpoint_iface_info__bindgen_ty_1"]
512 [::std::mem::size_of::<dv_endpoint_iface_info__bindgen_ty_1>() - 8usize];
513 ["Alignment of dv_endpoint_iface_info__bindgen_ty_1"]
514 [::std::mem::align_of::<dv_endpoint_iface_info__bindgen_ty_1>() - 8usize];
515 ["Offset of field: dv_endpoint_iface_info__bindgen_ty_1::pcie_dir"]
516 [::std::mem::offset_of!(dv_endpoint_iface_info__bindgen_ty_1, pcie_dir) - 0usize];
517};
518#[allow(clippy::unnecessary_operation, clippy::identity_op)]
519const _: () = {
520 ["Size of dv_endpoint_iface_info"][::std::mem::size_of::<dv_endpoint_iface_info>() - 32usize];
521 ["Alignment of dv_endpoint_iface_info"]
522 [::std::mem::align_of::<dv_endpoint_iface_info>() - 8usize];
523 ["Offset of field: dv_endpoint_iface_info::type_"]
524 [::std::mem::offset_of!(dv_endpoint_iface_info, type_) - 0usize];
525 ["Offset of field: dv_endpoint_iface_info::bus_num"]
526 [::std::mem::offset_of!(dv_endpoint_iface_info, bus_num) - 4usize];
527 ["Offset of field: dv_endpoint_iface_info::device_num"]
528 [::std::mem::offset_of!(dv_endpoint_iface_info, device_num) - 8usize];
529 ["Offset of field: dv_endpoint_iface_info::sysfs_path"]
530 [::std::mem::offset_of!(dv_endpoint_iface_info, sysfs_path) - 16usize];
531 ["Offset of field: dv_endpoint_iface_info::port_num"]
532 [::std::mem::offset_of!(dv_endpoint_iface_info, port_num) - 24usize];
533};
534#[doc = " DV Endpoint interface information"]
535pub type dv_endpoint_iface_info_t = dv_endpoint_iface_info;
536#[doc = " DV Endpoint information"]
537#[repr(C)]
538#[derive(Debug, Copy, Clone)]
539pub struct dv_endpoint_info {
540 #[doc = "< endpoint device id"]
541 pub device_id: u32,
542 #[doc = "< endpoint vendor id"]
543 pub vendor_id: u32,
544 #[doc = "< endpoint chip information"]
545 pub chip: *mut dv_endpoint_chip_info_t,
546 #[doc = "< endpoint external dram information"]
547 pub dram: *mut dv_endpoint_dram_info_t,
548 #[doc = "< endpoint interface information"]
549 pub iface: *mut dv_endpoint_iface_info_t,
550 #[doc = "< physical module name connected to server"]
551 pub module_name: *mut ::std::os::raw::c_char,
552 #[doc = "< [unused]"]
553 pub gpio0: u32,
554 #[doc = "< [unused]"]
555 pub gpio1: u32,
556 #[doc = "< used to uniquely identify the chip"]
557 pub device_uid: u32,
558}
559#[allow(clippy::unnecessary_operation, clippy::identity_op)]
560const _: () = {
561 ["Size of dv_endpoint_info"][::std::mem::size_of::<dv_endpoint_info>() - 56usize];
562 ["Alignment of dv_endpoint_info"][::std::mem::align_of::<dv_endpoint_info>() - 8usize];
563 ["Offset of field: dv_endpoint_info::device_id"]
564 [::std::mem::offset_of!(dv_endpoint_info, device_id) - 0usize];
565 ["Offset of field: dv_endpoint_info::vendor_id"]
566 [::std::mem::offset_of!(dv_endpoint_info, vendor_id) - 4usize];
567 ["Offset of field: dv_endpoint_info::chip"]
568 [::std::mem::offset_of!(dv_endpoint_info, chip) - 8usize];
569 ["Offset of field: dv_endpoint_info::dram"]
570 [::std::mem::offset_of!(dv_endpoint_info, dram) - 16usize];
571 ["Offset of field: dv_endpoint_info::iface"]
572 [::std::mem::offset_of!(dv_endpoint_info, iface) - 24usize];
573 ["Offset of field: dv_endpoint_info::module_name"]
574 [::std::mem::offset_of!(dv_endpoint_info, module_name) - 32usize];
575 ["Offset of field: dv_endpoint_info::gpio0"]
576 [::std::mem::offset_of!(dv_endpoint_info, gpio0) - 40usize];
577 ["Offset of field: dv_endpoint_info::gpio1"]
578 [::std::mem::offset_of!(dv_endpoint_info, gpio1) - 44usize];
579 ["Offset of field: dv_endpoint_info::device_uid"]
580 [::std::mem::offset_of!(dv_endpoint_info, device_uid) - 48usize];
581};
582#[doc = " DV Endpoint information"]
583pub type dv_endpoint_info_t = dv_endpoint_info;
584#[doc = " Endpoint/Endpoint Group object"]
585#[repr(C)]
586#[derive(Debug, Copy, Clone)]
587pub struct dv_endpoint {
588 #[doc = "< endpoint private handle, managed by client library"]
589 pub handle: *mut ::std::os::raw::c_void,
590 #[doc = "< session handle on which endpoint is queried"]
591 pub session: *mut dv_session_t,
592 #[doc = "< number of endpoints in the group"]
593 pub num_ep: ::std::os::raw::c_int,
594 #[doc = "< endpoint group type"]
595 pub grp_type: dv_endpoint_group_type_t,
596 #[doc = "< list of configuration for all the\nendpoint(s) in the group"]
597 pub ep_info_list: *mut *mut dv_endpoint_info_t,
598}
599#[allow(clippy::unnecessary_operation, clippy::identity_op)]
600const _: () = {
601 ["Size of dv_endpoint"][::std::mem::size_of::<dv_endpoint>() - 32usize];
602 ["Alignment of dv_endpoint"][::std::mem::align_of::<dv_endpoint>() - 8usize];
603 ["Offset of field: dv_endpoint::handle"][::std::mem::offset_of!(dv_endpoint, handle) - 0usize];
604 ["Offset of field: dv_endpoint::session"]
605 [::std::mem::offset_of!(dv_endpoint, session) - 8usize];
606 ["Offset of field: dv_endpoint::num_ep"][::std::mem::offset_of!(dv_endpoint, num_ep) - 16usize];
607 ["Offset of field: dv_endpoint::grp_type"]
608 [::std::mem::offset_of!(dv_endpoint, grp_type) - 20usize];
609 ["Offset of field: dv_endpoint::ep_info_list"]
610 [::std::mem::offset_of!(dv_endpoint, ep_info_list) - 24usize];
611};
612#[doc = " Endpoint/Endpoint Group object"]
613pub type dv_endpoint_t = dv_endpoint;
614#[repr(C)]
615#[derive(Debug, Copy, Clone)]
616pub struct dv_endpoint_dram_statistics {
617 #[doc = "< endpoint handle"]
618 pub ep: *mut dv_endpoint_t,
619 #[doc = "< endpoint dram size in bytes"]
620 pub ep_total_dram_size: u64,
621 #[doc = "< endpoint dram memory occupied in bytes"]
622 pub ep_total_dram_occupancy_size: u64,
623 #[doc = "< endpoint dram memory free in bytes"]
624 pub ep_total_free_size: u64,
625 #[doc = "< endpoint dram reserved memory in bytes for firmware"]
626 pub ep_total_reserved_occupancy_size: u64,
627 #[doc = "< endpoint dram memory occupied by all the active model artefacts in bytes"]
628 pub ep_total_model_occupancy_size: u64,
629 #[doc = "< endpoint dram memory occupied by all the active model tensors in bytes"]
630 pub ep_total_tensor_occupancy_size: u64,
631}
632#[allow(clippy::unnecessary_operation, clippy::identity_op)]
633const _: () = {
634 ["Size of dv_endpoint_dram_statistics"]
635 [::std::mem::size_of::<dv_endpoint_dram_statistics>() - 56usize];
636 ["Alignment of dv_endpoint_dram_statistics"]
637 [::std::mem::align_of::<dv_endpoint_dram_statistics>() - 8usize];
638 ["Offset of field: dv_endpoint_dram_statistics::ep"]
639 [::std::mem::offset_of!(dv_endpoint_dram_statistics, ep) - 0usize];
640 ["Offset of field: dv_endpoint_dram_statistics::ep_total_dram_size"]
641 [::std::mem::offset_of!(dv_endpoint_dram_statistics, ep_total_dram_size) - 8usize];
642 ["Offset of field: dv_endpoint_dram_statistics::ep_total_dram_occupancy_size"][::std::mem::offset_of!(
643 dv_endpoint_dram_statistics,
644 ep_total_dram_occupancy_size
645 ) - 16usize];
646 ["Offset of field: dv_endpoint_dram_statistics::ep_total_free_size"]
647 [::std::mem::offset_of!(dv_endpoint_dram_statistics, ep_total_free_size) - 24usize];
648 ["Offset of field: dv_endpoint_dram_statistics::ep_total_reserved_occupancy_size"][::std::mem::offset_of!(
649 dv_endpoint_dram_statistics,
650 ep_total_reserved_occupancy_size
651 ) - 32usize];
652 ["Offset of field: dv_endpoint_dram_statistics::ep_total_model_occupancy_size"][::std::mem::offset_of!(
653 dv_endpoint_dram_statistics,
654 ep_total_model_occupancy_size
655 ) - 40usize];
656 ["Offset of field: dv_endpoint_dram_statistics::ep_total_tensor_occupancy_size"][::std::mem::offset_of!(
657 dv_endpoint_dram_statistics,
658 ep_total_tensor_occupancy_size
659 ) - 48usize];
660};
661pub type dv_endpoint_dram_statistics_t = dv_endpoint_dram_statistics;
662#[repr(C)]
663#[derive(Debug, Copy, Clone)]
664pub struct dv_inference_queue_statistics {
665 #[doc = "< Number of inference queue slots occupied with inference request for the endpoint"]
666 pub occupancy_count: ::std::os::raw::c_int,
667 #[doc = "< length of the inference queue for the endpoint"]
668 pub length: ::std::os::raw::c_int,
669 #[doc = "< waiting time in mili secs for the new inference request to get picked up by endpoint"]
670 pub wait_time: f32,
671}
672#[allow(clippy::unnecessary_operation, clippy::identity_op)]
673const _: () = {
674 ["Size of dv_inference_queue_statistics"]
675 [::std::mem::size_of::<dv_inference_queue_statistics>() - 12usize];
676 ["Alignment of dv_inference_queue_statistics"]
677 [::std::mem::align_of::<dv_inference_queue_statistics>() - 4usize];
678 ["Offset of field: dv_inference_queue_statistics::occupancy_count"]
679 [::std::mem::offset_of!(dv_inference_queue_statistics, occupancy_count) - 0usize];
680 ["Offset of field: dv_inference_queue_statistics::length"]
681 [::std::mem::offset_of!(dv_inference_queue_statistics, length) - 4usize];
682 ["Offset of field: dv_inference_queue_statistics::wait_time"]
683 [::std::mem::offset_of!(dv_inference_queue_statistics, wait_time) - 8usize];
684};
685pub type dv_inference_queue_statistics_t = dv_inference_queue_statistics;
686#[repr(C)]
687#[derive(Debug, Copy, Clone)]
688pub struct dv_model_statistics {
689 #[doc = "< model handle"]
690 pub model: u32,
691 #[doc = "< number for active model input tensor(s) present in an endpoint"]
692 pub active_input_tensors_count: u32,
693 #[doc = "< number for active model output tensor(s) present in an endpoint"]
694 pub active_output_tensors_count: u32,
695 #[doc = "< number for active model inference request queued in an endpoint"]
696 pub active_inferences_count: u32,
697 #[doc = "< total endpoint dram occupancy in bytes by model artefacts"]
698 pub model_total_dram_occupancy_size: u32,
699 #[doc = "< total endpoint dram occupancy in bytes by model input tensors"]
700 pub model_total_input_tensor_occupancy_size: u32,
701 #[doc = "< total endpoint dram occupancy in bytes by model output tensors"]
702 pub model_total_output_tensor_occupancy_size: u32,
703 #[doc = "< \\since r5.3 void* handle which can be compared to `handle` member of dv_model_t"]
704 pub model_handle: *mut dv_model_handle_t,
705}
706#[allow(clippy::unnecessary_operation, clippy::identity_op)]
707const _: () = {
708 ["Size of dv_model_statistics"][::std::mem::size_of::<dv_model_statistics>() - 40usize];
709 ["Alignment of dv_model_statistics"][::std::mem::align_of::<dv_model_statistics>() - 8usize];
710 ["Offset of field: dv_model_statistics::model"]
711 [::std::mem::offset_of!(dv_model_statistics, model) - 0usize];
712 ["Offset of field: dv_model_statistics::active_input_tensors_count"]
713 [::std::mem::offset_of!(dv_model_statistics, active_input_tensors_count) - 4usize];
714 ["Offset of field: dv_model_statistics::active_output_tensors_count"]
715 [::std::mem::offset_of!(dv_model_statistics, active_output_tensors_count) - 8usize];
716 ["Offset of field: dv_model_statistics::active_inferences_count"]
717 [::std::mem::offset_of!(dv_model_statistics, active_inferences_count) - 12usize];
718 ["Offset of field: dv_model_statistics::model_total_dram_occupancy_size"]
719 [::std::mem::offset_of!(dv_model_statistics, model_total_dram_occupancy_size) - 16usize];
720 ["Offset of field: dv_model_statistics::model_total_input_tensor_occupancy_size"][::std::mem::offset_of!(
721 dv_model_statistics,
722 model_total_input_tensor_occupancy_size
723 ) - 20usize];
724 ["Offset of field: dv_model_statistics::model_total_output_tensor_occupancy_size"][::std::mem::offset_of!(
725 dv_model_statistics,
726 model_total_output_tensor_occupancy_size
727 ) - 24usize];
728 ["Offset of field: dv_model_statistics::model_handle"]
729 [::std::mem::offset_of!(dv_model_statistics, model_handle) - 32usize];
730};
731pub type dv_model_statistics_t = dv_model_statistics;
732#[repr(C)]
733#[derive(Debug, Copy, Clone)]
734pub struct dv_endpoint_stats {
735 #[doc = "< endpoint handle"]
736 pub ep: *mut dv_endpoint_t,
737 #[doc = "< endpoint state"]
738 pub state: dv_endpoint_state_t,
739 #[doc = "< endpoint system core clock in MHz"]
740 pub ep_sys_clk: ::std::os::raw::c_int,
741 #[doc = "< endpoint dram clock in MHz"]
742 pub ep_dram_clk: ::std::os::raw::c_int,
743 #[doc = "< average of endpoint core voltage across all measurement point in hardware in volts"]
744 pub ep_core_voltage: f32,
745 #[doc = "< average of endpoint temperature across all measurement point in hardware in degree celsius"]
746 pub ep_temp: f32,
747 #[doc = "< number of inference queues available for the endpoint [unsupported]"]
748 pub num_inference_queues: ::std::os::raw::c_int,
749 #[doc = "< inference queue statistics for the endpoint [unsupported]"]
750 pub ep_infq_stats: *mut dv_inference_queue_statistics_t,
751 #[doc = "< number of active models present in endpoint [unsupported]"]
752 pub num_active_models: ::std::os::raw::c_int,
753 #[doc = "< statistics for all models active on the endpoint [unsupported]"]
754 pub model_stats: *mut dv_model_statistics_t,
755 #[doc = "< endpoint dram statistics"]
756 pub ep_dram_stats: dv_endpoint_dram_statistics_t,
757 #[doc = "< endpoint power state [unsupported]"]
758 pub ep_power_state: dv_endpoint_power_state_t,
759 #[doc = "< endpoint soft reset count, non zero for usb devices"]
760 pub ep_soft_reset_count: u32,
761}
762#[allow(clippy::unnecessary_operation, clippy::identity_op)]
763const _: () = {
764 ["Size of dv_endpoint_stats"][::std::mem::size_of::<dv_endpoint_stats>() - 120usize];
765 ["Alignment of dv_endpoint_stats"][::std::mem::align_of::<dv_endpoint_stats>() - 8usize];
766 ["Offset of field: dv_endpoint_stats::ep"]
767 [::std::mem::offset_of!(dv_endpoint_stats, ep) - 0usize];
768 ["Offset of field: dv_endpoint_stats::state"]
769 [::std::mem::offset_of!(dv_endpoint_stats, state) - 8usize];
770 ["Offset of field: dv_endpoint_stats::ep_sys_clk"]
771 [::std::mem::offset_of!(dv_endpoint_stats, ep_sys_clk) - 12usize];
772 ["Offset of field: dv_endpoint_stats::ep_dram_clk"]
773 [::std::mem::offset_of!(dv_endpoint_stats, ep_dram_clk) - 16usize];
774 ["Offset of field: dv_endpoint_stats::ep_core_voltage"]
775 [::std::mem::offset_of!(dv_endpoint_stats, ep_core_voltage) - 20usize];
776 ["Offset of field: dv_endpoint_stats::ep_temp"]
777 [::std::mem::offset_of!(dv_endpoint_stats, ep_temp) - 24usize];
778 ["Offset of field: dv_endpoint_stats::num_inference_queues"]
779 [::std::mem::offset_of!(dv_endpoint_stats, num_inference_queues) - 28usize];
780 ["Offset of field: dv_endpoint_stats::ep_infq_stats"]
781 [::std::mem::offset_of!(dv_endpoint_stats, ep_infq_stats) - 32usize];
782 ["Offset of field: dv_endpoint_stats::num_active_models"]
783 [::std::mem::offset_of!(dv_endpoint_stats, num_active_models) - 40usize];
784 ["Offset of field: dv_endpoint_stats::model_stats"]
785 [::std::mem::offset_of!(dv_endpoint_stats, model_stats) - 48usize];
786 ["Offset of field: dv_endpoint_stats::ep_dram_stats"]
787 [::std::mem::offset_of!(dv_endpoint_stats, ep_dram_stats) - 56usize];
788 ["Offset of field: dv_endpoint_stats::ep_power_state"]
789 [::std::mem::offset_of!(dv_endpoint_stats, ep_power_state) - 112usize];
790 ["Offset of field: dv_endpoint_stats::ep_soft_reset_count"]
791 [::std::mem::offset_of!(dv_endpoint_stats, ep_soft_reset_count) - 116usize];
792};
793pub type dv_endpoint_statistics_t = dv_endpoint_stats;
794#[doc = " Usage:\n for quantization and dequantization of inputs/outputs is different for different qmodes\n for qmode - 0, 1, 2 and 3:\n quantized_value = round(float_value * qn)\n dequantized_value = quantized_value / qn\n for qmode - 9:\n quantized_value = round(float_value / qn) + offset\n dequantized_value = (float_value - offset )* qn"]
795#[repr(C)]
796#[derive(Debug, Copy, Clone)]
797pub struct dv_model_input_preprocess_param {
798 #[doc = "< quantization scale"]
799 pub qn: f32,
800 #[doc = "< per channel scale for nch<=3, else null"]
801 pub scale: *mut f32,
802 #[doc = "< per channel mean for nch<=3, else null"]
803 pub mean: *mut f32,
804 #[doc = "< aspect ratio based resize"]
805 pub aspect_resize: bool,
806 #[doc = "< mirror effect"]
807 pub mirror: bool,
808 #[doc = "< center crop"]
809 pub center_crop: bool,
810 #[doc = "< convert BGR to RGB"]
811 pub bgr_to_rgb: bool,
812 #[doc = "< interpolation method supported by OpenCV"]
813 pub interpolation: ::std::os::raw::c_int,
814 #[doc = "< input range ((-128) - (128)) / (0 - 255)"]
815 pub is_signed: bool,
816 #[doc = "< bytes per pixel"]
817 pub bpp: ::std::os::raw::c_int,
818 #[doc = "< output scale"]
819 pub output_scale: f32,
820 #[doc = "< aspect resize scaling factor"]
821 pub aspect_resize_scale: f32,
822 #[doc = "< offset for asymmetric quantization"]
823 pub offset: ::std::os::raw::c_int,
824 #[doc = "< quantization mode"]
825 pub qmode: ::std::os::raw::c_int,
826}
827#[allow(clippy::unnecessary_operation, clippy::identity_op)]
828const _: () = {
829 ["Size of dv_model_input_preprocess_param"]
830 [::std::mem::size_of::<dv_model_input_preprocess_param>() - 56usize];
831 ["Alignment of dv_model_input_preprocess_param"]
832 [::std::mem::align_of::<dv_model_input_preprocess_param>() - 8usize];
833 ["Offset of field: dv_model_input_preprocess_param::qn"]
834 [::std::mem::offset_of!(dv_model_input_preprocess_param, qn) - 0usize];
835 ["Offset of field: dv_model_input_preprocess_param::scale"]
836 [::std::mem::offset_of!(dv_model_input_preprocess_param, scale) - 8usize];
837 ["Offset of field: dv_model_input_preprocess_param::mean"]
838 [::std::mem::offset_of!(dv_model_input_preprocess_param, mean) - 16usize];
839 ["Offset of field: dv_model_input_preprocess_param::aspect_resize"]
840 [::std::mem::offset_of!(dv_model_input_preprocess_param, aspect_resize) - 24usize];
841 ["Offset of field: dv_model_input_preprocess_param::mirror"]
842 [::std::mem::offset_of!(dv_model_input_preprocess_param, mirror) - 25usize];
843 ["Offset of field: dv_model_input_preprocess_param::center_crop"]
844 [::std::mem::offset_of!(dv_model_input_preprocess_param, center_crop) - 26usize];
845 ["Offset of field: dv_model_input_preprocess_param::bgr_to_rgb"]
846 [::std::mem::offset_of!(dv_model_input_preprocess_param, bgr_to_rgb) - 27usize];
847 ["Offset of field: dv_model_input_preprocess_param::interpolation"]
848 [::std::mem::offset_of!(dv_model_input_preprocess_param, interpolation) - 28usize];
849 ["Offset of field: dv_model_input_preprocess_param::is_signed"]
850 [::std::mem::offset_of!(dv_model_input_preprocess_param, is_signed) - 32usize];
851 ["Offset of field: dv_model_input_preprocess_param::bpp"]
852 [::std::mem::offset_of!(dv_model_input_preprocess_param, bpp) - 36usize];
853 ["Offset of field: dv_model_input_preprocess_param::output_scale"]
854 [::std::mem::offset_of!(dv_model_input_preprocess_param, output_scale) - 40usize];
855 ["Offset of field: dv_model_input_preprocess_param::aspect_resize_scale"]
856 [::std::mem::offset_of!(dv_model_input_preprocess_param, aspect_resize_scale) - 44usize];
857 ["Offset of field: dv_model_input_preprocess_param::offset"]
858 [::std::mem::offset_of!(dv_model_input_preprocess_param, offset) - 48usize];
859 ["Offset of field: dv_model_input_preprocess_param::qmode"]
860 [::std::mem::offset_of!(dv_model_input_preprocess_param, qmode) - 52usize];
861};
862#[doc = " Usage:\n for quantization and dequantization of inputs/outputs is different for different qmodes\n for qmode - 0, 1, 2 and 3:\n quantized_value = round(float_value * qn)\n dequantized_value = quantized_value / qn\n for qmode - 9:\n quantized_value = round(float_value / qn) + offset\n dequantized_value = (float_value - offset )* qn"]
863pub type dv_model_input_preprocess_param_t = dv_model_input_preprocess_param;
864#[doc = " Model Input Tensor Parameters"]
865#[repr(C)]
866#[derive(Debug, Copy, Clone)]
867pub struct dv_model_input_param {
868 pub preprocess_param: *mut dv_model_input_preprocess_param_t,
869 #[doc = "< input layer id"]
870 pub layer_id: ::std::os::raw::c_int,
871 #[doc = "< input blob id within the layer"]
872 pub blob_id: ::std::os::raw::c_int,
873 #[doc = "< input layer name"]
874 pub layer_name: *mut ::std::os::raw::c_char,
875 #[doc = "< input blob name within the layer"]
876 pub blob_name: *mut ::std::os::raw::c_char,
877 #[doc = "< input layer type"]
878 pub layer_type: *mut ::std::os::raw::c_char,
879 #[doc = "< input layout"]
880 pub layout: *mut ::std::os::raw::c_char,
881 #[doc = "< tensor size in bytes"]
882 pub size: ::std::os::raw::c_int,
883 #[doc = "< tensor width"]
884 pub width: ::std::os::raw::c_int,
885 #[doc = "< tensor height"]
886 pub height: ::std::os::raw::c_int,
887 #[doc = "< depth dimension"]
888 pub depth: ::std::os::raw::c_int,
889 #[doc = "< number of channels"]
890 pub nch: ::std::os::raw::c_int,
891 #[doc = "< bytes per pixel"]
892 pub bpp: ::std::os::raw::c_int,
893 #[doc = "< batch size"]
894 pub batch_size: ::std::os::raw::c_int,
895 #[doc = "< num"]
896 pub num: ::std::os::raw::c_int,
897 #[doc = "<source graph input layer name"]
898 pub src_graph_layer_name: *mut ::std::os::raw::c_char,
899}
900#[allow(clippy::unnecessary_operation, clippy::identity_op)]
901const _: () = {
902 ["Size of dv_model_input_param"][::std::mem::size_of::<dv_model_input_param>() - 88usize];
903 ["Alignment of dv_model_input_param"][::std::mem::align_of::<dv_model_input_param>() - 8usize];
904 ["Offset of field: dv_model_input_param::preprocess_param"]
905 [::std::mem::offset_of!(dv_model_input_param, preprocess_param) - 0usize];
906 ["Offset of field: dv_model_input_param::layer_id"]
907 [::std::mem::offset_of!(dv_model_input_param, layer_id) - 8usize];
908 ["Offset of field: dv_model_input_param::blob_id"]
909 [::std::mem::offset_of!(dv_model_input_param, blob_id) - 12usize];
910 ["Offset of field: dv_model_input_param::layer_name"]
911 [::std::mem::offset_of!(dv_model_input_param, layer_name) - 16usize];
912 ["Offset of field: dv_model_input_param::blob_name"]
913 [::std::mem::offset_of!(dv_model_input_param, blob_name) - 24usize];
914 ["Offset of field: dv_model_input_param::layer_type"]
915 [::std::mem::offset_of!(dv_model_input_param, layer_type) - 32usize];
916 ["Offset of field: dv_model_input_param::layout"]
917 [::std::mem::offset_of!(dv_model_input_param, layout) - 40usize];
918 ["Offset of field: dv_model_input_param::size"]
919 [::std::mem::offset_of!(dv_model_input_param, size) - 48usize];
920 ["Offset of field: dv_model_input_param::width"]
921 [::std::mem::offset_of!(dv_model_input_param, width) - 52usize];
922 ["Offset of field: dv_model_input_param::height"]
923 [::std::mem::offset_of!(dv_model_input_param, height) - 56usize];
924 ["Offset of field: dv_model_input_param::depth"]
925 [::std::mem::offset_of!(dv_model_input_param, depth) - 60usize];
926 ["Offset of field: dv_model_input_param::nch"]
927 [::std::mem::offset_of!(dv_model_input_param, nch) - 64usize];
928 ["Offset of field: dv_model_input_param::bpp"]
929 [::std::mem::offset_of!(dv_model_input_param, bpp) - 68usize];
930 ["Offset of field: dv_model_input_param::batch_size"]
931 [::std::mem::offset_of!(dv_model_input_param, batch_size) - 72usize];
932 ["Offset of field: dv_model_input_param::num"]
933 [::std::mem::offset_of!(dv_model_input_param, num) - 76usize];
934 ["Offset of field: dv_model_input_param::src_graph_layer_name"]
935 [::std::mem::offset_of!(dv_model_input_param, src_graph_layer_name) - 80usize];
936};
937#[doc = " Model Input Tensor Parameters"]
938pub type dv_model_input_param_t = dv_model_input_param;
939#[doc = " Model output post processing parameters"]
940#[repr(C)]
941#[derive(Debug, Copy, Clone)]
942pub struct dv_model_output_postprocess_param {
943 #[doc = "< output quantization parameter"]
944 pub qn: f32,
945 #[doc = "< output is structured or not"]
946 pub is_struct_format: bool,
947 #[doc = "< output is float type"]
948 pub is_float: bool,
949 #[doc = "< output is signed or not"]
950 pub is_signed: bool,
951 #[doc = "< output scale for asymmetric quantization"]
952 pub output_scale: f32,
953 #[doc = "< offset for asymmetric quantization"]
954 pub offset: ::std::os::raw::c_int,
955}
956#[allow(clippy::unnecessary_operation, clippy::identity_op)]
957const _: () = {
958 ["Size of dv_model_output_postprocess_param"]
959 [::std::mem::size_of::<dv_model_output_postprocess_param>() - 16usize];
960 ["Alignment of dv_model_output_postprocess_param"]
961 [::std::mem::align_of::<dv_model_output_postprocess_param>() - 4usize];
962 ["Offset of field: dv_model_output_postprocess_param::qn"]
963 [::std::mem::offset_of!(dv_model_output_postprocess_param, qn) - 0usize];
964 ["Offset of field: dv_model_output_postprocess_param::is_struct_format"]
965 [::std::mem::offset_of!(dv_model_output_postprocess_param, is_struct_format) - 4usize];
966 ["Offset of field: dv_model_output_postprocess_param::is_float"]
967 [::std::mem::offset_of!(dv_model_output_postprocess_param, is_float) - 5usize];
968 ["Offset of field: dv_model_output_postprocess_param::is_signed"]
969 [::std::mem::offset_of!(dv_model_output_postprocess_param, is_signed) - 6usize];
970 ["Offset of field: dv_model_output_postprocess_param::output_scale"]
971 [::std::mem::offset_of!(dv_model_output_postprocess_param, output_scale) - 8usize];
972 ["Offset of field: dv_model_output_postprocess_param::offset"]
973 [::std::mem::offset_of!(dv_model_output_postprocess_param, offset) - 12usize];
974};
975#[doc = " Model output post processing parameters"]
976pub type dv_model_output_postprocess_param_t = dv_model_output_postprocess_param;
977#[doc = " Model output parameters"]
978#[repr(C)]
979#[derive(Debug, Copy, Clone)]
980pub struct dv_model_output_param {
981 #[doc = "<"]
982 pub postprocess_param: *mut dv_model_output_postprocess_param_t,
983 #[doc = "< layer id"]
984 pub layer_id: ::std::os::raw::c_int,
985 #[doc = "< input blob id within the layer"]
986 pub blob_id: ::std::os::raw::c_int,
987 #[doc = "< layer fused parent id"]
988 pub fused_parent_id: ::std::os::raw::c_int,
989 #[doc = "< layer name"]
990 pub layer_name: *mut ::std::os::raw::c_char,
991 #[doc = "< input blob name within the layer"]
992 pub blob_name: *mut ::std::os::raw::c_char,
993 #[doc = "< layer fused parent name"]
994 pub layer_fused_parent_name: *mut ::std::os::raw::c_char,
995 #[doc = "< layer type"]
996 pub layer_type: *mut ::std::os::raw::c_char,
997 #[doc = "< output layout"]
998 pub layout: *mut ::std::os::raw::c_char,
999 #[doc = "< layer size in bytes"]
1000 pub size: ::std::os::raw::c_int,
1001 #[doc = "< layer width in pixels"]
1002 pub width: ::std::os::raw::c_int,
1003 #[doc = "< layer height in pixels"]
1004 pub height: ::std::os::raw::c_int,
1005 #[doc = "< layer depth in pixels"]
1006 pub depth: ::std::os::raw::c_int,
1007 #[doc = "< number of channels"]
1008 pub nch: ::std::os::raw::c_int,
1009 #[doc = "< bytes per pixel"]
1010 pub bpp: ::std::os::raw::c_int,
1011 #[doc = "< number of classes for which model is trained on"]
1012 pub num_classes: ::std::os::raw::c_int,
1013 #[doc = "< output type of layer"]
1014 pub layer_output_type: dv_layer_output_type_t,
1015 #[doc = "< num dimension >"]
1016 pub num: ::std::os::raw::c_int,
1017 #[doc = "< max batch id"]
1018 pub max_dynamic_id: ::std::os::raw::c_int,
1019 #[doc = "< source graph output layer name"]
1020 pub src_graph_layer_name: *mut ::std::os::raw::c_char,
1021}
1022#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1023const _: () = {
1024 ["Size of dv_model_output_param"][::std::mem::size_of::<dv_model_output_param>() - 112usize];
1025 ["Alignment of dv_model_output_param"]
1026 [::std::mem::align_of::<dv_model_output_param>() - 8usize];
1027 ["Offset of field: dv_model_output_param::postprocess_param"]
1028 [::std::mem::offset_of!(dv_model_output_param, postprocess_param) - 0usize];
1029 ["Offset of field: dv_model_output_param::layer_id"]
1030 [::std::mem::offset_of!(dv_model_output_param, layer_id) - 8usize];
1031 ["Offset of field: dv_model_output_param::blob_id"]
1032 [::std::mem::offset_of!(dv_model_output_param, blob_id) - 12usize];
1033 ["Offset of field: dv_model_output_param::fused_parent_id"]
1034 [::std::mem::offset_of!(dv_model_output_param, fused_parent_id) - 16usize];
1035 ["Offset of field: dv_model_output_param::layer_name"]
1036 [::std::mem::offset_of!(dv_model_output_param, layer_name) - 24usize];
1037 ["Offset of field: dv_model_output_param::blob_name"]
1038 [::std::mem::offset_of!(dv_model_output_param, blob_name) - 32usize];
1039 ["Offset of field: dv_model_output_param::layer_fused_parent_name"]
1040 [::std::mem::offset_of!(dv_model_output_param, layer_fused_parent_name) - 40usize];
1041 ["Offset of field: dv_model_output_param::layer_type"]
1042 [::std::mem::offset_of!(dv_model_output_param, layer_type) - 48usize];
1043 ["Offset of field: dv_model_output_param::layout"]
1044 [::std::mem::offset_of!(dv_model_output_param, layout) - 56usize];
1045 ["Offset of field: dv_model_output_param::size"]
1046 [::std::mem::offset_of!(dv_model_output_param, size) - 64usize];
1047 ["Offset of field: dv_model_output_param::width"]
1048 [::std::mem::offset_of!(dv_model_output_param, width) - 68usize];
1049 ["Offset of field: dv_model_output_param::height"]
1050 [::std::mem::offset_of!(dv_model_output_param, height) - 72usize];
1051 ["Offset of field: dv_model_output_param::depth"]
1052 [::std::mem::offset_of!(dv_model_output_param, depth) - 76usize];
1053 ["Offset of field: dv_model_output_param::nch"]
1054 [::std::mem::offset_of!(dv_model_output_param, nch) - 80usize];
1055 ["Offset of field: dv_model_output_param::bpp"]
1056 [::std::mem::offset_of!(dv_model_output_param, bpp) - 84usize];
1057 ["Offset of field: dv_model_output_param::num_classes"]
1058 [::std::mem::offset_of!(dv_model_output_param, num_classes) - 88usize];
1059 ["Offset of field: dv_model_output_param::layer_output_type"]
1060 [::std::mem::offset_of!(dv_model_output_param, layer_output_type) - 92usize];
1061 ["Offset of field: dv_model_output_param::num"]
1062 [::std::mem::offset_of!(dv_model_output_param, num) - 96usize];
1063 ["Offset of field: dv_model_output_param::max_dynamic_id"]
1064 [::std::mem::offset_of!(dv_model_output_param, max_dynamic_id) - 100usize];
1065 ["Offset of field: dv_model_output_param::src_graph_layer_name"]
1066 [::std::mem::offset_of!(dv_model_output_param, src_graph_layer_name) - 104usize];
1067};
1068#[doc = " Model output parameters"]
1069pub type dv_model_output_param_t = dv_model_output_param;
1070#[repr(C)]
1071#[derive(Debug, Copy, Clone)]
1072pub struct dv_compiler_statistics {
1073 #[doc = "< DV1 config name, governed on ep system core clock"]
1074 pub config_name: *mut ::std::os::raw::c_char,
1075 #[doc = "< total cycles estimated by compiler"]
1076 pub cycles: f32,
1077 #[doc = "< inference per seconds estimated by compiler"]
1078 pub ips: f32,
1079 #[doc = "< ep dram estimated by compiler"]
1080 pub ddr_bandwidth: f32,
1081}
1082#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1083const _: () = {
1084 ["Size of dv_compiler_statistics"][::std::mem::size_of::<dv_compiler_statistics>() - 24usize];
1085 ["Alignment of dv_compiler_statistics"]
1086 [::std::mem::align_of::<dv_compiler_statistics>() - 8usize];
1087 ["Offset of field: dv_compiler_statistics::config_name"]
1088 [::std::mem::offset_of!(dv_compiler_statistics, config_name) - 0usize];
1089 ["Offset of field: dv_compiler_statistics::cycles"]
1090 [::std::mem::offset_of!(dv_compiler_statistics, cycles) - 8usize];
1091 ["Offset of field: dv_compiler_statistics::ips"]
1092 [::std::mem::offset_of!(dv_compiler_statistics, ips) - 12usize];
1093 ["Offset of field: dv_compiler_statistics::ddr_bandwidth"]
1094 [::std::mem::offset_of!(dv_compiler_statistics, ddr_bandwidth) - 16usize];
1095};
1096pub type dv_compiler_statistics_t = dv_compiler_statistics;
1097pub const DV_MODEL_TYPE_DV_MODEL_TYPE_ARA1_CNN: DV_MODEL_TYPE = 0;
1098pub const DV_MODEL_TYPE_DV_MODEL_TYPE_ARA2_CNN: DV_MODEL_TYPE = 1;
1099pub const DV_MODEL_TYPE_DV_MODEL_TYPE_ARA2_LLM: DV_MODEL_TYPE = 2;
1100pub const DV_MODEL_TYPE_DV_MODEL_TYPE_ARA2_LLM_DYN_V2: DV_MODEL_TYPE = 3;
1101pub type DV_MODEL_TYPE = ::std::os::raw::c_uint;
1102pub use self::DV_MODEL_TYPE as dv_model_type_t;
1103#[repr(C)]
1104#[derive(Debug, Copy, Clone)]
1105pub struct dv_model_options {
1106 #[doc = "< model name"]
1107 pub model_name: *mut ::std::os::raw::c_char,
1108 #[doc = "< priority of the model [unused]"]
1109 pub priority: dv_model_priority_level_t,
1110 #[doc = "< if true, the model is cached on disk"]
1111 pub cache: bool,
1112 #[doc = "< if true, the model load API immediately return \\see\ndv_model_load_wait_for_completion"]
1113 pub async_: bool,
1114 #[doc = "< specify the model type, if not specified it will be DV_MODEL_TYPE_ARA2_CNN"]
1115 pub model_type: dv_model_type_t,
1116}
1117#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1118const _: () = {
1119 ["Size of dv_model_options"][::std::mem::size_of::<dv_model_options>() - 24usize];
1120 ["Alignment of dv_model_options"][::std::mem::align_of::<dv_model_options>() - 8usize];
1121 ["Offset of field: dv_model_options::model_name"]
1122 [::std::mem::offset_of!(dv_model_options, model_name) - 0usize];
1123 ["Offset of field: dv_model_options::priority"]
1124 [::std::mem::offset_of!(dv_model_options, priority) - 8usize];
1125 ["Offset of field: dv_model_options::cache"]
1126 [::std::mem::offset_of!(dv_model_options, cache) - 12usize];
1127 ["Offset of field: dv_model_options::async_"]
1128 [::std::mem::offset_of!(dv_model_options, async_) - 13usize];
1129 ["Offset of field: dv_model_options::model_type"]
1130 [::std::mem::offset_of!(dv_model_options, model_type) - 16usize];
1131};
1132pub type dv_model_load_options_t = dv_model_options;
1133pub const DV_INFER_TYPE_DV_INFER_TYPE_ARA1_CNN: DV_INFER_TYPE = 0;
1134pub const DV_INFER_TYPE_DV_INFER_TYPE_ARA2_CNN: DV_INFER_TYPE = 1;
1135pub const DV_INFER_TYPE_DV_INFER_TYPE_LLM_PROMPT_PROCESSING: DV_INFER_TYPE = 2;
1136pub const DV_INFER_TYPE_DV_INFER_TYPE_LLM_FOLLOWUP_PROMPT_PROCESSING: DV_INFER_TYPE = 3;
1137pub const DV_INFER_TYPE_DV_INFER_TYPE_LLM_TOKEN_GENERATION: DV_INFER_TYPE = 4;
1138pub type DV_INFER_TYPE = ::std::os::raw::c_uint;
1139pub use self::DV_INFER_TYPE as dv_infer_type_t;
1140#[repr(C)]
1141#[derive(Debug, Copy, Clone)]
1142pub struct dv_infer_options {
1143 pub enable_stats: bool,
1144 #[doc = "< specify the model type, if not specified it will be DV_MODEL_TYPE_ARA2_CNN"]
1145 pub infer_type: dv_infer_type_t,
1146 pub active_tokens: u64,
1147 pub valid_tokens: u32,
1148 pub tokens_to_skip: u32,
1149}
1150#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1151const _: () = {
1152 ["Size of dv_infer_options"][::std::mem::size_of::<dv_infer_options>() - 24usize];
1153 ["Alignment of dv_infer_options"][::std::mem::align_of::<dv_infer_options>() - 8usize];
1154 ["Offset of field: dv_infer_options::enable_stats"]
1155 [::std::mem::offset_of!(dv_infer_options, enable_stats) - 0usize];
1156 ["Offset of field: dv_infer_options::infer_type"]
1157 [::std::mem::offset_of!(dv_infer_options, infer_type) - 4usize];
1158 ["Offset of field: dv_infer_options::active_tokens"]
1159 [::std::mem::offset_of!(dv_infer_options, active_tokens) - 8usize];
1160 ["Offset of field: dv_infer_options::valid_tokens"]
1161 [::std::mem::offset_of!(dv_infer_options, valid_tokens) - 16usize];
1162 ["Offset of field: dv_infer_options::tokens_to_skip"]
1163 [::std::mem::offset_of!(dv_infer_options, tokens_to_skip) - 20usize];
1164};
1165pub type dv_infer_options_t = dv_infer_options;
1166#[repr(C)]
1167#[derive(Debug, Copy, Clone)]
1168pub struct dv_model_llm_params {
1169 pub vocab_size: u32,
1170 pub embedding_size: u32,
1171 pub input_precision: u32,
1172 pub output_precision: u32,
1173 pub max_num_tokens: u32,
1174 pub is_dynamic: u32,
1175 pub num_inputs: u32,
1176 pub pad_token_id: u32,
1177 pub eos_token_id: u32,
1178 pub bos_token_id: u32,
1179 pub embedding_lookup_addr: u64,
1180 pub embedding_lookup_scale_addr: u64,
1181}
1182#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1183const _: () = {
1184 ["Size of dv_model_llm_params"][::std::mem::size_of::<dv_model_llm_params>() - 56usize];
1185 ["Alignment of dv_model_llm_params"][::std::mem::align_of::<dv_model_llm_params>() - 8usize];
1186 ["Offset of field: dv_model_llm_params::vocab_size"]
1187 [::std::mem::offset_of!(dv_model_llm_params, vocab_size) - 0usize];
1188 ["Offset of field: dv_model_llm_params::embedding_size"]
1189 [::std::mem::offset_of!(dv_model_llm_params, embedding_size) - 4usize];
1190 ["Offset of field: dv_model_llm_params::input_precision"]
1191 [::std::mem::offset_of!(dv_model_llm_params, input_precision) - 8usize];
1192 ["Offset of field: dv_model_llm_params::output_precision"]
1193 [::std::mem::offset_of!(dv_model_llm_params, output_precision) - 12usize];
1194 ["Offset of field: dv_model_llm_params::max_num_tokens"]
1195 [::std::mem::offset_of!(dv_model_llm_params, max_num_tokens) - 16usize];
1196 ["Offset of field: dv_model_llm_params::is_dynamic"]
1197 [::std::mem::offset_of!(dv_model_llm_params, is_dynamic) - 20usize];
1198 ["Offset of field: dv_model_llm_params::num_inputs"]
1199 [::std::mem::offset_of!(dv_model_llm_params, num_inputs) - 24usize];
1200 ["Offset of field: dv_model_llm_params::pad_token_id"]
1201 [::std::mem::offset_of!(dv_model_llm_params, pad_token_id) - 28usize];
1202 ["Offset of field: dv_model_llm_params::eos_token_id"]
1203 [::std::mem::offset_of!(dv_model_llm_params, eos_token_id) - 32usize];
1204 ["Offset of field: dv_model_llm_params::bos_token_id"]
1205 [::std::mem::offset_of!(dv_model_llm_params, bos_token_id) - 36usize];
1206 ["Offset of field: dv_model_llm_params::embedding_lookup_addr"]
1207 [::std::mem::offset_of!(dv_model_llm_params, embedding_lookup_addr) - 40usize];
1208 ["Offset of field: dv_model_llm_params::embedding_lookup_scale_addr"]
1209 [::std::mem::offset_of!(dv_model_llm_params, embedding_lookup_scale_addr) - 48usize];
1210};
1211pub type dv_model_llm_params_t = dv_model_llm_params;
1212#[repr(C)]
1213#[derive(Debug, Copy, Clone)]
1214pub struct dv_llm_cfg_upd_req_t {
1215 pub top_k: u32,
1216 pub top_p: f32,
1217 pub temperature: f32,
1218 pub repetition_penalty: f32,
1219 pub target_token_post_mcp: u32,
1220 pub target_token_pre_mcp: u32,
1221 pub target_prompt_post_mcp: u32,
1222 pub target_prompt_pre_mcp: u32,
1223 pub draft_token_post_mcp: u32,
1224 pub draft_token_pre_mcp: u32,
1225 pub draft_prompt_post_mcp: u32,
1226 pub draft_prompt_pre_mcp: u32,
1227}
1228#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1229const _: () = {
1230 ["Size of dv_llm_cfg_upd_req_t"][::std::mem::size_of::<dv_llm_cfg_upd_req_t>() - 48usize];
1231 ["Alignment of dv_llm_cfg_upd_req_t"][::std::mem::align_of::<dv_llm_cfg_upd_req_t>() - 4usize];
1232 ["Offset of field: dv_llm_cfg_upd_req_t::top_k"]
1233 [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, top_k) - 0usize];
1234 ["Offset of field: dv_llm_cfg_upd_req_t::top_p"]
1235 [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, top_p) - 4usize];
1236 ["Offset of field: dv_llm_cfg_upd_req_t::temperature"]
1237 [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, temperature) - 8usize];
1238 ["Offset of field: dv_llm_cfg_upd_req_t::repetition_penalty"]
1239 [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, repetition_penalty) - 12usize];
1240 ["Offset of field: dv_llm_cfg_upd_req_t::target_token_post_mcp"]
1241 [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, target_token_post_mcp) - 16usize];
1242 ["Offset of field: dv_llm_cfg_upd_req_t::target_token_pre_mcp"]
1243 [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, target_token_pre_mcp) - 20usize];
1244 ["Offset of field: dv_llm_cfg_upd_req_t::target_prompt_post_mcp"]
1245 [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, target_prompt_post_mcp) - 24usize];
1246 ["Offset of field: dv_llm_cfg_upd_req_t::target_prompt_pre_mcp"]
1247 [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, target_prompt_pre_mcp) - 28usize];
1248 ["Offset of field: dv_llm_cfg_upd_req_t::draft_token_post_mcp"]
1249 [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, draft_token_post_mcp) - 32usize];
1250 ["Offset of field: dv_llm_cfg_upd_req_t::draft_token_pre_mcp"]
1251 [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, draft_token_pre_mcp) - 36usize];
1252 ["Offset of field: dv_llm_cfg_upd_req_t::draft_prompt_post_mcp"]
1253 [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, draft_prompt_post_mcp) - 40usize];
1254 ["Offset of field: dv_llm_cfg_upd_req_t::draft_prompt_pre_mcp"]
1255 [::std::mem::offset_of!(dv_llm_cfg_upd_req_t, draft_prompt_pre_mcp) - 44usize];
1256};
1257#[repr(C)]
1258#[derive(Debug, Copy, Clone)]
1259pub struct dv_model {
1260 #[doc = "< private handle, managed by client library"]
1261 pub handle: *mut dv_model_handle_t,
1262 #[doc = "< session handle on which model is loaded"]
1263 pub session: *mut dv_session_t,
1264 #[doc = "< endpoint handle on which model is loaded"]
1265 pub endpoint: *mut dv_endpoint_t,
1266 #[doc = "< model version as generated by compiler"]
1267 pub version: dv_version_t,
1268 #[doc = "< model name provided by user"]
1269 pub name: *mut ::std::os::raw::c_char,
1270 #[doc = "< model type"]
1271 pub model_type: dv_model_type_t,
1272 #[doc = "< internal model name as generated by compiler"]
1273 pub internal_name: *mut ::std::os::raw::c_char,
1274 #[doc = "< number of inputs needed by model"]
1275 pub num_inputs: ::std::os::raw::c_int,
1276 #[doc = "< number of output produced by model"]
1277 pub num_outputs: ::std::os::raw::c_int,
1278 #[doc = "< model priority as set by user [unused]"]
1279 pub priority: dv_model_priority_level_t,
1280 #[doc = "< list of input params"]
1281 pub input_param: *mut dv_model_input_param_t,
1282 #[doc = "< list of output params"]
1283 pub output_param: *mut dv_model_output_param_t,
1284 #[doc = "< list of llm params, valid if model is llm model"]
1285 pub llm_params: *mut dv_model_llm_params_t,
1286 #[doc = "< [unsupported]"]
1287 pub num_compiler_config: ::std::os::raw::c_int,
1288 #[doc = "< [unsupported]"]
1289 pub compiler_stats: *mut dv_compiler_statistics_t,
1290 #[doc = "< [unsupported]"]
1291 pub model_load_options: *mut dv_model_load_options_t,
1292 #[doc = "< [unsupported]"]
1293 pub cp_layer: bool,
1294}
1295#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1296const _: () = {
1297 ["Size of dv_model"][::std::mem::size_of::<dv_model>() - 128usize];
1298 ["Alignment of dv_model"][::std::mem::align_of::<dv_model>() - 8usize];
1299 ["Offset of field: dv_model::handle"][::std::mem::offset_of!(dv_model, handle) - 0usize];
1300 ["Offset of field: dv_model::session"][::std::mem::offset_of!(dv_model, session) - 8usize];
1301 ["Offset of field: dv_model::endpoint"][::std::mem::offset_of!(dv_model, endpoint) - 16usize];
1302 ["Offset of field: dv_model::version"][::std::mem::offset_of!(dv_model, version) - 24usize];
1303 ["Offset of field: dv_model::name"][::std::mem::offset_of!(dv_model, name) - 32usize];
1304 ["Offset of field: dv_model::model_type"]
1305 [::std::mem::offset_of!(dv_model, model_type) - 40usize];
1306 ["Offset of field: dv_model::internal_name"]
1307 [::std::mem::offset_of!(dv_model, internal_name) - 48usize];
1308 ["Offset of field: dv_model::num_inputs"]
1309 [::std::mem::offset_of!(dv_model, num_inputs) - 56usize];
1310 ["Offset of field: dv_model::num_outputs"]
1311 [::std::mem::offset_of!(dv_model, num_outputs) - 60usize];
1312 ["Offset of field: dv_model::priority"][::std::mem::offset_of!(dv_model, priority) - 64usize];
1313 ["Offset of field: dv_model::input_param"]
1314 [::std::mem::offset_of!(dv_model, input_param) - 72usize];
1315 ["Offset of field: dv_model::output_param"]
1316 [::std::mem::offset_of!(dv_model, output_param) - 80usize];
1317 ["Offset of field: dv_model::llm_params"]
1318 [::std::mem::offset_of!(dv_model, llm_params) - 88usize];
1319 ["Offset of field: dv_model::num_compiler_config"]
1320 [::std::mem::offset_of!(dv_model, num_compiler_config) - 96usize];
1321 ["Offset of field: dv_model::compiler_stats"]
1322 [::std::mem::offset_of!(dv_model, compiler_stats) - 104usize];
1323 ["Offset of field: dv_model::model_load_options"]
1324 [::std::mem::offset_of!(dv_model, model_load_options) - 112usize];
1325 ["Offset of field: dv_model::cp_layer"][::std::mem::offset_of!(dv_model, cp_layer) - 120usize];
1326};
1327pub type dv_model_t = dv_model;
1328#[repr(C)]
1329#[derive(Debug, Copy, Clone)]
1330pub struct dv_infer_statistics {
1331 #[doc = "< ep hardware system core clock in MHz"]
1332 pub ep_hw_sys_clk: ::std::os::raw::c_int,
1333 #[doc = "< ep hardware external nnp clock in MHz"]
1334 pub ep_hw_nnp_clk: ::std::os::raw::c_int,
1335 #[doc = "< ep hardware external sbp clock in MHz"]
1336 pub ep_hw_sbp_clk: ::std::os::raw::c_int,
1337 #[doc = "< ep hardware external dram clock in MHz"]
1338 pub ep_hw_dram_clk: ::std::os::raw::c_int,
1339 #[doc = "< total cycles taken to compute\ninference in hardware, including\nfloating point computation"]
1340 pub ep_hw_total_inference_cycles: u32,
1341 #[doc = "< cycles taken to compute floating point\noperation in hardware"]
1342 pub ep_hw_fp_cycles: u32,
1343 #[doc = "< time taken in microseconds to transfer\ninput(s) from host dram to ep hardware dram"]
1344 pub input_transfer_time: f32,
1345 #[doc = "< time taken in microseconds to transfer\noutput(s) from ep hardware dram to host dram"]
1346 pub output_transfer_time: f32,
1347 #[doc = "< time taken in microseconds to submit\ninference request to ep hardware\nAs of now this is not supported and assigned a default value -1"]
1348 pub ep_queue_submission_time: f32,
1349 #[doc = "< Total number of infer retries occured per session of proxy"]
1350 pub cumulative_replay_count: u32,
1351 #[doc = "< Total number of infer retries occured per inference"]
1352 pub current_replay_count: u32,
1353 #[doc = "< time stamp when input\ntransfer started"]
1354 pub input_transfer_start_time_stamp: timespec,
1355 #[doc = "< time stamp when output\ntransfer started"]
1356 pub output_transfer_start_time_stamp: timespec,
1357 #[doc = "< time stamp when inference\nwent into NNP queue"]
1358 pub inference_start_time_stamp: timespec,
1359 #[doc = "< time taken for inference execution in\nmicroseconds"]
1360 pub inference_execution_time: f32,
1361 #[doc = "< input ddr address"]
1362 pub input_ddr_address: u32,
1363 #[doc = "< output ddr address"]
1364 pub output_ddr_address: u32,
1365}
1366#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1367const _: () = {
1368 ["Size of dv_infer_statistics"][::std::mem::size_of::<dv_infer_statistics>() - 112usize];
1369 ["Alignment of dv_infer_statistics"][::std::mem::align_of::<dv_infer_statistics>() - 8usize];
1370 ["Offset of field: dv_infer_statistics::ep_hw_sys_clk"]
1371 [::std::mem::offset_of!(dv_infer_statistics, ep_hw_sys_clk) - 0usize];
1372 ["Offset of field: dv_infer_statistics::ep_hw_nnp_clk"]
1373 [::std::mem::offset_of!(dv_infer_statistics, ep_hw_nnp_clk) - 4usize];
1374 ["Offset of field: dv_infer_statistics::ep_hw_sbp_clk"]
1375 [::std::mem::offset_of!(dv_infer_statistics, ep_hw_sbp_clk) - 8usize];
1376 ["Offset of field: dv_infer_statistics::ep_hw_dram_clk"]
1377 [::std::mem::offset_of!(dv_infer_statistics, ep_hw_dram_clk) - 12usize];
1378 ["Offset of field: dv_infer_statistics::ep_hw_total_inference_cycles"]
1379 [::std::mem::offset_of!(dv_infer_statistics, ep_hw_total_inference_cycles) - 16usize];
1380 ["Offset of field: dv_infer_statistics::ep_hw_fp_cycles"]
1381 [::std::mem::offset_of!(dv_infer_statistics, ep_hw_fp_cycles) - 20usize];
1382 ["Offset of field: dv_infer_statistics::input_transfer_time"]
1383 [::std::mem::offset_of!(dv_infer_statistics, input_transfer_time) - 24usize];
1384 ["Offset of field: dv_infer_statistics::output_transfer_time"]
1385 [::std::mem::offset_of!(dv_infer_statistics, output_transfer_time) - 28usize];
1386 ["Offset of field: dv_infer_statistics::ep_queue_submission_time"]
1387 [::std::mem::offset_of!(dv_infer_statistics, ep_queue_submission_time) - 32usize];
1388 ["Offset of field: dv_infer_statistics::cumulative_replay_count"]
1389 [::std::mem::offset_of!(dv_infer_statistics, cumulative_replay_count) - 36usize];
1390 ["Offset of field: dv_infer_statistics::current_replay_count"]
1391 [::std::mem::offset_of!(dv_infer_statistics, current_replay_count) - 40usize];
1392 ["Offset of field: dv_infer_statistics::input_transfer_start_time_stamp"]
1393 [::std::mem::offset_of!(dv_infer_statistics, input_transfer_start_time_stamp) - 48usize];
1394 ["Offset of field: dv_infer_statistics::output_transfer_start_time_stamp"]
1395 [::std::mem::offset_of!(dv_infer_statistics, output_transfer_start_time_stamp) - 64usize];
1396 ["Offset of field: dv_infer_statistics::inference_start_time_stamp"]
1397 [::std::mem::offset_of!(dv_infer_statistics, inference_start_time_stamp) - 80usize];
1398 ["Offset of field: dv_infer_statistics::inference_execution_time"]
1399 [::std::mem::offset_of!(dv_infer_statistics, inference_execution_time) - 96usize];
1400 ["Offset of field: dv_infer_statistics::input_ddr_address"]
1401 [::std::mem::offset_of!(dv_infer_statistics, input_ddr_address) - 100usize];
1402 ["Offset of field: dv_infer_statistics::output_ddr_address"]
1403 [::std::mem::offset_of!(dv_infer_statistics, output_ddr_address) - 104usize];
1404};
1405pub type dv_infer_statistics_t = dv_infer_statistics;
1406#[repr(C)]
1407#[derive(Debug, Copy, Clone)]
1408pub struct dv_infer_llm_info {
1409 pub llm_infer_resp_num_valid_tokens: u32,
1410}
1411#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1412const _: () = {
1413 ["Size of dv_infer_llm_info"][::std::mem::size_of::<dv_infer_llm_info>() - 4usize];
1414 ["Alignment of dv_infer_llm_info"][::std::mem::align_of::<dv_infer_llm_info>() - 4usize];
1415 ["Offset of field: dv_infer_llm_info::llm_infer_resp_num_valid_tokens"]
1416 [::std::mem::offset_of!(dv_infer_llm_info, llm_infer_resp_num_valid_tokens) - 0usize];
1417};
1418pub type dv_infer_llm_info_t = dv_infer_llm_info;
1419#[repr(C)]
1420#[derive(Debug, Copy, Clone)]
1421pub struct dv_infer_request {
1422 #[doc = "< private handle, managed by client library"]
1423 pub handle: *mut dv_infer_request_handle_t,
1424 #[doc = "< session for which inference is submitted"]
1425 pub session: *mut dv_session_t,
1426 #[doc = "< endpoint for which inference is queued."]
1427 pub ep_queued: *mut dv_endpoint_t,
1428 #[doc = "< when inference request is queued on group of\nendpoints, this provide endpoint info on which\ninference is submitted."]
1429 pub ep_submitted: *mut dv_endpoint_t,
1430 #[doc = "< model handle for inference request"]
1431 pub model: *mut dv_model_t,
1432 #[doc = "< input blob list"]
1433 pub ip_blob_list: *mut dv_blob_t,
1434 #[doc = "< output blob list"]
1435 pub op_blob_list: *mut dv_blob_t,
1436 #[doc = "< inference run status"]
1437 pub status: dv_inference_status_t,
1438 #[doc = "< inference stats"]
1439 pub stats: *mut dv_infer_statistics_t,
1440 pub llm_infer_info: *mut dv_infer_llm_info_t,
1441}
1442#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1443const _: () = {
1444 ["Size of dv_infer_request"][::std::mem::size_of::<dv_infer_request>() - 80usize];
1445 ["Alignment of dv_infer_request"][::std::mem::align_of::<dv_infer_request>() - 8usize];
1446 ["Offset of field: dv_infer_request::handle"]
1447 [::std::mem::offset_of!(dv_infer_request, handle) - 0usize];
1448 ["Offset of field: dv_infer_request::session"]
1449 [::std::mem::offset_of!(dv_infer_request, session) - 8usize];
1450 ["Offset of field: dv_infer_request::ep_queued"]
1451 [::std::mem::offset_of!(dv_infer_request, ep_queued) - 16usize];
1452 ["Offset of field: dv_infer_request::ep_submitted"]
1453 [::std::mem::offset_of!(dv_infer_request, ep_submitted) - 24usize];
1454 ["Offset of field: dv_infer_request::model"]
1455 [::std::mem::offset_of!(dv_infer_request, model) - 32usize];
1456 ["Offset of field: dv_infer_request::ip_blob_list"]
1457 [::std::mem::offset_of!(dv_infer_request, ip_blob_list) - 40usize];
1458 ["Offset of field: dv_infer_request::op_blob_list"]
1459 [::std::mem::offset_of!(dv_infer_request, op_blob_list) - 48usize];
1460 ["Offset of field: dv_infer_request::status"]
1461 [::std::mem::offset_of!(dv_infer_request, status) - 56usize];
1462 ["Offset of field: dv_infer_request::stats"]
1463 [::std::mem::offset_of!(dv_infer_request, stats) - 64usize];
1464 ["Offset of field: dv_infer_request::llm_infer_info"]
1465 [::std::mem::offset_of!(dv_infer_request, llm_infer_info) - 72usize];
1466};
1467pub type dv_infer_request_t = dv_infer_request;
1468pub struct araclient {
1469 __library: ::libloading::Library,
1470 pub dv_stringify_status_code: Result<
1471 unsafe extern "C" fn(status_code: dv_status_code_t) -> *const ::std::os::raw::c_char,
1472 ::libloading::Error,
1473 >,
1474 pub dv_session_create_via_unix_socket: Result<
1475 unsafe extern "C" fn(
1476 socket_file_path: *const ::std::os::raw::c_char,
1477 session: *mut *mut dv_session_t,
1478 ) -> dv_status_code_t,
1479 ::libloading::Error,
1480 >,
1481 pub dv_session_create_via_named_pipe: Result<
1482 unsafe extern "C" fn(
1483 named_pipe: *const ::std::os::raw::c_char,
1484 session: *mut *mut dv_session_t,
1485 ) -> dv_status_code_t,
1486 ::libloading::Error,
1487 >,
1488 pub dv_session_create_via_tcp_ipv4_socket: Result<
1489 unsafe extern "C" fn(
1490 tcp_ip_addr: *const ::std::os::raw::c_char,
1491 port: ::std::os::raw::c_int,
1492 session: *mut *mut dv_session_t,
1493 ) -> dv_status_code_t,
1494 ::libloading::Error,
1495 >,
1496 pub dv_session_close: Result<
1497 unsafe extern "C" fn(session: *mut dv_session_t) -> dv_status_code_t,
1498 ::libloading::Error,
1499 >,
1500 pub dv_shmfd_register: Result<
1501 unsafe extern "C" fn(
1502 session: *mut dv_session_t,
1503 fd: ::std::os::raw::c_int,
1504 size: u32,
1505 offset: u32,
1506 fd_type: ::std::os::raw::c_int,
1507 shm_desc: *mut *mut dv_shm_descriptor_t,
1508 ) -> dv_status_code_t,
1509 ::libloading::Error,
1510 >,
1511 pub dv_shmfd_unregister: Result<
1512 unsafe extern "C" fn(shm_desc: *mut dv_shm_descriptor_t) -> dv_status_code_t,
1513 ::libloading::Error,
1514 >,
1515 pub dv_endpoint_get_list: Result<
1516 unsafe extern "C" fn(
1517 session: *mut dv_session_t,
1518 ep_list: *mut *mut dv_endpoint_t,
1519 ep_count: *mut ::std::os::raw::c_int,
1520 ) -> dv_status_code_t,
1521 ::libloading::Error,
1522 >,
1523 pub dv_endpoint_get_default_group: Result<
1524 unsafe extern "C" fn(
1525 session: *mut dv_session_t,
1526 grp: dv_endpoint_default_group_t,
1527 ep_grp: *mut *mut dv_endpoint_t,
1528 ) -> dv_status_code_t,
1529 ::libloading::Error,
1530 >,
1531 pub dv_endpoint_create_group: Result<
1532 unsafe extern "C" fn(
1533 session: *mut dv_session_t,
1534 ep_list: *mut *mut dv_endpoint_t,
1535 ep_count: ::std::os::raw::c_int,
1536 ep_grp: *mut *mut dv_endpoint_t,
1537 ) -> dv_status_code_t,
1538 ::libloading::Error,
1539 >,
1540 pub dv_endpoint_free_group: Result<
1541 unsafe extern "C" fn(ep_grp: *mut dv_endpoint_t) -> dv_status_code_t,
1542 ::libloading::Error,
1543 >,
1544 pub dv_endpoint_check_status: Result<
1545 unsafe extern "C" fn(
1546 session: *mut dv_session_t,
1547 ep: *mut dv_endpoint_t,
1548 state: *mut dv_endpoint_state_t,
1549 ) -> dv_status_code_t,
1550 ::libloading::Error,
1551 >,
1552 pub dv_endpoint_get_dram_statistics: Result<
1553 unsafe extern "C" fn(
1554 session: *mut dv_session_t,
1555 ep: *mut dv_endpoint_t,
1556 ep_dram_stats: *mut *mut dv_endpoint_dram_statistics_t,
1557 ep_count: *mut ::std::os::raw::c_int,
1558 ) -> dv_status_code_t,
1559 ::libloading::Error,
1560 >,
1561 pub dv_endpoint_free_dram_statistics: Result<
1562 unsafe extern "C" fn(
1563 ep_dram_stats: *mut dv_endpoint_dram_statistics_t,
1564 count: ::std::os::raw::c_int,
1565 ) -> dv_status_code_t,
1566 ::libloading::Error,
1567 >,
1568 pub dv_endpoint_get_statistics: Result<
1569 unsafe extern "C" fn(
1570 session: *mut dv_session_t,
1571 ep: *mut dv_endpoint_t,
1572 ep_stats: *mut *mut dv_endpoint_statistics_t,
1573 ep_count: *mut ::std::os::raw::c_int,
1574 ) -> dv_status_code_t,
1575 ::libloading::Error,
1576 >,
1577 pub dv_endpoint_free_statistics: Result<
1578 unsafe extern "C" fn(
1579 ep_stats: *mut dv_endpoint_statistics_t,
1580 count: ::std::os::raw::c_int,
1581 ) -> dv_status_code_t,
1582 ::libloading::Error,
1583 >,
1584 pub dv_model_load_from_file: Result<
1585 unsafe extern "C" fn(
1586 session: *mut dv_session_t,
1587 endpt: *mut dv_endpoint_t,
1588 model_file_path: *const ::std::os::raw::c_char,
1589 model_name: *const ::std::os::raw::c_char,
1590 priority: dv_model_priority_level_t,
1591 model_handle: *mut *mut dv_model_t,
1592 ) -> dv_status_code_t,
1593 ::libloading::Error,
1594 >,
1595 pub dv_model_load_from_blob: Result<
1596 unsafe extern "C" fn(
1597 session: *mut dv_session_t,
1598 endpt: *mut dv_endpoint_t,
1599 model_blob: *mut dv_blob_t,
1600 model_name: *const ::std::os::raw::c_char,
1601 priority: dv_model_priority_level_t,
1602 model_handle: *mut *mut dv_model_t,
1603 ) -> dv_status_code_t,
1604 ::libloading::Error,
1605 >,
1606 pub dv_model_unload: Result<
1607 unsafe extern "C" fn(model: *mut dv_model_t) -> dv_status_code_t,
1608 ::libloading::Error,
1609 >,
1610 pub dv_model_get_parameters_from_file: Result<
1611 unsafe extern "C" fn(
1612 model_file_path: *const ::std::os::raw::c_char,
1613 model: *mut *mut dv_model_t,
1614 ) -> dv_status_code_t,
1615 ::libloading::Error,
1616 >,
1617 pub dv_model_get_parameters_from_blob: Result<
1618 unsafe extern "C" fn(
1619 model_blob: *mut dv_blob_t,
1620 model: *mut *mut dv_model_t,
1621 ) -> dv_status_code_t,
1622 ::libloading::Error,
1623 >,
1624 pub dv_model_free_parameters: Result<
1625 unsafe extern "C" fn(model: *mut dv_model_t) -> dv_status_code_t,
1626 ::libloading::Error,
1627 >,
1628 pub dv_model_set_llm_cfg_params: Result<
1629 unsafe extern "C" fn(
1630 session: *mut dv_session_t,
1631 ep: *mut dv_endpoint_t,
1632 model: *mut dv_model_t,
1633 llm_cfg_update: *mut dv_llm_cfg_upd_req_t,
1634 ) -> dv_status_code_t,
1635 ::libloading::Error,
1636 >,
1637 pub dv_infer_sync: Result<
1638 unsafe extern "C" fn(
1639 session: *mut dv_session_t,
1640 endpt: *mut dv_endpoint_t,
1641 model: *mut dv_model_t,
1642 ip_array: *mut dv_blob_t,
1643 op_array: *mut dv_blob_t,
1644 timeout: ::std::os::raw::c_int,
1645 enable_stats: bool,
1646 inf_obj: *mut *mut dv_infer_request_t,
1647 ) -> dv_status_code_t,
1648 ::libloading::Error,
1649 >,
1650 pub dv_infer_async: Result<
1651 unsafe extern "C" fn(
1652 session: *mut dv_session_t,
1653 endpt: *mut dv_endpoint_t,
1654 model: *mut dv_model_t,
1655 ip_array: *mut dv_blob_t,
1656 op_array: *mut dv_blob_t,
1657 enable_stats: bool,
1658 inf_obj: *mut *mut dv_infer_request_t,
1659 ) -> dv_status_code_t,
1660 ::libloading::Error,
1661 >,
1662 pub dv_infer_wait_for_all_completion: Result<
1663 unsafe extern "C" fn(
1664 session: *mut dv_session_t,
1665 inf_obj_list: *mut *mut dv_infer_request_t,
1666 inf_obj_count: ::std::os::raw::c_int,
1667 timeout: ::std::os::raw::c_int,
1668 completed_inf_list: *mut *mut dv_infer_request_t,
1669 completed_inf_count: *mut ::std::os::raw::c_int,
1670 ) -> dv_status_code_t,
1671 ::libloading::Error,
1672 >,
1673 pub dv_infer_wait_for_completion: Result<
1674 unsafe extern "C" fn(
1675 session: *mut dv_session_t,
1676 inf_obj_list: *mut *mut dv_infer_request_t,
1677 inf_obj_count: ::std::os::raw::c_int,
1678 timeout: ::std::os::raw::c_int,
1679 inf_obj: *mut *mut dv_infer_request_t,
1680 ) -> dv_status_code_t,
1681 ::libloading::Error,
1682 >,
1683 pub dv_infer_get_req_id: Result<
1684 unsafe extern "C" fn(
1685 inf_obj: *mut dv_infer_request_t,
1686 req_id: *mut u64,
1687 ) -> dv_status_code_t,
1688 ::libloading::Error,
1689 >,
1690 pub dv_infer_free: Result<
1691 unsafe extern "C" fn(inf_obj: *mut dv_infer_request_t) -> dv_status_code_t,
1692 ::libloading::Error,
1693 >,
1694 pub dv_infer_get_inflight_count: Result<
1695 unsafe extern "C" fn(
1696 session: *mut dv_session_t,
1697 count: *mut ::std::os::raw::c_int,
1698 ) -> dv_status_code_t,
1699 ::libloading::Error,
1700 >,
1701 pub dv_get_endpoint_busyness: Result<
1702 unsafe extern "C" fn(
1703 session: *mut dv_session_t,
1704 ep: *mut dv_endpoint_t,
1705 is_busy: *mut bool,
1706 ) -> dv_status_code_t,
1707 ::libloading::Error,
1708 >,
1709 pub dv_infer_sync_with_options: Result<
1710 unsafe extern "C" fn(
1711 session: *mut dv_session_t,
1712 endpt: *mut dv_endpoint_t,
1713 model: *mut dv_model_t,
1714 ip_array: *mut dv_blob_t,
1715 op_array: *mut dv_blob_t,
1716 timeout: ::std::os::raw::c_int,
1717 inf_obj: *mut *mut dv_infer_request_t,
1718 infer_options: *mut dv_infer_options_t,
1719 ) -> dv_status_code_t,
1720 ::libloading::Error,
1721 >,
1722 pub dv_infer_async_with_options: Result<
1723 unsafe extern "C" fn(
1724 session: *mut dv_session_t,
1725 endpt: *mut dv_endpoint_t,
1726 model: *mut dv_model_t,
1727 ip_array: *mut dv_blob_t,
1728 op_array: *mut dv_blob_t,
1729 inf_obj: *mut *mut dv_infer_request_t,
1730 infer_options: *mut dv_infer_options_t,
1731 ) -> dv_status_code_t,
1732 ::libloading::Error,
1733 >,
1734 pub dv_fetch_outputs_by_layer_name: Result<
1735 unsafe extern "C" fn(
1736 inf_obj: *mut dv_infer_request_t,
1737 src_op_layer_name: *mut ::std::os::raw::c_char,
1738 op_blobs: *mut *mut dv_blob_t,
1739 num_op_blobs: *mut ::std::os::raw::c_int,
1740 ) -> dv_status_code_t,
1741 ::libloading::Error,
1742 >,
1743 pub dv_model_load_from_file_with_options: Result<
1744 unsafe extern "C" fn(
1745 session: *mut dv_session_t,
1746 endpt: *mut dv_endpoint_t,
1747 model_file_path: *const ::std::os::raw::c_char,
1748 model_handle: *mut *mut dv_model_t,
1749 options: *mut dv_model_load_options_t,
1750 ) -> dv_status_code_t,
1751 ::libloading::Error,
1752 >,
1753 pub dv_model_load_from_blob_with_options: Result<
1754 unsafe extern "C" fn(
1755 session: *mut dv_session_t,
1756 endpt: *mut dv_endpoint_t,
1757 blob: *mut dv_blob_t,
1758 model_handle: *mut *mut dv_model_t,
1759 options: *mut dv_model_load_options_t,
1760 ) -> dv_status_code_t,
1761 ::libloading::Error,
1762 >,
1763 pub dv_exchange_current_version_details: Result<
1764 unsafe extern "C" fn(
1765 session: *mut dv_session_t,
1766 product_version: *mut *mut dv_product_version_t,
1767 product_count: *mut u8,
1768 ) -> dv_status_code_t,
1769 ::libloading::Error,
1770 >,
1771 pub dv_retrieve_version_details: Result<
1772 unsafe extern "C" fn(
1773 session: *mut dv_session_t,
1774 product_version: *mut *mut dv_product_version_t,
1775 product_count: *mut u8,
1776 ) -> dv_status_code_t,
1777 ::libloading::Error,
1778 >,
1779 pub dv_get_client_lib_version: Result<
1780 unsafe extern "C" fn(client_lib_version: *mut dv_version_t) -> dv_status_code_t,
1781 ::libloading::Error,
1782 >,
1783 pub dv_free_version_details: Result<
1784 unsafe extern "C" fn(product_version: *mut dv_product_version_t) -> dv_status_code_t,
1785 ::libloading::Error,
1786 >,
1787}
1788impl araclient {
1789 pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
1790 where
1791 P: AsRef<::std::ffi::OsStr>,
1792 {
1793 let library = ::libloading::Library::new(path)?;
1794 Self::from_library(library)
1795 }
1796
1797 pub unsafe fn from_library<L>(library: L) -> Result<Self, ::libloading::Error>
1798 where
1799 L: Into<::libloading::Library>,
1800 {
1801 let __library = library.into();
1802 let dv_stringify_status_code = __library.get(b"dv_stringify_status_code\0").map(|sym| *sym);
1803 let dv_session_create_via_unix_socket = __library
1804 .get(b"dv_session_create_via_unix_socket\0")
1805 .map(|sym| *sym);
1806 let dv_session_create_via_named_pipe = __library
1807 .get(b"dv_session_create_via_named_pipe\0")
1808 .map(|sym| *sym);
1809 let dv_session_create_via_tcp_ipv4_socket = __library
1810 .get(b"dv_session_create_via_tcp_ipv4_socket\0")
1811 .map(|sym| *sym);
1812 let dv_session_close = __library.get(b"dv_session_close\0").map(|sym| *sym);
1813 let dv_shmfd_register = __library.get(b"dv_shmfd_register\0").map(|sym| *sym);
1814 let dv_shmfd_unregister = __library.get(b"dv_shmfd_unregister\0").map(|sym| *sym);
1815 let dv_endpoint_get_list = __library.get(b"dv_endpoint_get_list\0").map(|sym| *sym);
1816 let dv_endpoint_get_default_group = __library
1817 .get(b"dv_endpoint_get_default_group\0")
1818 .map(|sym| *sym);
1819 let dv_endpoint_create_group = __library.get(b"dv_endpoint_create_group\0").map(|sym| *sym);
1820 let dv_endpoint_free_group = __library.get(b"dv_endpoint_free_group\0").map(|sym| *sym);
1821 let dv_endpoint_check_status = __library.get(b"dv_endpoint_check_status\0").map(|sym| *sym);
1822 let dv_endpoint_get_dram_statistics = __library
1823 .get(b"dv_endpoint_get_dram_statistics\0")
1824 .map(|sym| *sym);
1825 let dv_endpoint_free_dram_statistics = __library
1826 .get(b"dv_endpoint_free_dram_statistics\0")
1827 .map(|sym| *sym);
1828 let dv_endpoint_get_statistics = __library
1829 .get(b"dv_endpoint_get_statistics\0")
1830 .map(|sym| *sym);
1831 let dv_endpoint_free_statistics = __library
1832 .get(b"dv_endpoint_free_statistics\0")
1833 .map(|sym| *sym);
1834 let dv_model_load_from_file = __library.get(b"dv_model_load_from_file\0").map(|sym| *sym);
1835 let dv_model_load_from_blob = __library.get(b"dv_model_load_from_blob\0").map(|sym| *sym);
1836 let dv_model_unload = __library.get(b"dv_model_unload\0").map(|sym| *sym);
1837 let dv_model_get_parameters_from_file = __library
1838 .get(b"dv_model_get_parameters_from_file\0")
1839 .map(|sym| *sym);
1840 let dv_model_get_parameters_from_blob = __library
1841 .get(b"dv_model_get_parameters_from_blob\0")
1842 .map(|sym| *sym);
1843 let dv_model_free_parameters = __library.get(b"dv_model_free_parameters\0").map(|sym| *sym);
1844 let dv_model_set_llm_cfg_params = __library
1845 .get(b"dv_model_set_llm_cfg_params\0")
1846 .map(|sym| *sym);
1847 let dv_infer_sync = __library.get(b"dv_infer_sync\0").map(|sym| *sym);
1848 let dv_infer_async = __library.get(b"dv_infer_async\0").map(|sym| *sym);
1849 let dv_infer_wait_for_all_completion = __library
1850 .get(b"dv_infer_wait_for_all_completion\0")
1851 .map(|sym| *sym);
1852 let dv_infer_wait_for_completion = __library
1853 .get(b"dv_infer_wait_for_completion\0")
1854 .map(|sym| *sym);
1855 let dv_infer_get_req_id = __library.get(b"dv_infer_get_req_id\0").map(|sym| *sym);
1856 let dv_infer_free = __library.get(b"dv_infer_free\0").map(|sym| *sym);
1857 let dv_infer_get_inflight_count = __library
1858 .get(b"dv_infer_get_inflight_count\0")
1859 .map(|sym| *sym);
1860 let dv_get_endpoint_busyness = __library.get(b"dv_get_endpoint_busyness\0").map(|sym| *sym);
1861 let dv_infer_sync_with_options = __library
1862 .get(b"dv_infer_sync_with_options\0")
1863 .map(|sym| *sym);
1864 let dv_infer_async_with_options = __library
1865 .get(b"dv_infer_async_with_options\0")
1866 .map(|sym| *sym);
1867 let dv_fetch_outputs_by_layer_name = __library
1868 .get(b"dv_fetch_outputs_by_layer_name\0")
1869 .map(|sym| *sym);
1870 let dv_model_load_from_file_with_options = __library
1871 .get(b"dv_model_load_from_file_with_options\0")
1872 .map(|sym| *sym);
1873 let dv_model_load_from_blob_with_options = __library
1874 .get(b"dv_model_load_from_blob_with_options\0")
1875 .map(|sym| *sym);
1876 let dv_exchange_current_version_details = __library
1877 .get(b"dv_exchange_current_version_details\0")
1878 .map(|sym| *sym);
1879 let dv_retrieve_version_details = __library
1880 .get(b"dv_retrieve_version_details\0")
1881 .map(|sym| *sym);
1882 let dv_get_client_lib_version = __library
1883 .get(b"dv_get_client_lib_version\0")
1884 .map(|sym| *sym);
1885 let dv_free_version_details = __library.get(b"dv_free_version_details\0").map(|sym| *sym);
1886 Ok(araclient {
1887 __library,
1888 dv_stringify_status_code,
1889 dv_session_create_via_unix_socket,
1890 dv_session_create_via_named_pipe,
1891 dv_session_create_via_tcp_ipv4_socket,
1892 dv_session_close,
1893 dv_shmfd_register,
1894 dv_shmfd_unregister,
1895 dv_endpoint_get_list,
1896 dv_endpoint_get_default_group,
1897 dv_endpoint_create_group,
1898 dv_endpoint_free_group,
1899 dv_endpoint_check_status,
1900 dv_endpoint_get_dram_statistics,
1901 dv_endpoint_free_dram_statistics,
1902 dv_endpoint_get_statistics,
1903 dv_endpoint_free_statistics,
1904 dv_model_load_from_file,
1905 dv_model_load_from_blob,
1906 dv_model_unload,
1907 dv_model_get_parameters_from_file,
1908 dv_model_get_parameters_from_blob,
1909 dv_model_free_parameters,
1910 dv_model_set_llm_cfg_params,
1911 dv_infer_sync,
1912 dv_infer_async,
1913 dv_infer_wait_for_all_completion,
1914 dv_infer_wait_for_completion,
1915 dv_infer_get_req_id,
1916 dv_infer_free,
1917 dv_infer_get_inflight_count,
1918 dv_get_endpoint_busyness,
1919 dv_infer_sync_with_options,
1920 dv_infer_async_with_options,
1921 dv_fetch_outputs_by_layer_name,
1922 dv_model_load_from_file_with_options,
1923 dv_model_load_from_blob_with_options,
1924 dv_exchange_current_version_details,
1925 dv_retrieve_version_details,
1926 dv_get_client_lib_version,
1927 dv_free_version_details,
1928 })
1929 }
1930
1931 #[doc = " Stringify status code\n \\param[in] status_code : status code\n \\param[out] status : status code as string"]
1932 pub unsafe fn dv_stringify_status_code(
1933 &self,
1934 status_code: dv_status_code_t,
1935 ) -> *const ::std::os::raw::c_char {
1936 (self
1937 .dv_stringify_status_code
1938 .as_ref()
1939 .expect("Expected function, got error."))(status_code)
1940 }
1941
1942 #[doc = " Create a session to the server using unix file socket\n Returns DV_SUCCESS on success, else error\n \\param[in] socket_file_path : server unix socket path\n \\param[out] session : session handle returned by api"]
1943 pub unsafe fn dv_session_create_via_unix_socket(
1944 &self,
1945 socket_file_path: *const ::std::os::raw::c_char,
1946 session: *mut *mut dv_session_t,
1947 ) -> dv_status_code_t {
1948 (self
1949 .dv_session_create_via_unix_socket
1950 .as_ref()
1951 .expect("Expected function, got error."))(socket_file_path, session)
1952 }
1953
1954 #[doc = " Create a session to the server using windows named pipe\n Returns DV_SUCCESS on success, else error\n \\param[in] named_pipe : server pipe\n \\param[out] session : session handle returned by api"]
1955 pub unsafe fn dv_session_create_via_named_pipe(
1956 &self,
1957 named_pipe: *const ::std::os::raw::c_char,
1958 session: *mut *mut dv_session_t,
1959 ) -> dv_status_code_t {
1960 (self
1961 .dv_session_create_via_named_pipe
1962 .as_ref()
1963 .expect("Expected function, got error."))(named_pipe, session)
1964 }
1965
1966 #[doc = " Create a session to the server using TCP/IPv4 sockets\n Returns DV_SUCCESS on success, else error\n \\param[in] tcp_ip_addr : server ipv4 address\n \\param[in] port : server port\n \\param[out] session : session handle returned by api"]
1967 pub unsafe fn dv_session_create_via_tcp_ipv4_socket(
1968 &self,
1969 tcp_ip_addr: *const ::std::os::raw::c_char,
1970 port: ::std::os::raw::c_int,
1971 session: *mut *mut dv_session_t,
1972 ) -> dv_status_code_t {
1973 (self
1974 .dv_session_create_via_tcp_ipv4_socket
1975 .as_ref()
1976 .expect("Expected function, got error."))(tcp_ip_addr, port, session)
1977 }
1978
1979 #[doc = " Close the session to the server\n Returns DV_SUCCESS on success, else error\n \\param[in] session : session handle"]
1980 pub unsafe fn dv_session_close(&self, session: *mut dv_session_t) -> dv_status_code_t {
1981 (self
1982 .dv_session_close
1983 .as_ref()
1984 .expect("Expected function, got error."))(session)
1985 }
1986
1987 #[doc = " DV SharedFD API\n ***************************************/\n/** Register a file descriptor with the server\n Returns DV_SUCCESS on success, else error\n \\param[in] session : session object\n \\param[in] fd : file fd to share\n \\param[in] size : size to mmap\n \\param[in] offset : file offset\n \\param[in] fd_type : fd type to provide hint to server (reserved)\n \\param[out] shm_desc : shared memory descriptor"]
1988 pub unsafe fn dv_shmfd_register(
1989 &self,
1990 session: *mut dv_session_t,
1991 fd: ::std::os::raw::c_int,
1992 size: u32,
1993 offset: u32,
1994 fd_type: ::std::os::raw::c_int,
1995 shm_desc: *mut *mut dv_shm_descriptor_t,
1996 ) -> dv_status_code_t {
1997 (self
1998 .dv_shmfd_register
1999 .as_ref()
2000 .expect("Expected function, got error."))(
2001 session, fd, size, offset, fd_type, shm_desc
2002 )
2003 }
2004
2005 #[doc = " Un-register shared file with the server\n Returns DV_SUCCESS on success, else error\n \\param[in] shm_desc : shared buffer descriptor"]
2006 pub unsafe fn dv_shmfd_unregister(
2007 &self,
2008 shm_desc: *mut dv_shm_descriptor_t,
2009 ) -> dv_status_code_t {
2010 (self
2011 .dv_shmfd_unregister
2012 .as_ref()
2013 .expect("Expected function, got error."))(shm_desc)
2014 }
2015
2016 #[doc = " Get the list of endpoints connected to the server\n Endpoint list memory is allocated by the api. It also returns the endpoint\n count connected to server Returns DV_SUCCESS on success, else error\n \\param[in] session : session handle\n \\param[out] ep_list : connected endpoint list returned by server\n \\param[out] ep_count : number of endpoint connected to server"]
2017 pub unsafe fn dv_endpoint_get_list(
2018 &self,
2019 session: *mut dv_session_t,
2020 ep_list: *mut *mut dv_endpoint_t,
2021 ep_count: *mut ::std::os::raw::c_int,
2022 ) -> dv_status_code_t {
2023 (self
2024 .dv_endpoint_get_list
2025 .as_ref()
2026 .expect("Expected function, got error."))(session, ep_list, ep_count)
2027 }
2028
2029 #[doc = " Get the default endpoint group supported by server.\n Type of default group supported is defined in enum DV_ENDPOINT_DEFAULT_GROUP.\n API allocates the memory for the endpoint configuration of the group.\n Application needs to free the memory using dv_endpoint_free_group() Returns\n DV_SUCCESS on success, else error \\param[in] session : session handle\n \\param[in] grp : enum as defined in enum DV_ENDPOINT_DEFAULT_GROUP\n \\param[out] ep_grp : endpoint group handle"]
2030 pub unsafe fn dv_endpoint_get_default_group(
2031 &self,
2032 session: *mut dv_session_t,
2033 grp: dv_endpoint_default_group_t,
2034 ep_grp: *mut *mut dv_endpoint_t,
2035 ) -> dv_status_code_t {
2036 (self
2037 .dv_endpoint_get_default_group
2038 .as_ref()
2039 .expect("Expected function, got error."))(session, grp, ep_grp)
2040 }
2041
2042 #[doc = " Create custom endpoint group from the endpoints connected to the server\n API allocates the memory for the endpoint configuration of the group.\n Application needs to free the memory using dv_endpoint_free_group() Returns\n DV_SUCCESS on success, else error \\param[in] session : session handle\n \\param[in] ep_list : endpoint list for which custom group needs to be\n created \\param[in] ep_count : number of endpoint in the list\n \\param[out] ep_grp : endpoint group handle"]
2043 pub unsafe fn dv_endpoint_create_group(
2044 &self,
2045 session: *mut dv_session_t,
2046 ep_list: *mut *mut dv_endpoint_t,
2047 ep_count: ::std::os::raw::c_int,
2048 ep_grp: *mut *mut dv_endpoint_t,
2049 ) -> dv_status_code_t {
2050 (self
2051 .dv_endpoint_create_group
2052 .as_ref()
2053 .expect("Expected function, got error."))(session, ep_list, ep_count, ep_grp)
2054 }
2055
2056 #[doc = " Free the default/custom endpoint group\n Returns DV_SUCCESS on success, else error\n \\param[in] session : session handle\n \\param[out] ep_list : connected endpoint list returned by server\n \\param[out] ep_count : number of endpoint connected to server"]
2057 pub unsafe fn dv_endpoint_free_group(&self, ep_grp: *mut dv_endpoint_t) -> dv_status_code_t {
2058 (self
2059 .dv_endpoint_free_group
2060 .as_ref()
2061 .expect("Expected function, got error."))(ep_grp)
2062 }
2063
2064 #[doc = " Detects endpoint state\n \\param[in] session : session handle\n \\param[in] ep : endpoint handle\n \\param[out] state : endpoint state"]
2065 pub unsafe fn dv_endpoint_check_status(
2066 &self,
2067 session: *mut dv_session_t,
2068 ep: *mut dv_endpoint_t,
2069 state: *mut dv_endpoint_state_t,
2070 ) -> dv_status_code_t {
2071 (self
2072 .dv_endpoint_check_status
2073 .as_ref()
2074 .expect("Expected function, got error."))(session, ep, state)
2075 }
2076
2077 #[doc = " Get the dram usage statistics for the endpoint/endpoint group\n Server provides the snapshot of the endpoint dram usage at the time of\n request. Passing NULL to endpoint handle will provide dram statistics for all\n the endpoint connected to the server Memory for the statistics is allocated\n by API and dv_endpoint_free_dram_statistics() is needed to free up the memory\n Returns DV_SUCCESS on success, else error\n \\param[in] session : session handle\n \\param[in] ep : endpoint/endpoint group handle for particular\n endpoint or endpoint group or NULL for all endpoints \\param[out]\n ep_dram_stats : list of endpoint dram statistics \\param[out] ep_count :\n number of endpoint for which dram statistics is provided"]
2078 pub unsafe fn dv_endpoint_get_dram_statistics(
2079 &self,
2080 session: *mut dv_session_t,
2081 ep: *mut dv_endpoint_t,
2082 ep_dram_stats: *mut *mut dv_endpoint_dram_statistics_t,
2083 ep_count: *mut ::std::os::raw::c_int,
2084 ) -> dv_status_code_t {
2085 (self
2086 .dv_endpoint_get_dram_statistics
2087 .as_ref()
2088 .expect("Expected function, got error."))(session, ep, ep_dram_stats, ep_count)
2089 }
2090
2091 #[doc = " Free the endpoint dram stats memory allocated in\n dv_endpoint_get_dram_statistics() Returns DV_SUCCESS on success, else error\n \\param[in] ep_dram_stats : endpoint dram statistics to free\n \\param[in] count : number of items to free"]
2092 pub unsafe fn dv_endpoint_free_dram_statistics(
2093 &self,
2094 ep_dram_stats: *mut dv_endpoint_dram_statistics_t,
2095 count: ::std::os::raw::c_int,
2096 ) -> dv_status_code_t {
2097 (self
2098 .dv_endpoint_free_dram_statistics
2099 .as_ref()
2100 .expect("Expected function, got error."))(ep_dram_stats, count)
2101 }
2102
2103 #[doc = " Get all the statistics for the endpoint/endpoint group\n Server provides the snapshot of the endpoint statistics at the time of\n request. Passing NULL to endpoint handle will provide statistics for all the\n endpoint connected to the server Memory for the statistics is allocated by\n API and dv_endpoint_free_statistics() is needed to free up the memory Returns\n DV_SUCCESS on success, else error\n\n Notes on usage\n -------------\n `dv_model_statistics_t` member of `dv_endpoint_statistics_t` contains 2\n fields - uint32_t model and void* model_handle. This API will return stats of\n all models loaded across all clients - the `uint32_t model` will always hold\n a value and is an server generated id. The value of the `void* model_handle`\n member can be compared to the `handle` member of `dv_model_t` to map\n `dv_model_t` objects to their corresponding `dv_model_statistics_t` objects.\n\n \\param[in] session : session handle\n \\param[in] ep : endpoint/endpoint group handle for particular\n endpoint or endpoint group or NULL for all endpoints \\param[out] ep_stats :\n list of endpoint statistics \\param[out] ep_count : number of endpoint for\n which statistics is provided"]
2104 pub unsafe fn dv_endpoint_get_statistics(
2105 &self,
2106 session: *mut dv_session_t,
2107 ep: *mut dv_endpoint_t,
2108 ep_stats: *mut *mut dv_endpoint_statistics_t,
2109 ep_count: *mut ::std::os::raw::c_int,
2110 ) -> dv_status_code_t {
2111 (self
2112 .dv_endpoint_get_statistics
2113 .as_ref()
2114 .expect("Expected function, got error."))(session, ep, ep_stats, ep_count)
2115 }
2116
2117 #[doc = " Free the endpoint stats memory allocated in dv_endpoint_get_statistics()\n Returns DV_SUCCESS on success, else error\n \\param[in] ep_stats : endpoint statistics list to free\n \\param[in] count : number of items to free"]
2118 pub unsafe fn dv_endpoint_free_statistics(
2119 &self,
2120 ep_stats: *mut dv_endpoint_statistics_t,
2121 count: ::std::os::raw::c_int,
2122 ) -> dv_status_code_t {
2123 (self
2124 .dv_endpoint_free_statistics
2125 .as_ref()
2126 .expect("Expected function, got error."))(ep_stats, count)
2127 }
2128
2129 #[doc = " Creates a model object and load model contents from file and transfer it to\n endpoint Model object contains the model handle and model parameters.\n `dv_model_get_loaded_endpoint_list` returns the list of endpoints (individual\n device dv_endpoint_t handles) on which the model was successfully loaded.\n\n If model load fails on all individual devices representing `endpt`, the API\n call will error out.\n\n Returns DV_SUCCESS on success, else error\n \\param[in] session : session handle\n \\param[in] endpt : endpoint handle\n \\param[in] model_file_path : model file path\n \\param[in] priority : model priority [unused]\n \\param[in] model_name : model name [unused]\n \\param[out] model_handle : model handle returned by server"]
2130 pub unsafe fn dv_model_load_from_file(
2131 &self,
2132 session: *mut dv_session_t,
2133 endpt: *mut dv_endpoint_t,
2134 model_file_path: *const ::std::os::raw::c_char,
2135 model_name: *const ::std::os::raw::c_char,
2136 priority: dv_model_priority_level_t,
2137 model_handle: *mut *mut dv_model_t,
2138 ) -> dv_status_code_t {
2139 (self
2140 .dv_model_load_from_file
2141 .as_ref()
2142 .expect("Expected function, got error."))(
2143 session,
2144 endpt,
2145 model_file_path,
2146 model_name,
2147 priority,
2148 model_handle,
2149 )
2150 }
2151
2152 #[doc = " Creates a model object and load model contents from blob and transfer it to\n endpoint Model object contains the model handle and model parameters.\n `dv_model_get_loaded_endpoint_list` returns the list of endpoints (individual\n device dv_endpoint_t handles) on which the model was successfully loaded.\n\n If model load fails on all individual devices representing `endpt`, the API\n call will error out.\n\n Returns DV_SUCCESS on success, else error\n \\param[in] session : session handle\n \\param[in] endpt : endpoint handle\n \\param[in] model_blob : model blob\n \\param[in] priority : model priority [unused]\n \\param[in] model_name : model name [unused]\n \\param[out] model_handle : model handle returned by server"]
2153 pub unsafe fn dv_model_load_from_blob(
2154 &self,
2155 session: *mut dv_session_t,
2156 endpt: *mut dv_endpoint_t,
2157 model_blob: *mut dv_blob_t,
2158 model_name: *const ::std::os::raw::c_char,
2159 priority: dv_model_priority_level_t,
2160 model_handle: *mut *mut dv_model_t,
2161 ) -> dv_status_code_t {
2162 (self
2163 .dv_model_load_from_blob
2164 .as_ref()
2165 .expect("Expected function, got error."))(
2166 session,
2167 endpt,
2168 model_blob,
2169 model_name,
2170 priority,
2171 model_handle,
2172 )
2173 }
2174
2175 #[doc = " Unloads a model from the endpoint\n Returns DV_SUCCESS on success, else error\n \\param[in] model : model handle"]
2176 pub unsafe fn dv_model_unload(&self, model: *mut dv_model_t) -> dv_status_code_t {
2177 (self
2178 .dv_model_unload
2179 .as_ref()
2180 .expect("Expected function, got error."))(model)
2181 }
2182
2183 #[doc = " Get the model parameters from model file without loading the model to\n endpoint(s) API allocates memory for the parameters. Application can free it\n by calling dv_model_free_paramaters This is a utility function, useful to get\n model parameters without loading the model to endpoint(s). The model object\n returned by the api cannot be used Returns DV_SUCCESS on success, else error\n \\param[in] model_file_path : model file path\n \\param[in] model : model parameters"]
2184 pub unsafe fn dv_model_get_parameters_from_file(
2185 &self,
2186 model_file_path: *const ::std::os::raw::c_char,
2187 model: *mut *mut dv_model_t,
2188 ) -> dv_status_code_t {
2189 (self
2190 .dv_model_get_parameters_from_file
2191 .as_ref()
2192 .expect("Expected function, got error."))(model_file_path, model)
2193 }
2194
2195 #[doc = " Get the model parameters from model blob without loading the model onto\n endpoint(s) API allocates memory for the parameters. Application can free it\n by calling dv_model_free_paramaters This is a utility function, useful to get\n model parameters without loading the model to endpoint(s) Returns DV_SUCCESS\n on success, else error \\param[in] model_blob : model blob \\param[in] model\n : model parameters"]
2196 pub unsafe fn dv_model_get_parameters_from_blob(
2197 &self,
2198 model_blob: *mut dv_blob_t,
2199 model: *mut *mut dv_model_t,
2200 ) -> dv_status_code_t {
2201 (self
2202 .dv_model_get_parameters_from_blob
2203 .as_ref()
2204 .expect("Expected function, got error."))(model_blob, model)
2205 }
2206
2207 #[doc = " Free the memory allocations for model parameter made by\n dv_model_get_parameters_* call Returns DV_SUCCESS on success, else error\n \\param[in] model : model handle"]
2208 pub unsafe fn dv_model_free_parameters(&self, model: *mut dv_model_t) -> dv_status_code_t {
2209 (self
2210 .dv_model_free_parameters
2211 .as_ref()
2212 .expect("Expected function, got error."))(model)
2213 }
2214
2215 #[doc = " Pass pre/post processing flags and params to proxy/mcp\n \\param[in] session : session handle\n \\param[in] endpt : endpoint handle\n \\param[in] model : model handle // currently unused by proxy\n \\param[in] llm_cfg_update : dv_llm_cfg_upd_req_t type representing pre/post processing flags and params"]
2216 pub unsafe fn dv_model_set_llm_cfg_params(
2217 &self,
2218 session: *mut dv_session_t,
2219 ep: *mut dv_endpoint_t,
2220 model: *mut dv_model_t,
2221 llm_cfg_update: *mut dv_llm_cfg_upd_req_t,
2222 ) -> dv_status_code_t {
2223 (self
2224 .dv_model_set_llm_cfg_params
2225 .as_ref()
2226 .expect("Expected function, got error."))(session, ep, model, llm_cfg_update)
2227 }
2228
2229 #[doc = " Submit an synchronous inference for a model to an endpoint(group)\n This is a blocking call, it returns when inference is completed\n (success/error) or a timeout has occurred Input and output blobs should be\n provided as per input and output parameter provided by model Inference object\n memory will be allocated by API and can be freed upon calling dv_infer_free()\n Returns DV_SUCCESS on success, else error\n \\param[in] session : session handle\n \\param[in] endpt : endpoint handle\n \\param[in] model : model handle\n \\param[in] ip_array : an array of input blob descriptor\n \\param[in] op_array : an array of output blob descriptor\n \\param[in] timeout : maximum time in mili seconds to wait for request\n to complete \\param[in] enable_stats : enable stats for the inference request\n (deprecated) \\param[out] inf_obj : inference object"]
2230 pub unsafe fn dv_infer_sync(
2231 &self,
2232 session: *mut dv_session_t,
2233 endpt: *mut dv_endpoint_t,
2234 model: *mut dv_model_t,
2235 ip_array: *mut dv_blob_t,
2236 op_array: *mut dv_blob_t,
2237 timeout: ::std::os::raw::c_int,
2238 enable_stats: bool,
2239 inf_obj: *mut *mut dv_infer_request_t,
2240 ) -> dv_status_code_t {
2241 (self
2242 .dv_infer_sync
2243 .as_ref()
2244 .expect("Expected function, got error."))(
2245 session,
2246 endpt,
2247 model,
2248 ip_array,
2249 op_array,
2250 timeout,
2251 enable_stats,
2252 inf_obj,
2253 )
2254 }
2255
2256 #[doc = " Submit an asynchronous inference for a model to an endpoint(group)\n Server returns a inference request id which can be used to get the completion\n status or wait upon for compleetion after the call. Input and output blobs\n should be provided as per input and output parameter provided by model\n Inference object memory will be allocated by API and can be freed upon\n calling dv_infer_free() Returns DV_SUCCESS on success, else error \\param[in]\n session : session handle \\param[in] endpt : endpoint handle\n \\param[in] model : model handle\n \\param[in] ip_array : an array of input blob descriptor\n \\param[in] op_array : an array of output blob descriptor\n \\param[in] enable_stats : enable stats for the inference request\n (deprecated) \\param[out] inf_obj : inference object"]
2257 pub unsafe fn dv_infer_async(
2258 &self,
2259 session: *mut dv_session_t,
2260 endpt: *mut dv_endpoint_t,
2261 model: *mut dv_model_t,
2262 ip_array: *mut dv_blob_t,
2263 op_array: *mut dv_blob_t,
2264 enable_stats: bool,
2265 inf_obj: *mut *mut dv_infer_request_t,
2266 ) -> dv_status_code_t {
2267 (self
2268 .dv_infer_async
2269 .as_ref()
2270 .expect("Expected function, got error."))(
2271 session,
2272 endpt,
2273 model,
2274 ip_array,
2275 op_array,
2276 enable_stats,
2277 inf_obj,
2278 )
2279 }
2280
2281 #[doc = " Monitor multiple inference request object and wait until, all of the\n request updates/changes run status If the list is empty it waits until,\n atleast one inference request submitted in the session changes run status and\n API keeps track of status change for a inference request and run status is\n reported only once.\n\n For non-empty request list, application needs to remove the completed\n inference object from the list. Request completion status can be reported\n multiple times.\n\n Returns DV_SUCCESS on success, else error\n \\param[in] session : session handle\n \\param[in] inf_id_list : inference request object list\n \\param[in] inf_id_count : number of inference request to monitor\n \\param[in] timeout : maximum time in mili seconds to wait for inference\n request to change status; defaults to 60 seconds in case timeout is passed as\n -1"]
2282 pub unsafe fn dv_infer_wait_for_all_completion(
2283 &self,
2284 session: *mut dv_session_t,
2285 inf_obj_list: *mut *mut dv_infer_request_t,
2286 inf_obj_count: ::std::os::raw::c_int,
2287 timeout: ::std::os::raw::c_int,
2288 completed_inf_list: *mut *mut dv_infer_request_t,
2289 completed_inf_count: *mut ::std::os::raw::c_int,
2290 ) -> dv_status_code_t {
2291 (self
2292 .dv_infer_wait_for_all_completion
2293 .as_ref()
2294 .expect("Expected function, got error."))(
2295 session,
2296 inf_obj_list,
2297 inf_obj_count,
2298 timeout,
2299 completed_inf_list,
2300 completed_inf_count,
2301 )
2302 }
2303
2304 #[doc = " Monitor multiple inference request object and wait until, atleast one of the\n request updates/changes run status If the list is empty it waits until,\n atleast one inference request submitted in the session changes run status and\n API keeps track of status change for a inference request and run status is\n reported only once.\n\n For non-empty request list, application needs to remove the completed\n inference object from the list. Request completion status can be reported\n multiple times.\n\n Returns DV_SUCCESS on success, else error\n \\param[in] session : session handle\n \\param[in] inf_id_list : inference request object list\n \\param[in] inf_id_count : number of inference request to monitor\n \\param[in] timeout : maximum time in mili seconds to wait for inference\n request to change status; defaults to 60 seconds in case timeout is passed as\n -1 \\param[out] inf_obj : inference id for which the state is changed"]
2305 pub unsafe fn dv_infer_wait_for_completion(
2306 &self,
2307 session: *mut dv_session_t,
2308 inf_obj_list: *mut *mut dv_infer_request_t,
2309 inf_obj_count: ::std::os::raw::c_int,
2310 timeout: ::std::os::raw::c_int,
2311 inf_obj: *mut *mut dv_infer_request_t,
2312 ) -> dv_status_code_t {
2313 (self
2314 .dv_infer_wait_for_completion
2315 .as_ref()
2316 .expect("Expected function, got error."))(
2317 session,
2318 inf_obj_list,
2319 inf_obj_count,
2320 timeout,
2321 inf_obj,
2322 )
2323 }
2324
2325 #[doc = " Returns the request id of an inference that is sent by the client.\n The request id returned will be the same printed in logs if the proxy is\n passed the `-t` flag.\n\n If the inf_obj is null or if inf_obj->handle is null, DV_INVALID_HOST_PTR is\n returned. The req_id argument is not set to any value in this case.\n\n If return value is DV_SUCCESS req_id will contain the request id of the\n inference request sent to kinara inference proxy.\n\n This api is not thread safe. Calling this API on an inference handle that has\n already been `dv_infer_free`'d is incorrect and will result in undefined\n behaviour.\n\n \\param[in] inf_obj : inference request handle\n \\param[out] req_id : request id of the inference request\n \\since r6.1.1"]
2326 pub unsafe fn dv_infer_get_req_id(
2327 &self,
2328 inf_obj: *mut dv_infer_request_t,
2329 req_id: *mut u64,
2330 ) -> dv_status_code_t {
2331 (self
2332 .dv_infer_get_req_id
2333 .as_ref()
2334 .expect("Expected function, got error."))(inf_obj, req_id)
2335 }
2336
2337 #[doc = " Finish the life cycle for the inference request.\n API will free up the associated memory for the inference request and will no\n longer be accessible. After completion, any operation on the inference\n request will be invalid. Returns DV_SUCCESS on success, else error \\param[in]\n inf_obj : inference object"]
2338 pub unsafe fn dv_infer_free(&self, inf_obj: *mut dv_infer_request_t) -> dv_status_code_t {
2339 (self
2340 .dv_infer_free
2341 .as_ref()
2342 .expect("Expected function, got error."))(inf_obj)
2343 }
2344
2345 #[doc = " Returns the number of inflight inference requests for the session object for\n which the client library has not recieved a response from the proxy server.\n \\param[in] session : session handle\n \\param[out] count : number of inference requests in flight\n \\since r5.3"]
2346 pub unsafe fn dv_infer_get_inflight_count(
2347 &self,
2348 session: *mut dv_session_t,
2349 count: *mut ::std::os::raw::c_int,
2350 ) -> dv_status_code_t {
2351 (self
2352 .dv_infer_get_inflight_count
2353 .as_ref()
2354 .expect("Expected function, got error."))(session, count)
2355 }
2356
2357 #[doc = " Get the busyness for the endpoint\n Server provides busyness of any one endpoint at the time of request\n Memory for is_busy bool variable should be provided by client app\n Returns DV_SUCCESS on success, else error\n Notes on usage\n -------------\n\n \\param[in] session : session handle\n \\param[in] ep : endpoint handle for particular endpoint\n \\param[out] is_busy : will return true if endpoint is busy else false"]
2358 pub unsafe fn dv_get_endpoint_busyness(
2359 &self,
2360 session: *mut dv_session_t,
2361 ep: *mut dv_endpoint_t,
2362 is_busy: *mut bool,
2363 ) -> dv_status_code_t {
2364 (self
2365 .dv_get_endpoint_busyness
2366 .as_ref()
2367 .expect("Expected function, got error."))(session, ep, is_busy)
2368 }
2369
2370 pub unsafe fn dv_infer_sync_with_options(
2371 &self,
2372 session: *mut dv_session_t,
2373 endpt: *mut dv_endpoint_t,
2374 model: *mut dv_model_t,
2375 ip_array: *mut dv_blob_t,
2376 op_array: *mut dv_blob_t,
2377 timeout: ::std::os::raw::c_int,
2378 inf_obj: *mut *mut dv_infer_request_t,
2379 infer_options: *mut dv_infer_options_t,
2380 ) -> dv_status_code_t {
2381 (self
2382 .dv_infer_sync_with_options
2383 .as_ref()
2384 .expect("Expected function, got error."))(
2385 session,
2386 endpt,
2387 model,
2388 ip_array,
2389 op_array,
2390 timeout,
2391 inf_obj,
2392 infer_options,
2393 )
2394 }
2395
2396 pub unsafe fn dv_infer_async_with_options(
2397 &self,
2398 session: *mut dv_session_t,
2399 endpt: *mut dv_endpoint_t,
2400 model: *mut dv_model_t,
2401 ip_array: *mut dv_blob_t,
2402 op_array: *mut dv_blob_t,
2403 inf_obj: *mut *mut dv_infer_request_t,
2404 infer_options: *mut dv_infer_options_t,
2405 ) -> dv_status_code_t {
2406 (self
2407 .dv_infer_async_with_options
2408 .as_ref()
2409 .expect("Expected function, got error."))(
2410 session,
2411 endpt,
2412 model,
2413 ip_array,
2414 op_array,
2415 inf_obj,
2416 infer_options,
2417 )
2418 }
2419
2420 #[doc = " Get output blob for given output layer names\n\n API is available from r1.2 release onwards\n Returns an array of output blobs for a given layer name\n Api should be called by passing infer handle for a successfully run inference\n Freeing infer handle will free memory pointed by output_blobs\n \\param[in] inf_obj infer request handle received after running inference successfully\n \\param[in] src_op_layer_name source graph output layer name, as specified in model output layer params struct\n \\param[out] op_blobs array of output blobs for given src_op_layer_name\n \\param[out] num_op_blobs number of output blobs in op_blobs"]
2421 pub unsafe fn dv_fetch_outputs_by_layer_name(
2422 &self,
2423 inf_obj: *mut dv_infer_request_t,
2424 src_op_layer_name: *mut ::std::os::raw::c_char,
2425 op_blobs: *mut *mut dv_blob_t,
2426 num_op_blobs: *mut ::std::os::raw::c_int,
2427 ) -> dv_status_code_t {
2428 (self
2429 .dv_fetch_outputs_by_layer_name
2430 .as_ref()
2431 .expect("Expected function, got error."))(
2432 inf_obj,
2433 src_op_layer_name,
2434 op_blobs,
2435 num_op_blobs,
2436 )
2437 }
2438
2439 #[doc = " Creates a model object and load model contents from blob and transfer it to\n endpoint Model object contains the model handle and model parameters.\n `dv_model_get_loaded_endpoint_list` returns the list of endpoints (individual\n device dv_endpoint_t handles) on which the model was successfully loaded.\n\n If model load fails on all individual devices representing `endpt`, the API\n call will error out.\n\n Returns DV_SUCCESS on success, else error\n \\param[in] session : session handle\n \\param[in] endpt : endpoint handle\n \\param[in] model_file_path : path to model file\n \\param[out] model_handle : model handle returned by server\n \\param[in] options : model load options\n \\since r6.0"]
2440 pub unsafe fn dv_model_load_from_file_with_options(
2441 &self,
2442 session: *mut dv_session_t,
2443 endpt: *mut dv_endpoint_t,
2444 model_file_path: *const ::std::os::raw::c_char,
2445 model_handle: *mut *mut dv_model_t,
2446 options: *mut dv_model_load_options_t,
2447 ) -> dv_status_code_t {
2448 (self
2449 .dv_model_load_from_file_with_options
2450 .as_ref()
2451 .expect("Expected function, got error."))(
2452 session,
2453 endpt,
2454 model_file_path,
2455 model_handle,
2456 options,
2457 )
2458 }
2459
2460 #[doc = " Creates a model object and load model contents from blob and transfer it to\n endpoint Model object contains the model handle and model parameters.\n `dv_model_get_loaded_endpoint_list` returns the list of endpoints (individual\n device dv_endpoint_t handles) on which the model was successfully loaded.\n\n If model load fails on all individual devices representing `endpt`, the API\n call will error out.\n\n Returns DV_SUCCESS on success, else error\n \\param[in] session : session handle\n \\param[in] endpt : endpoint handle\n \\param[in] model_blob : dv_blob_t of the model\n \\param[in] options : model load options\n \\param[out] model_handle : model handle returned by server\n \\since r6.0"]
2461 pub unsafe fn dv_model_load_from_blob_with_options(
2462 &self,
2463 session: *mut dv_session_t,
2464 endpt: *mut dv_endpoint_t,
2465 blob: *mut dv_blob_t,
2466 model_handle: *mut *mut dv_model_t,
2467 options: *mut dv_model_load_options_t,
2468 ) -> dv_status_code_t {
2469 (self
2470 .dv_model_load_from_blob_with_options
2471 .as_ref()
2472 .expect("Expected function, got error."))(
2473 session, endpt, blob, model_handle, options
2474 )
2475 }
2476
2477 #[doc = " api gives current version details of\nmodel, driver, proxy, firmware version to client\n\n Returns DV_SUCCESS on success, else error\n \\param[in] session : session handle\n \\param[out] product_version : product versions\n \\param[out] product_count : number of product version sent"]
2478 pub unsafe fn dv_exchange_current_version_details(
2479 &self,
2480 session: *mut dv_session_t,
2481 product_version: *mut *mut dv_product_version_t,
2482 product_count: *mut u8,
2483 ) -> dv_status_code_t {
2484 (self
2485 .dv_exchange_current_version_details
2486 .as_ref()
2487 .expect("Expected function, got error."))(
2488 session, product_version, product_count
2489 )
2490 }
2491
2492 #[doc = " api gives all supported version details of\nmodel, driver, proxy, firmware version to client\n\n Returns DV_SUCCESS on success, else error\n \\param[in] product_version : list of versions"]
2493 pub unsafe fn dv_retrieve_version_details(
2494 &self,
2495 session: *mut dv_session_t,
2496 product_version: *mut *mut dv_product_version_t,
2497 product_count: *mut u8,
2498 ) -> dv_status_code_t {
2499 (self
2500 .dv_retrieve_version_details
2501 .as_ref()
2502 .expect("Expected function, got error."))(
2503 session, product_version, product_count
2504 )
2505 }
2506
2507 #[doc = " api gives current running version of client library\n\n Returns DV_SUCCESS on success, else error\n \\param[in] client_lib_version : fill struct with client library version"]
2508 pub unsafe fn dv_get_client_lib_version(
2509 &self,
2510 client_lib_version: *mut dv_version_t,
2511 ) -> dv_status_code_t {
2512 (self
2513 .dv_get_client_lib_version
2514 .as_ref()
2515 .expect("Expected function, got error."))(client_lib_version)
2516 }
2517
2518 #[doc = " api deletes memory created by dv_exchange_current_version_details or dv_retrieve_version_details apis\n\n Returns DV_SUCCESS on success, else error\n \\param[in] product_version : list of versions"]
2519 pub unsafe fn dv_free_version_details(
2520 &self,
2521 product_version: *mut dv_product_version_t,
2522 ) -> dv_status_code_t {
2523 (self
2524 .dv_free_version_details
2525 .as_ref()
2526 .expect("Expected function, got error."))(product_version)
2527 }
2528}