Boost-Geometry-Utils
view release on metacpan or search on metacpan
src/boost/graph/distributed/crauser_et_al_shortest_paths.hpp view on Meta::CPAN
vertex_descriptor& top() { return top_vertex; }
const vertex_descriptor& top() const { return top_vertex; }
bool empty()
{
inherited::collect();
// If there are no suitable messages, wait until we get something
while (!has_suitable_vertex()) {
if (do_synchronize()) return true;
}
// Return true only if nobody has any messages; false if we
// have suitable messages
return false;
}
bool do_synchronize()
{
using boost::parallel::all_reduce;
using boost::parallel::minimum;
inherited::synchronize();
// TBD: could use combine here, but then we need to stop using
// minimum<distance_type>() as the function object.
distance_type local_distances[2];
local_distances[0] =
dist_queue.empty()? (std::numeric_limits<distance_type>::max)()
: get(distance_map, dist_queue.top());
local_distances[1] =
out_queue.empty()? (std::numeric_limits<distance_type>::max)()
src/boost/graph/distributed/crauser_et_al_shortest_paths.hpp view on Meta::CPAN
// Send minimum weights off to the owners
set_property_map_role(vertex_distance, min_in_weight);
BGL_FORALL_VERTICES_T(v, g, Graph) {
BGL_FORALL_OUTEDGES_T(v, e, g, Graph) {
if (get(weight, e) < get(min_in_weight, target(e, g)))
put(min_in_weight, target(e, g), get(weight, e));
}
}
using boost::graph::parallel::process_group;
synchronize(process_group(g));
// Replace any infinities with zeros
BGL_FORALL_VERTICES_T(v, g, Graph) {
if (get(min_in_weight, v) == inf) put(min_in_weight, v, 0);
}
}
template<typename Graph, typename MinInWeightMap, typename WeightMap,
typename Inf, typename Compare>
void
src/boost/graph/distributed/detail/queue.ipp view on Meta::CPAN
buffer.push(x);
else
send(process_group, get(owner, x), msg_push, x);
}
template<BOOST_DISTRIBUTED_QUEUE_PARMS>
bool
BOOST_DISTRIBUTED_QUEUE_TYPE::empty() const
{
/* Processes will stay here until the buffer is nonempty or
synchronization with the other processes indicates that all local
buffers are empty (and no messages are in transit).
*/
while (buffer.empty() && !do_synchronize()) ;
return buffer.empty();
}
template<BOOST_DISTRIBUTED_QUEUE_PARMS>
typename BOOST_DISTRIBUTED_QUEUE_TYPE::size_type
BOOST_DISTRIBUTED_QUEUE_TYPE::size() const
{
empty();
return buffer.size();
src/boost/graph/distributed/detail/queue.ipp view on Meta::CPAN
handle_multipush(int /*source*/, int /*tag*/,
const std::vector<value_type>& values,
trigger_receive_context)
{
for (std::size_t i = 0; i < values.size(); ++i)
if (pred(values[i])) buffer.push(values[i]);
}
template<BOOST_DISTRIBUTED_QUEUE_PARMS>
bool
BOOST_DISTRIBUTED_QUEUE_TYPE::do_synchronize() const
{
#ifdef PBGL_ACCOUNTING
++num_synchronizations;
#endif
using boost::parallel::all_reduce;
using std::swap;
typedef typename ProcessGroup::process_id_type process_id_type;
if (outgoing_buffers) {
// Transfer all of the push requests
process_id_type id = process_id(process_group);
src/boost/graph/distributed/detail/queue.ipp view on Meta::CPAN
if (dest != id) {
send(process_group, dest, msg_multipush, outgoing);
} else {
for (std::size_t i = 0; i < size; ++i)
buffer.push(outgoing[i]);
}
outgoing.clear();
}
}
}
synchronize(process_group);
unsigned local_size = buffer.size();
unsigned global_size =
all_reduce(process_group, local_size, std::plus<unsigned>());
return global_size == 0;
}
} } } // end namespace boost::graph::distributed
src/boost/graph/distributed/detail/remote_update_set.hpp view on Meta::CPAN
#include <boost/graph/parallel/process_group.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <vector>
#include <boost/assert.hpp>
#include <boost/optional.hpp>
#include <queue>
namespace boost { namespace graph { namespace detail {
template<typename ProcessGroup>
void do_synchronize(ProcessGroup& pg)
{
using boost::parallel::synchronize;
synchronize(pg);
}
struct remote_set_queued {};
struct remote_set_immediate {};
template<typename ProcessGroup>
class remote_set_semantics
{
BOOST_STATIC_CONSTANT
(bool,
src/boost/graph/distributed/detail/remote_update_set.hpp view on Meta::CPAN
remote_set_immediate>::type type;
};
template<typename Derived, typename ProcessGroup, typename Value,
typename OwnerMap,
typename Semantics = typename remote_set_semantics<ProcessGroup>::type>
class remote_update_set;
/**********************************************************************
* Remote updating set that queues messages until synchronization *
**********************************************************************/
template<typename Derived, typename ProcessGroup, typename Value,
typename OwnerMap>
class remote_update_set<Derived, ProcessGroup, Value, OwnerMap,
remote_set_queued>
{
typedef typename property_traits<OwnerMap>::key_type Key;
typedef std::vector<std::pair<Key, Value> > Updates;
typedef typename Updates::size_type updates_size_type;
typedef typename Updates::value_type updates_pair_type;
src/boost/graph/distributed/detail/remote_update_set.hpp view on Meta::CPAN
Derived* derived = static_cast<Derived*>(this);
derived->receive_update(get(owner, key), key, value);
}
else {
updates[get(owner, key)].push_back(std::make_pair(key, value));
}
}
void collect() { }
void synchronize()
{
// Emit all updates and then remove them
process_id_type num_processes = updates.size();
for (process_id_type p = 0; p < num_processes; ++p) {
if (!updates[p].empty()) {
send(process_group, p, msg_num_updates, updates[p].size());
send(process_group, p, msg_updates,
&updates[p].front(), updates[p].size());
updates[p].clear();
}
}
do_synchronize(process_group);
}
ProcessGroup process_group;
private:
std::vector<Updates> updates;
OwnerMap owner;
};
/**********************************************************************
src/boost/graph/distributed/detail/remote_update_set.hpp view on Meta::CPAN
}
void collect()
{
typedef std::pair<process_id_type, int> probe_type;
handle_messages handler(this, process_group);
while (optional<probe_type> stp = probe(process_group))
if (stp->second == msg_update) handler(stp->first, stp->second);
}
void synchronize()
{
do_synchronize(process_group);
}
ProcessGroup process_group;
OwnerMap owner;
};
} } } // end namespace boost::graph::detail
#endif // BOOST_GRAPH_DETAIL_REMOTE_UPDATE_SET_HPP
src/boost/graph/distributed/eager_dijkstra_shortest_paths.hpp view on Meta::CPAN
value_type& top() { return queue.top(); }
const value_type& top() const { return queue.top(); }
bool empty()
{
inherited::collect();
// If there are no suitable messages, wait until we get something
while (!has_suitable_vertex()) {
if (do_synchronize()) return true;
}
// Return true only if nobody has any messages; false if we
// have suitable messages
return false;
}
private:
vertex_descriptor predecessor_value(vertex_descriptor v) const
{ return v; }
src/boost/graph/distributed/eager_dijkstra_shortest_paths.hpp view on Meta::CPAN
vertex_descriptor
predecessor_value(property_traits<dummy_property_map>::reference) const
{ return graph_traits<Graph>::null_vertex(); }
bool has_suitable_vertex() const
{
return (!queue.empty()
&& get(distance_map, queue.top()) <= min_distance + lookahead);
}
bool do_synchronize()
{
using boost::parallel::all_reduce;
using boost::parallel::minimum;
inherited::synchronize();
// TBD: could use combine here, but then we need to stop using
// minimum<distance_type>() as the function object.
distance_type local_distance =
queue.empty()? (std::numeric_limits<distance_type>::max)()
: get(distance_map, queue.top());
all_reduce(this->process_group, &local_distance, &local_distance + 1,
&min_distance, minimum<distance_type>());
src/boost/graph/distributed/queue.hpp view on Meta::CPAN
* can be parallelized via introduction of a distributed queue:
*
* distributed_queue<...> Q;
* Q.push(x);
* while (!Q.empty()) {
* // do something, that may push a value onto Q
* }
*
* In the parallel version, the initial @ref push operation will place
* the value @c x onto its owner's queue. All processes will
* synchronize at the call to empty, and only the process owning @c x
* will be allowed to execute the loop (@ref Q.empty() returns
* false). This iteration may in turn push values onto other remote
* queues, so when that process finishes execution of the loop body
* and all processes synchronize again in @ref empty, more processes
* may have nonempty local queues to execute. Once all local queues
* are empty, @ref Q.empty() returns @c false for all processes.
*
* The distributed queue can receive messages at two different times:
* during synchronization and when polling @ref empty. Messages are
* always received during synchronization, to ensure that accurate
* local queue sizes can be determines. However, whether @ref empty
* should poll for messages is specified as an option to the
* constructor. Polling may be desired when the order in which
* elements in the queue are processed is not important, because it
* permits fewer synchronization steps and less communication
* overhead. However, when more strict ordering guarantees are
* required, polling may be semantically incorrect. By disabling
* polling, one ensures that parallel execution using the idiom above
* will not process an element at a later "level" before an earlier
* "level".
*
* The distributed queue nearly models the @ref Buffer
* concept. However, the @ref push routine does not necessarily
* increase the result of @c size() by one (although the size of the
* global queue does increase by one).
src/boost/graph/distributed/queue.hpp view on Meta::CPAN
value_type& top() { return buffer.top(); }
/**
* \overload
*/
const value_type& top() const { return buffer.top(); }
/** Determine if the queue is empty.
*
* When the local queue is nonempty, returns @c true. If the local
* queue is empty, synchronizes with all other processes in the
* process group until either (1) the local queue is nonempty
* (returns @c true) (2) the entire distributed queue is empty
* (returns @c false).
*/
bool empty() const;
/** Determine the size of the local queue.
*
* The behavior of this routine is equivalent to the behavior of
* @ref empty, except that when @ref empty returns true this
src/boost/graph/distributed/queue.hpp view on Meta::CPAN
size_type size() const;
// private:
/** Synchronize the distributed queue and determine if all queues
* are empty.
*
* \returns \c true when all local queues are empty, or false if at least
* one of the local queues is nonempty.
* Defined as virtual for derived classes like depth_limited_distributed_queue.
*/
virtual bool do_synchronize() const;
private:
// Setup triggers
void setup_triggers();
// Message handlers
void
handle_push(int source, int tag, const value_type& value,
trigger_receive_context);
src/boost/graph/distributed/queue.hpp view on Meta::CPAN
typename ProcessGroup, typename OwnerMap, typename Buffer, \
typename UnaryPredicate
/// Helper macro containing the normal template-id for
/// distributed_queue.
#define BOOST_DISTRIBUTED_QUEUE_TYPE \
distributed_queue<ProcessGroup, OwnerMap, Buffer, UnaryPredicate>
/** Synchronize all processes involved with the given distributed queue.
*
* This function will synchronize all of the local queues for a given
* distributed queue, by ensuring that no additional messages are in
* transit. It is rarely required by the user, because most
* synchronization of distributed queues occurs via the @c empty or @c
* size methods.
*/
template<BOOST_DISTRIBUTED_QUEUE_PARMS>
inline void
synchronize(const BOOST_DISTRIBUTED_QUEUE_TYPE& Q)
{ Q.do_synchronize(); }
/// Construct a new distributed queue.
template<typename ProcessGroup, typename OwnerMap, typename Buffer>
inline distributed_queue<ProcessGroup, OwnerMap, Buffer>
make_distributed_queue(const ProcessGroup& process_group,
const OwnerMap& owner,
const Buffer& buffer,
bool polling = false)
{
typedef distributed_queue<ProcessGroup, OwnerMap, Buffer> result_type;
src/boost/graph/parallel/detail/inplace_all_to_all.hpp view on Meta::CPAN
std::vector<std::vector<T> >& incoming)
{
typedef typename std::vector<T>::size_type size_type;
typedef typename ProcessGroup::process_size_type process_size_type;
typedef typename ProcessGroup::process_id_type process_id_type;
process_size_type p = num_processes(pg);
// Make sure there are no straggling messages
synchronize(pg);
// Send along the count (always) and the data (if count > 0)
for (process_id_type dest = 0; dest < p; ++dest) {
if (dest != process_id(pg)) {
send(pg, dest, 0, outgoing[dest].size());
if (!outgoing[dest].empty())
send(pg, dest, 1, &outgoing[dest].front(), outgoing[dest].size());
}
}
// Make sure all of the data gets transferred
synchronize(pg);
// Receive the sizes and data
for (process_id_type source = 0; source < p; ++source) {
if (source != process_id(pg)) {
size_type size;
receive(pg, source, 0, size);
incoming[source].resize(size);
if (size > 0)
receive(pg, source, 1, &incoming[source].front(), size);
} else if (&incoming != &outgoing) {
src/boost/graph/parallel/process_group.hpp view on Meta::CPAN
*/
struct attach_distributed_object { };
/**
* Describes the context in which a trigger is being invoked to
* receive a message.
*/
enum trigger_receive_context {
/// No trigger is active at this time.
trc_none,
/// The trigger is being invoked during synchronization, at the end
/// of a superstep.
trc_in_synchronization,
/// The trigger is being invoked as an "early" receive of a message
/// that was sent through the normal "send" operations to be
/// received by the end of the superstep, but the process group sent
/// the message earlier to clear its buffers.
trc_early_receive,
/// The trigger is being invoked for an out-of-band message, which
/// must be handled immediately.
trc_out_of_band,
/// The trigger is being invoked for an out-of-band message, which
/// must be handled immediately and has alredy been received by
src/boost/graph/parallel/process_group.hpp view on Meta::CPAN
struct batch_process_group_tag : virtual messaging_process_group_tag {};
struct locking_process_group_tag : virtual process_group_tag {};
struct spawning_process_group_tag : virtual process_group_tag {};
struct process_group_archetype
{
typedef int process_id_type;
};
void wait(process_group_archetype&);
void synchronize(process_group_archetype&);
int process_id(const process_group_archetype&);
int num_processes(const process_group_archetype&);
template<typename T> void send(process_group_archetype&, int, int, const T&);
template<typename T>
process_group_archetype::process_id_type
receive(const process_group_archetype& pg,
process_group_archetype::process_id_type source, int tag, T& value);
src/boost/graph/parallel/process_group.hpp view on Meta::CPAN
process_group_archetype::process_id_type source, int tag, T values[],
std::size_t n);
} } } // end namespace boost::graph::parallel
namespace boost { namespace graph { namespace distributed {
using parallel::trigger_receive_context;
using parallel::trc_early_receive;
using parallel::trc_out_of_band;
using parallel::trc_irecv_out_of_band;
using parallel::trc_in_synchronization;
using parallel::trc_none;
using parallel::attach_distributed_object;
} } } // end namespace boost::graph::distributed
#endif // BOOST_GRAPH_PARALLEL_PROCESS_GROUP_HPP
src/boost/mpi/communicator.hpp view on Meta::CPAN
/**
* INTERNAL ONLY
*
* Forward declaration of @c graph_communicator needed for the "cast"
* from a communicator to a graph communicator.
*/
class graph_communicator;
/**
* @brief A communicator that permits communication and
* synchronization among a set of processes.
*
* The @c communicator class abstracts a set of communicating
* processes in MPI. All of the processes that belong to a certain
* communicator can determine the size of the communicator, their rank
* within the communicator, and communicate with any other processes
* in the communicator.
*/
class BOOST_MPI_DECL communicator
{
public:
src/boost/property_map/parallel/distributed_property_map.hpp view on Meta::CPAN
* update its own "official" value or may ignore the put request.
*
* - @c get operations returns the contents of the local ghost
* cell. If no ghost cell is available, one is created using the
* default value provided by the "reduce" operation. See, e.g.,
* @ref basic_reduce and @ref property_reduce.
*
* Using distributed property maps requires a bit more care than using
* local, sequential property maps. While the syntax and semantics are
* similar, distributed property maps may contain out-of-date
* information that can only be guaranteed to be synchronized by
* calling the @ref synchronize function in all processes.
*
* To address the issue of out-of-date values, distributed property
* maps are supplied with a reduction operation. The reduction
* operation has two roles:
*
* -# When a value is needed for a remote key but no value is
* immediately available, the reduction operation provides a
* suitable default. For instance, a distributed property map
* storing distances may have a reduction operation that returns
* an infinite value as the default, whereas a distributed
src/boost/property_map/parallel/distributed_property_map.hpp view on Meta::CPAN
/** A request to retrieve a particular value in a property
* map. The message contains a key. The owner of that key will
* reply with a value.
*/
property_map_get,
/** A request to update values stored on a remote processor. The
* message contains a vector of keys for which the source
* requests updated values. This message will only be transmitted
* during synchronization.
*/
property_map_multiget,
/** A request to store values in a ghost cell. This message
* contains a vector of key/value pairs corresponding to the
* sequence of keys sent to the source processor.
*/
property_map_multiget_reply,
/** The payload containing a vector of local key-value pairs to be
src/boost/property_map/parallel/distributed_property_map.hpp view on Meta::CPAN
{
send(data->process_group, p, property_map_put,
boost::parallel::detail::make_untracked_pair(k, v));
}
/** Access the ghost cell for the given key.
* \internal
*/
value_type& cell(const key_type& k, bool request_if_missing = true) const;
/** Perform synchronization
* \internal
*/
void do_synchronize();
const GlobalMap& global() const { return data->global; }
GlobalMap& global() { return data->global; }
struct data_t
{
data_t(const ProcessGroup& pg, const GlobalMap& global,
const StorageMap& pm, const function1<value_type, key_type>& dv,
bool has_default_resolver)
: process_group(pg), global(global), storage(pm),
src/boost/property_map/parallel/distributed_property_map.hpp view on Meta::CPAN
const std::vector<unsafe_pair<local_key_type, value_type> >& data,
trigger_receive_context);
void setup_triggers(process_group_type& pg);
private:
weak_ptr<data_t> data_ptr;
Reduce reduce;
};
/* Sets up the next stage in a multi-stage synchronization, for
bidirectional consistency. */
struct on_synchronize
{
explicit on_synchronize(const shared_ptr<data_t>& data) : data_ptr(data) { }
void operator()();
private:
weak_ptr<data_t> data_ptr;
};
};
/* An implementation helper macro for the common case of naming
distributed property maps with all of the normal template
parameters. */
#define PBGL_DISTRIB_PMAP \
distributed_property_map<ProcessGroup, GlobalMap, StorageMap>
/* Request that the value for the given remote key be retrieved in
the next synchronization round. */
template<typename ProcessGroup, typename GlobalMap, typename StorageMap>
inline void
request(const PBGL_DISTRIB_PMAP& pm,
typename PBGL_DISTRIB_PMAP::key_type const& key)
{
if (get(pm.data->global, key).first != process_id(pm.data->process_group))
pm.cell(key, false);
}
/** Get the value associated with a particular key. Retrieves the
src/boost/property_map/parallel/distributed_property_map.hpp view on Meta::CPAN
pm.cell(key, false) = value;
}
}
/** Put a value associated with a given key into the local view of the
* property map. This operation is equivalent to @c put, but with one
* exception: no message will be sent to the owning processor in the
* case of a remote update. The effect is that any value written via
* @c local_put for a remote key may be overwritten in the next
* synchronization round.
*/
template<typename ProcessGroup, typename GlobalMap, typename StorageMap>
void
local_put(const PBGL_DISTRIB_PMAP& pm,
typename PBGL_DISTRIB_PMAP::key_type const & key,
typename PBGL_DISTRIB_PMAP::value_type const & value)
{
using boost::put;
typename property_traits<GlobalMap>::value_type p =
src/boost/property_map/parallel/distributed_property_map.hpp view on Meta::CPAN
typename PBGL_DISTRIB_PMAP::value_type const & value)
{
typename ProcessGroup::process_id_type id = get(pm.data->global, key).first;
if (id != process_id(pm.data->process_group)) pm.cell(key, false) = value;
}
/// Synchronize the property map.
template<typename ProcessGroup, typename GlobalMap, typename StorageMap>
void
synchronize(PBGL_DISTRIB_PMAP& pm)
{
pm.do_synchronize();
}
/// Create a distributed property map.
template<typename ProcessGroup, typename GlobalMap, typename StorageMap>
inline distributed_property_map<ProcessGroup, GlobalMap, StorageMap>
make_distributed_property_map(const ProcessGroup& pg, GlobalMap global,
StorageMap storage)
{
typedef distributed_property_map<ProcessGroup, GlobalMap, StorageMap>
result_type;
src/boost/property_map/parallel/impl/distributed_property_map.ipp view on Meta::CPAN
&handle_message::handle_multiget);
simple_trigger(pg, property_map_multiget_reply, this,
&handle_message::handle_multiget_reply);
simple_trigger(pg, property_map_multiput, this,
&handle_message::handle_multiput);
}
template<typename ProcessGroup, typename GlobalMap, typename StorageMap>
void
PBGL_DISTRIB_PMAP
::on_synchronize::operator()()
{
int stage=0; // we only get called at the start now
shared_ptr<data_t> data(data_ptr);
BOOST_ASSERT(data);
// Determine in which stage backward consistency messages should be sent.
int backward_stage = -1;
if (data->model & cm_backward) {
if (data->model & cm_flush) backward_stage = 1;
else backward_stage = 0;
src/boost/property_map/parallel/impl/distributed_property_map.ipp view on Meta::CPAN
}
}
template<typename ProcessGroup, typename GlobalMap, typename StorageMap>
void
PBGL_DISTRIB_PMAP::set_consistency_model(int model)
{
data->model = model;
bool need_on_synchronize = (model != cm_forward);
// Backward consistency is a two-stage process.
if (model & cm_backward) {
// For backward consistency to work, we absolutely cannot throw
// away any ghost cells.
data->max_ghost_cells = 0;
}
// attach the on_synchronize handler.
if (need_on_synchronize)
data->process_group.replace_on_synchronize_handler(on_synchronize(data));
}
template<typename ProcessGroup, typename GlobalMap, typename StorageMap>
void
PBGL_DISTRIB_PMAP::set_max_ghost_cells(std::size_t max_ghost_cells)
{
if ((data->model & cm_backward) && max_ghost_cells > 0)
boost::throw_exception(std::runtime_error("distributed_property_map::set_max_ghost_cells: "
"cannot limit ghost-cell usage with a backward "
"consistency model"));
src/boost/property_map/parallel/impl/distributed_property_map.ipp view on Meta::CPAN
}
// Transmit flushed values
for (int p = 0; p < n; ++p) {
if (!values[p].empty())
send(process_group, p, property_map_multiput, values[p]);
}
}
template<typename ProcessGroup, typename GlobalMap, typename StorageMap>
void PBGL_DISTRIB_PMAP::do_synchronize()
{
if (data->model & cm_backward) {
synchronize(data->process_group);
return;
}
// Request refreshes of the values of our ghost cells
data->refresh_ghost_cells();
// Allows all of the multigets to get to their destinations
synchronize(data->process_group);
// Allows all of the multiget responses to get to their destinations
synchronize(data->process_group);
}
template<typename ProcessGroup, typename GlobalMap, typename StorageMap>
template<typename Resolver>
void PBGL_DISTRIB_PMAP::data_t::do_reset()
{
Resolver* resolver = get_default_value.template target<Resolver>();
BOOST_ASSERT(resolver);
for (iterator i = ghost_cells->begin(); i != ghost_cells->end(); ++i)
src/boost/smart_ptr/detail/atomic_count.hpp view on Meta::CPAN
// Effects: Atomically increments the value of a
// Returns: (long) the new value of a
//
// --a;
//
// Effects: Atomically decrements the value of a
// Returns: (long) the new value of a
//
// Important note: when --a returns zero, it must act as a
// read memory barrier (RMB); i.e. the calling thread must
// have a synchronized view of the memory
//
// On Intel IA-32 (x86) memory is always synchronized, so this
// is not a problem.
//
// On many architectures the atomic instructions already act as
// a memory barrier.
//
// This property is necessary for proper reference counting, since
// a thread can update the contents of a shared object, then
// release its reference, and another thread may immediately
// release the last reference causing object destruction.
//
// The destructor needs to have a synchronized view of the
// object to perform proper cleanup.
//
// Original example by Alexander Terekhov:
//
// Given:
//
// - a mutable shared object OBJ;
// - two threads THREAD1 and THREAD2 each holding
// a private smart_ptr object pointing to that OBJ.
//
// t1: THREAD1 updates OBJ (thread-safe via some synchronization)
// and a few cycles later (after "unlock") destroys smart_ptr;
//
// t2: THREAD2 destroys smart_ptr WITHOUT doing any synchronization
// with respect to shared mutable object OBJ; OBJ destructors
// are called driven by smart_ptr interface...
//
#include <boost/config.hpp>
#include <boost/smart_ptr/detail/sp_has_sync.hpp>
#ifndef BOOST_HAS_THREADS
namespace boost
src/boost/test/impl/execution_monitor.ipp view on Meta::CPAN
case SI_QUEUE:
report_error( execution_exception::system_error,
"signal: sent by sigqueue()" );
break;
case SI_TIMER:
report_error( execution_exception::system_error,
"signal: the expiration of a timer set by timer_settimer()" );
break;
case SI_ASYNCIO:
report_error( execution_exception::system_error,
"signal: generated by the completion of an asynchronous I/O request" );
break;
case SI_MESGQ:
report_error( execution_exception::system_error,
"signal: generated by the the arrival of a message on an empty message queue" );
break;
default:
break;
}
switch( m_sig_info->si_signo ) {
src/boost/test/impl/execution_monitor.ipp view on Meta::CPAN
#if defined(POLL_ERR) && defined(POLL_HUP) && (POLL_ERR - POLL_HUP)
case POLL_HUP:
report_error( execution_exception::system_error,
"device disconnected; band event %d",
(int)m_sig_info->si_band );
break;
#endif
#endif
default:
report_error( execution_exception::system_error,
"signal: SIGPOLL, si_code: %d (asynchronous I/O event occured; band event %d)",
(int)m_sig_info->si_band, m_sig_info->si_code );
break;
}
break;
#endif
case SIGABRT:
report_error( execution_exception::system_error,
"signal: SIGABRT (application abort requested)" );
( run in 0.521 second using v1.01-cache-2.11-cpan-0d8aa00de5b )