Realm
A distributed, event-based tasking library
Loading...
Searching...
No Matches
Realm Namespace Reference

Namespaces

namespace  Config
namespace  ThreadLocal
namespace  TypeConv
namespace  PieceLayoutTypes
namespace  PieceLookup
namespace  Cuda
namespace  NetworkSegmentInfo
namespace  DeppartConfig
namespace  DynamicTemplates
namespace  Faults
namespace  GASNetEXHandlers
namespace  HDF5
namespace  Hip
namespace  KokkosInterop
namespace  LLVMJit
namespace  MPI
namespace  Network
namespace  Numa
namespace  OpenMP
namespace  ProcSet
namespace  ProfilingMeasurements
namespace  Python
namespace  ReductionKernels
namespace  ProfilingGauges
namespace  SampleFile
namespace  Serialization
namespace  Threading
namespace  ControlPort
namespace  UCP
namespace  ucc

Classes

class  ActiveMessage
class  CompletionCallbackBase
class  CompletionCallback
class  ActiveMessageImpl
struct  ActiveMessageHandlerStats
struct  FragmentInfo
class  ActiveMessageHandlerTable
class  ActiveMessageHandlerRegBase
class  ActiveMessageHandlerReg
class  IncomingMessageManager
struct  WrappedWithFragInfo
struct  is_wrapped_with_frag_info
struct  is_wrapped_with_frag_info< WrappedWithFragInfo< U > >
struct  allow_unfragmentable_header
class  atomic
struct  BarrierTriggerMessageArgsInternal
struct  BarrierTriggerPayload
struct  BarrierTriggerMessageArgs
class  BarrierCommunicator
struct  RemoteNotification
struct  BarrierTriggerMessage
class  BarrierImpl
class  BackgroundWorkManager
class  BackgroundWorkItem
class  ByteArrayRef
class  ByteArray
class  CachingAllocator
class  CircularQueueIterator
class  CircularQueue
class  CommandLineParser
class  CommandLineOption
class  IntegerCommandLineOption
class  IntegerUnitsCommandLineOption
class  StringCommandLineOption
class  StringListCommandLineOption
class  BooleanCommandLineOption
class  MethodCommandLineOption
class  Type
class  OpaqueType
class  IntegerType
class  PointerType
class  FunctionPointerType
class  CodeDescriptor
class  CodeImplementation
class  CodeProperty
class  CodeTranslator
class  FunctionPointerImplementation
class  CompQueueImpl
struct  CudaArrayPieceInfo
class  CudaArrayLayoutPiece
class  ExternalCudaMemoryResource
class  ExternalCudaArrayResource
class  ExternalCudaPinnedHostResource
class  SerdezObject
class  SimpleSerdez
class  CustomSerdezUntyped
class  CustomSerdezWrapper
class  ByFieldMicroOp
class  ByFieldOperation
class  ImageMicroOp
class  ImageOperation
class  StructuredImageMicroOp
struct  NT_TemplateHelper
struct  FLDTYPES_AUG
struct  NTF_TemplateHelper
struct  NTNT_TemplateHelper
class  OverlapTester
class  OverlapTester< 1, T >
class  AsyncMicroOp
class  PartitioningMicroOp
class  ComputeOverlapMicroOp
class  PartitioningOperation
class  PartitioningOpQueue
struct  RemoteMicroOpMessage
struct  RemoteMicroOpCompleteMessage
class  PreimageMicroOp
struct  ApproxImageResponseMessage
class  PreimageOperation
class  StructuredPreimageMicroOp
class  CoverageCounter
class  DenseRectangleList
class  HybridRectangleList
class  UnionMicroOp
class  IntersectionMicroOp
class  DifferenceMicroOp
class  UnionOperation
class  IntersectionOperation
class  DifferenceOperation
class  SparsityMapRefCounter
class  SparsityMapCommunicator
class  SparsityMapImpl
class  SparsityWrapperCommunicator
class  SparsityMapImplWrapper
struct  DynamicTableNodeBase
struct  DynamicTableNode
class  DynamicTableFreeList
struct  DefaultElementConstructor
class  DynamicTable
class  DynamicTableAllocator
class  Event
class  UserEvent
class  Barrier
class  CompletionQueue
class  EventWaiter
class  EventTriggerNotifier
class  EventImpl
class  EventMerger
class  EventCommunicator
class  GenEventImpl
class  Backtrace
class  ExecutionException
class  CancellationException
class  PoisonedEventException
class  ApplicationException
class  FragmentedMessage
class  GASNet1Module
struct  GASNetEXRDMAInfo
class  OutbufUsecountDec
class  OutbufManager
class  PendingCompletion
struct  PendingCompletionGroup
class  PendingCompletionManager
class  ChunkedRecycler
struct  PreparedMessage
class  XmitSrcDestPair
class  XmitSrc
class  GASNetEXEvent
class  GASNetEXInjector
class  GASNetEXPoller
class  GASNetEXCompleter
struct  PendingPutHeader
struct  PendingReverseGet
class  ReverseGetter
class  GASNetEXInternal
class  GASNetEXModule
class  HardwareTopology
 Represents the topology of the host processor cores and memory. More...
struct  HDF5PieceInfo
class  HDF5LayoutPiece
class  ExternalHDF5Resource
class  ExternalHipMemoryResource
class  ExternalHipPinnedHostResource
class  ID
class  IndexSpaceGenericImpl
class  IndexSpaceGenericImplTyped
class  CopySrcDstField
class  IndexSpaceIterator
class  SparsityMap
class  FieldDataDescriptor
class  TranslationTransform
class  AffineTransform
class  StructuredTransform
class  DomainTransform
class  CopyIndirection
class  IndexSpace
class  IndexSpaceGeneric
class  LinearizedIndexSpace
class  LinearizedIndexSpaceIntfc
class  AffineLinearizedIndexSpace
class  SparsityMapPublicImpl
class  CompiledInstanceLayout
class  RegionInstanceImpl
struct  InstanceMetadataPrefetchRequest
class  InstanceLayoutConstraints
class  InstanceLayoutGeneric
class  InstanceLayoutOpaque
class  InstanceLayoutPieceBase
class  InstanceLayoutPiece
class  AffineLayoutPiece
class  InstancePieceList
class  InstanceLayout
class  AccessorRefHelper
class  GenericAccessor
class  AffineAccessor
class  MultiAffineAccessor
struct  Rect
class  RegionInstance
class  ExternalInstanceResource
class  ExternalMemoryResource
class  ExternalFileResource
class  IntervalTree
class  IntrusiveList
class  IntrusivePriorityList
class  LLVMIRImplementation
class  Logger
class  LoggerMessage
class  LoggerOutputStream
class  Machine
class  MachineQueryIterator
struct  MachineAffinityInfo
struct  MachineProcInfo
struct  MachineMemInfo
struct  MachineNodeInfo
class  MachineImpl
class  QueryPredicate
class  ProcessorHasAffinityPredicate
struct  QueryResultList
struct  QueryKindCache
class  QueryCacheSlot
class  ProcessorQueryImpl
class  MemoryHasProcAffinityPredicate
class  MemoryHasMemAffinityPredicate
class  MemoryQueryImpl
class  MemoryImpl
class  MemSpecificInfo
class  PendingIBRequests
class  BasicRangeAllocator
class  SizedRangeAllocator
class  LocalManagedMemory
class  LocalCPUMemory
class  DiskMemory
class  FileMemory
class  RemoteMemory
struct  MemStorageAllocRequest
struct  MemStorageAllocResponse
struct  MemStorageReleaseRequest
struct  MemStorageReleaseResponse
class  Memory
class  MetadataBase
struct  MetadataRequestMessage
struct  MetadataResponseMessage
struct  MetadataInvalidateMessage
struct  MetadataInvalidateAckMessage
class  Module
class  ModuleSpecificInfo
class  ModuleRegistrar
class  ModuleConfig
class  MPIModule
class  MutexChecker
class  Doorbell
class  DoorbellList
class  UnfairMutex
class  FIFOMutex
class  KernelMutex
class  DelegatingMutex
class  UnfairCondVar
class  FIFOCondVar
class  KernelCondVar
class  AutoLock
class  RWLock
class  StripedRWLock
struct  RemoteAddress
struct  LocalAddress
class  NetworkModule
class  NetworkSegment
class  NodeSetIterator
class  NodeSetBitmask
class  NodeSet
struct  NumaNodeMemInfo
struct  NumaNodeCpuInfo
struct  NvtxARGB
struct  NvtxCategory
struct  nvtxScopedRange
class  LocalOpenMPProcessor
class  LoopSchedule
class  ThreadPool
class  Operation
class  OperationTable
struct  CancelOperationMessage
struct  Point
class  PointInRectIterator
struct  Matrix
class  PriorityQueue
class  ProcessorImpl
class  LocalTaskProcessor
class  LocalCPUProcessor
class  LocalUtilityProcessor
class  LocalIOProcessor
class  RemoteProcessor
class  ProcessorGroupImpl
class  TaskRegistration
class  RemoteTaskRegistration
struct  RegisterTaskMessage
struct  RegisterTaskCompleteMessage
struct  SpawnTaskMessage
struct  ProcGroupCreateMessage
struct  ProcGroupDestroyMessage
struct  ProcGroupDestroyAckMessage
class  Processor
class  ProcessorGroup
class  ProfilingRequest
class  ProfilingRequestSet
class  ProfilingMeasurementCollection
class  ProfilingResponse
struct  PyThreadState
class  PythonAPI
class  PythonInterpreter
class  LocalPythonProcessor
class  PythonThreadTaskScheduler
class  PythonSourceImplementation
struct  ReductionOp
struct  ReductionOpUntyped
class  ReplicatedHeap
class  Reservation
class  FastReservation
class  ReservationImpl
struct  LockRequestMessage
struct  LockReleaseMessage
struct  LockGrantMessage
struct  DestroyLockMessage
class  Runtime
struct  Node
class  CoreModuleConfig
class  CoreModule
class  LockedMap
class  RuntimeImpl
struct  RuntimeShutdownRequest
struct  RuntimeShutdownMessage
class  SamplingProfiler
class  GaugeSampleBuffer
class  GaugeSampleBufferImpl
class  GaugeSampler
class  GaugeSamplerImpl
class  DelayedGaugeAddition
class  DelayedGaugeAdditionImpl
class  SamplingProfilerImpl
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  HierarchicalBitMap
struct  SparsityMapEntry
class  Subgraph
struct  SubgraphDefinition
struct  SubgraphScheduleEntry
class  SubgraphImpl
struct  SubgraphInstantiateMessage
struct  SubgraphDestroyMessage
class  Task
class  TaskQueue
class  InternalTask
class  TaskContextManager
class  ThreadedTaskScheduler
class  KernelThreadTaskScheduler
class  Thread
class  ThreadScheduler
class  ThreadLaunchParameters
class  CoreReservationParameters
class  CoreReservation
class  CoreReservationSet
class  DummyLock
class  Clock
class  TimeLimit
class  TimeStamp
struct  FieldBlockBase
class  AddressList
class  AddressListCursor
class  AddressSplitXferDesBase
class  AddressSplitChannel
struct  AddressSplitXferDesCreateMessage
class  AddressSplitCommunicator
class  AddressSplitXferDesFactory
class  AddressSplitXferDes
class  Request
class  SequenceAssembler
class  MemcpyRequest
class  GASNetRequest
class  RemoteWriteRequest
struct  XferDesPortInfo
struct  XferDesRedopInfo
class  XferDes
class  MemfillXferDes
class  MemreduceXferDes
class  GASNetXferDes
class  RemoteWriteXferDes
class  XferDesFactory
struct  XferDesCreateMessageBase
struct  SimpleXferDesCreateMessage
class  SimpleXferDesFactory
struct  ChannelCopyInfo
class  Channel
class  LocalChannel
class  RemoteChannelInfo
class  SimpleRemoteChannelInfo
class  RemoteChannel
class  XDQueue
class  SingleXDQChannel
class  MemfillChannel
class  MemreduceChannel
class  GASNetChannel
class  RemoteWriteChannel
struct  NotifyXferDesCompleteMessage
struct  XferDesDestroyMessage
struct  UpdateBytesTotalMessage
struct  UpdateBytesWriteMessage
struct  UpdateBytesReadMessage
class  XferDesPlaceholder
class  XferDesQueue
class  FileRequest
class  DiskRequest
class  FileXferDes
class  DiskXferDes
class  FileChannel
class  DiskChannel
class  IBMemory
struct  RemoteIBAllocRequestSingle
struct  RemoteIBAllocRequestMultiple
struct  RemoteIBAllocResponseSingle
struct  RemoteIBAllocResponseMultiple
struct  RemoteIBReleaseSingle
struct  RemoteIBReleaseMultiple
struct  MemPathInfo
class  PathLRU
class  AsyncFileIOContext
class  WrappingFIFOIterator
class  MemcpyXferDes
class  MemcpyChannel
class  TransferIterator
class  TransferIteratorBase
class  TransferIteratorIndexSpace
class  IDIndexedFieldsIterator
class  TransferIteratorIndirect
class  TransferDomain
struct  TransferGraph
class  TransferDesc
class  CopyAnalyzer
class  IndirectionInfo
class  IndirectionInfoBase
class  IndirectionInfoTyped
class  TransferOperation
struct  CopyImplRouter
class  UCPModule
class  span
class  shortstringbuf
class  stringbuilder
class  DeferredConstructor
struct  bitfield
class  bitpack
class  PrettyVector
class  span< T, dynamic_extent >
class  empty_span
class  noncopyable
class  RealmEntryExitRAII

Typedefs

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, 8, 4, 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
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

REALM_INTERNAL_API_EXTERNAL_LINKAGE uint64_t next_chunk_message_id (NodeID node_id)
REALM_INTERNAL_API_EXTERNAL_LINKAGE void report_unfragmentable_message (unsigned short msgid, size_t header_size, size_t wrapped_header_size, size_t payload_size)
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)
template<int N, typename T>
bool operator< (const IndexSpace< N, T > &lhs, const IndexSpace< N, T > &rhs)
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>
REALM_CUDA_HD bool operator< (const Point< N, T > &lhs, const Point< N, T > &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>
REALM_CUDA_HD bool operator< (const Rect< N, T > &lhs, const Rect< N, T > &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)
size_t ib_align_up (size_t n, size_t mult=IB_ALLOC_ALIGNMENT)
void free_intermediate_buffer (Memory mem, off_t offset, size_t size, TimeLimit work_until)
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
template<typename T, size_t N>
CachingAllocator< T, N >::Block::BlockList CachingAllocator< T, N >::free_blocks
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

◆ BarrierTableAllocator

◆ CompQueueTableAllocator

◆ CopyImplFn

template<int N, typename T>
using Realm::CopyImplFn
Initial value:
Event (*)(const IndexSpace<N, T> &, const std::vector<CopySrcDstField> &,
const std::vector<CopySrcDstField> &,
const std::vector<const typename CopyIndirection<N, T>::Base *> &,
Definition event.h:50
Definition profiling.h:363
Definition indexspace.h:323

◆ CustomSerdezID

typedef int Realm::CustomSerdezID

◆ DIMCOUNTS

◆ DIMTYPES

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

◆ FieldBlock

◆ FieldID

◆ FLDTYPES

◆ hdf5_size_t

typedef unsigned long long Realm::hdf5_size_t

◆ LocalEventTableAllocator

◆ MemoryQueryPredicate

◆ 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

◆ ProcQueryPredicate

◆ Py_ssize_t

typedef ssize_t Realm::Py_ssize_t

◆ ReductionOpID

◆ RemoteEventTableAllocator

◆ ReservationTableAllocator

◆ SparsityMapTableAllocator

◆ 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

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

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

Enumerator
PyGILState_LOCKED 
PyGILState_UNLOCKED 

◆ QueryType

Enumerator
QUERY_NEXT 
QUERY_FIRST 
QUERY_RANDOM 

◆ 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
NNumber of dimensions in the layout.
TCoordinate type (e.g., int, long).
Parameters
affinePointer to the affine layout piece being queried.
subrectSubrectangle to compute addressing for.
dim_orderOrdering of dimensions to compact/iterate over.
[out]total_bytesTotal bytes represented by the subrect.
[out]contig_bytesNumber of contiguous bytes in the compacted dimensions.
[out]count_stridesOutput 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,
TimeLimit work_until )

◆ 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
ididentifier of the realm object to get the name of
Returns
shared memory name of the requested object

◆ hash_combine()

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

◆ hash_fnv1a()

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

◆ ib_align_up()

size_t Realm::ib_align_up ( size_t n,
size_t mult = IB_ALLOC_ALIGNMENT )
inline

◆ 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
nameName 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
mailboxMailbox created via ipc_mailbox_create
fromName of the mailbox to receive from
[out]handlesOS handles to receive from
[out]dataBytes recieved from
[out]data_szLength of data in bytes received
max_data_szMaximum 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
mailboxMailbox created via ipc_mailbox_create
toName of the mailbox to send to
handlesOS handles to send to the receiver. These will have different "values" in the receiver, but will map to the same resource
dataBytes to send to receiver
data_szLength of data to send to receiver
Returns
True if successful, false otherwise

◆ make_point()

template<typename T = int, typename... U>
auto Realm::make_point ( const U &... rest) ->Point< sizeof...(rest), T >
nodiscardconstexpr

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_chunk_message_id()

REALM_INTERNAL_API_EXTERNAL_LINKAGE uint64_t Realm::next_chunk_message_id ( NodeID node_id)

◆ 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/3]

template<int N, typename T>
bool Realm::operator< ( const IndexSpace< N, T > & lhs,
const IndexSpace< N, T > & rhs )

◆ operator<() [2/3]

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

◆ operator<() [3/3]

template<int N, typename T>
REALM_CUDA_HD bool Realm::operator< ( const Rect< N, T > & lhs,
const Rect< N, T > & 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)

◆ report_unfragmentable_message()

REALM_INTERNAL_API_EXTERNAL_LINKAGE void Realm::report_unfragmentable_message ( unsigned short msgid,
size_t header_size,
size_t wrapped_header_size,
size_t payload_size )

◆ 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

◆ CachingAllocator< T, N >::free_blocks

template<typename T, size_t N>
CachingAllocator<T,N>::Block::BlockList Realm::CachingAllocator< T, N >::free_blocks

◆ 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