#[repr(C)]
#[derive(Default)]
pub struct __IncompleteArrayField<T>(PhantomData<T>);
impl <T> __IncompleteArrayField<T> {
pub fn new() -> Self {
__IncompleteArrayField(PhantomData)
}
pub unsafe fn as_ptr(&self) -> *const T { transmute(self) }
pub unsafe fn as_mut_ptr(&mut self) -> *mut T {
transmute(self)
}
pub unsafe fn as_slice(&self, len: usize) -> &[T] {
from_raw_parts(self.as_ptr(), len)
}
pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
from_raw_parts_mut(self.as_mut_ptr(), len)
}
}
impl <T> Debug for __IncompleteArrayField<T> {
fn fmt(&self, fmt: &mut Formatter) -> Result {
fmt.write_str("__IncompleteArrayField")
}
}
impl <T> Clone for __IncompleteArrayField<T> {
fn clone(&self) -> Self { Self::new() }
}
impl <T> Copy for __IncompleteArrayField<T> { }
pub const FI_MAJOR_VERSION: c_uint = 1;
pub const FI_MINOR_VERSION: c_uint = 5;
pub const FI_PROV_SPECIFIC: c_uint = 2147483648;
pub const FI_MSG: c_uint = 2;
pub const FI_RMA: c_uint = 4;
pub const FI_TAGGED: c_uint = 8;
pub const FI_ATOMIC: c_uint = 16;
pub const FI_ATOMICS: c_uint = 16;
pub const FI_MULTICAST: c_uint = 32;
pub const FI_READ: c_uint = 256;
pub const FI_WRITE: c_uint = 512;
pub const FI_RECV: c_uint = 1024;
pub const FI_SEND: c_uint = 2048;
pub const FI_TRANSMIT: c_uint = 2048;
pub const FI_REMOTE_READ: c_uint = 4096;
pub const FI_REMOTE_WRITE: c_uint = 8192;
pub const FI_MULTI_RECV: c_uint = 65536;
pub const FI_REMOTE_CQ_DATA: c_uint = 131072;
pub const FI_MORE: c_uint = 262144;
pub const FI_PEEK: c_uint = 524288;
pub const FI_TRIGGER: c_uint = 1048576;
pub const FI_FENCE: c_uint = 2097152;
pub const FI_COMPLETION: c_uint = 16777216;
pub const FI_EVENT: c_uint = 16777216;
pub const FI_INJECT: c_uint = 33554432;
pub const FI_INJECT_COMPLETE: c_uint = 67108864;
pub const FI_TRANSMIT_COMPLETE: c_uint = 134217728;
pub const FI_DELIVERY_COMPLETE: c_uint = 268435456;
pub const FI_AFFINITY: c_uint = 536870912;
pub const FI_SOURCE_ERR: c_ulonglong = 1125899906842624;
pub const FI_LOCAL_COMM: c_ulonglong = 2251799813685248;
pub const FI_REMOTE_COMM: c_ulonglong = 4503599627370496;
pub const FI_SHARED_AV: c_ulonglong = 9007199254740992;
pub const FI_PROV_ATTR_ONLY: c_ulonglong = 18014398509481984;
pub const FI_NUMERICHOST: c_ulonglong = 36028797018963968;
pub const FI_RMA_EVENT: c_ulonglong = 72057594037927936;
pub const FI_SOURCE: c_ulonglong = 144115188075855872;
pub const FI_NAMED_RX_CTX: c_ulonglong = 288230376151711744;
pub const FI_DIRECTED_RECV: c_ulonglong = 576460752303423488;
pub const FI_SHARED_CONTEXT: c_int = -1;
pub const FI_MR_LOCAL: c_uint = 4;
pub const FI_MR_RAW: c_uint = 8;
pub const FI_MR_VIRT_ADDR: c_uint = 16;
pub const FI_MR_ALLOCATED: c_uint = 32;
pub const FI_MR_PROV_KEY: c_uint = 64;
pub const FI_MR_MMU_NOTIFY: c_uint = 128;
pub const FI_MR_RMA_EVENT: c_uint = 256;
pub const FI_MR_ENDPOINT: c_uint = 512;
pub const FI_ORDER_NONE: c_uint = 0;
pub const FI_ORDER_RAR: c_uint = 1;
pub const FI_ORDER_RAW: c_uint = 2;
pub const FI_ORDER_RAS: c_uint = 4;
pub const FI_ORDER_WAR: c_uint = 8;
pub const FI_ORDER_WAW: c_uint = 16;
pub const FI_ORDER_WAS: c_uint = 32;
pub const FI_ORDER_SAR: c_uint = 64;
pub const FI_ORDER_SAW: c_uint = 128;
pub const FI_ORDER_SAS: c_uint = 256;
pub const FI_ORDER_STRICT: c_uint = 511;
pub const FI_ORDER_DATA: c_uint = 65536;
pub const FI_CONTEXT: c_ulonglong = 576460752303423488;
pub const FI_MSG_PREFIX: c_ulonglong = 288230376151711744;
pub const FI_ASYNC_IOV: c_ulonglong = 144115188075855872;
pub const FI_RX_CQ_DATA: c_ulonglong = 72057594037927936;
pub const FI_LOCAL_MR: c_ulonglong = 36028797018963968;
pub const FI_NOTIFY_FLAGS_ONLY: c_ulonglong = 18014398509481984;
pub const FI_RESTRICTED_COMP: c_ulonglong = 9007199254740992;
pub const FI_CONTEXT2: c_ulonglong = 4503599627370496;
pub const FI_SELECTIVE_COMPLETION: c_ulonglong = 576460752303423488;
pub const FI_SUCCESS: c_uint = 0;
pub const FI_ENOENT: c_uint = 2;
pub const FI_EIO: c_uint = 5;
pub const FI_E2BIG: c_uint = 7;
pub const FI_EBADF: c_uint = 9;
pub const FI_EAGAIN: c_uint = 11;
pub const FI_ENOMEM: c_uint = 12;
pub const FI_EACCES: c_uint = 13;
pub const FI_EBUSY: c_uint = 16;
pub const FI_ENODEV: c_uint = 19;
pub const FI_EINVAL: c_uint = 22;
pub const FI_EMFILE: c_uint = 24;
pub const FI_ENOSPC: c_uint = 28;
pub const FI_ENOSYS: c_uint = 38;
pub const FI_ENOMSG: c_uint = 42;
pub const FI_ENODATA: c_uint = 61;
pub const FI_EMSGSIZE: c_uint = 90;
pub const FI_ENOPROTOOPT: c_uint = 92;
pub const FI_EOPNOTSUPP: c_uint = 95;
pub const FI_EADDRINUSE: c_uint = 98;
pub const FI_EADDRNOTAVAIL: c_uint = 99;
pub const FI_ENETDOWN: c_uint = 100;
pub const FI_ENETUNREACH: c_uint = 101;
pub const FI_ECONNABORTED: c_uint = 103;
pub const FI_ECONNRESET: c_uint = 104;
pub const FI_EISCONN: c_uint = 106;
pub const FI_ENOTCONN: c_uint = 107;
pub const FI_ESHUTDOWN: c_uint = 108;
pub const FI_ETIMEDOUT: c_uint = 110;
pub const FI_ECONNREFUSED: c_uint = 111;
pub const FI_EHOSTUNREACH: c_uint = 113;
pub const FI_EALREADY: c_uint = 114;
pub const FI_EINPROGRESS: c_uint = 115;
pub const FI_EREMOTEIO: c_uint = 121;
pub const FI_ECANCELED: c_uint = 125;
pub const FI_EKEYREJECTED: c_uint = 129;
pub const FI_ERRNO_OFFSET: c_uint = 256;
pub const FI_SYMMETRIC: c_ulonglong = 576460752303423488;
pub const FI_SYNC_ERR: c_ulonglong = 288230376151711744;
pub const FI_REG_MR: c_ulonglong = 576460752303423488;
pub const FI_FETCH_ATOMIC: c_ulonglong = 288230376151711744;
pub const FI_COMPARE_ATOMIC: c_ulonglong = 576460752303423488;
pub const FI_CLAIM: c_ulonglong = 576460752303423488;
pub const FI_DISCARD: c_ulonglong = 288230376151711744;
pub const FI_PATH_MAX: _bindgen_ty_1 = 256;
pub const FI_NAME_MAX: _bindgen_ty_1 = 64;
pub const FI_VERSION_MAX: _bindgen_ty_1 = 64;
pub type _bindgen_ty_1 = c_uint;
extern "C" {
pub fn fi_version() -> u32;
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fid {
pub fclass: usize,
pub context: *mut c_void,
pub ops: *mut fi_ops,
}
impl Clone for fid {
fn clone(&self) -> Self { *self }
}
impl Default for fid {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fid_fabric {
pub fid: fid,
pub ops: *mut fi_ops_fabric,
pub api_version: u32,
}
impl Clone for fid_fabric {
fn clone(&self) -> Self { *self }
}
impl Default for fid_fabric {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fid_domain {
pub fid: fid,
pub ops: *mut fi_ops_domain,
pub mr: *mut fi_ops_mr,
}
impl Clone for fid_domain {
fn clone(&self) -> Self { *self }
}
impl Default for fid_domain {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fid_av {
pub fid: fid,
pub ops: *mut fi_ops_av,
}
impl Clone for fid_av {
fn clone(&self) -> Self { *self }
}
impl Default for fid_av {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fid_wait {
pub fid: fid,
pub ops: *mut fi_ops_wait,
}
impl Clone for fid_wait {
fn clone(&self) -> Self { *self }
}
impl Default for fid_wait {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fid_poll {
pub fid: fid,
pub ops: *mut fi_ops_poll,
}
impl Clone for fid_poll {
fn clone(&self) -> Self { *self }
}
impl Default for fid_poll {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fid_eq {
pub fid: fid,
pub ops: *mut fi_ops_eq,
}
impl Clone for fid_eq {
fn clone(&self) -> Self { *self }
}
impl Default for fid_eq {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fid_cq {
pub fid: fid,
pub ops: *mut fi_ops_cq,
}
impl Clone for fid_cq {
fn clone(&self) -> Self { *self }
}
impl Default for fid_cq {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fid_cntr {
pub fid: fid,
pub ops: *mut fi_ops_cntr,
}
impl Clone for fid_cntr {
fn clone(&self) -> Self { *self }
}
impl Default for fid_cntr {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fid_ep {
pub fid: fid,
pub ops: *mut fi_ops_ep,
pub cm: *mut fi_ops_cm,
pub msg: *mut fi_ops_msg,
pub rma: *mut fi_ops_rma,
pub tagged: *mut fi_ops_tagged,
pub atomic: *mut fi_ops_atomic,
}
impl Clone for fid_ep {
fn clone(&self) -> Self { *self }
}
impl Default for fid_ep {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fid_pep {
pub fid: fid,
pub ops: *mut fi_ops_ep,
pub cm: *mut fi_ops_cm,
}
impl Clone for fid_pep {
fn clone(&self) -> Self { *self }
}
impl Default for fid_pep {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fid_stx {
pub fid: fid,
pub ops: *mut fi_ops_ep,
}
impl Clone for fid_stx {
fn clone(&self) -> Self { *self }
}
impl Default for fid_stx {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fid_mr {
pub fid: fid,
pub mem_desc: *mut c_void,
pub key: u64,
}
impl Clone for fid_mr {
fn clone(&self) -> Self { *self }
}
impl Default for fid_mr {
fn default() -> Self { unsafe { zeroed() } }
}
pub type fid_t = *mut fid;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_ioc {
pub addr: *mut c_void,
pub count: usize,
}
impl Clone for fi_ioc {
fn clone(&self) -> Self { *self }
}
impl Default for fi_ioc {
fn default() -> Self { unsafe { zeroed() } }
}
pub const FI_FORMAT_UNSPEC: _bindgen_ty_2 = 0;
pub const FI_SOCKADDR: _bindgen_ty_2 = 1;
pub const FI_SOCKADDR_IN: _bindgen_ty_2 = 2;
pub const FI_SOCKADDR_IN6: _bindgen_ty_2 = 3;
pub const FI_SOCKADDR_IB: _bindgen_ty_2 = 4;
pub const FI_ADDR_PSMX: _bindgen_ty_2 = 5;
pub const FI_ADDR_GNI: _bindgen_ty_2 = 6;
pub const FI_ADDR_BGQ: _bindgen_ty_2 = 7;
pub const FI_ADDR_MLX: _bindgen_ty_2 = 8;
pub const FI_ADDR_STR: _bindgen_ty_2 = 9;
pub type _bindgen_ty_2 = c_uint;
pub type fi_addr_t = u64;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fi_av_type { FI_AV_UNSPEC = 0, FI_AV_MAP = 1, FI_AV_TABLE = 2, }
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fi_mr_mode { FI_MR_UNSPEC = 0, FI_MR_BASIC = 1, FI_MR_SCALABLE = 2, }
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fi_progress {
FI_PROGRESS_UNSPEC = 0,
FI_PROGRESS_AUTO = 1,
FI_PROGRESS_MANUAL = 2,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fi_threading {
FI_THREAD_UNSPEC = 0,
FI_THREAD_SAFE = 1,
FI_THREAD_FID = 2,
FI_THREAD_DOMAIN = 3,
FI_THREAD_COMPLETION = 4,
FI_THREAD_ENDPOINT = 5,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fi_resource_mgmt {
FI_RM_UNSPEC = 0,
FI_RM_DISABLED = 1,
FI_RM_ENABLED = 2,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fi_ep_type {
FI_EP_UNSPEC = 0,
FI_EP_MSG = 1,
FI_EP_DGRAM = 2,
FI_EP_RDM = 3,
FI_EP_SOCK_STREAM = 4,
FI_EP_SOCK_DGRAM = 5,
}
pub const FI_PROTO_UNSPEC: _bindgen_ty_3 = 0;
pub const FI_PROTO_RDMA_CM_IB_RC: _bindgen_ty_3 = 1;
pub const FI_PROTO_IWARP: _bindgen_ty_3 = 2;
pub const FI_PROTO_IB_UD: _bindgen_ty_3 = 3;
pub const FI_PROTO_PSMX: _bindgen_ty_3 = 4;
pub const FI_PROTO_UDP: _bindgen_ty_3 = 5;
pub const FI_PROTO_SOCK_TCP: _bindgen_ty_3 = 6;
pub const FI_PROTO_MXM: _bindgen_ty_3 = 7;
pub const FI_PROTO_IWARP_RDM: _bindgen_ty_3 = 8;
pub const FI_PROTO_IB_RDM: _bindgen_ty_3 = 9;
pub const FI_PROTO_GNI: _bindgen_ty_3 = 10;
pub const FI_PROTO_RXM: _bindgen_ty_3 = 11;
pub const FI_PROTO_RXD: _bindgen_ty_3 = 12;
pub const FI_PROTO_MLX: _bindgen_ty_3 = 13;
pub const FI_PROTO_NETWORKDIRECT: _bindgen_ty_3 = 14;
pub type _bindgen_ty_3 = c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct fi_tx_attr {
pub caps: u64,
pub mode: u64,
pub op_flags: u64,
pub msg_order: u64,
pub comp_order: u64,
pub inject_size: usize,
pub size: usize,
pub iov_limit: usize,
pub rma_iov_limit: usize,
}
impl Clone for fi_tx_attr {
fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct fi_rx_attr {
pub caps: u64,
pub mode: u64,
pub op_flags: u64,
pub msg_order: u64,
pub comp_order: u64,
pub total_buffered_recv: usize,
pub size: usize,
pub iov_limit: usize,
}
impl Clone for fi_rx_attr {
fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_ep_attr {
pub type_: fi_ep_type,
pub protocol: u32,
pub protocol_version: u32,
pub max_msg_size: usize,
pub msg_prefix_size: usize,
pub max_order_raw_size: usize,
pub max_order_war_size: usize,
pub max_order_waw_size: usize,
pub mem_tag_format: u64,
pub tx_ctx_cnt: usize,
pub rx_ctx_cnt: usize,
pub auth_key_size: usize,
pub auth_key: *mut u8,
}
impl Clone for fi_ep_attr {
fn clone(&self) -> Self { *self }
}
impl Default for fi_ep_attr {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_domain_attr {
pub domain: *mut fid_domain,
pub name: *mut c_char,
pub threading: fi_threading,
pub control_progress: fi_progress,
pub data_progress: fi_progress,
pub resource_mgmt: fi_resource_mgmt,
pub av_type: fi_av_type,
pub mr_mode: c_int,
pub mr_key_size: usize,
pub cq_data_size: usize,
pub cq_cnt: usize,
pub ep_cnt: usize,
pub tx_ctx_cnt: usize,
pub rx_ctx_cnt: usize,
pub max_ep_tx_ctx: usize,
pub max_ep_rx_ctx: usize,
pub max_ep_stx_ctx: usize,
pub max_ep_srx_ctx: usize,
pub cntr_cnt: usize,
pub mr_iov_limit: usize,
pub caps: u64,
pub mode: u64,
pub auth_key: *mut u8,
pub auth_key_size: usize,
pub max_err_data: usize,
}
impl Clone for fi_domain_attr {
fn clone(&self) -> Self { *self }
}
impl Default for fi_domain_attr {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_fabric_attr {
pub fabric: *mut fid_fabric,
pub name: *mut c_char,
pub prov_name: *mut c_char,
pub prov_version: u32,
pub api_version: u32,
}
impl Clone for fi_fabric_attr {
fn clone(&self) -> Self { *self }
}
impl Default for fi_fabric_attr {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_info {
pub next: *mut fi_info,
pub caps: u64,
pub mode: u64,
pub addr_format: u32,
pub src_addrlen: usize,
pub dest_addrlen: usize,
pub src_addr: *mut c_void,
pub dest_addr: *mut c_void,
pub handle: fid_t,
pub tx_attr: *mut fi_tx_attr,
pub rx_attr: *mut fi_rx_attr,
pub ep_attr: *mut fi_ep_attr,
pub domain_attr: *mut fi_domain_attr,
pub fabric_attr: *mut fi_fabric_attr,
}
impl Clone for fi_info {
fn clone(&self) -> Self { *self }
}
impl Default for fi_info {
fn default() -> Self { unsafe { zeroed() } }
}
pub const FI_CLASS_UNSPEC: _bindgen_ty_4 = 0;
pub const FI_CLASS_FABRIC: _bindgen_ty_4 = 1;
pub const FI_CLASS_DOMAIN: _bindgen_ty_4 = 2;
pub const FI_CLASS_EP: _bindgen_ty_4 = 3;
pub const FI_CLASS_SEP: _bindgen_ty_4 = 4;
pub const FI_CLASS_RX_CTX: _bindgen_ty_4 = 5;
pub const FI_CLASS_SRX_CTX: _bindgen_ty_4 = 6;
pub const FI_CLASS_TX_CTX: _bindgen_ty_4 = 7;
pub const FI_CLASS_STX_CTX: _bindgen_ty_4 = 8;
pub const FI_CLASS_PEP: _bindgen_ty_4 = 9;
pub const FI_CLASS_INTERFACE: _bindgen_ty_4 = 10;
pub const FI_CLASS_AV: _bindgen_ty_4 = 11;
pub const FI_CLASS_MR: _bindgen_ty_4 = 12;
pub const FI_CLASS_EQ: _bindgen_ty_4 = 13;
pub const FI_CLASS_CQ: _bindgen_ty_4 = 14;
pub const FI_CLASS_CNTR: _bindgen_ty_4 = 15;
pub const FI_CLASS_WAIT: _bindgen_ty_4 = 16;
pub const FI_CLASS_POLL: _bindgen_ty_4 = 17;
pub const FI_CLASS_CONNREQ: _bindgen_ty_4 = 18;
pub const FI_CLASS_MC: _bindgen_ty_4 = 19;
pub type _bindgen_ty_4 = c_uint;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_eq_attr {
pub size: usize,
pub flags: u64,
pub wait_obj: fi_wait_obj,
pub signaling_vector: c_int,
pub wait_set: *mut fid_wait,
}
impl Clone for fi_eq_attr {
fn clone(&self) -> Self { *self }
}
impl Default for fi_eq_attr {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_wait_attr {
pub wait_obj: fi_wait_obj,
pub flags: u64,
}
impl Clone for fi_wait_attr {
fn clone(&self) -> Self { *self }
}
impl Default for fi_wait_attr {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_ops {
pub size: usize,
pub close: Option<unsafe extern "C" fn(fid: *mut fid)
-> c_int>,
pub bind: Option<unsafe extern "C" fn(fid: *mut fid,
bfid: *mut fid,
flags: u64)
-> c_int>,
pub control: Option<unsafe extern "C" fn(fid: *mut fid,
command:
c_int,
arg:
*mut c_void)
-> c_int>,
pub ops_open: Option<unsafe extern "C" fn(fid: *mut fid,
name:
*const c_char,
flags: u64,
ops:
*mut *mut c_void,
context:
*mut c_void)
-> c_int>,
}
impl Clone for fi_ops {
fn clone(&self) -> Self { *self }
}
impl Default for fi_ops {
fn default() -> Self { unsafe { zeroed() } }
}
extern "C" {
pub fn fi_getinfo(version: u32, node: *const c_char,
service: *const c_char, flags: u64,
hints: *mut fi_info, info: *mut *mut fi_info)
-> c_int;
}
extern "C" {
pub fn fi_freeinfo(info: *mut fi_info);
}
extern "C" {
pub fn fi_dupinfo(info: *const fi_info) -> *mut fi_info;
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_ops_fabric {
pub size: usize,
pub domain: Option<unsafe extern "C" fn(fabric:
*mut fid_fabric,
info:
*mut fi_info,
dom:
*mut *mut fid_domain,
context:
*mut c_void)
-> c_int>,
pub passive_ep: Option<unsafe extern "C" fn(fabric:
*mut fid_fabric,
info:
*mut fi_info,
pep:
*mut *mut fid_pep,
context:
*mut c_void)
-> c_int>,
pub eq_open: Option<unsafe extern "C" fn(fabric:
*mut fid_fabric,
attr:
*mut fi_eq_attr,
eq:
*mut *mut fid_eq,
context:
*mut c_void)
-> c_int>,
pub wait_open: Option<unsafe extern "C" fn(fabric:
*mut fid_fabric,
attr:
*mut fi_wait_attr,
waitset:
*mut *mut fid_wait)
-> c_int>,
pub trywait: Option<unsafe extern "C" fn(fabric:
*mut fid_fabric,
fids:
*mut *mut fid,
count:
c_int)
-> c_int>,
}
impl Clone for fi_ops_fabric {
fn clone(&self) -> Self { *self }
}
impl Default for fi_ops_fabric {
fn default() -> Self { unsafe { zeroed() } }
}
extern "C" {
pub fn fi_fabric(attr: *mut fi_fabric_attr, fabric: *mut *mut fid_fabric,
context: *mut c_void) -> c_int;
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_alias {
pub fid: *mut *mut fid,
pub flags: u64,
}
impl Clone for fi_alias {
fn clone(&self) -> Self { *self }
}
impl Default for fi_alias {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_mr_raw_attr {
pub flags: u64,
pub base_addr: *mut u64,
pub raw_key: *mut u8,
pub key_size: *mut usize,
}
impl Clone for fi_mr_raw_attr {
fn clone(&self) -> Self { *self }
}
impl Default for fi_mr_raw_attr {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_mr_map_raw {
pub flags: u64,
pub base_addr: u64,
pub raw_key: *mut u8,
pub key_size: usize,
pub key: *mut u64,
}
impl Clone for fi_mr_map_raw {
fn clone(&self) -> Self { *self }
}
impl Default for fi_mr_map_raw {
fn default() -> Self { unsafe { zeroed() } }
}
pub const FI_GETFIDFLAG: _bindgen_ty_5 = 0;
pub const FI_SETFIDFLAG: _bindgen_ty_5 = 1;
pub const FI_GETOPSFLAG: _bindgen_ty_5 = 2;
pub const FI_SETOPSFLAG: _bindgen_ty_5 = 3;
pub const FI_ALIAS: _bindgen_ty_5 = 4;
pub const FI_GETWAIT: _bindgen_ty_5 = 5;
pub const FI_ENABLE: _bindgen_ty_5 = 6;
pub const FI_BACKLOG: _bindgen_ty_5 = 7;
pub const FI_GET_RAW_MR: _bindgen_ty_5 = 8;
pub const FI_MAP_RAW_MR: _bindgen_ty_5 = 9;
pub const FI_UNMAP_KEY: _bindgen_ty_5 = 10;
pub const FI_QUEUE_WORK: _bindgen_ty_5 = 11;
pub const FI_CANCEL_WORK: _bindgen_ty_5 = 12;
pub const FI_FLUSH_WORK: _bindgen_ty_5 = 13;
pub const FI_REFRESH: _bindgen_ty_5 = 14;
pub type _bindgen_ty_5 = c_uint;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fi_type {
FI_TYPE_INFO = 0,
FI_TYPE_EP_TYPE = 1,
FI_TYPE_CAPS = 2,
FI_TYPE_OP_FLAGS = 3,
FI_TYPE_ADDR_FORMAT = 4,
FI_TYPE_TX_ATTR = 5,
FI_TYPE_RX_ATTR = 6,
FI_TYPE_EP_ATTR = 7,
FI_TYPE_DOMAIN_ATTR = 8,
FI_TYPE_FABRIC_ATTR = 9,
FI_TYPE_THREADING = 10,
FI_TYPE_PROGRESS = 11,
FI_TYPE_PROTOCOL = 12,
FI_TYPE_MSG_ORDER = 13,
FI_TYPE_MODE = 14,
FI_TYPE_AV_TYPE = 15,
FI_TYPE_ATOMIC_TYPE = 16,
FI_TYPE_ATOMIC_OP = 17,
FI_TYPE_VERSION = 18,
FI_TYPE_EQ_EVENT = 19,
FI_TYPE_CQ_EVENT_FLAGS = 20,
FI_TYPE_MR_MODE = 21,
}
extern "C" {
pub fn fi_tostr(data: *const c_void, datatype: fi_type)
-> *mut c_char;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fi_param_type {
FI_PARAM_STRING = 0,
FI_PARAM_INT = 1,
FI_PARAM_BOOL = 2,
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_param {
pub name: *const c_char,
pub type_: fi_param_type,
pub help_string: *const c_char,
pub value: *const c_char,
}
impl Clone for fi_param {
fn clone(&self) -> Self { *self }
}
impl Default for fi_param {
fn default() -> Self { unsafe { zeroed() } }
}
extern "C" {
pub fn fi_getparams(params: *mut *mut fi_param, count: *mut c_int)
-> c_int;
}
extern "C" {
pub fn fi_freeparams(params: *mut fi_param);
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_context {
pub internal: [*mut c_void; 4usize],
}
impl Clone for fi_context {
fn clone(&self) -> Self { *self }
}
impl Default for fi_context {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_context2 {
pub internal: [*mut c_void; 8usize],
}
impl Clone for fi_context2 {
fn clone(&self) -> Self { *self }
}
impl Default for fi_context2 {
fn default() -> Self { unsafe { zeroed() } }
}
pub const FI_EOTHER: _bindgen_ty_6 = 256;
pub const FI_ETOOSMALL: _bindgen_ty_6 = 257;
pub const FI_EOPBADSTATE: _bindgen_ty_6 = 258;
pub const FI_EAVAIL: _bindgen_ty_6 = 259;
pub const FI_EBADFLAGS: _bindgen_ty_6 = 260;
pub const FI_ENOEQ: _bindgen_ty_6 = 261;
pub const FI_EDOMAIN: _bindgen_ty_6 = 262;
pub const FI_ENOCQ: _bindgen_ty_6 = 263;
pub const FI_ECRC: _bindgen_ty_6 = 264;
pub const FI_ETRUNC: _bindgen_ty_6 = 265;
pub const FI_ENOKEY: _bindgen_ty_6 = 266;
pub const FI_ENOAV: _bindgen_ty_6 = 267;
pub const FI_EOVERRUN: _bindgen_ty_6 = 268;
pub const FI_ERRNO_MAX: _bindgen_ty_6 = 269;
pub type _bindgen_ty_6 = c_uint;
extern "C" {
pub fn fi_strerror(errnum: c_int) -> *const c_char;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fi_wait_obj {
FI_WAIT_NONE = 0,
FI_WAIT_UNSPEC = 1,
FI_WAIT_SET = 2,
FI_WAIT_FD = 3,
FI_WAIT_MUTEX_COND = 4,
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_ops_wait {
pub size: usize,
pub wait: Option<unsafe extern "C" fn(waitset:
*mut fid_wait,
timeout:
c_int)
-> c_int>,
}
impl Clone for fi_ops_wait {
fn clone(&self) -> Self { *self }
}
impl Default for fi_ops_wait {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_mutex_cond {
pub mutex: *mut pthread_mutex_t,
pub cond: *mut pthread_cond_t,
}
impl Clone for fi_mutex_cond {
fn clone(&self) -> Self { *self }
}
impl Default for fi_mutex_cond {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct fi_poll_attr {
pub flags: u64,
}
impl Clone for fi_poll_attr {
fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_ops_poll {
pub size: usize,
pub poll: Option<unsafe extern "C" fn(pollset:
*mut fid_poll,
context:
*mut *mut c_void,
count:
c_int)
-> c_int>,
pub poll_add: Option<unsafe extern "C" fn(pollset:
*mut fid_poll,
event_fid:
*mut fid,
flags: u64)
-> c_int>,
pub poll_del: Option<unsafe extern "C" fn(pollset:
*mut fid_poll,
event_fid:
*mut fid,
flags: u64)
-> c_int>,
}
impl Clone for fi_ops_poll {
fn clone(&self) -> Self { *self }
}
impl Default for fi_ops_poll {
fn default() -> Self { unsafe { zeroed() } }
}
pub const FI_NOTIFY: _bindgen_ty_7 = 0;
pub const FI_CONNREQ: _bindgen_ty_7 = 1;
pub const FI_CONNECTED: _bindgen_ty_7 = 2;
pub const FI_SHUTDOWN: _bindgen_ty_7 = 3;
pub const FI_MR_COMPLETE: _bindgen_ty_7 = 4;
pub const FI_AV_COMPLETE: _bindgen_ty_7 = 5;
pub const FI_JOIN_COMPLETE: _bindgen_ty_7 = 6;
pub type _bindgen_ty_7 = c_uint;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_eq_entry {
pub fid: fid_t,
pub context: *mut c_void,
pub data: u64,
}
impl Clone for fi_eq_entry {
fn clone(&self) -> Self { *self }
}
impl Default for fi_eq_entry {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_eq_err_entry {
pub fid: fid_t,
pub context: *mut c_void,
pub data: u64,
pub err: c_int,
pub prov_errno: c_int,
pub err_data: *mut c_void,
pub err_data_size: usize,
}
impl Clone for fi_eq_err_entry {
fn clone(&self) -> Self { *self }
}
impl Default for fi_eq_err_entry {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_eq_cm_entry {
pub fid: fid_t,
pub info: *mut fi_info,
pub data: __IncompleteArrayField<u8>,
}
impl Clone for fi_eq_cm_entry {
fn clone(&self) -> Self { *self }
}
impl Default for fi_eq_cm_entry {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_ops_eq {
pub size: usize,
pub read: Option<unsafe extern "C" fn(eq: *mut fid_eq,
event: *mut u32,
buf:
*mut c_void,
len: usize,
flags: u64)
-> isize>,
pub readerr: Option<unsafe extern "C" fn(eq: *mut fid_eq,
buf:
*mut fi_eq_err_entry,
flags: u64)
-> isize>,
pub write: Option<unsafe extern "C" fn(eq: *mut fid_eq,
event: u32,
buf:
*const c_void,
len: usize,
flags: u64)
-> isize>,
pub sread: Option<unsafe extern "C" fn(eq: *mut fid_eq,
event: *mut u32,
buf:
*mut c_void,
len: usize,
timeout:
c_int,
flags: u64)
-> isize>,
pub strerror: Option<unsafe extern "C" fn(eq: *mut fid_eq,
prov_errno:
c_int,
err_data:
*const c_void,
buf:
*mut c_char,
len: usize)
-> *const c_char>,
}
impl Clone for fi_ops_eq {
fn clone(&self) -> Self { *self }
}
impl Default for fi_ops_eq {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fi_cq_format {
FI_CQ_FORMAT_UNSPEC = 0,
FI_CQ_FORMAT_CONTEXT = 1,
FI_CQ_FORMAT_MSG = 2,
FI_CQ_FORMAT_DATA = 3,
FI_CQ_FORMAT_TAGGED = 4,
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_cq_entry {
pub op_context: *mut c_void,
}
impl Clone for fi_cq_entry {
fn clone(&self) -> Self { *self }
}
impl Default for fi_cq_entry {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_cq_msg_entry {
pub op_context: *mut c_void,
pub flags: u64,
pub len: usize,
}
impl Clone for fi_cq_msg_entry {
fn clone(&self) -> Self { *self }
}
impl Default for fi_cq_msg_entry {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_cq_data_entry {
pub op_context: *mut c_void,
pub flags: u64,
pub len: usize,
pub buf: *mut c_void,
pub data: u64,
}
impl Clone for fi_cq_data_entry {
fn clone(&self) -> Self { *self }
}
impl Default for fi_cq_data_entry {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_cq_tagged_entry {
pub op_context: *mut c_void,
pub flags: u64,
pub len: usize,
pub buf: *mut c_void,
pub data: u64,
pub tag: u64,
}
impl Clone for fi_cq_tagged_entry {
fn clone(&self) -> Self { *self }
}
impl Default for fi_cq_tagged_entry {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_cq_err_entry {
pub op_context: *mut c_void,
pub flags: u64,
pub len: usize,
pub buf: *mut c_void,
pub data: u64,
pub tag: u64,
pub olen: usize,
pub err: c_int,
pub prov_errno: c_int,
pub err_data: *mut c_void,
pub err_data_size: usize,
}
impl Clone for fi_cq_err_entry {
fn clone(&self) -> Self { *self }
}
impl Default for fi_cq_err_entry {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fi_cq_wait_cond { FI_CQ_COND_NONE = 0, FI_CQ_COND_THRESHOLD = 1, }
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_cq_attr {
pub size: usize,
pub flags: u64,
pub format: fi_cq_format,
pub wait_obj: fi_wait_obj,
pub signaling_vector: c_int,
pub wait_cond: fi_cq_wait_cond,
pub wait_set: *mut fid_wait,
}
impl Clone for fi_cq_attr {
fn clone(&self) -> Self { *self }
}
impl Default for fi_cq_attr {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_ops_cq {
pub size: usize,
pub read: Option<unsafe extern "C" fn(cq: *mut fid_cq,
buf:
*mut c_void,
count: usize)
-> isize>,
pub readfrom: Option<unsafe extern "C" fn(cq: *mut fid_cq,
buf:
*mut c_void,
count: usize,
src_addr:
*mut fi_addr_t)
-> isize>,
pub readerr: Option<unsafe extern "C" fn(cq: *mut fid_cq,
buf:
*mut fi_cq_err_entry,
flags: u64)
-> isize>,
pub sread: Option<unsafe extern "C" fn(cq: *mut fid_cq,
buf:
*mut c_void,
count: usize,
cond:
*const c_void,
timeout:
c_int)
-> isize>,
pub sreadfrom: Option<unsafe extern "C" fn(cq:
*mut fid_cq,
buf:
*mut c_void,
count: usize,
src_addr:
*mut fi_addr_t,
cond:
*const c_void,
timeout:
c_int)
-> isize>,
pub signal: Option<unsafe extern "C" fn(cq: *mut fid_cq)
-> c_int>,
pub strerror: Option<unsafe extern "C" fn(cq: *mut fid_cq,
prov_errno:
c_int,
err_data:
*const c_void,
buf:
*mut c_char,
len: usize)
-> *const c_char>,
}
impl Clone for fi_ops_cq {
fn clone(&self) -> Self { *self }
}
impl Default for fi_ops_cq {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fi_cntr_events { FI_CNTR_EVENTS_COMP = 0, }
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_cntr_attr {
pub events: fi_cntr_events,
pub wait_obj: fi_wait_obj,
pub wait_set: *mut fid_wait,
pub flags: u64,
}
impl Clone for fi_cntr_attr {
fn clone(&self) -> Self { *self }
}
impl Default for fi_cntr_attr {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_ops_cntr {
pub size: usize,
pub read: Option<unsafe extern "C" fn(cntr: *mut fid_cntr)
-> u64>,
pub readerr: Option<unsafe extern "C" fn(cntr:
*mut fid_cntr)
-> u64>,
pub add: Option<unsafe extern "C" fn(cntr: *mut fid_cntr,
value: u64)
-> c_int>,
pub set: Option<unsafe extern "C" fn(cntr: *mut fid_cntr,
value: u64)
-> c_int>,
pub wait: Option<unsafe extern "C" fn(cntr: *mut fid_cntr,
threshold: u64,
timeout:
c_int)
-> c_int>,
pub adderr: Option<unsafe extern "C" fn(cntr:
*mut fid_cntr,
value: u64)
-> c_int>,
pub seterr: Option<unsafe extern "C" fn(cntr:
*mut fid_cntr,
value: u64)
-> c_int>,
}
impl Clone for fi_ops_cntr {
fn clone(&self) -> Self { *self }
}
impl Default for fi_ops_cntr {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_av_attr {
pub type_: fi_av_type,
pub rx_ctx_bits: c_int,
pub count: usize,
pub ep_per_node: usize,
pub name: *const c_char,
pub map_addr: *mut c_void,
pub flags: u64,
}
impl Clone for fi_av_attr {
fn clone(&self) -> Self { *self }
}
impl Default for fi_av_attr {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_ops_av {
pub size: usize,
pub insert: Option<unsafe extern "C" fn(av: *mut fid_av,
addr:
*const c_void,
count: usize,
fi_addr:
*mut fi_addr_t,
flags: u64,
context:
*mut c_void)
-> c_int>,
pub insertsvc: Option<unsafe extern "C" fn(av:
*mut fid_av,
node:
*const c_char,
service:
*const c_char,
fi_addr:
*mut fi_addr_t,
flags: u64,
context:
*mut c_void)
-> c_int>,
pub insertsym: Option<unsafe extern "C" fn(av:
*mut fid_av,
node:
*const c_char,
nodecnt: usize,
service:
*const c_char,
svccnt: usize,
fi_addr:
*mut fi_addr_t,
flags: u64,
context:
*mut c_void)
-> c_int>,
pub remove: Option<unsafe extern "C" fn(av: *mut fid_av,
fi_addr:
*mut fi_addr_t,
count: usize,
flags: u64)
-> c_int>,
pub lookup: Option<unsafe extern "C" fn(av: *mut fid_av,
fi_addr:
fi_addr_t,
addr:
*mut c_void,
addrlen:
*mut usize)
-> c_int>,
pub straddr: Option<unsafe extern "C" fn(av: *mut fid_av,
addr:
*const c_void,
buf:
*mut c_char,
len: *mut usize)
-> *const c_char>,
}
impl Clone for fi_ops_av {
fn clone(&self) -> Self { *self }
}
impl Default for fi_ops_av {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_mr_attr {
pub mr_iov: *const iovec,
pub iov_count: usize,
pub access: u64,
pub offset: u64,
pub requested_key: u64,
pub context: *mut c_void,
pub auth_key_size: usize,
pub auth_key: *mut u8,
}
impl Clone for fi_mr_attr {
fn clone(&self) -> Self { *self }
}
impl Default for fi_mr_attr {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_mr_modify {
pub flags: u64,
pub attr: fi_mr_attr,
}
impl Clone for fi_mr_modify {
fn clone(&self) -> Self { *self }
}
impl Default for fi_mr_modify {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fi_datatype {
FI_INT8 = 0,
FI_UINT8 = 1,
FI_INT16 = 2,
FI_UINT16 = 3,
FI_INT32 = 4,
FI_UINT32 = 5,
FI_INT64 = 6,
FI_UINT64 = 7,
FI_FLOAT = 8,
FI_DOUBLE = 9,
FI_FLOAT_COMPLEX = 10,
FI_DOUBLE_COMPLEX = 11,
FI_LONG_DOUBLE = 12,
FI_LONG_DOUBLE_COMPLEX = 13,
FI_DATATYPE_LAST = 14,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fi_op {
FI_MIN = 0,
FI_MAX = 1,
FI_SUM = 2,
FI_PROD = 3,
FI_LOR = 4,
FI_LAND = 5,
FI_BOR = 6,
FI_BAND = 7,
FI_LXOR = 8,
FI_BXOR = 9,
FI_ATOMIC_READ = 10,
FI_ATOMIC_WRITE = 11,
FI_CSWAP = 12,
FI_CSWAP_NE = 13,
FI_CSWAP_LE = 14,
FI_CSWAP_LT = 15,
FI_CSWAP_GE = 16,
FI_CSWAP_GT = 17,
FI_MSWAP = 18,
FI_ATOMIC_OP_LAST = 19,
}
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct fi_atomic_attr {
pub count: usize,
pub size: usize,
}
impl Clone for fi_atomic_attr {
fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_ops_domain {
pub size: usize,
pub av_open: Option<unsafe extern "C" fn(domain:
*mut fid_domain,
attr:
*mut fi_av_attr,
av:
*mut *mut fid_av,
context:
*mut c_void)
-> c_int>,
pub cq_open: Option<unsafe extern "C" fn(domain:
*mut fid_domain,
attr:
*mut fi_cq_attr,
cq:
*mut *mut fid_cq,
context:
*mut c_void)
-> c_int>,
pub endpoint: Option<unsafe extern "C" fn(domain:
*mut fid_domain,
info:
*mut fi_info,
ep:
*mut *mut fid_ep,
context:
*mut c_void)
-> c_int>,
pub scalable_ep: Option<unsafe extern "C" fn(domain:
*mut fid_domain,
info:
*mut fi_info,
sep:
*mut *mut fid_ep,
context:
*mut c_void)
-> c_int>,
pub cntr_open: Option<unsafe extern "C" fn(domain:
*mut fid_domain,
attr:
*mut fi_cntr_attr,
cntr:
*mut *mut fid_cntr,
context:
*mut c_void)
-> c_int>,
pub poll_open: Option<unsafe extern "C" fn(domain:
*mut fid_domain,
attr:
*mut fi_poll_attr,
pollset:
*mut *mut fid_poll)
-> c_int>,
pub stx_ctx: Option<unsafe extern "C" fn(domain:
*mut fid_domain,
attr:
*mut fi_tx_attr,
stx:
*mut *mut fid_stx,
context:
*mut c_void)
-> c_int>,
pub srx_ctx: Option<unsafe extern "C" fn(domain:
*mut fid_domain,
attr:
*mut fi_rx_attr,
rx_ep:
*mut *mut fid_ep,
context:
*mut c_void)
-> c_int>,
pub query_atomic: Option<unsafe extern "C" fn(domain:
*mut fid_domain,
datatype:
fi_datatype,
op: fi_op,
attr:
*mut fi_atomic_attr,
flags: u64)
-> c_int>,
}
impl Clone for fi_ops_domain {
fn clone(&self) -> Self { *self }
}
impl Default for fi_ops_domain {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_ops_mr {
pub size: usize,
pub reg: Option<unsafe extern "C" fn(fid: *mut fid,
buf:
*const c_void,
len: usize,
access: u64,
offset: u64,
requested_key: u64,
flags: u64,
mr: *mut *mut fid_mr,
context:
*mut c_void)
-> c_int>,
pub regv: Option<unsafe extern "C" fn(fid: *mut fid,
iov: *const iovec,
count: usize,
access: u64,
offset: u64,
requested_key: u64,
flags: u64,
mr:
*mut *mut fid_mr,
context:
*mut c_void)
-> c_int>,
pub regattr: Option<unsafe extern "C" fn(fid: *mut fid,
attr:
*const fi_mr_attr,
flags: u64,
mr:
*mut *mut fid_mr)
-> c_int>,
}
impl Clone for fi_ops_mr {
fn clone(&self) -> Self { *self }
}
impl Default for fi_ops_mr {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_msg {
pub msg_iov: *const iovec,
pub desc: *mut *mut c_void,
pub iov_count: usize,
pub addr: fi_addr_t,
pub context: *mut c_void,
pub data: u64,
}
impl Clone for fi_msg {
fn clone(&self) -> Self { *self }
}
impl Default for fi_msg {
fn default() -> Self { unsafe { zeroed() } }
}
pub const FI_OPT_ENDPOINT: _bindgen_ty_8 = 0;
pub type _bindgen_ty_8 = c_uint;
pub const FI_OPT_MIN_MULTI_RECV: _bindgen_ty_9 = 0;
pub const FI_OPT_CM_DATA_SIZE: _bindgen_ty_9 = 1;
pub type _bindgen_ty_9 = c_uint;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_ops_ep {
pub size: usize,
pub cancel: Option<unsafe extern "C" fn(fid: fid_t,
context:
*mut c_void)
-> isize>,
pub getopt: Option<unsafe extern "C" fn(fid: fid_t,
level:
c_int,
optname:
c_int,
optval:
*mut c_void,
optlen:
*mut usize)
-> c_int>,
pub setopt: Option<unsafe extern "C" fn(fid: fid_t,
level:
c_int,
optname:
c_int,
optval:
*const c_void,
optlen: usize)
-> c_int>,
pub tx_ctx: Option<unsafe extern "C" fn(sep: *mut fid_ep,
index:
c_int,
attr:
*mut fi_tx_attr,
tx_ep:
*mut *mut fid_ep,
context:
*mut c_void)
-> c_int>,
pub rx_ctx: Option<unsafe extern "C" fn(sep: *mut fid_ep,
index:
c_int,
attr:
*mut fi_rx_attr,
rx_ep:
*mut *mut fid_ep,
context:
*mut c_void)
-> c_int>,
pub rx_size_left: Option<unsafe extern "C" fn(ep:
*mut fid_ep)
-> isize>,
pub tx_size_left: Option<unsafe extern "C" fn(ep:
*mut fid_ep)
-> isize>,
}
impl Clone for fi_ops_ep {
fn clone(&self) -> Self { *self }
}
impl Default for fi_ops_ep {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_ops_msg {
pub size: usize,
pub recv: Option<unsafe extern "C" fn(ep: *mut fid_ep,
buf:
*mut c_void,
len: usize,
desc:
*mut c_void,
src_addr: fi_addr_t,
context:
*mut c_void)
-> isize>,
pub recvv: Option<unsafe extern "C" fn(ep: *mut fid_ep,
iov: *const iovec,
desc:
*mut *mut c_void,
count: usize,
src_addr:
fi_addr_t,
context:
*mut c_void)
-> isize>,
pub recvmsg: Option<unsafe extern "C" fn(ep: *mut fid_ep,
msg:
*const fi_msg,
flags: u64)
-> isize>,
pub send: Option<unsafe extern "C" fn(ep: *mut fid_ep,
buf:
*const c_void,
len: usize,
desc:
*mut c_void,
dest_addr:
fi_addr_t,
context:
*mut c_void)
-> isize>,
pub sendv: Option<unsafe extern "C" fn(ep: *mut fid_ep,
iov: *const iovec,
desc:
*mut *mut c_void,
count: usize,
dest_addr:
fi_addr_t,
context:
*mut c_void)
-> isize>,
pub sendmsg: Option<unsafe extern "C" fn(ep: *mut fid_ep,
msg:
*const fi_msg,
flags: u64)
-> isize>,
pub inject: Option<unsafe extern "C" fn(ep: *mut fid_ep,
buf:
*const c_void,
len: usize,
dest_addr:
fi_addr_t)
-> isize>,
pub senddata: Option<unsafe extern "C" fn(ep: *mut fid_ep,
buf:
*const c_void,
len: usize,
desc:
*mut c_void,
data: u64,
dest_addr:
fi_addr_t,
context:
*mut c_void)
-> isize>,
pub injectdata: Option<unsafe extern "C" fn(ep:
*mut fid_ep,
buf:
*const c_void,
len: usize,
data: u64,
dest_addr:
fi_addr_t)
-> isize>,
}
impl Clone for fi_ops_msg {
fn clone(&self) -> Self { *self }
}
impl Default for fi_ops_msg {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_ops_cm {
pub size: usize,
pub setname: Option<unsafe extern "C" fn(fid: fid_t,
addr:
*mut c_void,
addrlen: usize)
-> c_int>,
pub getname: Option<unsafe extern "C" fn(fid: fid_t,
addr:
*mut c_void,
addrlen:
*mut usize)
-> c_int>,
pub getpeer: Option<unsafe extern "C" fn(ep: *mut fid_ep,
addr:
*mut c_void,
addrlen:
*mut usize)
-> c_int>,
pub connect: Option<unsafe extern "C" fn(ep: *mut fid_ep,
addr:
*const c_void,
param:
*const c_void,
paramlen: usize)
-> c_int>,
pub listen: Option<unsafe extern "C" fn(pep: *mut fid_pep)
-> c_int>,
pub accept: Option<unsafe extern "C" fn(ep: *mut fid_ep,
param:
*const c_void,
paramlen: usize)
-> c_int>,
pub reject: Option<unsafe extern "C" fn(pep: *mut fid_pep,
handle: fid_t,
param:
*const c_void,
paramlen: usize)
-> c_int>,
pub shutdown: Option<unsafe extern "C" fn(ep: *mut fid_ep,
flags: u64)
-> c_int>,
pub join: Option<unsafe extern "C" fn(ep: *mut fid_ep,
addr:
*const c_void,
flags: u64,
mc:
*mut *mut fid_mc,
context:
*mut c_void)
-> c_int>,
}
impl Clone for fi_ops_cm {
fn clone(&self) -> Self { *self }
}
impl Default for fi_ops_cm {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_ops_rma {
pub size: usize,
pub read: Option<unsafe extern "C" fn(ep: *mut fid_ep,
buf:
*mut c_void,
len: usize,
desc:
*mut c_void,
src_addr: fi_addr_t,
addr: u64, key: u64,
context:
*mut c_void)
-> isize>,
pub readv: Option<unsafe extern "C" fn(ep: *mut fid_ep,
iov: *const iovec,
desc:
*mut *mut c_void,
count: usize,
src_addr:
fi_addr_t,
addr: u64,
key: u64,
context:
*mut c_void)
-> isize>,
pub readmsg: Option<unsafe extern "C" fn(ep: *mut fid_ep,
msg:
*const fi_msg_rma,
flags: u64)
-> isize>,
pub write: Option<unsafe extern "C" fn(ep: *mut fid_ep,
buf:
*const c_void,
len: usize,
desc:
*mut c_void,
dest_addr:
fi_addr_t,
addr: u64,
key: u64,
context:
*mut c_void)
-> isize>,
pub writev: Option<unsafe extern "C" fn(ep: *mut fid_ep,
iov: *const iovec,
desc:
*mut *mut c_void,
count: usize,
dest_addr:
fi_addr_t,
addr: u64,
key: u64,
context:
*mut c_void)
-> isize>,
pub writemsg: Option<unsafe extern "C" fn(ep: *mut fid_ep,
msg:
*const fi_msg_rma,
flags: u64)
-> isize>,
pub inject: Option<unsafe extern "C" fn(ep: *mut fid_ep,
buf:
*const c_void,
len: usize,
dest_addr:
fi_addr_t,
addr: u64,
key: u64)
-> isize>,
pub writedata: Option<unsafe extern "C" fn(ep:
*mut fid_ep,
buf:
*const c_void,
len: usize,
desc:
*mut c_void,
data: u64,
dest_addr:
fi_addr_t,
addr: u64,
key: u64,
context:
*mut c_void)
-> isize>,
pub injectdata: Option<unsafe extern "C" fn(ep:
*mut fid_ep,
buf:
*const c_void,
len: usize,
data: u64,
dest_addr:
fi_addr_t,
addr: u64,
key: u64)
-> isize>,
}
impl Clone for fi_ops_rma {
fn clone(&self) -> Self { *self }
}
impl Default for fi_ops_rma {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_ops_tagged {
pub size: usize,
pub recv: Option<unsafe extern "C" fn(ep: *mut fid_ep,
buf:
*mut c_void,
len: usize,
desc:
*mut c_void,
src_addr: fi_addr_t,
tag: u64,
ignore: u64,
context:
*mut c_void)
-> isize>,
pub recvv: Option<unsafe extern "C" fn(ep: *mut fid_ep,
iov: *const iovec,
desc:
*mut *mut c_void,
count: usize,
src_addr:
fi_addr_t,
tag: u64,
ignore: u64,
context:
*mut c_void)
-> isize>,
pub recvmsg: Option<unsafe extern "C" fn(ep: *mut fid_ep,
msg:
*const fi_msg_tagged,
flags: u64)
-> isize>,
pub send: Option<unsafe extern "C" fn(ep: *mut fid_ep,
buf:
*const c_void,
len: usize,
desc:
*mut c_void,
dest_addr:
fi_addr_t,
tag: u64,
context:
*mut c_void)
-> isize>,
pub sendv: Option<unsafe extern "C" fn(ep: *mut fid_ep,
iov: *const iovec,
desc:
*mut *mut c_void,
count: usize,
dest_addr:
fi_addr_t,
tag: u64,
context:
*mut c_void)
-> isize>,
pub sendmsg: Option<unsafe extern "C" fn(ep: *mut fid_ep,
msg:
*const fi_msg_tagged,
flags: u64)
-> isize>,
pub inject: Option<unsafe extern "C" fn(ep: *mut fid_ep,
buf:
*const c_void,
len: usize,
dest_addr:
fi_addr_t,
tag: u64)
-> isize>,
pub senddata: Option<unsafe extern "C" fn(ep: *mut fid_ep,
buf:
*const c_void,
len: usize,
desc:
*mut c_void,
data: u64,
dest_addr:
fi_addr_t,
tag: u64,
context:
*mut c_void)
-> isize>,
pub injectdata: Option<unsafe extern "C" fn(ep:
*mut fid_ep,
buf:
*const c_void,
len: usize,
data: u64,
dest_addr:
fi_addr_t,
tag: u64)
-> isize>,
}
impl Clone for fi_ops_tagged {
fn clone(&self) -> Self { *self }
}
impl Default for fi_ops_tagged {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct fi_ops_atomic {
pub size: usize,
pub write: Option<unsafe extern "C" fn(ep: *mut fid_ep,
buf:
*const c_void,
count: usize,
desc:
*mut c_void,
dest_addr:
fi_addr_t,
addr: u64,
key: u64,
datatype:
fi_datatype,
op: fi_op,
context:
*mut c_void)
-> isize>,
pub writev: Option<unsafe extern "C" fn(ep: *mut fid_ep,
iov:
*const fi_ioc,
desc:
*mut *mut c_void,
count: usize,
dest_addr:
fi_addr_t,
addr: u64,
key: u64,
datatype:
fi_datatype,
op: fi_op,
context:
*mut c_void)
-> isize>,
pub writemsg: Option<unsafe extern "C" fn(ep: *mut fid_ep,
msg:
*const fi_msg_atomic,
flags: u64)
-> isize>,
pub inject: Option<unsafe extern "C" fn(ep: *mut fid_ep,
buf:
*const c_void,
count: usize,
dest_addr:
fi_addr_t,
addr: u64,
key: u64,
datatype:
fi_datatype,
op: fi_op)
-> isize>,
pub readwrite: Option<unsafe extern "C" fn(ep:
*mut fid_ep,
buf:
*const c_void,
count: usize,
desc:
*mut c_void,
result:
*mut c_void,
result_desc:
*mut c_void,
dest_addr:
fi_addr_t,
addr: u64,
key: u64,
datatype:
fi_datatype,
op: fi_op,
context:
*mut c_void)
-> isize>,
pub readwritev: Option<unsafe extern "C" fn(ep:
*mut fid_ep,
iov:
*const fi_ioc,
desc:
*mut *mut c_void,
count: usize,
resultv:
*mut fi_ioc,
result_desc:
*mut *mut c_void,
result_count:
usize,
dest_addr:
fi_addr_t,
addr: u64,
key: u64,
datatype:
fi_datatype,
op: fi_op,
context:
*mut c_void)
-> isize>,
pub readwritemsg: Option<unsafe extern "C" fn(ep:
*mut fid_ep,
msg:
*const fi_msg_atomic,
resultv:
*mut fi_ioc,
result_desc:
*mut *mut c_void,
result_count:
usize,
flags: u64)
-> isize>,
pub compwrite: Option<unsafe extern "C" fn(ep:
*mut fid_ep,
buf:
*const c_void,
count: usize,
desc:
*mut c_void,
compare:
*const c_void,
compare_desc:
*mut c_void,
result:
*mut c_void,
result_desc:
*mut c_void,
dest_addr:
fi_addr_t,
addr: u64,
key: u64,
datatype:
fi_datatype,
op: fi_op,
context:
*mut c_void)
-> isize>,
pub compwritev: Option<unsafe extern "C" fn(ep:
*mut fid_ep,
iov:
*const fi_ioc,
desc:
*mut *mut c_void,
count: usize,
comparev:
*const fi_ioc,
compare_desc:
*mut *mut c_void,
compare_count:
usize,
resultv:
*mut fi_ioc,
result_desc:
*mut *mut c_void,
result_count:
usize,
dest_addr:
fi_addr_t,
addr: u64,
key: u64,
datatype:
fi_datatype,
op: fi_op,
context:
*mut c_void)
-> isize>,
pub compwritemsg: Option<unsafe extern "C" fn(ep:
*mut fid_ep,
msg:
*const fi_msg_atomic,
comparev:
*const fi_ioc,
compare_desc:
*mut *mut c_void,
compare_count:
usize,
resultv:
*mut fi_ioc,
result_desc:
*mut *mut c_void,
result_count:
usize,
flags: u64)
-> isize>,
pub writevalid: Option<unsafe extern "C" fn(ep:
*mut fid_ep,
datatype:
fi_datatype,
op: fi_op,
count:
*mut usize)
-> c_int>,
pub readwritevalid: Option<unsafe extern "C" fn(ep:
*mut fid_ep,
datatype:
fi_datatype,
op: fi_op,
count:
*mut usize)
-> c_int>,
pub compwritevalid: Option<unsafe extern "C" fn(ep:
*mut fid_ep,
datatype:
fi_datatype,
op: fi_op,
count:
*mut usize)
-> c_int>,
}
impl Clone for fi_ops_atomic {
fn clone(&self) -> Self { *self }
}
impl Default for fi_ops_atomic {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct fi_rma_iov {
pub addr: u64,
pub len: usize,
pub key: u64,
}
impl Clone for fi_rma_iov {
fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct fi_rma_ioc {
pub addr: u64,
pub count: usize,
pub key: u64,
}
impl Clone for fi_rma_ioc {
fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_msg_rma {
pub msg_iov: *const iovec,
pub desc: *mut *mut c_void,
pub iov_count: usize,
pub addr: fi_addr_t,
pub rma_iov: *const fi_rma_iov,
pub rma_iov_count: usize,
pub context: *mut c_void,
pub data: u64,
}
impl Clone for fi_msg_rma {
fn clone(&self) -> Self { *self }
}
impl Default for fi_msg_rma {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_msg_atomic {
pub msg_iov: *const fi_ioc,
pub desc: *mut *mut c_void,
pub iov_count: usize,
pub addr: fi_addr_t,
pub rma_iov: *const fi_rma_ioc,
pub rma_iov_count: usize,
pub datatype: fi_datatype,
pub op: fi_op,
pub context: *mut c_void,
pub data: u64,
}
impl Clone for fi_msg_atomic {
fn clone(&self) -> Self { *self }
}
impl Default for fi_msg_atomic {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_msg_fetch {
pub msg_iov: *mut fi_ioc,
pub desc: *mut *mut c_void,
pub iov_count: usize,
}
impl Clone for fi_msg_fetch {
fn clone(&self) -> Self { *self }
}
impl Default for fi_msg_fetch {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_msg_compare {
pub msg_iov: *const fi_ioc,
pub desc: *mut *mut c_void,
pub iov_count: usize,
}
impl Clone for fi_msg_compare {
fn clone(&self) -> Self { *self }
}
impl Default for fi_msg_compare {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fid_mc {
pub fid: fid,
pub fi_addr: fi_addr_t,
}
impl Clone for fid_mc {
fn clone(&self) -> Self { *self }
}
impl Default for fid_mc {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_msg_tagged {
pub msg_iov: *const iovec,
pub desc: *mut *mut c_void,
pub iov_count: usize,
pub addr: fi_addr_t,
pub tag: u64,
pub ignore: u64,
pub context: *mut c_void,
pub data: u64,
}
impl Clone for fi_msg_tagged {
fn clone(&self) -> Self { *self }
}
impl Default for fi_msg_tagged {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fi_trigger_event {
FI_TRIGGER_THRESHOLD = 0,
FI_TRIGGER_COMPLETION = 1,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fi_trigger_op {
FI_OP_RECV = 0,
FI_OP_SEND = 1,
FI_OP_TRECV = 2,
FI_OP_TSEND = 3,
FI_OP_READ = 4,
FI_OP_WRITE = 5,
FI_OP_ATOMIC = 6,
FI_OP_FETCH_ATOMIC = 7,
FI_OP_COMPARE_ATOMIC = 8,
FI_OP_CNTR_SET = 9,
FI_OP_CNTR_ADD = 10,
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_trigger_threshold {
pub cntr: *mut fid_cntr,
pub threshold: usize,
}
impl Clone for fi_trigger_threshold {
fn clone(&self) -> Self { *self }
}
impl Default for fi_trigger_threshold {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_trigger_completion {
pub context: *mut fi_context,
}
impl Clone for fi_trigger_completion {
fn clone(&self) -> Self { *self }
}
impl Default for fi_trigger_completion {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_op_msg {
pub ep: *mut fid_ep,
pub msg: fi_msg,
pub flags: u64,
}
impl Clone for fi_op_msg {
fn clone(&self) -> Self { *self }
}
impl Default for fi_op_msg {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_op_tagged {
pub ep: *mut fid_ep,
pub msg: fi_msg_tagged,
pub flags: u64,
}
impl Clone for fi_op_tagged {
fn clone(&self) -> Self { *self }
}
impl Default for fi_op_tagged {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_op_rma {
pub ep: *mut fid_ep,
pub msg: fi_msg_rma,
pub flags: u64,
}
impl Clone for fi_op_rma {
fn clone(&self) -> Self { *self }
}
impl Default for fi_op_rma {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_op_atomic {
pub ep: *mut fid_ep,
pub msg: fi_msg_atomic,
pub flags: u64,
}
impl Clone for fi_op_atomic {
fn clone(&self) -> Self { *self }
}
impl Default for fi_op_atomic {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_op_fetch_atomic {
pub ep: *mut fid_ep,
pub msg: fi_msg_atomic,
pub fetch: fi_msg_fetch,
pub flags: u64,
}
impl Clone for fi_op_fetch_atomic {
fn clone(&self) -> Self { *self }
}
impl Default for fi_op_fetch_atomic {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_op_compare_atomic {
pub ep: *mut fid_ep,
pub msg: fi_msg_atomic,
pub fetch: fi_msg_fetch,
pub compare: fi_msg_compare,
pub flags: u64,
}
impl Clone for fi_op_compare_atomic {
fn clone(&self) -> Self { *self }
}
impl Default for fi_op_compare_atomic {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct fi_op_cntr {
pub cntr: *mut fid_cntr,
pub value: u64,
}
impl Clone for fi_op_cntr {
fn clone(&self) -> Self { *self }
}
impl Default for fi_op_cntr {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct fi_triggered_context {
pub event_type: fi_trigger_event,
pub trigger: fi_triggered_context__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy)]
pub union fi_triggered_context__bindgen_ty_1 {
pub threshold: fi_trigger_threshold,
pub internal: [*mut c_void; 3usize],
}
impl Clone for fi_triggered_context__bindgen_ty_1 {
fn clone(&self) -> Self { *self }
}
impl Default for fi_triggered_context__bindgen_ty_1 {
fn default() -> Self { unsafe { zeroed() } }
}
impl Clone for fi_triggered_context {
fn clone(&self) -> Self { *self }
}
impl Default for fi_triggered_context {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct fi_deferred_work {
pub context: fi_context,
pub event_type: fi_trigger_event,
pub op_type: fi_trigger_op,
pub event: fi_deferred_work__bindgen_ty_1,
pub op: fi_deferred_work__bindgen_ty_2,
}
#[repr(C)]
#[derive(Copy)]
pub union fi_deferred_work__bindgen_ty_1 {
pub threshold: *mut fi_trigger_threshold,
pub completion: *mut fi_trigger_completion,
}
impl Clone for fi_deferred_work__bindgen_ty_1 {
fn clone(&self) -> Self { *self }
}
impl Default for fi_deferred_work__bindgen_ty_1 {
fn default() -> Self { unsafe { zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub union fi_deferred_work__bindgen_ty_2 {
pub msg: *mut fi_op_msg,
pub tagged: *mut fi_op_tagged,
pub rma: *mut fi_op_rma,
pub atomic: *mut fi_op_atomic,
pub fetch_atomic: *mut fi_op_fetch_atomic,
pub compare_atomic: *mut fi_op_compare_atomic,
pub cntr: *mut fi_op_cntr,
}
impl Clone for fi_deferred_work__bindgen_ty_2 {
fn clone(&self) -> Self { *self }
}
impl Default for fi_deferred_work__bindgen_ty_2 {
fn default() -> Self { unsafe { zeroed() } }
}
impl Clone for fi_deferred_work {
fn clone(&self) -> Self { *self }
}
impl Default for fi_deferred_work {
fn default() -> Self { unsafe { zeroed() } }
}
extern "C" {
pub fn rust_fi_allocinfo() -> *mut fi_info;
}
extern "C" {
pub fn rust_fi_close(fid: *mut fid) -> c_int;
}
extern "C" {
pub fn rust_fi_control(fid: *mut fid, command: c_int,
arg: *mut c_void) -> c_int;
}
extern "C" {
pub fn rust_fi_alias(fid: *mut fid, alias_fid: *mut *mut fid, flags: u64)
-> c_int;
}
extern "C" {
pub fn rust_fi_open_ops(fid: *mut fid, name: *const c_char,
flags: u64, ops: *mut *mut c_void,
context: *mut c_void) -> c_int;
}
extern "C" {
pub fn rust_fi_atomic(ep: *mut fid_ep, buf: *const c_void,
count: usize, desc: *mut c_void,
dest_addr: fi_addr_t, addr: u64, key: u64,
datatype: fi_datatype, op: fi_op,
context: *mut c_void) -> isize;
}
extern "C" {
pub fn rust_fi_atomicv(ep: *mut fid_ep, iov: *const fi_ioc,
desc: *mut *mut c_void, count: usize,
dest_addr: fi_addr_t, addr: u64, key: u64,
datatype: fi_datatype, op: fi_op,
context: *mut c_void) -> isize;
}
extern "C" {
pub fn rust_fi_atomicmsg(ep: *mut fid_ep, msg: *const fi_msg_atomic,
flags: u64) -> isize;
}
extern "C" {
pub fn rust_fi_inject_atomic(ep: *mut fid_ep, buf: *const c_void,
count: usize, dest_addr: fi_addr_t,
addr: u64, key: u64, datatype: fi_datatype,
op: fi_op) -> isize;
}
extern "C" {
pub fn rust_fi_fetch_atomic(ep: *mut fid_ep, buf: *const c_void,
count: usize, desc: *mut c_void,
result: *mut c_void,
result_desc: *mut c_void,
dest_addr: fi_addr_t, addr: u64, key: u64,
datatype: fi_datatype, op: fi_op,
context: *mut c_void) -> isize;
}