17 #ifndef __LEGION_C_UTIL_H__
18 #define __LEGION_C_UTIL_H__
27 #include "legion/legion_mapping.h"
28 #include "mappers/mapping_utilities.h"
35 {
return lhs.value < rhs.value; }
44 std::set<legion_ptr_t> points;
45 std::set<std::pair<legion_ptr_t,legion_ptr_t> > ranges;
47 typedef std::map<Color,ColoredPoints> Coloring;
48 typedef std::map<Color,Domain> DomainColoring;
49 typedef std::map<DomainPoint,ColoredPoints> PointColoring;
50 typedef std::map<DomainPoint,Domain> DomainPointColoring;
51 typedef std::map<DomainPoint,std::set<Domain> > MultiDomainPointColoring;
55 #define ARRAY_ACCESSOR(DIM) \
56 typedef Legion::UnsafeFieldAccessor<char,DIM,coord_t, \
57 Realm::AffineAccessor<char,DIM,coord_t> > ArrayAccessor##DIM##D;
58 LEGION_FOREACH_N(ARRAY_ACCESSOR)
61 #define RECT_ITERATOR(DIM) \
62 typedef RectInDomainIterator<DIM,coord_t> RectInDomainIterator##DIM##D;
63 LEGION_FOREACH_N(RECT_ITERATOR)
66 #define BUFFER_CHAR(DIM) \
67 typedef DeferredBuffer<char,DIM> DeferredBufferChar##DIM##D;
68 LEGION_FOREACH_N(BUFFER_CHAR)
74 #pragma warning (push)
75 #pragma warning (disable: 858)
78 #pragma warning (push)
79 #pragma diag_suppress 191
80 #pragma diag_suppress 816
82 #define NEW_OPAQUE_WRAPPER(T_, T) \
83 static T_ wrap(T t) { \
85 t_.impl = static_cast<void *>(t); \
88 static const T_ wrap_const(const T t) { \
90 t_.impl = const_cast<void *>(static_cast<const void *>(t)); \
93 static T unwrap(T_ t_) { \
94 return static_cast<T>(t_.impl); \
96 static const T unwrap_const(const T_ t_) { \
97 return static_cast<const T>(t_.impl); \
100 NEW_OPAQUE_WRAPPER(legion_runtime_t,
Runtime *);
101 NEW_OPAQUE_WRAPPER(legion_context_t,
CContext *);
103 #define RECT_ITERATOR(DIM) \
104 NEW_OPAQUE_WRAPPER(legion_rect_in_domain_iterator_##DIM##d_t, RectInDomainIterator##DIM##D *);
105 LEGION_FOREACH_N(RECT_ITERATOR)
107 NEW_OPAQUE_WRAPPER(legion_coloring_t, Coloring *);
108 NEW_OPAQUE_WRAPPER(legion_domain_coloring_t, DomainColoring *);
109 NEW_OPAQUE_WRAPPER(legion_point_coloring_t, PointColoring *);
110 NEW_OPAQUE_WRAPPER(legion_domain_point_coloring_t, DomainPointColoring *);
111 NEW_OPAQUE_WRAPPER(legion_multi_domain_point_coloring_t, MultiDomainPointColoring *);
112 NEW_OPAQUE_WRAPPER(legion_index_space_allocator_t, IndexSpaceAllocator *);
114 NEW_OPAQUE_WRAPPER(legion_argument_map_t,
ArgumentMap *);
115 NEW_OPAQUE_WRAPPER(legion_predicate_t,
Predicate *);
116 NEW_OPAQUE_WRAPPER(legion_future_t,
Future *);
117 NEW_OPAQUE_WRAPPER(legion_future_map_t,
FutureMap *);
118 #define BUFFER_CHAR(DIM) \
119 NEW_OPAQUE_WRAPPER(legion_deferred_buffer_char_##DIM##d_t, DeferredBufferChar##DIM##D *);
120 LEGION_FOREACH_N(BUFFER_CHAR)
122 NEW_OPAQUE_WRAPPER(legion_task_launcher_t,
TaskLauncher *);
125 NEW_OPAQUE_WRAPPER(legion_copy_launcher_t,
CopyLauncher *);
127 NEW_OPAQUE_WRAPPER(legion_fill_launcher_t,
FillLauncher *);
137 #define ACCESSOR_ARRAY(DIM) \
138 NEW_OPAQUE_WRAPPER(legion_accessor_array_##DIM##d_t, ArrayAccessor##DIM##D *);
140 #undef ACCESSOR_ARRAY
141 NEW_OPAQUE_WRAPPER(legion_task_t,
Task *);
142 NEW_OPAQUE_WRAPPER(legion_task_mut_t,
TaskMut *);
143 NEW_OPAQUE_WRAPPER(legion_copy_t,
Copy *);
144 NEW_OPAQUE_WRAPPER(legion_fill_t,
Fill *);
146 NEW_OPAQUE_WRAPPER(legion_mappable_t,
Mappable *);
149 NEW_OPAQUE_WRAPPER(legion_machine_t, Machine *);
150 NEW_OPAQUE_WRAPPER(legion_logger_t, Realm::Logger *);
151 NEW_OPAQUE_WRAPPER(legion_mapper_t, Mapping::Mapper *);
152 NEW_OPAQUE_WRAPPER(legion_processor_query_t, Machine::ProcessorQuery *);
153 NEW_OPAQUE_WRAPPER(legion_memory_query_t, Machine::MemoryQuery *);
154 NEW_OPAQUE_WRAPPER(legion_machine_query_interface_t,
155 Mapping::Utilities::MachineQueryInterface *);
156 NEW_OPAQUE_WRAPPER(legion_default_mapper_t, Mapping::DefaultMapper *);
157 NEW_OPAQUE_WRAPPER(legion_execution_constraint_set_t, ExecutionConstraintSet *);
158 NEW_OPAQUE_WRAPPER(legion_layout_constraint_set_t, LayoutConstraintSet *);
159 NEW_OPAQUE_WRAPPER(legion_task_layout_constraint_set_t, TaskLayoutConstraintSet *);
160 NEW_OPAQUE_WRAPPER(legion_map_task_input_t, Mapping::Mapper::MapTaskInput *);
161 NEW_OPAQUE_WRAPPER(legion_map_task_output_t, Mapping::Mapper::MapTaskOutput *);
162 NEW_OPAQUE_WRAPPER(legion_slice_task_output_t, Mapping::Mapper::SliceTaskOutput *);
163 NEW_OPAQUE_WRAPPER(legion_physical_instance_t, Mapping::PhysicalInstance *);
164 NEW_OPAQUE_WRAPPER(legion_mapper_runtime_t, Mapping::MapperRuntime *);
168 NEW_OPAQUE_WRAPPER(legion_mapper_context_t, Internal::MappingCallInfo *);
169 typedef std::map<FieldID, const char *> FieldMap;
170 NEW_OPAQUE_WRAPPER(legion_field_map_t, FieldMap *);
172 #undef NEW_OPAQUE_WRAPPER
176 #pragma warning (pop)
179 #pragma warning (pop)
182 #define NEW_POINT_WRAPPER(DIM) \
183 typedef Point<DIM,coord_t> Point##DIM##D; \
184 static legion_point_##DIM##d_t wrap(Point##DIM##D t) { \
185 legion_point_##DIM##d_t t_; \
186 for (int i = 0; i < DIM; i++) \
190 static Point##DIM##D unwrap(legion_point_##DIM##d_t t_) { \
192 for (int i = 0; i < DIM; i++) \
196 LEGION_FOREACH_N(NEW_POINT_WRAPPER)
197 #undef NEW_POINT_WRAPPER
199 #define NEW_RECT_WRAPPER(DIM) \
200 typedef Rect<DIM,coord_t> Rect##DIM##D; \
201 static legion_rect_##DIM##d_t wrap(Rect##DIM##D t) { \
202 legion_rect_##DIM##d_t t_; \
203 t_.lo = wrap(Point##DIM##D(t.lo)); \
204 t_.hi = wrap(Point##DIM##D(t.hi)); \
207 static Rect##DIM##D unwrap(legion_rect_##DIM##d_t t_) { \
208 Rect##DIM##D t(unwrap(t_.lo), unwrap(t_.hi)); \
211 LEGION_FOREACH_N(NEW_RECT_WRAPPER)
212 #undef NEW_RECT_WRAPPER
214 #define NEW_BLOCKIFY_WRAPPER(DIM) \
215 static Blockify<DIM> unwrap(legion_blockify_##DIM##d_t t_) { \
216 Blockify<DIM> t(unwrap(t_.block_size), unwrap(t_.offset)); \
223 Point<DIM,coord_t> o)
224 : block_size(b), offset(o) { }
226 Point<DIM,coord_t> block_size, offset;
228 LEGION_FOREACH_N(NEW_BLOCKIFY_WRAPPER)
229 #undef NEW_BLOCKIFY_WRAPPER
231 #define NEW_TRANSFORM_WRAPPER(D1,D2) \
232 typedef Transform<D1,D2,coord_t> Transform##D1##x##D2; \
233 static legion_transform_##D1##x##D2##_t wrap(Transform##D1##x##D2 t) { \
234 legion_transform_##D1##x##D2##_t t_; \
235 for (int i = 0; i < D1; i++) \
236 for (int j = 0; j < D2; j++) \
237 t_.trans[i][j] = t[i][j]; \
240 static Transform##D1##x##D2 unwrap(legion_transform_##D1##x##D2##_t t_) { \
241 Transform##D1##x##D2 t; \
242 for (int i = 0; i < D1; i++) \
243 for (int j = 0; j < D2; j++) \
244 t[i][j] = t_.trans[i][j]; \
247 LEGION_FOREACH_NN(NEW_TRANSFORM_WRAPPER)
248 #undef NEW_TRANSFORM_WRAPPER
250 #define NEW_AFFINE_TRANSFORM_WRAPPER(D1,D2) \
251 typedef AffineTransform<D1,D2,coord_t> AffineTransform##D1##x##D2; \
252 static legion_affine_transform_##D1##x##D2##_t wrap(AffineTransform##D1##x##D2 t) { \
253 legion_affine_transform_##D1##x##D2##_t t_; \
254 t_.transform = wrap(t.transform); \
255 t_.offset = wrap(t.offset); \
258 static AffineTransform##D1##x##D2 unwrap(legion_affine_transform_##D1##x##D2##_t t_) { \
259 AffineTransform##D1##x##D2 t; \
260 t.transform = unwrap(t_.transform); \
261 t.offset = unwrap(t_.offset); \
264 LEGION_FOREACH_NN(NEW_AFFINE_TRANSFORM_WRAPPER)
265 #undef NEW_AFFINE_TRANSFORM_WRAPPER
270 domain_.is_id = domain.is_id;
271 domain_.is_type = domain.is_type;
272 domain_.dim = domain.dim;
273 std::copy(domain.rect_data, domain.rect_data + 2 * LEGION_MAX_DIM, domain_.rect_data);
280 domain.is_id = domain_.is_id;
281 domain.is_type = domain_.is_type;
282 domain.dim = domain_.dim;
283 std::copy(domain_.rect_data, domain_.rect_data + 2 * LEGION_MAX_DIM, domain.rect_data);
288 wrap(DomainPoint dp) {
291 std::copy(dp.point_data, dp.point_data + LEGION_MAX_DIM, dp_.point_data);
299 std::copy(dp_.point_data, dp_.point_data + LEGION_MAX_DIM, dp.point_data);
304 wrap(DomainTransform transform) {
306 transform_.m = transform.m;
307 transform_.n = transform.n;
308 std::copy(transform.matrix, transform.matrix + LEGION_MAX_DIM * LEGION_MAX_DIM, transform_.matrix);
312 static DomainTransform
314 DomainTransform transform;
315 transform.m = transform_.m;
316 transform.n = transform_.n;
317 std::copy(transform_.matrix, transform_.matrix + LEGION_MAX_DIM * LEGION_MAX_DIM, transform.matrix);
322 wrap(DomainAffineTransform transform) {
324 transform_.transform = wrap(transform.transform);
325 transform_.offset = wrap(transform.offset);
329 static DomainAffineTransform
331 DomainAffineTransform transform;
332 transform.transform = unwrap(transform_.transform);
333 transform.offset = unwrap(transform_.offset);
343 is_.type_tag = is.type_tag;
353 is.type_tag = is_.type_tag;
358 wrap(IndexPartition ip)
363 ip_.type_tag = ip.type_tag;
367 static IndexPartition
373 ip.type_tag = ip_.type_tag;
388 FieldSpace fs(fs_.id);
393 wrap(LogicalRegion r)
396 r_.tree_id = r.tree_id;
397 r_.index_space = wrap(r.index_space);
398 r_.field_space = wrap(r.field_space);
405 LogicalRegion r(r_.tree_id,
406 unwrap(r_.index_space),
407 unwrap(r_.field_space));
412 wrap(LogicalPartition r)
415 r_.tree_id = r.tree_id;
416 r_.index_partition = wrap(r.index_partition);
417 r_.field_space = wrap(r.field_space);
421 static LogicalPartition
424 LogicalPartition r(r_.tree_id,
425 unwrap(r_.index_partition),
426 unwrap(r_.field_space));
431 wrap(UntypedBuffer arg)
434 arg_.args = arg.get_ptr();
435 arg_.arglen = arg.get_size();
442 return UntypedBuffer(arg_.args, arg_.arglen);
446 wrap(
const ptrdiff_t offset)
449 offset_.offset = offset;
456 return offset_.offset;
460 wrap_const(
const InputArgs arg)
463 arg_.argv = arg.argv;
464 arg_.argc = arg.argc;
468 static const InputArgs
472 args.argv = args_.argv;
473 args.argc = args_.argc;
478 wrap(TaskConfigOptions options)
481 options_.leaf = options.leaf;
482 options_.inner = options.inner;
483 options_.idempotent = options.idempotent;
487 static TaskConfigOptions
490 TaskConfigOptions options(options_.leaf,
492 options_.idempotent);
512 static legion_processor_kind_t
513 wrap(Processor::Kind options)
515 return static_cast<legion_processor_kind_t
>(options);
518 static Processor::Kind
519 unwrap(legion_processor_kind_t options_)
521 return static_cast<Processor::Kind
>(options_);
540 static legion_memory_kind_t
541 wrap(Memory::Kind options)
543 return static_cast<legion_memory_kind_t
>(options);
547 unwrap(legion_memory_kind_t options_)
549 return static_cast<Memory::Kind
>(options_);
553 wrap(Mapping::Mapper::TaskSlice task_slice) {
555 task_slice_.domain = wrap(task_slice.domain);
556 task_slice_.proc = wrap(task_slice.proc);
557 task_slice_.recurse = task_slice.recurse;
558 task_slice_.stealable = task_slice.stealable;
562 static Mapping::Mapper::TaskSlice
564 Mapping::Mapper::TaskSlice task_slice;
565 task_slice.domain = unwrap(task_slice_.domain);
566 task_slice.proc = unwrap(task_slice_.proc);
567 task_slice.recurse = task_slice_.recurse;
568 task_slice.stealable = task_slice_.stealable;
573 wrap(PhaseBarrier barrier) {
575 barrier_.id = barrier.get_barrier().id;
576 barrier_.timestamp = barrier.get_barrier().timestamp;
582 PhaseBarrier barrier;
583 barrier.phase_barrier.id = barrier_.id;
584 barrier.phase_barrier.timestamp = barrier_.timestamp;
589 wrap(DynamicCollective collective) {
591 collective_.id = collective.get_barrier().id;
592 collective_.timestamp = collective.get_barrier().timestamp;
593 collective_.redop = collective.redop;
597 static DynamicCollective
599 DynamicCollective collective;
600 collective.phase_barrier.id = collective_.id;
601 collective.phase_barrier.timestamp = collective_.timestamp;
602 collective.redop = collective_.redop;
607 wrap(Mapping::Mapper::TaskOptions& options) {
609 options_.initial_proc = CObjectWrapper::wrap(options.initial_proc);
610 options_.inline_task = options.inline_task;
611 options_.stealable = options.stealable;
612 options_.map_locally = options.map_locally;
613 options_.valid_instances = options.valid_instances;
614 options_.memoize = options.memoize;
615 options_.replicate = options.replicate;
616 options_.parent_priority = options.parent_priority;
620 static Mapping::Mapper::TaskOptions
622 Mapping::Mapper::TaskOptions options;
623 options.initial_proc = CObjectWrapper::unwrap(options_.initial_proc);
624 options.inline_task = options_.inline_task;
625 options.stealable = options_.stealable;
626 options.map_locally = options_.map_locally;
627 options.valid_instances = options_.valid_instances;
628 options.memoize = options_.memoize;
629 options.replicate = options_.replicate;
630 options.parent_priority = options_.parent_priority;
635 wrap(Mapping::Mapper::SliceTaskInput& input) {
637 input_.domain = CObjectWrapper::wrap(input.domain);
642 wrap_const(
const Mapping::Mapper::SliceTaskInput& input) {
644 input_.domain = CObjectWrapper::wrap(input.domain);
648 static Mapping::Mapper::SliceTaskInput
650 Mapping::Mapper::SliceTaskInput input;
651 input.domain = CObjectWrapper::unwrap(input_.domain);
662 CContext(Context _ctx,
const std::vector<PhysicalRegion>& _physical_regions)
664 , physical_regions(_physical_regions.size())
666 for (
size_t i = 0; i < _physical_regions.size(); i++) {
667 physical_regions[i] =
674 for (
size_t i = 0; i < physical_regions.size(); i++) {
675 delete CObjectWrapper::unwrap(physical_regions[i]);
679 Context context(
void)
const
684 const legion_physical_region_t *regions(
void)
const
686 if(physical_regions.empty())
689 return &physical_regions[0];
692 size_t num_regions(
void)
const
694 return physical_regions.size();
699 std::vector<legion_physical_region_t> physical_regions;
705 virtual UniqueID get_unique_id(
void)
const {
709 virtual uint64_t get_context_index(
void)
const {
713 virtual int get_depth(
void)
const {
717 virtual const Task* get_parent_task(
void)
const {
721 virtual const std::string& get_provenance_string(
bool human=
true)
const {
723 return (*
new std::string());
725 virtual bool has_parent_task(
void)
const {
729 virtual const char* get_task_name(
void)
const {
733 virtual Domain get_slice_domain(
void)
const {
735 return Domain::NO_DOMAIN;
737 virtual ShardID get_shard_id(
void)
const {
741 virtual size_t get_total_shards(
void)
const {
749 virtual Domain get_shard_domain(
void)
const {
Definition: legion_c_util.h:656
Definition: legion_c_util.h:53
Definition: legion.h:4401
Definition: legion_domain.h:351
Definition: legion_domain.h:253
Definition: legion_domain.h:132
Definition: legion.h:2683
Definition: legion.h:4518
Definition: legion.h:1172
Definition: legion.h:1374
Definition: legion.h:4430
Definition: legion.h:4259
Definition: legion.h:2537
Definition: legion.h:5008
Definition: legion.h:4330
Definition: legion_c_util.h:702
#define ACCESSOR_ARRAY(DIM)
Definition: legion_c.h:5193
Definition: legion.h:3999
Definition: legion.h:2188
Definition: legion_c_util.h:220
Definition: legion_c_util.h:42
Definition: legion.h:1811
Definition: legion.h:2147
Definition: legion.h:1980
Definition: legion.h:2280
Definition: legion.h:1892
Definition: legion.h:2040
Definition: legion.h:1626
Definition: legion.h:1751
Definition: legion.h:4106
Definition: legion.h:1067
Definition: legion.h:4047
Definition: legion.h:1523
Definition: legion_c.h:299
Definition: legion_c.h:240
Definition: legion_c.h:195
Definition: legion_c.h:156
Definition: legion_c.h:203
Definition: legion_c.h:358
Definition: legion_c.h:266
Definition: legion_c.h:257
Definition: legion_c.h:248
Definition: legion_c.h:282
Definition: legion_c.h:273
Definition: legion_c.h:331
Definition: legion_c.h:348
Definition: legion_c.h:324
Definition: legion_c.h:122
Definition: legion_c.h:314
Definition: legion_c.h:371
Definition: legion_c.h:338
Definition: legion_c.h:291