.rst .pdf

repository open issue

parcelport_libfabric

See Public API for a list of names and headers that are part of the public HPX API.

template<>
struct connection_handler_traits<policies::libfabric::parcelport>

Public Types

template<>
using connection_type = policies::libfabric::sender

template<>
using send_early_parcel = HPX_PARCELPORT_LIBFABRIC_HAVE_BOOTSTRAPPING

template<>
using do_background_work = std::true_type

template<>
using send_immediate_parcels = std::true_type

Public Static Functions

static constexpr const char *type()

static constexpr const char *pool_name()

static constexpr const char *pool_name_postfix()

namespace hpx

namespace parcelset

template<>
struct connection_handler_traits<policies::libfabric::parcelport>

Public Types

template<>
using connection_type = policies::libfabric::sender

template<>
using send_early_parcel = HPX_PARCELPORT_LIBFABRIC_HAVE_BOOTSTRAPPING

template<>
using do_background_work = std::true_type

template<>
using send_immediate_parcels = std::true_type

Public Static Functions

static constexpr const char *type()

static constexpr const char *pool_name()

static constexpr const char *pool_name_postfix()

namespace hpx

namespace parcelset

namespace policies

namespace libfabric

class fabric_error : public runtime_error

Public Functions

fabric_error(int err, const std::string &msg)

fabric_error(int err)

int error_code() const

Public Members

int error_

Public Static Functions

static char *error_string(int err)

namespace hpx

namespace parcelset

namespace policies

namespace libfabric

template<int SIZE>
struct header

Public Types

typedef serialization::serialization_chunk chunktype

Public Functions

template<typename Buffer>
header(Buffer const &buffer, void *tag)

char *chunk_ptr()

detail::chunk_header *chunk_header_ptr()

detail::rma_info *rma_info_ptr()

detail::message_info *message_info_ptr()

detail::message_chunk *message_chunk_ptr()

char *message_ptr()

uint32_t chunk_data_offset() const

uint32_t rma_info_offset() const

uint32_t message_info_offset() const

uint32_t message_offset() const

char *chunk_data()

char *message_data()

bool message_piggy_back()

uint64_t tag()

uint32_t message_size()

std::uint32_t header_length()

void set_message_rdma_info(uint64_t key, const void *addr)

std::uint32_t num_chunks()

std::uint32_t num_zero_copy_chunks()

std::uint32_t num_index_chunks()

Public Static Attributes

constexpr unsigned int header_block_size = sizeof(detail::header_block)

constexpr unsigned int data_size_ = SIZE - header_block_size

const unsigned int chunk_flag = 0x01

const unsigned int message_flag = 0x02

const unsigned int normal_flag = 0x04

const unsigned int zerocopy_flag = 0x08

Private Members

detail::header_block message_header

std::array<char, data_size_> data_

Friends

std::ostream &operator<<(std::ostream &os, header<SIZE> &h)

Defines

HPX_PARCELPORT_LIBFABRIC_ENDPOINT_MSG

namespace hpx

namespace parcelset

namespace policies

namespace libfabric

Typedefs

typedef std::shared_ptr<libfabric_controller> libfabric_controller_ptr

class libfabric_controller

Public Types

typedef hpx::lcos::local::spinlock mutex_type

typedef hpx::parcelset::policies::libfabric::unique_lock<mutex_type> unique_lock

typedef hpx::parcelset::policies::libfabric::scoped_lock<mutex_type> scoped_lock

typedef std::tuple<hpx::promise<fid_ep*>, hpx::shared_future<fid_ep*>> promise_tuple_type

typedef hpx::concurrent::unordered_map<uint32_t, promise_tuple_type>::map_read_lock_type map_read_lock_type

typedef hpx::concurrent::unordered_map<uint32_t, promise_tuple_type>::map_write_lock_type map_write_lock_type

typedef hpx::function<void(fid_ep *endpoint, uint32_t ipaddr)> ConnectionFunction

typedef hpx::function<void(fid_ep *endpoint, uint32_t ipaddr)> DisconnectionFunction

Public Functions

libfabric_controller(std::string const &provider, std::string const &domain, std::string const &endpoint, int = 7910)

void boot_PMI()

~libfabric_controller()

void open_fabric(std::string const &provider, std::string const &domain, std::string const &endpoint_type)

void startup(parcelport *pp)

void _set_check_domain_op_value(int op, const char *value)

void _set_disable_registration()

void create_event_queue()

locality create_local_endpoint()

void new_endpoint_active(struct fi_info *info, struct fid_ep **new_endpoint)

void bind_endpoint_to_queues(struct fid_ep *endpoint)

void bind_passive_endpoint_to_queues(struct fid_pep *endpoint)

void initialize_localities()

fi_addr_t get_fabric_address(const locality &dest_fabric)

const locality &here() const

const bool &immedate_data_supported() const

bool isTerminated()

void setConnectionFunction(ConnectionFunction f)

void setDisconnectionFunction(DisconnectionFunction f)

int poll_endpoints(bool stopped = false)

int poll_for_work_completions()

int poll_send_queue()

int poll_recv_queue()

int poll_event_queue(bool = false)

struct fid_domain *get_domain()

rma_memory_pool<libfabric_region_provider> &get_memory_pool()

void create_completion_queues(struct fi_info *info, int N)

std::pair<bool, hpx::shared_future<struct fid_ep*>> insert_new_future(uint32_t remote_ip)

fi_addr_t insert_address(const locality &remote)

hpx::shared_future<struct fid_ep*> connect_to_server(const locality &remote)

void disconnect_all()

bool active()

Public Members

hpx::concurrent::unordered_map<uint32_t, promise_tuple_type> endpoint_tmp_

std::unordered_map<uint64_t, fi_addr_t> endpoint_av_

locality here_

locality agas_

struct fi_info *fabric_info_

struct fid_fabric *fabric_

struct fid_domain *fabric_domain_

struct fid_pep *ep_passive_

struct fid_ep *ep_active_

struct fid_ep *ep_shared_rx_cxt_

struct fid_eq *event_queue_

struct fid_cq *txcq_

struct fid_cq *rxcq_

struct fid_av *av_

bool immediate_

Private Types

typedef std::chrono::time_point<std::chrono::system_clock> time_type

Private Members

std::string device_

std::string interface_

sockaddr_in local_addr_

ConnectionFunction connection_function_

DisconnectionFunction disconnection_function_

std::unique_ptr<rma_memory_pool<libfabric_region_provider>> memory_pool_

std::vector<receiver> receivers_

mutex_type initialization_mutex_

mutex_type endpoint_map_mutex_

mutex_type polling_mutex_

time_type event_check_time_

uint32_t event_pause_

namespace hpx

namespace parcelset

namespace policies

namespace libfabric

struct libfabric_region_provider

Public Types

typedef struct fid_mr provider_region

typedef struct fid_domain provider_domain

Public Static Functions

template<typename ...Args>
static int register_memory(Args&&... args)

static int unregister_memory(provider_region *region)

static int flags()

namespace hpx

namespace parcelset

namespace policies

namespace libfabric

struct locality

Public Types

typedef std::array<uint32_t, array_length> locality_data

Public Functions

locality(const locality_data &in_data)

locality()

locality(const locality &other)

locality(locality &&other)

locality &operator=(const locality &other)

const uint32_t &ip_address() const

fi_addr_t fi_address() const

void set_fi_address(fi_addr_t fi_addr)

uint16_t port() const

operator bool() const

void save(serialization::output_archive &ar) const

void load(serialization::input_archive &ar)

const void *fabric_data() const

char *fabric_data_writable()

bool valid()

Public Static Functions

static const char *type()

static const uint32_t &ip_address(const locality_data &data)

Public Static Attributes

const uint32_t array_length = HPX_PARCELPORT_LIBFABRIC_LOCALITY_SIZE / 4

const uint32_t array_size = HPX_PARCELPORT_LIBFABRIC_LOCALITY_SIZE

Private Members

locality_data data_

fi_addr_t fi_address_

Friends

bool operator==(locality const &lhs, locality const &rhs)

bool operator<(locality const &lhs, locality const &rhs)

std::ostream &operator<<(std::ostream &os, locality const &loc)

Defines

HPX_PARCELPORT_LIBFABRIC_SUSPEND_WAKE

HPX_PARCELPORT_LIBFABRIC_USE_SMALL_VECTOR

HPX_PARCELPORT_LIBFABRIC_IMM_UNSUPPORTED

template<>
struct plugin_config_data<hpx::parcelset::policies::libfabric::parcelport>

Public Static Functions

static char const *priority()

static void init(int*, char***, util::command_line_handling&)

static void destroy()

static char const *call()

namespace hpx

namespace parcelset

namespace policies

namespace libfabric

struct parcelport : public parcelport_impl<parcelport>

Public Types

typedef hpx::lcos::local::spinlock mutex_type

typedef hpx::parcelset::policies::libfabric::scoped_lock<mutex_type> scoped_lock

typedef hpx::parcelset::policies::libfabric::unique_lock<mutex_type> unique_lock

typedef rma_memory_region<libfabric_region_provider> region_type

typedef memory_region_allocator<libfabric_region_provider> allocator_type

typedef header<HPX_PARCELPORT_LIBFABRIC_MESSAGE_HEADER_SIZE> header_type

typedef rma_memory_pool<libfabric_region_provider> memory_pool_type

typedef pinned_memory_vector<char, header_size, region_type, memory_pool_type> snd_data_type

typedef parcel_buffer<snd_data_type> snd_buffer_type

Public Functions

parcelport(util::runtime_configuration const &ini, threads::policies::callback_notifier const &notifier)

bool do_run()

sender *get_connection(parcelset::locality const &dest, fi_addr_t &fi_addr)

void reclaim_connection(sender *s)

std::shared_ptr<sender> create_connection(parcelset::locality const &dest, error_code &ec)

~parcelport()

bool can_bootstrap() const

Should not be used any more as parcelport_impl handles this?

std::string get_locality_name() const

Return the name of this locality.

parcelset::locality agas_locality(util::runtime_configuration const &ini) const

parcelset::locality create_locality() const

void do_stop()

bool can_send_immediate()

template<typename Handler>
bool async_write(Handler &&handler, sender *sender, fi_addr_t addr, snd_buffer_type &buffer)

bool background_work(std::size_t num_thread, parcelport_background_mode mode)

void io_service_work()

bool background_work_OS_thread()

Public Members

libfabric_controller_ptr libfabric_controller_

uint32_t ip_addr_

bool bootstrap_enabled_

bool parcelport_enabled_

mutex_type stop_mutex

boost::lockfree::stack<sender*, boost::lockfree::capacity<HPX_PARCELPORT_LIBFABRIC_THROTTLE_SENDS>, boost::lockfree::fixed_sized<true>> senders_

std::atomic<bool> stopped_

memory_pool_type *chunk_pool_

performance_counter<unsigned int> completions_handled_

performance_counter<unsigned int> senders_in_use_

Public Static Functions

static void suspended_task_debug(const std::string &match)

Public Static Attributes

constexpr unsigned int header_size = header_type::header_block_size

Private Types

typedef parcelport_impl<parcelport> base_type

namespace traits

template<>
struct plugin_config_data<hpx::parcelset::policies::libfabric::parcelport>

Public Static Functions

static char const *priority()

static void init(int*, char***, util::command_line_handling&)

static void destroy()

static char const *call()

Defines

sched_getcpu()

nhex(n)

hexpointer(p)

hexuint64(p)

hexuint32(p)

hexlength(p)

hexnumber(p)

hexbyte(p)

decimal(n)

decnumber(p)

dec4(p)

ipaddress(p)

sockaddress(p)

THREAD_ID

CRC32(buf, len)

CRC32_MEM(buf, len, txt)

LOG_TRACE_MSG(x)

LOG_DEBUG_MSG(x)

LOG_INFO_MSG(x)

LOG_WARN_MSG(x)

LOG_ERROR_MSG(x)

LOG_FATAL_MSG(x)

LOG_EXCLUSIVE(x)

FUNC_START_DEBUG_MSG

FUNC_END_DEBUG_MSG

LOG_FORMAT_MSG(x)

LOG_DEVEL_MSG(x)

LOG_TIMED_INIT(name)

LOG_TIMED_MSG(name, level, delay, x)

LOG_TIMED_BLOCK(name, level, delay, x)

X_DEFINE_ENUM_WITH_STRING_CONVERSIONS_TOSTRING_CASE(r, data, elem)

DEFINE_ENUM_WITH_STRING_CONVERSIONS(name, enumerators)

Defines

PERFORMANCE_COUNTER_ENABLED

namespace hpx

namespace parcelset

template<typename T>
struct performance_counter<T, false>

Public Functions

constexpr performance_counter()

constexpr performance_counter(const T&)

constexpr operator T() const

constexpr T operator=(const T&)

constexpr T operator++()

constexpr T operator++(int)

constexpr T operator+=(const T&)

constexpr T operator--()

constexpr T operator--(int)

constexpr T operator-=(const T&)

Friends

std::ostream &operator<<(std::ostream &os, const performance_counter<T, false>&)

template<typename T>
struct performance_counter<T, true>

Public Functions

performance_counter()

performance_counter(const T &init)

operator T() const

T operator=(const T &x)

T operator++()

T operator++(int x)

T operator+=(const T &rhs)

T operator--()

T operator--(int x)

T operator-=(const T &rhs)

Public Members

std::atomic<T> value_

Friends

std::ostream &operator<<(std::ostream &os, const performance_counter<T, true> &x)

namespace hpx

namespace parcelset

namespace policies

namespace libfabric

template<typename T, int Offset, typename Region, typename Allocator>
class pinned_memory_vector

Public Types

typedef T value_type

typedef value_type &reference

typedef T *iterator

typedef T const *const_iterator

typedef std::vector<T>::difference_type difference_type

typedef std::vector<T>::size_type size_type

typedef Allocator allocator_type

typedef Region region_type

typedef pinned_memory_vector<T, Offset, region_type, allocator_type> vector_type

typedef hpx::function<void()> deleter_callback

Public Functions

pinned_memory_vector(allocator_type *alloc)

pinned_memory_vector(T *p, std::size_t s, deleter_callback cb, allocator_type *alloc, region_type *r)

pinned_memory_vector(vector_type &&other)

~pinned_memory_vector()

vector_type &operator=(vector_type &&other)

size_type size() const

size_type max_size() const

bool empty() const

T *data()

iterator begin()

iterator end()

const_iterator begin() const

const_iterator end() const

reference operator[](std::size_t index)

const_reference operator[](std::size_t index) const

void push_back(const T &_Val)

std::size_t capacity()

void resize(std::size_t s)

void reserve(std::size_t s)

Public Members

const typedef value_type& hpx::parcelset::policies::libfabric::pinned_memory_vector::const_reference

T *m_array_

std::size_t m_size_

deleter_callback m_cb_

allocator_type *m_alloc_

region_type *m_region_

Private Functions

pinned_memory_vector(vector_type const &other)

namespace hpx

namespace parcelset

namespace policies

namespace libfabric

Typedefs

template<typename Mutex>
using scoped_lock = std::lock_guard<Mutex>

template<typename Mutex>
using unique_lock = std::unique_lock<Mutex>

Defines

RWL_DEBUG_MSG(x)

atomic_xadd(P, V)

cmpxchg(P, O, N)

atomic_inc(P)

rwl_barrier_()

namespace hpx

namespace lcos

namespace local

class readers_writer_mutex

Public Functions

readers_writer_mutex()

void lock()

void unlock()

bool try_lock()

void lock_shared()

void unlock_shared()

bool try_lock_shared()

bool owns_lock()

Private Members

readwrite_ticket ticket

bool readlock_

union readwrite_ticket

Public Members

uint64_t u

uint32_t wr

struct hpx::lcos::local::readers_writer_mutex::readwrite_ticket::[anonymous] i

uint16_t writers

uint16_t readers

uint16_t next

uint16_t notused

struct hpx::lcos::local::readers_writer_mutex::readwrite_ticket::[anonymous] s

namespace hpx

namespace parcelset

namespace policies

namespace libfabric

struct receiver

Public Types

typedef libfabric_region_provider region_provider

typedef rma_memory_region<region_provider> region_type

typedef hpx::detail::small_vector<region_type*, 8> zero_copy_vector

Public Functions

receiver(parcelport *pp, fid_ep *endpoint, rma_memory_pool<region_provider> &memory_pool)

receiver(receiver &&other)

receiver &operator=(receiver &&other)

~receiver()

void handle_recv(fi_addr_t const &src_addr, std::uint64_t len)

void pre_post_receive()

void cleanup()

Private Types

typedef hpx::lcos::local::spinlock mutex_type

Private Members

parcelport *pp_

fid_ep *endpoint_

region_type *header_region_

rma_memory_pool<region_provider> *memory_pool_

performance_counter<unsigned int> messages_handled_

performance_counter<unsigned int> acks_received_

performance_counter<unsigned int> msg_plain_

performance_counter<unsigned int> msg_rma_

performance_counter<unsigned int> sent_ack_

performance_counter<unsigned int> rma_reads_

performance_counter<unsigned int> recv_deletes_

boost::lockfree::stack<rma_receiver*, boost::lockfree::capacity<HPX_PARCELPORT_LIBFABRIC_MAX_PREPOSTS>, boost::lockfree::fixed_sized<true>> rma_receivers_

mutex_type active_receivers_mtx_

hpx::lcos::local::detail::condition_variable active_receivers_cv_

hpx::util::atomic_count active_receivers_

Friends

friend hpx::parcelset::policies::libfabric::libfabric_controller

namespace hpx

namespace parcelset

namespace policies

namespace libfabric

struct rma_base

Subclassed by hpx::parcelset::policies::libfabric::rma_receiver, hpx::parcelset::policies::libfabric::sender

Public Functions

rma_base()

virtual ~rma_base()

virtual void handle_error(struct fi_cq_err_entry err) = 0

Defines

RDMA_POOL_1K_CHUNK_SIZE

RDMA_POOL_SMALL_CHUNK_SIZE

RDMA_POOL_MEDIUM_CHUNK_SIZE

RDMA_POOL_LARGE_CHUNK_SIZE

RDMA_POOL_MAX_1K_CHUNKS

RDMA_POOL_MAX_SMALL_CHUNKS

RDMA_POOL_MAX_MEDIUM_CHUNKS

RDMA_POOL_MAX_LARGE_CHUNKS

namespace hpx

namespace parcelset

template<typename RegionProvider>
struct memory_region_allocator

Public Types

typedef RegionProvider::provider_domain domain_type

typedef rma_memory_region<RegionProvider> region_type

typedef std::shared_ptr<region_type> region_ptr

Public Functions

memory_region_allocator()

Public Static Functions

static region_ptr malloc(domain_type *pd, const std::size_t bytes)

static void free(region_ptr region)

template<typename RegionProvider, typename Allocator, typename PoolType, std::size_t ChunkSize, std::size_t MaxChunks>
struct pool_container

Public Types

typedef RegionProvider::provider_domain domain_type

typedef rma_memory_region<RegionProvider> region_type

typedef std::shared_ptr<region_type> region_ptr

Public Functions

pool_container(domain_type *pd)

bool allocate_pool()

void DeallocatePool()

void push(region_type *region)

region_type *pop()

void decrement_used_count(uint32_t N)

std::string status()

constexpr std::size_t chunk_size() const

Public Members

performance_counter<unsigned int> accesses_

performance_counter<unsigned int> in_use_

domain_type *pd_

std::unordered_map<const char*, region_ptr> block_list_

std::array<region_type, MaxChunks> region_list_

bl::stack<region_type*, bl::capacity<MaxChunks>> free_list_

struct pool_large

Public Static Functions

static const char *desc()

struct pool_medium

Public Static Functions

static const char *desc()

struct pool_small

Public Static Functions

static const char *desc()

struct pool_tiny

Public Static Functions

static const char *desc()

template<typename RegionProvider>
struct rma_memory_pool

Public Types

typedef RegionProvider::provider_domain domain_type

typedef rma_memory_region<RegionProvider> region_type

typedef memory_region_allocator<RegionProvider> allocator_type

typedef std::shared_ptr<region_type> region_ptr

Public Functions

HPX_NON_COPYABLE(rma_memory_pool)

rma_memory_pool(domain_type *pd)

~rma_memory_pool()

void deallocate_pools()

bool can_allocate_unsafe(size_t length) const

region_type *allocate_region(size_t length)

void deallocate(region_type *region)

region_type *allocate_temporary_region(std::size_t length)

Public Members

domain_type *protection_domain_

pool_container<RegionProvider, allocator_type, pool_tiny, RDMA_POOL_1K_CHUNK_SIZE, RDMA_POOL_MAX_1K_CHUNKS> tiny_

pool_container<RegionProvider, allocator_type, pool_small, RDMA_POOL_SMALL_CHUNK_SIZE, RDMA_POOL_MAX_SMALL_CHUNKS> small_

pool_container<RegionProvider, allocator_type, pool_medium, RDMA_POOL_MEDIUM_CHUNK_SIZE, RDMA_POOL_MAX_MEDIUM_CHUNKS> medium_

pool_container<RegionProvider, allocator_type, pool_large, RDMA_POOL_LARGE_CHUNK_SIZE, RDMA_POOL_MAX_LARGE_CHUNKS> large_

hpx::util::atomic_count temp_regions

hpx::util::atomic_count user_regions

namespace hpx

namespace parcelset

struct rma_memory_base

Public Functions

rma_memory_base()

template<typename RegionProvider>
struct rma_memory_region

Public Types

enum [anonymous]

Values:

BLOCK_USER = 1

BLOCK_TEMP = 2

BLOCK_PARTIAL = 4

typedef RegionProvider::provider_domain provider_domain

typedef RegionProvider::provider_region provider_region

Public Functions

rma_memory_region()

rma_memory_region(provider_region *region, char *address, char *base_address, uint64_t size, uint32_t flags)

rma_memory_region(provider_domain *pd, const void *buffer, const uint64_t length)

int allocate(provider_domain *pd, uint64_t length)

~rma_memory_region()

int release(void)

char *get_address(void) const

char *get_base_address(void) const

uint64_t get_size(void) const

void *get_desc(void) const

uint64_t get_remote_key(void) const

void set_message_length(uint32_t length)

uint32_t get_message_length(void) const

struct fid_mr *get_region()

void set_user_region()

bool get_user_region() const

void set_temp_region()

bool get_temp_region() const

void set_partial_region()

bool get_partial_region() const

Private Members

provider_region *region_

char *address_

char *base_addr_

uint64_t size_

uint64_t used_space_

uint32_t flags_

Friends

std::ostream &operator<<(std::ostream &os, rma_memory_region const &region)

namespace hpx

namespace traits

template<typename RegionProvider>
struct rma_memory_region_traits

Public Types

typedef RegionProvider::provider_domain provider_domain

typedef RegionProvider::provider_region provider_region

Public Static Functions

static int register_memory(provider_domain *pd, const void *buf, size_t len, uint64_t access, uint64_t offset, uint64_t requested_key, uint64_t flags, provider_region **mr, void *context)

static int unregister_memory(provider_region *mr)

static int flags()

namespace hpx

namespace parcelset

namespace policies

namespace libfabric

struct rma_receiver : public hpx::parcelset::policies::libfabric::rma_base

Public Types

typedef libfabric_region_provider region_provider

typedef rma_memory_region<region_provider> region_type

typedef rma_memory_pool<region_provider> memory_pool_type

typedef hpx::detail::small_vector<region_type*, 8> zero_copy_vector

typedef header<HPX_PARCELPORT_LIBFABRIC_MESSAGE_HEADER_SIZE> header_type

typedef serialization::serialization_chunk chunk_struct

typedef hpx::function<void(rma_receiver*)> completion_handler

Public Functions

rma_receiver(parcelport *pp, fid_ep *endpoint, memory_pool_type *memory_pool, completion_handler &&handler)

~rma_receiver()

void read_message(region_type *region, fi_addr_t const &src_addr)

void handle_message_no_rma()

void handle_message_with_zerocopy_rma()

void handle_message_no_chunk_data()

int handle_chunks_read_message()

void handle_rma_read_completion()

void send_rdma_complete_ack()

void cleanup_receive()

void handle_error(struct fi_cq_err_entry err)

void read_chunk_list()

void read_one_chunk(fi_addr_t src_addr, region_type *get_region, const void *remoteAddr, uint64_t rkey)

Public Static Attributes

constexpr unsigned int header_size = header_type::header_block_size

Private Members

parcelport *pp_

fid_ep *endpoint_

region_type *header_region_

region_type *chunk_region_

region_type *message_region_

header_type *header_

std::vector<chunk_struct> chunks_

zero_copy_vector rma_regions_

rma_memory_pool<region_provider> *memory_pool_

fi_addr_t src_addr_

completion_handler handler_

hpx::util::atomic_count rma_count_

bool chunk_fetch_

double start_time_

performance_counter<unsigned int> msg_plain_

performance_counter<unsigned int> msg_rma_

performance_counter<unsigned int> sent_ack_

performance_counter<unsigned int> rma_reads_

performance_counter<unsigned int> recv_deletes_

Friends

friend hpx::parcelset::policies::libfabric::receiver

namespace hpx

namespace parcelset

namespace policies

namespace libfabric

struct sender : public hpx::parcelset::policies::libfabric::rma_base

Public Types

typedef libfabric_region_provider region_provider

typedef rma_memory_region<region_provider> region_type

typedef rma_memory_pool<region_provider> memory_pool_type

typedef header<HPX_PARCELPORT_LIBFABRIC_MESSAGE_HEADER_SIZE> header_type

typedef pinned_memory_vector<char, header_size, region_type, memory_pool_type> snd_data_type

typedef parcel_buffer<snd_data_type, serialization::serialization_chunk> snd_buffer_type

typedef hpx::detail::small_vector<region_type*, 8> zero_copy_vector

Public Functions

sender(parcelport *pp, fid_ep *endpoint, fid_domain *domain, memory_pool_type *memory_pool)

~sender()

snd_buffer_type get_new_buffer()

template<typename Handler, typename ParcelPostprocess>
void async_write(Handler&&, ParcelPostprocess&&)

void verify_(parcelset::locality const&) const

void async_write_impl()

void handle_send_completion()

void handle_message_completion_ack()

void cleanup()

void handle_error(struct fi_cq_err_entry err)

Public Members

parcelport *parcelport_

fid_ep *endpoint_

fid_domain *domain_

memory_pool_type *memory_pool_

fi_addr_t dst_addr_

snd_buffer_type buffer_

region_type *header_region_

region_type *chunk_region_

region_type *message_region_

header_type *header_

zero_copy_vector rma_regions_

hpx::util::atomic_count completion_count_

performance_counter<unsigned int> sends_posted_

performance_counter<unsigned int> sends_deleted_

performance_counter<unsigned int> acks_received_

hpx::move_only_function<void(error_code const&)> handler_

hpx::function<void(sender*)> postprocess_handler_

struct iovec region_list_[2]

void *desc_[2]

Public Static Attributes

constexpr unsigned int header_size = header_type::header_block_size

namespace hpx

namespace concurrent

template<class Key, class Value, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, Value>>>
class unordered_map

Public Types

typedef hpx::lcos::local::readers_writer_mutex rw_mutex_type

typedef std::unique_lock<rw_mutex_type> write_lock

typedef std::shared_lock<rw_mutex_type> read_lock

typedef std::defer_lock_t defer_lock

typedef base_map::key_type key_type

typedef base_map::mapped_type mapped_type

typedef base_map::value_type value_type

typedef base_map::size_type size_type

typedef base_map::difference_type difference_type

typedef base_map::hasher hasher

typedef base_map::key_equal key_equal

typedef base_map::allocator_type allocator_type

typedef base_map::reference reference

typedef base_map::const_reference const_reference

typedef base_map::pointer pointer

typedef base_map::const_pointer const_pointer

typedef base_map::iterator iterator

typedef base_map::const_iterator const_iterator

typedef base_map::local_iterator local_iterator

typedef base_map::const_local_iterator const_local_iterator

typedef read_lock map_read_lock_type

typedef write_lock map_write_lock_type

Public Functions

unordered_map(size_type n = 64, const hasher &hf = hasher(), const key_equal &eql = key_equal(), const allocator_type &a = allocator_type())

template<typename InputIterator>
unordered_map(InputIterator first, InputIterator last, size_type n = 64, const hasher &hf = hasher(), const key_equal &eql = key_equal(), const allocator_type &a = allocator_type())

unordered_map(const unordered_map &other)

unordered_map(const allocator_type &a)

unordered_map(const unordered_map &other, const allocator_type &a)

unordered_map(unordered_map &&other)

unordered_map(unordered_map &&other, const allocator_type &a)

unordered_map(std::initializer_list<value_type> il, size_type n = 64, const hasher &hf = hasher(), const key_equal &eql = key_equal(), const allocator_type &a = allocator_type())

~unordered_map()

unordered_map &operator=(const unordered_map &other)

unordered_map &operator=(unordered_map &&other)

unordered_map &operator=(std::initializer_list<value_type> il)

void swap(unordered_map &other)

std::pair<iterator, bool> insert(const value_type &x)

iterator insert(const_iterator hint, const value_type &x)

template<class InputIterator>
void insert(InputIterator first, InputIterator last)

std::pair<iterator, bool> insert(value_type &&x)

iterator insert(const_iterator hint, value_type &&x)

void insert(std::initializer_list<value_type> il)

template<typename ...Args>
std::pair<iterator, bool> emplace(Args&&... args)

template<typename ...Args>
iterator emplace_hint(const_iterator hint, Args&&... args)

iterator erase(const_iterator position)

size_type erase(const key_type &k)

iterator erase(const_iterator first, const_iterator last)

void clear()

bool empty() const

size_type size() const

size_type max_size() const

iterator begin()

const_iterator begin() const

iterator end()

const_iterator end() const

const_iterator cbegin() const

const_iterator cend() const

rw_mutex_type &read_write_mutex()

hasher hash_function() const

key_equal key_eq() const

iterator find(const key_type &k)

const_iterator find(const key_type &k) const

std::pair<const_iterator, bool> is_in_map(const key_type &k) const

size_type count(const key_type &k) const

std::pair<iterator, iterator> equal_range(const key_type &k)

std::pair<const_iterator, const_iterator> equal_range(const key_type &k) const

const mapped_type &operator[](const key_type &k) const

mapped_type &at(const key_type &k)

const mapped_type &at(const key_type &k) const

Private Types

typedef std::unordered_map<Key, Value, Hash, KeyEqual, Allocator> base_map

Private Members

base_map map_

rw_mutex_type mutex_

read_lock iterator_lock_

previous

parcelport_lci

next

parcelport_mpi