Realm
A distributed, event-based tasking library
Loading...
Searching...
No Matches
Realm::SparsityMapImpl< N, T > Class Template Reference

#include <sparsity_impl.h>

Inheritance diagram for Realm::SparsityMapImpl< N, T >:
[legend]
Collaboration diagram for Realm::SparsityMapImpl< N, T >:
[legend]

Classes

struct  RemoteSparsityRequest
struct  RemoteSparsityContrib
struct  SetContribCountMessage

Public Member Functions

 SparsityMapImpl (SparsityMap< N, T > _me, NodeSet &subscribers)
 SparsityMapImpl (SparsityMap< N, T > _me, NodeSet &subscribers, SparsityMapCommunicator< N, T > *_sparsity_comm)
Event make_valid (bool precise=true)
void set_contributor_count (int count)
void record_remote_contributor (NodeID contributor)
void contribute_nothing (void)
void contribute_dense_rect_list (const std::vector< Rect< N, T > > &rects, bool disjoint)
void contribute_raw_rects (const Rect< N, T > *rects, size_t count, size_t piece_count, bool disjoint, size_t total_count)
bool add_waiter (PartitioningMicroOp *uop, bool precise)
void remote_data_request (NodeID requestor, bool send_precise, bool send_approx)
void remote_data_reply (NodeID requestor, bool send_precise, bool send_approx)
Public Member Functions inherited from Realm::SparsityMapPublicImpl< N, T >
REALM_PUBLIC_API Event make_valid (bool precise=true)
REALM_PUBLIC_API bool is_valid (bool precise=true)
REALM_PUBLIC_API const std::vector< SparsityMapEntry< N, T > > & get_entries (void)
REALM_PUBLIC_API const std::vector< Rect< N, T > > & get_approx_rects (void)
REALM_PUBLIC_API bool overlaps (SparsityMapPublicImpl< N, T > *other, const Rect< N, T > &bounds, bool approx)
REALM_PUBLIC_API bool compute_covering (const Rect< N, T > &bounds, size_t max_rects, int max_overhead, std::vector< Rect< N, T > > &covering)

Static Public Member Functions

static SparsityMapImpl< N, T > * lookup (SparsityMap< N, T > sparsity)

Public Attributes

SparsityMap< N, T > me

Protected Member Functions

void finalize (void)
Protected Member Functions inherited from Realm::SparsityMapPublicImpl< N, T >
 SparsityMapPublicImpl (void)

Protected Attributes

atomic< int > remaining_contributor_count {0}
atomic< int > total_piece_count {0}
atomic< int > remaining_piece_count {0}
Mutex mutex
std::vector< PartitioningMicroOp * > approx_waiters
std::vector< PartitioningMicroOp * > precise_waiters
bool precise_requested {0}
bool approx_requested {0}
Event precise_ready_event = Event::NO_EVENT
Event approx_ready_event = Event::NO_EVENT
NodeSet remote_precise_waiters
NodeSet remote_approx_waiters
NodeSet & remote_subscribers
size_t sizeof_precise {0}
std::unique_ptr< SparsityMapCommunicator< N, T > > sparsity_comm
Protected Attributes inherited from Realm::SparsityMapPublicImpl< N, T >
atomic< bool > entries_valid {false}
atomic< bool > approx_valid {false}
std::vector< SparsityMapEntry< N, T > > entries
std::vector< Rect< N, T > > approx_rects

Static Protected Attributes

static ActiveMessageHandlerReg< RemoteSparsityRequest > remote_sparsity_request_reg
static ActiveMessageHandlerReg< RemoteSparsityContrib > remote_sparsity_contrib_reg
static ActiveMessageHandlerReg< SetContribCountMessage > set_contrib_count_msg_reg

Detailed Description

template<int N, typename T>
class Realm::SparsityMapImpl< N, T >

SparsityMapImpl is the actual dynamically allocated object that exists on each "interested" node for a given SparsityMap - it inherits from SparsityMapPublicImpl and adds the "private" storage and functionality - this separation is primarily to avoid the installed version of of Realm having to include all the internal .h files. TODO(apryakhin@): Consider doing an doxygen style.

Constructor & Destructor Documentation

◆ SparsityMapImpl() [1/2]

template<int N, typename T>
Realm::SparsityMapImpl< N, T >::SparsityMapImpl ( SparsityMap< N, T > _me,
NodeSet & subscribers )

◆ SparsityMapImpl() [2/2]

template<int N, typename T>
Realm::SparsityMapImpl< N, T >::SparsityMapImpl ( SparsityMap< N, T > _me,
NodeSet & subscribers,
SparsityMapCommunicator< N, T > * _sparsity_comm )

Member Function Documentation

◆ add_waiter()

template<int N, typename T>
bool Realm::SparsityMapImpl< N, T >::add_waiter ( PartitioningMicroOp * uop,
bool precise )

◆ contribute_dense_rect_list()

template<int N, typename T>
void Realm::SparsityMapImpl< N, T >::contribute_dense_rect_list ( const std::vector< Rect< N, T > > & rects,
bool disjoint )

◆ contribute_nothing()

template<int N, typename T>
void Realm::SparsityMapImpl< N, T >::contribute_nothing ( void )

◆ contribute_raw_rects()

template<int N, typename T>
void Realm::SparsityMapImpl< N, T >::contribute_raw_rects ( const Rect< N, T > * rects,
size_t count,
size_t piece_count,
bool disjoint,
size_t total_count )

◆ finalize()

template<int N, typename T>
void Realm::SparsityMapImpl< N, T >::finalize ( void )
protected

◆ lookup()

template<int N, typename T>
SparsityMapImpl< N, T > * Realm::SparsityMapImpl< N, T >::lookup ( SparsityMap< N, T > sparsity)
static

◆ make_valid()

template<int N, typename T>
Event Realm::SparsityMapImpl< N, T >::make_valid ( bool precise = true)

◆ record_remote_contributor()

template<int N, typename T>
void Realm::SparsityMapImpl< N, T >::record_remote_contributor ( NodeID contributor)

◆ remote_data_reply()

template<int N, typename T>
void Realm::SparsityMapImpl< N, T >::remote_data_reply ( NodeID requestor,
bool send_precise,
bool send_approx )

◆ remote_data_request()

template<int N, typename T>
void Realm::SparsityMapImpl< N, T >::remote_data_request ( NodeID requestor,
bool send_precise,
bool send_approx )

◆ set_contributor_count()

template<int N, typename T>
void Realm::SparsityMapImpl< N, T >::set_contributor_count ( int count)

Member Data Documentation

◆ approx_ready_event

template<int N, typename T>
Event Realm::SparsityMapImpl< N, T >::approx_ready_event = Event::NO_EVENT
protected

◆ approx_requested

template<int N, typename T>
bool Realm::SparsityMapImpl< N, T >::approx_requested {0}
protected

◆ approx_waiters

template<int N, typename T>
std::vector<PartitioningMicroOp *> Realm::SparsityMapImpl< N, T >::approx_waiters
protected

◆ me

template<int N, typename T>
SparsityMap<N, T> Realm::SparsityMapImpl< N, T >::me

◆ mutex

template<int N, typename T>
Mutex Realm::SparsityMapImpl< N, T >::mutex
protected

◆ precise_ready_event

template<int N, typename T>
Event Realm::SparsityMapImpl< N, T >::precise_ready_event = Event::NO_EVENT
protected

◆ precise_requested

template<int N, typename T>
bool Realm::SparsityMapImpl< N, T >::precise_requested {0}
protected

◆ precise_waiters

template<int N, typename T>
std::vector<PartitioningMicroOp *> Realm::SparsityMapImpl< N, T >::precise_waiters
protected

◆ remaining_contributor_count

template<int N, typename T>
atomic<int> Realm::SparsityMapImpl< N, T >::remaining_contributor_count {0}
protected

◆ remaining_piece_count

template<int N, typename T>
atomic<int> Realm::SparsityMapImpl< N, T >::remaining_piece_count {0}
protected

◆ remote_approx_waiters

template<int N, typename T>
NodeSet Realm::SparsityMapImpl< N, T >::remote_approx_waiters
protected

◆ remote_precise_waiters

template<int N, typename T>
NodeSet Realm::SparsityMapImpl< N, T >::remote_precise_waiters
protected

◆ remote_sparsity_contrib_reg

template<int N, typename T>
ActiveMessageHandlerReg<RemoteSparsityContrib> Realm::SparsityMapImpl< N, T >::remote_sparsity_contrib_reg
staticprotected

◆ remote_sparsity_request_reg

template<int N, typename T>
ActiveMessageHandlerReg<RemoteSparsityRequest> Realm::SparsityMapImpl< N, T >::remote_sparsity_request_reg
staticprotected

◆ remote_subscribers

template<int N, typename T>
NodeSet& Realm::SparsityMapImpl< N, T >::remote_subscribers
protected

◆ set_contrib_count_msg_reg

template<int N, typename T>
ActiveMessageHandlerReg<SetContribCountMessage> Realm::SparsityMapImpl< N, T >::set_contrib_count_msg_reg
staticprotected

◆ sizeof_precise

template<int N, typename T>
size_t Realm::SparsityMapImpl< N, T >::sizeof_precise {0}
protected

◆ sparsity_comm

template<int N, typename T>
std::unique_ptr<SparsityMapCommunicator<N, T> > Realm::SparsityMapImpl< N, T >::sparsity_comm
protected

◆ total_piece_count

template<int N, typename T>
atomic<int> Realm::SparsityMapImpl< N, T >::total_piece_count {0}
protected

The documentation for this class was generated from the following file:
  • /home/runner/work/realm/realm/realm-src/src/realm/deppart/sparsity_impl.h