lci_binding_pre.hpp

Go to the documentation of this file.

 
// Copyright (c) 2025 The LCI Project Authors
// SPDX-License-Identifier: NCSA
 
// clang-format off
// This file is generated by generate_binding.py
#ifndef LCI_BINDING_PRE_HPP_
#define LCI_BINDING_PRE_HPP_
 
namespace lci {
class net_context_t;
struct net_context_attr_t;
class device_t;
struct device_attr_t;
class mr_t;
struct mr_attr_t;
class endpoint_t;
struct endpoint_attr_t;
class runtime_t;
struct runtime_attr_t;
class packet_pool_t;
struct packet_pool_attr_t;
class matching_engine_t;
struct matching_engine_attr_t;
class comp_t;
struct comp_attr_t;
 
enum class attr_ibv_odp_strategy_t {
  none,
  explicit_odp,
  implicit_odp,
};
 
enum class attr_ibv_prefetch_strategy_t {
  none,
  prefetch,
  prefetch_write,
  prefetch_no_fault,
};
 
enum class attr_ibv_td_strategy_t {
  none,
  all_qp,
  per_qp,
};
 
enum class attr_matching_engine_type_t {
  queue,
  map,
};
 
enum class attr_comp_type_t {
  sync,
  counter,
  cq,
  handler,
  graph,
  custom,
};
 
enum class attr_cq_type_t {
  array_atomic,
  lcrq,
};
 
struct global_attr_t {
  attr_backend_t backend;
  std::string ofi_provider_name;
  size_t max_msg_size;
  size_t max_inject_size;
  int ibv_gid_idx;
  bool ibv_force_gid_auto_select;
  attr_ibv_odp_strategy_t ibv_odp_strategy;
  attr_ibv_prefetch_strategy_t ibv_prefetch_strategy;
  size_t net_max_sends;
  size_t net_max_recvs;
  size_t net_max_cqes;
  uint64_t ofi_lock_mode;
  bool alloc_default_endpoint;
  attr_ibv_td_strategy_t ibv_td_strategy;
  size_t packet_return_threshold;
  int imm_nbits_tag;
  int imm_nbits_rcomp;
  bool alloc_default_device;
  bool alloc_default_packet_pool;
  bool alloc_default_matching_engine;
  size_t packet_size;
  size_t npackets;
  attr_matching_engine_type_t matching_engine_type;
  int sync_threshold;
  bool zero_copy_am;
  attr_cq_type_t cq_type;
  int cq_default_length;
};
 
struct net_context_attr_t {
  attr_backend_t backend;
  std::string ofi_provider_name;
  size_t max_msg_size;
  size_t max_inject_size;
  int ibv_gid_idx;
  bool ibv_force_gid_auto_select;
  attr_ibv_odp_strategy_t ibv_odp_strategy;
  attr_ibv_prefetch_strategy_t ibv_prefetch_strategy;
  bool support_putimm;
  void* user_context;
};
 
class net_context_impl_t;

 
class net_context_t {
 public:
  using attr_t = net_context_attr_t;
  // attribute getter
  attr_backend_t get_attr_backend() const;
  std::string get_attr_ofi_provider_name() const;
  size_t get_attr_max_msg_size() const;
  size_t get_attr_max_inject_size() const;
  int get_attr_ibv_gid_idx() const;
  bool get_attr_ibv_force_gid_auto_select() const;
  attr_ibv_odp_strategy_t get_attr_ibv_odp_strategy() const;
  attr_ibv_prefetch_strategy_t get_attr_ibv_prefetch_strategy() const;
  bool get_attr_support_putimm() const;
  void* get_attr_user_context() const;
  attr_t get_attr() const;
  net_context_impl_t* p_impl = nullptr;
 
  net_context_t() = default;
  net_context_t(void* p) : p_impl(static_cast<net_context_impl_t*>(p)) {}
  inline bool is_empty() const { return p_impl == nullptr; }
  inline net_context_impl_t *get_impl() const { if (!p_impl) throw std::runtime_error("net_context p_impl is nullptr!"); return p_impl; }
  inline void set_impl(net_context_impl_t* p) { p_impl = p; }
  bool operator==(const net_context_t& other) const { return p_impl == other.p_impl; }
};
 
struct device_attr_t {
  size_t net_max_sends;
  size_t net_max_recvs;
  size_t net_max_cqes;
  uint64_t ofi_lock_mode;
  bool alloc_default_endpoint;
  int uid;
  attr_ibv_td_strategy_t ibv_td_strategy;
  void* user_context;
};
 
class device_impl_t;

 
class device_t {
 public:
  using attr_t = device_attr_t;
  // attribute getter
  size_t get_attr_net_max_sends() const;
  size_t get_attr_net_max_recvs() const;
  size_t get_attr_net_max_cqes() const;
  uint64_t get_attr_ofi_lock_mode() const;
  bool get_attr_alloc_default_endpoint() const;
  int get_attr_uid() const;
  attr_ibv_td_strategy_t get_attr_ibv_td_strategy() const;
  void* get_attr_user_context() const;
  attr_t get_attr() const;
  device_impl_t* p_impl = nullptr;
 
  device_t() = default;
  device_t(void* p) : p_impl(static_cast<device_impl_t*>(p)) {}
  inline bool is_empty() const { return p_impl == nullptr; }
  inline device_impl_t *get_impl() const { if (!p_impl) throw std::runtime_error("device p_impl is nullptr!"); return p_impl; }
  inline void set_impl(device_impl_t* p) { p_impl = p; }
  bool operator==(const device_t& other) const { return p_impl == other.p_impl; }
};
 
struct mr_attr_t {
  void* user_context;
};
 
class mr_impl_t;

 
class mr_t {
 public:
  using attr_t = mr_attr_t;
  // attribute getter
  void* get_attr_user_context() const;
  attr_t get_attr() const;
  mr_impl_t* p_impl = nullptr;
 
  mr_t() = default;
  mr_t(void* p) : p_impl(static_cast<mr_impl_t*>(p)) {}
  inline bool is_empty() const;
  inline mr_impl_t *get_impl() const { if (!p_impl) throw std::runtime_error("mr p_impl is nullptr!"); return p_impl; }
  inline void set_impl(mr_impl_t* p) { p_impl = p; }
  bool operator==(const mr_t& other) const { return p_impl == other.p_impl; }
};
 
struct endpoint_attr_t {
  int uid;
  void* user_context;
};
 
class endpoint_impl_t;

 
class endpoint_t {
 public:
  using attr_t = endpoint_attr_t;
  // attribute getter
  int get_attr_uid() const;
  void* get_attr_user_context() const;
  attr_t get_attr() const;
  endpoint_impl_t* p_impl = nullptr;
 
  endpoint_t() = default;
  endpoint_t(void* p) : p_impl(static_cast<endpoint_impl_t*>(p)) {}
  inline bool is_empty() const { return p_impl == nullptr; }
  inline endpoint_impl_t *get_impl() const { if (!p_impl) throw std::runtime_error("endpoint p_impl is nullptr!"); return p_impl; }
  inline void set_impl(endpoint_impl_t* p) { p_impl = p; }
  bool operator==(const endpoint_t& other) const { return p_impl == other.p_impl; }
};
 
struct runtime_attr_t {
  size_t packet_return_threshold;
  int imm_nbits_tag;
  int imm_nbits_rcomp;
  uint64_t max_imm_tag;
  uint64_t max_imm_rcomp;
  uint64_t max_tag;
  uint64_t max_rcomp;
  bool alloc_default_device;
  bool alloc_default_packet_pool;
  bool alloc_default_matching_engine;
  void* user_context;
};
 
class runtime_impl_t;

 
class runtime_t {
 public:
  using attr_t = runtime_attr_t;
  // attribute getter
  size_t get_attr_packet_return_threshold() const;
  int get_attr_imm_nbits_tag() const;
  int get_attr_imm_nbits_rcomp() const;
  uint64_t get_attr_max_imm_tag() const;
  uint64_t get_attr_max_imm_rcomp() const;
  uint64_t get_attr_max_tag() const;
  uint64_t get_attr_max_rcomp() const;
  bool get_attr_alloc_default_device() const;
  bool get_attr_alloc_default_packet_pool() const;
  bool get_attr_alloc_default_matching_engine() const;
  void* get_attr_user_context() const;
  attr_t get_attr() const;
  runtime_impl_t* p_impl = nullptr;
 
  runtime_t() = default;
  runtime_t(void* p) : p_impl(static_cast<runtime_impl_t*>(p)) {}
  inline bool is_empty() const { return p_impl == nullptr; }
  inline runtime_impl_t *get_impl() const { if (!p_impl) throw std::runtime_error("runtime p_impl is nullptr!"); return p_impl; }
  inline void set_impl(runtime_impl_t* p) { p_impl = p; }
  bool operator==(const runtime_t& other) const { return p_impl == other.p_impl; }
};
 
struct packet_pool_attr_t {
  size_t packet_size;
  size_t npackets;
  void* user_context;
};
 
class packet_pool_impl_t;

 
class packet_pool_t {
 public:
  using attr_t = packet_pool_attr_t;
  // attribute getter
  size_t get_attr_packet_size() const;
  size_t get_attr_npackets() const;
  void* get_attr_user_context() const;
  attr_t get_attr() const;
  packet_pool_impl_t* p_impl = nullptr;
 
  packet_pool_t() = default;
  packet_pool_t(void* p) : p_impl(static_cast<packet_pool_impl_t*>(p)) {}
  inline bool is_empty() const { return p_impl == nullptr; }
  inline packet_pool_impl_t *get_impl() const { if (!p_impl) throw std::runtime_error("packet_pool p_impl is nullptr!"); return p_impl; }
  inline void set_impl(packet_pool_impl_t* p) { p_impl = p; }
  bool operator==(const packet_pool_t& other) const { return p_impl == other.p_impl; }
};
 
struct matching_engine_attr_t {
  attr_matching_engine_type_t matching_engine_type;
  void* user_context;
};
 
class matching_engine_impl_t;

 
class matching_engine_t {
 public:
  using attr_t = matching_engine_attr_t;
  // attribute getter
  attr_matching_engine_type_t get_attr_matching_engine_type() const;
  void* get_attr_user_context() const;
  attr_t get_attr() const;
  matching_engine_impl_t* p_impl = nullptr;
 
  matching_engine_t() = default;
  matching_engine_t(void* p) : p_impl(static_cast<matching_engine_impl_t*>(p)) {}
  inline bool is_empty() const { return p_impl == nullptr; }
  inline matching_engine_impl_t *get_impl() const { if (!p_impl) throw std::runtime_error("matching_engine p_impl is nullptr!"); return p_impl; }
  inline void set_impl(matching_engine_impl_t* p) { p_impl = p; }
  bool operator==(const matching_engine_t& other) const { return p_impl == other.p_impl; }
};
 
struct comp_attr_t {
  attr_comp_type_t comp_type;
  int sync_threshold;
  bool zero_copy_am;
  attr_cq_type_t cq_type;
  int cq_default_length;
  void* user_context;
};
 
class comp_impl_t;

 
class comp_t {
 public:
  using attr_t = comp_attr_t;
  // attribute getter
  attr_comp_type_t get_attr_comp_type() const;
  int get_attr_sync_threshold() const;
  bool get_attr_zero_copy_am() const;
  attr_cq_type_t get_attr_cq_type() const;
  int get_attr_cq_default_length() const;
  void* get_attr_user_context() const;
  attr_t get_attr() const;
  comp_impl_t* p_impl = nullptr;
 
  comp_t() = default;
  comp_t(void* p) : p_impl(static_cast<comp_impl_t*>(p)) {}
  inline bool is_empty() const;
  inline comp_impl_t *get_impl() const { if (!p_impl) throw std::runtime_error("comp p_impl is nullptr!"); return p_impl; }
  inline void set_impl(comp_impl_t* p) { p_impl = p; }
  bool operator==(const comp_t& other) const { return p_impl == other.p_impl; }
};
 
 
} // namespace lci
 
#endif // LCI_BINDING_PRE_HPP_