local_lcos

#include <compatibility/hpx/lcos/local/packaged_task.hpp>

#include <compatibility/hpx/lcos/local/promise.hpp>

#include <compatibility/hpx/lcos/local/trigger.hpp>

#include <compatibility/hpx/lcos/local/composable_guard.hpp>

#include <compatibility/hpx/lcos/local/receive_buffer.hpp>

#include <compatibility/hpx/lcos/local/channel.hpp>

#include <compatibility/hpx/lcos/local/and_gate.hpp>

#include <compatibility/hpx/lcos/local/conditional_trigger.hpp>

#include <hpx/local_lcos/packaged_task.hpp>

namespace hpx

namespace lcos

namespace local

template <typename R, typename... Ts>
template<>
class packaged_task<R(Ts...)>

Public Functions

packaged_task()

template <typename F, typename FD = typename std::decay<F>::type, typename Enable = typename std::enable_if< !std::is_same<FD, packaged_task>::value && traits::is_invocable_r<R, FD&, Ts...>::value>::type>
packaged_task(F &&f)

template <typename Allocator, typename F, typename FD = typename std::decay<F>::type, typename Enable = typename std::enable_if< !std::is_same<FD, packaged_task>::value && traits::is_invocable_r<R, FD&, Ts...>::value>::type>
packaged_task(std::allocator_arg_t, Allocator const &a, F &&f)

packaged_task(packaged_task &&rhs)

packaged_task &operator=(packaged_task &&rhs)

void swap(packaged_task &rhs)

void operator()(Ts... vs)

lcos::future<R> get_future(error_code &ec = throws)

bool valid() const

void reset(error_code &ec = throws)

void set_exception(std::exception_ptr const &e)

Private Types

typedef util::unique_function_nonser<R(Ts...)> function_type

Private Functions

template <typename... Vs>
void invoke_impl(std::false_type, Vs&&... vs)

template <typename... Vs>
void invoke_impl(std::true_type, Vs&&... vs)

Private Members

function_type function_

local::promise<R> promise_

#include <hpx/local_lcos/promise.hpp>

namespace hpx

namespace lcos

namespace local

Functions

template <typename R>
void swap(promise<R> &x, promise<R> &y)

template <typename R>
class promise : public hpx::lcos::local::detail::promise_base<R>

Public Functions

promise()

template <typename Allocator>
promise(std::allocator_arg_t, Allocator const &a)

promise(promise &&other)

~promise()

promise &operator=(promise &&other)

void swap(promise &other)

bool valid() const

void set_value(R const &r)

void set_value(R &&r)

template <typename... Ts>
void set_value(Ts&&... ts)

void set_exception(std::exception_ptr e)

Private Types

typedef detail::promise_base<R> base_type

template <typename R>
template<>
class promise<R&> : public hpx::lcos::local::detail::promise_base<R&>

Public Functions

promise()

template <typename Allocator>
promise(std::allocator_arg_t, Allocator const &a)

promise(promise &&other)

~promise()

promise &operator=(promise &&other)

void swap(promise &other)

bool valid() const

void set_value(R &r)

void set_exception(std::exception_ptr e)

Private Types

typedef detail::promise_base<R&> base_type

template <>
template<>
class promise<void> : public hpx::lcos::local::detail::promise_base<void>

Public Functions

promise()

template <typename Allocator>
promise(std::allocator_arg_t, Allocator const &a)

promise(promise &&other)

~promise()

promise &operator=(promise &&other)

void swap(promise &other)

bool valid() const

void set_value()

void set_exception(std::exception_ptr e)

Private Types

typedef detail::promise_base<void> base_type

#include <hpx/local_lcos/trigger.hpp>

namespace hpx

namespace lcos

namespace local

template <typename Mutex = lcos::local::spinlock>
struct base_trigger

Public Functions

base_trigger()

base_trigger(base_trigger &&rhs)

base_trigger &operator=(base_trigger &&rhs)

future<void> get_future(std::size_t *generation_value = nullptr, error_code &ec = hpx::throws)

get a future allowing to wait for the trigger to fire

bool set(error_code &ec = throws)

Trigger this object.

void synchronize(std::size_t generation_value, char const *function_name = "base_and_gate<>::synchronize", error_code &ec = throws)

Wait for the generational counter to reach the requested stage.

std::size_t next_generation()

std::size_t generation() const

Protected Types

typedef Mutex mutex_type

Protected Functions

bool trigger_conditions(error_code &ec = throws)

template <typename Lock>
void synchronize(std::size_t generation_value, Lock &l, char const *function_name = "base_and_gate<>::synchronize", error_code &ec = throws)

Private Types

typedef std::list<conditional_trigger *> condition_list_type

Private Functions

bool test_condition(std::size_t generation_value)

Private Members

mutex_type mtx_

lcos::local::promise<void> promise_

std::size_t generation_

condition_list_type conditions_

struct manage_condition

Public Functions

template<>
manage_condition(base_trigger &gate, conditional_trigger &cond)

template<>
~manage_condition()

template <typename Condition>
template<>
future<void> get_future(Condition &&func, error_code &ec = hpx::throws)

Public Members

template<>
base_trigger &this_

template<>
condition_list_type::iterator it_

struct trigger : public hpx::lcos::local::base_trigger<no_mutex>

Public Functions

trigger()

trigger(trigger &&rhs)

trigger &operator=(trigger &&rhs)

template <typename Lock>
void synchronize(std::size_t generation_value, Lock &l, char const *function_name = "trigger::synchronize", error_code &ec = throws)

Private Types

typedef base_trigger<no_mutex> base_type

#include <hpx/local_lcos/composable_guard.hpp>

namespace hpx

namespace lcos

namespace local

Functions

void run_guarded(guard &guard, detail::guard_function task)

Conceptually, a guard acts like a mutex on an asynchronous task. The mutex is locked before the task runs, and unlocked afterwards.

template <typename F, typename... Args>
void run_guarded(guard &guard, F &&f, Args&&... args)

void run_guarded(guard_set &guards, detail::guard_function task)

Conceptually, a guard_set acts like a set of mutexes on an asynchronous task. The mutexes are locked before the task runs, and unlocked afterwards.

template <typename F, typename... Args>
void run_guarded(guard_set &guards, F &&f, Args&&... args)

class guard : public hpx::lcos::local::detail::debug_object

Public Functions

guard()

~guard()

Public Members

detail::guard_atomic task

class guard_set : public hpx::lcos::local::detail::debug_object

Public Functions

guard_set()

~guard_set()

std::shared_ptr<guard> get(std::size_t i)

void add(std::shared_ptr<guard> const &guard_ptr)

std::size_t size()

Private Functions

void sort()

Private Members

std::vector<std::shared_ptr<guard>> guards

bool sorted

Friends

void run_guarded(guard_set &guards, detail::guard_function task)

Conceptually, a guard_set acts like a set of mutexes on an asynchronous task. The mutexes are locked before the task runs, and unlocked afterwards.

#include <hpx/local_lcos/receive_buffer.hpp>

namespace hpx

namespace lcos

namespace local

template <typename T, typename Mutex = lcos::local::spinlock>
struct receive_buffer

Public Functions

receive_buffer()

receive_buffer(receive_buffer &&other)

~receive_buffer()

receive_buffer &operator=(receive_buffer &&other)

hpx::future<T> receive(std::size_t step)

bool try_receive(std::size_t step, hpx::future<T> *f = nullptr)

template <typename Lock = hpx::lcos::local::no_mutex>
void store_received(std::size_t step, T &&val, Lock *lock = nullptr)

bool empty() const

std::size_t cancel_waiting(std::exception_ptr const &e, bool force_delete_entries = false)

Protected Types

typedef Mutex mutex_type

typedef hpx::lcos::local::promise<T> buffer_promise_type

typedef std::map<std::size_t, std::shared_ptr<entry_data>> buffer_map_type

typedef buffer_map_type::iterator iterator

Protected Functions

iterator get_buffer_entry(std::size_t step)

Private Members

mutex_type mtx_

buffer_map_type buffer_map_

struct entry_data

Public Functions

template<>
HPX_NON_COPYABLE(entry_data)

template<>
entry_data()

template<>
hpx::future<T> get_future()

template <typename Val>
template<>
void set_value(Val &&val)

template<>
bool cancel(std::exception_ptr const &e)

Public Members

template<>
buffer_promise_type promise_

template<>
bool can_be_deleted_

template<>
bool value_set_

struct erase_on_exit

Public Functions

template<>
erase_on_exit(buffer_map_type &buffer_map, iterator it)

template<>
~erase_on_exit()

Public Members

template<>
buffer_map_type &buffer_map_

template<>
iterator it_

template <typename Mutex>
template<>
struct receive_buffer<void, Mutex>

Public Functions

receive_buffer()

receive_buffer(receive_buffer &&other)

~receive_buffer()

receive_buffer &operator=(receive_buffer &&other)

hpx::future<void> receive(std::size_t step)

bool try_receive(std::size_t step, hpx::future<void> *f = nullptr)

template <typename Lock = hpx::lcos::local::no_mutex>
void store_received(std::size_t step, Lock *lock = nullptr)

bool empty() const

std::size_t cancel_waiting(std::exception_ptr const &e, bool force_delete_entries = false)

Protected Types

typedef Mutex mutex_type

typedef hpx::lcos::local::promise<void> buffer_promise_type

typedef std::map<std::size_t, std::shared_ptr<entry_data>> buffer_map_type

typedef buffer_map_type::iterator iterator

Protected Functions

iterator get_buffer_entry(std::size_t step)

Private Members

mutex_type mtx_

buffer_map_type buffer_map_

template<>
struct entry_data

Public Functions

template<>
HPX_NON_COPYABLE(entry_data)

template<>
entry_data()

template<>
hpx::future<void> get_future()

template<>
void set_value()

template<>
bool cancel(std::exception_ptr const &e)

Public Members

template<>
buffer_promise_type promise_

template<>
bool can_be_deleted_

template<>
bool value_set_

template<>
struct erase_on_exit

Public Functions

template<>
erase_on_exit(buffer_map_type &buffer_map, iterator it)

template<>
~erase_on_exit()

Public Members

template<>
buffer_map_type &buffer_map_

template<>
iterator it_

#include <hpx/local_lcos/channel.hpp>

namespace hpx

namespace lcos

namespace local

template <typename T>
class channel : protected hpx::lcos::local::detail::channel_base<T>

Public Types

typedef T value_type

Public Functions

channel()

Private Types

typedef detail::channel_base<T> base_type

Friends

friend hpx::lcos::local::channel_iterator< T >

friend hpx::lcos::local::receive_channel< T >

friend hpx::lcos::local::send_channel< T >

template <>
template<>
class channel<void> : protected hpx::lcos::local::detail::channel_base<void>

Public Types

typedef void value_type

Public Functions

channel()

Private Types

typedef detail::channel_base<void> base_type

Friends

friend hpx::lcos::local::channel_iterator< void >

friend hpx::lcos::local::receive_channel< void >

friend hpx::lcos::local::send_channel< void >

template <typename T>
class channel_async_iterator : public hpx::util::iterator_facade<channel_async_iterator<T>, hpx::future<T>, std::input_iterator_tag, hpx::future<T>>

Public Functions

channel_async_iterator()

channel_async_iterator(detail::channel_base<T> const *c)

Private Types

typedef hpx::util::iterator_facade<channel_async_iterator<T>, hpx::future<T>, std::input_iterator_tag, hpx::future<T>> base_type

Private Functions

std::pair<hpx::future<T>, bool> get_checked() const

bool equal(channel_async_iterator const &rhs) const

void increment()

base_type::reference dereference() const

Private Members

hpx::intrusive_ptr<detail::channel_impl_base<T>> channel_

std::pair<hpx::future<T>, bool> data_

Friends

friend hpx::lcos::local::hpx::util::iterator_core_access

template <typename T>
class channel_iterator : public hpx::util::iterator_facade<channel_iterator<T>, T const, std::input_iterator_tag>

Public Functions

channel_iterator()

channel_iterator(detail::channel_base<T> const *c)

channel_iterator(receive_channel<T> const *c)

Private Types

typedef hpx::util::iterator_facade<channel_iterator<T>, T const, std::input_iterator_tag> base_type

Private Functions

std::pair<T, bool> get_checked() const

bool equal(channel_iterator const &rhs) const

void increment()

base_type::reference dereference() const

Private Members

hpx::intrusive_ptr<detail::channel_impl_base<T>> channel_

std::pair<T, bool> data_

Friends

friend hpx::lcos::local::hpx::util::iterator_core_access

template <>
template<>
class channel_iterator<void> : public hpx::util::iterator_facade<channel_iterator<void>, util::unused_type const, std::input_iterator_tag>

Public Functions

channel_iterator()

channel_iterator(detail::channel_base<void> const *c)

channel_iterator(receive_channel<void> const *c)

Private Types

typedef hpx::util::iterator_facade<channel_iterator<void>, util::unused_type const, std::input_iterator_tag> base_type

Private Functions

bool get_checked()

bool equal(channel_iterator const &rhs) const

void increment()

base_type::reference dereference() const

Private Members

hpx::intrusive_ptr<detail::channel_impl_base<util::unused_type>> channel_

bool data_

Friends

friend hpx::lcos::local::hpx::util::iterator_core_access

template <typename T>
class one_element_channel : protected hpx::lcos::local::detail::channel_base<T>

Public Types

typedef T value_type

Public Functions

one_element_channel()

Private Types

typedef detail::channel_base<T> base_type

Friends

friend hpx::lcos::local::channel_iterator< T >

friend hpx::lcos::local::receive_channel< T >

friend hpx::lcos::local::send_channel< T >

template <>
template<>
class one_element_channel<void> : protected hpx::lcos::local::detail::channel_base<void>

Public Types

typedef void value_type

Public Functions

one_element_channel()

Private Types

typedef detail::channel_base<void> base_type

Friends

friend hpx::lcos::local::channel_iterator< void >

friend hpx::lcos::local::receive_channel< void >

friend hpx::lcos::local::send_channel< void >

template <typename T>
class receive_channel : protected hpx::lcos::local::detail::channel_base<T>

Public Functions

receive_channel(channel<T> const &c)

receive_channel(one_element_channel<T> const &c)

Private Types

typedef detail::channel_base<T> base_type

Friends

friend hpx::lcos::local::channel_iterator< T >

friend hpx::lcos::local::send_channel< T >

template <>
template<>
class receive_channel<void> : protected hpx::lcos::local::detail::channel_base<void>

Public Functions

receive_channel(channel<void> const &c)

receive_channel(one_element_channel<void> const &c)

Private Types

typedef detail::channel_base<void> base_type

Friends

friend hpx::lcos::local::channel_iterator< void >

friend hpx::lcos::local::send_channel< void >

template <typename T>
class send_channel : hpx::lcos::local::detail::channel_base<T>

Public Functions

send_channel(channel<T> const &c)

send_channel(one_element_channel<T> const &c)

Private Types

typedef detail::channel_base<T> base_type

template <>
template<>
class send_channel<void> : hpx::lcos::local::detail::channel_base<void>

Public Functions

send_channel(channel<void> const &c)

send_channel(one_element_channel<void> const &c)

Private Types

typedef detail::channel_base<void> base_type

#include <hpx/local_lcos/force_linking.hpp>

namespace hpx

namespace local_lcos

Functions

force_linking_helper &force_linking()

struct force_linking_helper

Public Members

void (*free)(lcos::local::detail::guard_task *task)

#include <hpx/local_lcos/and_gate.hpp>

namespace hpx

namespace lcos

namespace local

struct and_gate : public hpx::lcos::local::base_and_gate<no_mutex>

Public Functions

and_gate(std::size_t count = 0)

and_gate(and_gate &&rhs)

and_gate &operator=(and_gate &&rhs)

template <typename Lock>
future<void> get_future(Lock &l, std::size_t count = std::size_t(-1), std::size_t *generation_value = nullptr, error_code &ec = hpx::throws)

template <typename Lock>
shared_future<void> get_shared_future(Lock &l, std::size_t count = std::size_t(-1), std::size_t *generation_value = nullptr, error_code &ec = hpx::throws)

template <typename Lock>
bool set(std::size_t which, Lock &l, error_code &ec = throws)

template <typename Lock>
void synchronize(std::size_t generation_value, Lock &l, char const *function_name = "and_gate::synchronize", error_code &ec = throws)

Private Types

typedef base_and_gate<no_mutex> base_type

template <typename Mutex = lcos::local::spinlock>
struct base_and_gate

Public Functions

base_and_gate(std::size_t count = 0)

This constructor initializes the base_and_gate object from the the number of participants to synchronize the control flow with.

base_and_gate(base_and_gate &&rhs)

base_and_gate &operator=(base_and_gate &&rhs)

future<void> get_future(std::size_t count = std::size_t(-1), std::size_t *generation_value = nullptr, error_code &ec = hpx::throws)

shared_future<void> get_shared_future(std::size_t count = std::size_t(-1), std::size_t *generation_value = nullptr, error_code &ec = hpx::throws)

bool set(std::size_t which, error_code &ec = throws)

void synchronize(std::size_t generation_value, char const *function_name = "base_and_gate<>::synchronize", error_code &ec = throws)

Wait for the generational counter to reach the requested stage.

std::size_t next_generation()

std::size_t generation() const

Protected Types

typedef Mutex mutex_type

Protected Functions

bool trigger_conditions(error_code &ec = throws)

template <typename OuterLock>
future<void> get_future(OuterLock &outer_lock, std::size_t count = std::size_t(-1), std::size_t *generation_value = nullptr, error_code &ec = hpx::throws)

get a future allowing to wait for the gate to fire

template <typename OuterLock>
shared_future<void> get_shared_future(OuterLock &outer_lock, std::size_t count = std::size_t(-1), std::size_t *generation_value = nullptr, error_code &ec = hpx::throws)

get a shared future allowing to wait for the gate to fire

template <typename OuterLock>
bool set(std::size_t which, OuterLock &outer_lock, error_code &ec = throws)

Set the data which has to go into the segment which.

bool test_condition(std::size_t generation_value)

template <typename Lock>
void synchronize(std::size_t generation_value, Lock &l, char const *function_name = "base_and_gate<>::synchronize", error_code &ec = throws)

template <typename OuterLock, typename Lock>
void init_locked(OuterLock &outer_lock, Lock &l, std::size_t count, error_code &ec = throws)

Private Types

typedef std::list<conditional_trigger *> condition_list_type

Private Members

mutex_type mtx_

boost::dynamic_bitset received_segments_

lcos::local::promise<void> promise_

std::size_t generation_

condition_list_type conditions_

struct manage_condition

Public Functions

template<>
manage_condition(base_and_gate &gate, conditional_trigger &cond)

template<>
~manage_condition()

template <typename Condition>
template<>
future<void> get_future(Condition &&func, error_code &ec = hpx::throws)

Public Members

template<>
base_and_gate &this_

template<>
condition_list_type::iterator it_

#include <hpx/local_lcos/conditional_trigger.hpp>

namespace hpx

namespace lcos

namespace local

struct conditional_trigger

Public Functions

conditional_trigger()

conditional_trigger(conditional_trigger &&rhs)

conditional_trigger &operator=(conditional_trigger &&rhs)

template <typename Condition>
future<void> get_future(Condition &&func, error_code &ec = hpx::throws)

get a future allowing to wait for the trigger to fire

void reset()

bool set(error_code &ec = throws)

Trigger this object.

Private Members

lcos::local::promise<void> promise_

util::function_nonser<bool()> cond_