Namespaces
namespace	Config

namespace	ControlPort

namespace	Cuda

namespace	DeppartConfig

namespace	DynamicTemplates

namespace	Faults

namespace	GASNetEXHandlers

namespace	HDF5

namespace	Hip

namespace	KokkosInterop

namespace	LLVMJit

namespace	MPI

namespace	Network

namespace	NetworkSegmentInfo

namespace	Numa

namespace	OpenMP

namespace	PieceLayoutTypes

namespace	PieceLookup

namespace	ProcSet

namespace	ProfilingGauges

namespace	ProfilingMeasurements

namespace	Python

namespace	ReductionKernels

namespace	SampleFile

namespace	Serialization

namespace	Threading

namespace	ThreadLocal

namespace	TypeConv

namespace	ucc

namespace	UCP

Classes
class	AccessorRefHelper

class	ActiveMessage

class	ActiveMessageAuto

class	ActiveMessageHandlerReg

class	ActiveMessageHandlerRegBase

struct	ActiveMessageHandlerStats

class	ActiveMessageHandlerTable

class	ActiveMessageImpl

class	AddressList

class	AddressListCursor

class	AddressSplitChannel

class	AddressSplitCommunicator

class	AddressSplitXferDes

class	AddressSplitXferDesBase

struct	AddressSplitXferDesCreateMessage

class	AddressSplitXferDesFactory

class	AffineAccessor

class	AffineLayoutPiece

class	AffineLinearizedIndexSpace

class	AffineTransform

class	ApplicationException

struct	ApproxImageResponseMessage

class	AsyncFileIOContext

class	AsyncMicroOp

class	atomic

class	AutoLock

struct	AutoMessageRegistrar

class	BackgroundWorkItem

class	BackgroundWorkManager

class	Backtrace

class	Barrier

class	BarrierCommunicator

class	BarrierImpl

struct	BarrierTriggerMessage

struct	BarrierTriggerMessageArgs

struct	BarrierTriggerMessageArgsInternal

struct	BarrierTriggerPayload

class	BasicRangeAllocator

struct	bitfield

class	bitpack

class	BooleanCommandLineOption

class	ByFieldMicroOp

class	ByFieldOperation

class	ByteArray

class	ByteArrayRef

class	CachingAllocator

class	CancellationException

struct	CancelOperationMessage

class	Channel

struct	ChannelCopyInfo

class	ChunkedRecycler

class	CircularQueue

class	CircularQueueIterator

class	Clock

class	CodeDescriptor

class	CodeImplementation

class	CodeProperty

class	CodeTranslator

class	CommandLineOption

class	CommandLineParser

class	CompiledInstanceLayout

class	CompletionCallback

class	CompletionCallbackBase

class	CompletionQueue

class	CompQueueImpl

class	ComputeOverlapMicroOp

struct	CopyImplRouter

class	CopyIndirection

class	CopySrcDstField

class	CoreModule

class	CoreModuleConfig

class	CoreReservation

class	CoreReservationParameters

class	CoreReservationSet

class	CoverageCounter

class	CudaArrayLayoutPiece

struct	CudaArrayPieceInfo

class	CustomSerdezUntyped

class	CustomSerdezWrapper

struct	DefaultElementConstructor

class	DeferredConstructor

class	DelayedGaugeAddition

class	DelayedGaugeAdditionImpl

class	DelegatingMutex

class	DenseRectangleList

struct	DestroyLockMessage

class	DifferenceMicroOp

class	DifferenceOperation

class	DiskChannel

class	DiskMemory

class	DiskRequest

class	DiskXferDes

class	DomainTransform

class	Doorbell

class	DoorbellList

class	DummyLock

class	DynamicTable

class	DynamicTableAllocator

class	DynamicTableFreeList

struct	DynamicTableNode

struct	DynamicTableNodeBase

class	empty_span

class	Event

class	EventCommunicator

class	EventImpl

class	EventMerger

class	EventTriggerNotifier

class	EventWaiter

class	ExecutionException

class	ExternalCudaArrayResource

class	ExternalCudaMemoryResource

class	ExternalCudaPinnedHostResource

class	ExternalFileResource

class	ExternalHDF5Resource

class	ExternalHipMemoryResource

class	ExternalHipPinnedHostResource

class	ExternalInstanceResource

class	ExternalMemoryResource

class	FastReservation

struct	FieldBlockBase

class	FieldDataDescriptor

class	FIFOCondVar

class	FIFOMutex

class	FileChannel

class	FileMemory

class	FileRequest

class	FileXferDes

struct	FLDTYPES_AUG

class	FragmentedMessage

struct	FragmentInfo

class	FunctionPointerImplementation

class	FunctionPointerType

class	GASNet1Module

class	GASNetChannel

class	GASNetEXCompleter

class	GASNetEXEvent

class	GASNetEXInjector

class	GASNetEXInternal

class	GASNetEXModule

class	GASNetEXPoller

struct	GASNetEXRDMAInfo

class	GASNetRequest

class	GASNetXferDes

class	GaugeSampleBuffer

class	GaugeSampleBufferImpl

class	GaugeSampler

class	GaugeSamplerImpl

class	GenericAccessor

class	GenEventImpl

class	HardwareTopology
	Represents the topology of the host processor cores and memory. More...

class	HDF5LayoutPiece

struct	HDF5PieceInfo

class	HierarchicalBitMap

class	HybridRectangleList

class	IBMemory

class	ID

class	ImageMicroOp

class	ImageOperation

class	IncomingMessageManager

class	IndexSpace

class	IndexSpaceGeneric

class	IndexSpaceGenericImpl

class	IndexSpaceGenericImplTyped

class	IndexSpaceIterator

class	IndirectionInfo

class	IndirectionInfoBase

class	IndirectionInfoTyped

class	InstanceLayout

class	InstanceLayoutConstraints

class	InstanceLayoutGeneric

class	InstanceLayoutOpaque

class	InstanceLayoutPiece

class	InstanceLayoutPieceBase

struct	InstanceMetadataPrefetchRequest

class	InstancePieceList

class	IntegerCommandLineOption

class	IntegerType

class	IntegerUnitsCommandLineOption

class	InternalTask

class	IntersectionMicroOp

class	IntersectionOperation

class	IntervalTree

class	IntrusiveList

struct	IntrusiveListLink

class	IntrusivePriorityList

struct	IntrusivePriorityListLink

class	KernelCondVar

class	KernelMutex

class	KernelThreadTaskScheduler

class	LinearizedIndexSpace

class	LinearizedIndexSpaceIntfc

class	LLVMIRImplementation

struct	LocalAddress

class	LocalChannel

class	LocalCPUMemory

class	LocalCPUProcessor

class	LocalIOProcessor

class	LocalManagedMemory

class	LocalOpenMPProcessor

class	LocalPythonProcessor

class	LocalTaskProcessor

class	LocalUtilityProcessor

class	LockedMap

struct	LockGrantMessage

struct	LockReleaseMessage

struct	LockRequestMessage

class	Logger

class	LoggerMessage

class	LoggerOutputStream

class	LoopSchedule

class	Machine

struct	MachineAffinityInfo

class	MachineImpl

struct	MachineMemInfo

struct	MachineNodeInfo

struct	MachineProcInfo

class	MachineQueryIterator

struct	Matrix

class	MemcpyChannel

class	MemcpyRequest

class	MemcpyXferDes

class	MemfillChannel

class	MemfillXferDes

class	Memory

class	MemoryHasMemAffinityPredicate

class	MemoryHasProcAffinityPredicate

class	MemoryImpl

class	MemoryQueryImpl

struct	MemPathInfo

class	MemreduceChannel

class	MemreduceXferDes

class	MemSpecificInfo

struct	MemStorageAllocRequest

struct	MemStorageAllocResponse

struct	MemStorageReleaseRequest

struct	MemStorageReleaseResponse

class	MetadataBase

struct	MetadataInvalidateAckMessage

struct	MetadataInvalidateMessage

struct	MetadataRequestMessage

struct	MetadataResponseMessage

class	MethodCommandLineOption

class	Module

class	ModuleConfig

class	ModuleRegistrar

class	ModuleSpecificInfo

class	MPIModule

class	MultiAffineAccessor

class	MutexChecker

class	NetworkModule

class	NetworkSegment

struct	Node

class	NodeSet

class	NodeSetBitmask

class	NodeSetIterator

class	noncopyable

struct	NotifyXferDesCompleteMessage

struct	NT_TemplateHelper

struct	NTF_TemplateHelper

struct	NTNT_TemplateHelper

struct	NumaNodeCpuInfo

struct	NumaNodeMemInfo

struct	NvtxARGB

struct	NvtxCategory

struct	nvtxScopedRange

class	OpaqueType

class	Operation

class	OperationTable

class	OutbufManager

class	OutbufMetadata

class	OutbufUsecountDec

class	OverlapTester

class	OverlapTester< 1, T >

class	PartitioningMicroOp

class	PartitioningOperation

class	PartitioningOpQueue

class	PathLRU

class	PendingCompletion

struct	PendingCompletionGroup

class	PendingCompletionManager

class	PendingIBRequests

struct	PendingPutHeader

struct	PendingReverseGet

struct	Point

class	PointerType

class	PointInRectIterator

class	PoisonedEventException

class	PreimageMicroOp

class	PreimageOperation

struct	PreparedMessage

class	PrettyVector

class	PriorityQueue

class	Processor

class	ProcessorGroup

class	ProcessorGroupImpl

class	ProcessorHasAffinityPredicate

class	ProcessorImpl

class	ProcessorQueryImpl

struct	ProcGroupCreateMessage

struct	ProcGroupDestroyAckMessage

struct	ProcGroupDestroyMessage

class	ProfilingMeasurementCollection

class	ProfilingRequest

class	ProfilingRequestSet

class	ProfilingResponse

class	PythonAPI

class	PythonInterpreter

class	PythonSourceImplementation

class	PythonThreadTaskScheduler

struct	PyThreadState

class	QueryPredicate

class	RealmEntryExitRAII

struct	Rect

struct	ReductionOp

struct	ReductionOpUntyped

class	RegionInstance

class	RegionInstanceImpl

struct	RegisterTaskCompleteMessage

struct	RegisterTaskMessage

struct	RemoteAddress

class	RemoteChannel

class	RemoteChannelInfo

struct	RemoteIBAllocRequestMultiple

struct	RemoteIBAllocRequestSingle

struct	RemoteIBAllocResponseMultiple

struct	RemoteIBAllocResponseSingle

struct	RemoteIBReleaseMultiple

struct	RemoteIBReleaseSingle

class	RemoteMemory

struct	RemoteMicroOpCompleteMessage

struct	RemoteMicroOpMessage

struct	RemoteNotification

class	RemoteProcessor

class	RemoteTaskRegistration

class	RemoteWriteChannel

class	RemoteWriteRequest

class	RemoteWriteXferDes

class	ReplicatedHeap

class	Request

class	Reservation

class	ReservationImpl

class	ReverseGetter

class	Runtime

class	RuntimeImpl

struct	RuntimeShutdownMessage

struct	RuntimeShutdownRequest

class	RWLock

class	SamplingProfiler

class	SamplingProfilerImpl

class	SequenceAssembler

class	SerdezObject

class	SharedMemoryInfo
	Holds a reference to a mapped shared memory region and all the information used to create/open it. Such shared memory region can be shared with other processes on the same system using a communication mechanism such as via unix domain sockets, win32 DuplicateHandle, or if names are used, transferring the names to the processes and opening them (. More...

class	shortstringbuf

class	SimpleRemoteChannelInfo

class	SimpleSerdez

struct	SimpleXferDesCreateMessage

class	SimpleXferDesFactory

class	SingleXDQChannel

class	SizedRangeAllocator

class	span

class	span< T, dynamic_extent >

class	SparsityMap

class	SparsityMapCommunicator

struct	SparsityMapEntry

class	SparsityMapImpl

class	SparsityMapImplWrapper

class	SparsityMapPublicImpl

class	SparsityMapRefCounter

class	SparsityWrapperCommunicator

struct	SpawnTaskMessage

class	stringbuilder

class	StringCommandLineOption

class	StringListCommandLineOption

class	StructuredImageMicroOp

class	StructuredPreimageMicroOp

class	StructuredTransform

class	Subgraph

struct	SubgraphDefinition

struct	SubgraphDestroyMessage

class	SubgraphImpl

struct	SubgraphInstantiateMessage

struct	SubgraphScheduleEntry

class	Task

class	TaskContextManager

class	TaskQueue

class	TaskRegistration

class	Thread

class	ThreadedTaskScheduler

class	ThreadLaunchParameters

class	ThreadPool

class	ThreadScheduler

class	TimeLimit

class	TimeStamp

class	TransferDesc

class	TransferDomain

struct	TransferGraph

class	TransferIterator

class	TransferIteratorBase

class	TransferIteratorIndexSpace

class	TransferIteratorIndirect

class	TransferOperation

class	TranslationTransform

class	Type

class	UCPModule

class	UnfairCondVar

class	UnfairMutex

class	UnionMicroOp

class	UnionOperation

struct	UpdateBytesReadMessage

struct	UpdateBytesTotalMessage

struct	UpdateBytesWriteMessage

class	UserEvent

struct	WrappedWithFragInfo

class	WrappingFIFOIterator

class	XDQueue

class	XferDes

struct	XferDesCreateMessageBase

struct	XferDesDestroyMessage

class	XferDesFactory

class	XferDesPlaceholder

struct	XferDesPortInfo

class	XferDesQueue

struct	XferDesRedopInfo

class	XmitSrc

class	XmitSrcDestPair

Typedefs
template<typename Hdr >
using	DefaultActiveMessageBuilder = ActiveMessage< WrappedWithFragInfo< Hdr > >

typedef int	CustomSerdezID

typedef ::realm_reduction_op_id_t	ReductionOpID

typedef unsigned long long	hdf5_size_t

typedef DynamicTemplates::IntList< 1, REALM_MAX_DIM >	DIMCOUNTS

typedef DynamicTemplates::TypeList< int, unsignedint, longlong >::TL	DIMTYPES

typedef DynamicTemplates::TypeList< int, bool >::TL	FLDTYPES

typedef realm_field_id_t	FieldID

typedef QueryPredicate< Processor, MachineProcInfo >	ProcQueryPredicate

typedef QueryPredicate< Memory, MachineMemInfo >	MemoryQueryPredicate

typedef ::realm_address_space_t	AddressSpace

typedef UnfairMutex	Mutex

typedef int	NodeID

typedef ssize_t	Py_ssize_t

typedef DynamicTableAllocator< GenEventImpl, 11, 16, GenEventImpl::GenEventImplAllocator >	LocalEventTableAllocator

typedef DynamicTableAllocator< GenEventImpl, 10, 7, GenEventImpl::GenEventImplAllocator >	RemoteEventTableAllocator

typedef DynamicTableAllocator< BarrierImpl, 10, 4 >	BarrierTableAllocator

typedef DynamicTableAllocator< ReservationImpl, 10, 8 >	ReservationTableAllocator

typedef DynamicTableAllocator< ProcessorGroupImpl, 10, 4 >	ProcessorGroupTableAllocator

typedef DynamicTableAllocator< SparsityMapImplWrapper, 10, 4 >	SparsityMapTableAllocator

typedef DynamicTableAllocator< CompQueueImpl, 10, 4 >	CompQueueTableAllocator

typedef DynamicTableAllocator< SubgraphImpl, 10, 4 >	SubgraphTableAllocator

using	FieldBlock = FieldBlockBase< int >

typedef unsigned long long	XferDesID

typedef std::map< std::pair< realm_id_t, realm_id_t >, PathLRU * >	PathCache

template<int N, typename T >
using	CopyImplFn = Event()(const IndexSpace< N, T > &, const std::vector< CopySrcDstField > &, const std::vector< CopySrcDstField > &, const std::vector< const typename CopyIndirection< N, T >::Base > &, const Realm::ProfilingRequestSet &, Event, int)

typedef int	OsHandle

Enumerations
enum	{ PAYLOAD_NONE , PAYLOAD_KEEP , PAYLOAD_FREE , PAYLOAD_COPY , PAYLOAD_SRCPTR , PAYLOAD_PENDING , PAYLOAD_KEEPREG , PAYLOAD_EMPTY }

enum	QueryType { QUERY_NEXT = 0 , QUERY_FIRST , QUERY_RANDOM }

enum	NodeAnnounceTag { NODE_ANNOUNCE_INVALID = 0 , NODE_ANNOUNCE_PROC , NODE_ANNOUNCE_MEM , NODE_ANNOUNCE_IB_MEM , NODE_ANNOUNCE_PMA , NODE_ANNOUNCE_DMA_CHANNEL , NODE_ANNOUNCE_PROCESS_INFO }

enum	nvtx_color : uint32_t { white = NvtxARGB(255, 255, 255).to_uint() , red = NvtxARGB(255, 0, 0).to_uint() , green = NvtxARGB(0, 255, 0).to_uint() , blue = NvtxARGB(0, 0, 255).to_uint() , purple = NvtxARGB(128, 0, 128).to_uint() , lawn_green = NvtxARGB(124, 252, 0).to_uint() , cyan = NvtxARGB(0, 255, 255).to_uint() , maroon = NvtxARGB(128, 0, 0).to_uint() , navy = NvtxARGB(0, 0, 128).to_uint() , magenta = NvtxARGB(255, 0, 255).to_uint() , yellow = NvtxARGB(255, 255, 0).to_uint() , gray = NvtxARGB(128, 128, 128).to_uint() , teal = NvtxARGB(0, 128, 128).to_uint() , olive = NvtxARGB(128, 128, 0).to_uint() }

enum	ProfilingMeasurementID { PMID_OP_STATUS , PMID_OP_STATUS_ABNORMAL , PMID_OP_BACKTRACE , PMID_OP_TIMELINE , PMID_OP_EVENT_WAITS , PMID_OP_PROC_USAGE , PMID_OP_MEM_USAGE , PMID_INST_STATUS , PMID_INST_STATUS_ABNORMAL , PMID_INST_ALLOCRESULT , PMID_INST_TIMELINE , PMID_INST_MEM_USAGE , PMID_PCTRS_CACHE_L1I , PMID_PCTRS_CACHE_L1D , PMID_PCTRS_CACHE_L2 , PMID_PCTRS_CACHE_L3 , PMID_PCTRS_IPC , PMID_PCTRS_TLB , PMID_PCTRS_BP , PMID_OP_TIMELINE_GPU , PMID_OP_SUBGRAPH_INFO , PMID_OP_FINISH_EVENT , PMID_OP_COPY_INFO , PMID_REALM_LAST = 10000 }

enum	PyGILState_STATE { PyGILState_LOCKED , PyGILState_UNLOCKED }

enum	XferDesKind

Functions
template<typename S >
bool	serialize (S &serdez, const ByteArrayRef &a)

template<typename S >
bool	serialize (S &serdez, const ByteArray &a)

template<typename S >
bool	deserialize (S &serdez, ByteArray &a)

template<typename S >
bool	serialize (S &serializer, const CodeDescriptor &cd)

template<typename S >
bool	deserialize (S &deserializer, CodeDescriptor &cd)

template<typename S >
bool	serialize (S &serializer, const CodeImplementation &ci)

template<int N, typename T >
std::ostream &	operator<< (std::ostream &os, const DenseRectangleList< N, T > &drl)

template<int N, typename T >
std::ostream &	operator<< (std::ostream &os, const HybridRectangleList< N, T > &hrl)

std::ostream &	operator<< (std::ostream &os, const CopySrcDstField &sd)

template<int N, typename T >
REALM_PUBLIC_API std::ostream &	operator<< (std::ostream &os, const IndexSpace< N, T > &p)

REALM_PUBLIC_API std::ostream &	operator<< (std::ostream &os, const InstanceLayoutGeneric &ilg)

template<int N, typename T >
REALM_PUBLIC_API std::ostream &	operator<< (std::ostream &os, const InstanceLayoutPiece< N, T > &ilp)

template<int N, typename T >
REALM_PUBLIC_API std::ostream &	operator<< (std::ostream &os, const InstancePieceList< N, T > &ipl)

template<typename FT , int N, typename T >
REALM_PUBLIC_API std::ostream &	operator<< (std::ostream &os, const GenericAccessor< FT, N, T > &a)

template<typename FT , int N, typename T >
REALM_PUBLIC_API std::ostream &	operator<< (std::ostream &os, const AffineAccessor< FT, N, T > &a)

template<typename FT , int N, typename T >
REALM_PUBLIC_API std::ostream &	operator<< (std::ostream &os, const MultiAffineAccessor< FT, N, T > &a)

REALM_PUBLIC_API std::ostream &	operator<< (std::ostream &os, RegionInstance r)

template<typename S >
bool	serialize (S &serializer, const ExternalInstanceResource &res)

template<typename T , typename PT , REALM_PMTA_DECL(T, IntrusivePriorityListLink< T >, LINK) , REALM_PMTA_DECL(T, PT, PRI) , typename LT >
std::ostream &	operator<< (std::ostream &os, const IntrusivePriorityList< T, PT, LINK, PRI, LT > &to_print)

MachineImpl *	get_machine (void)

void	cleanup_query_caches ()

std::string	get_shm_name (realm_id_t id)
	Returns the full path for use in SharedMemoryInfo::create and SharedMemoryInfo::open given the realm id.

std::ostream &	operator<< (std::ostream &os, Memory m)

std::ostream &	operator<< (std::ostream &os, Memory::Kind kind)

bool	numasysif_numa_available (void)

bool	numasysif_get_mem_info (std::map< int, NumaNodeMemInfo > &info, bool only_available=true)

bool	numasysif_get_cpu_info (std::map< int, NumaNodeCpuInfo > &info, bool only_available=true)

int	numasysif_get_distance (int node1, int node2)

void *	numasysif_alloc_mem (int node, size_t bytes, bool pin)

bool	numasysif_free_mem (int node, void *base, size_t bytes)

bool	numasysif_bind_mem (int node, void *base, size_t bytes, bool pin)

void	init_nvtx_thread (const char *thread_name)

void	init_nvtx (std::vector< std::string > &nvtx_modules)

void	finalize_nvtx_thread (void)

void	finalize_nvtx (void)

void	nvtx_range_push (NvtxCategory category, const char message, uint32_t color=nvtx_color::white, int32_t payload=0)

void	nvtx_range_push (const std::string &name, const char *message, uint32_t color=nvtx_color::white, int32_t payload=0)

void	nvtx_range_pop (void)

nvtxRangeId_t	nvtx_range_start (NvtxCategory category, const char message, uint32_t color=nvtx_color::white, int32_t payload=0)

nvtxRangeId_t	nvtx_range_start (const std::string &name, const char *message, uint32_t color=nvtx_color::white, int32_t payload=0)

void	nvtx_range_end (nvtxRangeId_t id)

void	nvtx_mark (NvtxCategory category, const char message, uint32_t color=nvtx_color::white, int32_t payload=0)

void	nvtx_mark (const std::string &name, const char *message, uint32_t color=nvtx_color::white, int32_t payload=0)

template<typename T = int, typename... U>
constexpr auto	make_point (const U &...rest) -> Point< sizeof...(rest), T >
	Helper function to initialize Point from a list of types without needing to explicitly specify the dimension or type of the resulting Point.

template<int N, typename T >
std::ostream &	operator<< (std::ostream &os, const Point< N, T > &p)

template<int N, typename T , typename T2 >
REALM_CUDA_HD bool	operator== (const Point< N, T > &lhs, const Point< N, T2 > &rhs)

template<int N, typename T , typename T2 >
REALM_CUDA_HD bool	operator!= (const Point< N, T > &lhs, const Point< N, T2 > &rhs)

template<int N, typename T , typename T2 >
REALM_CUDA_HD Point< N, T >	operator+ (const Point< N, T > &lhs, const Point< N, T2 > &rhs)

template<int N, typename T , typename T2 >
REALM_CUDA_HD Point< N, T > &	operator+= (Point< N, T > &lhs, const Point< N, T2 > &rhs)

template<int N, typename T , typename T2 >
REALM_CUDA_HD Point< N, T >	operator- (const Point< N, T > &lhs, const Point< N, T2 > &rhs)

template<int N, typename T , typename T2 >
REALM_CUDA_HD Point< N, T > &	operator-= (Point< N, T > &lhs, const Point< N, T2 > &rhs)

template<int N, typename T , typename T2 >
REALM_CUDA_HD Point< N, T >	operator* (const Point< N, T > &lhs, const Point< N, T2 > &rhs)

template<int N, typename T , typename T2 >
REALM_CUDA_HD Point< N, T > &	operator*= (Point< N, T > &lhs, const Point< N, T2 > &rhs)

template<int N, typename T , typename T2 >
REALM_CUDA_HD Point< N, T >	operator/ (const Point< N, T > &lhs, const Point< N, T2 > &rhs)

template<int N, typename T , typename T2 >
REALM_CUDA_HD Point< N, T > &	operator/= (Point< N, T > &lhs, const Point< N, T2 > &rhs)

template<int N, typename T , typename T2 >
REALM_CUDA_HD Point< N, T >	operator% (const Point< N, T > &lhs, const Point< N, T2 > &rhs)

template<int N, typename T , typename T2 >
REALM_CUDA_HD Point< N, T > &	operator%= (Point< N, T > &lhs, const Point< N, T2 > &rhs)

template<int N, typename T >
std::ostream &	operator<< (std::ostream &os, const Rect< N, T > &p)

template<int M, int N, typename T >
std::ostream &	operator<< (std::ostream &os, const Matrix< M, N, T > &p)

template<int N, typename T , typename T2 >
REALM_CUDA_HD bool	operator== (const Rect< N, T > &lhs, const Rect< N, T2 > &rhs)

template<int N, typename T , typename T2 >
REALM_CUDA_HD bool	operator!= (const Rect< N, T > &lhs, const Rect< N, T2 > &rhs)

template<int N, typename T , typename T2 >
REALM_CUDA_HD Rect< N, T >	operator+ (const Rect< N, T > &lhs, const Point< N, T2 > &rhs)

template<int N, typename T , typename T2 >
REALM_CUDA_HD Rect< N, T > &	operator+= (Rect< N, T > &lhs, const Point< N, T2 > &rhs)

template<int N, typename T , typename T2 >
REALM_CUDA_HD Rect< N, T >	operator- (const Rect< N, T > &lhs, const Point< N, T2 > &rhs)

template<int N, typename T , typename T2 >
REALM_CUDA_HD Rect< N, T > &	operator-= (Rect< N, T > &lhs, const Rect< N, T2 > &rhs)

template<int M, int N, typename T , typename T2 >
REALM_CUDA_HD Point< M, T >	operator* (const Matrix< M, N, T > &m, const Point< N, T2 > &p)

template<int M, int P, int N, typename T , typename T2 >
REALM_CUDA_HD Matrix< M, N, T >	operator* (const Matrix< M, P, T > &m, const Matrix< P, N, T2 > &n)

template<int M, int N, typename T , typename T2 >
REALM_CUDA_HD bool	operator== (const Matrix< M, N, T > &lhs, const Matrix< M, N, T > &rhs)

template<int M, int N, typename T , typename T2 >
REALM_CUDA_HD bool	operator!= (const Matrix< M, N, T > &lhs, const Matrix< M, N, T > &rhs)

template<typename T , typename LT >
std::ostream &	operator<< (std::ostream &os, const PriorityQueue< T, LT > &pq)

std::ostream &	operator<< (std::ostream &os, Reservation r)

std::ostream &	operator<< (std::ostream &os, const Node &node)

REALM_INTERNAL_API_EXTERNAL_LINKAGE RuntimeImpl *	get_runtime (void)

EventImpl *	get_event_impl (Event e)

GenEventImpl *	get_genevent_impl (Event e)

BarrierImpl *	get_barrier_impl (Event e)

template<int N, typename T >
REALM_PUBLIC_API std::ostream &	operator<< (std::ostream &os, SparsityMap< N, T > s)

template<int N, typename T >
REALM_PUBLIC_API std::ostream &	operator<< (std::ostream &os, const SparsityMapEntry< N, T > &entry)

std::ostream &	operator<< (std::ostream &os, const AddressListCursor &alc)

std::ostream &	operator<< (std::ostream &os, XferDesKind kind)

std::ostream &	operator<< (std::ostream &os, const ChannelCopyInfo &info)

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

std::ostream &	operator<< (std::ostream &os, const Channel::SupportedPath &p)

template<typename S >
bool	serialize (S &serializer, const RemoteChannelInfo &rci)

void	destroy_xfer_des (XferDesID _guid)

void	memcpy_1d (uintptr_t dst_base, uintptr_t src_base, size_t bytes)

void	memcpy_2d (uintptr_t dst_base, uintptr_t dst_lstride, uintptr_t src_base, uintptr_t src_lstride, size_t bytes, size_t lines)

void	memcpy_3d (uintptr_t dst_base, uintptr_t dst_lstride, uintptr_t dst_pstride, uintptr_t src_base, uintptr_t src_lstride, uintptr_t src_pstride, size_t bytes, size_t lines, size_t planes)

void	memset_1d (uintptr_t dst_base, size_t bytes, const void *fill_data, size_t fill_size)

void	memset_2d (uintptr_t dst_base, uintptr_t dst_lstride, size_t bytes, size_t lines, const void *fill_data, size_t fill_size)

void	memset_3d (uintptr_t dst_base, uintptr_t dst_lstride, uintptr_t dst_pstride, size_t bytes, size_t lines, size_t planes, const void *fill_data, size_t fill_size)

void	enumerate_local_cpu_memories (const Node *node, std::vector< Memory > &mems)

void	free_intermediate_buffer (Memory mem, off_t offset, size_t size)

void	init_dma_handler (void)

void	start_dma_system (BackgroundWorkManager *bgwork)

void	stop_dma_system (void)

void	init_path_cache (void)

void	finalize_path_cache (void)

bool	find_shortest_path (const Node *nodes_info, Memory src_mem, Memory dst_mem, CustomSerdezID serdez_id, ReductionOpID redop_id, MemPathInfo &info, bool skip_final_memcpy=false)

bool	find_best_channel_for_memories (const Node nodes_info, ChannelCopyInfo channel_copy_info, CustomSerdezID src_serdez_id, CustomSerdezID dst_serdez_id, ReductionOpID redop_id, size_t total_bytes, const std::vector< size_t > src_frags, const std::vector< size_t > dst_frags, uint64_t &best_cost, Channel &best_channel, XferDesKind &best_kind)

bool	find_fastest_path (const Node nodes_info, PathCache &path_cache, ChannelCopyInfo channel_copy_info, CustomSerdezID serdez_id, ReductionOpID redop_id, size_t total_bytes, const std::vector< size_t > src_frags, const std::vector< size_t > *dst_frags, MemPathInfo &info, bool skip_final_memcpy=false)

std::ostream &	operator<< (std::ostream &os, const IndirectionInfo &ii)

template<int N, typename T >
bool	next_subrect (const Rect< N, T > &domain, const Point< N, T > &start, const Rect< N, T > &restriction, const int *dim_order, Rect< N, T > &subrect, Point< N, T > &next_start)

template<int N, typename T >
bool	compute_target_subrect (const Rect< N, T > &layout_bounds, const Rect< N, T > &cur_rect, Point< N, T > &cur_point, Rect< N, T > &target_subrect, const int *dim_order)

template<int N, typename T >
int	compact_affine_dims (const AffineLayoutPiece< N, T > *affine, const Rect< N, T > &subrect, const int dim_order[N], size_t field_size, size_t &total_bytes, size_t &contig_bytes, std::unordered_map< int, std::pair< size_t, size_t > > &count_strides)
	Computes compact affine addressing information for a subrectangle.

constexpr uint64_t	hash_fnv1a (const char *s, size_t n, const uint64_t value=0xcbf29ce484222325ULL) noexcept

constexpr size_t	hash_combine (size_t lhs, size_t rhs) noexcept

template<typename T >
void	delete_container_contents (std::vector< T * > &v, bool clear_cont=true)

template<typename K , typename V >
void	delete_container_contents (std::map< K, V * > &m, bool clear_cont=true)

template<typename K , typename V >
void	delete_container_contents_free (std::map< K, V * > &m, bool clear_cont=true)

template<typename T , typename T2 >
T	checked_cast (T2 *ptr)

template<typename T >
std::ostream &	operator<< (std::ostream &os, const PrettyVector< T > &pv)

template<typename T >
span< T, dynamic_extent >	make_span (T *base, size_t length)

REALM_PUBLIC_API uint32_t	crc32c_accumulate (uint32_t accum_in, const void *data, size_t len)

template<typename T >
void	call_destructor (T *obj)

REALM_PUBLIC_API const char *	realm_strerror (int err)

unsigned	ctz (uint64_t v)

OsHandle	ipc_mailbox_create (const std::string &name)
	Creates an ipc mailbox useful for sending and receiving other OSHandles between ranks on the same physical node.

bool	ipc_mailbox_send (OsHandle mailbox, const std::string &to, const std::vector< OsHandle > &handles, const void *data, size_t data_sz)
	Send the `handles` and `data` given via the `mailbox` created by ipc_mailbox_create to the receiving mailbox given by `to`.

bool	ipc_mailbox_recv (OsHandle mailbox, const std::string &from, std::vector< OsHandle > &handles, void *data, size_t &data_sz, size_t max_data_sz)
	Receive in `handles` and `data` via the `mailbox` created by ipc_mailbox_create from the sending mailbox given by `from`.

void	close_handle (OsHandle handle)
	Close the given OS handle.

Variables
ActiveMessageHandlerTable	activemsg_handler_table

Logger	log_poison

gex_wrapper_handle_t	gex_wrapper_handle

MachineImpl *	machine_singleton

REALM_INTERNAL_API_EXTERNAL_LINKAGE RuntimeImpl *	runtime_singleton

Logger	log_new_dma

const size_t	dynamic_extent = size_t(-1)

Typedef Documentation

◆ AddressSpace

typedef::realm_address_space_t Realm::AddressSpace

◆ BarrierTableAllocator

typedef DynamicTableAllocator<BarrierImpl, 10, 4> Realm::BarrierTableAllocator

◆ CompQueueTableAllocator

typedef DynamicTableAllocator<CompQueueImpl, 10, 4> Realm::CompQueueTableAllocator

◆ CopyImplFn

template<int N, typename T >

using Realm::CopyImplFn = typedef Event (*)(const IndexSpace<N, T> &, const std::vector<CopySrcDstField> &, const std::vector<CopySrcDstField> &, const std::vector<const typename CopyIndirection<N, T>::Base *> &, const Realm::ProfilingRequestSet &, Event, int)

◆ CustomSerdezID

typedef int Realm::CustomSerdezID

◆ DefaultActiveMessageBuilder

template<typename Hdr >

using Realm::DefaultActiveMessageBuilder = typedef ActiveMessage<WrappedWithFragInfo<Hdr> >

◆ DIMCOUNTS

typedef DynamicTemplates::IntList<1, REALM_MAX_DIM> Realm::DIMCOUNTS

◆ DIMTYPES

typedef DynamicTemplates::TypeList<int,unsignedint,longlong>::TL Realm::DIMTYPES

◆ FieldBlock

using Realm::FieldBlock = typedef FieldBlockBase<int>

◆ FieldID

typedef realm_field_id_t Realm::FieldID

◆ FLDTYPES

typedef DynamicTemplates::TypeList<int,bool>::TL Realm::FLDTYPES

◆ hdf5_size_t

typedef unsigned long long Realm::hdf5_size_t

◆ LocalEventTableAllocator

typedef DynamicTableAllocator<GenEventImpl, 11, 16, GenEventImpl::GenEventImplAllocator> Realm::LocalEventTableAllocator

◆ MemoryQueryPredicate

typedef QueryPredicate<Memory, MachineMemInfo> Realm::MemoryQueryPredicate

◆ Mutex

typedef UnfairMutex Realm::Mutex

◆ NodeID

typedef int Realm::NodeID

◆ OsHandle

typedef int Realm::OsHandle

◆ PathCache

typedef std::map<std::pair<realm_id_t, realm_id_t>, PathLRU *> Realm::PathCache

◆ ProcessorGroupTableAllocator

typedef DynamicTableAllocator<ProcessorGroupImpl, 10, 4> Realm::ProcessorGroupTableAllocator

◆ ProcQueryPredicate

typedef QueryPredicate<Processor, MachineProcInfo> Realm::ProcQueryPredicate

◆ Py_ssize_t

typedef ssize_t Realm::Py_ssize_t

◆ ReductionOpID

typedef ::realm_reduction_op_id_t Realm::ReductionOpID

◆ RemoteEventTableAllocator

typedef DynamicTableAllocator<GenEventImpl, 10, 7, GenEventImpl::GenEventImplAllocator> Realm::RemoteEventTableAllocator

◆ ReservationTableAllocator

typedef DynamicTableAllocator<ReservationImpl, 10, 8> Realm::ReservationTableAllocator

◆ SparsityMapTableAllocator

typedef DynamicTableAllocator<SparsityMapImplWrapper, 10, 4> Realm::SparsityMapTableAllocator

◆ SubgraphTableAllocator

typedef DynamicTableAllocator<SubgraphImpl, 10, 4> Realm::SubgraphTableAllocator

◆ XferDesID

typedef unsigned long long Realm::XferDesID

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
PAYLOAD_NONE
PAYLOAD_KEEP
PAYLOAD_FREE
PAYLOAD_COPY
PAYLOAD_SRCPTR
PAYLOAD_PENDING
PAYLOAD_KEEPREG
PAYLOAD_EMPTY

◆ NodeAnnounceTag

enum Realm::NodeAnnounceTag

Enumerator
NODE_ANNOUNCE_INVALID
NODE_ANNOUNCE_PROC
NODE_ANNOUNCE_MEM
NODE_ANNOUNCE_IB_MEM
NODE_ANNOUNCE_PMA
NODE_ANNOUNCE_DMA_CHANNEL
NODE_ANNOUNCE_PROCESS_INFO

◆ nvtx_color

enum Realm::nvtx_color : uint32_t

Enumerator
white
red
green
blue
purple
lawn_green
cyan
maroon
navy
magenta
yellow
gray
teal
olive

◆ ProfilingMeasurementID

enum Realm::ProfilingMeasurementID

Enumerator
PMID_OP_STATUS
PMID_OP_STATUS_ABNORMAL
PMID_OP_BACKTRACE
PMID_OP_TIMELINE
PMID_OP_EVENT_WAITS
PMID_OP_PROC_USAGE
PMID_OP_MEM_USAGE
PMID_INST_STATUS
PMID_INST_STATUS_ABNORMAL
PMID_INST_ALLOCRESULT
PMID_INST_TIMELINE
PMID_INST_MEM_USAGE
PMID_PCTRS_CACHE_L1I
PMID_PCTRS_CACHE_L1D
PMID_PCTRS_CACHE_L2
PMID_PCTRS_CACHE_L3
PMID_PCTRS_IPC
PMID_PCTRS_TLB
PMID_PCTRS_BP
PMID_OP_TIMELINE_GPU
PMID_OP_SUBGRAPH_INFO
PMID_OP_FINISH_EVENT
PMID_OP_COPY_INFO
PMID_REALM_LAST

◆ PyGILState_STATE

enum Realm::PyGILState_STATE

Enumerator
PyGILState_LOCKED
PyGILState_UNLOCKED

◆ QueryType

enum Realm::QueryType

Enumerator
QUERY_NEXT
QUERY_FIRST
QUERY_RANDOM

◆ XferDesKind

enum Realm::XferDesKind

Function Documentation

◆ call_destructor()

template<typename T >

void Realm::call_destructor ( T * obj )

◆ checked_cast()

template<typename T , typename T2 >

T Realm::checked_cast ( T2 * ptr )

inline

◆ cleanup_query_caches()

void Realm::cleanup_query_caches ( )

extern

◆ close_handle()

void Realm::close_handle ( OsHandle handle )

Close the given OS handle.

Parameters

handle

◆ compact_affine_dims()

template<int N, typename T >

int Realm::compact_affine_dims	(	const AffineLayoutPiece< N, T > *	affine,
		const Rect< N, T > &	subrect,
		const int	dim_order[N],
		size_t	field_size,
		size_t &	total_bytes,
		size_t &	contig_bytes,
		std::unordered_map< int, std::pair< size_t, size_t > > &	count_strides
	)

inline

Computes compact affine addressing information for a subrectangle.

Given an affine layout piece and a target subrectangle, this function determines the base offset, total number of bytes, and dimension stride/count pairs for efficient memory access. It compactly represents contiguous dimensions and generates stride-based indexing information for the remaining ones.

Template Parameters

N	Number of dimensions in the layout.
T	Coordinate type (e.g., int, long).

Parameters

	affine	Pointer to the affine layout piece being queried.
	subrect	Subrectangle to compute addressing for.
	dim_order	Ordering of dimensions to compact/iterate over.
[out]	total_bytes	Total bytes represented by the subrect.
[out]	contig_bytes	Number of contiguous bytes in the compacted dimensions.
[out]	count_strides	Output stride/count pairs indexed by dimension. count_strides[i][0] = count, count_strides[i][1] = stride.

◆ compute_target_subrect()

template<int N, typename T >

bool Realm::compute_target_subrect	(	const Rect< N, T > &	layout_bounds,
		const Rect< N, T > &	cur_rect,
		Point< N, T > &	cur_point,
		Rect< N, T > &	target_subrect,
		const int *	dim_order
	)

Computes an intersection between cur_rect and a given layout bounds starting from cur_point. Can be used iteratively to walk over the layout bounds.

Parameters

layout_bounds	- boundaries of the source data layout
cur_rect	- rectangle used to interesect with boundaries
cur_point	- starting point inside cur_rect
target_subrect	- the result of an intersection
dim_order	- dimension order of the source layout bounds

Returns: true if target subrectangle was successfully computed

◆ crc32c_accumulate()

REALM_PUBLIC_API uint32_t Realm::crc32c_accumulate	(	uint32_t	accum_in,
		const void *	data,
		size_t	len
	)

◆ ctz()

unsigned Realm::ctz ( uint64_t v )

◆ delete_container_contents() [1/2]

template<typename K , typename V >

void Realm::delete_container_contents	(	std::map< K, V * > &	m,
		bool	clear_cont = `true`
	)

◆ delete_container_contents() [2/2]

template<typename T >

void Realm::delete_container_contents	(	std::vector< T * > &	v,
		bool	clear_cont = `true`
	)

◆ delete_container_contents_free()

template<typename K , typename V >

void Realm::delete_container_contents_free	(	std::map< K, V * > &	m,
		bool	clear_cont = `true`
	)

◆ deserialize() [1/2]

template<typename S >

bool Realm::deserialize	(	S &	deserializer,
		CodeDescriptor &	cd
	)

◆ deserialize() [2/2]

template<typename S >

bool Realm::deserialize	(	S &	serdez,
		ByteArray &	a
	)

◆ destroy_xfer_des()

void Realm::destroy_xfer_des ( XferDesID _guid )

◆ enumerate_local_cpu_memories()

void Realm::enumerate_local_cpu_memories	(	const Node *	node,
		std::vector< Memory > &	mems
	)

◆ finalize_nvtx()

void Realm::finalize_nvtx ( void )

◆ finalize_nvtx_thread()

void Realm::finalize_nvtx_thread ( void )

◆ finalize_path_cache()

void Realm::finalize_path_cache ( void )

extern

◆ find_best_channel_for_memories()

bool Realm::find_best_channel_for_memories	(	const Node *	nodes_info,
		ChannelCopyInfo	channel_copy_info,
		CustomSerdezID	src_serdez_id,
		CustomSerdezID	dst_serdez_id,
		ReductionOpID	redop_id,
		size_t	total_bytes,
		const std::vector< size_t > *	src_frags,
		const std::vector< size_t > *	dst_frags,
		uint64_t &	best_cost,
		Channel *&	best_channel,
		XferDesKind &	best_kind
	)

◆ find_fastest_path()

bool Realm::find_fastest_path	(	const Node *	nodes_info,
		PathCache &	path_cache,
		ChannelCopyInfo	channel_copy_info,
		CustomSerdezID	serdez_id,
		ReductionOpID	redop_id,
		size_t	total_bytes,
		const std::vector< size_t > *	src_frags,
		const std::vector< size_t > *	dst_frags,
		MemPathInfo &	info,
		bool	skip_final_memcpy = `false`
	)

◆ find_shortest_path()

bool Realm::find_shortest_path	(	const Node *	nodes_info,
		Memory	src_mem,
		Memory	dst_mem,
		CustomSerdezID	serdez_id,
		ReductionOpID	redop_id,
		MemPathInfo &	info,
		bool	skip_final_memcpy = `false`
	)

◆ free_intermediate_buffer()

void Realm::free_intermediate_buffer	(	Memory	mem,
		off_t	offset,
		size_t	size
	)

◆ get_barrier_impl()

BarrierImpl * Realm::get_barrier_impl ( Event e )

inline

◆ get_event_impl()

EventImpl * Realm::get_event_impl ( Event e )

inline

◆ get_genevent_impl()

GenEventImpl * Realm::get_genevent_impl ( Event e )

inline

◆ get_machine()

MachineImpl * Realm::get_machine ( void )

inline

◆ get_runtime()

REALM_INTERNAL_API_EXTERNAL_LINKAGE RuntimeImpl * Realm::get_runtime ( void )

inline

◆ get_shm_name()

std::string Realm::get_shm_name ( realm_id_t id )

Returns the full path for use in SharedMemoryInfo::create and SharedMemoryInfo::open given the realm id.

Parameters

id	identifier of the realm object to get the name of

Returns: shared memory name of the requested object

◆ hash_combine()

constexpr size_t Realm::hash_combine	(	size_t	lhs,
		size_t	rhs
	)

constexprnoexcept

◆ hash_fnv1a()

constexpr uint64_t Realm::hash_fnv1a	(	const char *	s,
		size_t	n,
		const uint64_t	value = `0xcbf29ce484222325ULL`
	)

constexprnoexcept

◆ init_dma_handler()

void Realm::init_dma_handler ( void )

extern

◆ init_nvtx()

void Realm::init_nvtx ( std::vector< std::string > & nvtx_modules )

◆ init_nvtx_thread()

void Realm::init_nvtx_thread ( const char * thread_name )

◆ init_path_cache()

void Realm::init_path_cache ( void )

extern

◆ ipc_mailbox_create()

OsHandle Realm::ipc_mailbox_create ( const std::string & name )

Creates an ipc mailbox useful for sending and receiving other OSHandles between ranks on the same physical node.

Parameters

name	Name of the mailbox that acts as the endpoint address for other ranks to access

Returns: A valid OS handle it successful, Realm::INVALID_OS_HANDLE if not

◆ ipc_mailbox_recv()

bool Realm::ipc_mailbox_recv	(	OsHandle	mailbox,
		const std::string &	from,
		std::vector< OsHandle > &	handles,
		void *	data,
		size_t &	data_sz,
		size_t	max_data_sz
	)

Receive in handles and data via the mailbox created by ipc_mailbox_create from the sending mailbox given by from.

Parameters

	mailbox	Mailbox created via ipc_mailbox_create
	from	Name of the mailbox to receive from
[out]	handles	OS handles to receive from
[out]	data	Bytes recieved from
[out]	data_sz	Length of data in bytes received
	max_data_sz	Maximum length of `data` that can be received. If the incoming message is larger, this function will fail (return false)

Returns: True if successful, false otherwise

◆ ipc_mailbox_send()

bool Realm::ipc_mailbox_send	(	OsHandle	mailbox,
		const std::string &	to,
		const std::vector< OsHandle > &	handles,
		const void *	data,
		size_t	data_sz
	)

Send the handles and data given via the mailbox created by ipc_mailbox_create to the receiving mailbox given by to.

Parameters

mailbox	Mailbox created via ipc_mailbox_create
to	Name of the mailbox to send to
handles	OS handles to send to the receiver. These will have different "values" in the receiver, but will map to the same resource
data	Bytes to send to receiver
data_sz	Length of `data` to send to receiver

Returns: True if successful, false otherwise

◆ make_point()

template<typename T = int, typename... U>

constexpr auto Realm::make_point ( const U &... rest ) -> Point<sizeof...(rest), T>

constexpr

Helper function to initialize Point from a list of types without needing to explicitly specify the dimension or type of the resulting Point.

◆ make_span()

template<typename T >

span< T, dynamic_extent > Realm::make_span	(	T *	base,
		size_t	length
	)

◆ memcpy_1d()

void Realm::memcpy_1d	(	uintptr_t	dst_base,
		uintptr_t	src_base,
		size_t	bytes
	)

◆ memcpy_2d()

void Realm::memcpy_2d	(	uintptr_t	dst_base,
		uintptr_t	dst_lstride,
		uintptr_t	src_base,
		uintptr_t	src_lstride,
		size_t	bytes,
		size_t	lines
	)

◆ memcpy_3d()

void Realm::memcpy_3d	(	uintptr_t	dst_base,
		uintptr_t	dst_lstride,
		uintptr_t	dst_pstride,
		uintptr_t	src_base,
		uintptr_t	src_lstride,
		uintptr_t	src_pstride,
		size_t	bytes,
		size_t	lines,
		size_t	planes
	)

◆ memset_1d()

void Realm::memset_1d	(	uintptr_t	dst_base,
		size_t	bytes,
		const void *	fill_data,
		size_t	fill_size
	)

◆ memset_2d()

void Realm::memset_2d	(	uintptr_t	dst_base,
		uintptr_t	dst_lstride,
		size_t	bytes,
		size_t	lines,
		const void *	fill_data,
		size_t	fill_size
	)

◆ memset_3d()

void Realm::memset_3d	(	uintptr_t	dst_base,
		uintptr_t	dst_lstride,
		uintptr_t	dst_pstride,
		size_t	bytes,
		size_t	lines,
		size_t	planes,
		const void *	fill_data,
		size_t	fill_size
	)

◆ next_subrect()

template<int N, typename T >

bool Realm::next_subrect	(	const Rect< N, T > &	domain,
		const Point< N, T > &	start,
		const Rect< N, T > &	restriction,
		const int *	dim_order,
		Rect< N, T > &	subrect,
		Point< N, T > &	next_start
	)

◆ numasysif_alloc_mem()

void * Realm::numasysif_alloc_mem	(	int	node,
		size_t	bytes,
		bool	pin
	)

◆ numasysif_bind_mem()

bool Realm::numasysif_bind_mem	(	int	node,
		void *	base,
		size_t	bytes,
		bool	pin
	)

◆ numasysif_free_mem()

bool Realm::numasysif_free_mem	(	int	node,
		void *	base,
		size_t	bytes
	)

◆ numasysif_get_cpu_info()

bool Realm::numasysif_get_cpu_info	(	std::map< int, NumaNodeCpuInfo > &	info,
		bool	only_available = `true`
	)

◆ numasysif_get_distance()

int Realm::numasysif_get_distance	(	int	node1,
		int	node2
	)

◆ numasysif_get_mem_info()

bool Realm::numasysif_get_mem_info	(	std::map< int, NumaNodeMemInfo > &	info,
		bool	only_available = `true`
	)

◆ numasysif_numa_available()

bool Realm::numasysif_numa_available ( void )

◆ nvtx_mark() [1/2]

void Realm::nvtx_mark	(	const std::string &	name,
		const char *	message,
		uint32_t	color = `nvtx_color::white`,
		int32_t	payload = `0`
	)

◆ nvtx_mark() [2/2]

void Realm::nvtx_mark	(	NvtxCategory *	category,
		const char *	message,
		uint32_t	color = `nvtx_color::white`,
		int32_t	payload = `0`
	)

◆ nvtx_range_end()

void Realm::nvtx_range_end ( nvtxRangeId_t id )

◆ nvtx_range_pop()

void Realm::nvtx_range_pop ( void )

◆ nvtx_range_push() [1/2]

void Realm::nvtx_range_push	(	const std::string &	name,
		const char *	message,
		uint32_t	color = `nvtx_color::white`,
		int32_t	payload = `0`
	)

◆ nvtx_range_push() [2/2]

void Realm::nvtx_range_push	(	NvtxCategory *	category,
		const char *	message,
		uint32_t	color = `nvtx_color::white`,
		int32_t	payload = `0`
	)

◆ nvtx_range_start() [1/2]

nvtxRangeId_t Realm::nvtx_range_start	(	const std::string &	name,
		const char *	message,
		uint32_t	color = `nvtx_color::white`,
		int32_t	payload = `0`
	)

◆ nvtx_range_start() [2/2]

nvtxRangeId_t Realm::nvtx_range_start	(	NvtxCategory *	category,
		const char *	message,
		uint32_t	color = `nvtx_color::white`,
		int32_t	payload = `0`
	)

◆ operator!=() [1/3]

template<int M, int N, typename T , typename T2 >

REALM_CUDA_HD bool Realm::operator!=	(	const Matrix< M, N, T > &	lhs,
		const Matrix< M, N, T > &	rhs
	)

◆ operator!=() [2/3]

template<int N, typename T , typename T2 >

REALM_CUDA_HD bool Realm::operator!=	(	const Point< N, T > &	lhs,
		const Point< N, T2 > &	rhs
	)

◆ operator!=() [3/3]

template<int N, typename T , typename T2 >

REALM_CUDA_HD bool Realm::operator!=	(	const Rect< N, T > &	lhs,
		const Rect< N, T2 > &	rhs
	)

◆ operator%()

template<int N, typename T , typename T2 >

REALM_CUDA_HD Point< N, T > Realm::operator%	(	const Point< N, T > &	lhs,
		const Point< N, T2 > &	rhs
	)

◆ operator%=()

template<int N, typename T , typename T2 >

REALM_CUDA_HD Point< N, T > & Realm::operator%=	(	Point< N, T > &	lhs,
		const Point< N, T2 > &	rhs
	)

◆ operator*() [1/3]

template<int M, int N, typename T , typename T2 >

REALM_CUDA_HD Point< M, T > Realm::operator*	(	const Matrix< M, N, T > &	m,
		const Point< N, T2 > &	p
	)

◆ operator*() [2/3]

template<int M, int P, int N, typename T , typename T2 >

REALM_CUDA_HD Matrix< M, N, T > Realm::operator*	(	const Matrix< M, P, T > &	m,
		const Matrix< P, N, T2 > &	n
	)

◆ operator*() [3/3]

template<int N, typename T , typename T2 >

REALM_CUDA_HD Point< N, T > Realm::operator*	(	const Point< N, T > &	lhs,
		const Point< N, T2 > &	rhs
	)

◆ operator*=()

template<int N, typename T , typename T2 >

REALM_CUDA_HD Point< N, T > & Realm::operator*=	(	Point< N, T > &	lhs,
		const Point< N, T2 > &	rhs
	)

◆ operator+() [1/2]

template<int N, typename T , typename T2 >

REALM_CUDA_HD Point< N, T > Realm::operator+	(	const Point< N, T > &	lhs,
		const Point< N, T2 > &	rhs
	)

◆ operator+() [2/2]

template<int N, typename T , typename T2 >

REALM_CUDA_HD Rect< N, T > Realm::operator+	(	const Rect< N, T > &	lhs,
		const Point< N, T2 > &	rhs
	)

◆ operator+=() [1/2]

template<int N, typename T , typename T2 >

REALM_CUDA_HD Point< N, T > & Realm::operator+=	(	Point< N, T > &	lhs,
		const Point< N, T2 > &	rhs
	)

◆ operator+=() [2/2]

template<int N, typename T , typename T2 >

REALM_CUDA_HD Rect< N, T > & Realm::operator+=	(	Rect< N, T > &	lhs,
		const Point< N, T2 > &	rhs
	)

◆ operator-() [1/2]

template<int N, typename T , typename T2 >

REALM_CUDA_HD Point< N, T > Realm::operator-	(	const Point< N, T > &	lhs,
		const Point< N, T2 > &	rhs
	)

◆ operator-() [2/2]

template<int N, typename T , typename T2 >

REALM_CUDA_HD Rect< N, T > Realm::operator-	(	const Rect< N, T > &	lhs,
		const Point< N, T2 > &	rhs
	)

◆ operator-=() [1/2]

template<int N, typename T , typename T2 >

REALM_CUDA_HD Point< N, T > & Realm::operator-=	(	Point< N, T > &	lhs,
		const Point< N, T2 > &	rhs
	)

◆ operator-=() [2/2]

template<int N, typename T , typename T2 >

REALM_CUDA_HD Rect< N, T > & Realm::operator-=	(	Rect< N, T > &	lhs,
		const Rect< N, T2 > &	rhs
	)

◆ operator/()

template<int N, typename T , typename T2 >

REALM_CUDA_HD Point< N, T > Realm::operator/	(	const Point< N, T > &	lhs,
		const Point< N, T2 > &	rhs
	)

◆ operator/=()

template<int N, typename T , typename T2 >

REALM_CUDA_HD Point< N, T > & Realm::operator/=	(	Point< N, T > &	lhs,
		const Point< N, T2 > &	rhs
	)

◆ operator<<() [1/28]

std::ostream & Realm::operator<<	(	std::ostream &	os,
		const AddressListCursor &	alc
	)

◆ operator<<() [2/28]

template<typename FT , int N, typename T >

REALM_PUBLIC_API std::ostream & Realm::operator<<	(	std::ostream &	os,
		const AffineAccessor< FT, N, T > &	a
	)

◆ operator<<() [3/28]

std::ostream & Realm::operator<<	(	std::ostream &	os,
		const Channel::SupportedPath &	p
	)

◆ operator<<() [4/28]

std::ostream & Realm::operator<<	(	std::ostream &	os,
		const ChannelCopyInfo &	info
	)

◆ operator<<() [5/28]

std::ostream & Realm::operator<<	(	std::ostream &	os,
		const CopySrcDstField &	sd
	)

◆ operator<<() [6/28]

template<int N, typename T >

std::ostream & Realm::operator<<	(	std::ostream &	os,
		const DenseRectangleList< N, T > &	drl
	)

◆ operator<<() [7/28]

template<typename FT , int N, typename T >

REALM_PUBLIC_API std::ostream & Realm::operator<<	(	std::ostream &	os,
		const GenericAccessor< FT, N, T > &	a
	)

◆ operator<<() [8/28]

template<int N, typename T >

std::ostream & Realm::operator<<	(	std::ostream &	os,
		const HybridRectangleList< N, T > &	hrl
	)

◆ operator<<() [9/28]

template<int N, typename T >

REALM_PUBLIC_API std::ostream & Realm::operator<<	(	std::ostream &	os,
		const IndexSpace< N, T > &	p
	)

◆ operator<<() [10/28]

std::ostream & Realm::operator<<	(	std::ostream &	os,
		const IndirectionInfo &	ii
	)

◆ operator<<() [11/28]

REALM_PUBLIC_API std::ostream & Realm::operator<<	(	std::ostream &	os,
		const InstanceLayoutGeneric &	ilg
	)

◆ operator<<() [12/28]

template<int N, typename T >

REALM_PUBLIC_API std::ostream & Realm::operator<<	(	std::ostream &	os,
		const InstanceLayoutPiece< N, T > &	ilp
	)

◆ operator<<() [13/28]

template<int N, typename T >

REALM_PUBLIC_API std::ostream & Realm::operator<<	(	std::ostream &	os,
		const InstancePieceList< N, T > &	ipl
	)

◆ operator<<() [14/28]

template<typename T , typename PT , REALM_PMTA_DECL(T, IntrusivePriorityListLink< T >, LINK) , REALM_PMTA_DECL(T, PT, PRI) , typename LT >

std::ostream & Realm::operator<<	(	std::ostream &	os,
		const IntrusivePriorityList< T, PT, LINK, PRI, LT > &	to_print
	)

◆ operator<<() [15/28]

template<int M, int N, typename T >

std::ostream & Realm::operator<<	(	std::ostream &	os,
		const Matrix< M, N, T > &	p
	)

◆ operator<<() [16/28]

template<typename FT , int N, typename T >

REALM_PUBLIC_API std::ostream & Realm::operator<<	(	std::ostream &	os,
		const MultiAffineAccessor< FT, N, T > &	a
	)

◆ operator<<() [17/28]

std::ostream & Realm::operator<<	(	std::ostream &	os,
		const Node &	node
	)

◆ operator<<() [18/28]

template<int N, typename T >

std::ostream & Realm::operator<<	(	std::ostream &	os,
		const Point< N, T > &	p
	)

◆ operator<<() [19/28]

template<typename T >

std::ostream & Realm::operator<<	(	std::ostream &	os,
		const PrettyVector< T > &	pv
	)

◆ operator<<() [20/28]

template<typename T , typename LT >

std::ostream & Realm::operator<<	(	std::ostream &	os,
		const PriorityQueue< T, LT > &	pq
	)

◆ operator<<() [21/28]

template<int N, typename T >

std::ostream & Realm::operator<<	(	std::ostream &	os,
		const Rect< N, T > &	p
	)

◆ operator<<() [22/28]

template<int N, typename T >

REALM_PUBLIC_API std::ostream & Realm::operator<<	(	std::ostream &	os,
		const SparsityMapEntry< N, T > &	entry
	)

◆ operator<<() [23/28]

std::ostream & Realm::operator<<	(	std::ostream &	os,
		Memory	m
	)

inline

◆ operator<<() [24/28]

std::ostream & Realm::operator<<	(	std::ostream &	os,
		Memory::Kind	kind
	)

inline

◆ operator<<() [25/28]

REALM_PUBLIC_API std::ostream & Realm::operator<<	(	std::ostream &	os,
		RegionInstance	r
	)

◆ operator<<() [26/28]

std::ostream & Realm::operator<<	(	std::ostream &	os,
		Reservation	r
	)

inline

◆ operator<<() [27/28]

template<int N, typename T >

REALM_PUBLIC_API std::ostream & Realm::operator<<	(	std::ostream &	os,
		SparsityMap< N, T >	s
	)

◆ operator<<() [28/28]

std::ostream & Realm::operator<<	(	std::ostream &	os,
		XferDesKind	kind
	)

inline

◆ operator==() [1/4]

bool Realm::operator==	(	const ChannelCopyInfo &	lhs,
		const ChannelCopyInfo &	rhs
	)

◆ operator==() [2/4]

template<int M, int N, typename T , typename T2 >

REALM_CUDA_HD bool Realm::operator==	(	const Matrix< M, N, T > &	lhs,
		const Matrix< M, N, T > &	rhs
	)

◆ operator==() [3/4]

template<int N, typename T , typename T2 >

REALM_CUDA_HD bool Realm::operator==	(	const Point< N, T > &	lhs,
		const Point< N, T2 > &	rhs
	)

◆ operator==() [4/4]

template<int N, typename T , typename T2 >

REALM_CUDA_HD bool Realm::operator==	(	const Rect< N, T > &	lhs,
		const Rect< N, T2 > &	rhs
	)

◆ realm_strerror()

REALM_PUBLIC_API const char * Realm::realm_strerror ( int err )

◆ serialize() [1/6]

template<typename S >

bool Realm::serialize	(	S &	serdez,
		const ByteArray &	a
	)

◆ serialize() [2/6]

template<typename S >

bool Realm::serialize	(	S &	serdez,
		const ByteArrayRef &	a
	)

◆ serialize() [3/6]

template<typename S >

bool Realm::serialize	(	S &	serializer,
		const CodeDescriptor &	cd
	)

◆ serialize() [4/6]

template<typename S >

bool Realm::serialize	(	S &	serializer,
		const CodeImplementation &	ci
	)

◆ serialize() [5/6]

template<typename S >

bool Realm::serialize	(	S &	serializer,
		const ExternalInstanceResource &	res
	)

◆ serialize() [6/6]

template<typename S >

bool Realm::serialize	(	S &	serializer,
		const RemoteChannelInfo &	rci
	)

◆ start_dma_system()

void Realm::start_dma_system ( BackgroundWorkManager * bgwork )

extern

◆ stop_dma_system()

void Realm::stop_dma_system ( void )

extern

Variable Documentation

◆ activemsg_handler_table

ActiveMessageHandlerTable Realm::activemsg_handler_table

extern

◆ dynamic_extent

const size_t Realm::dynamic_extent = size_t(-1)

◆ gex_wrapper_handle

gex_wrapper_handle_t Realm::gex_wrapper_handle

extern

◆ log_new_dma

Logger Realm::log_new_dma

extern

◆ log_poison

Logger Realm::log_poison

extern

◆ machine_singleton

MachineImpl* Realm::machine_singleton

extern

◆ runtime_singleton

REALM_INTERNAL_API_EXTERNAL_LINKAGE RuntimeImpl* Realm::runtime_singleton

extern

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ AddressSpace

◆ BarrierTableAllocator

◆ CompQueueTableAllocator

◆ CopyImplFn

◆ CustomSerdezID

◆ DefaultActiveMessageBuilder

◆ DIMCOUNTS

◆ DIMTYPES

◆ FieldBlock

◆ FieldID

◆ FLDTYPES

◆ hdf5_size_t

◆ LocalEventTableAllocator

◆ MemoryQueryPredicate

◆ Mutex

◆ NodeID

◆ OsHandle

◆ PathCache

◆ ProcessorGroupTableAllocator

◆ ProcQueryPredicate

◆ Py_ssize_t

◆ ReductionOpID

◆ RemoteEventTableAllocator

◆ ReservationTableAllocator

◆ SparsityMapTableAllocator

◆ SubgraphTableAllocator

◆ XferDesID

Enumeration Type Documentation

◆ anonymous enum

◆ NodeAnnounceTag

◆ nvtx_color

◆ ProfilingMeasurementID

◆ PyGILState_STATE

◆ QueryType

◆ XferDesKind

Function Documentation

◆ call_destructor()

◆ checked_cast()

◆ cleanup_query_caches()

◆ close_handle()

◆ compact_affine_dims()

◆ compute_target_subrect()

◆ crc32c_accumulate()

◆ ctz()

◆ delete_container_contents() [1/2]

◆ delete_container_contents() [2/2]

◆ delete_container_contents_free()

◆ deserialize() [1/2]

◆ deserialize() [2/2]

◆ destroy_xfer_des()

◆ enumerate_local_cpu_memories()

◆ finalize_nvtx()

◆ finalize_nvtx_thread()

◆ finalize_path_cache()

◆ find_best_channel_for_memories()

◆ find_fastest_path()

◆ find_shortest_path()

◆ free_intermediate_buffer()

◆ get_barrier_impl()

◆ get_event_impl()

◆ get_genevent_impl()

◆ get_machine()

◆ get_runtime()

◆ get_shm_name()

◆ hash_combine()

◆ hash_fnv1a()

◆ init_dma_handler()

◆ init_nvtx()

◆ init_nvtx_thread()

◆ init_path_cache()

◆ ipc_mailbox_create()

◆ ipc_mailbox_recv()

◆ ipc_mailbox_send()