Legion Runtime
Loading...
Searching...
No Matches
legion_types.h
Go to the documentation of this file.
1/* Copyright 2024 Stanford University, NVIDIA Corporation
2 *
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#ifndef __LEGION_TYPES_H__
17#define __LEGION_TYPES_H__
18
23#include <stdio.h>
24#include <stdlib.h>
25#include <assert.h>
26#include <string.h>
27#include <stdint.h>
28#include <limits.h>
29
30#include <map>
31#include <set>
32#include <list>
33#include <limits>
34#include <deque>
35#include <vector>
36#include <optional>
37#include <typeinfo>
38#include <type_traits>
39#include <string_view>
40#include <unordered_set>
41#include <unordered_map>
42
43#include "legion/legion_config.h"
44
45// Make sure we have the appropriate defines in place for including realm
46#include "realm.h"
47#include "realm/id.h"
48#include "realm/dynamic_templates.h"
49
50// this may be set before including legion.h to eliminate deprecation warnings
51// for just the Legion API
52#ifndef LEGION_DEPRECATED
53#if __cplusplus >= 201402L
54#define LEGION_DEPRECATED(x) [[deprecated(x)]]
55#else
56#define LEGION_DEPRECATED(x)
57#endif
58#endif
59
60// Macros for disabling and re-enabling deprecated warnings
61#if defined(__PGIC__)
62// PGI has to go first because it also responds to GCC defines
63#define LEGION_DISABLE_DEPRECATED_WARNINGS \
64 _Pragma("warning (push)") \
65 _Pragma("diag_suppress 1445")
66#define LEGION_REENABLE_DEPRECATED_WARNINGS \
67 _Pragma("warning (pop)")
68#elif defined(__GNUC__)
69#define LEGION_DISABLE_DEPRECATED_WARNINGS \
70 _Pragma("GCC diagnostic push") \
71 _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
72#define LEGION_REENABLE_DEPRECATED_WARNINGS \
73 _Pragma("GCC diagnostic pop")
74#elif defined(__clang__)
75#define LEGION_DISABLE_DEPRECATED_WARNINGS \
76 _Pragma("clang diagnostic push") \
77 _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
78#define LEGION_REENABLE_DEPRECATED_WARNINGS \
79 _Pragma("clang diagnostic pop")
80#elif defined(__INTEL_COMPILER) || defined(__INTEL_LLVM_COMPILER)
81#define LEGION_DISABLE_DEPRECATED_WARNINGS \
82 _Pragma("warning push") \
83 _Pragma("warning disable 1478")
84#define LEGION_REENABLE_DEPRECATED_WARNINGS \
85 _Pragma("warning pop")
86#else
87#warning "Don't know how to suppress deprecated warnings for this compiler"
88#define LEGION_DISABLE_DEPRECATED_WARNINGS
89#define LEGION_REENABLE_DEPRECATED_WARNINGS
90#endif
91
92// If we're doing full LEGION_SPY then turn off event pruning
93#ifdef LEGION_SPY
94#ifndef LEGION_DISABLE_EVENT_PRUNING
95#define LEGION_DISABLE_EVENT_PRUNING
96#endif
97#endif
98
99// forward declarations from bitmask.h
100template<typename T, unsigned int MAX,
101 unsigned SHIFT, unsigned MASK> class BitMask;
102template<typename T, unsigned int MAX,
103 unsigned SHIFT, unsigned MASK> class TLBitMask;
104#ifdef __SSE2__
105template<unsigned int MAX> class SSEBitMask;
106template<unsigned int MAX> class SSETLBitMask;
107#endif
108#ifdef __AVX__
109template<unsigned int MAX> class AVXBitMask;
110template<unsigned int MAX> class AVXTLBitMask;
111#endif
112#ifdef __ALTIVEC__
113template<unsigned int MAX> class PPCBitMask;
114template<unsigned int MAX> class PPCTLBitMask;
115#endif
116#ifdef __ARM_NEON
117template<unsigned int MAX> class NeonBitMask;
118template<unsigned int MAX> class NeonTLBitMask;
119#endif
120template<typename DT, unsigned BLOAT, bool BIDIR> class CompoundBitMask;
121
122namespace BindingLib { class Utility; } // BindingLib namespace
123
124namespace Legion {
125
126 typedef ::legion_error_t LegionErrorType;
127 typedef ::legion_privilege_mode_t PrivilegeMode;
128 typedef ::legion_allocate_mode_t AllocateMode;
129 typedef ::legion_coherence_property_t CoherenceProperty;
130 typedef ::legion_region_flags_t RegionFlags;
131 typedef ::legion_projection_type_t ProjectionType;
132 typedef ::legion_partition_kind_t PartitionKind;
133 typedef ::legion_external_resource_t ExternalResource;
134 typedef ::legion_timing_measurement_t TimingMeasurement;
135 typedef ::legion_dependence_type_t DependenceType;
136 typedef ::legion_mappable_type_id_t MappableType;
137 typedef ::legion_file_mode_t LegionFileMode;
138 typedef ::legion_execution_constraint_t ExecutionConstraintKind;
139 typedef ::legion_layout_constraint_t LayoutConstraintKind;
140 typedef ::legion_equality_kind_t EqualityKind;
141 typedef ::legion_dimension_kind_t DimensionKind;
142 typedef ::legion_isa_kind_t ISAKind;
143 typedef ::legion_resource_constraint_t ResourceKind;
144 typedef ::legion_launch_constraint_t LaunchKind;
145 typedef ::legion_specialized_constraint_t SpecializedKind;
146 typedef ::legion_unbounded_pool_scope_t UnboundPoolScope;
147
148 // Forward declarations for user level objects
149 // legion.h
150 class IndexSpace;
151 template<int DIM, typename T> class IndexSpaceT;
152 class IndexPartition;
153 template<int DIM, typename T> class IndexPartitionT;
154 class FieldSpace;
155 class LogicalRegion;
156 template<int DIM, typename T> class LogicalRegionT;
157 class LogicalPartition;
158 template<int DIM, typename T> class LogicalPartitionT;
159 class IndexAllocator;
160 class FieldAllocator;
161 class UntypedBuffer;
162 class ArgumentMap;
163 class Lock;
164 struct LockRequest;
165 class Grant;
166 class PhaseBarrier;
167 struct RegionRequirement;
168 struct OutputRequirement;
169 struct IndexSpaceRequirement;
170 struct FieldSpaceRequirement;
171 struct TaskLauncher;
172 struct IndexTaskLauncher;
173 typedef IndexTaskLauncher IndexLauncher; // for backwards compatibility
174 struct InlineLauncher;
175 struct CopyLauncher;
176 struct AcquireLauncher;
177 struct ReleaseLauncher;
178 struct FillLauncher;
179 struct LayoutConstraintRegistrar;
180 struct TaskVariantRegistrar;
181 class Future;
182 class FutureMap;
183 class Predicate;
184 class PhysicalRegion;
185 class OutputRegion;
186 class ExternalResources;
187 class UntypedDeferredValue;
188 template<typename>
189 class DeferredValue;
190 template<typename, bool>
191 class DeferredReduction;
192 template<typename, int, typename, bool>
193 class DeferredBuffer;
194 template<typename COORD_T>
195 class UntypedDeferredBuffer;
196 template<PrivilegeMode,typename,int,typename,typename,bool>
197 class FieldAccessor;
198 template<typename, bool, int, typename, typename, bool>
199 class ReductionAccessor;
200 template<typename, int, typename, typename, bool>
201 class PaddingAccessor;
202#ifdef LEGION_MULTI_REGION_ACCESSOR
203 template<typename, int,typename,typename,bool,bool,int>
204 class MultiRegionAccessor;
205#endif
206 template<typename,int,typename,typename>
207 class UnsafeFieldAccessor;
208 namespace ArraySyntax {
209 template<typename, PrivilegeMode> class AccessorRefHelper;
210 template<typename> class AffineRefHelper;
211 }
212 class PieceIterator;
213 template<int,typename>
214 class PieceIteratorT;
215 template<PrivilegeMode,typename,int,typename>
216 class SpanIterator;
217 struct InputArgs;
218 struct RegistrationCallbackArgs;
219 class ProjectionFunctor;
220 class ShardingFunctor;
221 class Task;
222 class Copy;
223 class InlineMapping;
224 class Acquire;
225 class Release;
226 class Close;
227 class Fill;
228 class Partition;
229 class MustEpoch;
230 class PointTransformFunctor;
231 class Runtime;
232 class LegionHandshake;
233 class MPILegionHandshake;
234 // For backwards compatibility
235 typedef Runtime HighLevelRuntime;
236 // Helper for saving instantiated template functions
237 struct SerdezRedopFns;
238 // Some typedefs for making things nicer for users with C++11 support
239 template<typename FT, int N, typename T = ::legion_coord_t>
240 using GenericAccessor = Realm::GenericAccessor<FT,N,T>;
241 template<typename FT, int N, typename T = ::legion_coord_t>
242 using AffineAccessor = Realm::AffineAccessor<FT,N,T>;
243 template<typename FT, int N, typename T = ::legion_coord_t>
244 using MultiAffineAccessor = Realm::MultiAffineAccessor<FT,N,T>;
245
246 // Forward declarations for wrapper tasks
247 // legion.h
248 class LegionTaskWrapper;
249 class LegionSerialization;
250
251 // Forward declarations for C wrapper objects
252 // legion_c_util.h
253 class TaskResult;
254 class CObjectWrapper;
255
256 // legion_domain.h
257 class DomainPoint;
258 class Domain;
259 class IndexSpaceAllocator;
260
261 // legion_utilities.h
262 class Serializer;
263 class Deserializer;
264
265 // legion_constraint.h
266 class ISAConstraint;
267 class ProcessorConstraint;
268 class ResourceConstraint;
269 class LaunchConstraint;
270 class ColocationConstraint;
271 class ExecutionConstraintSet;
272
273 class SpecializedConstraint;
274 class MemoryConstraint;
275 class FieldConstraint;
276 class PaddingConstraint;
277 class OrderingConstraint;
278 class TilingConstraint;
279 class DimensionConstraint;
280 class AlignmentConstraint;
281 class OffsetConstraint;
282 class PointerConstraint;
283 class LayoutConstraintSet;
284 class TaskLayoutConstraintSet;
285
286 namespace Mapping {
287 class PhysicalInstance;
288 class CollectiveView;
289 class MapperEvent;
290 class ProfilingRequestSet;
291 class Mapper;
292 class MapperRuntime;
293 class AutoLock;
294 class DefaultMapper;
295 class ShimMapper;
296 class TestMapper;
297 class DebugMapper;
298 class ReplayMapper;
299
300 // The following types are effectively overlaid on the Realm versions
301 // to allow for Legion-specific profiling measurements
302 enum ProfilingMeasurementID {
303 PMID_LEGION_FIRST = Realm::PMID_REALM_LAST,
304 PMID_RUNTIME_OVERHEAD,
305 };
306 };
307
308 namespace Internal {
309
310 enum OpenState {
311 NOT_OPEN = 0,
312 OPEN_READ_ONLY = 1,
313 OPEN_READ_WRITE = 2, // unknown dirty information below
314 OPEN_REDUCE = 3, // make sure to check reduction value
315 };
316
317 // Internal reduction operators
318 // Currently we don't use any, but 0 is reserved
319 enum {
320 REDOP_ID_AVAILABLE = 1,
321 };
322
323 // Realm dependent partitioning kinds
324 enum DepPartOpKind {
325 DEP_PART_UNION = 0, // a single union
326 DEP_PART_UNIONS = 1, // many parallel unions
327 DEP_PART_UNION_REDUCTION = 2, // union reduction to a single space
328 DEP_PART_INTERSECTION = 3, // a single intersection
329 DEP_PART_INTERSECTIONS = 4, // many parallel intersections
330 DEP_PART_INTERSECTION_REDUCTION = 5, // intersection reduction to a space
331 DEP_PART_DIFFERENCE = 6, // a single difference
332 DEP_PART_DIFFERENCES = 7, // many parallel differences
333 DEP_PART_EQUAL = 8, // an equal partition operation
334 DEP_PART_BY_FIELD = 9, // create a partition from a field
335 DEP_PART_BY_IMAGE = 10, // create partition by image
336 DEP_PART_BY_IMAGE_RANGE = 11, // create partition by image range
337 DEP_PART_BY_PREIMAGE = 12, // create partition by preimage
338 DEP_PART_BY_PREIMAGE_RANGE = 13, // create partition by preimage range
339 DEP_PART_ASSOCIATION = 14, // create an association
340 DEP_PART_WEIGHTS = 15, // create partition by weights
341 };
342
343 // Collective copy kinds
344 enum CollectiveKind {
345 COLLECTIVE_NONE = 0,
346 // Filling a collective instance (both normal and reductions)
347 COLLECTIVE_FILL = 1,
348 // Broadcasting one normal instance to a collective normal instance
349 COLLECTIVE_BROADCAST = 2,
350 // Reducing a collective reduction instance to either a
351 // single normal or a single reduction instance
352 COLLECTIVE_REDUCTION = 3,
353 // Performing an all-reduce from a collective reduction instance
354 // to a collective normal or reduction instance using a butterfly
355 // network reduction (both instances using the same nodes)
356 COLLECTIVE_BUTTERFLY_ALLREDUCE = 4,
357 // Performing an all-reduce by doing a reduction down to a single
358 // instance and then broadcasting the result out from that instance
359 // (instances don't exist on the same set of nodes)
360 COLLECTIVE_HOURGLASS_ALLREDUCE = 5,
361 // Copy from one collective normal instanace to another collective
362 // normal instance for each of the points in the destination
363 COLLECTIVE_POINT_TO_POINT = 6,
364 // Apply a reduction from a single reduction instance to
365 // a collective normal instance
366 COLLECTIVE_REDUCECAST = 7,
367 // Degenerate case: apply a copy-across from a collective reduction
368 // instance to any kind of other instance without doing an all-reduce
369 COLLECTIVE_HAMMER_REDUCTION = 8,
370 };
371
372 // Enumeration of Legion runtime tasks
373 enum LgTaskID {
374 LG_SCHEDULER_ID,
375 LG_TRIGGER_READY_ID,
376 LG_TRIGGER_EXECUTION_ID,
377 LG_TRIGGER_COMMIT_ID,
378 LG_DEFERRED_EXECUTION_ID,
379 LG_DEFERRED_COMPLETION_ID,
380 LG_DEFERRED_COMMIT_ID,
381 LG_PRE_PIPELINE_ID,
382 LG_TRIGGER_DEPENDENCE_ID,
383 LG_DEFERRED_MAPPED_ID,
384 LG_TRIGGER_OP_ID,
385 LG_TRIGGER_TASK_ID,
386 LG_DEFER_MAPPER_SCHEDULER_TASK_ID,
387 LG_MUST_INDIV_ID,
388 LG_MUST_INDEX_ID,
389 LG_MUST_MAP_ID,
390 LG_MUST_DIST_ID,
391 LG_MUST_LAUNCH_ID,
392 LG_CONTRIBUTE_COLLECTIVE_ID,
393 LG_FUTURE_CALLBACK_TASK_ID,
394 LG_CALLBACK_RELEASE_TASK_ID,
395 LG_FUTURE_BROADCAST_TASK_ID,
396 LG_TOP_FINISH_TASK_ID,
397 LG_MAPPER_TASK_ID,
398 LG_DISJOINTNESS_TASK_ID,
399 LG_DEFER_TIMING_MEASUREMENT_TASK_ID,
400 LG_TASK_IMPL_SEMANTIC_INFO_REQ_TASK_ID,
401 LG_INDEX_SPACE_SEMANTIC_INFO_REQ_TASK_ID,
402 LG_INDEX_PART_SEMANTIC_INFO_REQ_TASK_ID,
403 LG_FIELD_SPACE_SEMANTIC_INFO_REQ_TASK_ID,
404 LG_FIELD_SEMANTIC_INFO_REQ_TASK_ID,
405 LG_DEFER_FIELD_INFOS_TASK_ID,
406 LG_REGION_SEMANTIC_INFO_REQ_TASK_ID,
407 LG_PARTITION_SEMANTIC_INFO_REQ_TASK_ID,
408 LG_INDEX_SPACE_DEFER_CHILD_TASK_ID,
409 LG_INDEX_PART_DEFER_CHILD_TASK_ID,
410 LG_INDEX_PART_DEFER_SHARD_RECTS_TASK_ID,
411 LG_DEFERRED_ENQUEUE_TASK_ID,
412 LG_DEFER_MAPPER_MESSAGE_TASK_ID,
413 LG_DEFER_MAPPER_COLLECTION_TASK_ID,
414 LG_REMOTE_VIEW_CREATION_TASK_ID,
415 LG_DEFERRED_DISTRIBUTE_TASK_ID,
416 LG_DEFER_PERFORM_MAPPING_TASK_ID,
417 LG_FINALIZE_OUTPUT_TREE_TASK_ID,
418 LG_DEFERRED_LAUNCH_TASK_ID,
419 LG_MISPREDICATION_TASK_ID,
420 LG_DEFER_TRIGGER_CHILDREN_COMMIT_TASK_ID,
421 LG_ORDER_CONCURRENT_LAUNCH_TASK_ID,
422 LG_DEFER_MATERIALIZED_VIEW_TASK_ID,
423 LG_DEFER_REDUCTION_VIEW_TASK_ID,
424 LG_DEFER_PHI_VIEW_REGISTRATION_TASK_ID,
425 LG_DEFER_COMPOSITE_COPY_TASK_ID,
426 LG_TIGHTEN_INDEX_SPACE_TASK_ID,
427 LG_REPLAY_SLICE_TASK_ID,
428 LG_TRANSITIVE_REDUCTION_TASK_ID,
429 LG_DELETE_TEMPLATE_TASK_ID,
430 LG_DEFER_MAKE_OWNER_TASK_ID,
431 LG_DEFER_APPLY_STATE_TASK_ID,
432 LG_COPY_FILL_AGGREGATION_TASK_ID,
433 LG_COPY_FILL_DELETION_TASK_ID,
434 LG_FINALIZE_EQ_SETS_TASK_ID,
435 LG_FINALIZE_OUTPUT_EQ_SET_TASK_ID,
436 LG_DEFERRED_COPY_ACROSS_TASK_ID,
437 LG_DEFER_REMOTE_OP_DELETION_TASK_ID,
438 LG_DEFER_REMOTE_INSTANCE_TASK_ID,
439 LG_DEFER_REMOTE_REDUCTION_TASK_ID,
440 LG_DEFER_REMOTE_UPDATE_TASK_ID,
441 LG_DEFER_REMOTE_ACQUIRE_TASK_ID,
442 LG_DEFER_REMOTE_RELEASE_TASK_ID,
443 LG_DEFER_REMOTE_COPIES_ACROSS_TASK_ID,
444 LG_DEFER_REMOTE_OVERWRITE_TASK_ID,
445 LG_DEFER_REMOTE_FILTER_TASK_ID,
446 LG_DEFER_PERFORM_TRAVERSAL_TASK_ID,
447 LG_DEFER_PERFORM_ANALYSIS_TASK_ID,
448 LG_DEFER_PERFORM_REMOTE_TASK_ID,
449 LG_DEFER_PERFORM_UPDATE_TASK_ID,
450 LG_DEFER_PERFORM_REGISTRATION_TASK_ID,
451 LG_DEFER_PERFORM_OUTPUT_TASK_ID,
452 LG_DEFER_PHYSICAL_MANAGER_TASK_ID,
453 LG_DEFER_DELETE_PHYSICAL_MANAGER_TASK_ID,
454 LG_DEFER_VERIFY_PARTITION_TASK_ID,
455 LG_DEFER_RELEASE_ACQUIRED_TASK_ID,
456 LG_DEFER_COPY_ACROSS_TASK_ID,
457 LG_DEFER_COLLECTIVE_MESSAGE_TASK_ID,
458 LG_FREE_EAGER_INSTANCE_TASK_ID,
459 LG_MALLOC_INSTANCE_TASK_ID,
460 LG_FREE_INSTANCE_TASK_ID,
461 LG_DEFER_TRACE_UPDATE_TASK_ID,
462 LG_FINALIZE_OUTPUT_ID,
463 LG_DEFER_DELETE_FUTURE_INSTANCE_TASK_ID,
464 LG_FREE_EXTERNAL_TASK_ID,
465 LG_DEFER_CONSENSUS_MATCH_TASK_ID,
466 LG_DEFER_COLLECTIVE_TASK_ID,
467 LG_DEFER_ISSUE_FILL_TASK_ID,
468 LG_DEFER_MUST_EPOCH_RETURN_TASK_ID,
469 LG_DEFER_DELETION_COMMIT_TASK_ID,
470 LG_YIELD_TASK_ID,
471 // this marks the beginning of task IDs tracked by the shutdown algorithm
472 LG_BEGIN_SHUTDOWN_TASK_IDS,
473 LG_RETRY_SHUTDOWN_TASK_ID = LG_BEGIN_SHUTDOWN_TASK_IDS,
474 // Message ID goes at the end so we can append additional
475 // message IDs here for the profiler and separate meta-tasks
476 LG_MESSAGE_ID,
477 LG_LAST_TASK_ID, // This one should always be last
478 };
479
480 // Make this a macro so we can keep it close to
481 // declaration of the task IDs themselves
482#define LG_TASK_DESCRIPTIONS(name) \
483 const char *name[LG_LAST_TASK_ID] = { \
484 "Scheduler", \
485 "Trigger Ready", \
486 "Trigger Execution", \
487 "Trigger Commit", \
488 "Deferred Execution", \
489 "Deferred Completion", \
490 "Deferred Commit", \
491 "Prepipeline Stage", \
492 "Logical Dependence Analysis", \
493 "Deferred Mapped", \
494 "Trigger Operation Mapping", \
495 "Trigger Task Mapping", \
496 "Defer Mapper Scheduler", \
497 "Must Individual Task Dependence Analysis", \
498 "Must Index Task Dependence Analysis", \
499 "Must Task Physical Dependence Analysis", \
500 "Must Task Distribution", \
501 "Must Task Launch", \
502 "Contribute Collective", \
503 "Future Callback", \
504 "Future Callback Release", \
505 "Future Broadcast", \
506 "Top Finish", \
507 "Mapper Task", \
508 "Disjointness Test", \
509 "Defer Timing Measurement", \
510 "Task Impl Semantic Request", \
511 "Index Space Semantic Request", \
512 "Index Partition Semantic Request", \
513 "Field Space Semantic Request", \
514 "Field Semantic Request", \
515 "Defer Field Infos Request", \
516 "Region Semantic Request", \
517 "Partition Semantic Request", \
518 "Defer Index Space Child Request", \
519 "Defer Index Partition Child Request", \
520 "Defer Index Partition Find Shard Rects", \
521 "Deferred Enqueue Task", \
522 "Deferred Mapper Message", \
523 "Deferred Mapper Instance Collective", \
524 "Remote View Creation", \
525 "Deferred Distribute Task", \
526 "Defer Task Perform Mapping", \
527 "Finalize Output Regions Eq KD Tree", \
528 "Deferred Task Launch", \
529 "Handle Mapping Mispredication", \
530 "Defer Trigger Children Commit", \
531 "Order Concurrent Launch", \
532 "Defer Materialized View Registration", \
533 "Defer Reduction View Registration", \
534 "Defer Phi View Registration", \
535 "Defer Composite Copy", \
536 "Tighten Index Space", \
537 "Replay Physical Trace", \
538 "Template Transitive Reduction", \
539 "Delete Physical Template", \
540 "Defer Equivalence Set Make Owner", \
541 "Defer Equivalence Set Apply State", \
542 "Copy Fill Aggregation", \
543 "Copy Fill Deletion", \
544 "Finalize Equivalence Sets", \
545 "Finalize Output Equivalence Set", \
546 "Deferred Copy Across", \
547 "Defer Remote Op Deletion", \
548 "Defer Remote Instance Request", \
549 "Defer Remote Reduction Request", \
550 "Defer Remote Update Equivalence Set", \
551 "Defer Remote Acquire", \
552 "Defer Remote Release", \
553 "Defer Remote Copy Across", \
554 "Defer Remote Overwrite Equivalence Set", \
555 "Defer Remote Filter Equivalence Set", \
556 "Defer Physical Analysis Traversal Stage", \
557 "Defer Physical Analysis Analyze Equivalence Set Stage", \
558 "Defer Physical Analysis Remote Stage", \
559 "Defer Physical Analysis Update Stage", \
560 "Defer Physical Analysis Registration Stage", \
561 "Defer Physical Analysis Output Stage", \
562 "Defer Physical Manager Registration", \
563 "Defer Physical Manager Deletion", \
564 "Defer Verify Partition", \
565 "Defer Release Acquired Instances", \
566 "Defer Copy-Across Execution for Preimages", \
567 "Defer Collective Instance Message", \
568 "Free Eager Instance", \
569 "Malloc Instance", \
570 "Free Instance", \
571 "Defer Trace Update", \
572 "Finalize Output Region Instance", \
573 "Defer Delete Future Instance", \
574 "Free External Allocation", \
575 "Defer Consensus Match", \
576 "Defer Collective Async", \
577 "Defer Issue Fill", \
578 "Defer Must Epoch Return Resources", \
579 "Defer Deletion Commit", \
580 "Yield", \
581 "Retry Shutdown", \
582 "Remote Message", \
583 };
584
585 enum MappingCallKind {
586 GET_MAPPER_NAME_CALL,
587 GET_MAPER_SYNC_MODEL_CALL,
588 SELECT_TASK_OPTIONS_CALL,
589 PREMAP_TASK_CALL,
590 SLICE_TASK_CALL,
591 MAP_TASK_CALL,
592 REPLICATE_TASK_CALL,
593 SELECT_VARIANT_CALL,
594 POSTMAP_TASK_CALL,
595 TASK_SELECT_SOURCES_CALL,
596 TASK_SPECULATE_CALL,
597 TASK_REPORT_PROFILING_CALL,
598 TASK_SELECT_SHARDING_FUNCTOR_CALL,
599 MAP_INLINE_CALL,
600 INLINE_SELECT_SOURCES_CALL,
601 INLINE_REPORT_PROFILING_CALL,
602 MAP_COPY_CALL,
603 COPY_SELECT_SOURCES_CALL,
604 COPY_SPECULATE_CALL,
605 COPY_REPORT_PROFILING_CALL,
606 COPY_SELECT_SHARDING_FUNCTOR_CALL,
607 CLOSE_SELECT_SOURCES_CALL,
608 CLOSE_REPORT_PROFILING_CALL,
609 CLOSE_SELECT_SHARDING_FUNCTOR_CALL,
610 MAP_ACQUIRE_CALL,
611 ACQUIRE_SPECULATE_CALL,
612 ACQUIRE_REPORT_PROFILING_CALL,
613 ACQUIRE_SELECT_SHARDING_FUNCTOR_CALL,
614 MAP_RELEASE_CALL,
615 RELEASE_SELECT_SOURCES_CALL,
616 RELEASE_SPECULATE_CALL,
617 RELEASE_REPORT_PROFILING_CALL,
618 RELEASE_SELECT_SHARDING_FUNCTOR_CALL,
619 SELECT_PARTITION_PROJECTION_CALL,
620 MAP_PARTITION_CALL,
621 PARTITION_SELECT_SOURCES_CALL,
622 PARTITION_REPORT_PROFILING_CALL,
623 PARTITION_SELECT_SHARDING_FUNCTOR_CALL,
624 FILL_SELECT_SHARDING_FUNCTOR_CALL,
625 MAP_FUTURE_MAP_REDUCTION_CALL,
626 CONFIGURE_CONTEXT_CALL,
627 SELECT_TUNABLE_VALUE_CALL,
628 MUST_EPOCH_SELECT_SHARDING_FUNCTOR_CALL,
629 MAP_MUST_EPOCH_CALL,
630 MAP_DATAFLOW_GRAPH_CALL,
631 MEMOIZE_OPERATION_CALL,
632 SELECT_TASKS_TO_MAP_CALL,
633 SELECT_STEAL_TARGETS_CALL,
634 PERMIT_STEAL_REQUEST_CALL,
635 HANDLE_MESSAGE_CALL,
636 HANDLE_TASK_RESULT_CALL,
637 HANDLE_INSTANCE_COLLECTION_CALL,
638 APPLICATION_MAPPER_CALL,
639 LAST_MAPPER_CALL,
640 };
641
642#define MAPPER_CALL_NAMES(name) \
643 const char *name[LAST_MAPPER_CALL] = { \
644 "get_mapper_name", \
645 "get_mapper_sync_model", \
646 "select_task_options", \
647 "premap_task", \
648 "slice_task", \
649 "map_task", \
650 "replicate_task", \
651 "select_task_variant", \
652 "postmap_task", \
653 "select_task_sources", \
654 "speculate (for task)", \
655 "report profiling (for task)", \
656 "select sharding functor (for task)", \
657 "map_inline", \
658 "select_inline_sources", \
659 "report profiling (for inline)", \
660 "map_copy", \
661 "select_copy_sources", \
662 "speculate (for copy)", \
663 "report_profiling (for copy)", \
664 "select sharding functor (for copy)", \
665 "select_close_sources", \
666 "report_profiling (for close)", \
667 "select sharding functor (for close)", \
668 "map_acquire", \
669 "speculate (for acquire)", \
670 "report_profiling (for acquire)", \
671 "select sharding functor (for acquire)", \
672 "map_release", \
673 "select_release_sources", \
674 "speculate (for release)", \
675 "report_profiling (for release)", \
676 "select sharding functor (for release)", \
677 "select partition projection", \
678 "map_partition", \
679 "select_partition_sources", \
680 "report_profiling (for partition)", \
681 "select sharding functor (for partition)", \
682 "select sharding functor (for fill)", \
683 "map future map reduction", \
684 "configure_context", \
685 "select_tunable_value", \
686 "select sharding functor (for must epoch)", \
687 "map_must_epoch", \
688 "map_dataflow_graph", \
689 "memoize_operation", \
690 "select_tasks_to_map", \
691 "select_steal_targets", \
692 "permit_steal_request", \
693 "handle_message", \
694 "handle_task_result", \
695 "handle_instance_collection", \
696 "application mapper call", \
697 }
698
699 // Methodology for assigning priorities to meta-tasks:
700 // Minimum and low priority are for things like profiling
701 // that we don't want to interfere with normal execution.
702 // Resource priority is reserved for tasks that have been
703 // granted resources like reservations. Running priority
704 // is the highest and guarantees that we drain out any
705 // previously running tasks over starting new ones. The rest
706 // of the priorities are classified as either 'throughput'
707 // or 'latency' sensitive. Under each of these two major
708 // categories there are four sub-priorities:
709 // - work: general work to be done
710 // - deferred: work that was already scheduled but
711 // for which a continuation had to be
712 // made so we don't want to wait behind
713 // work that hasn't started yet
714 // - messsage: a message from a remote node that we
715 // should handle sooner than our own
716 // work since work on the other node is
717 // blocked waiting on our response
718 // - response: a response message from a remote node
719 // that we should handle to unblock work
720 // on our own node
721 enum LgPriority {
722 LG_MIN_PRIORITY = INT_MIN,
723 LG_LOW_PRIORITY = -1,
724 // Throughput priorities
725 LG_THROUGHPUT_WORK_PRIORITY = 0,
726 LG_THROUGHPUT_DEFERRED_PRIORITY = 1,
727 LG_THROUGHPUT_MESSAGE_PRIORITY = 2,
728 LG_THROUGHPUT_RESPONSE_PRIORITY = 3,
729 // Latency priorities
730 LG_LATENCY_WORK_PRIORITY = 4,
731 LG_LATENCY_DEFERRED_PRIORITY = 5,
732 LG_LATENCY_MESSAGE_PRIORITY = 6,
733 LG_LATENCY_RESPONSE_PRIORITY = 7,
734 // Resource priorities
735 LG_RESOURCE_PRIORITY = 8,
736 // Running priorities
737 LG_RUNNING_PRIORITY = 9,
738 };
739
740 enum VirtualChannelKind {
741 // The default and work virtual channels are unordered
742 DEFAULT_VIRTUAL_CHANNEL = 0, // latency priority
743 THROUGHPUT_VIRTUAL_CHANNEL = 1, // throughput priority
744 LAST_UNORDERED_VIRTUAL_CHANNEL = THROUGHPUT_VIRTUAL_CHANNEL,
745 // All the rest of these are ordered (latency-priority) channels
746 MAPPER_VIRTUAL_CHANNEL = 1,
747 TASK_VIRTUAL_CHANNEL = 2,
748 INDEX_SPACE_VIRTUAL_CHANNEL = 3,
749 FIELD_SPACE_VIRTUAL_CHANNEL = 4,
750 REFERENCE_VIRTUAL_CHANNEL = 6,
751 UPDATE_VIRTUAL_CHANNEL = 7, // deferred-priority
752 SUBSET_VIRTUAL_CHANNEL = 8,
753 COLLECTIVE_VIRTUAL_CHANNEL = 9,
754 LAYOUT_CONSTRAINT_VIRTUAL_CHANNEL = 10,
755 EXPRESSION_VIRTUAL_CHANNEL = 11,
756 MIGRATION_VIRTUAL_CHANNEL = 12,
757 TRACING_VIRTUAL_CHANNEL = 13,
758 RENDEZVOUS_VIRTUAL_CHANNEL = 14,
759 PROFILING_VIRTUAL_CHANNEL = 15,
760 MAX_NUM_VIRTUAL_CHANNELS = 16, // this one must be last
761 };
762
763 enum MessageKind {
764 SEND_STARTUP_BARRIER,
765 TASK_MESSAGE,
766 STEAL_MESSAGE,
767 ADVERTISEMENT_MESSAGE,
768 SEND_REGISTRATION_CALLBACK,
769 SEND_REMOTE_TASK_REPLAY,
770 SEND_REMOTE_TASK_PROFILING_RESPONSE,
771 SEND_SHARED_OWNERSHIP,
772 SEND_INDEX_SPACE_REQUEST,
773 SEND_INDEX_SPACE_RESPONSE,
774 SEND_INDEX_SPACE_RETURN,
775 SEND_INDEX_SPACE_SET,
776 SEND_INDEX_SPACE_CHILD_REQUEST,
777 SEND_INDEX_SPACE_CHILD_RESPONSE,
778 SEND_INDEX_SPACE_COLORS_REQUEST,
779 SEND_INDEX_SPACE_COLORS_RESPONSE,
780 SEND_INDEX_SPACE_GENERATE_COLOR_REQUEST,
781 SEND_INDEX_SPACE_GENERATE_COLOR_RESPONSE,
782 SEND_INDEX_SPACE_RELEASE_COLOR,
783 SEND_INDEX_PARTITION_NOTIFICATION,
784 SEND_INDEX_PARTITION_REQUEST,
785 SEND_INDEX_PARTITION_RESPONSE,
786 SEND_INDEX_PARTITION_RETURN,
787 SEND_INDEX_PARTITION_CHILD_REQUEST,
788 SEND_INDEX_PARTITION_CHILD_RESPONSE,
789 SEND_INDEX_PARTITION_CHILD_REPLICATION,
790 SEND_INDEX_PARTITION_DISJOINT_UPDATE,
791 SEND_INDEX_PARTITION_SHARD_RECTS_REQUEST,
792 SEND_INDEX_PARTITION_SHARD_RECTS_RESPONSE,
793 SEND_INDEX_PARTITION_REMOTE_INTERFERENCE_REQUEST,
794 SEND_INDEX_PARTITION_REMOTE_INTERFERENCE_RESPONSE,
795 SEND_FIELD_SPACE_NODE,
796 SEND_FIELD_SPACE_REQUEST,
797 SEND_FIELD_SPACE_RETURN,
798 SEND_FIELD_SPACE_ALLOCATOR_REQUEST,
799 SEND_FIELD_SPACE_ALLOCATOR_RESPONSE,
800 SEND_FIELD_SPACE_ALLOCATOR_INVALIDATION,
801 SEND_FIELD_SPACE_ALLOCATOR_FLUSH,
802 SEND_FIELD_SPACE_ALLOCATOR_FREE,
803 SEND_FIELD_SPACE_INFOS_REQUEST,
804 SEND_FIELD_SPACE_INFOS_RESPONSE,
805 SEND_FIELD_ALLOC_REQUEST,
806 SEND_FIELD_SIZE_UPDATE,
807 SEND_FIELD_FREE,
808 SEND_FIELD_FREE_INDEXES,
809 SEND_FIELD_SPACE_LAYOUT_INVALIDATION,
810 SEND_LOCAL_FIELD_ALLOC_REQUEST,
811 SEND_LOCAL_FIELD_ALLOC_RESPONSE,
812 SEND_LOCAL_FIELD_FREE,
813 SEND_LOCAL_FIELD_UPDATE,
814 SEND_TOP_LEVEL_REGION_REQUEST,
815 SEND_TOP_LEVEL_REGION_RETURN,
816 INDEX_SPACE_DESTRUCTION_MESSAGE,
817 INDEX_PARTITION_DESTRUCTION_MESSAGE,
818 FIELD_SPACE_DESTRUCTION_MESSAGE,
819 LOGICAL_REGION_DESTRUCTION_MESSAGE,
820 INDIVIDUAL_REMOTE_FUTURE_SIZE,
821 INDIVIDUAL_REMOTE_OUTPUT_REGISTRATION,
822 INDIVIDUAL_REMOTE_MAPPED,
823 INDIVIDUAL_REMOTE_COMPLETE,
824 INDIVIDUAL_REMOTE_COMMIT,
825 SLICE_REMOTE_MAPPED,
826 SLICE_REMOTE_COMPLETE,
827 SLICE_REMOTE_COMMIT,
828 SLICE_RENDEZVOUS_CONCURRENT_MAPPED,
829 SLICE_CONCURRENT_ALLREDUCE_REQUEST,
830 SLICE_CONCURRENT_ALLREDUCE_RESPONSE,
831 SLICE_FIND_INTRA_DEP,
832 SLICE_RECORD_INTRA_DEP,
833 SLICE_REMOTE_COLLECTIVE_RENDEZVOUS,
834 SLICE_REMOTE_VERSIONING_COLLECTIVE_RENDEZVOUS,
835 SLICE_REMOTE_OUTPUT_EXTENTS,
836 SLICE_REMOTE_OUTPUT_REGISTRATION,
837 DISTRIBUTED_REMOTE_REGISTRATION,
838 DISTRIBUTED_DOWNGRADE_REQUEST,
839 DISTRIBUTED_DOWNGRADE_RESPONSE,
840 DISTRIBUTED_DOWNGRADE_SUCCESS,
841 DISTRIBUTED_DOWNGRADE_UPDATE,
842 DISTRIBUTED_DOWNGRADE_RESTART,
843 DISTRIBUTED_GLOBAL_ACQUIRE_REQUEST,
844 DISTRIBUTED_GLOBAL_ACQUIRE_RESPONSE,
845 DISTRIBUTED_VALID_ACQUIRE_REQUEST,
846 DISTRIBUTED_VALID_ACQUIRE_RESPONSE,
847 SEND_ATOMIC_RESERVATION_REQUEST,
848 SEND_ATOMIC_RESERVATION_RESPONSE,
849 SEND_PADDED_RESERVATION_REQUEST,
850 SEND_PADDED_RESERVATION_RESPONSE,
851 SEND_CREATED_REGION_CONTEXTS,
852 SEND_MATERIALIZED_VIEW,
853 SEND_FILL_VIEW,
854 SEND_FILL_VIEW_VALUE,
855 SEND_PHI_VIEW,
856 SEND_REDUCTION_VIEW,
857 SEND_REPLICATED_VIEW,
858 SEND_ALLREDUCE_VIEW,
859 SEND_INSTANCE_MANAGER,
860 SEND_MANAGER_UPDATE,
861 SEND_COLLECTIVE_DISTRIBUTE_FILL,
862 SEND_COLLECTIVE_DISTRIBUTE_POINT,
863 SEND_COLLECTIVE_DISTRIBUTE_POINTWISE,
864 SEND_COLLECTIVE_DISTRIBUTE_REDUCTION,
865 SEND_COLLECTIVE_DISTRIBUTE_BROADCAST,
866 SEND_COLLECTIVE_DISTRIBUTE_REDUCECAST,
867 SEND_COLLECTIVE_DISTRIBUTE_HOURGLASS,
868 SEND_COLLECTIVE_DISTRIBUTE_ALLREDUCE,
869 SEND_COLLECTIVE_HAMMER_REDUCTION,
870 SEND_COLLECTIVE_FUSE_GATHER,
871 SEND_COLLECTIVE_USER_REQUEST,
872 SEND_COLLECTIVE_USER_RESPONSE,
873 SEND_COLLECTIVE_REGISTER_USER,
874 SEND_COLLECTIVE_REMOTE_INSTANCES_REQUEST,
875 SEND_COLLECTIVE_REMOTE_INSTANCES_RESPONSE,
876 SEND_COLLECTIVE_NEAREST_INSTANCES_REQUEST,
877 SEND_COLLECTIVE_NEAREST_INSTANCES_RESPONSE,
878 SEND_COLLECTIVE_REMOTE_REGISTRATION,
879 SEND_COLLECTIVE_FINALIZE_MAPPING,
880 SEND_COLLECTIVE_VIEW_CREATION,
881 SEND_COLLECTIVE_VIEW_DELETION,
882 SEND_COLLECTIVE_VIEW_RELEASE,
883 SEND_COLLECTIVE_VIEW_NOTIFICATION,
884 SEND_COLLECTIVE_VIEW_MAKE_VALID,
885 SEND_COLLECTIVE_VIEW_MAKE_INVALID,
886 SEND_COLLECTIVE_VIEW_INVALIDATE_REQUEST,
887 SEND_COLLECTIVE_VIEW_INVALIDATE_RESPONSE,
888 SEND_COLLECTIVE_VIEW_ADD_REMOTE_REFERENCE,
889 SEND_COLLECTIVE_VIEW_REMOVE_REMOTE_REFERENCE,
890 SEND_CREATE_TOP_VIEW_REQUEST,
891 SEND_CREATE_TOP_VIEW_RESPONSE,
892 SEND_VIEW_REQUEST,
893 SEND_VIEW_REGISTER_USER,
894 SEND_VIEW_FIND_COPY_PRE_REQUEST,
895 SEND_VIEW_ADD_COPY_USER,
896 SEND_VIEW_FIND_LAST_USERS_REQUEST,
897 SEND_VIEW_FIND_LAST_USERS_RESPONSE,
898 SEND_MANAGER_REQUEST,
899 SEND_FUTURE_RESULT,
900 SEND_FUTURE_RESULT_SIZE,
901 SEND_FUTURE_SUBSCRIPTION,
902 SEND_FUTURE_CREATE_INSTANCE_REQUEST,
903 SEND_FUTURE_CREATE_INSTANCE_RESPONSE,
904 SEND_FUTURE_MAP_REQUEST,
905 SEND_FUTURE_MAP_RESPONSE,
906 SEND_REPL_COMPUTE_EQUIVALENCE_SETS,
907 SEND_REPL_OUTPUT_EQUIVALENCE_SET,
908 SEND_REPL_REFINE_EQUIVALENCE_SETS,
909 SEND_REPL_EQUIVALENCE_SET_NOTIFICATION,
910 SEND_REPL_INTRA_SPACE_DEP,
911 SEND_REPL_BROADCAST_UPDATE,
912 SEND_REPL_CREATED_REGIONS,
913 SEND_REPL_TRACE_EVENT_REQUEST,
914 SEND_REPL_TRACE_EVENT_RESPONSE,
915 SEND_REPL_TRACE_EVENT_TRIGGER,
916 SEND_REPL_TRACE_FRONTIER_REQUEST,
917 SEND_REPL_TRACE_FRONTIER_RESPONSE,
918 SEND_REPL_TRACE_UPDATE,
919 SEND_REPL_FIND_TRACE_SETS,
920 SEND_REPL_IMPLICIT_RENDEZVOUS,
921 SEND_REPL_FIND_COLLECTIVE_VIEW,
922 SEND_MAPPER_MESSAGE,
923 SEND_MAPPER_BROADCAST,
924 SEND_TASK_IMPL_SEMANTIC_REQ,
925 SEND_INDEX_SPACE_SEMANTIC_REQ,
926 SEND_INDEX_PARTITION_SEMANTIC_REQ,
927 SEND_FIELD_SPACE_SEMANTIC_REQ,
928 SEND_FIELD_SEMANTIC_REQ,
929 SEND_LOGICAL_REGION_SEMANTIC_REQ,
930 SEND_LOGICAL_PARTITION_SEMANTIC_REQ,
931 SEND_TASK_IMPL_SEMANTIC_INFO,
932 SEND_INDEX_SPACE_SEMANTIC_INFO,
933 SEND_INDEX_PARTITION_SEMANTIC_INFO,
934 SEND_FIELD_SPACE_SEMANTIC_INFO,
935 SEND_FIELD_SEMANTIC_INFO,
936 SEND_LOGICAL_REGION_SEMANTIC_INFO,
937 SEND_LOGICAL_PARTITION_SEMANTIC_INFO,
938 SEND_REMOTE_CONTEXT_REQUEST,
939 SEND_REMOTE_CONTEXT_RESPONSE,
940 SEND_REMOTE_CONTEXT_PHYSICAL_REQUEST,
941 SEND_REMOTE_CONTEXT_PHYSICAL_RESPONSE,
942 SEND_REMOTE_CONTEXT_FIND_COLLECTIVE_VIEW_REQUEST,
943 SEND_REMOTE_CONTEXT_FIND_COLLECTIVE_VIEW_RESPONSE,
944 SEND_REMOTE_CONTEXT_REFINE_EQUIVALENCE_SETS,
945 SEND_REMOTE_CONTEXT_FIND_TRACE_LOCAL_SETS_REQUEST,
946 SEND_REMOTE_CONTEXT_FIND_TRACE_LOCAL_SETS_RESPONSE,
947 SEND_COMPUTE_EQUIVALENCE_SETS_REQUEST,
948 SEND_COMPUTE_EQUIVALENCE_SETS_RESPONSE,
949 SEND_COMPUTE_EQUIVALENCE_SETS_PENDING,
950 SEND_OUTPUT_EQUIVALENCE_SET_REQUEST,
951 SEND_OUTPUT_EQUIVALENCE_SET_RESPONSE,
952 SEND_CANCEL_EQUIVALENCE_SETS_SUBSCRIPTION,
953 SEND_INVALIDATE_EQUIVALENCE_SETS_SUBSCRIPTION,
954 SEND_EQUIVALENCE_SET_CREATION,
955 SEND_EQUIVALENCE_SET_REUSE,
956 SEND_EQUIVALENCE_SET_REQUEST,
957 SEND_EQUIVALENCE_SET_RESPONSE,
958 SEND_EQUIVALENCE_SET_REPLICATION_REQUEST,
959 SEND_EQUIVALENCE_SET_REPLICATION_RESPONSE,
960 SEND_EQUIVALENCE_SET_MIGRATION,
961 SEND_EQUIVALENCE_SET_OWNER_UPDATE,
962 SEND_EQUIVALENCE_SET_CLONE_REQUEST,
963 SEND_EQUIVALENCE_SET_CLONE_RESPONSE,
964 SEND_EQUIVALENCE_SET_CAPTURE_REQUEST,
965 SEND_EQUIVALENCE_SET_CAPTURE_RESPONSE,
966 SEND_EQUIVALENCE_SET_REMOTE_REQUEST_INSTANCES,
967 SEND_EQUIVALENCE_SET_REMOTE_REQUEST_INVALID,
968 SEND_EQUIVALENCE_SET_REMOTE_REQUEST_ANTIVALID,
969 SEND_EQUIVALENCE_SET_REMOTE_UPDATES,
970 SEND_EQUIVALENCE_SET_REMOTE_ACQUIRES,
971 SEND_EQUIVALENCE_SET_REMOTE_RELEASES,
972 SEND_EQUIVALENCE_SET_REMOTE_COPIES_ACROSS,
973 SEND_EQUIVALENCE_SET_REMOTE_OVERWRITES,
974 SEND_EQUIVALENCE_SET_REMOTE_FILTERS,
975 SEND_EQUIVALENCE_SET_REMOTE_INSTANCES,
976 SEND_EQUIVALENCE_SET_FILTER_INVALIDATIONS,
977 SEND_INSTANCE_REQUEST,
978 SEND_INSTANCE_RESPONSE,
979 SEND_EXTERNAL_CREATE_REQUEST,
980 SEND_EXTERNAL_CREATE_RESPONSE,
981 SEND_EXTERNAL_ATTACH,
982 SEND_EXTERNAL_DETACH,
983 SEND_GC_PRIORITY_UPDATE,
984 SEND_GC_REQUEST,
985 SEND_GC_RESPONSE,
986 SEND_GC_ACQUIRE,
987 SEND_GC_FAILED,
988 SEND_GC_MISMATCH,
989 SEND_GC_NOTIFY,
990 SEND_GC_DEBUG_REQUEST,
991 SEND_GC_DEBUG_RESPONSE,
992 SEND_GC_RECORD_EVENT,
993 SEND_ACQUIRE_REQUEST,
994 SEND_ACQUIRE_RESPONSE,
995 SEND_VARIANT_BROADCAST,
996 SEND_CONSTRAINT_REQUEST,
997 SEND_CONSTRAINT_RESPONSE,
998 SEND_CONSTRAINT_RELEASE,
999 SEND_TOP_LEVEL_TASK_COMPLETE,
1000 SEND_MPI_RANK_EXCHANGE,
1001 SEND_REPLICATE_DISTRIBUTION,
1002 SEND_REPLICATE_COLLECTIVE_VERSIONING,
1003 SEND_REPLICATE_COLLECTIVE_MAPPING,
1004 SEND_REPLICATE_VIRTUAL_RENDEZVOUS,
1005 SEND_REPLICATE_STARTUP_COMPLETE,
1006 SEND_REPLICATE_POST_MAPPED,
1007 SEND_REPLICATE_TRIGGER_COMPLETE,
1008 SEND_REPLICATE_TRIGGER_COMMIT,
1009 SEND_CONTROL_REPLICATE_RENDEZVOUS_MESSAGE,
1010 SEND_LIBRARY_MAPPER_REQUEST,
1011 SEND_LIBRARY_MAPPER_RESPONSE,
1012 SEND_LIBRARY_TRACE_REQUEST,
1013 SEND_LIBRARY_TRACE_RESPONSE,
1014 SEND_LIBRARY_PROJECTION_REQUEST,
1015 SEND_LIBRARY_PROJECTION_RESPONSE,
1016 SEND_LIBRARY_SHARDING_REQUEST,
1017 SEND_LIBRARY_SHARDING_RESPONSE,
1018 SEND_LIBRARY_TASK_REQUEST,
1019 SEND_LIBRARY_TASK_RESPONSE,
1020 SEND_LIBRARY_REDOP_REQUEST,
1021 SEND_LIBRARY_REDOP_RESPONSE,
1022 SEND_LIBRARY_SERDEZ_REQUEST,
1023 SEND_LIBRARY_SERDEZ_RESPONSE,
1024 SEND_REMOTE_OP_REPORT_UNINIT,
1025 SEND_REMOTE_OP_PROFILING_COUNT_UPDATE,
1026 SEND_REMOTE_OP_COMPLETION_EFFECT,
1027 SEND_REMOTE_TRACE_UPDATE,
1028 SEND_REMOTE_TRACE_RESPONSE,
1029 SEND_FREE_EXTERNAL_ALLOCATION,
1030 SEND_NOTIFY_COLLECTED_INSTANCES,
1031 SEND_CREATE_FUTURE_INSTANCE_REQUEST,
1032 SEND_CREATE_FUTURE_INSTANCE_RESPONSE,
1033 SEND_FREE_FUTURE_INSTANCE,
1034 SEND_REMOTE_DISTRIBUTED_ID_REQUEST,
1035 SEND_REMOTE_DISTRIBUTED_ID_RESPONSE,
1036 SEND_CONTROL_REPLICATION_FUTURE_ALLREDUCE,
1037 SEND_CONTROL_REPLICATION_FUTURE_BROADCAST,
1038 SEND_CONTROL_REPLICATION_FUTURE_REDUCTION,
1039 SEND_CONTROL_REPLICATION_VALUE_ALLREDUCE,
1040 SEND_CONTROL_REPLICATION_VALUE_BROADCAST,
1041 SEND_CONTROL_REPLICATION_VALUE_EXCHANGE,
1042 SEND_CONTROL_REPLICATION_BUFFER_BROADCAST,
1043 SEND_CONTROL_REPLICATION_SHARD_SYNC_TREE,
1044 SEND_CONTROL_REPLICATION_SHARD_EVENT_TREE,
1045 SEND_CONTROL_REPLICATION_SINGLE_TASK_TREE,
1046 SEND_CONTROL_REPLICATION_CROSS_PRODUCT_PARTITION,
1047 SEND_CONTROL_REPLICATION_SHARDING_GATHER_COLLECTIVE,
1048 SEND_CONTROL_REPLICATION_INDIRECT_COPY_EXCHANGE,
1049 SEND_CONTROL_REPLICATION_FIELD_DESCRIPTOR_EXCHANGE,
1050 SEND_CONTROL_REPLICATION_FIELD_DESCRIPTOR_GATHER,
1051 SEND_CONTROL_REPLICATION_DEPPART_RESULT_SCATTER,
1052 SEND_CONTROL_REPLICATION_BUFFER_EXCHANGE,
1053 SEND_CONTROL_REPLICATION_FUTURE_NAME_EXCHANGE,
1054 SEND_CONTROL_REPLICATION_MUST_EPOCH_MAPPING_BROADCAST,
1055 SEND_CONTROL_REPLICATION_MUST_EPOCH_MAPPING_EXCHANGE,
1056 SEND_CONTROL_REPLICATION_MUST_EPOCH_DEPENDENCE_EXCHANGE,
1057 SEND_CONTROL_REPLICATION_MUST_EPOCH_COMPLETION_EXCHANGE,
1058 SEND_CONTROL_REPLICATION_CHECK_COLLECTIVE_MAPPING,
1059 SEND_CONTROL_REPLICATION_CHECK_COLLECTIVE_SOURCES,
1060 SEND_CONTROL_REPLICATION_TEMPLATE_INDEX_EXCHANGE,
1061 SEND_CONTROL_REPLICATION_UNORDERED_EXCHANGE,
1062 SEND_CONTROL_REPLICATION_CONSENSUS_MATCH,
1063 SEND_CONTROL_REPLICATION_VERIFY_CONTROL_REPLICATION_EXCHANGE,
1064 SEND_CONTROL_REPLICATION_OUTPUT_SIZE_EXCHANGE,
1065 SEND_CONTROL_REPLICATION_INDEX_ATTACH_LAUNCH_SPACE,
1066 SEND_CONTROL_REPLICATION_INDEX_ATTACH_UPPER_BOUND,
1067 SEND_CONTROL_REPLICATION_INDEX_ATTACH_EXCHANGE,
1068 SEND_CONTROL_REPLICATION_SHARD_PARTICIPANTS_EXCHANGE,
1069 SEND_CONTROL_REPLICATION_IMPLICIT_SHARDING_FUNCTOR,
1070 SEND_CONTROL_REPLICATION_CREATE_FILL_VIEW,
1071 SEND_CONTROL_REPLICATION_VERSIONING_RENDEZVOUS,
1072 SEND_CONTROL_REPLICATION_VIEW_RENDEZVOUS,
1073 SEND_CONTROL_REPLICATION_CONCURRENT_MAPPING_RENDEZVOUS,
1074 SEND_CONTROL_REPLICATION_CONCURRENT_ALLREDUCE,
1075 SEND_CONTROL_REPLICATION_PROJECTION_TREE_EXCHANGE,
1076 SEND_CONTROL_REPLICATION_TIMEOUT_MATCH_EXCHANGE,
1077 SEND_CONTROL_REPLICATION_MASK_EXCHANGE,
1078 SEND_CONTROL_REPLICATION_PREDICATE_EXCHANGE,
1079 SEND_CONTROL_REPLICATION_CROSS_PRODUCT_EXCHANGE,
1080 SEND_CONTROL_REPLICATION_TRACING_SET_DEDUPLICATION,
1081 SEND_CONTROL_REPLICATION_SLOW_BARRIER,
1082 SEND_PROFILER_EVENT_TRIGGER,
1083 SEND_PROFILER_EVENT_POISON,
1084 SEND_SHUTDOWN_NOTIFICATION,
1085 SEND_SHUTDOWN_RESPONSE,
1086 LAST_SEND_KIND, // This one must be last
1087 };
1088
1089#define LG_MESSAGE_DESCRIPTIONS(name) \
1090 const char *name[LAST_SEND_KIND] = { \
1091 "Send Startup Barrier", \
1092 "Task Message", \
1093 "Steal Message", \
1094 "Advertisement Message", \
1095 "Send Registration Callback", \
1096 "Send Remote Task Replay", \
1097 "Send Remote Task Profiling Response", \
1098 "Send Shared Ownership", \
1099 "Send Index Space Request", \
1100 "Send Index Space Response", \
1101 "Send Index Space Return", \
1102 "Send Index Space Set", \
1103 "Send Index Space Child Request", \
1104 "Send Index Space Child Response", \
1105 "Send Index Space Colors Request", \
1106 "Send Index Space Colors Response", \
1107 "Send Index Space Generate Color Request", \
1108 "Send Index Space Generate Color Response", \
1109 "Send Index Space Release Color", \
1110 "Send Index Partition Notification", \
1111 "Send Index Partition Request", \
1112 "Send Index Partition Response", \
1113 "Send Index Partition Return", \
1114 "Send Index Partition Child Request", \
1115 "Send Index Partition Child Response", \
1116 "Send Index Partition Child Replication", \
1117 "Send Index Partition Disjoint Update", \
1118 "Send Index Partition Shard Rects Request", \
1119 "Send Index Partition Shard Rects Response", \
1120 "Send Index Partition Remote Interference Request", \
1121 "Send Index Partition Remote Interference Response", \
1122 "Send Field Space Node", \
1123 "Send Field Space Request", \
1124 "Send Field Space Return", \
1125 "Send Field Space Allocator Request", \
1126 "Send Field Space Allocator Response", \
1127 "Send Field Space Allocator Invalidation", \
1128 "Send Field Space Allocator Flush", \
1129 "Send Field Space Allocator Free", \
1130 "Send Field Space Infos Request", \
1131 "Send Field Space Infos Response", \
1132 "Send Field Alloc Request", \
1133 "Send Field Size Update", \
1134 "Send Field Free", \
1135 "Send Field Free Indexes", \
1136 "Send Field Space Layout Invalidation", \
1137 "Send Local Field Alloc Request", \
1138 "Send Local Field Alloc Response", \
1139 "Send Local Field Free", \
1140 "Send Local Field Update", \
1141 "Send Top Level Region Request", \
1142 "Send Top Level Region Return", \
1143 "Index Space Destruction", \
1144 "Index Partition Destruction", \
1145 "Field Space Destruction", \
1146 "Logical Region Destruction", \
1147 "Individual Remote Future Size", \
1148 "Individual Remote Output Region Registration", \
1149 "Individual Remote Mapped", \
1150 "Individual Remote Complete", \
1151 "Individual Remote Commit", \
1152 "Slice Remote Mapped", \
1153 "Slice Remote Complete", \
1154 "Slice Remote Commit", \
1155 "Slice Rendezvous Concurrent Mapped", \
1156 "Slice Concurrent Allreduce Request", \
1157 "Slice Concurrent Allreduce Response", \
1158 "Slice Find Intra-Space Dependence", \
1159 "Slice Record Intra-Space Dependence", \
1160 "Slice Remote Collective Rendezvous", \
1161 "Slice Remote Collective Versioning Rendezvous", \
1162 "Slice Remote Output Region Extents", \
1163 "Slice Remote Output Region Registration", \
1164 "Distributed Remote Registration", \
1165 "Distributed Downgrade Request", \
1166 "Distributed Downgrade Response", \
1167 "Distributed Downgrade Success", \
1168 "Distributed Downgrade Update", \
1169 "Distributed Downgrade Restart", \
1170 "Distributed Global Acquire Request", \
1171 "Distributed Global Acquire Response", \
1172 "Distributed Valid Acquire Request", \
1173 "Distributed Valid Acquire Response", \
1174 "Send Atomic Reservation Request", \
1175 "Send Atomic Reservation Response", \
1176 "Send Padded Reservation Request", \
1177 "Send Padded Reservation Response", \
1178 "Send Created Region Contexts", \
1179 "Send Materialized View", \
1180 "Send Fill View", \
1181 "Send Fill View Value", \
1182 "Send Phi View", \
1183 "Send Reduction View", \
1184 "Send Replicated View", \
1185 "Send Allreduce View", \
1186 "Send Instance Manager", \
1187 "Send Manager Update", \
1188 "Send Collective Distribute Fill", \
1189 "Send Collective Distribute Point", \
1190 "Send Collective Distribute Pointwise", \
1191 "Send Collective Distribute Reduction", \
1192 "Send Collective Distribute Broadcast", \
1193 "Send Collective Distribute Reducecast", \
1194 "Send Collective Distribute Hourglass", \
1195 "Send Collective Distribute Allreduce", \
1196 "Send Collective Hammer Reduction", \
1197 "Send Collective Fuse Gather", \
1198 "Send Collective User Request", \
1199 "Send Collective User Response", \
1200 "Send Collective Individual Register User", \
1201 "Send Collective Remote Instances Request", \
1202 "Send Collective Remote Instances Response", \
1203 "Send Collective Nearest Instances Request", \
1204 "Send Collective Nearest Instances Response", \
1205 "Send Collective Remote Registration", \
1206 "Send Collective Finalize Mapping", \
1207 "Send Collective View Creation", \
1208 "Send Collective View Deletion", \
1209 "Send Collective View Release", \
1210 "Send Collective View Deletion Notification", \
1211 "Send Collective View Make Valid", \
1212 "Send Collective View Make Invalid", \
1213 "Send Collective View Invalidate Request", \
1214 "Send Collective View Invalidate Response", \
1215 "Send Collective View Add Remote Reference", \
1216 "Send Collective View Remove Remote Reference", \
1217 "Send Create Top View Request", \
1218 "Send Create Top View Response", \
1219 "Send View Request", \
1220 "Send View Register User", \
1221 "Send View Find Copy Preconditions Request", \
1222 "Send View Add Copy User", \
1223 "Send View Find Last Users Request", \
1224 "Send View Find Last Users Response", \
1225 "Send Manager Request", \
1226 "Send Future Result", \
1227 "Send Future Result Size", \
1228 "Send Future Subscription", \
1229 "Send Future Create Instance Request", \
1230 "Send Future Create Instance Response", \
1231 "Send Future Map Future Request", \
1232 "Send Future Map Future Response", \
1233 "Send Replicate Compute Equivalence Sets", \
1234 "Send Replicate Register Output Equivalence Set", \
1235 "Send Replicate Refine Equivalence Sets", \
1236 "Send Replicate Equivalence Set Notification", \
1237 "Send Replicate Intra Space Dependence", \
1238 "Send Replicate Broadcast Update", \
1239 "Send Replicate Created Regions Return", \
1240 "Send Replicate Trace Event Request", \
1241 "Send Replicate Trace Event Response", \
1242 "Send Replicate Trace Event Trigger", \
1243 "Send Replicate Trace Frontier Request", \
1244 "Send Replicate Trace Frontier Response", \
1245 "Send Replicate Trace Update", \
1246 "Send Replicate Find Trace Local Sets", \
1247 "Send Replicate Implicit Rendezvous", \
1248 "Send Replicate Find or Create Collective View", \
1249 "Send Mapper Message", \
1250 "Send Mapper Broadcast", \
1251 "Send Task Impl Semantic Req", \
1252 "Send Index Space Semantic Req", \
1253 "Send Index Partition Semantic Req", \
1254 "Send Field Space Semantic Req", \
1255 "Send Field Semantic Req", \
1256 "Send Logical Region Semantic Req", \
1257 "Send Logical Partition Semantic Req", \
1258 "Send Task Impl Semantic Info", \
1259 "Send Index Space Semantic Info", \
1260 "Send Index Partition Semantic Info", \
1261 "Send Field Space Semantic Info", \
1262 "Send Field Semantic Info", \
1263 "Send Logical Region Semantic Info", \
1264 "Send Logical Partition Semantic Info", \
1265 "Send Remote Context Request", \
1266 "Send Remote Context Response", \
1267 "Send Remote Context Physical Request", \
1268 "Send Remote Context Physical Response", \
1269 "Send Remote Context Find Collective View Request", \
1270 "Send Remote Context Find Collective View Response", \
1271 "Send Remote Context Refine Equivalence Sets", \
1272 "Send Remote Context Find Trace Local Sets Request", \
1273 "Send Remote Context Find Trace Local Sets Response", \
1274 "Send Compute Equivalence Sets Request", \
1275 "Send Compute Equivalence Sets Response", \
1276 "Send Compute Equivalence Sets Pending", \
1277 "Send Register Output Equivalence Set Request", \
1278 "Send Register Output Equivalence Set Response", \
1279 "Send Cancel Equivalence Sets Subscription", \
1280 "Send Invalidate Equivalence Sets Subscription", \
1281 "Send Equivalence Set Creation", \
1282 "Send Equivalence Set Reuse", \
1283 "Send Equivalence Set Request", \
1284 "Send Equivalence Set Response", \
1285 "Send Equivalence Set Replication Request", \
1286 "Send Equivalence Set Replication Response", \
1287 "Send Equivalence Set Migration", \
1288 "Send Equivalence Set Owner Update", \
1289 "Send Equivalence Set Clone Request", \
1290 "Send Equivalence Set Clone Response", \
1291 "Send Equivalence Set Tracing Capture Request", \
1292 "Send Equivalence Set Tracing Capture Response", \
1293 "Send Equivalence Set Remote Request Instances", \
1294 "Send Equivalence Set Remote Request Invalid", \
1295 "Send Equivalence Set Remote Request Antivalid", \
1296 "Send Equivalence Set Remote Updates", \
1297 "Send Equivalence Set Remote Acquires", \
1298 "Send Equivalence Set Remote Releases", \
1299 "Send Equivalence Set Remote Copies Across", \
1300 "Send Equivalence Set Remote Overwrites", \
1301 "Send Equivalence Set Remote Filters", \
1302 "Send Equivalence Set Remote Instances", \
1303 "Send Equivalence Set Filter Invalidations", \
1304 "Send Instance Request", \
1305 "Send Instance Response", \
1306 "Send External Create Request", \
1307 "Send External Create Response", \
1308 "Send External Attach", \
1309 "Send External Detach", \
1310 "Send GC Priority Update", \
1311 "Send GC Request", \
1312 "Send GC Response", \
1313 "Send GC Acquire Request", \
1314 "Send GC Acquire Failed", \
1315 "Send GC Packed Reference Mismatch", \
1316 "Send GC Notify Collected", \
1317 "Send GC Debug Request", \
1318 "Send GC Debug Response", \
1319 "Send GC Record Event", \
1320 "Send Acquire Request", \
1321 "Send Acquire Response", \
1322 "Send Task Variant Broadcast", \
1323 "Send Constraint Request", \
1324 "Send Constraint Response", \
1325 "Send Constraint Release", \
1326 "Top Level Task Complete", \
1327 "Send MPI Rank Exchange", \
1328 "Send Replication Distribution", \
1329 "Send Replication Collective Versioning", \
1330 "Send Replication Collective Mapping", \
1331 "Send Replication Virtual Mapping Rendezvous", \
1332 "Send Replication Startup Complete", \
1333 "Send Replication Post Mapped", \
1334 "Send Replication Trigger Complete", \
1335 "Send Replication Trigger Commit", \
1336 "Send Control Replication Rendezvous Message", \
1337 "Send Library Mapper Request", \
1338 "Send Library Mapper Response", \
1339 "Send Library Trace Request", \
1340 "Send Library Trace Response", \
1341 "Send Library Projection Request", \
1342 "Send Library Projection Response", \
1343 "Send Library Sharding Request", \
1344 "Send Library Sharding Response", \
1345 "Send Library Task Request", \
1346 "Send Library Task Response", \
1347 "Send Library Redop Request", \
1348 "Send Library Redop Response", \
1349 "Send Library Serdez Request", \
1350 "Send Library Serdez Response", \
1351 "Remote Op Report Uninitialized", \
1352 "Remote Op Profiling Count Update", \
1353 "Remote Op Completion Effect", \
1354 "Send Remote Trace Update", \
1355 "Send Remote Trace Response", \
1356 "Send Free External Allocation", \
1357 "Send Notify Collected Instances", \
1358 "Send Create Future Instance Request", \
1359 "Send Create Future Instance Response", \
1360 "Send Free Future Instance", \
1361 "Send Remote Distributed ID Request", \
1362 "Send Remote Distributed ID Response", \
1363 "Control Replication Collective Future All-Reduce", \
1364 "Control Replication Collective Future Broadcast", \
1365 "Control Replication Collective Future Reduction", \
1366 "Control Replication Collective Value All-Reduce", \
1367 "Control Replication Collective Value Broadcast", \
1368 "Control Replication Collective Value Exchange", \
1369 "Control Replication Collective Buffer Broadcast", \
1370 "Control Replication Collective Shard Sync Tree", \
1371 "Control Replication Collective Shard Event Tree", \
1372 "Control Replication Collective Single Task Tree", \
1373 "Control Replication Collective Cross Product Partition", \
1374 "Control Replication Collective Sharding Gather Collective", \
1375 "Control Replication Collective Indirect Copy Exchange", \
1376 "Control Replication Collective Field Descriptor Exchange", \
1377 "Control Replication Collective Field Descriptor Gather", \
1378 "Control Replication Collective Deppart Result Scatter", \
1379 "Control Replication Collective Buffer Exchange", \
1380 "Control Replication Collective Future Name Exchange", \
1381 "Control Replication Collective Must Epoch Mapping Broadcast",\
1382 "Control Replication Collective Must Epoch Mapping Exchange", \
1383 "Control Replication Collective Must Epoch Dependence Exchange",\
1384 "Control Replication Collective Must Epoch Completion Exchange",\
1385 "Control Replication Collective Check Mapping", \
1386 "Control Replication Collective Check Sources", \
1387 "Control Replication Collective Template Index Exchange", \
1388 "Control Replication Collective Unordered Exchange", \
1389 "Control Replication Collective Consensus Match", \
1390 "Control Replication Collective Verify Control Replication Exchange",\
1391 "Control Replication Collective Output Size Exchange", \
1392 "Control Replication Collective Index Attach Launch Space", \
1393 "Control Replication Collective Index Attach Upper Bound", \
1394 "Control Replication Collective Index Attach Exchange", \
1395 "Control Replication Collective Shard Participants Exchange", \
1396 "Control Replication Collective Implicit Sharding Functor", \
1397 "Control Replication Collective Create Fill View", \
1398 "Control Replication Collective Versioning Rendezvous", \
1399 "Control Replication Collective View Rendezvous", \
1400 "Control Replication Collective Concurrent Mapping Rendezvous",\
1401 "Control Replication Collective Concurrent Allreduce", \
1402 "Control Replication Collective Projection Tree Exchange", \
1403 "Control Replication Collective Timeout Match Exchange", \
1404 "Control Replication Collective Mask Exchange", \
1405 "Control Replication Collective Predicate Exchange", \
1406 "Control Replication Collective Cross Product Exchange", \
1407 "Control Replication Collective Tracing Set Deduplication", \
1408 "Control Replication Collective Slow Barrier", \
1409 "Send Profiler Event Trigger", \
1410 "Send Profiler Event Poison", \
1411 "Send Shutdown Notification", \
1412 "Send Shutdown Response", \
1413 };
1414
1415 // Runtime task numbering
1416 enum {
1417 LG_STARTUP_TASK_ID = Realm::Processor::TASK_ID_PROCESSOR_INIT,
1418 LG_SHUTDOWN_TASK_ID = Realm::Processor::TASK_ID_PROCESSOR_SHUTDOWN,
1419 LG_TASK_ID = Realm::Processor::TASK_ID_FIRST_AVAILABLE,
1420#ifdef LEGION_SEPARATE_META_TASKS
1421 LG_LEGION_PROFILING_ID = LG_TASK_ID+LG_LAST_TASK_ID+LAST_SEND_KIND,
1422 LG_ENDPOINT_TASK_ID = LG_TASK_ID+LG_LAST_TASK_ID+LAST_SEND_KIND+1,
1423 LG_APP_PROC_TASK_ID = LG_TASK_ID+LG_LAST_TASK_ID+LAST_SEND_KIND+2,
1424 LG_TASK_ID_AVAILABLE = LG_APP_PROC_TASK_ID+LG_LAST_TASK_ID,
1425#else
1426 LG_LEGION_PROFILING_ID = LG_TASK_ID+1,
1427 LG_ENDPOINT_TASK_ID = LG_TASK_ID+2,
1428 LG_APP_PROC_TASK_ID = LG_TASK_ID+3,
1429 LG_TASK_ID_AVAILABLE = LG_TASK_ID+4,
1430#endif
1431 };
1432
1433 enum RuntimeCallKind {
1434 // Mapper runtime call kinds
1435 MAPPER_SEND_MESSAGE_CALL,
1436 MAPPER_BROADCAST_CALL,
1437 MAPPER_UNPACK_INSTANCE_CALL,
1438 MAPPER_CREATE_EVENT_CALL,
1439 MAPPER_HAS_TRIGGERED_CALL,
1440 MAPPER_TRIGGER_EVENT_CALL,
1441 MAPPER_WAIT_EVENT_CALL,
1442 MAPPER_FIND_EXECUTION_CONSTRAINTS_CALL,
1443 MAPPER_FIND_TASK_LAYOUT_CONSTRAINTS_CALL,
1444 MAPPER_FIND_LAYOUT_CONSTRAINTS_CALL,
1445 MAPPER_REGISTER_LAYOUT_CALL,
1446 MAPPER_RELEASE_LAYOUT_CALL,
1447 MAPPER_CONSTRAINTS_CONFLICT_CALL,
1448 MAPPER_CONSTRAINTS_ENTAIL_CALL,
1449 MAPPER_FIND_VALID_VARIANTS_CALL,
1450 MAPPER_FIND_TASK_VARIANT_NAME_CALL,
1451 MAPPER_IS_LEAF_VARIANT_CALL,
1452 MAPPER_IS_INNER_VARIANT_CALL,
1453 MAPPER_IS_IDEMPOTENT_VARIANT_CALL,
1454 MAPPER_IS_REPLICABLE_VARIANT_CALL,
1455 MAPPER_REGISTER_TASK_VARIANT_CALL,
1456 MAPPER_FILTER_VARIANTS_CALL,
1457 MAPPER_FILTER_INSTANCES_CALL,
1458 MAPPER_CREATE_PHYSICAL_INSTANCE_CALL,
1459 MAPPER_FIND_OR_CREATE_PHYSICAL_INSTANCE_CALL,
1460 MAPPER_FIND_PHYSICAL_INSTANCE_CALL,
1461 MAPPER_FIND_PHYSICAL_INSTANCES_CALL,
1462 MAPPER_SET_GC_PRIORITY_CALL,
1463 MAPPER_ACQUIRE_INSTANCE_CALL,
1464 MAPPER_ACQUIRE_INSTANCES_CALL,
1465 MAPPER_ACQUIRE_AND_FILTER_INSTANCES_CALL,
1466 MAPPER_RELEASE_INSTANCE_CALL,
1467 MAPPER_RELEASE_INSTANCES_CALL,
1468 MAPPER_SUBSCRIBE_INSTANCE_CALL,
1469 MAPPER_UNSUBSCRIBE_INSTANCE_CALL,
1470 MAPPER_COLLECT_INSTANCE_CALL,
1471 MAPPER_COLLECT_INSTANCES_CALL,
1472 MAPPER_ACQUIRE_FUTURE_CALL,
1473 MAPPER_CREATE_INDEX_SPACE_CALL,
1474 MAPPER_UNION_INDEX_SPACES_CALL,
1475 MAPPER_INTERSECT_INDEX_SPACES_CALL,
1476 MAPPER_SUBTRACT_INDEX_SPACES_CALL,
1477 MAPPER_INDEX_SPACE_EMPTY_CALL,
1478 MAPPER_INDEX_SPACES_OVERLAP_CALL,
1479 MAPPER_INDEX_SPACE_DOMINATES_CALL,
1480 MAPPER_HAS_INDEX_PARTITION_CALL,
1481 MAPPER_GET_INDEX_PARTITION_CALL,
1482 MAPPER_GET_INDEX_SUBSPACE_CALL,
1483 MAPPER_GET_INDEX_SPACE_DOMAIN_CALL,
1484 MAPPER_GET_INDEX_PARTITION_CS_CALL,
1485 MAPPER_GET_INDEX_PARTITION_CS_NAME_CALL,
1486 MAPPER_GET_INDEX_SPACE_PARTITION_COLORS_CALL,
1487 MAPPER_IS_INDEX_PARTITION_DISJOINT_CALL,
1488 MAPPER_IS_INDEX_PARTITION_COMPLETE_CALL,
1489 MAPPER_GET_INDEX_SPACE_COLOR_CALL,
1490 MAPPER_GET_INDEX_SPACE_COLOR_POINT_CALL,
1491 MAPPER_GET_INDEX_PARTITION_COLOR_CALL,
1492 MAPPER_GET_PARENT_INDEX_SPACE_CALL,
1493 MAPPER_HAS_PARENT_INDEX_PARTITION_CALL,
1494 MAPPER_GET_PARENT_INDEX_PARTITION_CALL,
1495 MAPPER_GET_INDEX_SPACE_DEPTH_CALL,
1496 MAPPER_GET_INDEX_PARTITION_DEPTH_CALL,
1497 MAPPER_GET_FIELD_SIZE_CALL,
1498 MAPPER_GET_FIELD_SPACE_FIELDS_CALL,
1499 MAPPER_GET_LOGICAL_PARTITION_CALL,
1500 MAPPER_GET_LOGICAL_PARTITION_BY_COLOR_CALL,
1501 MAPPER_GET_LOGICAL_PARTITION_BY_TREE_CALL,
1502 MAPPER_GET_LOGICAL_SUBREGION_CALL,
1503 MAPPER_GET_LOGICAL_SUBREGION_BY_COLOR_CALL,
1504 MAPPER_GET_LOGICAL_SUBREGION_BY_TREE_CALL,
1505 MAPPER_GET_LOGICAL_REGION_COLOR_CALL,
1506 MAPPER_GET_LOGICAL_REGION_COLOR_POINT_CALL,
1507 MAPPER_GET_LOGICAL_PARTITION_COLOR_CALL,
1508 MAPPER_GET_PARENT_LOGICAL_REGION_CALL,
1509 MAPPER_HAS_PARENT_LOGICAL_PARTITION_CALL,
1510 MAPPER_GET_PARENT_LOGICAL_PARTITION_CALL,
1511 MAPPER_RETRIEVE_SEMANTIC_INFO_CALL,
1512 MAPPER_RETRIEVE_NAME_CALL,
1513 MAPPER_AUTO_LOCK_CALL,
1514 // Old runtime call kinds
1515 PACK_BASE_TASK_CALL,
1516 UNPACK_BASE_TASK_CALL,
1517 TASK_PRIVILEGE_CHECK_CALL,
1518 CLONE_TASK_CALL,
1519 COMPUTE_POINT_REQUIREMENTS_CALL,
1520 INTRA_TASK_ALIASING_CALL,
1521 ACTIVATE_SINGLE_CALL,
1522 DEACTIVATE_SINGLE_CALL,
1523 SELECT_INLINE_VARIANT_CALL,
1524 INLINE_CHILD_TASK_CALL,
1525 PACK_SINGLE_TASK_CALL,
1526 UNPACK_SINGLE_TASK_CALL,
1527 PACK_REMOTE_CONTEXT_CALL,
1528 HAS_CONFLICTING_INTERNAL_CALL,
1529 FIND_CONFLICTING_CALL,
1530 FIND_CONFLICTING_INTERNAL_CALL,
1531 CHECK_REGION_DEPENDENCE_CALL,
1532 FIND_PARENT_REGION_REQ_CALL,
1533 FIND_PARENT_REGION_CALL,
1534 CHECK_PRIVILEGE_CALL,
1535 TRIGGER_SINGLE_CALL,
1536 INITIALIZE_MAP_TASK_CALL,
1537 FINALIZE_MAP_TASK_CALL,
1538 VALIDATE_VARIANT_SELECTION_CALL,
1539 MAP_ALL_REGIONS_CALL,
1540 INITIALIZE_REGION_TREE_CONTEXTS_CALL,
1541 INVALIDATE_REGION_TREE_CONTEXTS_CALL,
1542 CREATE_INSTANCE_TOP_VIEW_CALL,
1543 LAUNCH_TASK_CALL,
1544 ACTIVATE_MULTI_CALL,
1545 DEACTIVATE_MULTI_CALL,
1546 SLICE_INDEX_SPACE_CALL,
1547 CLONE_MULTI_CALL,
1548 MULTI_TRIGGER_EXECUTION_CALL,
1549 PACK_MULTI_CALL,
1550 UNPACK_MULTI_CALL,
1551 ACTIVATE_INDIVIDUAL_CALL,
1552 DEACTIVATE_INDIVIDUAL_CALL,
1553 INDIVIDUAL_PERFORM_MAPPING_CALL,
1554 INDIVIDUAL_RETURN_VIRTUAL_CALL,
1555 INDIVIDUAL_TRIGGER_COMPLETE_CALL,
1556 INDIVIDUAL_TRIGGER_COMMIT_CALL,
1557 INDIVIDUAL_POST_MAPPED_CALL,
1558 INDIVIDUAL_PACK_TASK_CALL,
1559 INDIVIDUAL_UNPACK_TASK_CALL,
1560 INDIVIDUAL_PACK_REMOTE_COMPLETE_CALL,
1561 INDIVIDUAL_UNPACK_REMOTE_COMPLETE_CALL,
1562 POINT_ACTIVATE_CALL,
1563 POINT_DEACTIVATE_CALL,
1564 POINT_TASK_COMPLETE_CALL,
1565 POINT_TASK_COMMIT_CALL,
1566 POINT_PACK_TASK_CALL,
1567 POINT_UNPACK_TASK_CALL,
1568 POINT_TASK_POST_MAPPED_CALL,
1569 REMOTE_TASK_ACTIVATE_CALL,
1570 REMOTE_TASK_DEACTIVATE_CALL,
1571 REMOTE_UNPACK_CONTEXT_CALL,
1572 INDEX_ACTIVATE_CALL,
1573 INDEX_DEACTIVATE_CALL,
1574 INDEX_COMPUTE_FAT_PATH_CALL,
1575 INDEX_PREMAP_TASK_CALL,
1576 INDEX_DISTRIBUTE_CALL,
1577 INDEX_PERFORM_MAPPING_CALL,
1578 INDEX_COMPLETE_CALL,
1579 INDEX_COMMIT_CALL,
1580 INDEX_PERFORM_INLINING_CALL,
1581 INDEX_CLONE_AS_SLICE_CALL,
1582 INDEX_HANDLE_FUTURE,
1583 INDEX_RETURN_SLICE_MAPPED_CALL,
1584 INDEX_RETURN_SLICE_COMPLETE_CALL,
1585 INDEX_RETURN_SLICE_COMMIT_CALL,
1586 SLICE_ACTIVATE_CALL,
1587 SLICE_DEACTIVATE_CALL,
1588 SLICE_APPLY_VERSION_INFO_CALL,
1589 SLICE_DISTRIBUTE_CALL,
1590 SLICE_PERFORM_MAPPING_CALL,
1591 SLICE_LAUNCH_CALL,
1592 SLICE_MAP_AND_LAUNCH_CALL,
1593 SLICE_PACK_TASK_CALL,
1594 SLICE_UNPACK_TASK_CALL,
1595 SLICE_CLONE_AS_SLICE_CALL,
1596 SLICE_HANDLE_FUTURE_CALL,
1597 SLICE_CLONE_AS_POINT_CALL,
1598 SLICE_ENUMERATE_POINTS_CALL,
1599 SLICE_MAPPED_CALL,
1600 SLICE_COMPLETE_CALL,
1601 SLICE_COMMIT_CALL,
1602 REALM_SPAWN_META_CALL,
1603 REALM_SPAWN_TASK_CALL,
1604 REALM_CREATE_INSTANCE_CALL,
1605 REALM_ISSUE_COPY_CALL,
1606 REALM_ISSUE_FILL_CALL,
1607 REGION_TREE_LOGICAL_ANALYSIS_CALL,
1608 REGION_TREE_LOGICAL_FENCE_CALL,
1609 REGION_TREE_VERSIONING_ANALYSIS_CALL,
1610 REGION_TREE_ADVANCE_VERSION_NUMBERS_CALL,
1611 REGION_TREE_INITIALIZE_CONTEXT_CALL,
1612 REGION_TREE_INVALIDATE_CONTEXT_CALL,
1613 REGION_TREE_PREMAP_ONLY_CALL,
1614 REGION_TREE_PHYSICAL_REGISTER_ONLY_CALL,
1615 REGION_TREE_PHYSICAL_REGISTER_USERS_CALL,
1616 REGION_TREE_PHYSICAL_PERFORM_CLOSE_CALL,
1617 REGION_TREE_PHYSICAL_CLOSE_CONTEXT_CALL,
1618 REGION_TREE_PHYSICAL_COPY_ACROSS_CALL,
1619 REGION_TREE_PHYSICAL_REDUCE_ACROSS_CALL,
1620 REGION_TREE_PHYSICAL_CONVERT_MAPPING_CALL,
1621 REGION_TREE_PHYSICAL_FILL_FIELDS_CALL,
1622 REGION_TREE_PHYSICAL_ATTACH_EXTERNAL_CALL,
1623 REGION_TREE_PHYSICAL_DETACH_EXTERNAL_CALL,
1624 REGION_NODE_REGISTER_LOGICAL_USER_CALL,
1625 REGION_NODE_CLOSE_LOGICAL_NODE_CALL,
1626 REGION_NODE_SIPHON_LOGICAL_CHILDREN_CALL,
1627 REGION_NODE_SIPHON_LOGICAL_PROJECTION_CALL,
1628 REGION_NODE_PERFORM_LOGICAL_CLOSES_CALL,
1629 REGION_NODE_FIND_VALID_INSTANCE_VIEWS_CALL,
1630 REGION_NODE_FIND_VALID_REDUCTION_VIEWS_CALL,
1631 REGION_NODE_ISSUE_UPDATE_COPIES_CALL,
1632 REGION_NODE_SORT_COPY_INSTANCES_CALL,
1633 REGION_NODE_ISSUE_GROUPED_COPIES_CALL,
1634 REGION_NODE_ISSUE_UPDATE_REDUCTIONS_CALL,
1635 REGION_NODE_PREMAP_REGION_CALL,
1636 REGION_NODE_REGISTER_REGION_CALL,
1637 REGION_NODE_CLOSE_STATE_CALL,
1638 CURRENT_STATE_RECORD_VERSION_NUMBERS_CALL,
1639 CURRENT_STATE_ADVANCE_VERSION_NUMBERS_CALL,
1640 PHYSICAL_STATE_CAPTURE_STATE_CALL,
1641 PHYSICAL_STATE_APPLY_PATH_ONLY_CALL,
1642 PHYSICAL_STATE_APPLY_STATE_CALL,
1643 PHYSICAL_STATE_MAKE_LOCAL_CALL,
1644 MATERIALIZED_VIEW_FIND_LOCAL_PRECONDITIONS_CALL,
1645 MATERIALIZED_VIEW_FIND_LOCAL_COPY_PRECONDITIONS_CALL,
1646 MATERIALIZED_VIEW_FILTER_PREVIOUS_USERS_CALL,
1647 MATERIALIZED_VIEW_FILTER_CURRENT_USERS_CALL,
1648 MATERIALIZED_VIEW_FILTER_LOCAL_USERS_CALL,
1649 REDUCTION_VIEW_PERFORM_REDUCTION_CALL,
1650 REDUCTION_VIEW_PERFORM_DEFERRED_REDUCTION_CALL,
1651 REDUCTION_VIEW_PERFORM_DEFERRED_REDUCTION_ACROSS_CALL,
1652 REDUCTION_VIEW_FIND_COPY_PRECONDITIONS_CALL,
1653 REDUCTION_VIEW_FIND_USER_PRECONDITIONS_CALL,
1654 REDUCTION_VIEW_FILTER_LOCAL_USERS_CALL,
1655 PHYSICAL_TRACE_EXECUTE_CALL,
1656 PHYSICAL_TRACE_PRECONDITION_CHECK_CALL,
1657 PHYSICAL_TRACE_OPTIMIZE_CALL,
1658 LAST_RUNTIME_CALL_KIND, // This one must be last
1659 };
1660
1661#define RUNTIME_CALL_DESCRIPTIONS(name) \
1662 const char *name[Internal::LAST_RUNTIME_CALL_KIND] = { \
1663 "MapperRuntime::send_message", \
1664 "MapperRuntime::broadcast", \
1665 "MapperRuntime::unpack_physical_instance", \
1666 "MapperRuntime::create_mapper_event", \
1667 "MapperRuntime::has_mapper_event_triggered", \
1668 "MapperRuntime::trigger_mapper_event", \
1669 "MapperRuntime::wait_on_mapper_event", \
1670 "MapperRuntime::find_execution_constraints", \
1671 "MapperRuntime::find_task_layout_constraints", \
1672 "MapperRuntime::find_layout_constraints", \
1673 "MapperRuntime::register_layout", \
1674 "MapperRuntime::release_layout", \
1675 "MapperRuntime::do_constraints_conflict", \
1676 "MapperRuntime::do_constraints_entail", \
1677 "MapperRuntime::find_valid_variants", \
1678 "MapperRuntime::find_task_variant_name", \
1679 "MapperRuntime::is_leaf_variant", \
1680 "MapperRuntime::is_inner_variant", \
1681 "MapperRuntime::is_idempotent_variant", \
1682 "MapperRuntime::is_replicable_variant", \
1683 "MapperRuntime::register_task_variant", \
1684 "MapperRuntime::filter_variants", \
1685 "MapperRuntime::filter_instances", \
1686 "MapperRuntime::create_physical_instance", \
1687 "MapperRuntime::find_or_create_physical_instance", \
1688 "MapperRuntime::find_physical_instance", \
1689 "MapperRuntime::find_physical_instances", \
1690 "MapperRuntime::set_garbage_collection_priority", \
1691 "MapperRuntime::acquire_instance", \
1692 "MapperRuntime::acquire_instances", \
1693 "MapperRuntime::acquire_and_filter_instances", \
1694 "MapperRuntime::release_instance", \
1695 "MapperRuntime::release_instances", \
1696 "MapperRuntime::subscribe", \
1697 "MapperRuntime::unsubscribe", \
1698 "MapperRuntime::collect_instance", \
1699 "MapperRuntime::collect_instances", \
1700 "MapperRuntime::acquire_future", \
1701 "MapperRuntime::create_index_space", \
1702 "MapperRuntime::union_index_spaces", \
1703 "MapperRuntime::intersect_index_spaces", \
1704 "MapperRuntime::subtract_index_spaces", \
1705 "MapperRuntime::is_index_space_empty", \
1706 "MapperRuntime::index_spaces_overlap", \
1707 "MapperRuntime::index_space_dominates", \
1708 "MapperRuntime::has_index_partition", \
1709 "MapperRuntime::get_index_partition", \
1710 "MapperRuntime::get_index_subspace", \
1711 "MapperRuntime::get_index_space_domain", \
1712 "MapperRuntime::get_index_partition_color_space", \
1713 "MapperRuntime::get_index_partition_color_space_name", \
1714 "MapperRuntime::get_index_space_parition_colors", \
1715 "MapperRuntime::is_index_partition_disjoint", \
1716 "MapperRuntime::is_index_partition_complete", \
1717 "MapperRuntime::get_index_space_color", \
1718 "MapperRuntime::get_index_space_color_point", \
1719 "MapperRuntime::get_index_partition_color", \
1720 "MapperRuntime::get_parent_index_space", \
1721 "MapperRuntime::has_parent_index_partition", \
1722 "MapperRuntime::get_parent_index_partition", \
1723 "MapperRuntime::get_index_space_depth", \
1724 "MapperRuntime::get_index_partition_depth", \
1725 "MapperRuntime::get_field_size", \
1726 "MapperRuntime::get_field_space_fields", \
1727 "MapperRuntime::get_logical_partition", \
1728 "MapperRuntime::get_logical_partition_by_color", \
1729 "MapperRuntime::get_logical_partition_by_tree", \
1730 "MapperRuntime::get_logical_subregion", \
1731 "MapperRuntime::get_logical_subregion_by_color", \
1732 "MapperRuntime::get_logical_subregion_by_tree", \
1733 "MapperRuntime::get_logical_region_color", \
1734 "MapperRuntime::get_logical_region_color_point", \
1735 "MapperRuntime::get_logical_partition_color", \
1736 "MapperRuntime::get_parent_logical_region", \
1737 "MapperRuntime::has_parent_logical_partition", \
1738 "MapperRuntime::get_parent_logical_partition", \
1739 "MapperRuntime::retrieve_semantic_information", \
1740 "MapperRuntime::retrieve_name", \
1741 "MapperRuntime::AutoLock", \
1742 "Pack Base Task", \
1743 "Unpack Base Task", \
1744 "Task Privilege Check", \
1745 "Clone Base Task", \
1746 "Compute Point Requirements", \
1747 "Intra-Task Aliasing", \
1748 "Activate Single", \
1749 "Deactivate Single", \
1750 "Select Inline Variant", \
1751 "Inline Child Task", \
1752 "Pack Single Task", \
1753 "Unpack Single Task", \
1754 "Pack Remote Context", \
1755 "Has Conflicting Internal", \
1756 "Find Conflicting", \
1757 "Find Conflicting Internal", \
1758 "Check Region Dependence", \
1759 "Find Parent Region Requirement", \
1760 "Find Parent Region", \
1761 "Check Privilege", \
1762 "Trigger Single", \
1763 "Initialize Map Task", \
1764 "Finalized Map Task", \
1765 "Validate Variant Selection", \
1766 "Map All Regions", \
1767 "Initialize Region Tree Contexts", \
1768 "Invalidate Region Tree Contexts", \
1769 "Create Instance Top View", \
1770 "Launch Task", \
1771 "Activate Multi", \
1772 "Deactivate Multi", \
1773 "Slice Index Space", \
1774 "Clone Multi Call", \
1775 "Multi Trigger Execution", \
1776 "Pack Multi", \
1777 "Unpack Multi", \
1778 "Activate Individual", \
1779 "Deactivate Individual", \
1780 "Individual Perform Mapping", \
1781 "Individual Return Virtual", \
1782 "Individual Trigger Complete", \
1783 "Individual Trigger Commit", \
1784 "Individual Post Mapped", \
1785 "Individual Pack Task", \
1786 "Individual Unpack Task", \
1787 "Individual Pack Remote Complete", \
1788 "Individual Unpack Remote Complete", \
1789 "Activate Point", \
1790 "Deactivate Point", \
1791 "Point Task Complete", \
1792 "Point Task Commit", \
1793 "Point Task Pack", \
1794 "Point Task Unpack", \
1795 "Point Task Post Mapped", \
1796 "Remote Task Activate", \
1797 "Remote Task Deactivate", \
1798 "Remote Unpack Context", \
1799 "Index Activate", \
1800 "Index Deactivate", \
1801 "Index Compute Fat Path", \
1802 "Index PreMap Task", \
1803 "Index Distribute", \
1804 "Index Perform Mapping", \
1805 "Index Complete", \
1806 "Index Commit", \
1807 "Index Perform Inlining", \
1808 "Index Clone As Slice", \
1809 "Index Handle Future", \
1810 "Index Return Slice Mapped", \
1811 "Index Return Slice Complete", \
1812 "Index Return Slice Commit", \
1813 "Slice Activate", \
1814 "Slice Deactivate", \
1815 "Slice Apply Version Info", \
1816 "Slice Distribute", \
1817 "Slice Perform Mapping", \
1818 "Slice Launch", \
1819 "Slice Map and Launch", \
1820 "Slice Pack Task", \
1821 "Slice Unpack Task", \
1822 "Slice Clone As Slice", \
1823 "Slice Handle Future", \
1824 "Slice Cone as Point", \
1825 "Slice Enumerate Points", \
1826 "Slice Mapped", \
1827 "Slice Complete", \
1828 "Slice Commit", \
1829 "Realm Spawn Meta", \
1830 "Realm Spawn Task", \
1831 "Realm Create Instance", \
1832 "Realm Issue Copy", \
1833 "Realm Issue Fill", \
1834 "Region Tree Logical Analysis", \
1835 "Region Tree Logical Fence", \
1836 "Region Tree Versioning Analysis", \
1837 "Region Tree Advance Version Numbers", \
1838 "Region Tree Initialize Context", \
1839 "Region Tree Invalidate Context", \
1840 "Region Tree Premap Only", \
1841 "Region Tree Physical Register Only", \
1842 "Region Tree Physical Register Users", \
1843 "Region Tree Physical Perform Close", \
1844 "Region Tree Physical Close Context", \
1845 "Region Tree Physical Copy Across", \
1846 "Region Tree Physical Reduce Across", \
1847 "Region Tree Physical Convert Mapping", \
1848 "Region Tree Physical Fill Fields", \
1849 "Region Tree Physical Attach External", \
1850 "Region Tree Physical Detach External", \
1851 "Region Node Register Logical User", \
1852 "Region Node Close Logical Node", \
1853 "Region Node Siphon Logical Children", \
1854 "Region Node Siphon Logical Projection", \
1855 "Region Node Perform Logical Closes", \
1856 "Region Node Find Valid Instance Views", \
1857 "Region Node Find Valid Reduction Views", \
1858 "Region Node Issue Update Copies", \
1859 "Region Node Sort Copy Instances", \
1860 "Region Node Issue Grouped Copies", \
1861 "Region Node Issue Update Reductions", \
1862 "Region Node Premap Region", \
1863 "Region Node Register Region", \
1864 "Region Node Close State", \
1865 "Logical State Record Verison Numbers", \
1866 "Logical State Advance Version Numbers", \
1867 "Physical State Capture State", \
1868 "Physical State Apply Path Only", \
1869 "Physical State Apply State", \
1870 "Physical State Make Local", \
1871 "Materialized View Find Local Preconditions", \
1872 "Materialized View Find Local Copy Preconditions", \
1873 "Materialized View Filter Previous Users", \
1874 "Materialized View Filter Current Users", \
1875 "Materialized View Filter Local Users", \
1876 "Reduction View Perform Reduction", \
1877 "Reduction View Perform Deferred Reduction", \
1878 "Reduction View Perform Deferred Reduction Across", \
1879 "Reduction View Find Copy Preconditions", \
1880 "Reduction View Find User Preconditions", \
1881 "Reduction View Filter Local Users", \
1882 "Physical Trace Execute", \
1883 "Physical Trace Precondition Check", \
1884 "Physical Trace Optimize", \
1885 };
1886
1887 enum SemanticInfoKind {
1888 INDEX_SPACE_SEMANTIC,
1889 INDEX_PARTITION_SEMANTIC,
1890 FIELD_SPACE_SEMANTIC,
1891 FIELD_SEMANTIC,
1892 LOGICAL_REGION_SEMANTIC,
1893 LOGICAL_PARTITION_SEMANTIC,
1894 TASK_SEMANTIC,
1895 };
1896
1897 // Static locations for where collectives are allocated
1898 // These are just arbitrary numbers but they should appear
1899 // with at most one logical static collective kind
1900 // Ones that have been commented out are free to be reused
1901 enum CollectiveIndexLocation {
1902 //COLLECTIVE_LOC_0 = 0,
1903 COLLECTIVE_LOC_1 = 1,
1904 COLLECTIVE_LOC_2 = 2,
1905 COLLECTIVE_LOC_3 = 3,
1906 COLLECTIVE_LOC_4 = 4,
1907 COLLECTIVE_LOC_5 = 5,
1908 COLLECTIVE_LOC_6 = 6,
1909 COLLECTIVE_LOC_7 = 7,
1910 COLLECTIVE_LOC_8 = 8,
1911 COLLECTIVE_LOC_9 = 9,
1912 COLLECTIVE_LOC_10 = 10,
1913 COLLECTIVE_LOC_11 = 11,
1914 COLLECTIVE_LOC_12 = 12,
1915 COLLECTIVE_LOC_13 = 13,
1916 COLLECTIVE_LOC_14 = 14,
1917 COLLECTIVE_LOC_15 = 15,
1918 COLLECTIVE_LOC_16 = 16,
1919 COLLECTIVE_LOC_17 = 17,
1920 COLLECTIVE_LOC_18 = 18,
1921 COLLECTIVE_LOC_19 = 19,
1922 COLLECTIVE_LOC_20 = 20,
1923 COLLECTIVE_LOC_21 = 21,
1924 COLLECTIVE_LOC_22 = 22,
1925 COLLECTIVE_LOC_23 = 23,
1926 COLLECTIVE_LOC_24 = 24,
1927 COLLECTIVE_LOC_25 = 25,
1928 COLLECTIVE_LOC_26 = 26,
1929 COLLECTIVE_LOC_27 = 27,
1930 COLLECTIVE_LOC_28 = 28,
1931 COLLECTIVE_LOC_29 = 29,
1932 COLLECTIVE_LOC_30 = 30,
1933 COLLECTIVE_LOC_31 = 31,
1934 COLLECTIVE_LOC_32 = 32,
1935 COLLECTIVE_LOC_33 = 33,
1936 COLLECTIVE_LOC_34 = 34,
1937 COLLECTIVE_LOC_35 = 35,
1938 COLLECTIVE_LOC_36 = 36,
1939 COLLECTIVE_LOC_37 = 37,
1940 COLLECTIVE_LOC_38 = 38,
1941 COLLECTIVE_LOC_39 = 39,
1942 COLLECTIVE_LOC_40 = 40,
1943 COLLECTIVE_LOC_41 = 41,
1944 COLLECTIVE_LOC_42 = 42,
1945 COLLECTIVE_LOC_43 = 43,
1946 COLLECTIVE_LOC_44 = 44,
1947 COLLECTIVE_LOC_45 = 45,
1948 COLLECTIVE_LOC_46 = 46,
1949 COLLECTIVE_LOC_47 = 47,
1950 COLLECTIVE_LOC_48 = 48,
1951 COLLECTIVE_LOC_49 = 49,
1952 COLLECTIVE_LOC_50 = 50,
1953 COLLECTIVE_LOC_51 = 51,
1954 COLLECTIVE_LOC_52 = 52,
1955 COLLECTIVE_LOC_53 = 53,
1956 COLLECTIVE_LOC_54 = 54,
1957 COLLECTIVE_LOC_55 = 55,
1958 COLLECTIVE_LOC_56 = 56,
1959 COLLECTIVE_LOC_57 = 57,
1960 COLLECTIVE_LOC_58 = 58,
1961 COLLECTIVE_LOC_59 = 59,
1962 COLLECTIVE_LOC_60 = 60,
1963 COLLECTIVE_LOC_61 = 61,
1964 COLLECTIVE_LOC_62 = 62,
1965 COLLECTIVE_LOC_63 = 63,
1966 COLLECTIVE_LOC_64 = 64,
1967 COLLECTIVE_LOC_65 = 65,
1968 COLLECTIVE_LOC_66 = 66,
1969 COLLECTIVE_LOC_67 = 67,
1970 //COLLECTIVE_LOC_68 = 68,
1971 //COLLECTIVE_LOC_69 = 69,
1972 COLLECTIVE_LOC_70 = 70,
1973 COLLECTIVE_LOC_71 = 71,
1974 COLLECTIVE_LOC_72 = 72,
1975 COLLECTIVE_LOC_73 = 73,
1976 COLLECTIVE_LOC_74 = 74,
1977 COLLECTIVE_LOC_75 = 75,
1978 COLLECTIVE_LOC_76 = 76,
1979 COLLECTIVE_LOC_77 = 77,
1980 COLLECTIVE_LOC_78 = 78,
1981 COLLECTIVE_LOC_79 = 79,
1982 COLLECTIVE_LOC_80 = 80,
1983 COLLECTIVE_LOC_81 = 81,
1984 COLLECTIVE_LOC_82 = 82,
1985 COLLECTIVE_LOC_83 = 83,
1986 COLLECTIVE_LOC_84 = 84,
1987 COLLECTIVE_LOC_85 = 85,
1988 COLLECTIVE_LOC_86 = 86,
1989 COLLECTIVE_LOC_87 = 87,
1990 COLLECTIVE_LOC_88 = 88,
1991 COLLECTIVE_LOC_89 = 89,
1992 COLLECTIVE_LOC_90 = 90,
1993 COLLECTIVE_LOC_91 = 91,
1994 COLLECTIVE_LOC_92 = 92,
1995 COLLECTIVE_LOC_93 = 93,
1996 COLLECTIVE_LOC_94 = 94,
1997 COLLECTIVE_LOC_95 = 95,
1998 COLLECTIVE_LOC_96 = 96,
1999 COLLECTIVE_LOC_97 = 97,
2000 COLLECTIVE_LOC_98 = 98,
2001 COLLECTIVE_LOC_99 = 99,
2002 COLLECTIVE_LOC_100 = 100,
2003 COLLECTIVE_LOC_101 = 101,
2004 COLLECTIVE_LOC_102 = 102,
2005 COLLECTIVE_LOC_103 = 103,
2006 COLLECTIVE_LOC_104 = 104,
2007 COLLECTIVE_LOC_105 = 105,
2008 };
2009
2010 // legion_types.h
2011 class LocalLock;
2012 class AutoLock;
2013 class AutoTryLock;
2014 class LgEvent; // base event type for legion
2015 class ApEvent; // application event
2016 class ApUserEvent; // application user event
2017 class ApBarrier; // application barrier
2018 class RtEvent; // runtime event
2019 class RtUserEvent; // runtime user event
2020 class RtBarrier;
2021
2022 // legion_utilities.h
2023 struct RegionUsage;
2024 template<typename T> class Fraction;
2025 template<typename T, unsigned LOG2MAX> class BitPermutation;
2026
2027 // Forward declarations for runtime level objects
2028 // runtime.h
2029 class Collectable;
2030 class FieldAllocatorImpl;
2031 class ArgumentMapImpl;
2032 class FutureImpl;
2033 class FutureInstance;
2034 class FutureMapImpl;
2035 class ReplFutureMapImpl;
2036 class PhysicalRegionImpl;
2037 class OutputRegionImpl;
2038 class ExternalResourcesImpl;
2039 class PieceIteratorImpl;
2040 class GrantImpl;
2041 class PredicateImpl;
2042 class LegionHandshakeImpl;
2043 class ProcessorManager;
2044 class MemoryManager;
2045 class VirtualChannel;
2046 class MessageManager;
2047 class ShutdownManager;
2048 class TaskImpl;
2049 class VariantImpl;
2050 class LayoutConstraints;
2051 class ProjectionFunction;
2052 class ShardingFunction;
2053 class Runtime;
2054
2055 // legion_ops.h
2056 class Provenance;
2057 class Operation;
2058 class MemoizableOp;
2059 class PredicatedOp;
2060 class MapOp;
2061 class CopyOp;
2062 class IndexCopyOp;
2063 class PointCopyOp;
2064 class FenceOp;
2065 class FrameOp;
2066 class CreationOp;
2067 class DeletionOp;
2068 class InternalOp;
2069 class CloseOp;
2070 class MergeCloseOp;
2071 class PostCloseOp;
2072 class RefinementOp;
2073 class ResetOp;
2074 class AcquireOp;
2075 class ReleaseOp;
2076 class DynamicCollectiveOp;
2077 class FuturePredOp;
2078 class NotPredOp;
2079 class AndPredOp;
2080 class OrPredOp;
2081 class MustEpochOp;
2082 class PendingPartitionOp;
2083 class DependentPartitionOp;
2084 class PointDepPartOp;
2085 class FillOp;
2086 class IndexFillOp;
2087 class PointFillOp;
2088 class DiscardOp;
2089 class AttachOp;
2090 class IndexAttachOp;
2091 class PointAttachOp;
2092 class DetachOp;
2093 class IndexDetachOp;
2094 class PointDetachOp;
2095 class TimingOp;
2096 class TunableOp;
2097 class AllReduceOp;
2098 class ExternalMappable;
2099 class RemoteOp;
2100 class RemoteMapOp;
2101 class RemoteCopyOp;
2102 class RemoteCloseOp;
2103 class RemoteAcquireOp;
2104 class RemoteReleaseOp;
2105 class RemoteFillOp;
2106 class RemotePartitionOp;
2107 class RemoteReplayOp;
2108 class RemoteSummaryOp;
2109 template<typename OP>
2110 class Memoizable;
2111 template<typename OP>
2112 class Predicated;
2113
2114
2115 // legion_tasks.h
2116 class ExternalTask;
2117 class TaskOp;
2118 class RemoteTaskOp;
2119 class SingleTask;
2120 class MultiTask;
2121 class IndividualTask;
2122 class PointTask;
2123 class ShardTask;
2124 class IndexTask;
2125 class SliceTask;
2126 class RemoteTask;
2127
2128 // legion_context.h
2129 class TaskContext;
2130 class InnerContext;;
2131 class TopLevelContext;
2132 class ReplicateContext;
2133 class RemoteContext;
2134 class LeafContext;
2135
2136 // legion_trace.h
2137 class LogicalTrace;
2138 class TraceBeginOp;
2139 class TraceRecurrentOp;
2140 class TraceCompleteOp;
2141 class PhysicalTrace;
2142 class TraceViewSet;
2143 class TraceConditionSet;
2144 class PhysicalTemplate;
2145 class ShardedPhysicalTemplate;
2146 class Instruction;
2147 class GetTermEvent;
2148 class ReplayMapping;
2149 class CreateApUserEvent;
2150 class TriggerEvent;
2151 class MergeEvent;
2152 class AssignFenceCompletion;
2153 class IssueCopy;
2154 class IssueFill;
2155 class IssueAcross;
2156 class GetOpTermEvent;
2157 class SetOpSyncEvent;
2158 class SetEffects;
2159 class CompleteReplay;
2160 class AcquireReplay;
2161 class ReleaseReplay;
2162 class BarrierArrival;
2163 class BarrierAdvance;
2164
2165 // region_tree.h
2166 class RegionTreeForest;
2167 class CopyAcrossExecutor;
2168 class CopyAcrossUnstructured;
2169 class IndexSpaceExpression;
2170 class IndexSpaceExprRef;
2171 class IndexSpaceOperation;
2172 template<int DIM, typename T> class IndexSpaceOperationT;
2173 template<int DIM, typename T> class IndexSpaceUnion;
2174 template<int DIM, typename T> class IndexSpaceIntersection;
2175 template<int DIM, typename T> class IndexSpaceDifference;
2176 class ExpressionTrieNode;
2177 class IndexTreeNode;
2178 class IndexSpaceNode;
2179 template<int DIM, typename T> class IndexSpaceNodeT;
2180 class IndexPartNode;
2181 template<int DIM, typename T> class IndexPartNodeT;
2182 class FieldSpaceNode;
2183 class RegionTreeNode;
2184 class RegionNode;
2185 class PartitionNode;
2186 class ColorSpaceIterator;
2187 template<int DIM, typename T> class ColorSpaceLinearizationT;
2188 template<int DIM, typename T, typename RT = void> class KDNode;
2189 class EqKDTree;
2190 template<int DIM, typename T> class EqKDTreeT;
2191
2192 class RegionTreePath;
2193 class PathTraverser;
2194 class NodeTraverser;
2195
2196 class LogicalState;
2197 class LogicalAnalysis;
2198 class PhysicalAnalysis;
2199 class EquivalenceSet;
2200 class EqSetTracker;
2201 class VersionManager;
2202 class VersionInfo;
2203 class ProjectionNode;
2204 class ProjectionRegion;
2205 class ProjectionPartition;
2206 class RefinementTracker;
2207 class RegionRefinementTracker;
2208 class PartitionRefinementTracker;
2209
2210 class Collectable;
2211 class Notifiable;
2212 class ImplicitReferenceTracker;
2213 class DistributedCollectable;
2214 class LayoutDescription;
2215 class InstanceManager; // base class for all instances
2216 class CopyAcrossHelper;
2217 class LogicalView; // base class for instance and reduction
2218 class InstanceKey;
2219 class InstanceView;
2220 class ExprView;
2221 class CollectableView; // pure virtual class
2222 class IndividualView;
2223 class CollectiveView;
2224 class MaterializedView;
2225 class ReplicatedView;
2226 class ReductionView;
2227 class AllreduceView;
2228 class DeferredView;
2229 class FillView;
2230 class PhiView;
2231 class MappingRef;
2232 class InstanceRef;
2233 class InstanceSet;
2234 class InnerTaskView;
2235 class VirtualManager;
2236 class PhysicalManager;
2237 class InstanceBuilder;
2238
2239 class RegionAnalyzer;
2240 class RegionMapper;
2241
2242 struct LogicalUser;
2243 struct PhysicalUser;
2244 struct LogicalTraceInfo;
2245 struct PhysicalTraceInfo;
2246 class TreeCloseImpl;
2247 class TreeClose;
2248 struct CloseInfo;
2249 struct FieldDataDescriptor;
2250 struct PendingRemoteExpression;
2251 class ProjectionSummary;
2252 class ProjectionInfo;
2253
2254
2255 // legion_spy.h
2256 class TreeStateLogger;
2257
2258 // legion_profiling.h
2259 class LegionProfiler;
2260 class LegionProfInstance;
2261
2262 // mapper_manager.h
2263 class MappingCallInfo;
2264 class MapperManager;
2265 class SerializingManager;
2266 class ConcurrentManager;
2267 typedef Mapping::MapperEvent MapperEvent;
2268 typedef Mapping::ProfilingMeasurementID ProfilingMeasurementID;
2269
2270 // legion_replication.h
2271 class ShardedMapping;
2272 class ReplIndividualTask;
2273 class ReplIndexTask;
2274 class ReplMergeCloseOp;
2275 class ReplRefinementOp;
2276 class ReplResetOp;
2277 class ReplFillOp;
2278 class ReplIndexFillOp;
2279 class ReplDiscardOp;
2280 class ReplCopyOp;
2281 class ReplIndexCopyOp;
2282 class ReplDeletionOp;
2283 class ReplPendingPartitionOp;
2284 class ReplDependentPartitionOp;
2285 class ReplMustEpochOp;
2286 class ReplTimingOp;
2287 class ReplTunableOp;
2288 class ReplAllReduceOp;
2289 class ReplFenceOp;
2290 class ReplMapOp;
2291 class ReplAttachOp;
2292 class ReplIndexAttachOp;
2293 class ReplDetachOp;
2294 class ReplIndexDetachOp;
2295 class ReplAcquireOp;
2296 class ReplReleaseOp;
2297 class ReplTraceOp;
2298 class ReplTraceBeginOp;
2299 class ReplTraceRecurrentOp;
2300 class ReplTraceCompleteOp;
2301 class ShardMapping;
2302 class CollectiveMapping;
2303 class ShardManager;
2304 class ShardCollective;
2305 class GatherCollective;
2306 template<bool>
2307 class AllGatherCollective;
2308 template<typename T> class BarrierExchangeCollective;
2309 template<typename T> class ValueBroadcast;
2310 template<typename T, bool> class AllReduceCollective;
2311 class CrossProductCollective;
2312 class ShardingGatherCollective;
2313 class FieldDescriptorExchange;
2314 class FieldDescriptorGather;
2315 class FutureBroadcast;
2316 class FutureExchange;
2317 class FutureNameExchange;
2318 class MustEpochMappingBroadcast;
2319 class MustEpochMappingExchange;
2320 class PredicateCollective;
2321 class UnorderedExchange;
2322 class ShardRendezvous;
2323 class ProjectionTreeExchange;
2324 class TimeoutMatchExchange;
2325
2326 // Nasty global variable for TLS support of figuring out
2327 // our context implicitly
2328 extern thread_local TaskContext *implicit_context;
2329 // Mapper context if we're inside of a mapper call
2330 extern thread_local MappingCallInfo *implicit_mapper_call;
2331 // Same thing for the runtime
2332 extern thread_local Runtime *implicit_runtime;
2333 // Implicit thread-local profiler
2334 extern thread_local LegionProfInstance *implicit_profiler;
2335 // Another nasty global variable for tracking the fast
2336 // reservations that we are holding
2337 extern thread_local AutoLock *local_lock_list;
2338 // One more nasty global variable that we use for tracking
2339 // the provenance of meta-task operations for profiling
2340 // purposes, this has no bearing on correctness
2341 extern thread_local ::legion_unique_id_t implicit_provenance;
2342 // Use this global variable to track name of the "finish event"
2343 // for whatever (meta-)task we're running on at the moment.
2344 // It should always be the case that the owner node of the
2345 // "finish" event" is the same as the node we're on.
2346 extern thread_local LgEvent implicit_fevent;
2347 // Use this to track if we're inside of a registration
2348 // callback function which we know to be deduplicated
2349 enum RegistrationCallbackMode {
2350 NO_REGISTRATION_CALLBACK = 0,
2351 LOCAL_REGISTRATION_CALLBACK = 1,
2352 GLOBAL_REGISTRATION_CALLBACK = 2,
2353 };
2354 extern thread_local unsigned inside_registration_callback;
2355 // This data structure tracks references to any live
2356 // temporary index space expressions that have been
2357 // handed back by the region tree inside the execution
2358 // of a meta-task or a runtime API call. It also tracks
2359 // changes to remote distributed collectable that can be
2360 // delayed and batched together.
2361 extern thread_local ImplicitReferenceTracker *implicit_reference_tracker;
2362#ifdef DEBUG_LEGION_CALLERS
2363 extern thread_local LgTaskID implicit_task_kind;
2364 extern thread_local LgTaskID implicit_task_caller;
2365#endif
2366
2371 template<typename T>
2372 struct LgTaskArgs {
2373 public:
2374 LgTaskArgs(::legion_unique_id_t uid)
2375 : provenance(uid),
2376#ifdef DEBUG_LEGION_CALLERS
2377 lg_call_id(implicit_task_kind),
2378#endif
2379 lg_task_id(T::TASK_ID) { }
2380 public:
2381 // In this order for alignment reasons
2382 const ::legion_unique_id_t provenance;
2383#ifdef DEBUG_LEGION_CALLERS
2384 const LgTaskID lg_call_id;
2385#endif
2386 const LgTaskID lg_task_id;
2387 };
2388
2389#define FRIEND_ALL_RUNTIME_CLASSES \
2390 friend class Legion::Runtime; \
2391 friend class Legion::Mapping::MapperRuntime; \
2392 friend class Internal::Runtime; \
2393 friend class Internal::FutureImpl; \
2394 friend class Internal::FutureMapImpl; \
2395 friend class Internal::PhysicalRegionImpl; \
2396 friend class Internal::ExternalResourcesImpl; \
2397 friend class Internal::TaskImpl; \
2398 friend class Internal::VariantImpl; \
2399 friend class Internal::ProcessorManager; \
2400 friend class Internal::MemoryManager; \
2401 friend class Internal::Operation; \
2402 friend class Internal::PredicatedOp; \
2403 friend class Internal::MapOp; \
2404 friend class Internal::CopyOp; \
2405 friend class Internal::IndexCopyOp; \
2406 friend class Internal::PointCopyOp; \
2407 friend class Internal::FenceOp; \
2408 friend class Internal::DynamicCollectiveOp; \
2409 friend class Internal::FuturePredOp; \
2410 friend class Internal::CreationOp; \
2411 friend class Internal::DeletionOp; \
2412 friend class Internal::CloseOp; \
2413 friend class Internal::MergeCloseOp; \
2414 friend class Internal::PostCloseOp; \
2415 friend class Internal::RefinementOp; \
2416 friend class Internal::ResetOp; \
2417 friend class Internal::AcquireOp; \
2418 friend class Internal::ReleaseOp; \
2419 friend class Internal::PredicateImpl; \
2420 friend class Internal::NotPredOp; \
2421 friend class Internal::AndPredOp; \
2422 friend class Internal::OrPredOp; \
2423 friend class Internal::MustEpochOp; \
2424 friend class Internal::PendingPartitionOp; \
2425 friend class Internal::DependentPartitionOp; \
2426 friend class Internal::PointDepPartOp; \
2427 friend class Internal::FillOp; \
2428 friend class Internal::IndexFillOp; \
2429 friend class Internal::PointFillOp; \
2430 friend class Internal::DiscardOp; \
2431 friend class Internal::AttachOp; \
2432 friend class Internal::IndexAttachOp; \
2433 friend class Internal::ReplIndexAttachOp; \
2434 friend class Internal::PointAttachOp; \
2435 friend class Internal::DetachOp; \
2436 friend class Internal::IndexDetachOp; \
2437 friend class Internal::ReplIndexDetachOp; \
2438 friend class Internal::PointDetachOp; \
2439 friend class Internal::TimingOp; \
2440 friend class Internal::TunableOp; \
2441 friend class Internal::AllReduceOp; \
2442 friend class Internal::TraceRecurrentOp; \
2443 friend class Internal::ExternalMappable; \
2444 friend class Internal::ExternalTask; \
2445 friend class Internal::TaskOp; \
2446 friend class Internal::SingleTask; \
2447 friend class Internal::MultiTask; \
2448 friend class Internal::IndividualTask; \
2449 friend class Internal::PointTask; \
2450 friend class Internal::IndexTask; \
2451 friend class Internal::SliceTask; \
2452 friend class Internal::ReplIndividualTask; \
2453 friend class Internal::ReplIndexTask; \
2454 friend class Internal::ReplFillOp; \
2455 friend class Internal::ReplIndexFillOp; \
2456 friend class Internal::ReplDiscardOp; \
2457 friend class Internal::ReplCopyOp; \
2458 friend class Internal::ReplIndexCopyOp; \
2459 friend class Internal::ReplDeletionOp; \
2460 friend class Internal::ReplPendingPartitionOp; \
2461 friend class Internal::ReplDependentPartitionOp; \
2462 friend class Internal::ReplMustEpochOp; \
2463 friend class Internal::ReplMapOp; \
2464 friend class Internal::ReplTimingOp; \
2465 friend class Internal::ReplTunableOp; \
2466 friend class Internal::ReplAllReduceOp; \
2467 friend class Internal::ReplFenceOp; \
2468 friend class Internal::ReplAttachOp; \
2469 friend class Internal::ReplDetachOp; \
2470 friend class Internal::ReplAcquireOp; \
2471 friend class Internal::ReplReleaseOp; \
2472 friend class Internal::MemoizableOp; \
2473 template<typename OP> \
2474 friend class Internal::Memoizable; \
2475 friend class Internal::ShardManager; \
2476 friend class Internal::RegionTreeForest; \
2477 friend class Internal::IndexSpaceNode; \
2478 template<int, typename> \
2479 friend class Internal::IndexSpaceNodeT; \
2480 friend class Internal::IndexPartNode; \
2481 friend class Internal::FieldSpaceNode; \
2482 friend class Internal::RegionTreeNode; \
2483 friend class Internal::RegionNode; \
2484 friend class Internal::PartitionNode; \
2485 friend class Internal::LogicalView; \
2486 friend class Internal::InstanceView; \
2487 friend class Internal::DeferredView; \
2488 friend class Internal::ReductionView; \
2489 friend class Internal::MaterializedView; \
2490 friend class Internal::FillView; \
2491 friend class Internal::LayoutDescription; \
2492 friend class Internal::InstanceManager; \
2493 friend class Internal::PhysicalManager; \
2494 friend class Internal::TreeStateLogger; \
2495 friend class Internal::MapperManager; \
2496 friend class Internal::InstanceRef; \
2497 friend class Internal::LegionHandshakeImpl; \
2498 friend class Internal::ArgumentMapImpl; \
2499 friend class Internal::FutureMapImpl; \
2500 friend class Internal::ReplFutureMapImpl; \
2501 friend class Internal::TaskContext; \
2502 friend class Internal::InnerContext; \
2503 friend class Internal::TopLevelContext; \
2504 friend class Internal::RemoteContext; \
2505 friend class Internal::LeafContext; \
2506 friend class Internal::ReplicateContext; \
2507 friend class Internal::InstanceBuilder; \
2508 friend class Internal::FutureNameExchange; \
2509 friend class Internal::MustEpochMappingExchange; \
2510 friend class Internal::MustEpochMappingBroadcast; \
2511 friend class Internal::MappingCallInfo; \
2512 friend class BindingLib::Utility; \
2513 friend class CObjectWrapper;
2514
2515#define LEGION_EXTERN_LOGGER_DECLARATIONS \
2516 extern Realm::Logger log_run; \
2517 extern Realm::Logger log_task; \
2518 extern Realm::Logger log_index; \
2519 extern Realm::Logger log_field; \
2520 extern Realm::Logger log_region; \
2521 extern Realm::Logger log_inst; \
2522 extern Realm::Logger log_variant; \
2523 extern Realm::Logger log_allocation; \
2524 extern Realm::Logger log_migration; \
2525 extern Realm::Logger log_prof; \
2526 extern Realm::Logger log_garbage; \
2527 extern Realm::Logger log_spy; \
2528 extern Realm::Logger log_shutdown; \
2529 extern Realm::Logger log_tracing;
2530
2531 }; // Internal namespace
2532
2533 // Typedefs that are needed everywhere
2534 typedef Realm::Runtime RealmRuntime;
2535 typedef Realm::Machine Machine;
2536 typedef Realm::Memory Memory;
2537 typedef Realm::Processor Processor;
2538 typedef Realm::ProcessorGroup ProcessorGroup;
2539 typedef Realm::CodeDescriptor CodeDescriptor;
2540 typedef Realm::Reservation Reservation;
2541 typedef Realm::CompletionQueue CompletionQueue;
2542 typedef ::legion_reduction_op_id_t ReductionOpID;
2543 typedef Realm::ReductionOpUntyped ReductionOp;
2544 typedef ::legion_custom_serdez_id_t CustomSerdezID;
2545 typedef Realm::CustomSerdezUntyped SerdezOp;
2546 typedef Realm::Machine::ProcessorMemoryAffinity ProcessorMemoryAffinity;
2547 typedef Realm::Machine::MemoryMemoryAffinity MemoryMemoryAffinity;
2548 typedef Realm::DynamicTemplates::TagType TypeTag;
2549 typedef Realm::Logger Logger;
2550 typedef ::legion_coord_t coord_t;
2551 typedef std::map<CustomSerdezID,
2552 const Realm::CustomSerdezUntyped *> SerdezOpTable;
2553 typedef std::map<Realm::ReductionOpID,
2554 Realm::ReductionOpUntyped *> ReductionOpTable;
2555 typedef void (*SerdezInitFnptr)(const ReductionOp*, void *&, size_t&);
2556 typedef void (*SerdezFoldFnptr)(const ReductionOp*, void *&,
2557 size_t&, const void*);
2558 typedef std::map<Realm::ReductionOpID, SerdezRedopFns> SerdezRedopTable;
2559 typedef ::legion_projection_type_t HandleType;
2560 typedef ::legion_address_space_t AddressSpace;
2561 typedef ::legion_task_priority_t TaskPriority;
2562 typedef ::legion_task_priority_t RealmPriority;
2563 typedef ::legion_garbage_collection_priority_t GCPriority;
2564 typedef ::legion_color_t Color;
2565 typedef ::legion_field_id_t FieldID;
2566 typedef ::legion_trace_id_t TraceID;
2567 typedef ::legion_mapper_id_t MapperID;
2568 typedef ::legion_context_id_t ContextID;
2569 typedef ::legion_instance_id_t InstanceID;
2570 typedef ::legion_index_space_id_t IndexSpaceID;
2571 typedef ::legion_index_partition_id_t IndexPartitionID;
2572 typedef ::legion_index_tree_id_t IndexTreeID;
2573 typedef ::legion_field_space_id_t FieldSpaceID;
2574 typedef ::legion_generation_id_t GenerationID;
2575 typedef ::legion_type_handle TypeHandle;
2576 typedef ::legion_projection_id_t ProjectionID;
2577 typedef ::legion_sharding_id_t ShardingID;
2578 typedef ::legion_region_tree_id_t RegionTreeID;
2579 typedef ::legion_distributed_id_t DistributedID;
2580 typedef ::legion_address_space_t AddressSpaceID;
2581 typedef ::legion_tunable_id_t TunableID;
2582 typedef ::legion_local_variable_id_t LocalVariableID;
2583 typedef ::legion_mapping_tag_id_t MappingTagID;
2584 typedef ::legion_semantic_tag_t SemanticTag;
2585 typedef ::legion_variant_id_t VariantID;
2586 typedef ::legion_code_descriptor_id_t CodeDescriptorID;
2587 typedef ::legion_unique_id_t UniqueID;
2588 typedef ::legion_version_id_t VersionID;
2589 typedef ::legion_projection_epoch_id_t ProjectionEpochID;
2590 typedef ::legion_task_id_t TaskID;
2591 typedef ::legion_layout_constraint_id_t LayoutConstraintID;
2592 typedef ::legion_shard_id_t ShardID;
2593 typedef ::legion_provenance_id_t ProvenanceID;
2594 typedef ::legion_internal_color_t LegionColor;
2595 typedef void (*RegistrationCallbackFnptr)(Machine machine,
2596 Runtime *rt, const std::set<Processor> &local_procs);
2597 typedef void (*RegistrationWithArgsCallbackFnptr)(
2598 const RegistrationCallbackArgs &args);
2599 typedef LogicalRegion (*RegionProjectionFnptr)(LogicalRegion parent,
2600 const DomainPoint&, Runtime *rt);
2601 typedef LogicalRegion (*PartitionProjectionFnptr)(LogicalPartition parent,
2602 const DomainPoint&, Runtime *rt);
2603 typedef bool (*PredicateFnptr)(const void*, size_t,
2604 const std::vector<Future> futures);
2605 typedef void (*RealmFnptr)(const void*,size_t,
2606 const void*,size_t,Processor);
2607 // Magical typedefs
2608 // (don't forget to update ones in old HighLevel namespace in legion.inl)
2609 typedef Internal::TaskContext* Context;
2610 // Anothing magical typedef
2611 namespace Mapping {
2612 typedef Internal::MappingCallInfo* MapperContext;
2613 typedef Internal::InstanceManager* PhysicalInstanceImpl;
2614 typedef Internal::CollectiveView* CollectiveViewImpl;
2615 // This type import is experimental to facilitate coordination and
2616 // synchronization between different mappers and may be revoked later
2617 // as we develop new abstractions for mappers to interact
2618 typedef Internal::LocalLock LocalLock;
2619 };
2620
2621 namespace Internal {
2622 // The invalid color
2623 const LegionColor INVALID_COLOR = LLONG_MAX;
2624 // This is only needed internally
2625 typedef Realm::RegionInstance PhysicalInstance;
2626 typedef Realm::CopySrcDstField CopySrcDstField;
2627 typedef unsigned long long CollectiveID;
2628 typedef unsigned long long IndexSpaceExprID;
2629 struct ContextCoordinate;
2630 typedef ContextCoordinate TraceLocalID;
2631 typedef std::vector<ContextCoordinate> TaskTreeCoordinates;
2632 // Helper for encoding templates
2633 struct NT_TemplateHelper :
2634 public Realm::DynamicTemplates::ListProduct2<Realm::DIMCOUNTS,
2635 Realm::DIMTYPES> {
2636 typedef Realm::DynamicTemplates::ListProduct2<Realm::DIMCOUNTS,
2637 Realm::DIMTYPES> SUPER;
2638 public:
2639 template<int N, typename T> __CUDA_HD__
2640 static inline constexpr TypeTag encode_tag(void) {
2641#if __cplusplus >= 201402L
2642 constexpr TypeTag type =
2643 SUPER::template encode_tag<Realm::DynamicTemplates::Int<N>, T>();
2644 static_assert(type != 0, "All types should be non-zero for Legion");
2645 return type;
2646#else
2647 return SUPER::template encode_tag<Realm::DynamicTemplates::Int<N>, T>();
2648#endif
2649 }
2650 template<int N, typename T>
2651 static inline void check_type(const TypeTag t) {
2652#ifdef DEBUG_LEGION
2653#ifndef NDEBUG
2654 const TypeTag t1 = encode_tag<N,T>();
2655#endif
2656 assert(t1 == t);
2657#endif
2658 }
2659 struct DimHelper {
2660 public:
2661 template<typename N, typename T>
2662 static inline void demux(int *result) { *result = N::N; }
2663 };
2664 static inline int get_dim(const TypeTag t) {
2665 int result = 0;
2666 SUPER::demux<DimHelper>(t, &result);
2667 return result;
2668 }
2669 };
2670 // Pull some of the mapper types into the internal space
2671 typedef Mapping::Mapper Mapper;
2672 typedef Mapping::PhysicalInstance MappingInstance;
2673 typedef Mapping::CollectiveView MappingCollective;
2674 // A little bit of logic here to figure out the
2675 // kind of bit mask to use for FieldMask
2676
2677// The folowing macros are used in the FieldMask instantiation of BitMask
2678// If you change one you probably have to change the others too
2679#define LEGION_FIELD_MASK_FIELD_TYPE uint64_t
2680#define LEGION_FIELD_MASK_FIELD_SHIFT 6
2681#define LEGION_FIELD_MASK_FIELD_MASK 0x3F
2682#define LEGION_FIELD_MASK_FIELD_ALL_ONES 0xFFFFFFFFFFFFFFFF
2683
2684#if defined(__AVX__)
2685#if (LEGION_MAX_FIELDS > 256)
2686 typedef AVXTLBitMask<LEGION_MAX_FIELDS> FieldMask;
2687#elif (LEGION_MAX_FIELDS > 128)
2688 typedef AVXBitMask<LEGION_MAX_FIELDS> FieldMask;
2689#elif (LEGION_MAX_FIELDS > 64)
2690 typedef SSEBitMask<LEGION_MAX_FIELDS> FieldMask;
2691#else
2692 typedef BitMask<LEGION_FIELD_MASK_FIELD_TYPE,LEGION_MAX_FIELDS,
2693 LEGION_FIELD_MASK_FIELD_SHIFT,
2694 LEGION_FIELD_MASK_FIELD_MASK> FieldMask;
2695#endif
2696#elif defined(__SSE2__)
2697#if (LEGION_MAX_FIELDS > 128)
2698 typedef SSETLBitMask<LEGION_MAX_FIELDS> FieldMask;
2699#elif (LEGION_MAX_FIELDS > 64)
2700 typedef SSEBitMask<LEGION_MAX_FIELDS> FieldMask;
2701#else
2702 typedef BitMask<LEGION_FIELD_MASK_FIELD_TYPE,LEGION_MAX_FIELDS,
2703 LEGION_FIELD_MASK_FIELD_SHIFT,
2704 LEGION_FIELD_MASK_FIELD_MASK> FieldMask;
2705#endif
2706#elif defined(__ALTIVEC__)
2707#if (LEGION_MAX_FIELDS > 128)
2708 typedef PPCTLBitMask<LEGION_MAX_FIELDS> FieldMask;
2709#elif (LEGION_MAX_FIELDS > 64)
2710 typedef PPCBitMask<LEGION_MAX_FIELDS> FieldMask;
2711#else
2712 typedef BitMask<LEGION_FIELD_MASK_FIELD_TYPE,LEGION_MAX_FIELDS,
2713 LEGION_FIELD_MASK_FIELD_SHIFT,
2714 LEGION_FIELD_MASK_FIELD_MASK> FieldMask;
2715#endif
2716#elif defined(__ARM_NEON)
2717#if (LEGION_MAX_FIELDS > 128)
2718 typedef NeonTLBitMask<LEGION_MAX_FIELDS> FieldMask;
2719#elif (LEGION_MAX_FIELDS > 64)
2720 typedef NeonBitMask<LEGION_MAX_FIELDS> FieldMask;
2721#else
2722 typedef BitMask<LEGION_FIELD_MASK_FIELD_TYPE,LEGION_MAX_FIELDS,
2723 LEGION_FIELD_MASK_FIELD_SHIFT,
2724 LEGION_FIELD_MASK_FIELD_MASK> FieldMask;
2725#endif
2726#else
2727#if (LEGION_MAX_FIELDS > 64)
2728 typedef TLBitMask<LEGION_FIELD_MASK_FIELD_TYPE,LEGION_MAX_FIELDS,
2729 LEGION_FIELD_MASK_FIELD_SHIFT,
2730 LEGION_FIELD_MASK_FIELD_MASK> FieldMask;
2731#else
2732 typedef BitMask<LEGION_FIELD_MASK_FIELD_TYPE,LEGION_MAX_FIELDS,
2733 LEGION_FIELD_MASK_FIELD_SHIFT,
2734 LEGION_FIELD_MASK_FIELD_MASK> FieldMask;
2735#endif
2736#endif
2737 typedef BitPermutation<FieldMask,LEGION_FIELD_LOG2> FieldPermutation;
2738 typedef Fraction<unsigned long> InstFrac;
2739#undef LEGION_FIELD_MASK_FIELD_SHIFT
2740#undef LEGION_FIELD_MASK_FIELD_MASK
2741
2742 // Similar logic as field masks for node masks
2743
2744// The following macros are used in the NodeMask instantiation of BitMask
2745// If you change one you probably have to change the others too
2746#define LEGION_NODE_MASK_NODE_TYPE uint64_t
2747#define LEGION_NODE_MASK_NODE_SHIFT 6
2748#define LEGION_NODE_MASK_NODE_MASK 0x3F
2749#define LEGION_NODE_MASK_NODE_ALL_ONES 0xFFFFFFFFFFFFFFFF
2750
2751#if defined(__AVX__)
2752#if (LEGION_MAX_NUM_NODES > 256)
2753 typedef AVXTLBitMask<LEGION_MAX_NUM_NODES> NodeMask;
2754#elif (LEGION_MAX_NUM_NODES > 128)
2755 typedef AVXBitMask<LEGION_MAX_NUM_NODES> NodeMask;
2756#elif (LEGION_MAX_NUM_NODES > 64)
2757 typedef SSEBitMask<LEGION_MAX_NUM_NODES> NodeMask;
2758#else
2759 typedef BitMask<LEGION_NODE_MASK_NODE_TYPE,LEGION_MAX_NUM_NODES,
2760 LEGION_NODE_MASK_NODE_SHIFT,
2761 LEGION_NODE_MASK_NODE_MASK> NodeMask;
2762#endif
2763#elif defined(__SSE2__)
2764#if (LEGION_MAX_NUM_NODES > 128)
2765 typedef SSETLBitMask<LEGION_MAX_NUM_NODES> NodeMask;
2766#elif (LEGION_MAX_NUM_NODES > 64)
2767 typedef SSEBitMask<LEGION_MAX_NUM_NODES> NodeMask;
2768#else
2769 typedef BitMask<LEGION_NODE_MASK_NODE_TYPE,LEGION_MAX_NUM_NODES,
2770 LEGION_NODE_MASK_NODE_SHIFT,
2771 LEGION_NODE_MASK_NODE_MASK> NodeMask;
2772#endif
2773#elif defined(__ALTIVEC__)
2774#if (LEGION_MAX_NUM_NODES > 128)
2775 typedef PPCTLBitMask<LEGION_MAX_NUM_NODES> NodeMask;
2776#elif (LEGION_MAX_NUM_NODES > 64)
2777 typedef PPCBitMask<LEGION_MAX_NUM_NODES> NodeMask;
2778#else
2779 typedef BitMask<LEGION_NODE_MASK_NODE_TYPE,LEGION_MAX_NUM_NODES,
2780 LEGION_NODE_MASK_NODE_SHIFT,
2781 LEGION_NODE_MASK_NODE_MASK> NodeMask;
2782#endif
2783#elif defined(__ARM_NEON)
2784#if (LEGION_MAX_NUM_NODES > 128)
2785 typedef NeonTLBitMask<LEGION_MAX_NUM_NODES> NodeMask;
2786#elif (LEGION_MAX_NUM_NODES > 64)
2787 typedef NeonBitMask<LEGION_MAX_NUM_NODES> NodeMask;
2788#else
2789 typedef BitMask<LEGION_NODE_MASK_NODE_TYPE,LEGION_MAX_NUM_NODES,
2790 LEGION_NODE_MASK_NODE_SHIFT,
2791 LEGION_NODE_MASK_NODE_MASK> NodeMask;
2792#endif
2793#else
2794#if (LEGION_MAX_NUM_NODES > 64)
2795 typedef TLBitMask<LEGION_NODE_MASK_NODE_TYPE,LEGION_MAX_NUM_NODES,
2796 LEGION_NODE_MASK_NODE_SHIFT,
2797 LEGION_NODE_MASK_NODE_MASK> NodeMask;
2798#else
2799 typedef BitMask<LEGION_NODE_MASK_NODE_TYPE,LEGION_MAX_NUM_NODES,
2800 LEGION_NODE_MASK_NODE_SHIFT,
2801 LEGION_NODE_MASK_NODE_MASK> NodeMask;
2802#endif
2803#endif
2804 typedef CompoundBitMask<NodeMask,1/*bloat*/,true/*bidir*/> NodeSet;
2805
2806#undef LEGION_NODE_MASK_NODE_SHIFT
2807#undef LEGION_NODE_MASK_NODE_MASK
2808
2809// The following macros are used in the ProcessorMask instantiation of BitMask
2810// If you change one you probably have to change the others too
2811#define LEGION_PROC_MASK_PROC_TYPE uint64_t
2812#define LEGION_PROC_MASK_PROC_SHIFT 6
2813#define LEGION_PROC_MASK_PROC_MASK 0x3F
2814#define LEGION_PROC_MASK_PROC_ALL_ONES 0xFFFFFFFFFFFFFFFF
2815
2816#if defined(__AVX__)
2817#if (LEGION_MAX_NUM_PROCS > 256)
2818 typedef AVXTLBitMask<LEGION_MAX_NUM_PROCS> ProcessorMask;
2819#elif (LEGION_MAX_NUM_PROCS > 128)
2820 typedef AVXBitMask<LEGION_MAX_NUM_PROCS> ProcessorMask;
2821#elif (LEGION_MAX_NUM_PROCS > 64)
2822 typedef SSEBitMask<LEGION_MAX_NUM_PROCS> ProcessorMask;
2823#else
2824 typedef BitMask<LEGION_PROC_MASK_PROC_TYPE,LEGION_MAX_NUM_PROCS,
2825 LEGION_PROC_MASK_PROC_SHIFT,
2826 LEGION_PROC_MASK_PROC_MASK> ProcessorMask;
2827#endif
2828#elif defined(__SSE2__)
2829#if (LEGION_MAX_NUM_PROCS > 128)
2830 typedef SSETLBitMask<LEGION_MAX_NUM_PROCS> ProcessorMask;
2831#elif (LEGION_MAX_NUM_PROCS > 64)
2832 typedef SSEBitMask<LEGION_MAX_NUM_PROCS> ProcessorMask;
2833#else
2834 typedef BitMask<LEGION_PROC_MASK_PROC_TYPE,LEGION_MAX_NUM_PROCS,
2835 LEGION_PROC_MASK_PROC_SHIFT,
2836 LEGION_PROC_MASK_PROC_MASK> ProcessorMask;
2837#endif
2838#elif defined(__ALTIVEC__)
2839#if (LEGION_MAX_NUM_PROCS > 128)
2840 typedef PPCTLBitMask<LEGION_MAX_NUM_PROCS> ProcessorMask;
2841#elif (LEGION_MAX_NUM_PROCS > 64)
2842 typedef PPCBitMask<LEGION_MAX_NUM_PROCS> ProcessorMask;
2843#else
2844 typedef BitMask<LEGION_PROC_MASK_PROC_TYPE,LEGION_MAX_NUM_PROCS,
2845 LEGION_PROC_MASK_PROC_SHIFT,
2846 LEGION_PROC_MASK_PROC_MASK> ProcessorMask;
2847#endif
2848#elif defined(__ARM_NEON)
2849#if (LEGION_MAX_NUM_PROCS > 128)
2850 typedef NeonTLBitMask<LEGION_MAX_NUM_PROCS> ProcessorMask;
2851#elif (LEGION_MAX_NUM_PROCS > 64)
2852 typedef NeonBitMask<LEGION_MAX_NUM_PROCS> ProcessorMask;
2853#else
2854 typedef BitMask<LEGION_PROC_MASK_PROC_TYPE,LEGION_MAX_NUM_PROCS,
2855 LEGION_PROC_MASK_PROC_SHIFT,
2856 LEGION_PROC_MASK_PROC_MASK> ProcessorMask;
2857#endif
2858#else
2859#if (LEGION_MAX_NUM_PROCS > 64)
2860 typedef TLBitMask<LEGION_PROC_MASK_PROC_TYPE,LEGION_MAX_NUM_PROCS,
2861 LEGION_PROC_MASK_PROC_SHIFT,
2862 LEGION_PROC_MASK_PROC_MASK> ProcessorMask;
2863#else
2864 typedef BitMask<LEGION_PROC_MASK_PROC_TYPE,LEGION_MAX_NUM_PROCS,
2865 LEGION_PROC_MASK_PROC_SHIFT,
2866 LEGION_PROC_MASK_PROC_MASK> ProcessorMask;
2867#endif
2868#endif
2869
2870#undef PROC_SHIFT
2871#undef PROC_MASK
2872
2873 // Legion derived event types
2874 class LgEvent : public Realm::Event {
2875 public:
2876 static const LgEvent NO_LG_EVENT;
2877 public:
2878 LgEvent(void) noexcept { id = 0; }
2879 LgEvent(const LgEvent &rhs) = default;
2880 explicit LgEvent(const Realm::Event e) { id = e.id; }
2881 public:
2882 inline LgEvent& operator=(const LgEvent &rhs) = default;
2883 public:
2884 // Override the wait method so we can have our own implementation
2885 inline void wait(void) const;
2886 inline void wait_faultaware(bool &poisoned, bool from_application) const;
2887 inline bool is_barrier(void) const;
2888 protected:
2889 void begin_context_wait(Context ctx, bool from_application) const;
2890 void end_context_wait(Context ctx, bool from_application) const;
2891 void record_event_wait(LegionProfInstance *profiler,
2892 Realm::Backtrace &bt) const;
2893 void record_event_trigger(LgEvent precondition) const;
2894 };
2895
2896 class PredEvent : public LgEvent {
2897 public:
2898 static const PredEvent NO_PRED_EVENT;
2899 public:
2900 PredEvent(void) noexcept : LgEvent() { }
2901 PredEvent(const PredEvent &rhs) = default;
2902 explicit PredEvent(const Realm::Event &e) : LgEvent(e) { }
2903 public:
2904 inline PredEvent& operator=(const PredEvent &rhs) = default;
2905 };
2906
2907 class PredUserEvent : public PredEvent {
2908 public:
2909 static const PredUserEvent NO_PRED_USER_EVENT;
2910 public:
2911 PredUserEvent(void) noexcept : PredEvent() { }
2912 PredUserEvent(const PredUserEvent &rhs) = default;
2913 explicit PredUserEvent(const Realm::UserEvent &e) : PredEvent(e) { }
2914 public:
2915 inline PredUserEvent& operator=(const PredUserEvent &rhs) = default;
2916 inline operator Realm::UserEvent() const
2917 { Realm::UserEvent e; e.id = id; return e; }
2918 };
2919
2920 class ApEvent : public LgEvent {
2921 public:
2922 static const ApEvent NO_AP_EVENT;
2923 public:
2924 ApEvent(void) noexcept : LgEvent() { }
2925 ApEvent(const ApEvent &rhs) = default;
2926 explicit ApEvent(const Realm::Event &e) : LgEvent(e) { }
2927 explicit ApEvent(const PredEvent &e) { id = e.id; }
2928 public:
2929 inline ApEvent& operator=(const ApEvent &rhs) = default;
2930 inline bool has_triggered_faultignorant(void) const
2931 { bool poisoned = false;
2932 return has_triggered_faultaware(poisoned); }
2933 inline void wait_faultaware(bool &poisoned) const
2934 { return LgEvent::wait_faultaware(poisoned, true/*application*/); }
2935 inline void wait_faultignorant(void) const
2936 { bool poisoned = false;
2937 LgEvent::wait_faultaware(poisoned, true/*application*/); }
2938 private:
2939 // Make these private because we always want to be conscious of faults
2940 // when testing or waiting on application events
2941 inline bool has_triggered(void) const { return LgEvent::has_triggered(); }
2942 inline void wait(void) const { LgEvent::wait(); }
2943 };
2944
2945 class ApUserEvent : public ApEvent {
2946 public:
2947 static const ApUserEvent NO_AP_USER_EVENT;
2948 public:
2949 ApUserEvent(void) noexcept : ApEvent() { }
2950 ApUserEvent(const ApUserEvent &rhs) = default;
2951 explicit ApUserEvent(const Realm::UserEvent &e) : ApEvent(e) { }
2952 public:
2953 inline ApUserEvent& operator=(const ApUserEvent &rhs) = default;
2954 inline operator Realm::UserEvent() const
2955 { Realm::UserEvent e; e.id = id; return e; }
2956 };
2957
2958 class ApBarrier : public ApEvent {
2959 public:
2960 static const ApBarrier NO_AP_BARRIER;
2961 public:
2962 ApBarrier(void) noexcept : ApEvent(), timestamp(0) { }
2963 ApBarrier(const ApBarrier &rhs) = default;
2964 explicit ApBarrier(const Realm::Barrier &b)
2965 : ApEvent(b), timestamp(b.timestamp) { }
2966 public:
2967 inline ApBarrier& operator=(const ApBarrier &rhs) = default;
2968 inline operator Realm::Barrier() const
2969 { Realm::Barrier b; b.id = id;
2970 b.timestamp = timestamp; return b; }
2971 public:
2972 inline bool get_result(void *value, size_t value_size) const
2973 { Realm::Barrier b; b.id = id;
2974 b.timestamp = timestamp; return b.get_result(value, value_size); }
2975 inline void destroy_barrier(void)
2976 { Realm::Barrier b; b.id = id;
2977 b.timestamp = timestamp; b.destroy_barrier(); }
2978 public:
2979 Realm::Barrier::timestamp_t timestamp;
2980 };
2981
2982 class RtEvent : public LgEvent {
2983 public:
2984 static const RtEvent NO_RT_EVENT;
2985 public:
2986 RtEvent(void) noexcept : LgEvent() { }
2987 RtEvent(const RtEvent &rhs) = default;
2988 explicit RtEvent(const Realm::Event &e) : LgEvent(e) { }
2989 explicit RtEvent(const PredEvent &e) { id = e.id; }
2990 public:
2991 inline RtEvent& operator=(const RtEvent &rhs) = default;
2992 };
2993
2994 class RtUserEvent : public RtEvent {
2995 public:
2996 static const RtUserEvent NO_RT_USER_EVENT;
2997 public:
2998 RtUserEvent(void) noexcept : RtEvent() { }
2999 RtUserEvent(const RtUserEvent &rhs) = default;
3000 explicit RtUserEvent(const Realm::UserEvent &e) : RtEvent(e) { }
3001 public:
3002 inline RtUserEvent& operator=(const RtUserEvent &rhs) = default;
3003 inline operator Realm::UserEvent() const
3004 { Realm::UserEvent e; e.id = id; return e; }
3005 };
3006
3007 class RtBarrier : public RtEvent {
3008 public:
3009 static const RtBarrier NO_RT_BARRIER;
3010 public:
3011 RtBarrier(void) noexcept : RtEvent(), timestamp(0) { }
3012 RtBarrier(const RtBarrier &rhs) = default;
3013 explicit RtBarrier(const Realm::Barrier &b)
3014 : RtEvent(b), timestamp(b.timestamp) { }
3015 public:
3016 inline RtBarrier& operator=(const RtBarrier &rhs) = default;
3017 inline operator Realm::Barrier() const
3018 { Realm::Barrier b; b.id = id;
3019 b.timestamp = timestamp; return b; }
3020 public:
3021 inline bool get_result(void *value, size_t value_size) const
3022 { Realm::Barrier b; b.id = id;
3023 b.timestamp = timestamp; return b.get_result(value, value_size); }
3024 inline RtBarrier get_previous_phase(void)
3025 { Realm::Barrier b; b.id = id;
3026 return RtBarrier(b.get_previous_phase()); }
3027 inline void destroy_barrier(void)
3028 { Realm::Barrier b; b.id = id;
3029 b.timestamp = timestamp; b.destroy_barrier(); }
3030 public:
3031 Realm::Barrier::timestamp_t timestamp;
3032 };
3033
3034 // Local lock for accelerating lock taking
3035 class LocalLock {
3036 public:
3037 inline LocalLock(void) { }
3038 public:
3039 inline LocalLock(const LocalLock &rhs)
3040 {
3041 // should never be called
3042 assert(false);
3043 }
3044 inline ~LocalLock(void) { }
3045 public:
3046 inline LocalLock& operator=(const LocalLock &rhs)
3047 {
3048 // should never be called
3049 assert(false);
3050 return *this;
3051 }
3052 private:
3053 // These are only accessible via AutoLock
3054 friend class AutoLock;
3055 friend class AutoTryLock;
3056 friend class Mapping::AutoLock;
3057 inline RtEvent lock(void) { return RtEvent(wrlock()); }
3058 inline RtEvent wrlock(void) { return RtEvent(reservation.wrlock()); }
3059 inline RtEvent rdlock(void) { return RtEvent(reservation.rdlock()); }
3060 inline bool trylock(void) { return reservation.trylock(); }
3061 inline bool trywrlock(void) { return reservation.trywrlock(); }
3062 inline bool tryrdlock(void) { return reservation.tryrdlock(); }
3063 inline void unlock(void) { reservation.unlock(); }
3064 private:
3065 inline void advise_sleep_entry(Realm::UserEvent guard)
3066 { reservation.advise_sleep_entry(guard); }
3067 inline void advise_sleep_exit(void)
3068 { reservation.advise_sleep_exit(); }
3069 protected:
3070 Realm::FastReservation reservation;
3071 };
3072
3074 // AutoLock
3076 // An auto locking class for taking a lock and releasing it when
3077 // the object goes out of scope
3078 class AutoLock {
3079 public:
3080 inline AutoLock(LocalLock &r, int mode = 0, bool excl = true)
3081 : local_lock(r), previous(Internal::local_lock_list),
3082 exclusive(excl), held(true)
3083 {
3084#ifdef DEBUG_REENTRANT_LOCKS
3085 if (previous != NULL)
3086 previous->check_for_reentrant_locks(&local_lock);
3087#endif
3088 if (exclusive)
3089 {
3090 RtEvent ready = local_lock.wrlock();
3091 while (ready.exists())
3092 {
3093 ready.wait();
3094 ready = local_lock.wrlock();
3095 }
3096 }
3097 else
3098 {
3099 RtEvent ready = local_lock.rdlock();
3100 while (ready.exists())
3101 {
3102 ready.wait();
3103 ready = local_lock.rdlock();
3104 }
3105 }
3106 Internal::local_lock_list = this;
3107 }
3108 protected:
3109 // Helper constructor for AutoTryLock and Mapping::AutoLock
3110 inline AutoLock(int mode, bool excl, LocalLock &r)
3111 : local_lock(r), previous(Internal::local_lock_list),
3112 exclusive(excl), held(false)
3113 {
3114#ifdef DEBUG_REENTRANT_LOCKS
3115 if (previous != NULL)
3116 previous->check_for_reentrant_locks(&local_lock);
3117#endif
3118 }
3119 public:
3120 AutoLock(AutoLock &&rhs) = delete;
3121 AutoLock(const AutoLock &rhs) = delete;
3122 inline ~AutoLock(void)
3123 {
3124 if (held)
3125 {
3126#ifdef DEBUG_LEGION
3127 assert(Internal::local_lock_list == this);
3128#endif
3129 local_lock.unlock();
3130 Internal::local_lock_list = previous;
3131 }
3132 else
3133 assert(Internal::local_lock_list == previous);
3134 }
3135 public:
3136 AutoLock& operator=(AutoLock &&rhs) = delete;
3137 AutoLock& operator=(const AutoLock &rhs) = delete;
3138 public:
3139 inline void release(void)
3140 {
3141#ifdef DEBUG_LEGION
3142 assert(held);
3143 assert(Internal::local_lock_list == this);
3144#endif
3145 local_lock.unlock();
3146 Internal::local_lock_list = previous;
3147 held = false;
3148 }
3149 inline void reacquire(void)
3150 {
3151#ifdef DEBUG_LEGION
3152 assert(!held);
3153 assert(Internal::local_lock_list == previous);
3154#endif
3155#ifdef DEBUG_REENTRANT_LOCKS
3156 if (previous != NULL)
3157 previous->check_for_reentrant_locks(&local_lock);
3158#endif
3159 if (exclusive)
3160 {
3161 RtEvent ready = local_lock.wrlock();
3162 while (ready.exists())
3163 {
3164 ready.wait();
3165 ready = local_lock.wrlock();
3166 }
3167 }
3168 else
3169 {
3170 RtEvent ready = local_lock.rdlock();
3171 while (ready.exists())
3172 {
3173 ready.wait();
3174 ready = local_lock.rdlock();
3175 }
3176 }
3177 Internal::local_lock_list = this;
3178 held = true;
3179 }
3180 public:
3181 inline void advise_sleep_entry(Realm::UserEvent guard) const
3182 {
3183 if (held)
3184 local_lock.advise_sleep_entry(guard);
3185 if (previous != NULL)
3186 previous->advise_sleep_entry(guard);
3187 }
3188 inline void advise_sleep_exit(void) const
3189 {
3190 if (held)
3191 local_lock.advise_sleep_exit();
3192 if (previous != NULL)
3193 previous->advise_sleep_exit();
3194 }
3195#ifdef DEBUG_REENTRANT_LOCKS
3196 inline void check_for_reentrant_locks(LocalLock *to_acquire) const
3197 {
3198 assert(to_acquire != &local_lock);
3199 if (previous != NULL)
3200 previous->check_for_reentrant_locks(to_acquire);
3201 }
3202#endif
3203 protected:
3204 LocalLock &local_lock;
3205 AutoLock *const previous;
3206 const bool exclusive;
3207 bool held;
3208 };
3209
3210 // AutoTryLock is an extension of AutoLock that supports try lock
3211 class AutoTryLock : public AutoLock {
3212 public:
3213 inline AutoTryLock(LocalLock &r, int mode = 0, bool excl = true)
3214 : AutoLock(mode, excl, r)
3215 {
3216 if (exclusive)
3217 ready = local_lock.wrlock();
3218 else
3219 ready = local_lock.rdlock();
3220 held = !ready.exists();
3221 if (held)
3222 Internal::local_lock_list = this;
3223 }
3224 AutoTryLock(const AutoTryLock &rhs) = delete;
3225 public:
3226 AutoTryLock& operator=(const AutoTryLock &rhs) = delete;
3227 public:
3228 // Allow an easy test for whether we got the lock or not
3229 inline bool has_lock(void) const { return held; }
3230 inline RtEvent try_next(void) const { return ready; }
3231 protected:
3232 RtEvent ready;
3233 };
3234
3235 // Special method that we need here for waiting on events
3236
3237 //--------------------------------------------------------------------------
3238 inline void LgEvent::wait(void) const
3239 //--------------------------------------------------------------------------
3240 {
3241 if (!exists())
3242 return;
3243#ifdef DEBUG_LEGION_CALLERS
3244 LgTaskID local_kind = Internal::implicit_task_kind;
3245 LgTaskID local_caller = Internal::implicit_task_caller;
3246#endif
3247 // Save whether we are in a registration callback
3248 unsigned local_callback = Internal::inside_registration_callback;
3249 // Save the reference tracker that we have
3250 ImplicitReferenceTracker *local_tracker = implicit_reference_tracker;
3251 Internal::implicit_reference_tracker = NULL;
3252 LegionProfInstance *local_profiler = Internal::implicit_profiler;
3253 if (local_profiler != NULL)
3254 {
3255 // Cannot call back into wait while recording a wait
3256 implicit_profiler = NULL;
3257 Realm::Backtrace bt;
3258 bt.capture_backtrace();
3259 record_event_wait(local_profiler, bt);
3260 }
3261 // Save the context locally
3262 Internal::TaskContext *local_ctx = Internal::implicit_context;
3263 Internal::implicit_context = NULL;
3264 // Save the mapper call locally
3265 Internal::MappingCallInfo *local_call = Internal::implicit_mapper_call;
3266 Internal::implicit_mapper_call = NULL;
3267 // Save the implicit fevent
3268 LgEvent local_fevent = Internal::implicit_fevent;
3269 Internal::implicit_fevent = LgEvent::NO_LG_EVENT;
3270 // Save the task provenance information
3271 UniqueID local_provenance = Internal::implicit_provenance;
3272 Internal::implicit_provenance = 0;
3273 // Check to see if we have any local locks to notify
3274 if (Internal::local_lock_list != NULL)
3275 {
3276 // Make a copy of the local locks here
3277 AutoLock *local_lock_list_copy = Internal::local_lock_list;
3278 // Set this back to NULL until we are done waiting
3279 Internal::local_lock_list = NULL;
3280 // Make a user event and notify all the thread locks
3281 const Realm::UserEvent done = Realm::UserEvent::create_user_event();
3282 local_lock_list_copy->advise_sleep_entry(done);
3283 if (local_ctx != NULL)
3284 begin_context_wait(local_ctx, false/*from application*/);
3285 // Now we can do the wait
3286 if (!Processor::get_executing_processor().exists())
3287 Realm::Event::external_wait();
3288 else
3289 Realm::Event::wait();
3290 if (local_ctx != NULL)
3291 end_context_wait(local_ctx, false/*from application*/);
3292 // When we wake up, notify that we are done and exited the wait
3293 local_lock_list_copy->advise_sleep_exit();
3294 // If we're profiling we need to record that we triggered this
3295 // event as it will help us hook up the critical path for
3296 // local lock acquires
3297 if (local_profiler != NULL)
3298 {
3299 // Make sure to restore this before recording
3300 Internal::implicit_fevent = local_fevent;
3301 Internal::implicit_profiler = local_profiler;
3302 const LgEvent to_trigger(done);
3303 to_trigger.record_event_trigger(LgEvent::NO_LG_EVENT);
3304 }
3305 // Trigger the user-event
3306 done.trigger();
3307 // Restore our local lock list
3308 Internal::local_lock_list = local_lock_list_copy;
3309 }
3310 else // Just do the normal wait
3311 {
3312 if (local_ctx != NULL)
3313 begin_context_wait(local_ctx, false/*from application*/);
3314 if (!Processor::get_executing_processor().exists())
3315 Realm::Event::external_wait();
3316 else
3317 Realm::Event::wait();
3318 if (local_ctx != NULL)
3319 end_context_wait(local_ctx, false/*from application*/);
3320 }
3321 // Write the context back
3322 Internal::implicit_context = local_ctx;
3323 // Write the mapper call back
3324 Internal::implicit_mapper_call = local_call;
3325 // Write the implicit fevent back
3326 Internal::implicit_fevent = local_fevent;
3327 // Write the provenance information back
3328 Internal::implicit_provenance = local_provenance;
3329 // Restore the local profiler
3330 Internal::implicit_profiler = local_profiler;
3331#ifdef DEBUG_LEGION_CALLERS
3332 Internal::implicit_task_kind = local_kind;
3333 Internal::implicit_task_caller = local_caller;
3334#endif
3335 // Write the registration callback information back
3336 Internal::inside_registration_callback = local_callback;
3337#ifdef DEBUG_LEGION
3338 assert(Internal::implicit_reference_tracker == NULL);
3339#endif
3340 // Write the local reference tracker back
3341 Internal::implicit_reference_tracker = local_tracker;
3342 }
3343
3344 //--------------------------------------------------------------------------
3345 inline void LgEvent::wait_faultaware(bool &poisoned, bool from_app) const
3346 //--------------------------------------------------------------------------
3347 {
3348 if (!exists())
3349 return;
3350 if (has_triggered_faultaware(poisoned))
3351 return;
3352#ifdef DEBUG_LEGION_CALLERS
3353 LgTaskID local_kind = Internal::implicit_task_kind;
3354 LgTaskID local_caller = Internal::implicit_task_caller;
3355#endif
3356 // Save whether we are in a registration callback
3357 unsigned local_callback = Internal::inside_registration_callback;
3358 // Save the reference tracker that we have
3359 ImplicitReferenceTracker *local_tracker = implicit_reference_tracker;
3360 Internal::implicit_reference_tracker = NULL;
3361 LegionProfInstance *local_profiler = Internal::implicit_profiler;
3362 if (local_profiler != NULL)
3363 {
3364 // Cannot call back into wait while recording a wait
3365 implicit_profiler = NULL;
3366 Realm::Backtrace bt;
3367 bt.capture_backtrace();
3368 record_event_wait(local_profiler, bt);
3369 }
3370 // Save the context locally
3371 Internal::TaskContext *local_ctx = Internal::implicit_context;
3372 Internal::implicit_context = NULL;
3373 // Save the mapper call locally
3374 Internal::MappingCallInfo *local_call = Internal::implicit_mapper_call;
3375 Internal::implicit_mapper_call = NULL;
3376 // Save the fevent
3377 LgEvent local_fevent = Internal::implicit_fevent;
3378 Internal::implicit_fevent = LgEvent::NO_LG_EVENT;
3379 // Save the task provenance information
3380 UniqueID local_provenance = Internal::implicit_provenance;
3381 Internal::implicit_provenance = 0;
3382 // Check to see if we have any local locks to notify
3383 if (Internal::local_lock_list != NULL)
3384 {
3385 // Make a copy of the local locks here
3386 AutoLock *local_lock_list_copy = Internal::local_lock_list;
3387 // Set this back to NULL until we are done waiting
3388 Internal::local_lock_list = NULL;
3389 // Make a user event and notify all the thread locks
3390 const Realm::UserEvent done = Realm::UserEvent::create_user_event();
3391 local_lock_list_copy->advise_sleep_entry(done);
3392 if (local_ctx != NULL)
3393 begin_context_wait(local_ctx, from_app);
3394 // Now we can do the wait
3395 if (!Processor::get_executing_processor().exists())
3396 Realm::Event::external_wait_faultaware(poisoned);
3397 else
3398 Realm::Event::wait_faultaware(poisoned);
3399 if (local_ctx != NULL)
3400 end_context_wait(local_ctx, from_app);
3401 // When we wake up, notify that we are done and exited the wait
3402 local_lock_list_copy->advise_sleep_exit();
3403 // If we're profiling we need to record that we triggered this
3404 // event as it will help us hook up the critical path for
3405 // local lock acquires
3406 if (local_profiler != NULL)
3407 {
3408 // Make sure to restore this before recording
3409 Internal::implicit_fevent = local_fevent;
3410 Internal::implicit_profiler = local_profiler;
3411 const LgEvent to_trigger(done);
3412 to_trigger.record_event_trigger(LgEvent::NO_LG_EVENT);
3413 }
3414 // Trigger the user-event
3415 done.trigger();
3416 // Restore our local lock list
3417 Internal::local_lock_list = local_lock_list_copy;
3418 }
3419 else // Just do the normal wait
3420 {
3421 if (local_ctx != NULL)
3422 begin_context_wait(local_ctx, from_app);
3423 if (!Processor::get_executing_processor().exists())
3424 Realm::Event::external_wait_faultaware(poisoned);
3425 else
3426 Realm::Event::wait_faultaware(poisoned);
3427 if (local_ctx != NULL)
3428 end_context_wait(local_ctx, from_app);
3429 }
3430 // Write the context back
3431 Internal::implicit_context = local_ctx;
3432 // Write the mapper call back
3433 Internal::implicit_mapper_call = local_call;
3434 // Write the implicit fevent back
3435 Internal::implicit_fevent = local_fevent;
3436 // Write the provenance information back
3437 Internal::implicit_provenance = local_provenance;
3438 // Restore the local profiler
3439 Internal::implicit_profiler = local_profiler;
3440#ifdef DEBUG_LEGION_CALLERS
3441 Internal::implicit_task_kind = local_kind;
3442 Internal::implicit_task_caller = local_caller;
3443#endif
3444 // Write the registration callback information back
3445 Internal::inside_registration_callback = local_callback;
3446#ifdef DEBUG_LEGION
3447 assert(Internal::implicit_reference_tracker == NULL);
3448#endif
3449 // Write the local reference tracker back
3450 Internal::implicit_reference_tracker = local_tracker;
3451 }
3452
3453 //--------------------------------------------------------------------------
3454 inline bool LgEvent::is_barrier(void) const
3455 //--------------------------------------------------------------------------
3456 {
3457 const Realm::ID identity(id);
3458 return identity.is_barrier();
3459 }
3460
3461 }; // namespace Internal
3462
3463 // A class for preventing serialization of Legion objects
3464 // which cannot be serialized
3465 template<typename T>
3466 class Unserializable {
3467 public:
3468 inline size_t legion_buffer_size(void);
3469 inline size_t legion_serialize(void *buffer);
3470 inline size_t legion_deserialize(const void *buffer);
3471 };
3472
3473}; // Legion namespace
3474
3475#endif // __LEGION_TYPES_H__
BitMask
Definition legion_types.h:101
CompoundBitMask
Definition legion_types.h:120
Legion::Acquire
Definition legion.h:4521
Legion::ArraySyntax::AccessorRefHelper
Definition legion_types.h:209
Legion::ArraySyntax::AffineRefHelper
Definition legion_types.h:210
Legion::CObjectWrapper
Definition legion_c_util.h:53
Legion::Close
Definition legion.h:4569
Legion::Copy
Definition legion.h:4470
Legion::Domain
Definition legion_domain.h:253
Legion::DomainPoint
Definition legion_domain.h:132
Legion::Fill
Definition legion.h:4587
Legion::InlineMapping
Definition legion.h:4499
Legion::Internal::AllGatherCollective
Definition legion_types.h:2307
Legion::Internal::AllReduceCollective
Definition legion_types.h:2310
Legion::Internal::ApBarrier
Definition legion_types.h:2958
Legion::Internal::ApEvent
Definition legion_types.h:2920
Legion::Internal::ApUserEvent
Definition legion_types.h:2945
Legion::Internal::AutoLock
Definition legion_types.h:3078
Legion::Internal::AutoTryLock
Definition legion_types.h:3211
Legion::Internal::BarrierExchangeCollective
Definition legion_types.h:2308
Legion::Internal::BitPermutation
Definition legion_types.h:2025
Legion::Internal::ColorSpaceLinearizationT
Definition legion_types.h:2187
Legion::Internal::EqKDTreeT
Definition legion_types.h:2190
Legion::Internal::Fraction
Definition legion_types.h:2024
Legion::Internal::IndexPartNodeT
Definition legion_types.h:2181
Legion::Internal::IndexSpaceDifference
Definition legion_types.h:2175
Legion::Internal::IndexSpaceIntersection
Definition legion_types.h:2174
Legion::Internal::IndexSpaceNodeT
Definition legion_types.h:2179
Legion::Internal::IndexSpaceOperationT
Definition legion_types.h:2172
Legion::Internal::IndexSpaceUnion
Definition legion_types.h:2173
Legion::Internal::KDNode
Definition legion_types.h:2188
Legion::Internal::LgEvent
Definition legion_types.h:2874
Legion::Internal::LocalLock
Definition legion_types.h:3035
Legion::Internal::Memoizable
Definition legion_types.h:2110
Legion::Internal::PredEvent
Definition legion_types.h:2896
Legion::Internal::PredUserEvent
Definition legion_types.h:2907
Legion::Internal::Predicated
Definition legion_types.h:2112
Legion::Internal::RtBarrier
Definition legion_types.h:3007
Legion::Internal::RtEvent
Definition legion_types.h:2982
Legion::Internal::RtUserEvent
Definition legion_types.h:2994
Legion::Internal::ValueBroadcast
Definition legion_types.h:2309
Legion::LegionHandshake
Definition legion.h:4214
Legion::LogicalPartition
Definition legion.h:304
Legion::LogicalRegion
Definition legion.h:236
Legion::MPILegionHandshake
Definition legion.h:4279
Legion::MustEpoch
Definition legion.h:4648
Legion::Partition
Definition legion.h:4615
Legion::PieceIterator
Definition legion.h:3593
Legion::PieceIteratorT
Definition legion.h:3633
Legion::PointTransformFunctor
Definition legion.h:5037
Legion::ProjectionFunctor
Definition legion.h:4730
Legion::Release
Definition legion.h:4543
Legion::Runtime
Definition legion.h:5077
Legion::ShardingFunctor
Definition legion.h:4968
Legion::SpanIterator
Definition legion.h:3668
Legion::Task
Definition legion.h:4399
Legion::UnsafeFieldAccessor
Definition legion_types.h:207
Legion::Unserializable
Definition legion_types.h:3466
TLBitMask
Definition legion_types.h:103
legion_config.h
Legion::InputArgs
Definition legion.h:4673
Legion::Internal::LgTaskArgs
Definition legion_types.h:2372
Legion::Internal::NT_TemplateHelper::DimHelper
Definition legion_types.h:2659
Legion::Internal::NT_TemplateHelper
Definition legion_types.h:2635
Legion::RegistrationCallbackArgs
Definition legion.h:4683
Generated on Wed Mar 5 2025 18:09:59 for Legion Runtime by doxygen 1.9.8