#include <physical_region.h>

Inheritance diagram for Legion::PhysicalRegion:

Public Member Functions
	PhysicalRegion (const PhysicalRegion &rhs)

	PhysicalRegion (PhysicalRegion &&rhs) noexcept

PhysicalRegion &	operator= (const PhysicalRegion &rhs)

PhysicalRegion &	operator= (PhysicalRegion &&rhs) noexcept

bool	exists (void) const

bool	operator== (const PhysicalRegion &reg) const

bool	operator!= (const PhysicalRegion &reg) const

bool	operator< (const PhysicalRegion &reg) const

std::size_t	hash (void) const

bool	is_mapped (void) const

void	wait_until_valid (bool silence_warnings=false, const char *warning_string=nullptr)

bool	is_valid (void) const

LogicalRegion	get_logical_region (void) const

PrivilegeMode	get_privilege (void) const

void	get_memories (std::set< Memory > &memories, bool silence_warnings=false, const char *warning_string=nullptr) const

void	get_fields (std::vector< FieldID > &fields) const

template<int DIM, typename COORD_T >
DomainT< DIM, COORD_T >	get_bounds (void) const

template<int DIM, typename COORD_T >
	operator DomainT< DIM, COORD_T > (void) const

template<int DIM, typename COORD_T >
	operator Rect< DIM, COORD_T > (void) const

Protected Member Functions
FRIEND_ALL_RUNTIME_CLASSES	PhysicalRegion (Internal::PhysicalRegionImpl *impl)

Realm::RegionInstance	get_instance_info (PrivilegeMode mode, FieldID fid, size_t field_size, void realm_is, TypeTag type_tag, const char warning_string, bool silence_warnings, bool generic_accessor, bool check_field_size, ReductionOpID redop=0) const

Realm::RegionInstance	get_instance_info (PrivilegeMode mode, const std::vector< PhysicalRegion > &other_regions, FieldID fid, size_t field_size, void realm_is, TypeTag type_tag, const char warning_string, bool silence_warnings, bool generic_accessor, bool check_field_size, bool need_bounds, ReductionOpID redop=0) const

Realm::RegionInstance	get_padding_info (FieldID fid, size_t field_size, Domain inner, Domain &outer, const char warning_string, bool silence_warnings, bool generic_accessor, bool check_field_size) const

void	report_incompatible_accessor (const char *accessor_kind, Realm::RegionInstance instance, FieldID fid) const

void	report_incompatible_multi_accessor (unsigned index, FieldID fid, Realm::RegionInstance inst1, Realm::RegionInstance inst2) const

void	report_colocation_violation (const char *accessor_kind, FieldID fid, Realm::RegionInstance inst1, Realm::RegionInstance inst2, const PhysicalRegion &other, bool reduction=false) const

void	get_bounds (void *realm_is, TypeTag type_tag) const

Static Protected Member Functions
static void	empty_colocation_regions (const char *accessor_kind, FieldID fid, bool reduction=false)

static void	fail_bounds_check (DomainPoint p, FieldID fid, PrivilegeMode mode, bool multi=false)

static void	fail_bounds_check (Domain d, FieldID fid, PrivilegeMode mode, bool multi=false)

static void	fail_privilege_check (DomainPoint p, FieldID fid, PrivilegeMode mode)

static void	fail_privilege_check (Domain d, FieldID fid, PrivilegeMode mode)

static void	fail_padding_check (DomainPoint p, FieldID fid)

static void	fail_nondense_rect (void)

static void	fail_rect_piece (void)

Detailed Description

Physical region objects are used to manage access to the physical instances that hold data. They are lightweight handles that can be stored in data structures and passed by value. They should never escape the context in which they are created.

Member Function Documentation

◆ get_fields()

void Legion::PhysicalRegion::get_fields ( std::vector< FieldID > & fields ) const

Return a list of fields that the physical region contains.

◆ get_logical_region()

LogicalRegion Legion::PhysicalRegion::get_logical_region ( void ) const

Returns: the logical region for this physical region

◆ get_memories()

void Legion::PhysicalRegion::get_memories	(	std::set< Memory > &	memories,
		bool	silence_warnings = `false`,
		const char *	warning_string = `nullptr`
	)		const

Return the memories where the underlying physical instances locate.

◆ get_privilege()

PrivilegeMode Legion::PhysicalRegion::get_privilege ( void ) const

Returns: the privilege mode for this physical region

◆ is_mapped()

bool Legion::PhysicalRegion::is_mapped ( void ) const

Check to see if this represents a mapped physical region.

◆ is_valid()

bool Legion::PhysicalRegion::is_valid ( void ) const

For physical regions returned from inline mappings, this call will query if the instance contains valid data yet.

Returns: whether the region has valid data

◆ wait_until_valid()

void Legion::PhysicalRegion::wait_until_valid	(	bool	silence_warnings = `false`,
		const char *	warning_string = `nullptr`
	)

For physical regions returned as the result of an inline mapping, this call will block until the physical instance has a valid copy of the data. You can silence warnings about this blocking call with the 'silence_warnings' parameter.

The documentation for this class was generated from the following file:

legion/api/physical_region.h

Public Member Functions

Protected Member Functions

Static Protected Member Functions