Legion Runtime
Loading...
Searching...
No Matches
legion_c.h
Go to the documentation of this file.
1/* Copyright 2024 Stanford University
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
17#ifndef __LEGION_C_H__
18#define __LEGION_C_H__
19
25// ******************** IMPORTANT **************************
26//
27// This file is PURE C, **NOT** C++.
28//
29// ******************** IMPORTANT **************************
30
31#include "legion/legion_config.h"
32
33#include <stdbool.h>
34#ifndef LEGION_USE_PYTHON_CFFI
35#include <stddef.h>
36#include <stdint.h>
37#include <stdio.h>
38#endif // LEGION_USE_PYTHON_CFFI
39
40#ifdef __cplusplus
41extern "C" {
42#endif
43
44 // -----------------------------------------------------------------------
45 // Proxy Types
46 // -----------------------------------------------------------------------
47
48// #define NEW_OPAQUE_TYPE(T) typedef void * T
49#define NEW_OPAQUE_TYPE(T) typedef struct T { void *impl; } T
50 NEW_OPAQUE_TYPE(legion_runtime_t);
51 NEW_OPAQUE_TYPE(legion_context_t);
52 NEW_OPAQUE_TYPE(legion_domain_point_iterator_t);
53#define NEW_ITERATOR_TYPE(DIM) \
54 NEW_OPAQUE_TYPE(legion_rect_in_domain_iterator_##DIM##d_t);
55 LEGION_FOREACH_N(NEW_ITERATOR_TYPE);
56#undef NEW_ITERATOR_TYPE
57 NEW_OPAQUE_TYPE(legion_coloring_t);
58 NEW_OPAQUE_TYPE(legion_domain_coloring_t);
59 NEW_OPAQUE_TYPE(legion_point_coloring_t);
60 NEW_OPAQUE_TYPE(legion_domain_point_coloring_t);
61 NEW_OPAQUE_TYPE(legion_multi_domain_point_coloring_t);
62 NEW_OPAQUE_TYPE(legion_index_space_allocator_t);
63 NEW_OPAQUE_TYPE(legion_field_allocator_t);
64 NEW_OPAQUE_TYPE(legion_argument_map_t);
65 NEW_OPAQUE_TYPE(legion_predicate_t);
66 NEW_OPAQUE_TYPE(legion_future_t);
67 NEW_OPAQUE_TYPE(legion_future_map_t);
68#define NEW_DEFERRED_BUFFER_TYPE(DIM) \
69 NEW_OPAQUE_TYPE(legion_deferred_buffer_char_##DIM##d_t);
70 LEGION_FOREACH_N(NEW_DEFERRED_BUFFER_TYPE)
71#undef NEW_DEFERRED_BUFFER_TYPE
72 NEW_OPAQUE_TYPE(legion_task_launcher_t);
73 NEW_OPAQUE_TYPE(legion_index_launcher_t);
74 NEW_OPAQUE_TYPE(legion_inline_launcher_t);
75 NEW_OPAQUE_TYPE(legion_copy_launcher_t);
76 NEW_OPAQUE_TYPE(legion_index_copy_launcher_t);
77 NEW_OPAQUE_TYPE(legion_fill_launcher_t);
78 NEW_OPAQUE_TYPE(legion_index_fill_launcher_t);
79 NEW_OPAQUE_TYPE(legion_discard_launcher_t);
80 NEW_OPAQUE_TYPE(legion_acquire_launcher_t);
81 NEW_OPAQUE_TYPE(legion_release_launcher_t);
82 NEW_OPAQUE_TYPE(legion_attach_launcher_t);
83 NEW_OPAQUE_TYPE(legion_index_attach_launcher_t);
84 NEW_OPAQUE_TYPE(legion_must_epoch_launcher_t);
85 NEW_OPAQUE_TYPE(legion_physical_region_t);
86 NEW_OPAQUE_TYPE(legion_external_resources_t);
87#define NEW_ACCESSOR_ARRAY_TYPE(DIM) \
88 NEW_OPAQUE_TYPE(legion_accessor_array_##DIM##d_t);
89 LEGION_FOREACH_N(NEW_ACCESSOR_ARRAY_TYPE)
90#undef NEW_ACCESSOR_ARRAY_TYPE
91 NEW_OPAQUE_TYPE(legion_task_t);
92 NEW_OPAQUE_TYPE(legion_task_mut_t);
93 NEW_OPAQUE_TYPE(legion_copy_t);
94 NEW_OPAQUE_TYPE(legion_fill_t);
95 NEW_OPAQUE_TYPE(legion_inline_t);
96 NEW_OPAQUE_TYPE(legion_mappable_t);
97 NEW_OPAQUE_TYPE(legion_region_requirement_t);
98 NEW_OPAQUE_TYPE(legion_output_requirement_t);
99 NEW_OPAQUE_TYPE(legion_machine_t);
100 NEW_OPAQUE_TYPE(legion_logger_t);
101 NEW_OPAQUE_TYPE(legion_mapper_t);
102 NEW_OPAQUE_TYPE(legion_default_mapper_t);
103 NEW_OPAQUE_TYPE(legion_processor_query_t);
104 NEW_OPAQUE_TYPE(legion_memory_query_t);
105 NEW_OPAQUE_TYPE(legion_machine_query_interface_t);
106 NEW_OPAQUE_TYPE(legion_execution_constraint_set_t);
107 NEW_OPAQUE_TYPE(legion_layout_constraint_set_t);
108 NEW_OPAQUE_TYPE(legion_task_layout_constraint_set_t);
109 NEW_OPAQUE_TYPE(legion_slice_task_output_t);
110 NEW_OPAQUE_TYPE(legion_map_task_input_t);
111 NEW_OPAQUE_TYPE(legion_map_task_output_t);
112 NEW_OPAQUE_TYPE(legion_physical_instance_t);
113 NEW_OPAQUE_TYPE(legion_mapper_runtime_t);
114 NEW_OPAQUE_TYPE(legion_mapper_context_t);
115 NEW_OPAQUE_TYPE(legion_field_map_t);
116 NEW_OPAQUE_TYPE(legion_point_transform_functor_t);
117 NEW_OPAQUE_TYPE(legion_task_variant_registrar_t);
118#undef NEW_OPAQUE_TYPE
119
123 typedef struct legion_ptr_t {
124 long long int value;
125 } legion_ptr_t;
126
127 typedef legion_coord_t coord_t;
128
129#define NEW_POINT_TYPE(DIM) typedef struct legion_point_##DIM##d_t { coord_t x[DIM]; } legion_point_##DIM##d_t;
130 LEGION_FOREACH_N(NEW_POINT_TYPE)
131#undef NEW_POINT_TYPE
132
133#define NEW_RECT_TYPE(DIM) typedef struct legion_rect_##DIM##d_t { legion_point_##DIM##d_t lo, hi; } legion_rect_##DIM##d_t;
134 LEGION_FOREACH_N(NEW_RECT_TYPE)
135#undef NEW_RECT_TYPE
136
137#define NEW_BLOCKIFY_TYPE(DIM) \
138 typedef struct legion_blockify_##DIM##d_t { legion_point_##DIM##d_t block_size; legion_point_##DIM##d_t offset; } legion_blockify_##DIM##d_t;
139 LEGION_FOREACH_N(NEW_BLOCKIFY_TYPE)
140#undef NEW_BLOCKIFY_TYPE
141
142#define NEW_TRANSFORM_TYPE(D1,D2) \
143 typedef struct legion_transform_##D1##x##D2##_t { coord_t trans[D1][D2]; } legion_transform_##D1##x##D2##_t;
144 LEGION_FOREACH_NN(NEW_TRANSFORM_TYPE)
145#undef NEW_TRANSFORM_TYPE
146
147#define NEW_AFFINE_TRANSFORM_TYPE(D1,D2) \
148 typedef struct legion_affine_transform_##D1##x##D2##_t { \
149 legion_transform_##D1##x##D2##_t transform; legion_point_##D1##d_t offset; } \
150 legion_affine_transform_##D1##x##D2##_t;
151 LEGION_FOREACH_NN(NEW_AFFINE_TRANSFORM_TYPE)
152#undef NEW_AFFINE_TRANSFORM_TYPE
153
157 typedef struct legion_domain_t {
158 realm_id_t is_id;
159 legion_type_tag_t is_type;
160 int dim;
161// Hack: Python CFFI isn't smart enough to do constant folding so we
162// have to do this by hand here. To avoid this bitrotting, at least
163// make the preprocessor check that the value is equal to what we
164// expect.
165#if LEGION_MAX_DIM == 1
166#define MAX_DOMAIN_DIM 2 // 2 * LEGION_MAX_RECT_DIM
167#elif LEGION_MAX_DIM == 2
168#define MAX_DOMAIN_DIM 4 // 2 * LEGION_MAX_RECT_DIM
169#elif LEGION_MAX_DIM == 3
170#define MAX_DOMAIN_DIM 6 // 2 * LEGION_MAX_RECT_DIM
171#elif LEGION_MAX_DIM == 4
172#define MAX_DOMAIN_DIM 8 // 2 * LEGION_MAX_RECT_DIM
173#elif LEGION_MAX_DIM == 5
174#define MAX_DOMAIN_DIM 10 // 2 * LEGION_MAX_RECT_DIM
175#elif LEGION_MAX_DIM == 6
176#define MAX_DOMAIN_DIM 12 // 2 * LEGION_MAX_RECT_DIM
177#elif LEGION_MAX_DIM == 7
178#define MAX_DOMAIN_DIM 14 // 2 * LEGION_MAX_RECT_DIM
179#elif LEGION_MAX_DIM == 8
180#define MAX_DOMAIN_DIM 16 // 2 * LEGION_MAX_RECT_DIM
181#elif LEGION_MAX_DIM == 9
182#define MAX_DOMAIN_DIM 18 // 2 * LEGION_MAX_RECT_DIM
183#else
184#error "Illegal value of LEGION_MAX_DIM"
185#endif
186#if MAX_DOMAIN_DIM != 2 * LEGION_MAX_RECT_DIM // sanity check value
187#error Mismatch in MAX_DOMAIN_DIM
188#endif
189 coord_t rect_data[MAX_DOMAIN_DIM];
190#undef MAX_DOMAIN_DIM
191 } legion_domain_t;
192
196 typedef struct legion_domain_point_t {
197 int dim;
198 coord_t point_data[LEGION_MAX_DIM];
199 } legion_domain_point_t;
200
204 typedef struct legion_domain_transform_t {
205 int m, n;
206// Hack: Python CFFI isn't smart enough to do constant folding so we
207// have to do this by hand here. To avoid this bitrotting, at least
208// make the preprocessor check that the value is equal to what we
209// expect.
210#if LEGION_MAX_DIM == 1
211#define MAX_MATRIX_DIM 1
212#elif LEGION_MAX_DIM == 2
213#define MAX_MATRIX_DIM 4
214#elif LEGION_MAX_DIM == 3
215#define MAX_MATRIX_DIM 9
216#elif LEGION_MAX_DIM == 4
217#define MAX_MATRIX_DIM 16
218#elif LEGION_MAX_DIM == 5
219#define MAX_MATRIX_DIM 25
220#elif LEGION_MAX_DIM == 6
221#define MAX_MATRIX_DIM 36
222#elif LEGION_MAX_DIM == 7
223#define MAX_MATRIX_DIM 49
224#elif LEGION_MAX_DIM == 8
225#define MAX_MATRIX_DIM 64
226#elif LEGION_MAX_DIM == 9
227#define MAX_MATRIX_DIM 81
228#else
229#error "Illegal value of LEGION_MAX_DIM"
230#endif
231#if MAX_MATRIX_DIM != LEGION_MAX_POINT_DIM * LEGION_MAX_POINT_DIM // sanity check
232#error Mismatch in MAX_MATRIX_DIM
233#endif
234 coord_t matrix[MAX_MATRIX_DIM];
235#undef MAX_MATRIX_DIM
236 } legion_domain_transform_t;
237
245
249 typedef struct legion_index_space_t {
250 legion_index_space_id_t id;
251 legion_index_tree_id_t tid;
252 legion_type_tag_t type_tag;
253 } legion_index_space_t;
254
258 typedef struct legion_index_partition_t {
259 legion_index_partition_id_t id;
260 legion_index_tree_id_t tid;
261 legion_type_tag_t type_tag;
262 } legion_index_partition_t;
263
267 typedef struct legion_field_space_t {
268 legion_field_space_id_t id;
269 } legion_field_space_t;
270
274 typedef struct legion_logical_region_t {
275 legion_region_tree_id_t tree_id;
276 legion_index_space_t index_space;
277 legion_field_space_t field_space;
278 } legion_logical_region_t;
279
283 typedef struct legion_logical_partition_t {
284 legion_region_tree_id_t tree_id;
285 legion_index_partition_t index_partition;
286 legion_field_space_t field_space;
287 } legion_logical_partition_t;
288
292 typedef struct legion_untyped_buffer_t {
293 void *args;
294 size_t arglen;
295 } legion_untyped_buffer_t;
296 // This is for backwards compatibility when we used
297 // to call legion_untyped_buffer_t as legion_task_argument_t
298 typedef legion_untyped_buffer_t legion_task_argument_t;
299
300 typedef struct legion_byte_offset_t {
301 int offset;
302 } legion_byte_offset_t;
303
307 typedef struct legion_input_args_t {
308 char **argv;
309 int argc;
310 } legion_input_args_t;
311
315 typedef struct legion_task_config_options_t {
316 bool leaf /* = false */;
317 bool inner /* = false */;
318 bool idempotent /* = false */;
319 bool replicable /* = false */;
320 } legion_task_config_options_t;
321
325 typedef struct legion_processor_t {
326 realm_id_t id;
327 } legion_processor_t;
328
332 typedef struct legion_memory_t {
333 realm_id_t id;
334 } legion_memory_t;
335
339 typedef struct legion_task_slice_t {
340 legion_domain_t domain;
341 legion_processor_t proc;
342 bool recurse;
343 bool stealable;
344 } legion_task_slice_t;
345
349 typedef struct legion_phase_barrier_t {
350 // From Realm::Event
351 realm_id_t id;
352 // From Realm::Barrier
353 realm_barrier_timestamp_t timestamp;
354 } legion_phase_barrier_t;
355
359 typedef struct legion_dynamic_collective_t {
360 // From Legion::PhaseBarrier
361 // From Realm::Event
362 realm_id_t id;
363 // From Realm::Barrier
364 realm_barrier_timestamp_t timestamp;
365 // From Legion::DynamicCollective
366 legion_reduction_op_id_t redop;
367 } legion_dynamic_collective_t;
368
372 typedef struct legion_task_options_t {
373 legion_processor_t initial_proc;
374 bool inline_task;
375 bool stealable;
376 bool map_locally;
377 bool valid_instances;
378 bool memoize;
379 bool replicate;
380 legion_task_priority_t parent_priority;
381 } legion_task_options_t;
382
386
390 typedef
391 void (*legion_registration_callback_pointer_t)(
392 legion_machine_t /* machine */,
393 legion_runtime_t /* runtime */,
394 const legion_processor_t * /* local_procs */,
395 unsigned /* num_local_procs */);
396
401 typedef realm_task_pointer_t legion_task_pointer_wrapped_t;
402
407 typedef
408 legion_logical_region_t (*legion_projection_functor_logical_region_t)(
409 legion_runtime_t /* runtime */,
410 legion_logical_region_t /* upper_bound */,
411 legion_domain_point_t /* point */,
412 legion_domain_t /* launch domain */);
413
418 typedef
419 legion_logical_region_t (*legion_projection_functor_logical_partition_t)(
420 legion_runtime_t /* runtime */,
421 legion_logical_partition_t /* upper_bound */,
422 legion_domain_point_t /* point */,
423 legion_domain_t /* launch domain */);
424
429 typedef
430 legion_logical_region_t (*legion_projection_functor_logical_region_args_t)(
431 legion_runtime_t /* runtime */,
432 legion_logical_region_t /* upper_bound */,
433 legion_domain_point_t /* point */,
434 legion_domain_t /* launch domain */,
435 const void * /* args */,
436 size_t /* size */);
437
442 typedef
443 legion_logical_region_t (*legion_projection_functor_logical_partition_args_t)(
444 legion_runtime_t /* runtime */,
445 legion_logical_partition_t /* upper_bound */,
446 legion_domain_point_t /* point */,
447 legion_domain_t /* launch domain */,
448 const void * /* args */,
449 size_t /* size */);
450
455 typedef
456 legion_logical_region_t (*legion_projection_functor_logical_region_mappable_t)(
457 legion_runtime_t /* runtime */,
458 legion_mappable_t /* mappable */,
459 unsigned /* index */,
460 legion_logical_region_t /* upper_bound */,
461 legion_domain_point_t /* point */);
462
467 typedef
468 legion_logical_region_t (*legion_projection_functor_logical_partition_mappable_t)(
469 legion_runtime_t /* runtime */,
470 legion_mappable_t /* mappable */,
471 unsigned /* index */,
472 legion_logical_partition_t /* upper_bound */,
473 legion_domain_point_t /* point */);
474
475 // -----------------------------------------------------------------------
476 // Pointer Operations
477 // -----------------------------------------------------------------------
478
482 legion_ptr_t
483 legion_ptr_nil(void);
484
488 bool
489 legion_ptr_is_null(legion_ptr_t ptr);
490
495 legion_ptr_t
496 legion_ptr_safe_cast(legion_runtime_t runtime,
497 legion_context_t ctx,
498 legion_ptr_t pointer,
499 legion_logical_region_t region);
500
501 // -----------------------------------------------------------------------
502 // Domain Operations
503 // -----------------------------------------------------------------------
504
508 legion_domain_t
509 legion_domain_empty(unsigned dim);
510
514#define FROM_RECT(DIM) \
515 legion_domain_t \
516 legion_domain_from_rect_##DIM##d(legion_rect_##DIM##d_t r);
517 LEGION_FOREACH_N(FROM_RECT)
518#undef FROM_RECT
519
523 legion_domain_t
524 legion_domain_from_index_space(legion_runtime_t runtime,
525 legion_index_space_t is);
526
530#define GET_RECT(DIM) \
531 legion_rect_##DIM##d_t \
532 legion_domain_get_rect_##DIM##d(legion_domain_t d);
533 LEGION_FOREACH_N(GET_RECT)
534#undef GET_RECT
535
536 bool
537 legion_domain_is_dense(legion_domain_t d);
538
539 // These are the same as above but will ignore
540 // the existence of any sparsity map, whereas the
541 // ones above will fail if a sparsity map exists
542#define GET_BOUNDS(DIM) \
543 legion_rect_##DIM##d_t \
544 legion_domain_get_bounds_##DIM##d(legion_domain_t d);
545 LEGION_FOREACH_N(GET_BOUNDS)
546#undef GET_BOUNDS
547
551 bool
552 legion_domain_contains(legion_domain_t d, legion_domain_point_t p);
553
557 size_t
558 legion_domain_get_volume(legion_domain_t d);
559
560 // -----------------------------------------------------------------------
561 // Domain Transform Operations
562 // -----------------------------------------------------------------------
563
564 legion_domain_transform_t
565 legion_domain_transform_identity(unsigned m, unsigned n);
566
567#define FROM_TRANSFORM(D1,D2) \
568 legion_domain_transform_t \
569 legion_domain_transform_from_##D1##x##D2(legion_transform_##D1##x##D2##_t t);
570 LEGION_FOREACH_NN(FROM_TRANSFORM)
571#undef FROM_TRANSFORM
572
573 legion_domain_affine_transform_t
574 legion_domain_affine_transform_identity(unsigned m, unsigned n);
575
576#define FROM_AFFINE(D1,D2) \
577 legion_domain_affine_transform_t \
578 legion_domain_affine_transform_from_##D1##x##D2(legion_affine_transform_##D1##x##D2##_t t);
579 LEGION_FOREACH_NN(FROM_AFFINE)
580#undef FROM_AFFINE
581
582 // -----------------------------------------------------------------------
583 // Domain Point Operations
584 // -----------------------------------------------------------------------
585
589#define FROM_POINT(DIM) \
590 legion_domain_point_t \
591 legion_domain_point_from_point_##DIM##d(legion_point_##DIM##d_t p);
592 LEGION_FOREACH_N(FROM_POINT)
593#undef FROM_POINT
594
598#define GET_POINT(DIM) \
599 legion_point_##DIM##d_t \
600 legion_domain_point_get_point_##DIM##d(legion_domain_point_t p);
601 LEGION_FOREACH_N(GET_POINT)
602#undef GET_POINT
603
604 legion_domain_point_t
605 legion_domain_point_origin(unsigned dim);
606
610 legion_domain_point_t
611 legion_domain_point_nil(void);
612
616 bool
617 legion_domain_point_is_null(legion_domain_point_t point);
618
623 legion_domain_point_t
624 legion_domain_point_safe_cast(legion_runtime_t runtime,
625 legion_context_t ctx,
626 legion_domain_point_t point,
627 legion_logical_region_t region);
628
629 // -----------------------------------------------------------------------
630 // Domain Point Iterator
631 // -----------------------------------------------------------------------
632
638 legion_domain_point_iterator_t
639 legion_domain_point_iterator_create(legion_domain_t handle);
640
646 void
647 legion_domain_point_iterator_destroy(legion_domain_point_iterator_t handle);
648
652 bool
653 legion_domain_point_iterator_has_next(legion_domain_point_iterator_t handle);
654
658 legion_domain_point_t
659 legion_domain_point_iterator_next(legion_domain_point_iterator_t handle);
660
661 // -----------------------------------------------------------------------
662 // Rect in Domain Iterator
663 // -----------------------------------------------------------------------
664
670#define ITERATOR_CREATE(DIM) \
671 legion_rect_in_domain_iterator_##DIM##d_t \
672 legion_rect_in_domain_iterator_create_##DIM##d(legion_domain_t handle);
673 LEGION_FOREACH_N(ITERATOR_CREATE)
674#undef ITERATOR_CREATE
675
681#define ITERATOR_DESTROY(DIM) \
682 void legion_rect_in_domain_iterator_destroy_##DIM##d( \
683 legion_rect_in_domain_iterator_##DIM##d_t handle);
684 LEGION_FOREACH_N(ITERATOR_DESTROY)
685#undef ITERATOR_DESTROY
686
690#define ITERATOR_VALID(DIM) \
691 bool legion_rect_in_domain_iterator_valid_##DIM##d( \
692 legion_rect_in_domain_iterator_##DIM##d_t handle);
693 LEGION_FOREACH_N(ITERATOR_VALID)
694#undef ITERATOR_VALID
695
699#define ITERATOR_STEP(DIM) \
700 bool legion_rect_in_domain_iterator_step_##DIM##d( \
701 legion_rect_in_domain_iterator_##DIM##d_t handle);
702 LEGION_FOREACH_N(ITERATOR_STEP)
703#undef ITERATOR_STEP
704
708#define ITERATOR_OP(DIM) \
709 legion_rect_##DIM##d_t \
710 legion_rect_in_domain_iterator_get_rect_##DIM##d( \
711 legion_rect_in_domain_iterator_##DIM##d_t handle);
712 LEGION_FOREACH_N(ITERATOR_OP)
713#undef ITERATOR_OP
714
715 // -----------------------------------------------------------------------
716 // Coloring Operations
717 // -----------------------------------------------------------------------
718
724 legion_coloring_t
725 legion_coloring_create(void);
726
732 void
733 legion_coloring_destroy(legion_coloring_t handle);
734
738 void
739 legion_coloring_ensure_color(legion_coloring_t handle,
740 legion_color_t color);
741
745 void
746 legion_coloring_add_point(legion_coloring_t handle,
747 legion_color_t color,
748 legion_ptr_t point);
749
753 void
754 legion_coloring_delete_point(legion_coloring_t handle,
755 legion_color_t color,
756 legion_ptr_t point);
757
761 bool
762 legion_coloring_has_point(legion_coloring_t handle,
763 legion_color_t color,
764 legion_ptr_t point);
765
769 void
770 legion_coloring_add_range(legion_coloring_t handle,
771 legion_color_t color,
772 legion_ptr_t start,
773 legion_ptr_t end );
774
775 // -----------------------------------------------------------------------
776 // Domain Coloring Operations
777 // -----------------------------------------------------------------------
778
784 legion_domain_coloring_t
785 legion_domain_coloring_create(void);
786
792 void
793 legion_domain_coloring_destroy(legion_domain_coloring_t handle);
794
798 void
799 legion_domain_coloring_color_domain(legion_domain_coloring_t handle,
800 legion_color_t color,
801 legion_domain_t domain);
802
806 legion_domain_t
807 legion_domain_coloring_get_color_space(legion_domain_coloring_t handle);
808
809 // -----------------------------------------------------------------------
810 // Point Coloring Operations
811 // -----------------------------------------------------------------------
812
818 legion_point_coloring_t
819 legion_point_coloring_create(void);
820
826 void
827 legion_point_coloring_destroy(
828 legion_point_coloring_t handle);
829
833 void
834 legion_point_coloring_add_point(legion_point_coloring_t handle,
835 legion_domain_point_t color,
836 legion_ptr_t point);
837
841 void
842 legion_point_coloring_add_range(legion_point_coloring_t handle,
843 legion_domain_point_t color,
844 legion_ptr_t start,
845 legion_ptr_t end );
846
847 // -----------------------------------------------------------------------
848 // Domain Point Coloring Operations
849 // -----------------------------------------------------------------------
850
856 legion_domain_point_coloring_t
857 legion_domain_point_coloring_create(void);
858
864 void
865 legion_domain_point_coloring_destroy(
866 legion_domain_point_coloring_t handle);
867
871 void
872 legion_domain_point_coloring_color_domain(
873 legion_domain_point_coloring_t handle,
874 legion_domain_point_t color,
875 legion_domain_t domain);
876
877 // -----------------------------------------------------------------------
878 // Multi-Domain Point Coloring Operations
879 // -----------------------------------------------------------------------
880
886 legion_multi_domain_point_coloring_t
887 legion_multi_domain_point_coloring_create(void);
888
894 void
895 legion_multi_domain_point_coloring_destroy(
896 legion_multi_domain_point_coloring_t handle);
897
901 void
902 legion_multi_domain_point_coloring_color_domain(
903 legion_multi_domain_point_coloring_t handle,
904 legion_domain_point_t color,
905 legion_domain_t domain);
906
907 // -----------------------------------------------------------------------
908 // Index Space Operations
909 // ----------------------------------------------------------------------
910
916 legion_index_space_t
917 legion_index_space_create(legion_runtime_t runtime,
918 legion_context_t ctx,
919 size_t max_num_elmts);
920
926 legion_index_space_t
927 legion_index_space_create_domain(legion_runtime_t runtime,
928 legion_context_t ctx,
929 legion_domain_t domain);
930
936 legion_index_space_t
937 legion_index_space_create_future(legion_runtime_t runtime,
938 legion_context_t ctx,
939 size_t dimensions,
940 legion_future_t future,
941 legion_type_tag_t type_tag/*=0*/);
942
948 legion_index_space_t
949 legion_index_space_union(legion_runtime_t runtime,
950 legion_context_t ctx,
951 const legion_index_space_t *spaces,
952 size_t num_spaces);
953
959 legion_index_space_t
960 legion_index_space_intersection(legion_runtime_t runtime,
961 legion_context_t ctx,
962 const legion_index_space_t *spaces,
963 size_t num_spaces);
964
970 legion_index_space_t
971 legion_index_space_subtraction(legion_runtime_t runtime,
972 legion_context_t ctx,
973 legion_index_space_t left,
974 legion_index_space_t right);
975
979 bool
980 legion_index_space_has_multiple_domains(legion_runtime_t runtime,
981 legion_index_space_t handle);
982
988 legion_domain_t
989 legion_index_space_get_domain(legion_runtime_t runtime,
990 legion_index_space_t handle);
991
997 bool
998 legion_index_space_has_parent_index_partition(legion_runtime_t runtime,
999 legion_index_space_t handle);
1005 legion_index_partition_t
1006 legion_index_space_get_parent_index_partition(legion_runtime_t runtime,
1007 legion_index_space_t handle);
1008
1014 void
1015 legion_index_space_create_shared_ownership(legion_runtime_t runtime,
1016 legion_context_t ctx,
1017 legion_index_space_t handle);
1018
1024 void
1025 legion_index_space_destroy(legion_runtime_t runtime,
1026 legion_context_t ctx,
1027 legion_index_space_t handle);
1028
1034 void
1035 legion_index_space_destroy_unordered(legion_runtime_t runtime,
1036 legion_context_t ctx,
1037 legion_index_space_t handle,
1038 bool unordered);
1039
1043 void
1044 legion_index_space_attach_semantic_information(legion_runtime_t runtime,
1045 legion_index_space_t handle,
1046 legion_semantic_tag_t tag,
1047 const void *buffer,
1048 size_t size,
1049 bool is_mutable /* = false */);
1050
1054 bool
1055 legion_index_space_retrieve_semantic_information(
1056 legion_runtime_t runtime,
1057 legion_index_space_t handle,
1058 legion_semantic_tag_t tag,
1059 const void **result,
1060 size_t *size,
1061 bool can_fail /* = false */,
1062 bool wait_until_ready /* = false */);
1063
1067 void
1068 legion_index_space_attach_name(legion_runtime_t runtime,
1069 legion_index_space_t handle,
1070 const char *name,
1071 bool is_mutable /* = false */);
1072
1076 void
1077 legion_index_space_retrieve_name(legion_runtime_t runtime,
1078 legion_index_space_t handle,
1079 const char **result);
1080
1086 int
1087 legion_index_space_get_dim(legion_index_space_t handle);
1088
1089 // -----------------------------------------------------------------------
1090 // Index Partition Operations
1091 // -----------------------------------------------------------------------
1092
1099 legion_index_partition_t
1100 legion_index_partition_create_coloring(
1101 legion_runtime_t runtime,
1102 legion_context_t ctx,
1103 legion_index_space_t parent,
1104 legion_coloring_t coloring,
1105 bool disjoint,
1106 legion_color_t part_color /* = AUTO_GENERATE_ID */);
1107
1114 legion_index_partition_t
1115 legion_index_partition_create_domain_coloring(
1116 legion_runtime_t runtime,
1117 legion_context_t ctx,
1118 legion_index_space_t parent,
1119 legion_domain_t color_space,
1120 legion_domain_coloring_t coloring,
1121 bool disjoint,
1122 legion_color_t part_color /* = AUTO_GENERATE_ID */);
1123
1130 legion_index_partition_t
1131 legion_index_partition_create_point_coloring(
1132 legion_runtime_t runtime,
1133 legion_context_t ctx,
1134 legion_index_space_t parent,
1135 legion_domain_t color_space,
1136 legion_point_coloring_t coloring,
1137 legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1138 legion_color_t color /* = AUTO_GENERATE_ID */);
1139
1146 legion_index_partition_t
1147 legion_index_partition_create_domain_point_coloring(
1148 legion_runtime_t runtime,
1149 legion_context_t ctx,
1150 legion_index_space_t parent,
1151 legion_domain_t color_space,
1152 legion_domain_point_coloring_t coloring,
1153 legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1154 legion_color_t color /* = AUTO_GENERATE_ID */);
1155
1162 legion_index_partition_t
1163 legion_index_partition_create_multi_domain_point_coloring(
1164 legion_runtime_t runtime,
1165 legion_context_t ctx,
1166 legion_index_space_t parent,
1167 legion_domain_t color_space,
1168 legion_multi_domain_point_coloring_t coloring,
1169 legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1170 legion_color_t color /* = AUTO_GENERATE_ID */);
1171
1178#define CREATE_BLOCKIFY(DIM) \
1179 legion_index_partition_t \
1180 legion_index_partition_create_blockify_##DIM##d( \
1181 legion_runtime_t runtime, \
1182 legion_context_t ctx, \
1183 legion_index_space_t parent, \
1184 legion_blockify_##DIM##d_t blockify, \
1185 legion_color_t part_color /* = AUTO_GENERATE_ID */);
1186 LEGION_FOREACH_N(CREATE_BLOCKIFY)
1187#undef CREATE_BLOCKIFY
1188
1194 legion_index_partition_t
1195 legion_index_partition_create_equal(legion_runtime_t runtime,
1196 legion_context_t ctx,
1197 legion_index_space_t parent,
1198 legion_index_space_t color_space,
1199 size_t granularity,
1200 legion_color_t color /* = AUTO_GENERATE_ID */);
1201
1207 legion_index_partition_t
1208 legion_index_partition_create_by_weights(
1209 legion_runtime_t runtime,
1210 legion_context_t ctx,
1211 legion_index_space_t parent,
1212 legion_domain_point_t *colors,
1213 int *weights,
1214 size_t num_colors,
1215 legion_index_space_t color_space,
1216 size_t granularity /* = 1 */,
1217 legion_color_t color /* = AUTO_GENERATE_ID */);
1218
1224 legion_index_partition_t
1225 legion_index_partition_create_by_weights_future_map(
1226 legion_runtime_t runtime,
1227 legion_context_t ctx,
1228 legion_index_space_t parent,
1229 legion_future_map_t future_map,
1230 legion_index_space_t color_space,
1231 size_t granularity /* = 1 */,
1232 legion_color_t color /* = AUTO_GENERATE_ID */);
1233
1239 legion_index_partition_t
1240 legion_index_partition_create_by_union(
1241 legion_runtime_t runtime,
1242 legion_context_t ctx,
1243 legion_index_space_t parent,
1244 legion_index_partition_t handle1,
1245 legion_index_partition_t handle2,
1246 legion_index_space_t color_space,
1247 legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1248 legion_color_t color /* = AUTO_GENERATE_ID */);
1249
1255 legion_index_partition_t
1256 legion_index_partition_create_by_intersection(
1257 legion_runtime_t runtime,
1258 legion_context_t ctx,
1259 legion_index_space_t parent,
1260 legion_index_partition_t handle1,
1261 legion_index_partition_t handle2,
1262 legion_index_space_t color_space,
1263 legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1264 legion_color_t color /* = AUTO_GENERATE_ID */);
1265
1271 legion_index_partition_t
1272 legion_index_partition_create_by_intersection_mirror(
1273 legion_runtime_t runtime,
1274 legion_context_t ctx,
1275 legion_index_space_t parent,
1276 legion_index_partition_t handle,
1277 legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1278 legion_color_t color /* = AUTO_GENERATE_ID */,
1279 bool dominates /* = false */);
1280
1286 legion_index_partition_t
1287 legion_index_partition_create_by_difference(
1288 legion_runtime_t runtime,
1289 legion_context_t ctx,
1290 legion_index_space_t parent,
1291 legion_index_partition_t handle1,
1292 legion_index_partition_t handle2,
1293 legion_index_space_t color_space,
1294 legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1295 legion_color_t color /* = AUTO_GENERATE_ID */);
1296
1302 legion_index_partition_t
1303 legion_index_partition_create_by_domain(
1304 legion_runtime_t runtime,
1305 legion_context_t ctx,
1306 legion_index_space_t parent,
1307 legion_domain_point_t *colors,
1308 legion_domain_t *domains,
1309 size_t num_color_domains,
1310 legion_index_space_t color_space,
1311 bool perform_intersections /* = true */,
1312 legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1313 legion_color_t color /* = AUTO_GENERATE_ID */);
1314
1320 legion_index_partition_t
1321 legion_index_partition_create_by_domain_future_map(
1322 legion_runtime_t runtime,
1323 legion_context_t ctx,
1324 legion_index_space_t parent,
1325 legion_future_map_t future_map,
1326 legion_index_space_t color_space,
1327 bool perform_intersections /* = true */,
1328 legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1329 legion_color_t color /* = AUTO_GENERATE_ID */);
1330
1336 legion_index_partition_t
1337 legion_index_partition_create_by_field(legion_runtime_t runtime,
1338 legion_context_t ctx,
1339 legion_logical_region_t handle,
1340 legion_logical_region_t parent,
1341 legion_field_id_t fid,
1342 legion_index_space_t color_space,
1343 legion_color_t color /* = AUTO_GENERATE_ID */,
1344 legion_mapper_id_t id /* = 0 */,
1345 legion_mapping_tag_id_t tag /* = 0 */,
1346 legion_partition_kind_t part_kind /* = DISJOINT_KIND */,
1347 legion_untyped_buffer_t map_arg);
1348
1354 legion_index_partition_t
1355 legion_index_partition_create_by_image(
1356 legion_runtime_t runtime,
1357 legion_context_t ctx,
1358 legion_index_space_t handle,
1359 legion_logical_partition_t projection,
1360 legion_logical_region_t parent,
1361 legion_field_id_t fid,
1362 legion_index_space_t color_space,
1363 legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1364 legion_color_t color /* = AUTO_GENERATE_ID */,
1365 legion_mapper_id_t id /* = 0 */,
1366 legion_mapping_tag_id_t tag /* = 0 */,
1367 legion_untyped_buffer_t map_arg);
1368
1374 legion_index_partition_t
1375 legion_index_partition_create_by_preimage(
1376 legion_runtime_t runtime,
1377 legion_context_t ctx,
1378 legion_index_partition_t projection,
1379 legion_logical_region_t handle,
1380 legion_logical_region_t parent,
1381 legion_field_id_t fid,
1382 legion_index_space_t color_space,
1383 legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1384 legion_color_t color /* = AUTO_GENERATE_ID */,
1385 legion_mapper_id_t id /* = 0 */,
1386 legion_mapping_tag_id_t tag /* = 0 */,
1387 legion_untyped_buffer_t map_arg);
1388
1394 legion_index_partition_t
1395 legion_index_partition_create_by_image_range(
1396 legion_runtime_t runtime,
1397 legion_context_t ctx,
1398 legion_index_space_t handle,
1399 legion_logical_partition_t projection,
1400 legion_logical_region_t parent,
1401 legion_field_id_t fid,
1402 legion_index_space_t color_space,
1403 legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1404 legion_color_t color /* = AUTO_GENERATE_ID */,
1405 legion_mapper_id_t id /* = 0 */,
1406 legion_mapping_tag_id_t tag /* = 0 */,
1407 legion_untyped_buffer_t map_arg);
1408
1414 legion_index_partition_t
1415 legion_index_partition_create_by_preimage_range(
1416 legion_runtime_t runtime,
1417 legion_context_t ctx,
1418 legion_index_partition_t projection,
1419 legion_logical_region_t handle,
1420 legion_logical_region_t parent,
1421 legion_field_id_t fid,
1422 legion_index_space_t color_space,
1423 legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1424 legion_color_t color /* = AUTO_GENERATE_ID */,
1425 legion_mapper_id_t id /* = 0 */,
1426 legion_mapping_tag_id_t tag /* = 0 */,
1427 legion_untyped_buffer_t map_arg);
1428
1434 legion_index_partition_t
1435 legion_index_partition_create_by_restriction(
1436 legion_runtime_t runtime,
1437 legion_context_t ctx,
1438 legion_index_space_t parent,
1439 legion_index_space_t color_space,
1440 legion_domain_transform_t transform,
1441 legion_domain_t extent,
1442 legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1443 legion_color_t color /* = AUTO_GENERATE_ID */);
1444
1450 legion_index_partition_t
1451 legion_index_partition_create_pending_partition(
1452 legion_runtime_t runtime,
1453 legion_context_t ctx,
1454 legion_index_space_t parent,
1455 legion_index_space_t color_space,
1456 legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1457 legion_color_t color /* = AUTO_GENERATE_ID */);
1458
1462 legion_index_space_t
1463 legion_index_partition_create_index_space_union_spaces(
1464 legion_runtime_t runtime,
1465 legion_context_t ctx,
1466 legion_index_partition_t parent,
1467 legion_domain_point_t color,
1468 const legion_index_space_t *spaces,
1469 size_t num_spaces);
1470
1474 legion_index_space_t
1475 legion_index_partition_create_index_space_union_partition(
1476 legion_runtime_t runtime,
1477 legion_context_t ctx,
1478 legion_index_partition_t parent,
1479 legion_domain_point_t color,
1480 legion_index_partition_t handle);
1481
1485 legion_index_space_t
1486 legion_index_partition_create_index_space_intersection_spaces(
1487 legion_runtime_t runtime,
1488 legion_context_t ctx,
1489 legion_index_partition_t parent,
1490 legion_domain_point_t color,
1491 const legion_index_space_t *spaces,
1492 size_t num_spaces);
1493
1497 legion_index_space_t
1498 legion_index_partition_create_index_space_intersection_partition(
1499 legion_runtime_t runtime,
1500 legion_context_t ctx,
1501 legion_index_partition_t parent,
1502 legion_domain_point_t color,
1503 legion_index_partition_t handle);
1504
1508 legion_index_space_t
1509 legion_index_partition_create_index_space_difference(
1510 legion_runtime_t runtime,
1511 legion_context_t ctx,
1512 legion_index_partition_t parent,
1513 legion_domain_point_t color,
1514 legion_index_space_t initial,
1515 const legion_index_space_t *spaces,
1516 size_t num_spaces);
1517
1521 bool
1522 legion_index_partition_is_disjoint(legion_runtime_t runtime,
1523 legion_index_partition_t handle);
1524
1528 bool
1529 legion_index_partition_is_complete(legion_runtime_t runtime,
1530 legion_index_partition_t handle);
1531
1537 legion_index_space_t
1538 legion_index_partition_get_index_subspace(legion_runtime_t runtime,
1539 legion_index_partition_t handle,
1540 legion_color_t color);
1541
1547 legion_index_space_t
1548 legion_index_partition_get_index_subspace_domain_point(
1549 legion_runtime_t runtime,
1550 legion_index_partition_t handle,
1551 legion_domain_point_t color);
1552
1556 bool
1557 legion_index_partition_has_index_subspace_domain_point(
1558 legion_runtime_t runtime,
1559 legion_index_partition_t handle,
1560 legion_domain_point_t color);
1561
1565 legion_index_space_t
1566 legion_index_partition_get_color_space(legion_runtime_t runtime,
1567 legion_index_partition_t handle);
1568
1572 legion_color_t
1573 legion_index_partition_get_color(legion_runtime_t runtime,
1574 legion_index_partition_t handle);
1575
1581 legion_index_space_t
1582 legion_index_partition_get_parent_index_space(legion_runtime_t runtime,
1583 legion_index_partition_t handle);
1584
1590 void
1591 legion_index_partition_create_shared_ownership(legion_runtime_t runtime,
1592 legion_context_t ctx,
1593 legion_index_partition_t handle);
1594
1600 void
1601 legion_index_partition_destroy(legion_runtime_t runtime,
1602 legion_context_t ctx,
1603 legion_index_partition_t handle);
1604
1610 void
1611 legion_index_partition_destroy_unordered(legion_runtime_t runtime,
1612 legion_context_t ctx,
1613 legion_index_partition_t handle,
1614 bool unordered /* = false */,
1615 bool recurse /* = true */);
1616
1620 void
1621 legion_index_partition_attach_semantic_information(
1622 legion_runtime_t runtime,
1623 legion_index_partition_t handle,
1624 legion_semantic_tag_t tag,
1625 const void *buffer,
1626 size_t size,
1627 bool is_mutable /* = false */);
1628
1632 bool
1633 legion_index_partition_retrieve_semantic_information(
1634 legion_runtime_t runtime,
1635 legion_index_partition_t handle,
1636 legion_semantic_tag_t tag,
1637 const void **result,
1638 size_t *size,
1639 bool can_fail /* = false */,
1640 bool wait_until_ready /* = false */);
1641
1645 void
1646 legion_index_partition_attach_name(legion_runtime_t runtime,
1647 legion_index_partition_t handle,
1648 const char *name,
1649 bool is_mutable /* = false */);
1650
1654 void
1655 legion_index_partition_retrieve_name(legion_runtime_t runtime,
1656 legion_index_partition_t handle,
1657 const char **result);
1658
1659 // -----------------------------------------------------------------------
1660 // Field Space Operations
1661 // -----------------------------------------------------------------------
1662
1668 legion_field_space_t
1669 legion_field_space_create(legion_runtime_t runtime,
1670 legion_context_t ctx);
1671
1677 legion_field_space_t
1678 legion_field_space_create_with_fields(legion_runtime_t runtime,
1679 legion_context_t ctx,
1680 size_t *field_sizes,
1681 legion_field_id_t *field_ids,
1682 size_t num_fields,
1683 legion_custom_serdez_id_t serdez);
1684
1690 legion_field_space_t
1691 legion_field_space_create_with_futures(legion_runtime_t runtime,
1692 legion_context_t ctx,
1693 legion_future_t *field_sizes,
1694 legion_field_id_t *field_ids,
1695 size_t num_fields,
1696 legion_custom_serdez_id_t serdez);
1697
1701 legion_field_space_t
1702 legion_field_space_no_space();
1703
1709 void
1710 legion_field_space_create_shared_ownership(legion_runtime_t runtime,
1711 legion_context_t ctx,
1712 legion_field_space_t handle);
1713
1719 void
1720 legion_field_space_destroy(legion_runtime_t runtime,
1721 legion_context_t ctx,
1722 legion_field_space_t handle);
1723
1729 void
1730 legion_field_space_destroy_unordered(legion_runtime_t runtime,
1731 legion_context_t ctx,
1732 legion_field_space_t handle,
1733 bool unordered);
1734
1738 void
1739 legion_field_space_attach_semantic_information(
1740 legion_runtime_t runtime,
1741 legion_field_space_t handle,
1742 legion_semantic_tag_t tag,
1743 const void *buffer,
1744 size_t size,
1745 bool is_mutable /* = false */);
1746
1750 bool
1751 legion_field_space_retrieve_semantic_information(
1752 legion_runtime_t runtime,
1753 legion_field_space_t handle,
1754 legion_semantic_tag_t tag,
1755 const void **result,
1756 size_t *size,
1757 bool can_fail /* = false */,
1758 bool wait_until_ready /* = false */);
1759
1765 legion_field_id_t *
1766 legion_field_space_get_fields(legion_runtime_t runtime,
1767 legion_context_t ctx,
1768 legion_field_space_t handle,
1769 size_t *size);
1770
1776 bool
1777 legion_field_space_has_fields(legion_runtime_t runtime,
1778 legion_context_t ctx,
1779 legion_field_space_t handle,
1780 const legion_field_id_t *fields,
1781 size_t fields_size);
1782
1786 void
1787 legion_field_id_attach_semantic_information(legion_runtime_t runtime,
1788 legion_field_space_t handle,
1789 legion_field_id_t id,
1790 legion_semantic_tag_t tag,
1791 const void *buffer,
1792 size_t size,
1793 bool is_mutable /* = false */);
1794
1798 bool
1799 legion_field_id_retrieve_semantic_information(
1800 legion_runtime_t runtime,
1801 legion_field_space_t handle,
1802 legion_field_id_t id,
1803 legion_semantic_tag_t tag,
1804 const void **result,
1805 size_t *size,
1806 bool can_fail /* = false */,
1807 bool wait_until_ready /* = false */);
1808
1812 void
1813 legion_field_space_attach_name(legion_runtime_t runtime,
1814 legion_field_space_t handle,
1815 const char *name,
1816 bool is_mutable /* = false */);
1817
1821 void
1822 legion_field_space_retrieve_name(legion_runtime_t runtime,
1823 legion_field_space_t handle,
1824 const char **result);
1825
1829 void
1830 legion_field_id_attach_name(legion_runtime_t runtime,
1831 legion_field_space_t handle,
1832 legion_field_id_t id,
1833 const char *name,
1834 bool is_mutable /* = false */);
1835
1839 void
1840 legion_field_id_retrieve_name(legion_runtime_t runtime,
1841 legion_field_space_t handle,
1842 legion_field_id_t id,
1843 const char **result);
1844
1848 size_t
1849 legion_field_id_get_size(legion_runtime_t runtime,
1850 legion_context_t ctx,
1851 legion_field_space_t handle,
1852 legion_field_id_t id);
1853
1854 // -----------------------------------------------------------------------
1855 // Logical Region Operations
1856 // -----------------------------------------------------------------------
1857
1863 legion_logical_region_t
1864 legion_logical_region_create(legion_runtime_t runtime,
1865 legion_context_t ctx,
1866 legion_index_space_t index,
1867 legion_field_space_t fields,
1868 bool task_local);
1869
1875 void
1876 legion_logical_region_create_shared_ownership(legion_runtime_t runtime,
1877 legion_context_t ctx,
1878 legion_logical_region_t handle);
1879
1885 void
1886 legion_logical_region_destroy(legion_runtime_t runtime,
1887 legion_context_t ctx,
1888 legion_logical_region_t handle);
1889
1895 void
1896 legion_logical_region_destroy_unordered(legion_runtime_t runtime,
1897 legion_context_t ctx,
1898 legion_logical_region_t handle,
1899 bool unordered);
1900
1904 legion_color_t
1905 legion_logical_region_get_color(legion_runtime_t runtime,
1906 legion_logical_region_t handle);
1907
1911 legion_domain_point_t
1912 legion_logical_region_get_color_domain_point(legion_runtime_t runtime_,
1913 legion_logical_region_t handle_);
1914
1918 bool
1919 legion_logical_region_has_parent_logical_partition(
1920 legion_runtime_t runtime,
1921 legion_logical_region_t handle);
1922
1926 legion_logical_partition_t
1927 legion_logical_region_get_parent_logical_partition(
1928 legion_runtime_t runtime,
1929 legion_logical_region_t handle);
1930
1934 void
1935 legion_logical_region_attach_semantic_information(
1936 legion_runtime_t runtime,
1937 legion_logical_region_t handle,
1938 legion_semantic_tag_t tag,
1939 const void *buffer,
1940 size_t size,
1941 bool is_mutable /* = false */);
1942
1946 bool
1947 legion_logical_region_retrieve_semantic_information(
1948 legion_runtime_t runtime,
1949 legion_logical_region_t handle,
1950 legion_semantic_tag_t tag,
1951 const void **result,
1952 size_t *size,
1953 bool can_fail /* = false */,
1954 bool wait_until_ready /* = false */);
1955
1959 void
1960 legion_logical_region_attach_name(legion_runtime_t runtime,
1961 legion_logical_region_t handle,
1962 const char *name,
1963 bool is_mutable /* = false */);
1964
1968 void
1969 legion_logical_region_retrieve_name(legion_runtime_t runtime,
1970 legion_logical_region_t handle,
1971 const char **result);
1972
1976 legion_index_space_t
1977 legion_logical_region_get_index_space(legion_logical_region_t handle);
1978
1979 // -----------------------------------------------------------------------
1980 // Logical Region Tree Traversal Operations
1981 // -----------------------------------------------------------------------
1982
1988 legion_logical_partition_t
1989 legion_logical_partition_create(legion_runtime_t runtime,
1990 legion_logical_region_t parent,
1991 legion_index_partition_t handle);
1992
1998 legion_logical_partition_t
1999 legion_logical_partition_create_by_tree(legion_runtime_t runtime,
2000 legion_context_t ctx,
2001 legion_index_partition_t handle,
2002 legion_field_space_t fspace,
2003 legion_region_tree_id_t tid);
2004
2010 void
2011 legion_logical_partition_destroy(legion_runtime_t runtime,
2012 legion_context_t ctx,
2013 legion_logical_partition_t handle);
2014
2020 void
2021 legion_logical_partition_destroy_unordered(legion_runtime_t runtime,
2022 legion_context_t ctx,
2023 legion_logical_partition_t handle,
2024 bool unordered);
2025
2031 legion_logical_region_t
2032 legion_logical_partition_get_logical_subregion(
2033 legion_runtime_t runtime,
2034 legion_logical_partition_t parent,
2035 legion_index_space_t handle);
2036
2042 legion_logical_region_t
2043 legion_logical_partition_get_logical_subregion_by_color(
2044 legion_runtime_t runtime,
2045 legion_logical_partition_t parent,
2046 legion_color_t c);
2047
2053 legion_logical_region_t
2054 legion_logical_partition_get_logical_subregion_by_color_domain_point(
2055 legion_runtime_t runtime,
2056 legion_logical_partition_t parent,
2057 legion_domain_point_t c);
2058
2062 bool
2063 legion_logical_partition_has_logical_subregion_by_color_domain_point(
2064 legion_runtime_t runtime,
2065 legion_logical_partition_t parent,
2066 legion_domain_point_t c);
2067
2073 legion_logical_region_t
2074 legion_logical_partition_get_logical_subregion_by_tree(
2075 legion_runtime_t runtime,
2076 legion_index_space_t handle,
2077 legion_field_space_t fspace,
2078 legion_region_tree_id_t tid);
2079
2083 legion_logical_region_t
2084 legion_logical_partition_get_parent_logical_region(
2085 legion_runtime_t runtime,
2086 legion_logical_partition_t handle);
2087
2091 void
2092 legion_logical_partition_attach_semantic_information(
2093 legion_runtime_t runtime,
2094 legion_logical_partition_t handle,
2095 legion_semantic_tag_t tag,
2096 const void *buffer,
2097 size_t size,
2098 bool is_mutable /* = false */);
2099
2103 bool
2104 legion_logical_partition_retrieve_semantic_information(
2105 legion_runtime_t runtime,
2106 legion_logical_partition_t handle,
2107 legion_semantic_tag_t tag,
2108 const void **result,
2109 size_t *size,
2110 bool can_fail /* = false */,
2111 bool wait_until_ready /* = false */);
2112
2116 void
2117 legion_logical_partition_attach_name(legion_runtime_t runtime,
2118 legion_logical_partition_t handle,
2119 const char *name,
2120 bool is_mutable /* = false */);
2121
2125 void
2126 legion_logical_partition_retrieve_name(legion_runtime_t runtime,
2127 legion_logical_partition_t handle,
2128 const char **result);
2129
2136 void legion_reset_equivalence_sets(legion_runtime_t runtime,
2137 legion_context_t ctx,
2138 legion_logical_region_t parent,
2139 legion_logical_region_t region,
2140 int num_fields,
2141 legion_field_id_t* fields);
2142
2143 // -----------------------------------------------------------------------
2144 // Region Requirement Operations
2145 // -----------------------------------------------------------------------
2146
2150 legion_region_requirement_t
2151 legion_region_requirement_create_logical_region(
2152 legion_logical_region_t handle,
2153 legion_privilege_mode_t priv,
2154 legion_coherence_property_t prop,
2155 legion_logical_region_t parent,
2156 legion_mapping_tag_id_t tag /* = 0 */,
2157 bool verified /* = false*/);
2158
2162 legion_region_requirement_t
2163 legion_region_requirement_create_logical_region_projection(
2164 legion_logical_region_t handle,
2165 legion_projection_id_t proj /* = 0 */,
2166 legion_privilege_mode_t priv,
2167 legion_coherence_property_t prop,
2168 legion_logical_region_t parent,
2169 legion_mapping_tag_id_t tag /* = 0 */,
2170 bool verified /* = false*/);
2171
2175 legion_region_requirement_t
2176 legion_region_requirement_create_logical_partition(
2177 legion_logical_partition_t handle,
2178 legion_projection_id_t proj /* = 0 */,
2179 legion_privilege_mode_t priv,
2180 legion_coherence_property_t prop,
2181 legion_logical_region_t parent,
2182 legion_mapping_tag_id_t tag /* = 0 */,
2183 bool verified /* = false*/);
2184
2188 void
2189 legion_region_requirement_destroy(legion_region_requirement_t handle);
2190
2194 void
2195 legion_region_requirement_add_field(legion_region_requirement_t handle,
2196 legion_field_id_t field,
2197 bool instance_field);
2198
2202 void
2203 legion_region_requirement_add_flags(legion_region_requirement_t handle,
2204 legion_region_flags_t flags);
2205
2209 legion_logical_region_t
2210 legion_region_requirement_get_region(legion_region_requirement_t handle);
2211
2215 legion_logical_region_t
2216 legion_region_requirement_get_parent(legion_region_requirement_t handle);
2217
2221 legion_logical_partition_t
2222 legion_region_requirement_get_partition(legion_region_requirement_t handle);
2223
2227 unsigned
2228 legion_region_requirement_get_privilege_fields_size(
2229 legion_region_requirement_t handle);
2230
2242 void
2243 legion_region_requirement_get_privilege_fields(
2244 legion_region_requirement_t handle,
2245 legion_field_id_t* fields,
2246 unsigned fields_size);
2247
2255 legion_field_id_t
2256 legion_region_requirement_get_privilege_field(
2257 legion_region_requirement_t handle,
2258 unsigned idx);
2259
2263 unsigned
2264 legion_region_requirement_get_instance_fields_size(
2265 legion_region_requirement_t handle);
2266
2278 void
2279 legion_region_requirement_get_instance_fields(
2280 legion_region_requirement_t handle,
2281 legion_field_id_t* fields,
2282 unsigned fields_size);
2283
2289 legion_field_id_t
2290 legion_region_requirement_get_instance_field(
2291 legion_region_requirement_t handle,
2292 unsigned idx);
2293
2297 legion_privilege_mode_t
2298 legion_region_requirement_get_privilege(legion_region_requirement_t handle);
2299
2303 legion_coherence_property_t
2304 legion_region_requirement_get_prop(legion_region_requirement_t handle);
2305
2309 legion_reduction_op_id_t
2310 legion_region_requirement_get_redop(legion_region_requirement_t handle);
2311
2315 legion_mapping_tag_id_t
2316 legion_region_requirement_get_tag(legion_region_requirement_t handle);
2317
2321 legion_handle_type_t
2322 legion_region_requirement_get_handle_type(legion_region_requirement_t handle);
2323
2327 legion_projection_id_t
2328 legion_region_requirement_get_projection(legion_region_requirement_t handle);
2329
2330 // -----------------------------------------------------------------------
2331 // Output Requirement Operations
2332 // -----------------------------------------------------------------------
2333
2337 legion_output_requirement_t
2338 legion_output_requirement_create(legion_field_space_t field_space,
2339 legion_field_id_t *fields,
2340 size_t fields_size,
2341 int dim,
2342 bool global_indexing);
2343
2347 legion_output_requirement_t
2348 legion_output_requirement_create_region_requirement(
2349 legion_region_requirement_t handle);
2350
2354 void
2355 legion_output_requirement_destroy(legion_output_requirement_t handle);
2356
2360 void
2361 legion_output_requirement_add_field(legion_output_requirement_t handle,
2362 legion_field_id_t field,
2363 bool instance);
2364
2368 legion_logical_region_t
2369 legion_output_requirement_get_region(legion_output_requirement_t handle);
2370
2374 legion_logical_region_t
2375 legion_output_requirement_get_parent(legion_output_requirement_t handle);
2376
2380 legion_logical_partition_t
2381 legion_output_requirement_get_partition(legion_output_requirement_t handle);
2382
2383 // -----------------------------------------------------------------------
2384 // Allocator and Argument Map Operations
2385 // -----------------------------------------------------------------------
2386
2392 legion_field_allocator_t
2393 legion_field_allocator_create(legion_runtime_t runtime,
2394 legion_context_t ctx,
2395 legion_field_space_t handle);
2396
2402 void
2403 legion_field_allocator_destroy(legion_field_allocator_t handle);
2404
2408 legion_field_id_t
2409 legion_auto_generate_id(void);
2410
2414 legion_field_id_t
2415 legion_field_allocator_allocate_field(
2416 legion_field_allocator_t allocator,
2417 size_t field_size,
2418 legion_field_id_t desired_fieldid /* = AUTO_GENERATE_ID */);
2419
2423 legion_field_id_t
2424 legion_field_allocator_allocate_field_future(
2425 legion_field_allocator_t allocator,
2426 legion_future_t field_size,
2427 legion_field_id_t desired_fieldid /* = AUTO_GENERATE_ID */);
2428
2432 void
2433 legion_field_allocator_free_field(legion_field_allocator_t allocator,
2434 legion_field_id_t fid);
2435
2439 void
2440 legion_field_allocator_free_field_unordered(legion_field_allocator_t allocator,
2441 legion_field_id_t fid,
2442 bool unordered);
2443
2447 legion_field_id_t
2448 legion_field_allocator_allocate_local_field(
2449 legion_field_allocator_t allocator,
2450 size_t field_size,
2451 legion_field_id_t desired_fieldid /* = AUTO_GENERATE_ID */);
2452
2458 legion_argument_map_t
2459 legion_argument_map_create(void);
2460
2466 legion_argument_map_t
2467 legion_argument_map_from_future_map(legion_future_map_t map);
2468
2472 void
2473 legion_argument_map_set_point(legion_argument_map_t map,
2474 legion_domain_point_t dp,
2475 legion_untyped_buffer_t arg,
2476 bool replace /* = true */);
2477
2481 void
2482 legion_argument_map_set_future(legion_argument_map_t map,
2483 legion_domain_point_t dp,
2484 legion_future_t future,
2485 bool replace /* = true */);
2486
2492 void
2493 legion_argument_map_destroy(legion_argument_map_t handle);
2494
2495 // -----------------------------------------------------------------------
2496 // Predicate Operations
2497 // -----------------------------------------------------------------------
2498
2504 legion_predicate_t
2505 legion_predicate_create(legion_runtime_t runtime,
2506 legion_context_t ctx,
2507 legion_future_t f);
2508
2514 void
2515 legion_predicate_destroy(legion_predicate_t handle);
2516
2522 const legion_predicate_t
2523 legion_predicate_true(void);
2524
2530 const legion_predicate_t
2531 legion_predicate_false(void);
2532
2533 // -----------------------------------------------------------------------
2534 // Phase Barrier Operations
2535 // -----------------------------------------------------------------------
2536
2542 legion_phase_barrier_t
2543 legion_phase_barrier_create(legion_runtime_t runtime,
2544 legion_context_t ctx,
2545 unsigned arrivals);
2546
2552 void
2553 legion_phase_barrier_destroy(legion_runtime_t runtime,
2554 legion_context_t ctx,
2555 legion_phase_barrier_t handle);
2556
2560 legion_phase_barrier_t
2561 legion_phase_barrier_alter_arrival_count(legion_runtime_t runtime,
2562 legion_context_t ctx,
2563 legion_phase_barrier_t handle,
2564 int delta);
2565
2569 void
2570 legion_phase_barrier_arrive(legion_runtime_t runtime,
2571 legion_context_t ctx,
2572 legion_phase_barrier_t handle,
2573 unsigned count /* = 1 */);
2574
2578 void
2579 legion_phase_barrier_wait(legion_runtime_t runtime,
2580 legion_context_t ctx,
2581 legion_phase_barrier_t handle);
2582
2588 legion_phase_barrier_t
2589 legion_phase_barrier_advance(legion_runtime_t runtime,
2590 legion_context_t ctx,
2591 legion_phase_barrier_t handle);
2592
2593 // -----------------------------------------------------------------------
2594 // Dynamic Collective Operations
2595 // -----------------------------------------------------------------------
2596
2602 legion_dynamic_collective_t
2603 legion_dynamic_collective_create(legion_runtime_t runtime,
2604 legion_context_t ctx,
2605 unsigned arrivals,
2606 legion_reduction_op_id_t redop,
2607 const void *init_value,
2608 size_t init_size);
2609
2615 void
2616 legion_dynamic_collective_destroy(legion_runtime_t runtime,
2617 legion_context_t ctx,
2618 legion_dynamic_collective_t handle);
2619
2623 legion_dynamic_collective_t
2624 legion_dynamic_collective_alter_arrival_count(
2625 legion_runtime_t runtime,
2626 legion_context_t ctx,
2627 legion_dynamic_collective_t handle,
2628 int delta);
2629
2633 void
2634 legion_dynamic_collective_arrive(legion_runtime_t runtime,
2635 legion_context_t ctx,
2636 legion_dynamic_collective_t handle,
2637 const void *buffer,
2638 size_t size,
2639 unsigned count /* = 1 */);
2640
2644 void
2645 legion_dynamic_collective_defer_arrival(legion_runtime_t runtime,
2646 legion_context_t ctx,
2647 legion_dynamic_collective_t handle,
2648 legion_future_t f,
2649 unsigned count /* = 1 */);
2650
2656 legion_future_t
2657 legion_dynamic_collective_get_result(legion_runtime_t runtime,
2658 legion_context_t ctx,
2659 legion_dynamic_collective_t handle);
2660
2666 legion_dynamic_collective_t
2667 legion_dynamic_collective_advance(legion_runtime_t runtime,
2668 legion_context_t ctx,
2669 legion_dynamic_collective_t handle);
2670
2671 // -----------------------------------------------------------------------
2672 // Future Operations
2673 // -----------------------------------------------------------------------
2674
2680 legion_future_t
2681 legion_future_from_untyped_pointer(legion_runtime_t runtime,
2682 const void *buffer,
2683 size_t size);
2684
2690 legion_future_t
2691 legion_future_from_untyped_pointer_detailed(legion_runtime_t runtime,
2692 const void *buffer,
2693 size_t size,
2694 bool take_ownership,
2695 const char *provenance,
2696 bool shard_local);
2697
2703 legion_future_t
2704 legion_future_copy(legion_future_t handle);
2705
2711 void
2712 legion_future_destroy(legion_future_t handle);
2713
2717 void
2718 legion_future_get_void_result(legion_future_t handle);
2719
2723 void
2724 legion_future_wait(legion_future_t handle,
2725 bool silence_warnings /* = false */,
2726 const char *warning_string /* = NULL */);
2727
2731 bool
2732 legion_future_is_empty(legion_future_t handle,
2733 bool block /* = false */);
2734
2738 bool
2739 legion_future_is_ready(legion_future_t handle);
2740
2744 bool
2745 legion_future_is_ready_subscribe(legion_future_t handle, bool subscribe);
2746
2750 const void *
2751 legion_future_get_untyped_pointer(legion_future_t handle);
2752
2756 size_t
2757 legion_future_get_untyped_size(legion_future_t handle);
2758
2762 const void *
2763 legion_future_get_metadata(legion_future_t handle, size_t *size/*=NULL*/);
2764
2765 // -----------------------------------------------------------------------
2766 // Future Map Operations
2767 // -----------------------------------------------------------------------
2768
2774 legion_future_map_t
2775 legion_future_map_copy(legion_future_map_t handle);
2776
2782 void
2783 legion_future_map_destroy(legion_future_map_t handle);
2784
2788 void
2789 legion_future_map_wait_all_results(legion_future_map_t handle);
2790
2796 legion_future_t
2797 legion_future_map_get_future(legion_future_map_t handle,
2798 legion_domain_point_t point);
2799
2803 legion_domain_t
2804 legion_future_map_get_domain(legion_future_map_t handle);
2805
2811 legion_future_t
2812 legion_future_map_reduce(legion_runtime_t runtime,
2813 legion_context_t ctx,
2814 legion_future_map_t handle,
2815 legion_reduction_op_id_t redop,
2816 bool deterministic,
2817 legion_mapper_id_t map_id,
2818 legion_mapping_tag_id_t tag);
2819
2825 legion_future_t
2826 legion_future_map_reduce_with_initial_value(legion_runtime_t runtime,
2827 legion_context_t ctx,
2828 legion_future_map_t handle,
2829 legion_reduction_op_id_t redop,
2830 bool deterministic,
2831 legion_mapper_id_t map_id,
2832 legion_mapping_tag_id_t tag,
2833 const char *provenance,
2834 legion_future_t initial_value);
2835
2841 legion_future_map_t
2842 legion_future_map_construct_from_buffers(legion_runtime_t runtime,
2843 legion_context_t ctx,
2844 legion_domain_t domain,
2845 legion_domain_point_t *points,
2846 legion_untyped_buffer_t *buffers,
2847 size_t num_points,
2848 bool collective,
2849 legion_sharding_id_t sid,
2850 bool implicit_sharding);
2851
2857 legion_future_map_t
2858 legion_future_map_construct_from_futures(legion_runtime_t runtime,
2859 legion_context_t ctx,
2860 legion_domain_t domain,
2861 legion_domain_point_t *points,
2862 legion_future_t *futures,
2863 size_t num_futures,
2864 bool collective,
2865 legion_sharding_id_t sid,
2866 bool implicit_sharding);
2867
2873 legion_future_map_t
2874 legion_future_map_transform(legion_runtime_t runtime,
2875 legion_context_t ctx,
2876 legion_future_map_t fm,
2877 legion_index_space_t new_domain,
2878 legion_point_transform_functor_t functor,
2879 bool take_ownership);
2880
2881 // -----------------------------------------------------------------------
2882 // Deferred Buffer Operations
2883 // -----------------------------------------------------------------------
2884
2890#define BUFFER_CREATE(DIM) \
2891 legion_deferred_buffer_char_##DIM##d_t \
2892 legion_deferred_buffer_char_##DIM##d_create( \
2893 legion_rect_##DIM##d_t bounds, \
2894 legion_memory_kind_t kind, \
2895 char *initial_value);
2896 LEGION_FOREACH_N(BUFFER_CREATE)
2897#undef BUFFER_CREATE
2898
2899 /*
2900 * @see Legion::DeferredBuffer::ptr()
2901 */
2902#define BUFFER_PTR(DIM) \
2903 char* \
2904 legion_deferred_buffer_char_##DIM##d_ptr( \
2905 legion_deferred_buffer_char_##DIM##d_t buffer, \
2906 legion_point_##DIM##d_t p);
2907 LEGION_FOREACH_N(BUFFER_PTR)
2908#undef BUFFER_PTR
2909
2910 /*
2911 * @see Legion::DeferredBuffer::~DeferredBuffer()
2912 */
2913#define BUFFER_DESTROY(DIM) \
2914 void \
2915 legion_deferred_buffer_char_##DIM##d_destroy( \
2916 legion_deferred_buffer_char_##DIM##d_t buffer);
2917 LEGION_FOREACH_N(BUFFER_DESTROY)
2918#undef BUFFER_DESTROY
2919
2920 // -----------------------------------------------------------------------
2921 // Task Launch Operations
2922 // -----------------------------------------------------------------------
2923
2929 legion_task_launcher_t
2930 legion_task_launcher_create(
2931 legion_task_id_t tid,
2932 legion_untyped_buffer_t arg,
2933 legion_predicate_t pred /* = legion_predicate_true() */,
2934 legion_mapper_id_t id /* = 0 */,
2935 legion_mapping_tag_id_t tag /* = 0 */);
2936
2942 legion_task_launcher_t
2943 legion_task_launcher_create_from_buffer(
2944 legion_task_id_t tid,
2945 const void *buffer,
2946 size_t buffer_size,
2947 legion_predicate_t pred /* = legion_predicate_true() */,
2948 legion_mapper_id_t id /* = 0 */,
2949 legion_mapping_tag_id_t tag /* = 0 */);
2950
2956 void
2957 legion_task_launcher_destroy(legion_task_launcher_t handle);
2958
2964 legion_future_t
2965 legion_task_launcher_execute(legion_runtime_t runtime,
2966 legion_context_t ctx,
2967 legion_task_launcher_t launcher);
2968
2974 legion_future_t
2975 legion_task_launcher_execute_outputs(legion_runtime_t runtime,
2976 legion_context_t ctx,
2977 legion_task_launcher_t launcher,
2978 legion_output_requirement_t *reqs,
2979 size_t reqs_size);
2980
2984 unsigned
2985 legion_task_launcher_add_region_requirement_logical_region(
2986 legion_task_launcher_t launcher,
2987 legion_logical_region_t handle,
2988 legion_privilege_mode_t priv,
2989 legion_coherence_property_t prop,
2990 legion_logical_region_t parent,
2991 legion_mapping_tag_id_t tag /* = 0 */,
2992 bool verified /* = false*/);
2993
2997 unsigned
2998 legion_task_launcher_add_region_requirement_logical_region_reduction(
2999 legion_task_launcher_t launcher,
3000 legion_logical_region_t handle,
3001 legion_reduction_op_id_t redop,
3002 legion_coherence_property_t prop,
3003 legion_logical_region_t parent,
3004 legion_mapping_tag_id_t tag /* = 0 */,
3005 bool verified /* = false*/);
3006
3010 void
3011 legion_task_launcher_set_region_requirement_logical_region(
3012 legion_task_launcher_t launcher,
3013 unsigned idx,
3014 legion_logical_region_t handle,
3015 legion_privilege_mode_t priv,
3016 legion_coherence_property_t prop,
3017 legion_logical_region_t parent,
3018 legion_mapping_tag_id_t tag /* = 0 */,
3019 bool verified /* = false*/);
3020
3024 void
3025 legion_task_launcher_set_region_requirement_logical_region_reduction(
3026 legion_task_launcher_t launcher,
3027 unsigned idx,
3028 legion_logical_region_t handle,
3029 legion_reduction_op_id_t redop,
3030 legion_coherence_property_t prop,
3031 legion_logical_region_t parent,
3032 legion_mapping_tag_id_t tag /* = 0 */,
3033 bool verified /* = false*/);
3034
3038 void
3039 legion_task_launcher_add_field(legion_task_launcher_t launcher,
3040 unsigned idx,
3041 legion_field_id_t fid,
3042 bool inst /* = true */);
3043
3047 const void*
3048 legion_index_launcher_get_projection_args(legion_region_requirement_t requirement,
3049 size_t *size);
3050
3054 void
3055 legion_index_launcher_set_projection_args(legion_index_launcher_t launcher_,
3056 unsigned idx,
3057 const void *args,
3058 size_t size,
3059 bool own);
3060
3064 void
3065 legion_task_launcher_add_flags(legion_task_launcher_t launcher,
3066 unsigned idx,
3067 enum legion_region_flags_t flags);
3068
3072 void
3073 legion_task_launcher_intersect_flags(legion_task_launcher_t launcher,
3074 unsigned idx,
3075 enum legion_region_flags_t flags);
3076
3080 unsigned
3081 legion_task_launcher_add_index_requirement(
3082 legion_task_launcher_t launcher,
3083 legion_index_space_t handle,
3084 legion_allocate_mode_t priv,
3085 legion_index_space_t parent,
3086 bool verified /* = false*/);
3087
3091 void
3092 legion_task_launcher_add_future(legion_task_launcher_t launcher,
3093 legion_future_t future);
3094
3098 void
3099 legion_task_launcher_add_wait_barrier(legion_task_launcher_t launcher,
3100 legion_phase_barrier_t bar);
3101
3105 void
3106 legion_task_launcher_add_arrival_barrier(legion_task_launcher_t launcher,
3107 legion_phase_barrier_t bar);
3108
3112 void
3113 legion_task_launcher_set_argument(legion_task_launcher_t launcher,
3114 legion_untyped_buffer_t arg);
3115
3119 void
3120 legion_task_launcher_set_point(legion_task_launcher_t launcher,
3121 legion_domain_point_t point);
3122
3126 void
3127 legion_task_launcher_set_sharding_space(legion_task_launcher_t launcher,
3128 legion_index_space_t is);
3129
3133 void
3134 legion_task_launcher_set_predicate_false_future(legion_task_launcher_t launcher,
3135 legion_future_t f);
3136
3140 void
3141 legion_task_launcher_set_predicate_false_result(legion_task_launcher_t launcher,
3142 legion_untyped_buffer_t arg);
3143
3147 void
3148 legion_task_launcher_set_mapper(legion_task_launcher_t launcher,
3149 legion_mapper_id_t mapper_id);
3150
3154 void
3155 legion_task_launcher_set_mapping_tag(legion_task_launcher_t launcher,
3156 legion_mapping_tag_id_t tag);
3157
3161 void
3162 legion_task_launcher_set_mapper_arg(legion_task_launcher_t launcher,
3163 legion_untyped_buffer_t arg);
3164
3168 void
3169 legion_task_launcher_set_enable_inlining(legion_task_launcher_t launcher,
3170 bool enable_inlining);
3171
3175 void
3176 legion_task_launcher_set_local_function_task(legion_task_launcher_t launcher,
3177 bool local_function_task);
3178
3182 void
3183 legion_task_launcher_set_elide_future_return(legion_task_launcher_t launcher,
3184 bool elide_future_return);
3185
3189 void
3190 legion_task_launcher_set_provenance(legion_task_launcher_t launcher,
3191 const char *provenance);
3192
3198 legion_index_launcher_t
3199 legion_index_launcher_create(
3200 legion_task_id_t tid,
3201 legion_domain_t domain,
3202 legion_untyped_buffer_t global_arg,
3203 legion_argument_map_t map,
3204 legion_predicate_t pred /* = legion_predicate_true() */,
3205 bool must /* = false */,
3206 legion_mapper_id_t id /* = 0 */,
3207 legion_mapping_tag_id_t tag /* = 0 */);
3208
3214 legion_index_launcher_t
3215 legion_index_launcher_create_from_buffer(
3216 legion_task_id_t tid,
3217 legion_domain_t domain,
3218 const void *buffer,
3219 size_t buffer_size,
3220 legion_argument_map_t map,
3221 legion_predicate_t pred /* = legion_predicate_true() */,
3222 bool must /* = false */,
3223 legion_mapper_id_t id /* = 0 */,
3224 legion_mapping_tag_id_t tag /* = 0 */);
3225
3231 void
3232 legion_index_launcher_destroy(legion_index_launcher_t handle);
3233
3239 legion_future_map_t
3240 legion_index_launcher_execute(legion_runtime_t runtime,
3241 legion_context_t ctx,
3242 legion_index_launcher_t launcher);
3243
3249 legion_future_t
3250 legion_index_launcher_execute_reduction(legion_runtime_t runtime,
3251 legion_context_t ctx,
3252 legion_index_launcher_t launcher,
3253 legion_reduction_op_id_t redop);
3254
3260 legion_future_map_t
3261 legion_index_launcher_execute_outputs(legion_runtime_t runtime,
3262 legion_context_t ctx,
3263 legion_index_launcher_t launcher,
3264 legion_output_requirement_t *reqs,
3265 size_t reqs_size);
3266
3272 legion_future_t
3273 legion_index_launcher_execute_deterministic_reduction(legion_runtime_t runtime,
3274 legion_context_t ctx,
3275 legion_index_launcher_t launcher,
3276 legion_reduction_op_id_t redop,
3277 bool deterministic);
3278
3284 legion_future_t
3285 legion_index_launcher_execute_reduction_and_outputs(legion_runtime_t runtime,
3286 legion_context_t ctx,
3287 legion_index_launcher_t launcher,
3288 legion_reduction_op_id_t redop,
3289 bool deterministic,
3290 legion_output_requirement_t *reqs,
3291 size_t reqs_size);
3292
3296 unsigned
3297 legion_index_launcher_add_region_requirement_logical_region(
3298 legion_index_launcher_t launcher,
3299 legion_logical_region_t handle,
3300 legion_projection_id_t proj /* = 0 */,
3301 legion_privilege_mode_t priv,
3302 legion_coherence_property_t prop,
3303 legion_logical_region_t parent,
3304 legion_mapping_tag_id_t tag /* = 0 */,
3305 bool verified /* = false*/);
3306
3310 unsigned
3311 legion_index_launcher_add_region_requirement_logical_partition(
3312 legion_index_launcher_t launcher,
3313 legion_logical_partition_t handle,
3314 legion_projection_id_t proj /* = 0 */,
3315 legion_privilege_mode_t priv,
3316 legion_coherence_property_t prop,
3317 legion_logical_region_t parent,
3318 legion_mapping_tag_id_t tag /* = 0 */,
3319 bool verified /* = false*/);
3320
3324 unsigned
3325 legion_index_launcher_add_region_requirement_logical_region_reduction(
3326 legion_index_launcher_t launcher,
3327 legion_logical_region_t handle,
3328 legion_projection_id_t proj /* = 0 */,
3329 legion_reduction_op_id_t redop,
3330 legion_coherence_property_t prop,
3331 legion_logical_region_t parent,
3332 legion_mapping_tag_id_t tag /* = 0 */,
3333 bool verified /* = false*/);
3334
3338 unsigned
3339 legion_index_launcher_add_region_requirement_logical_partition_reduction(
3340 legion_index_launcher_t launcher,
3341 legion_logical_partition_t handle,
3342 legion_projection_id_t proj /* = 0 */,
3343 legion_reduction_op_id_t redop,
3344 legion_coherence_property_t prop,
3345 legion_logical_region_t parent,
3346 legion_mapping_tag_id_t tag /* = 0 */,
3347 bool verified /* = false*/);
3348
3352 void
3353 legion_index_launcher_set_region_requirement_logical_region(
3354 legion_index_launcher_t launcher,
3355 unsigned idx,
3356 legion_logical_region_t handle,
3357 legion_projection_id_t proj /* = 0 */,
3358 legion_privilege_mode_t priv,
3359 legion_coherence_property_t prop,
3360 legion_logical_region_t parent,
3361 legion_mapping_tag_id_t tag /* = 0 */,
3362 bool verified /* = false*/);
3363
3367 void
3368 legion_index_launcher_set_region_requirement_logical_partition(
3369 legion_index_launcher_t launcher,
3370 unsigned idx,
3371 legion_logical_partition_t handle,
3372 legion_projection_id_t proj /* = 0 */,
3373 legion_privilege_mode_t priv,
3374 legion_coherence_property_t prop,
3375 legion_logical_region_t parent,
3376 legion_mapping_tag_id_t tag /* = 0 */,
3377 bool verified /* = false*/);
3378
3382 void
3383 legion_index_launcher_set_region_requirement_logical_region_reduction(
3384 legion_index_launcher_t launcher,
3385 unsigned idx,
3386 legion_logical_region_t handle,
3387 legion_projection_id_t proj /* = 0 */,
3388 legion_reduction_op_id_t redop,
3389 legion_coherence_property_t prop,
3390 legion_logical_region_t parent,
3391 legion_mapping_tag_id_t tag /* = 0 */,
3392 bool verified /* = false*/);
3393
3397 void
3398 legion_index_launcher_set_region_requirement_logical_partition_reduction(
3399 legion_index_launcher_t launcher,
3400 unsigned idx,
3401 legion_logical_partition_t handle,
3402 legion_projection_id_t proj /* = 0 */,
3403 legion_reduction_op_id_t redop,
3404 legion_coherence_property_t prop,
3405 legion_logical_region_t parent,
3406 legion_mapping_tag_id_t tag /* = 0 */,
3407 bool verified /* = false*/);
3408
3412 void
3413 legion_index_launcher_add_field(legion_index_launcher_t launcher,
3414 unsigned idx,
3415 legion_field_id_t fid,
3416 bool inst /* = true */);
3417
3421 void
3422 legion_index_launcher_add_flags(legion_index_launcher_t launcher,
3423 unsigned idx,
3424 enum legion_region_flags_t flags);
3425
3429 void
3430 legion_index_launcher_intersect_flags(legion_index_launcher_t launcher,
3431 unsigned idx,
3432 enum legion_region_flags_t flags);
3433
3437 unsigned
3438 legion_index_launcher_add_index_requirement(
3439 legion_index_launcher_t launcher,
3440 legion_index_space_t handle,
3441 legion_allocate_mode_t priv,
3442 legion_index_space_t parent,
3443 bool verified /* = false*/);
3444
3448 void
3449 legion_index_launcher_add_future(legion_index_launcher_t launcher,
3450 legion_future_t future);
3451
3455 void
3456 legion_index_launcher_add_wait_barrier(legion_index_launcher_t launcher,
3457 legion_phase_barrier_t bar);
3458
3462 void
3463 legion_index_launcher_add_arrival_barrier(legion_index_launcher_t launcher,
3464 legion_phase_barrier_t bar);
3465
3469 void
3470 legion_index_launcher_add_point_future(legion_index_launcher_t launcher,
3471 legion_argument_map_t map);
3472
3476 void
3477 legion_index_launcher_set_global_arg(legion_index_launcher_t launcher,
3478 legion_untyped_buffer_t global_arg);
3479
3483 void
3484 legion_index_launcher_set_sharding_space(legion_index_launcher_t launcher,
3485 legion_index_space_t is);
3486
3490 void
3491 legion_index_launcher_set_mapper(legion_index_launcher_t launcher,
3492 legion_mapper_id_t mapper_id);
3493
3497 void
3498 legion_index_launcher_set_mapping_tag(legion_index_launcher_t launcher,
3499 legion_mapping_tag_id_t tag);
3500
3504 void
3505 legion_index_launcher_set_mapper_arg(legion_index_launcher_t launcher,
3506 legion_untyped_buffer_t map_arg);
3507
3511 void
3512 legion_index_launcher_set_elide_future_return(legion_index_launcher_t launcher,
3513 bool elide_future_return);
3514
3518 void
3519 legion_index_launcher_set_provenance(legion_index_launcher_t launcher,
3520 const char *provenance);
3521
3525 void
3526 legion_index_launcher_set_concurrent(legion_index_launcher_t launcher,
3527 bool concurrent);
3528
3532 void
3533 legion_index_launcher_set_initial_value(legion_index_launcher_t launcher,
3534 legion_future_t initial_value);
3535
3536 // -----------------------------------------------------------------------
3537 // Inline Mapping Operations
3538 // -----------------------------------------------------------------------
3539
3545 legion_inline_launcher_t
3546 legion_inline_launcher_create_logical_region(
3547 legion_logical_region_t handle,
3548 legion_privilege_mode_t priv,
3549 legion_coherence_property_t prop,
3550 legion_logical_region_t parent,
3551 legion_mapping_tag_id_t region_tag /* = 0 */,
3552 bool verified /* = false*/,
3553 legion_mapper_id_t id /* = 0 */,
3554 legion_mapping_tag_id_t launcher_tag /* = 0 */);
3555
3561 void
3562 legion_inline_launcher_destroy(legion_inline_launcher_t handle);
3563
3569 legion_physical_region_t
3570 legion_inline_launcher_execute(legion_runtime_t runtime,
3571 legion_context_t ctx,
3572 legion_inline_launcher_t launcher);
3573
3577 void
3578 legion_inline_launcher_add_field(legion_inline_launcher_t launcher,
3579 legion_field_id_t fid,
3580 bool inst /* = true */);
3581
3585 void
3586 legion_inline_launcher_set_mapper_arg(legion_inline_launcher_t launcher,
3587 legion_untyped_buffer_t arg);
3588
3592 void
3593 legion_inline_launcher_set_provenance(legion_inline_launcher_t launcher,
3594 const char *provenance);
3595
3599 void
3600 legion_runtime_remap_region(legion_runtime_t runtime,
3601 legion_context_t ctx,
3602 legion_physical_region_t region);
3603
3607 void
3608 legion_runtime_unmap_region(legion_runtime_t runtime,
3609 legion_context_t ctx,
3610 legion_physical_region_t region);
3611
3615 void
3616 legion_runtime_unmap_all_regions(legion_runtime_t runtime,
3617 legion_context_t ctx);
3618
3619 // -----------------------------------------------------------------------
3620 // Fill Field Operations
3621 // -----------------------------------------------------------------------
3622
3626 void
3627 legion_runtime_fill_field(
3628 legion_runtime_t runtime,
3629 legion_context_t ctx,
3630 legion_logical_region_t handle,
3631 legion_logical_region_t parent,
3632 legion_field_id_t fid,
3633 const void *value,
3634 size_t value_size,
3635 legion_predicate_t pred /* = legion_predicate_true() */);
3636
3640 void
3641 legion_runtime_fill_field_future(
3642 legion_runtime_t runtime,
3643 legion_context_t ctx,
3644 legion_logical_region_t handle,
3645 legion_logical_region_t parent,
3646 legion_field_id_t fid,
3647 legion_future_t f,
3648 legion_predicate_t pred /* = legion_predicate_true() */);
3649
3655 legion_fill_launcher_t
3656 legion_fill_launcher_create(
3657 legion_logical_region_t handle,
3658 legion_logical_region_t parent,
3659 legion_field_id_t fid,
3660 const void *value,
3661 size_t value_size,
3662 legion_predicate_t pred /* = legion_predicate_true() */,
3663 legion_mapper_id_t id /* = 0 */,
3664 legion_mapping_tag_id_t tag /* = 0 */);
3665
3671 legion_fill_launcher_t
3672 legion_fill_launcher_create_from_future(
3673 legion_logical_region_t handle,
3674 legion_logical_region_t parent,
3675 legion_field_id_t fid,
3676 legion_future_t f,
3677 legion_predicate_t pred /* = legion_predicate_true() */,
3678 legion_mapper_id_t id /* = 0 */,
3679 legion_mapping_tag_id_t tag /* = 0 */);
3680
3686 void
3687 legion_fill_launcher_destroy(legion_fill_launcher_t handle);
3688
3692 void
3693 legion_fill_launcher_add_field(legion_fill_launcher_t handle,
3694 legion_field_id_t fid);
3695
3699 void
3700 legion_fill_launcher_execute(legion_runtime_t runtime,
3701 legion_context_t ctx,
3702 legion_fill_launcher_t launcher);
3703
3707 void
3708 legion_fill_launcher_set_point(legion_fill_launcher_t launcher,
3709 legion_domain_point_t point);
3710
3714 void legion_fill_launcher_set_sharding_space(legion_fill_launcher_t launcher,
3715 legion_index_space_t space);
3716
3720 void
3721 legion_fill_launcher_set_mapper_arg(legion_fill_launcher_t launcher,
3722 legion_untyped_buffer_t arg);
3723
3727 void
3728 legion_fill_launcher_set_provenance(legion_fill_launcher_t launcher,
3729 const char *provenance);
3730
3731 // -----------------------------------------------------------------------
3732 // Index Fill Field Operations
3733 // -----------------------------------------------------------------------
3734
3739 void
3740 legion_runtime_index_fill_field(
3741 legion_runtime_t runtime,
3742 legion_context_t ctx,
3743 legion_logical_partition_t handle,
3744 legion_logical_region_t parent,
3745 legion_field_id_t fid,
3746 const void *value,
3747 size_t value_size,
3748 legion_projection_id_t proj /* = 0 */,
3749 legion_predicate_t pred /* = legion_predicate_true() */,
3750 legion_mapper_id_t id /* = 0 */,
3751 legion_mapping_tag_id_t launcher_tag /* = 0 */);
3752
3757 void
3758 legion_runtime_index_fill_field_with_space(
3759 legion_runtime_t runtime,
3760 legion_context_t ctx,
3761 legion_index_space_t space,
3762 legion_logical_partition_t handle,
3763 legion_logical_region_t parent,
3764 legion_field_id_t fid,
3765 const void *value,
3766 size_t value_size,
3767 legion_projection_id_t proj /* = 0 */,
3768 legion_predicate_t pred /* = legion_predicate_true() */,
3769 legion_mapper_id_t id /* = 0 */,
3770 legion_mapping_tag_id_t launcher_tag /* = 0 */);
3771
3776 void
3777 legion_runtime_index_fill_field_with_domain(
3778 legion_runtime_t runtime,
3779 legion_context_t ctx,
3780 legion_domain_t domain,
3781 legion_logical_partition_t handle,
3782 legion_logical_region_t parent,
3783 legion_field_id_t fid,
3784 const void *value,
3785 size_t value_size,
3786 legion_projection_id_t proj /* = 0 */,
3787 legion_predicate_t pred /* = legion_predicate_true() */,
3788 legion_mapper_id_t id /* = 0 */,
3789 legion_mapping_tag_id_t launcher_tag /* = 0 */);
3790
3795 void
3796 legion_runtime_index_fill_field_future(
3797 legion_runtime_t runtime,
3798 legion_context_t ctx,
3799 legion_logical_partition_t handle,
3800 legion_logical_region_t parent,
3801 legion_field_id_t fid,
3802 legion_future_t f,
3803 legion_projection_id_t proj /* = 0 */,
3804 legion_predicate_t pred /* = legion_predicate_true() */,
3805 legion_mapper_id_t id /* = 0 */,
3806 legion_mapping_tag_id_t launcher_tag /* = 0 */);
3807
3812 void
3813 legion_runtime_index_fill_field_future_with_space(
3814 legion_runtime_t runtime,
3815 legion_context_t ctx,
3816 legion_index_space_t space,
3817 legion_logical_partition_t handle,
3818 legion_logical_region_t parent,
3819 legion_field_id_t fid,
3820 legion_future_t f,
3821 legion_projection_id_t proj /* = 0 */,
3822 legion_predicate_t pred /* = legion_predicate_true() */,
3823 legion_mapper_id_t id /* = 0 */,
3824 legion_mapping_tag_id_t launcher_tag /* = 0 */);
3825
3830 void
3831 legion_runtime_index_fill_field_future_with_domain(
3832 legion_runtime_t runtime,
3833 legion_context_t ctx,
3834 legion_domain_t domain,
3835 legion_logical_partition_t handle,
3836 legion_logical_region_t parent,
3837 legion_field_id_t fid,
3838 legion_future_t f,
3839 legion_projection_id_t proj /* = 0 */,
3840 legion_predicate_t pred /* = legion_predicate_true() */,
3841 legion_mapper_id_t id /* = 0 */,
3842 legion_mapping_tag_id_t launcher_tag /* = 0 */);
3843
3849 legion_index_fill_launcher_t
3850 legion_index_fill_launcher_create_with_space(
3851 legion_index_space_t space,
3852 legion_logical_partition_t handle,
3853 legion_logical_region_t parent,
3854 legion_field_id_t fid,
3855 const void *value,
3856 size_t value_size,
3857 legion_projection_id_t proj /* = 0 */,
3858 legion_predicate_t pred /* = legion_predicate_true() */,
3859 legion_mapper_id_t id /* = 0 */,
3860 legion_mapping_tag_id_t launcher_tag /* = 0 */);
3861
3867 legion_index_fill_launcher_t
3868 legion_index_fill_launcher_create_with_domain(
3869 legion_domain_t domain,
3870 legion_logical_partition_t handle,
3871 legion_logical_region_t parent,
3872 legion_field_id_t fid,
3873 const void *value,
3874 size_t value_size,
3875 legion_projection_id_t proj /* = 0 */,
3876 legion_predicate_t pred /* = legion_predicate_true() */,
3877 legion_mapper_id_t id /* = 0 */,
3878 legion_mapping_tag_id_t launcher_tag /* = 0 */);
3879
3885 legion_index_fill_launcher_t
3886 legion_index_fill_launcher_create_from_future_with_space(
3887 legion_index_space_t space,
3888 legion_logical_partition_t handle,
3889 legion_logical_region_t parent,
3890 legion_field_id_t fid,
3891 legion_future_t future,
3892 legion_projection_id_t proj /* = 0 */,
3893 legion_predicate_t pred /* = legion_predicate_true() */,
3894 legion_mapper_id_t id /* = 0 */,
3895 legion_mapping_tag_id_t launcher_tag /* = 0 */);
3896
3902 legion_index_fill_launcher_t
3903 legion_index_fill_launcher_create_from_future_with_domain(
3904 legion_domain_t domain,
3905 legion_logical_partition_t handle,
3906 legion_logical_region_t parent,
3907 legion_field_id_t fid,
3908 legion_future_t future,
3909 legion_projection_id_t proj /* = 0 */,
3910 legion_predicate_t pred /* = legion_predicate_true() */,
3911 legion_mapper_id_t id /* = 0 */,
3912 legion_mapping_tag_id_t launcher_tag /* = 0 */);
3913
3919 void
3920 legion_index_fill_launcher_destroy(legion_index_fill_launcher_t handle);
3921
3925 void
3926 legion_index_fill_launcher_add_field(legion_fill_launcher_t handle,
3927 legion_field_id_t fid);
3928
3932 void
3933 legion_index_fill_launcher_execute(legion_runtime_t runtime,
3934 legion_context_t ctx,
3935 legion_index_fill_launcher_t launcher);
3936
3940 void legion_index_fill_launcher_set_sharding_space(legion_index_fill_launcher_t launcher,
3941 legion_index_space_t space);
3942
3946 void
3947 legion_index_fill_launcher_set_mapper_arg(legion_index_fill_launcher_t launcher,
3948 legion_untyped_buffer_t arg);
3949
3953 void
3954 legion_index_fill_launcher_set_provenance(legion_index_fill_launcher_t launcher,
3955 const char *provenance);
3956
3962 legion_region_requirement_t
3963 legion_fill_get_requirement(legion_fill_t fill);
3964
3965 // -----------------------------------------------------------------------
3966 // Discard Operation
3967 // -----------------------------------------------------------------------
3968
3974 legion_discard_launcher_t
3975 legion_discard_launcher_create(
3976 legion_logical_region_t handle,
3977 legion_logical_region_t parent);
3978
3984 void
3985 legion_discard_launcher_destroy(legion_discard_launcher_t handle);
3986
3990 void
3991 legion_discard_launcher_add_field(legion_discard_launcher_t handle,
3992 legion_field_id_t fid);
3993
3997 void
3998 legion_discard_launcher_execute(legion_runtime_t runtime,
3999 legion_context_t ctx,
4000 legion_discard_launcher_t launcher);
4001
4005 void
4006 legion_discard_launcher_set_provenance(legion_discard_launcher_t launcher,
4007 const char *provenance);
4008
4009 // -----------------------------------------------------------------------
4010 // File Operations
4011 // -----------------------------------------------------------------------
4012
4016 legion_field_map_t
4017 legion_field_map_create(void);
4018
4022 void
4023 legion_field_map_destroy(legion_field_map_t handle);
4024
4025 void
4026 legion_field_map_insert(legion_field_map_t handle,
4027 legion_field_id_t key,
4028 const char *value);
4029
4035 legion_physical_region_t
4036 legion_runtime_attach_hdf5(
4037 legion_runtime_t runtime,
4038 legion_context_t ctx,
4039 const char *filename,
4040 legion_logical_region_t handle,
4041 legion_logical_region_t parent,
4042 legion_field_map_t field_map,
4043 legion_file_mode_t mode);
4044
4048 void
4049 legion_runtime_detach_hdf5(
4050 legion_runtime_t runtime,
4051 legion_context_t ctx,
4052 legion_physical_region_t region);
4053
4054 // -----------------------------------------------------------------------
4055 // Copy Operations
4056 // -----------------------------------------------------------------------
4057
4063 legion_copy_launcher_t
4064 legion_copy_launcher_create(
4065 legion_predicate_t pred /* = legion_predicate_true() */,
4066 legion_mapper_id_t id /* = 0 */,
4067 legion_mapping_tag_id_t launcher_tag /* = 0 */);
4068
4074 void
4075 legion_copy_launcher_destroy(legion_copy_launcher_t handle);
4076
4082 void
4083 legion_copy_launcher_execute(legion_runtime_t runtime,
4084 legion_context_t ctx,
4085 legion_copy_launcher_t launcher);
4086
4090 unsigned
4091 legion_copy_launcher_add_src_region_requirement_logical_region(
4092 legion_copy_launcher_t launcher,
4093 legion_logical_region_t handle,
4094 legion_privilege_mode_t priv,
4095 legion_coherence_property_t prop,
4096 legion_logical_region_t parent,
4097 legion_mapping_tag_id_t tag /* = 0 */,
4098 bool verified /* = false*/);
4099
4103 unsigned
4104 legion_copy_launcher_add_dst_region_requirement_logical_region(
4105 legion_copy_launcher_t launcher,
4106 legion_logical_region_t handle,
4107 legion_privilege_mode_t priv,
4108 legion_coherence_property_t prop,
4109 legion_logical_region_t parent,
4110 legion_mapping_tag_id_t tag /* = 0 */,
4111 bool verified /* = false*/);
4112
4116 unsigned
4117 legion_copy_launcher_add_dst_region_requirement_logical_region_reduction(
4118 legion_copy_launcher_t launcher,
4119 legion_logical_region_t handle,
4120 legion_reduction_op_id_t redop,
4121 legion_coherence_property_t prop,
4122 legion_logical_region_t parent,
4123 legion_mapping_tag_id_t tag /* = 0 */,
4124 bool verified /* = false*/);
4125
4129 unsigned
4130 legion_copy_launcher_add_src_indirect_region_requirement_logical_region(
4131 legion_copy_launcher_t launcher,
4132 legion_logical_region_t handle,
4133 legion_field_id_t fid,
4134 legion_coherence_property_t prop,
4135 legion_logical_region_t parent,
4136 legion_mapping_tag_id_t tag /* = 0 */,
4137 bool is_range_indirection /* = false */,
4138 bool verified /* = false*/);
4139
4143 unsigned
4144 legion_copy_launcher_add_dst_indirect_region_requirement_logical_region(
4145 legion_copy_launcher_t launcher,
4146 legion_logical_region_t handle,
4147 legion_field_id_t fid,
4148 legion_coherence_property_t prop,
4149 legion_logical_region_t parent,
4150 legion_mapping_tag_id_t tag /* = 0 */,
4151 bool is_range_indirection /* = false */,
4152 bool verified /* = false*/);
4153
4157 void
4158 legion_copy_launcher_add_src_field(legion_copy_launcher_t launcher,
4159 unsigned idx,
4160 legion_field_id_t fid,
4161 bool inst /* = true */);
4162
4166 void
4167 legion_copy_launcher_add_dst_field(legion_copy_launcher_t launcher,
4168 unsigned idx,
4169 legion_field_id_t fid,
4170 bool inst /* = true */);
4171
4175 void
4176 legion_copy_launcher_add_wait_barrier(legion_copy_launcher_t launcher,
4177 legion_phase_barrier_t bar);
4178
4182 void
4183 legion_copy_launcher_add_arrival_barrier(legion_copy_launcher_t launcher,
4184 legion_phase_barrier_t bar);
4185
4189 void
4190 legion_copy_launcher_set_possible_src_indirect_out_of_range(
4191 legion_copy_launcher_t launcher, bool flag);
4192
4196 void
4197 legion_copy_launcher_set_possible_dst_indirect_out_of_range(
4198 legion_copy_launcher_t launcher, bool flag);
4199
4203 void
4204 legion_copy_launcher_set_point(legion_copy_launcher_t launcher,
4205 legion_domain_point_t point);
4206
4210 void legion_copy_launcher_set_sharding_space(legion_copy_launcher_t launcher,
4211 legion_index_space_t space);
4212
4216 void
4217 legion_copy_launcher_set_mapper_arg(legion_copy_launcher_t launcher,
4218 legion_untyped_buffer_t arg);
4219
4223 void
4224 legion_copy_launcher_set_provenance(legion_copy_launcher_t launcher,
4225 const char *provenance);
4226
4235 legion_region_requirement_t
4236 legion_copy_get_requirement(legion_copy_t copy, unsigned idx);
4237
4238 // -----------------------------------------------------------------------
4239 // Index Copy Operations
4240 // -----------------------------------------------------------------------
4241
4247 legion_index_copy_launcher_t
4248 legion_index_copy_launcher_create(
4249 legion_domain_t domain,
4250 legion_predicate_t pred /* = legion_predicate_true() */,
4251 legion_mapper_id_t id /* = 0 */,
4252 legion_mapping_tag_id_t launcher_tag /* = 0 */);
4253
4259 void
4260 legion_index_copy_launcher_destroy(legion_index_copy_launcher_t handle);
4261
4267 void
4268 legion_index_copy_launcher_execute(legion_runtime_t runtime,
4269 legion_context_t ctx,
4270 legion_index_copy_launcher_t launcher);
4271
4275 unsigned
4276 legion_index_copy_launcher_add_src_region_requirement_logical_region(
4277 legion_index_copy_launcher_t launcher,
4278 legion_logical_region_t handle,
4279 legion_projection_id_t proj /* = 0 */,
4280 legion_privilege_mode_t priv,
4281 legion_coherence_property_t prop,
4282 legion_logical_region_t parent,
4283 legion_mapping_tag_id_t tag /* = 0 */,
4284 bool verified /* = false*/);
4285
4289 unsigned
4290 legion_index_copy_launcher_add_dst_region_requirement_logical_region(
4291 legion_index_copy_launcher_t launcher,
4292 legion_logical_region_t handle,
4293 legion_projection_id_t proj /* = 0 */,
4294 legion_privilege_mode_t priv,
4295 legion_coherence_property_t prop,
4296 legion_logical_region_t parent,
4297 legion_mapping_tag_id_t tag /* = 0 */,
4298 bool verified /* = false*/);
4299
4303 unsigned
4304 legion_index_copy_launcher_add_src_region_requirement_logical_partition(
4305 legion_index_copy_launcher_t launcher,
4306 legion_logical_partition_t handle,
4307 legion_projection_id_t proj /* = 0 */,
4308 legion_privilege_mode_t priv,
4309 legion_coherence_property_t prop,
4310 legion_logical_region_t parent,
4311 legion_mapping_tag_id_t tag /* = 0 */,
4312 bool verified /* = false*/);
4313
4317 unsigned
4318 legion_index_copy_launcher_add_dst_region_requirement_logical_partition(
4319 legion_index_copy_launcher_t launcher,
4320 legion_logical_partition_t handle,
4321 legion_projection_id_t proj /* = 0 */,
4322 legion_privilege_mode_t priv,
4323 legion_coherence_property_t prop,
4324 legion_logical_region_t parent,
4325 legion_mapping_tag_id_t tag /* = 0 */,
4326 bool verified /* = false*/);
4327
4331 unsigned
4332 legion_index_copy_launcher_add_dst_region_requirement_logical_region_reduction(
4333 legion_index_copy_launcher_t launcher,
4334 legion_logical_region_t handle,
4335 legion_projection_id_t proj /* = 0 */,
4336 legion_reduction_op_id_t redop,
4337 legion_coherence_property_t prop,
4338 legion_logical_region_t parent,
4339 legion_mapping_tag_id_t tag /* = 0 */,
4340 bool verified /* = false*/);
4341
4345 unsigned
4346 legion_index_copy_launcher_add_dst_region_requirement_logical_partition_reduction(
4347 legion_index_copy_launcher_t launcher,
4348 legion_logical_partition_t handle,
4349 legion_projection_id_t proj /* = 0 */,
4350 legion_reduction_op_id_t redop,
4351 legion_coherence_property_t prop,
4352 legion_logical_region_t parent,
4353 legion_mapping_tag_id_t tag /* = 0 */,
4354 bool verified /* = false*/);
4355
4359 unsigned
4360 legion_index_copy_launcher_add_src_indirect_region_requirement_logical_region(
4361 legion_index_copy_launcher_t launcher,
4362 legion_logical_region_t handle,
4363 legion_projection_id_t proj /* = 0 */,
4364 legion_field_id_t fid,
4365 legion_coherence_property_t prop,
4366 legion_logical_region_t parent,
4367 legion_mapping_tag_id_t tag /* = 0 */,
4368 bool is_range_indirection /* = false */,
4369 bool verified /* = false*/);
4370
4374 unsigned
4375 legion_index_copy_launcher_add_dst_indirect_region_requirement_logical_region(
4376 legion_index_copy_launcher_t launcher,
4377 legion_logical_region_t handle,
4378 legion_projection_id_t proj /* = 0 */,
4379 legion_field_id_t fid,
4380 legion_coherence_property_t prop,
4381 legion_logical_region_t parent,
4382 legion_mapping_tag_id_t tag /* = 0 */,
4383 bool is_range_indirection /* = false */,
4384 bool verified /* = false*/);
4385
4389 unsigned
4390 legion_index_copy_launcher_add_src_indirect_region_requirement_logical_partition(
4391 legion_index_copy_launcher_t launcher,
4392 legion_logical_partition_t handle,
4393 legion_projection_id_t proj /* = 0 */,
4394 legion_field_id_t fid,
4395 legion_coherence_property_t prop,
4396 legion_logical_region_t parent,
4397 legion_mapping_tag_id_t tag /* = 0 */,
4398 bool is_range_indirection /* = false */,
4399 bool verified /* = false*/);
4400
4404 unsigned
4405 legion_index_copy_launcher_add_dst_indirect_region_requirement_logical_partition(
4406 legion_index_copy_launcher_t launcher,
4407 legion_logical_partition_t handle,
4408 legion_projection_id_t proj /* = 0 */,
4409 legion_field_id_t fid,
4410 legion_coherence_property_t prop,
4411 legion_logical_region_t parent,
4412 legion_mapping_tag_id_t tag /* = 0 */,
4413 bool is_range_indirection /* = false */,
4414 bool verified /* = false*/);
4415
4419 void
4420 legion_index_copy_launcher_add_src_field(legion_index_copy_launcher_t launcher,
4421 unsigned idx,
4422 legion_field_id_t fid,
4423 bool inst /* = true */);
4424
4428 void
4429 legion_index_copy_launcher_add_dst_field(legion_index_copy_launcher_t launcher,
4430 unsigned idx,
4431 legion_field_id_t fid,
4432 bool inst /* = true */);
4433
4437 void
4438 legion_index_copy_launcher_add_wait_barrier(legion_index_copy_launcher_t launcher,
4439 legion_phase_barrier_t bar);
4440
4444 void
4445 legion_index_copy_launcher_add_arrival_barrier(legion_index_copy_launcher_t launcher,
4446 legion_phase_barrier_t bar);
4447
4451 void
4452 legion_index_copy_launcher_set_possible_src_indirect_out_of_range(
4453 legion_index_copy_launcher_t launcher, bool flag);
4454
4458 void
4459 legion_index_copy_launcher_set_possible_dst_indirect_out_of_range(
4460 legion_index_copy_launcher_t launcher, bool flag);
4461
4465 void
4466 legion_index_copy_launcher_set_sharding_space(legion_index_copy_launcher_t launcher,
4467 legion_index_space_t is);
4468
4472 void
4473 legion_index_copy_launcher_set_mapper_arg(legion_index_copy_launcher_t launcher,
4474 legion_untyped_buffer_t arg);
4475
4479 void
4480 legion_index_copy_launcher_set_provenance(legion_index_copy_launcher_t launcher,
4481 const char *provenance);
4482
4483 // -----------------------------------------------------------------------
4484 // Acquire Operations
4485 // -----------------------------------------------------------------------
4486
4492 legion_acquire_launcher_t
4493 legion_acquire_launcher_create(
4494 legion_logical_region_t logical_region,
4495 legion_logical_region_t parent_region,
4496 legion_predicate_t pred /* = legion_predicate_true() */,
4497 legion_mapper_id_t id /* = 0 */,
4498 legion_mapping_tag_id_t tag /* = 0 */);
4499
4505 void
4506 legion_acquire_launcher_destroy(legion_acquire_launcher_t handle);
4507
4513 void
4514 legion_acquire_launcher_execute(legion_runtime_t runtime,
4515 legion_context_t ctx,
4516 legion_acquire_launcher_t launcher);
4517
4521 void
4522 legion_acquire_launcher_add_field(legion_acquire_launcher_t launcher,
4523 legion_field_id_t fid);
4524
4528 void
4529 legion_acquire_launcher_add_wait_barrier(legion_acquire_launcher_t launcher,
4530 legion_phase_barrier_t bar);
4531
4535 void
4536 legion_acquire_launcher_add_arrival_barrier(
4537 legion_acquire_launcher_t launcher,
4538 legion_phase_barrier_t bar);
4539
4543 void
4544 legion_acquire_launcher_set_sharding_space(legion_acquire_launcher_t launcher,
4545 legion_index_space_t space);
4546
4550 void
4551 legion_acquire_launcher_set_mapper_arg(legion_acquire_launcher_t launcher,
4552 legion_untyped_buffer_t arg);
4553
4557 void
4558 legion_acquire_launcher_set_provenance(legion_acquire_launcher_t launcher,
4559 const char *provenance);
4560
4561 // -----------------------------------------------------------------------
4562 // Release Operations
4563 // -----------------------------------------------------------------------
4564
4570 legion_release_launcher_t
4571 legion_release_launcher_create(
4572 legion_logical_region_t logical_region,
4573 legion_logical_region_t parent_region,
4574 legion_predicate_t pred /* = legion_predicate_true() */,
4575 legion_mapper_id_t id /* = 0 */,
4576 legion_mapping_tag_id_t tag /* = 0 */);
4577
4583 void
4584 legion_release_launcher_destroy(legion_release_launcher_t handle);
4585
4591 void
4592 legion_release_launcher_execute(legion_runtime_t runtime,
4593 legion_context_t ctx,
4594 legion_release_launcher_t launcher);
4595
4599 void
4600 legion_release_launcher_add_field(legion_release_launcher_t launcher,
4601 legion_field_id_t fid);
4602
4606 void
4607 legion_release_launcher_add_wait_barrier(legion_release_launcher_t launcher,
4608 legion_phase_barrier_t bar);
4609
4613 void
4614 legion_release_launcher_add_arrival_barrier(
4615 legion_release_launcher_t launcher,
4616 legion_phase_barrier_t bar);
4617
4621 void
4622 legion_release_launcher_set_sharding_space(legion_release_launcher_t launcher,
4623 legion_index_space_t space);
4624
4628 void
4629 legion_release_launcher_set_mapper_arg(legion_release_launcher_t launcher,
4630 legion_untyped_buffer_t arg);
4631
4635 void
4636 legion_release_launcher_set_provenance(legion_release_launcher_t launcher,
4637 const char *provenance);
4638
4639 // -----------------------------------------------------------------------
4640 // Attach/Detach Operations
4641 // -----------------------------------------------------------------------
4642
4648 legion_attach_launcher_t
4649 legion_attach_launcher_create(
4650 legion_logical_region_t logical_region,
4651 legion_logical_region_t parent_region,
4652 legion_external_resource_t resource);
4653
4657 void
4658 legion_attach_launcher_attach_hdf5(legion_attach_launcher_t handle,
4659 const char *filename,
4660 legion_field_map_t field_map,
4661 legion_file_mode_t mode);
4662
4666 void
4667 legion_attach_launcher_set_restricted(legion_attach_launcher_t handle,
4668 bool restricted);
4669
4673 void
4674 legion_attach_launcher_set_mapped(legion_attach_launcher_t handle,
4675 bool mapped);
4676
4680 void
4681 legion_attach_launcher_set_provenance(legion_attach_launcher_t handle,
4682 const char *provenance);
4683
4689 void
4690 legion_attach_launcher_destroy(legion_attach_launcher_t handle);
4691
4697 legion_physical_region_t
4698 legion_attach_launcher_execute(legion_runtime_t runtime,
4699 legion_context_t ctx,
4700 legion_attach_launcher_t launcher);
4701
4705 void
4706 legion_attach_launcher_add_cpu_soa_field(legion_attach_launcher_t launcher,
4707 legion_field_id_t fid,
4708 void *base_ptr,
4709 bool column_major);
4710
4716 legion_future_t
4717 legion_detach_external_resource(legion_runtime_t runtime,
4718 legion_context_t ctx,
4719 legion_physical_region_t handle);
4720
4726 legion_future_t
4727 legion_flush_detach_external_resource(legion_runtime_t runtime,
4728 legion_context_t ctx,
4729 legion_physical_region_t handle,
4730 bool flush);
4731
4737 legion_future_t
4738 legion_unordered_detach_external_resource(legion_runtime_t runtime,
4739 legion_context_t ctx,
4740 legion_physical_region_t handle,
4741 bool flush,
4742 bool unordered);
4743
4747 void
4748 legion_context_progress_unordered_operations(legion_runtime_t runtime,
4749 legion_context_t ctx);
4750
4751 // -----------------------------------------------------------------------
4752 // Index Attach/Detach Operations
4753 // -----------------------------------------------------------------------
4754
4760 legion_index_attach_launcher_t
4761 legion_index_attach_launcher_create(
4762 legion_logical_region_t parent_region,
4763 legion_external_resource_t resource,
4764 bool restricted/*=true*/);
4765
4769 void
4770 legion_index_attach_launcher_set_restricted(
4771 legion_index_attach_launcher_t handle, bool restricted);
4772
4776 void
4777 legion_index_attach_launcher_set_provenance(
4778 legion_index_attach_launcher_t handle, const char *provenance);
4779
4783 void
4784 legion_index_attach_launcher_set_deduplicate_across_shards(
4785 legion_index_attach_launcher_t handle, bool deduplicate);
4786
4790 void
4791 legion_index_attach_launcher_attach_file(legion_index_attach_launcher_t handle,
4792 legion_logical_region_t region,
4793 const char *filename,
4794 const legion_field_id_t *fields,
4795 size_t num_fields,
4796 legion_file_mode_t mode);
4797
4801 void
4802 legion_index_attach_launcher_attach_hdf5(legion_index_attach_launcher_t handle,
4803 legion_logical_region_t region,
4804 const char *filename,
4805 legion_field_map_t field_map,
4806 legion_file_mode_t mode);
4807
4811 void
4812 legion_index_attach_launcher_attach_array_soa(legion_index_attach_launcher_t handle,
4813 legion_logical_region_t region,
4814 void *base_ptr, bool column_major,
4815 const legion_field_id_t *fields,
4816 size_t num_fields,
4817 legion_memory_t memory);
4818
4822 void
4823 legion_index_attach_launcher_attach_array_aos(legion_index_attach_launcher_t handle,
4824 legion_logical_region_t region,
4825 void *base_ptr, bool column_major,
4826 const legion_field_id_t *fields,
4827 size_t num_fields,
4828 legion_memory_t memory);
4829
4835 void
4836 legion_index_attach_launcher_destroy(legion_index_attach_launcher_t handle);
4837
4843 legion_external_resources_t
4844 legion_attach_external_resources(legion_runtime_t runtime,
4845 legion_context_t ctx,
4846 legion_index_attach_launcher_t launcher);
4847
4853 legion_future_t
4854 legion_detach_external_resources(legion_runtime_t runtime,
4855 legion_context_t ctx,
4856 legion_external_resources_t,
4857 bool flush, bool unordered);
4858
4859 // -----------------------------------------------------------------------
4860 // Must Epoch Operations
4861 // -----------------------------------------------------------------------
4862
4868 legion_must_epoch_launcher_t
4869 legion_must_epoch_launcher_create(
4870 legion_mapper_id_t id /* = 0 */,
4871 legion_mapping_tag_id_t launcher_tag /* = 0 */);
4872
4878 void
4879 legion_must_epoch_launcher_destroy(legion_must_epoch_launcher_t handle);
4880
4886 legion_future_map_t
4887 legion_must_epoch_launcher_execute(legion_runtime_t runtime,
4888 legion_context_t ctx,
4889 legion_must_epoch_launcher_t launcher);
4890
4896 void
4897 legion_must_epoch_launcher_add_single_task(
4898 legion_must_epoch_launcher_t launcher,
4899 legion_domain_point_t point,
4900 legion_task_launcher_t handle);
4901
4907 void
4908 legion_must_epoch_launcher_add_index_task(
4909 legion_must_epoch_launcher_t launcher,
4910 legion_index_launcher_t handle);
4911
4915 void
4916 legion_must_epoch_launcher_set_launch_domain(
4917 legion_must_epoch_launcher_t launcher,
4918 legion_domain_t domain);
4919
4923 void
4924 legion_must_epoch_launcher_set_launch_space(
4925 legion_must_epoch_launcher_t launcher,
4926 legion_index_space_t is);
4927
4931 void
4932 legion_must_epoch_launcher_set_provenance(
4933 legion_must_epoch_launcher_t launcher, const char *provenance);
4934
4935 // -----------------------------------------------------------------------
4936 // Fence Operations
4937 // -----------------------------------------------------------------------
4938
4942 legion_future_t
4943 legion_runtime_issue_mapping_fence(legion_runtime_t runtime,
4944 legion_context_t ctx);
4945
4949 legion_future_t
4950 legion_runtime_issue_execution_fence(legion_runtime_t runtime,
4951 legion_context_t ctx);
4952
4953 // -----------------------------------------------------------------------
4954 // Tracing Operations
4955 // -----------------------------------------------------------------------
4956
4960 void
4961 legion_runtime_begin_trace(legion_runtime_t runtime,
4962 legion_context_t ctx,
4963 legion_trace_id_t tid,
4964 bool logical_only);
4965
4969 void
4970 legion_runtime_end_trace(legion_runtime_t runtime,
4971 legion_context_t ctx,
4972 legion_trace_id_t tid);
4973
4974 // -----------------------------------------------------------------------
4975 // Frame Operations
4976 // -----------------------------------------------------------------------
4977
4978 void
4979 legion_runtime_complete_frame(legion_runtime_t runtime,
4980 legion_context_t ctx);
4981
4982 // -----------------------------------------------------------------------
4983 // Tunable Variables
4984 // -----------------------------------------------------------------------
4985
4991 legion_future_t
4992 legion_runtime_select_tunable_value(legion_runtime_t runtime,
4993 legion_context_t ctx,
4994 legion_tunable_id_t tid,
4995 legion_mapper_id_t mapper /* = 0 */,
4996 legion_mapping_tag_id_t tag /* = 0 */);
4997
4998 // -----------------------------------------------------------------------
4999 // Miscellaneous Operations
5000 // -----------------------------------------------------------------------
5001
5005 bool
5006 legion_runtime_has_runtime(void);
5007
5011 legion_runtime_t
5012 legion_runtime_get_runtime(void);
5013
5017 bool
5018 legion_runtime_has_context(void);
5019
5025 legion_context_t
5026 legion_runtime_get_context(void);
5027
5033 void
5034 legion_context_destroy(legion_context_t);
5035
5039 legion_processor_t
5040 legion_runtime_get_executing_processor(legion_runtime_t runtime,
5041 legion_context_t ctx);
5042
5046 void
5047 legion_runtime_yield(legion_runtime_t runtime, legion_context_t ctx);
5048
5052 legion_shard_id_t
5053 legion_runtime_local_shard(legion_runtime_t runtime, legion_context_t ctx);
5054
5055 legion_shard_id_t
5056 legion_runtime_local_shard_without_context(void);
5057
5061 size_t
5062 legion_runtime_total_shards(legion_runtime_t runtime, legion_context_t ctx);
5063
5069 legion_shard_id_t
5070 legion_sharding_functor_shard(legion_sharding_id_t sid,
5071 legion_domain_point_t point,
5072 legion_domain_t full_space,
5073 size_t total_shards);
5074
5089 void
5090 legion_sharding_functor_invert(legion_sharding_id_t sid,
5091 legion_shard_id_t shard,
5092 legion_domain_t shard_domain,
5093 legion_domain_t full_domain,
5094 size_t total_shards,
5095 legion_domain_point_t *points,
5096 size_t *points_size);
5097
5098 void
5099 legion_runtime_enable_scheduler_lock(void);
5100
5101 void
5102 legion_runtime_disable_scheduler_lock(void);
5103
5107 void
5108 legion_runtime_print_once(legion_runtime_t runtime,
5109 legion_context_t ctx,
5110 FILE *f,
5111 const char *message);
5115 void
5116 legion_runtime_print_once_fd(legion_runtime_t runtime,
5117 legion_context_t ctx,
5118 int fd, const char *mode,
5119 const char *message);
5120
5121 // -----------------------------------------------------------------------
5122 // Physical Data Operations
5123 // -----------------------------------------------------------------------
5124
5130 void
5131 legion_physical_region_destroy(legion_physical_region_t handle);
5132
5138 legion_physical_region_t
5139 legion_physical_region_copy(legion_physical_region_t handle);
5140
5144 bool
5145 legion_physical_region_is_mapped(legion_physical_region_t handle);
5146
5150 void
5151 legion_physical_region_wait_until_valid(legion_physical_region_t handle);
5152
5156 bool
5157 legion_physical_region_is_valid(legion_physical_region_t handle);
5158
5162 legion_logical_region_t
5163 legion_physical_region_get_logical_region(legion_physical_region_t handle);
5164
5168 size_t
5169 legion_physical_region_get_field_count(legion_physical_region_t handle);
5170 legion_field_id_t
5171 legion_physical_region_get_field_id(legion_physical_region_t handle, size_t index);
5172
5176 size_t
5177 legion_physical_region_get_memory_count(legion_physical_region_t handle);
5178 legion_memory_t
5179 legion_physical_region_get_memory(legion_physical_region_t handle, size_t index);
5180
5186#define ACCESSOR_ARRAY(DIM) \
5187 legion_accessor_array_##DIM##d_t \
5188 legion_physical_region_get_field_accessor_array_##DIM##d( \
5189 legion_physical_region_t handle, \
5190 legion_field_id_t fid);
5191 LEGION_FOREACH_N(ACCESSOR_ARRAY)
5192#undef ACCESSOR_ARRAY
5193
5194#define ACCESSOR_ARRAY(DIM) \
5195 legion_accessor_array_##DIM##d_t \
5196 legion_physical_region_get_field_accessor_array_##DIM##d_with_transform( \
5197 legion_physical_region_t handle, \
5198 legion_field_id_t fid, \
5199 legion_domain_affine_transform_t transform);
5200 LEGION_FOREACH_N(ACCESSOR_ARRAY)
5201#undef ACCESSOR_ARRAY
5202
5203#define RAW_PTR(DIM) \
5204 void * \
5205 legion_accessor_array_##DIM##d_raw_rect_ptr(legion_accessor_array_##DIM##d_t handle, \
5206 legion_rect_##DIM##d_t rect, \
5207 legion_rect_##DIM##d_t *subrect, \
5208 legion_byte_offset_t *offsets);
5209 LEGION_FOREACH_N(RAW_PTR)
5210#undef RAW_PTR
5211
5212 // Read
5213 void
5214 legion_accessor_array_1d_read(legion_accessor_array_1d_t handle,
5215 legion_ptr_t ptr,
5216 void *dst, size_t bytes);
5217
5218#define READ_ARRAY(DIM) \
5219 void \
5220 legion_accessor_array_##DIM##d_read_point(legion_accessor_array_##DIM##d_t handle, \
5221 legion_point_##DIM##d_t point, \
5222 void *dst, size_t bytes);
5223 LEGION_FOREACH_N(READ_ARRAY)
5224#undef READ_ARRAY
5225
5226 // Write
5227 void
5228 legion_accessor_array_1d_write(legion_accessor_array_1d_t handle,
5229 legion_ptr_t ptr,
5230 const void *src, size_t bytes);
5231
5232#define WRITE_ARRAY(DIM) \
5233 void \
5234 legion_accessor_array_##DIM##d_write_point(legion_accessor_array_##DIM##d_t handle, \
5235 legion_point_##DIM##d_t point, \
5236 const void *src, size_t bytes);
5237 LEGION_FOREACH_N(WRITE_ARRAY)
5238#undef WRITE_ARRAY
5239
5240 // Ref
5241 void *
5242 legion_accessor_array_1d_ref(legion_accessor_array_1d_t handle,
5243 legion_ptr_t ptr);
5244
5245#define REF_ARRAY(DIM) \
5246 void * \
5247 legion_accessor_array_##DIM##d_ref_point(legion_accessor_array_##DIM##d_t handle, \
5248 legion_point_##DIM##d_t point);
5249 LEGION_FOREACH_N(REF_ARRAY)
5250#undef REF_ARRAY
5251
5255#define DESTROY_ARRAY(DIM) \
5256 void \
5257 legion_accessor_array_##DIM##d_destroy(legion_accessor_array_##DIM##d_t handle);
5258 LEGION_FOREACH_N(DESTROY_ARRAY)
5259#undef DESTROY_ARRAY
5260
5261 // -----------------------------------------------------------------------
5262 // External Resource Operations
5263 // -----------------------------------------------------------------------
5264
5268 void
5269 legion_external_resources_destroy(legion_external_resources_t handle);
5270
5274 size_t
5275 legion_external_resources_size(legion_external_resources_t handle);
5276
5282 legion_physical_region_t
5283 legion_external_resources_get_region(legion_external_resources_t handle,
5284 unsigned index);
5285
5286 // -----------------------------------------------------------------------
5287 // Mappable Operations
5288 // -----------------------------------------------------------------------
5289
5293 enum legion_mappable_type_id_t
5294 legion_mappable_get_type(legion_mappable_t mappable);
5295
5299 legion_task_t
5300 legion_mappable_as_task(legion_mappable_t mappable);
5301
5305 legion_copy_t
5306 legion_mappable_as_copy(legion_mappable_t mappable);
5307
5311 legion_fill_t
5312 legion_mappable_as_fill(legion_mappable_t mappable);
5313
5317 legion_inline_t
5318 legion_mappable_as_inline_mapping(legion_mappable_t mappable);
5319
5320
5321 // -----------------------------------------------------------------------
5322 // Task Operations
5323 // -----------------------------------------------------------------------
5324
5328 legion_unique_id_t
5329 legion_context_get_unique_id(legion_context_t ctx);
5330
5341 legion_task_mut_t
5342 legion_task_create_empty();
5343
5349 void
5350 legion_task_destroy(legion_task_mut_t handle);
5351
5357 legion_task_t
5358 legion_task_mut_as_task(legion_task_mut_t task);
5359
5363 legion_unique_id_t
5364 legion_task_get_unique_id(legion_task_t task);
5365
5369 int
5370 legion_task_get_depth(legion_task_t task);
5371
5375 legion_mapper_id_t
5376 legion_task_get_mapper(legion_task_t task);
5377
5381 legion_mapping_tag_id_t
5382 legion_task_get_tag(legion_task_t task);
5383
5387 void
5388 legion_task_id_attach_semantic_information(legion_runtime_t runtime,
5389 legion_task_id_t task_id,
5390 legion_semantic_tag_t tag,
5391 const void *buffer,
5392 size_t size,
5393 bool is_mutable /* = false */);
5394
5398 bool
5399 legion_task_id_retrieve_semantic_information(
5400 legion_runtime_t runtime,
5401 legion_task_id_t task_id,
5402 legion_semantic_tag_t tag,
5403 const void **result,
5404 size_t *size,
5405 bool can_fail /* = false */,
5406 bool wait_until_ready /* = false */);
5407
5411 void
5412 legion_task_id_attach_name(legion_runtime_t runtime,
5413 legion_task_id_t task_id,
5414 const char *name,
5415 bool is_mutable /* = false */);
5416
5420 void
5421 legion_task_id_retrieve_name(legion_runtime_t runtime,
5422 legion_task_id_t task_id,
5423 const char **result);
5424
5428 void *
5429 legion_task_get_args(legion_task_t task);
5430
5434 void
5435 legion_task_set_args(legion_task_mut_t task, void *args);
5436
5440 size_t
5441 legion_task_get_arglen(legion_task_t task);
5442
5446 void
5447 legion_task_set_arglen(legion_task_mut_t task, size_t arglen);
5448
5452 legion_domain_t
5453 legion_task_get_index_domain(legion_task_t task);
5454
5458 legion_domain_point_t
5459 legion_task_get_index_point(legion_task_t task);
5460
5464 bool
5465 legion_task_get_is_index_space(legion_task_t task);
5466
5470 void *
5471 legion_task_get_local_args(legion_task_t task);
5472
5476 size_t
5477 legion_task_get_local_arglen(legion_task_t task);
5478
5482 unsigned
5483 legion_task_get_regions_size(legion_task_t task);
5484
5490 legion_region_requirement_t
5491 legion_task_get_requirement(legion_task_t task, unsigned idx);
5492
5496 unsigned
5497 legion_task_get_futures_size(legion_task_t task);
5498
5502 legion_future_t
5503 legion_task_get_future(legion_task_t task, unsigned idx);
5504
5508 void
5509 legion_task_add_future(legion_task_mut_t task, legion_future_t future);
5510
5514 legion_task_id_t
5515 legion_task_get_task_id(legion_task_t task);
5516
5520 legion_processor_t
5521 legion_task_get_target_proc(legion_task_t task);
5522
5526 const char *
5527 legion_task_get_name(legion_task_t task);
5528
5529 // -----------------------------------------------------------------------
5530 // Inline Operations
5531 // -----------------------------------------------------------------------
5532
5538 legion_region_requirement_t
5539 legion_inline_get_requirement(legion_inline_t inline_operation);
5540
5541 // -----------------------------------------------------------------------
5542 // Execution Constraints
5543 // -----------------------------------------------------------------------
5544
5550 legion_execution_constraint_set_t
5551 legion_execution_constraint_set_create(void);
5552
5558 void
5559 legion_execution_constraint_set_destroy(
5560 legion_execution_constraint_set_t handle);
5561
5565 void
5566 legion_execution_constraint_set_add_isa_constraint(
5567 legion_execution_constraint_set_t handle,
5568 uint64_t prop);
5569
5574 void
5575 legion_execution_constraint_set_add_processor_constraint(
5576 legion_execution_constraint_set_t handle,
5577 legion_processor_kind_t proc_kind);
5578
5583 void
5584 legion_execution_constraint_set_add_resource_constraint(
5585 legion_execution_constraint_set_t handle,
5586 legion_resource_constraint_t resource,
5587 legion_equality_kind_t eq,
5588 size_t value);
5589
5594 void
5595 legion_execution_constraint_set_add_launch_constraint(
5596 legion_execution_constraint_set_t handle,
5597 legion_launch_constraint_t kind,
5598 size_t value);
5599
5604 void
5605 legion_execution_constraint_set_add_launch_constraint_multi_dim(
5606 legion_execution_constraint_set_t handle,
5607 legion_launch_constraint_t kind,
5608 const size_t *values,
5609 int dims);
5610
5615 void
5616 legion_execution_constraint_set_add_colocation_constraint(
5617 legion_execution_constraint_set_t handle,
5618 const unsigned *indexes,
5619 size_t num_indexes,
5620 const legion_field_id_t *fields,
5621 size_t num_fields);
5622
5623 // -----------------------------------------------------------------------
5624 // Layout Constraints
5625 // -----------------------------------------------------------------------
5626
5632 legion_layout_constraint_set_t
5633 legion_layout_constraint_set_create(void);
5634
5640 void
5641 legion_layout_constraint_set_destroy(legion_layout_constraint_set_t handle);
5642
5648 legion_layout_constraint_id_t
5649 legion_layout_constraint_set_register(
5650 legion_runtime_t runtime,
5651 legion_field_space_t fspace,
5652 legion_layout_constraint_set_t handle,
5653 const char *layout_name /* = NULL */);
5654
5660 legion_layout_constraint_id_t
5661 legion_layout_constraint_set_preregister(
5662 legion_layout_constraint_set_t handle,
5663 const char *layout_name /* = NULL */);
5664
5670 void
5671 legion_layout_constraint_set_release(legion_runtime_t runtime,
5672 legion_layout_constraint_id_t handle);
5673
5678 void
5679 legion_layout_constraint_set_add_specialized_constraint(
5680 legion_layout_constraint_set_t handle,
5681 legion_specialized_constraint_t specialized,
5682 legion_reduction_op_id_t redop);
5683
5688 void
5689 legion_layout_constraint_set_add_memory_constraint(
5690 legion_layout_constraint_set_t handle,
5691 legion_memory_kind_t kind);
5692
5697 void
5698 legion_layout_constraint_set_add_field_constraint(
5699 legion_layout_constraint_set_t handle,
5700 const legion_field_id_t *fields,
5701 size_t num_fields,
5702 bool contiguous,
5703 bool inorder);
5704
5709 void
5710 legion_layout_constraint_set_add_ordering_constraint(
5711 legion_layout_constraint_set_t handle,
5712 const legion_dimension_kind_t *dims,
5713 size_t num_dims,
5714 bool contiguous);
5715
5720 void
5721 legion_layout_constraint_set_add_tiling_constraint(
5722 legion_layout_constraint_set_t handle,
5723 legion_dimension_kind_t dim,
5724 size_t value, bool tiles);
5725
5730 void
5731 legion_layout_constraint_set_add_dimension_constraint(
5732 legion_layout_constraint_set_t handle,
5733 legion_dimension_kind_t dim,
5734 legion_equality_kind_t eq,
5735 size_t value);
5736
5741 void
5742 legion_layout_constraint_set_add_alignment_constraint(
5743 legion_layout_constraint_set_t handle,
5744 legion_field_id_t field,
5745 legion_equality_kind_t eq,
5746 size_t byte_boundary);
5747
5752 void
5753 legion_layout_constraint_set_add_offset_constraint(
5754 legion_layout_constraint_set_t handle,
5755 legion_field_id_t field,
5756 size_t offset);
5757
5762 void
5763 legion_layout_constraint_set_add_pointer_constraint(
5764 legion_layout_constraint_set_t handle,
5765 legion_memory_t memory,
5766 uintptr_t ptr);
5767
5768 // -----------------------------------------------------------------------
5769 // Task Layout Constraints
5770 // -----------------------------------------------------------------------
5771
5777 legion_task_layout_constraint_set_t
5778 legion_task_layout_constraint_set_create(void);
5779
5785 void
5786 legion_task_layout_constraint_set_destroy(
5787 legion_task_layout_constraint_set_t handle);
5788
5792 void
5793 legion_task_layout_constraint_set_add_layout_constraint(
5794 legion_task_layout_constraint_set_t handle,
5795 unsigned idx,
5796 legion_layout_constraint_id_t layout);
5797
5798 // -----------------------------------------------------------------------
5799 // Start-up Operations
5800 // -----------------------------------------------------------------------
5801
5805 void
5806 legion_runtime_initialize(int *argc,
5807 char ***argv,
5808 bool filter /* = false */);
5809
5813 int
5814 legion_runtime_start(int argc,
5815 char **argv,
5816 bool background /* = false */);
5817
5821 int
5822 legion_runtime_wait_for_shutdown(void);
5823
5827 void
5828 legion_runtime_set_return_code(int return_code);
5829
5833 void
5834 legion_runtime_set_top_level_task_id(legion_task_id_t top_id);
5835
5839 size_t
5840 legion_runtime_get_maximum_dimension(void);
5841
5845 const legion_input_args_t
5846 legion_runtime_get_input_args(void);
5847
5851 void
5852 legion_runtime_add_registration_callback(
5853 legion_registration_callback_pointer_t callback);
5854
5858 legion_mapper_id_t
5859 legion_runtime_generate_library_mapper_ids(
5860 legion_runtime_t runtime,
5861 const char *library_name,
5862 size_t count);
5863
5867 void
5868 legion_runtime_replace_default_mapper(
5869 legion_runtime_t runtime,
5870 legion_mapper_t mapper,
5871 legion_processor_t proc);
5872
5876 legion_projection_id_t
5877 legion_runtime_generate_static_projection_id();
5878
5882 legion_projection_id_t
5883 legion_runtime_generate_library_projection_ids(
5884 legion_runtime_t runtime,
5885 const char *library_name,
5886 size_t count);
5887
5891 legion_sharding_id_t
5892 legion_runtime_generate_library_sharding_ids(
5893 legion_runtime_t runtime,
5894 const char *library_name,
5895 size_t count);
5896
5900 legion_reduction_op_id_t
5901 legion_runtime_generate_library_reduction_ids(
5902 legion_runtime_t runtime,
5903 const char *library_name,
5904 size_t count);
5905
5909 void
5910 legion_runtime_preregister_projection_functor(
5911 legion_projection_id_t id,
5912 bool exclusive,
5913 unsigned depth,
5914 legion_projection_functor_logical_region_t region_functor,
5915 legion_projection_functor_logical_partition_t partition_functor);
5916
5920 void
5921 legion_runtime_register_projection_functor(
5922 legion_runtime_t runtime,
5923 legion_projection_id_t id,
5924 bool exclusive,
5925 unsigned depth,
5926 legion_projection_functor_logical_region_args_t region_functor,
5927 legion_projection_functor_logical_partition_args_t partition_functor);
5928
5932 void
5933 legion_runtime_preregister_projection_functor_args(
5934 legion_projection_id_t id,
5935 bool exclusive,
5936 unsigned depth,
5937 legion_projection_functor_logical_region_args_t region_functor,
5938 legion_projection_functor_logical_partition_args_t partition_functor);
5939
5943 void
5944 legion_runtime_register_projection_functor_args(
5945 legion_runtime_t runtime,
5946 legion_projection_id_t id,
5947 bool exclusive,
5948 unsigned depth,
5949 legion_projection_functor_logical_region_t region_functor,
5950 legion_projection_functor_logical_partition_t partition_functor);
5951
5955 void
5956 legion_runtime_preregister_projection_functor_mappable(
5957 legion_projection_id_t id,
5958 bool exclusive,
5959 unsigned depth,
5960 legion_projection_functor_logical_region_mappable_t region_functor,
5961 legion_projection_functor_logical_partition_mappable_t partition_functor);
5962
5966 void
5967 legion_runtime_register_projection_functor_mappable(
5968 legion_runtime_t runtime,
5969 legion_projection_id_t id,
5970 bool exclusive,
5971 unsigned depth,
5972 legion_projection_functor_logical_region_mappable_t region_functor,
5973 legion_projection_functor_logical_partition_mappable_t partition_functor);
5974
5978 legion_task_id_t
5979 legion_runtime_generate_library_task_ids(
5980 legion_runtime_t runtime,
5981 const char *library_name,
5982 size_t count);
5983
5989 legion_task_variant_registrar_t
5990 legion_task_variant_registrar_create(
5991 legion_task_id_t tid,
5992 bool global,
5993 const char *variant_name);
5994
6000 void
6001 legion_task_variant_registrar_destroy(
6002 legion_task_variant_registrar_t registrar);
6003
6007 void
6008 legion_task_variant_registrar_set_execution_constraints(
6009 legion_task_variant_registrar_t registrar,
6010 legion_execution_constraint_set_t constraints);
6011
6015 void
6016 legion_task_variant_registrar_set_layout_constraints(
6017 legion_task_variant_registrar_t registrar,
6018 legion_task_layout_constraint_set_t constraints);
6019
6020
6027 void
6028 legion_task_variant_registrar_set_options(
6029 legion_task_variant_registrar_t registrar,
6030 legion_task_config_options_t options);
6031
6035 void
6036 legion_task_variant_registrar_set_leaf_memory_pool_bounds(
6037 legion_task_variant_registrar_t registrar,
6038 legion_memory_kind_t kind,
6039 size_t size,
6040 unsigned alignment);
6041
6045 legion_variant_id_t
6046 legion_runtime_register_task_variant_fnptr_with_registrar(
6047 legion_runtime_t runtime,
6048 legion_task_variant_registrar_t registrar,
6049 legion_task_pointer_wrapped_t wrapped_task_pointer,
6050 legion_variant_id_t variant_id,
6051 const void *userdata,
6052 size_t userlen,
6053 size_t return_type_size,
6054 bool has_return_type_size);
6055
6056
6060 legion_variant_id_t
6061 legion_runtime_preregister_task_variant_fnptr_with_registrar(
6062 legion_task_variant_registrar_t registrar,
6063 legion_task_pointer_wrapped_t wrapped_task_pointer,
6064 legion_variant_id_t variant_id,
6065 const char *task_name,
6066 const void *userdata,
6067 size_t userlen,
6068 size_t return_type_size,
6069 bool has_return_type_size);
6070
6074 legion_task_id_t
6075 legion_runtime_register_task_variant_fnptr(
6076 legion_runtime_t runtime,
6077 legion_task_id_t id /* = AUTO_GENERATE_ID */,
6078 const char *task_name /* = NULL*/,
6079 const char *variant_name /* = NULL*/,
6080 bool global,
6081 legion_execution_constraint_set_t execution_constraints,
6082 legion_task_layout_constraint_set_t layout_constraints,
6083 legion_task_config_options_t options,
6084 legion_task_pointer_wrapped_t wrapped_task_pointer,
6085 const void *userdata,
6086 size_t userlen);
6087
6091 legion_task_id_t
6092 legion_runtime_preregister_task_variant_fnptr(
6093 legion_task_id_t id /* = AUTO_GENERATE_ID */,
6094 legion_variant_id_t variant_id /* = AUTO_GENERATE_ID */,
6095 const char *task_name /* = NULL*/,
6096 const char *variant_name /* = NULL*/,
6097 legion_execution_constraint_set_t execution_constraints,
6098 legion_task_layout_constraint_set_t layout_constraints,
6099 legion_task_config_options_t options,
6100 legion_task_pointer_wrapped_t wrapped_task_pointer,
6101 const void *userdata,
6102 size_t userlen);
6103
6104#ifdef REALM_USE_LLVM
6108 legion_task_id_t
6109 legion_runtime_register_task_variant_llvmir(
6110 legion_runtime_t runtime,
6111 legion_task_id_t id /* = AUTO_GENERATE_ID */,
6112 const char *task_name /* = NULL*/,
6113 bool global,
6114 legion_execution_constraint_set_t execution_constraints,
6115 legion_task_layout_constraint_set_t layout_constraints,
6116 legion_task_config_options_t options,
6117 const char *llvmir,
6118 const char *entry_symbol,
6119 const void *userdata,
6120 size_t userlen);
6121
6125 legion_task_id_t
6126 legion_runtime_preregister_task_variant_llvmir(
6127 legion_task_id_t id /* = AUTO_GENERATE_ID */,
6128 legion_variant_id_t variant_id /* = AUTO_GENERATE_ID */,
6129 const char *task_name /* = NULL*/,
6130 legion_execution_constraint_set_t execution_constraints,
6131 legion_task_layout_constraint_set_t layout_constraints,
6132 legion_task_config_options_t options,
6133 const char *llvmir,
6134 const char *entry_symbol,
6135 const void *userdata,
6136 size_t userlen);
6137#endif
6138
6139#ifdef REALM_USE_PYTHON
6143 legion_task_id_t
6144 legion_runtime_register_task_variant_python_source(
6145 legion_runtime_t runtime,
6146 legion_task_id_t id /* = AUTO_GENERATE_ID */,
6147 const char *task_name /* = NULL*/,
6148 bool global,
6149 legion_execution_constraint_set_t execution_constraints,
6150 legion_task_layout_constraint_set_t layout_constraints,
6151 legion_task_config_options_t options,
6152 const char *module_name,
6153 const char *function_name,
6154 const void *userdata,
6155 size_t userlen);
6156
6160 legion_task_id_t
6161 legion_runtime_register_task_variant_python_source_qualname(
6162 legion_runtime_t runtime,
6163 legion_task_id_t id /* = AUTO_GENERATE_ID */,
6164 const char *task_name /* = NULL*/,
6165 bool global,
6166 legion_execution_constraint_set_t execution_constraints,
6167 legion_task_layout_constraint_set_t layout_constraints,
6168 legion_task_config_options_t options,
6169 const char *module_name,
6170 const char **function_qualname,
6171 size_t function_qualname_len,
6172 const void *userdata,
6173 size_t userlen);
6174#endif
6175
6179 void
6180 legion_task_preamble(
6181 const void *data,
6182 size_t datalen,
6183 realm_id_t proc_id,
6184 legion_task_t *taskptr,
6185 const legion_physical_region_t **regionptr,
6186 unsigned * num_regions_ptr,
6187 legion_context_t * ctxptr,
6188 legion_runtime_t * runtimeptr);
6189
6193 void
6194 legion_task_postamble(
6195 legion_runtime_t runtime,
6196 legion_context_t ctx,
6197 const void *retval,
6198 size_t retsize);
6199
6200 // -----------------------------------------------------------------------
6201 // Timing Operations
6202 // -----------------------------------------------------------------------
6203
6207 unsigned long long
6208 legion_get_current_time_in_micros(void);
6209
6213 unsigned long long
6214 legion_get_current_time_in_nanos(void);
6215
6219 legion_future_t
6220 legion_issue_timing_op_seconds(legion_runtime_t runtime,
6221 legion_context_t ctx);
6222
6226 legion_future_t
6227 legion_issue_timing_op_microseconds(legion_runtime_t runtime,
6228 legion_context_t ctx);
6229
6233 legion_future_t
6234 legion_issue_timing_op_nanoseconds(legion_runtime_t runtime,
6235 legion_context_t ctx);
6236
6237 // -----------------------------------------------------------------------
6238 // Logging Operations
6239 // -----------------------------------------------------------------------
6240
6246 legion_logger_t
6247 legion_logger_create(const char* name);
6248
6254 void
6255 legion_logger_destroy(legion_logger_t handle);
6256
6260 void
6261 legion_logger_spew(legion_logger_t handle, const char *msg);
6262
6266 void
6267 legion_logger_debug(legion_logger_t handle, const char *msg);
6268
6272 void
6273 legion_logger_info(legion_logger_t handle, const char *msg);
6274
6278 void
6279 legion_logger_print(legion_logger_t handle, const char *msg);
6280
6284 void
6285 legion_logger_warning(legion_logger_t handle, const char *msg);
6286
6290 void
6291 legion_logger_error(legion_logger_t handle, const char *msg);
6292
6296 void
6297 legion_logger_fatal(legion_logger_t handle, const char *msg);
6298
6302 bool
6303 legion_logger_want_spew(legion_logger_t handle);
6304
6308 bool
6309 legion_logger_want_debug(legion_logger_t handle);
6310
6314 bool
6315 legion_logger_want_info(legion_logger_t handle);
6316
6320 bool
6321 legion_logger_want_print(legion_logger_t handle);
6322
6326 bool
6327 legion_logger_want_warning(legion_logger_t handle);
6328
6332 bool
6333 legion_logger_want_error(legion_logger_t handle);
6334
6338 bool
6339 legion_logger_want_fatal(legion_logger_t handle);
6340
6341 // -----------------------------------------------------------------------
6342 // Machine Operations
6343 // -----------------------------------------------------------------------
6344
6350 legion_machine_t
6351 legion_machine_create(void);
6352
6358 void
6359 legion_machine_destroy(legion_machine_t handle);
6360
6364 void
6365 legion_machine_get_all_processors(
6366 legion_machine_t machine,
6367 legion_processor_t *processors,
6368 size_t processors_size);
6369
6373 size_t
6374 legion_machine_get_all_processors_size(legion_machine_t machine);
6375
6379 void
6380 legion_machine_get_all_memories(
6381 legion_machine_t machine,
6382 legion_memory_t *memories,
6383 size_t memories_size);
6384
6388 size_t
6389 legion_machine_get_all_memories_size(legion_machine_t machine);
6390
6391 // -----------------------------------------------------------------------
6392 // Processor Operations
6393 // -----------------------------------------------------------------------
6394
6398 legion_processor_kind_t
6399 legion_processor_kind(legion_processor_t proc);
6400
6404 legion_address_space_t
6405 legion_processor_address_space(legion_processor_t proc);
6406
6407 // -----------------------------------------------------------------------
6408 // Memory Operations
6409 // -----------------------------------------------------------------------
6410
6414 legion_memory_kind_t
6415 legion_memory_kind(legion_memory_t mem);
6416
6420 legion_address_space_t
6421 legion_memory_address_space(legion_memory_t mem);
6422
6423 // -----------------------------------------------------------------------
6424 // Processor Query Operations
6425 // -----------------------------------------------------------------------
6426
6432 legion_processor_query_t
6433 legion_processor_query_create(legion_machine_t machine);
6434
6440 legion_processor_query_t
6441 legion_processor_query_create_copy(legion_processor_query_t query);
6442
6448 void
6449 legion_processor_query_destroy(legion_processor_query_t handle);
6450
6456 void
6457 legion_processor_query_only_kind(legion_processor_query_t query,
6458 legion_processor_kind_t kind);
6459
6465 void
6466 legion_processor_query_local_address_space(legion_processor_query_t query);
6467
6473 void
6474 legion_processor_query_same_address_space_as_processor(legion_processor_query_t query,
6475 legion_processor_t proc);
6476
6482 void
6483 legion_processor_query_same_address_space_as_memory(legion_processor_query_t query,
6484 legion_memory_t mem);
6485
6491 void
6492 legion_processor_query_has_affinity_to_memory(legion_processor_query_t query,
6493 legion_memory_t mem,
6494 unsigned min_bandwidth /* = 0 */,
6495 unsigned max_latency /* = 0 */);
6496
6502 void
6503 legion_processor_query_best_affinity_to_memory(legion_processor_query_t query,
6504 legion_memory_t mem,
6505 int bandwidth_weight /* = 0 */,
6506 int latency_weight /* = 0 */);
6507
6511 size_t
6512 legion_processor_query_count(legion_processor_query_t query);
6513
6517 legion_processor_t
6518 legion_processor_query_first(legion_processor_query_t query);
6519
6523 legion_processor_t
6524 legion_processor_query_next(legion_processor_query_t query,
6525 legion_processor_t after);
6526
6530 legion_processor_t
6531 legion_processor_query_random(legion_processor_query_t query);
6532
6533 // -----------------------------------------------------------------------
6534 // Memory Query Operations
6535 // -----------------------------------------------------------------------
6536
6542 legion_memory_query_t
6543 legion_memory_query_create(legion_machine_t machine);
6544
6550 legion_memory_query_t
6551 legion_memory_query_create_copy(legion_memory_query_t query);
6552
6558 void
6559 legion_memory_query_destroy(legion_memory_query_t handle);
6560
6566 void
6567 legion_memory_query_only_kind(legion_memory_query_t query,
6568 legion_memory_kind_t kind);
6569
6575 void
6576 legion_memory_query_local_address_space(legion_memory_query_t query);
6577
6583 void
6584 legion_memory_query_same_address_space_as_processor(legion_memory_query_t query,
6585 legion_processor_t proc);
6586
6592 void
6593 legion_memory_query_same_address_space_as_memory(legion_memory_query_t query,
6594 legion_memory_t mem);
6595
6601 void
6602 legion_memory_query_has_affinity_to_processor(legion_memory_query_t query,
6603 legion_processor_t proc,
6604 unsigned min_bandwidth /* = 0 */,
6605 unsigned max_latency /* = 0 */);
6606
6612 void
6613 legion_memory_query_has_affinity_to_memory(legion_memory_query_t query,
6614 legion_memory_t mem,
6615 unsigned min_bandwidth /* = 0 */,
6616 unsigned max_latency /* = 0 */);
6617
6623 void
6624 legion_memory_query_best_affinity_to_processor(legion_memory_query_t query,
6625 legion_processor_t proc,
6626 int bandwidth_weight /* = 0 */,
6627 int latency_weight /* = 0 */);
6628
6634 void
6635 legion_memory_query_best_affinity_to_memory(legion_memory_query_t query,
6636 legion_memory_t mem,
6637 int bandwidth_weight /* = 0 */,
6638 int latency_weight /* = 0 */);
6639
6643 size_t
6644 legion_memory_query_count(legion_memory_query_t query);
6645
6649 legion_memory_t
6650 legion_memory_query_first(legion_memory_query_t query);
6651
6655 legion_memory_t
6656 legion_memory_query_next(legion_memory_query_t query,
6657 legion_memory_t after);
6658
6662 legion_memory_t
6663 legion_memory_query_random(legion_memory_query_t query);
6664
6665 // -----------------------------------------------------------------------
6666 // Physical Instance Operations
6667 // -----------------------------------------------------------------------
6668
6669 /*
6670 * @param instance Caller must have ownership of parameter `instance`.
6671 *
6672 * @see Legion::Mapping::PhysicalInstance
6673 */
6674 void
6675 legion_physical_instance_destroy(legion_physical_instance_t instance);
6676
6677 // -----------------------------------------------------------------------
6678 // Slice Task Output
6679 // -----------------------------------------------------------------------
6680
6684 void
6685 legion_slice_task_output_slices_add(
6686 legion_slice_task_output_t output,
6687 legion_task_slice_t slice);
6688
6692 void
6693 legion_slice_task_output_verify_correctness_set(
6694 legion_slice_task_output_t output,
6695 bool verify_correctness);
6696
6697 // -----------------------------------------------------------------------
6698 // Map Task Input/Output
6699 // -----------------------------------------------------------------------
6700
6704 void
6705 legion_map_task_output_chosen_instances_clear_all(
6706 legion_map_task_output_t output);
6707
6711 void
6712 legion_map_task_output_chosen_instances_clear_each(
6713 legion_map_task_output_t output,
6714 size_t idx);
6715
6719 void
6720 legion_map_task_output_chosen_instances_add(
6721 legion_map_task_output_t output,
6722 legion_physical_instance_t *instances,
6723 size_t instances_size);
6724
6728 void
6729 legion_map_task_output_chosen_instances_set(
6730 legion_map_task_output_t output,
6731 size_t idx,
6732 legion_physical_instance_t *instances,
6733 size_t instances_size);
6734
6738 void
6739 legion_map_task_output_target_procs_clear(
6740 legion_map_task_output_t output);
6741
6745 void
6746 legion_map_task_output_target_procs_add(
6747 legion_map_task_output_t output,
6748 legion_processor_t proc);
6749
6753 legion_processor_t
6754 legion_map_task_output_target_procs_get(
6755 legion_map_task_output_t output,
6756 size_t idx);
6757
6761 void
6762 legion_map_task_output_task_priority_set(
6763 legion_map_task_output_t output,
6764 legion_task_priority_t priority);
6765
6766 // -----------------------------------------------------------------------
6767 // MapperRuntime Operations
6768 // -----------------------------------------------------------------------
6769
6775 bool
6776 legion_mapper_runtime_create_physical_instance_layout_constraint(
6777 legion_mapper_runtime_t runtime,
6778 legion_mapper_context_t ctx,
6779 legion_memory_t target_memory,
6780 legion_layout_constraint_set_t constraints,
6781 const legion_logical_region_t *regions,
6782 size_t regions_size,
6783 legion_physical_instance_t *result,
6784 bool acquire,
6785 legion_garbage_collection_priority_t priority);
6786
6792 bool
6793 legion_mapper_runtime_create_physical_instance_layout_constraint_id(
6794 legion_mapper_runtime_t runtime,
6795 legion_mapper_context_t ctx,
6796 legion_memory_t target_memory,
6797 legion_layout_constraint_id_t layout_id,
6798 const legion_logical_region_t *regions,
6799 size_t regions_size,
6800 legion_physical_instance_t *result,
6801 bool acquire,
6802 legion_garbage_collection_priority_t priority);
6803
6809 bool
6810 legion_mapper_runtime_find_or_create_physical_instance_layout_constraint(
6811 legion_mapper_runtime_t runtime,
6812 legion_mapper_context_t ctx,
6813 legion_memory_t target_memory,
6814 legion_layout_constraint_set_t constraints,
6815 const legion_logical_region_t *regions,
6816 size_t regions_size,
6817 legion_physical_instance_t *result,
6818 bool *created,
6819 bool acquire,
6820 legion_garbage_collection_priority_t priority,
6821 bool tight_region_bounds);
6822
6828 bool
6829 legion_mapper_runtime_find_or_create_physical_instance_layout_constraint_id(
6830 legion_mapper_runtime_t runtime,
6831 legion_mapper_context_t ctx,
6832 legion_memory_t target_memory,
6833 legion_layout_constraint_id_t layout_id,
6834 const legion_logical_region_t *regions,
6835 size_t regions_size,
6836 legion_physical_instance_t *result,
6837 bool *created,
6838 bool acquire,
6839 legion_garbage_collection_priority_t priority,
6840 bool tight_region_bounds);
6841
6847 bool
6848 legion_mapper_runtime_find_physical_instance_layout_constraint(
6849 legion_mapper_runtime_t runtime,
6850 legion_mapper_context_t ctx,
6851 legion_memory_t target_memory,
6852 legion_layout_constraint_set_t constraints,
6853 const legion_logical_region_t *regions,
6854 size_t regions_size,
6855 legion_physical_instance_t *result,
6856 bool acquire,
6857 bool tight_region_bounds);
6858
6864 bool
6865 legion_mapper_runtime_find_physical_instance_layout_constraint_id(
6866 legion_mapper_runtime_t runtime,
6867 legion_mapper_context_t ctx,
6868 legion_memory_t target_memory,
6869 legion_layout_constraint_id_t layout_id,
6870 const legion_logical_region_t *regions,
6871 size_t regions_size,
6872 legion_physical_instance_t *result,
6873 bool acquire,
6874 bool tight_region_bounds);
6875
6876
6882 bool
6883 legion_mapper_runtime_acquire_instance(
6884 legion_mapper_runtime_t runtime,
6885 legion_mapper_context_t ctx,
6886 legion_physical_instance_t instance);
6887
6893 bool
6894 legion_mapper_runtime_acquire_instances(
6895 legion_mapper_runtime_t runtime,
6896 legion_mapper_context_t ctx,
6897 legion_physical_instance_t *instances,
6898 size_t instances_size);
6899
6900 // A hidden method here that hopefully nobody sees or ever needs
6901 // to use but its here anyway just in case
6902 legion_shard_id_t
6903 legion_context_get_shard_id(legion_runtime_t /*runtime*/,
6904 legion_context_t /*context*/,
6905 bool /*I know what I am doing*/);
6906 // Another hidden method for getting the number of shards
6907 size_t
6908 legion_context_get_num_shards(legion_runtime_t /*runtime*/,
6909 legion_context_t /*context*/,
6910 bool /*I know what I am doing*/);
6911 // Another hidden method for control replication that most
6912 // people should not be using but for which there are legitamite
6913 // user, especially in garbage collected languages
6914 // Note the caller takes ownership of the future
6915 legion_future_t
6916 legion_context_consensus_match(legion_runtime_t /*runtime*/,
6917 legion_context_t /*context*/,
6918 const void* /*input*/,
6919 void* /*output*/,
6920 size_t /*num elements*/,
6921 size_t /*element size*/);
6922
6926 legion_physical_region_t
6927 legion_get_physical_region_by_id(
6928 legion_physical_region_t *regionptr,
6929 int id,
6930 int num_regions);
6931#ifdef __cplusplus
6932}
6933#endif
6934
6935#endif // __LEGION_C_H__
legion_task_launcher_set_point
void legion_task_launcher_set_point(legion_task_launcher_t launcher, legion_domain_point_t point)
legion_index_space_destroy_unordered
void legion_index_space_destroy_unordered(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t handle, bool unordered)
legion_index_partition_retrieve_semantic_information
bool legion_index_partition_retrieve_semantic_information(legion_runtime_t runtime, legion_index_partition_t handle, legion_semantic_tag_t tag, const void **result, size_t *size, bool can_fail, bool wait_until_ready)
legion_runtime_get_maximum_dimension
size_t legion_runtime_get_maximum_dimension(void)
legion_inline_launcher_destroy
void legion_inline_launcher_destroy(legion_inline_launcher_t handle)
legion_domain_point_coloring_create
legion_domain_point_coloring_t legion_domain_point_coloring_create(void)
legion_index_space_create_future
legion_index_space_t legion_index_space_create_future(legion_runtime_t runtime, legion_context_t ctx, size_t dimensions, legion_future_t future, legion_type_tag_t type_tag)
legion_predicate_false
const legion_predicate_t legion_predicate_false(void)
legion_context_progress_unordered_operations
void legion_context_progress_unordered_operations(legion_runtime_t runtime, legion_context_t ctx)
legion_layout_constraint_set_register
legion_layout_constraint_id_t legion_layout_constraint_set_register(legion_runtime_t runtime, legion_field_space_t fspace, legion_layout_constraint_set_t handle, const char *layout_name)
legion_sharding_functor_shard
legion_shard_id_t legion_sharding_functor_shard(legion_sharding_id_t sid, legion_domain_point_t point, legion_domain_t full_space, size_t total_shards)
legion_runtime_replace_default_mapper
void legion_runtime_replace_default_mapper(legion_runtime_t runtime, legion_mapper_t mapper, legion_processor_t proc)
legion_index_partition_create_index_space_difference
legion_index_space_t legion_index_partition_create_index_space_difference(legion_runtime_t runtime, legion_context_t ctx, legion_index_partition_t parent, legion_domain_point_t color, legion_index_space_t initial, const legion_index_space_t *spaces, size_t num_spaces)
legion_index_fill_launcher_set_mapper_arg
void legion_index_fill_launcher_set_mapper_arg(legion_index_fill_launcher_t launcher, legion_untyped_buffer_t arg)
legion_task_set_arglen
void legion_task_set_arglen(legion_task_mut_t task, size_t arglen)
legion_field_id_attach_name
void legion_field_id_attach_name(legion_runtime_t runtime, legion_field_space_t handle, legion_field_id_t id, const char *name, bool is_mutable)
legion_runtime_preregister_task_variant_fnptr_with_registrar
legion_variant_id_t legion_runtime_preregister_task_variant_fnptr_with_registrar(legion_task_variant_registrar_t registrar, legion_task_pointer_wrapped_t wrapped_task_pointer, legion_variant_id_t variant_id, const char *task_name, const void *userdata, size_t userlen, size_t return_type_size, bool has_return_type_size)
legion_region_requirement_get_privilege_fields_size
unsigned legion_region_requirement_get_privilege_fields_size(legion_region_requirement_t handle)
legion_processor_query_same_address_space_as_processor
void legion_processor_query_same_address_space_as_processor(legion_processor_query_t query, legion_processor_t proc)
legion_task_layout_constraint_set_destroy
void legion_task_layout_constraint_set_destroy(legion_task_layout_constraint_set_t handle)
legion_index_partition_create_by_preimage_range
legion_index_partition_t legion_index_partition_create_by_preimage_range(legion_runtime_t runtime, legion_context_t ctx, legion_index_partition_t projection, legion_logical_region_t handle, legion_logical_region_t parent, legion_field_id_t fid, legion_index_space_t color_space, legion_partition_kind_t part_kind, legion_color_t color, legion_mapper_id_t id, legion_mapping_tag_id_t tag, legion_untyped_buffer_t map_arg)
legion_index_partition_create_by_intersection
legion_index_partition_t legion_index_partition_create_by_intersection(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t parent, legion_index_partition_t handle1, legion_index_partition_t handle2, legion_index_space_t color_space, legion_partition_kind_t part_kind, legion_color_t color)
legion_projection_functor_logical_region_mappable_t
legion_logical_region_t(* legion_projection_functor_logical_region_mappable_t)(legion_runtime_t, legion_mappable_t, unsigned, legion_logical_region_t, legion_domain_point_t)
Definition legion_c.h:456
legion_task_get_name
const char * legion_task_get_name(legion_task_t task)
legion_index_copy_launcher_add_dst_region_requirement_logical_region_reduction
unsigned legion_index_copy_launcher_add_dst_region_requirement_logical_region_reduction(legion_index_copy_launcher_t launcher, legion_logical_region_t handle, legion_projection_id_t proj, legion_reduction_op_id_t redop, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_runtime_start
int legion_runtime_start(int argc, char **argv, bool background)
legion_memory_query_random
legion_memory_t legion_memory_query_random(legion_memory_query_t query)
legion_index_fill_launcher_create_with_domain
legion_index_fill_launcher_t legion_index_fill_launcher_create_with_domain(legion_domain_t domain, legion_logical_partition_t handle, legion_logical_region_t parent, legion_field_id_t fid, const void *value, size_t value_size, legion_projection_id_t proj, legion_predicate_t pred, legion_mapper_id_t id, legion_mapping_tag_id_t launcher_tag)
legion_index_fill_launcher_create_from_future_with_domain
legion_index_fill_launcher_t legion_index_fill_launcher_create_from_future_with_domain(legion_domain_t domain, legion_logical_partition_t handle, legion_logical_region_t parent, legion_field_id_t fid, legion_future_t future, legion_projection_id_t proj, legion_predicate_t pred, legion_mapper_id_t id, legion_mapping_tag_id_t launcher_tag)
legion_runtime_fill_field
void legion_runtime_fill_field(legion_runtime_t runtime, legion_context_t ctx, legion_logical_region_t handle, legion_logical_region_t parent, legion_field_id_t fid, const void *value, size_t value_size, legion_predicate_t pred)
legion_task_variant_registrar_destroy
void legion_task_variant_registrar_destroy(legion_task_variant_registrar_t registrar)
legion_runtime_index_fill_field_future
void legion_runtime_index_fill_field_future(legion_runtime_t runtime, legion_context_t ctx, legion_logical_partition_t handle, legion_logical_region_t parent, legion_field_id_t fid, legion_future_t f, legion_projection_id_t proj, legion_predicate_t pred, legion_mapper_id_t id, legion_mapping_tag_id_t launcher_tag)
legion_index_attach_launcher_attach_array_soa
void legion_index_attach_launcher_attach_array_soa(legion_index_attach_launcher_t handle, legion_logical_region_t region, void *base_ptr, bool column_major, const legion_field_id_t *fields, size_t num_fields, legion_memory_t memory)
legion_field_space_retrieve_name
void legion_field_space_retrieve_name(legion_runtime_t runtime, legion_field_space_t handle, const char **result)
legion_index_partition_get_index_subspace
legion_index_space_t legion_index_partition_get_index_subspace(legion_runtime_t runtime, legion_index_partition_t handle, legion_color_t color)
legion_processor_query_only_kind
void legion_processor_query_only_kind(legion_processor_query_t query, legion_processor_kind_t kind)
legion_index_launcher_execute
legion_future_map_t legion_index_launcher_execute(legion_runtime_t runtime, legion_context_t ctx, legion_index_launcher_t launcher)
legion_coloring_create
legion_coloring_t legion_coloring_create(void)
legion_must_epoch_launcher_add_single_task
void legion_must_epoch_launcher_add_single_task(legion_must_epoch_launcher_t launcher, legion_domain_point_t point, legion_task_launcher_t handle)
legion_domain_point_coloring_color_domain
void legion_domain_point_coloring_color_domain(legion_domain_point_coloring_t handle, legion_domain_point_t color, legion_domain_t domain)
legion_index_copy_launcher_add_src_indirect_region_requirement_logical_partition
unsigned legion_index_copy_launcher_add_src_indirect_region_requirement_logical_partition(legion_index_copy_launcher_t launcher, legion_logical_partition_t handle, legion_projection_id_t proj, legion_field_id_t fid, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool is_range_indirection, bool verified)
legion_acquire_launcher_destroy
void legion_acquire_launcher_destroy(legion_acquire_launcher_t handle)
legion_index_partition_attach_semantic_information
void legion_index_partition_attach_semantic_information(legion_runtime_t runtime, legion_index_partition_t handle, legion_semantic_tag_t tag, const void *buffer, size_t size, bool is_mutable)
legion_release_launcher_set_provenance
void legion_release_launcher_set_provenance(legion_release_launcher_t launcher, const char *provenance)
legion_index_partition_destroy_unordered
void legion_index_partition_destroy_unordered(legion_runtime_t runtime, legion_context_t ctx, legion_index_partition_t handle, bool unordered, bool recurse)
legion_index_partition_create_by_image_range
legion_index_partition_t legion_index_partition_create_by_image_range(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t handle, legion_logical_partition_t projection, legion_logical_region_t parent, legion_field_id_t fid, legion_index_space_t color_space, legion_partition_kind_t part_kind, legion_color_t color, legion_mapper_id_t id, legion_mapping_tag_id_t tag, legion_untyped_buffer_t map_arg)
legion_inline_launcher_create_logical_region
legion_inline_launcher_t legion_inline_launcher_create_logical_region(legion_logical_region_t handle, legion_privilege_mode_t priv, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t region_tag, bool verified, legion_mapper_id_t id, legion_mapping_tag_id_t launcher_tag)
legion_index_partition_destroy
void legion_index_partition_destroy(legion_runtime_t runtime, legion_context_t ctx, legion_index_partition_t handle)
legion_runtime_yield
void legion_runtime_yield(legion_runtime_t runtime, legion_context_t ctx)
legion_index_launcher_add_field
void legion_index_launcher_add_field(legion_index_launcher_t launcher, unsigned idx, legion_field_id_t fid, bool inst)
legion_attach_launcher_create
legion_attach_launcher_t legion_attach_launcher_create(legion_logical_region_t logical_region, legion_logical_region_t parent_region, legion_external_resource_t resource)
legion_task_get_local_args
void * legion_task_get_local_args(legion_task_t task)
legion_processor_query_first
legion_processor_t legion_processor_query_first(legion_processor_query_t query)
legion_future_map_destroy
void legion_future_map_destroy(legion_future_map_t handle)
legion_index_partition_create_index_space_intersection_partition
legion_index_space_t legion_index_partition_create_index_space_intersection_partition(legion_runtime_t runtime, legion_context_t ctx, legion_index_partition_t parent, legion_domain_point_t color, legion_index_partition_t handle)
legion_task_launcher_intersect_flags
void legion_task_launcher_intersect_flags(legion_task_launcher_t launcher, unsigned idx, enum legion_region_flags_t flags)
legion_execution_constraint_set_create
legion_execution_constraint_set_t legion_execution_constraint_set_create(void)
legion_logical_region_get_color_domain_point
legion_domain_point_t legion_logical_region_get_color_domain_point(legion_runtime_t runtime_, legion_logical_region_t handle_)
legion_index_copy_launcher_add_dst_region_requirement_logical_partition
unsigned legion_index_copy_launcher_add_dst_region_requirement_logical_partition(legion_index_copy_launcher_t launcher, legion_logical_partition_t handle, legion_projection_id_t proj, legion_privilege_mode_t priv, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_field_allocator_allocate_local_field
legion_field_id_t legion_field_allocator_allocate_local_field(legion_field_allocator_t allocator, size_t field_size, legion_field_id_t desired_fieldid)
legion_domain_contains
bool legion_domain_contains(legion_domain_t d, legion_domain_point_t p)
legion_index_attach_launcher_attach_file
void legion_index_attach_launcher_attach_file(legion_index_attach_launcher_t handle, legion_logical_region_t region, const char *filename, const legion_field_id_t *fields, size_t num_fields, legion_file_mode_t mode)
legion_index_attach_launcher_set_deduplicate_across_shards
void legion_index_attach_launcher_set_deduplicate_across_shards(legion_index_attach_launcher_t handle, bool deduplicate)
legion_future_from_untyped_pointer
legion_future_t legion_future_from_untyped_pointer(legion_runtime_t runtime, const void *buffer, size_t size)
legion_logical_partition_create_by_tree
legion_logical_partition_t legion_logical_partition_create_by_tree(legion_runtime_t runtime, legion_context_t ctx, legion_index_partition_t handle, legion_field_space_t fspace, legion_region_tree_id_t tid)
legion_runtime_set_top_level_task_id
void legion_runtime_set_top_level_task_id(legion_task_id_t top_id)
legion_copy_launcher_set_mapper_arg
void legion_copy_launcher_set_mapper_arg(legion_copy_launcher_t launcher, legion_untyped_buffer_t arg)
legion_future_from_untyped_pointer_detailed
legion_future_t legion_future_from_untyped_pointer_detailed(legion_runtime_t runtime, const void *buffer, size_t size, bool take_ownership, const char *provenance, bool shard_local)
legion_index_fill_launcher_destroy
void legion_index_fill_launcher_destroy(legion_index_fill_launcher_t handle)
DESTROY_ARRAY
#define DESTROY_ARRAY(DIM)
Definition legion_c.h:5255
legion_index_launcher_add_arrival_barrier
void legion_index_launcher_add_arrival_barrier(legion_index_launcher_t launcher, legion_phase_barrier_t bar)
legion_acquire_launcher_add_arrival_barrier
void legion_acquire_launcher_add_arrival_barrier(legion_acquire_launcher_t launcher, legion_phase_barrier_t bar)
legion_region_requirement_get_privilege_field
legion_field_id_t legion_region_requirement_get_privilege_field(legion_region_requirement_t handle, unsigned idx)
legion_phase_barrier_alter_arrival_count
legion_phase_barrier_t legion_phase_barrier_alter_arrival_count(legion_runtime_t runtime, legion_context_t ctx, legion_phase_barrier_t handle, int delta)
legion_logical_region_get_parent_logical_partition
legion_logical_partition_t legion_logical_region_get_parent_logical_partition(legion_runtime_t runtime, legion_logical_region_t handle)
legion_future_get_metadata
const void * legion_future_get_metadata(legion_future_t handle, size_t *size)
legion_index_partition_create_point_coloring
legion_index_partition_t legion_index_partition_create_point_coloring(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t parent, legion_domain_t color_space, legion_point_coloring_t coloring, legion_partition_kind_t part_kind, legion_color_t color)
legion_index_space_create
legion_index_space_t legion_index_space_create(legion_runtime_t runtime, legion_context_t ctx, size_t max_num_elmts)
legion_index_launcher_add_region_requirement_logical_partition_reduction
unsigned legion_index_launcher_add_region_requirement_logical_partition_reduction(legion_index_launcher_t launcher, legion_logical_partition_t handle, legion_projection_id_t proj, legion_reduction_op_id_t redop, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_output_requirement_add_field
void legion_output_requirement_add_field(legion_output_requirement_t handle, legion_field_id_t field, bool instance)
legion_index_space_has_parent_index_partition
bool legion_index_space_has_parent_index_partition(legion_runtime_t runtime, legion_index_space_t handle)
legion_point_coloring_create
legion_point_coloring_t legion_point_coloring_create(void)
legion_output_requirement_destroy
void legion_output_requirement_destroy(legion_output_requirement_t handle)
legion_physical_region_get_field_count
size_t legion_physical_region_get_field_count(legion_physical_region_t handle)
legion_discard_launcher_execute
void legion_discard_launcher_execute(legion_runtime_t runtime, legion_context_t ctx, legion_discard_launcher_t launcher)
legion_index_copy_launcher_execute
void legion_index_copy_launcher_execute(legion_runtime_t runtime, legion_context_t ctx, legion_index_copy_launcher_t launcher)
legion_index_space_get_domain
legion_domain_t legion_index_space_get_domain(legion_runtime_t runtime, legion_index_space_t handle)
legion_field_space_no_space
legion_field_space_t legion_field_space_no_space()
legion_index_partition_create_coloring
legion_index_partition_t legion_index_partition_create_coloring(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t parent, legion_coloring_t coloring, bool disjoint, legion_color_t part_color)
legion_task_get_target_proc
legion_processor_t legion_task_get_target_proc(legion_task_t task)
legion_region_requirement_get_handle_type
legion_handle_type_t legion_region_requirement_get_handle_type(legion_region_requirement_t handle)
legion_logical_region_attach_name
void legion_logical_region_attach_name(legion_runtime_t runtime, legion_logical_region_t handle, const char *name, bool is_mutable)
legion_logger_want_print
bool legion_logger_want_print(legion_logger_t handle)
legion_task_get_unique_id
legion_unique_id_t legion_task_get_unique_id(legion_task_t task)
legion_index_partition_create_by_domain
legion_index_partition_t legion_index_partition_create_by_domain(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t parent, legion_domain_point_t *colors, legion_domain_t *domains, size_t num_color_domains, legion_index_space_t color_space, bool perform_intersections, legion_partition_kind_t part_kind, legion_color_t color)
legion_external_resources_destroy
void legion_external_resources_destroy(legion_external_resources_t handle)
legion_projection_functor_logical_partition_t
legion_logical_region_t(* legion_projection_functor_logical_partition_t)(legion_runtime_t, legion_logical_partition_t, legion_domain_point_t, legion_domain_t)
Definition legion_c.h:419
legion_external_resources_get_region
legion_physical_region_t legion_external_resources_get_region(legion_external_resources_t handle, unsigned index)
legion_region_requirement_get_prop
legion_coherence_property_t legion_region_requirement_get_prop(legion_region_requirement_t handle)
legion_copy_launcher_destroy
void legion_copy_launcher_destroy(legion_copy_launcher_t handle)
legion_layout_constraint_set_add_specialized_constraint
void legion_layout_constraint_set_add_specialized_constraint(legion_layout_constraint_set_t handle, legion_specialized_constraint_t specialized, legion_reduction_op_id_t redop)
legion_region_requirement_get_instance_fields
void legion_region_requirement_get_instance_fields(legion_region_requirement_t handle, legion_field_id_t *fields, unsigned fields_size)
legion_domain_point_iterator_destroy
void legion_domain_point_iterator_destroy(legion_domain_point_iterator_t handle)
legion_logical_partition_get_logical_subregion_by_tree
legion_logical_region_t legion_logical_partition_get_logical_subregion_by_tree(legion_runtime_t runtime, legion_index_space_t handle, legion_field_space_t fspace, legion_region_tree_id_t tid)
legion_processor_query_has_affinity_to_memory
void legion_processor_query_has_affinity_to_memory(legion_processor_query_t query, legion_memory_t mem, unsigned min_bandwidth, unsigned max_latency)
legion_layout_constraint_set_add_tiling_constraint
void legion_layout_constraint_set_add_tiling_constraint(legion_layout_constraint_set_t handle, legion_dimension_kind_t dim, size_t value, bool tiles)
legion_discard_launcher_create
legion_discard_launcher_t legion_discard_launcher_create(legion_logical_region_t handle, legion_logical_region_t parent)
legion_attach_launcher_set_restricted
void legion_attach_launcher_set_restricted(legion_attach_launcher_t handle, bool restricted)
legion_task_get_depth
int legion_task_get_depth(legion_task_t task)
legion_logger_destroy
void legion_logger_destroy(legion_logger_t handle)
legion_runtime_generate_library_projection_ids
legion_projection_id_t legion_runtime_generate_library_projection_ids(legion_runtime_t runtime, const char *library_name, size_t count)
legion_index_launcher_add_region_requirement_logical_region_reduction
unsigned legion_index_launcher_add_region_requirement_logical_region_reduction(legion_index_launcher_t launcher, legion_logical_region_t handle, legion_projection_id_t proj, legion_reduction_op_id_t redop, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_memory_query_has_affinity_to_processor
void legion_memory_query_has_affinity_to_processor(legion_memory_query_t query, legion_processor_t proc, unsigned min_bandwidth, unsigned max_latency)
legion_index_space_has_multiple_domains
bool legion_index_space_has_multiple_domains(legion_runtime_t runtime, legion_index_space_t handle)
legion_index_partition_create_domain_coloring
legion_index_partition_t legion_index_partition_create_domain_coloring(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t parent, legion_domain_t color_space, legion_domain_coloring_t coloring, bool disjoint, legion_color_t part_color)
legion_acquire_launcher_create
legion_acquire_launcher_t legion_acquire_launcher_create(legion_logical_region_t logical_region, legion_logical_region_t parent_region, legion_predicate_t pred, legion_mapper_id_t id, legion_mapping_tag_id_t tag)
legion_task_get_index_domain
legion_domain_t legion_task_get_index_domain(legion_task_t task)
legion_index_partition_is_disjoint
bool legion_index_partition_is_disjoint(legion_runtime_t runtime, legion_index_partition_t handle)
legion_memory_query_same_address_space_as_memory
void legion_memory_query_same_address_space_as_memory(legion_memory_query_t query, legion_memory_t mem)
legion_task_launcher_set_enable_inlining
void legion_task_launcher_set_enable_inlining(legion_task_launcher_t launcher, bool enable_inlining)
legion_field_allocator_free_field
void legion_field_allocator_free_field(legion_field_allocator_t allocator, legion_field_id_t fid)
legion_fill_launcher_create
legion_fill_launcher_t legion_fill_launcher_create(legion_logical_region_t handle, legion_logical_region_t parent, legion_field_id_t fid, const void *value, size_t value_size, legion_predicate_t pred, legion_mapper_id_t id, legion_mapping_tag_id_t tag)
legion_argument_map_from_future_map
legion_argument_map_t legion_argument_map_from_future_map(legion_future_map_t map)
legion_index_launcher_set_mapper_arg
void legion_index_launcher_set_mapper_arg(legion_index_launcher_t launcher, legion_untyped_buffer_t map_arg)
legion_physical_region_get_logical_region
legion_logical_region_t legion_physical_region_get_logical_region(legion_physical_region_t handle)
legion_region_requirement_create_logical_region
legion_region_requirement_t legion_region_requirement_create_logical_region(legion_logical_region_t handle, legion_privilege_mode_t priv, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_logical_region_get_color
legion_color_t legion_logical_region_get_color(legion_runtime_t runtime, legion_logical_region_t handle)
legion_execution_constraint_set_add_launch_constraint_multi_dim
void legion_execution_constraint_set_add_launch_constraint_multi_dim(legion_execution_constraint_set_t handle, legion_launch_constraint_t kind, const size_t *values, int dims)
legion_output_requirement_create
legion_output_requirement_t legion_output_requirement_create(legion_field_space_t field_space, legion_field_id_t *fields, size_t fields_size, int dim, bool global_indexing)
legion_domain_point_nil
legion_domain_point_t legion_domain_point_nil(void)
legion_domain_point_coloring_destroy
void legion_domain_point_coloring_destroy(legion_domain_point_coloring_t handle)
legion_future_is_ready_subscribe
bool legion_future_is_ready_subscribe(legion_future_t handle, bool subscribe)
legion_projection_functor_logical_region_t
legion_logical_region_t(* legion_projection_functor_logical_region_t)(legion_runtime_t, legion_logical_region_t, legion_domain_point_t, legion_domain_t)
Definition legion_c.h:408
legion_runtime_print_once
void legion_runtime_print_once(legion_runtime_t runtime, legion_context_t ctx, FILE *f, const char *message)
legion_mapper_runtime_find_or_create_physical_instance_layout_constraint
bool legion_mapper_runtime_find_or_create_physical_instance_layout_constraint(legion_mapper_runtime_t runtime, legion_mapper_context_t ctx, legion_memory_t target_memory, legion_layout_constraint_set_t constraints, const legion_logical_region_t *regions, size_t regions_size, legion_physical_instance_t *result, bool *created, bool acquire, legion_garbage_collection_priority_t priority, bool tight_region_bounds)
legion_domain_point_iterator_next
legion_domain_point_t legion_domain_point_iterator_next(legion_domain_point_iterator_t handle)
legion_field_id_attach_semantic_information
void legion_field_id_attach_semantic_information(legion_runtime_t runtime, legion_field_space_t handle, legion_field_id_t id, legion_semantic_tag_t tag, const void *buffer, size_t size, bool is_mutable)
legion_index_partition_create_by_union
legion_index_partition_t legion_index_partition_create_by_union(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t parent, legion_index_partition_t handle1, legion_index_partition_t handle2, legion_index_space_t color_space, legion_partition_kind_t part_kind, legion_color_t color)
legion_index_partition_create_by_weights
legion_index_partition_t legion_index_partition_create_by_weights(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t parent, legion_domain_point_t *colors, int *weights, size_t num_colors, legion_index_space_t color_space, size_t granularity, legion_color_t color)
legion_index_launcher_add_index_requirement
unsigned legion_index_launcher_add_index_requirement(legion_index_launcher_t launcher, legion_index_space_t handle, legion_allocate_mode_t priv, legion_index_space_t parent, bool verified)
legion_logical_region_create
legion_logical_region_t legion_logical_region_create(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t index, legion_field_space_t fields, bool task_local)
legion_projection_functor_logical_partition_args_t
legion_logical_region_t(* legion_projection_functor_logical_partition_args_t)(legion_runtime_t, legion_logical_partition_t, legion_domain_point_t, legion_domain_t, const void *, size_t)
Definition legion_c.h:443
legion_copy_launcher_add_dst_region_requirement_logical_region
unsigned legion_copy_launcher_add_dst_region_requirement_logical_region(legion_copy_launcher_t launcher, legion_logical_region_t handle, legion_privilege_mode_t priv, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_runtime_generate_library_task_ids
legion_task_id_t legion_runtime_generate_library_task_ids(legion_runtime_t runtime, const char *library_name, size_t count)
legion_dynamic_collective_create
legion_dynamic_collective_t legion_dynamic_collective_create(legion_runtime_t runtime, legion_context_t ctx, unsigned arrivals, legion_reduction_op_id_t redop, const void *init_value, size_t init_size)
legion_index_launcher_set_initial_value
void legion_index_launcher_set_initial_value(legion_index_launcher_t launcher, legion_future_t initial_value)
legion_attach_launcher_execute
legion_physical_region_t legion_attach_launcher_execute(legion_runtime_t runtime, legion_context_t ctx, legion_attach_launcher_t launcher)
legion_index_partition_create_multi_domain_point_coloring
legion_index_partition_t legion_index_partition_create_multi_domain_point_coloring(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t parent, legion_domain_t color_space, legion_multi_domain_point_coloring_t coloring, legion_partition_kind_t part_kind, legion_color_t color)
ITERATOR_DESTROY
#define ITERATOR_DESTROY(DIM)
Definition legion_c.h:681
legion_logical_region_has_parent_logical_partition
bool legion_logical_region_has_parent_logical_partition(legion_runtime_t runtime, legion_logical_region_t handle)
legion_index_partition_create_by_intersection_mirror
legion_index_partition_t legion_index_partition_create_by_intersection_mirror(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t parent, legion_index_partition_t handle, legion_partition_kind_t part_kind, legion_color_t color, bool dominates)
legion_memory_query_best_affinity_to_memory
void legion_memory_query_best_affinity_to_memory(legion_memory_query_t query, legion_memory_t mem, int bandwidth_weight, int latency_weight)
legion_machine_get_all_memories
void legion_machine_get_all_memories(legion_machine_t machine, legion_memory_t *memories, size_t memories_size)
legion_future_map_reduce_with_initial_value
legion_future_t legion_future_map_reduce_with_initial_value(legion_runtime_t runtime, legion_context_t ctx, legion_future_map_t handle, legion_reduction_op_id_t redop, bool deterministic, legion_mapper_id_t map_id, legion_mapping_tag_id_t tag, const char *provenance, legion_future_t initial_value)
legion_discard_launcher_add_field
void legion_discard_launcher_add_field(legion_discard_launcher_t handle, legion_field_id_t fid)
legion_release_launcher_add_wait_barrier
void legion_release_launcher_add_wait_barrier(legion_release_launcher_t launcher, legion_phase_barrier_t bar)
legion_dynamic_collective_defer_arrival
void legion_dynamic_collective_defer_arrival(legion_runtime_t runtime, legion_context_t ctx, legion_dynamic_collective_t handle, legion_future_t f, unsigned count)
legion_logical_partition_get_logical_subregion_by_color
legion_logical_region_t legion_logical_partition_get_logical_subregion_by_color(legion_runtime_t runtime, legion_logical_partition_t parent, legion_color_t c)
legion_task_variant_registrar_set_leaf_memory_pool_bounds
void legion_task_variant_registrar_set_leaf_memory_pool_bounds(legion_task_variant_registrar_t registrar, legion_memory_kind_t kind, size_t size, unsigned alignment)
legion_runtime_preregister_projection_functor_args
void legion_runtime_preregister_projection_functor_args(legion_projection_id_t id, bool exclusive, unsigned depth, legion_projection_functor_logical_region_args_t region_functor, legion_projection_functor_logical_partition_args_t partition_functor)
legion_runtime_remap_region
void legion_runtime_remap_region(legion_runtime_t runtime, legion_context_t ctx, legion_physical_region_t region)
legion_physical_region_is_mapped
bool legion_physical_region_is_mapped(legion_physical_region_t handle)
legion_domain_get_volume
size_t legion_domain_get_volume(legion_domain_t d)
legion_index_space_create_shared_ownership
void legion_index_space_create_shared_ownership(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t handle)
legion_runtime_generate_library_sharding_ids
legion_sharding_id_t legion_runtime_generate_library_sharding_ids(legion_runtime_t runtime, const char *library_name, size_t count)
legion_field_space_attach_semantic_information
void legion_field_space_attach_semantic_information(legion_runtime_t runtime, legion_field_space_t handle, legion_semantic_tag_t tag, const void *buffer, size_t size, bool is_mutable)
legion_must_epoch_launcher_set_provenance
void legion_must_epoch_launcher_set_provenance(legion_must_epoch_launcher_t launcher, const char *provenance)
legion_layout_constraint_set_add_memory_constraint
void legion_layout_constraint_set_add_memory_constraint(legion_layout_constraint_set_t handle, legion_memory_kind_t kind)
legion_domain_coloring_color_domain
void legion_domain_coloring_color_domain(legion_domain_coloring_t handle, legion_color_t color, legion_domain_t domain)
legion_runtime_preregister_task_variant_fnptr
legion_task_id_t legion_runtime_preregister_task_variant_fnptr(legion_task_id_t id, legion_variant_id_t variant_id, const char *task_name, const char *variant_name, legion_execution_constraint_set_t execution_constraints, legion_task_layout_constraint_set_t layout_constraints, legion_task_config_options_t options, legion_task_pointer_wrapped_t wrapped_task_pointer, const void *userdata, size_t userlen)
GET_POINT
#define GET_POINT(DIM)
Definition legion_c.h:598
legion_fill_launcher_set_point
void legion_fill_launcher_set_point(legion_fill_launcher_t launcher, legion_domain_point_t point)
legion_fill_launcher_set_provenance
void legion_fill_launcher_set_provenance(legion_fill_launcher_t launcher, const char *provenance)
legion_index_launcher_set_concurrent
void legion_index_launcher_set_concurrent(legion_index_launcher_t launcher, bool concurrent)
legion_logger_want_spew
bool legion_logger_want_spew(legion_logger_t handle)
legion_dynamic_collective_get_result
legion_future_t legion_dynamic_collective_get_result(legion_runtime_t runtime, legion_context_t ctx, legion_dynamic_collective_t handle)
legion_index_launcher_set_mapping_tag
void legion_index_launcher_set_mapping_tag(legion_index_launcher_t launcher, legion_mapping_tag_id_t tag)
legion_index_partition_has_index_subspace_domain_point
bool legion_index_partition_has_index_subspace_domain_point(legion_runtime_t runtime, legion_index_partition_t handle, legion_domain_point_t color)
legion_runtime_register_projection_functor
void legion_runtime_register_projection_functor(legion_runtime_t runtime, legion_projection_id_t id, bool exclusive, unsigned depth, legion_projection_functor_logical_region_args_t region_functor, legion_projection_functor_logical_partition_args_t partition_functor)
legion_index_fill_launcher_set_sharding_space
void legion_index_fill_launcher_set_sharding_space(legion_index_fill_launcher_t launcher, legion_index_space_t space)
legion_task_launcher_create_from_buffer
legion_task_launcher_t legion_task_launcher_create_from_buffer(legion_task_id_t tid, const void *buffer, size_t buffer_size, legion_predicate_t pred, legion_mapper_id_t id, legion_mapping_tag_id_t tag)
legion_task_launcher_set_region_requirement_logical_region
void legion_task_launcher_set_region_requirement_logical_region(legion_task_launcher_t launcher, unsigned idx, legion_logical_region_t handle, legion_privilege_mode_t priv, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_dynamic_collective_alter_arrival_count
legion_dynamic_collective_t legion_dynamic_collective_alter_arrival_count(legion_runtime_t runtime, legion_context_t ctx, legion_dynamic_collective_t handle, int delta)
legion_point_coloring_add_range
void legion_point_coloring_add_range(legion_point_coloring_t handle, legion_domain_point_t color, legion_ptr_t start, legion_ptr_t end)
legion_copy_launcher_create
legion_copy_launcher_t legion_copy_launcher_create(legion_predicate_t pred, legion_mapper_id_t id, legion_mapping_tag_id_t launcher_tag)
legion_machine_destroy
void legion_machine_destroy(legion_machine_t handle)
legion_runtime_index_fill_field_future_with_space
void legion_runtime_index_fill_field_future_with_space(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t space, legion_logical_partition_t handle, legion_logical_region_t parent, legion_field_id_t fid, legion_future_t f, legion_projection_id_t proj, legion_predicate_t pred, legion_mapper_id_t id, legion_mapping_tag_id_t launcher_tag)
legion_runtime_issue_execution_fence
legion_future_t legion_runtime_issue_execution_fence(legion_runtime_t runtime, legion_context_t ctx)
legion_index_partition_create_equal
legion_index_partition_t legion_index_partition_create_equal(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t parent, legion_index_space_t color_space, size_t granularity, legion_color_t color)
legion_index_space_subtraction
legion_index_space_t legion_index_space_subtraction(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t left, legion_index_space_t right)
legion_index_partition_create_index_space_intersection_spaces
legion_index_space_t legion_index_partition_create_index_space_intersection_spaces(legion_runtime_t runtime, legion_context_t ctx, legion_index_partition_t parent, legion_domain_point_t color, const legion_index_space_t *spaces, size_t num_spaces)
legion_domain_from_index_space
legion_domain_t legion_domain_from_index_space(legion_runtime_t runtime, legion_index_space_t is)
legion_index_copy_launcher_add_src_field
void legion_index_copy_launcher_add_src_field(legion_index_copy_launcher_t launcher, unsigned idx, legion_field_id_t fid, bool inst)
legion_runtime_preregister_projection_functor_mappable
void legion_runtime_preregister_projection_functor_mappable(legion_projection_id_t id, bool exclusive, unsigned depth, legion_projection_functor_logical_region_mappable_t region_functor, legion_projection_functor_logical_partition_mappable_t partition_functor)
legion_task_get_is_index_space
bool legion_task_get_is_index_space(legion_task_t task)
legion_domain_coloring_get_color_space
legion_domain_t legion_domain_coloring_get_color_space(legion_domain_coloring_t handle)
legion_mappable_get_type
enum legion_mappable_type_id_t legion_mappable_get_type(legion_mappable_t mappable)
legion_index_launcher_set_region_requirement_logical_partition
void legion_index_launcher_set_region_requirement_logical_partition(legion_index_launcher_t launcher, unsigned idx, legion_logical_partition_t handle, legion_projection_id_t proj, legion_privilege_mode_t priv, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_get_current_time_in_micros
unsigned long long legion_get_current_time_in_micros(void)
legion_index_partition_create_by_image
legion_index_partition_t legion_index_partition_create_by_image(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t handle, legion_logical_partition_t projection, legion_logical_region_t parent, legion_field_id_t fid, legion_index_space_t color_space, legion_partition_kind_t part_kind, legion_color_t color, legion_mapper_id_t id, legion_mapping_tag_id_t tag, legion_untyped_buffer_t map_arg)
legion_task_variant_registrar_create
legion_task_variant_registrar_t legion_task_variant_registrar_create(legion_task_id_t tid, bool global, const char *variant_name)
legion_logger_fatal
void legion_logger_fatal(legion_logger_t handle, const char *msg)
legion_copy_launcher_set_provenance
void legion_copy_launcher_set_provenance(legion_copy_launcher_t launcher, const char *provenance)
legion_index_attach_launcher_set_restricted
void legion_index_attach_launcher_set_restricted(legion_index_attach_launcher_t handle, bool restricted)
legion_region_requirement_add_flags
void legion_region_requirement_add_flags(legion_region_requirement_t handle, legion_region_flags_t flags)
legion_task_add_future
void legion_task_add_future(legion_task_mut_t task, legion_future_t future)
legion_region_requirement_get_tag
legion_mapping_tag_id_t legion_region_requirement_get_tag(legion_region_requirement_t handle)
legion_slice_task_output_verify_correctness_set
void legion_slice_task_output_verify_correctness_set(legion_slice_task_output_t output, bool verify_correctness)
legion_future_map_copy
legion_future_map_t legion_future_map_copy(legion_future_map_t handle)
legion_runtime_wait_for_shutdown
int legion_runtime_wait_for_shutdown(void)
legion_layout_constraint_set_destroy
void legion_layout_constraint_set_destroy(legion_layout_constraint_set_t handle)
legion_index_attach_launcher_set_provenance
void legion_index_attach_launcher_set_provenance(legion_index_attach_launcher_t handle, const char *provenance)
legion_future_map_transform
legion_future_map_t legion_future_map_transform(legion_runtime_t runtime, legion_context_t ctx, legion_future_map_t fm, legion_index_space_t new_domain, legion_point_transform_functor_t functor, bool take_ownership)
legion_attach_external_resources
legion_external_resources_t legion_attach_external_resources(legion_runtime_t runtime, legion_context_t ctx, legion_index_attach_launcher_t launcher)
legion_task_preamble
void legion_task_preamble(const void *data, size_t datalen, realm_id_t proc_id, legion_task_t *taskptr, const legion_physical_region_t **regionptr, unsigned *num_regions_ptr, legion_context_t *ctxptr, legion_runtime_t *runtimeptr)
legion_index_launcher_add_point_future
void legion_index_launcher_add_point_future(legion_index_launcher_t launcher, legion_argument_map_t map)
ITERATOR_STEP
#define ITERATOR_STEP(DIM)
Definition legion_c.h:699
legion_map_task_output_chosen_instances_clear_all
void legion_map_task_output_chosen_instances_clear_all(legion_map_task_output_t output)
legion_task_get_requirement
legion_region_requirement_t legion_task_get_requirement(legion_task_t task, unsigned idx)
legion_index_launcher_add_region_requirement_logical_partition
unsigned legion_index_launcher_add_region_requirement_logical_partition(legion_index_launcher_t launcher, legion_logical_partition_t handle, legion_projection_id_t proj, legion_privilege_mode_t priv, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_map_task_output_chosen_instances_add
void legion_map_task_output_chosen_instances_add(legion_map_task_output_t output, legion_physical_instance_t *instances, size_t instances_size)
legion_predicate_create
legion_predicate_t legion_predicate_create(legion_runtime_t runtime, legion_context_t ctx, legion_future_t f)
legion_task_id_attach_semantic_information
void legion_task_id_attach_semantic_information(legion_runtime_t runtime, legion_task_id_t task_id, legion_semantic_tag_t tag, const void *buffer, size_t size, bool is_mutable)
legion_context_destroy
void legion_context_destroy(legion_context_t)
legion_memory_query_has_affinity_to_memory
void legion_memory_query_has_affinity_to_memory(legion_memory_query_t query, legion_memory_t mem, unsigned min_bandwidth, unsigned max_latency)
legion_map_task_output_target_procs_add
void legion_map_task_output_target_procs_add(legion_map_task_output_t output, legion_processor_t proc)
legion_task_id_retrieve_name
void legion_task_id_retrieve_name(legion_runtime_t runtime, legion_task_id_t task_id, const char **result)
legion_copy_launcher_add_dst_field
void legion_copy_launcher_add_dst_field(legion_copy_launcher_t launcher, unsigned idx, legion_field_id_t fid, bool inst)
legion_runtime_index_fill_field_with_domain
void legion_runtime_index_fill_field_with_domain(legion_runtime_t runtime, legion_context_t ctx, legion_domain_t domain, legion_logical_partition_t handle, legion_logical_region_t parent, legion_field_id_t fid, const void *value, size_t value_size, legion_projection_id_t proj, legion_predicate_t pred, legion_mapper_id_t id, legion_mapping_tag_id_t launcher_tag)
legion_phase_barrier_advance
legion_phase_barrier_t legion_phase_barrier_advance(legion_runtime_t runtime, legion_context_t ctx, legion_phase_barrier_t handle)
legion_logger_debug
void legion_logger_debug(legion_logger_t handle, const char *msg)
legion_processor_address_space
legion_address_space_t legion_processor_address_space(legion_processor_t proc)
legion_task_mut_as_task
legion_task_t legion_task_mut_as_task(legion_task_mut_t task)
legion_runtime_issue_mapping_fence
legion_future_t legion_runtime_issue_mapping_fence(legion_runtime_t runtime, legion_context_t ctx)
legion_output_requirement_create_region_requirement
legion_output_requirement_t legion_output_requirement_create_region_requirement(legion_region_requirement_t handle)
legion_fill_launcher_execute
void legion_fill_launcher_execute(legion_runtime_t runtime, legion_context_t ctx, legion_fill_launcher_t launcher)
legion_logical_partition_get_logical_subregion_by_color_domain_point
legion_logical_region_t legion_logical_partition_get_logical_subregion_by_color_domain_point(legion_runtime_t runtime, legion_logical_partition_t parent, legion_domain_point_t c)
legion_index_partition_retrieve_name
void legion_index_partition_retrieve_name(legion_runtime_t runtime, legion_index_partition_t handle, const char **result)
legion_map_task_output_target_procs_get
legion_processor_t legion_map_task_output_target_procs_get(legion_map_task_output_t output, size_t idx)
legion_region_requirement_get_privilege_fields
void legion_region_requirement_get_privilege_fields(legion_region_requirement_t handle, legion_field_id_t *fields, unsigned fields_size)
legion_coloring_has_point
bool legion_coloring_has_point(legion_coloring_t handle, legion_color_t color, legion_ptr_t point)
legion_attach_launcher_add_cpu_soa_field
void legion_attach_launcher_add_cpu_soa_field(legion_attach_launcher_t launcher, legion_field_id_t fid, void *base_ptr, bool column_major)
legion_index_copy_launcher_add_wait_barrier
void legion_index_copy_launcher_add_wait_barrier(legion_index_copy_launcher_t launcher, legion_phase_barrier_t bar)
legion_mappable_as_fill
legion_fill_t legion_mappable_as_fill(legion_mappable_t mappable)
legion_index_copy_launcher_set_sharding_space
void legion_index_copy_launcher_set_sharding_space(legion_index_copy_launcher_t launcher, legion_index_space_t is)
legion_task_variant_registrar_set_layout_constraints
void legion_task_variant_registrar_set_layout_constraints(legion_task_variant_registrar_t registrar, legion_task_layout_constraint_set_t constraints)
legion_task_pointer_wrapped_t
realm_task_pointer_t legion_task_pointer_wrapped_t
Definition legion_c.h:401
legion_field_space_create_with_futures
legion_field_space_t legion_field_space_create_with_futures(legion_runtime_t runtime, legion_context_t ctx, legion_future_t *field_sizes, legion_field_id_t *field_ids, size_t num_fields, legion_custom_serdez_id_t serdez)
legion_attach_launcher_set_provenance
void legion_attach_launcher_set_provenance(legion_attach_launcher_t handle, const char *provenance)
legion_task_launcher_add_index_requirement
unsigned legion_task_launcher_add_index_requirement(legion_task_launcher_t launcher, legion_index_space_t handle, legion_allocate_mode_t priv, legion_index_space_t parent, bool verified)
legion_fill_launcher_destroy
void legion_fill_launcher_destroy(legion_fill_launcher_t handle)
legion_logical_region_destroy_unordered
void legion_logical_region_destroy_unordered(legion_runtime_t runtime, legion_context_t ctx, legion_logical_region_t handle, bool unordered)
legion_future_is_empty
bool legion_future_is_empty(legion_future_t handle, bool block)
legion_sharding_functor_invert
void legion_sharding_functor_invert(legion_sharding_id_t sid, legion_shard_id_t shard, legion_domain_t shard_domain, legion_domain_t full_domain, size_t total_shards, legion_domain_point_t *points, size_t *points_size)
legion_runtime_add_registration_callback
void legion_runtime_add_registration_callback(legion_registration_callback_pointer_t callback)
legion_argument_map_destroy
void legion_argument_map_destroy(legion_argument_map_t handle)
legion_index_copy_launcher_add_dst_indirect_region_requirement_logical_region
unsigned legion_index_copy_launcher_add_dst_indirect_region_requirement_logical_region(legion_index_copy_launcher_t launcher, legion_logical_region_t handle, legion_projection_id_t proj, legion_field_id_t fid, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool is_range_indirection, bool verified)
legion_index_attach_launcher_destroy
void legion_index_attach_launcher_destroy(legion_index_attach_launcher_t handle)
legion_runtime_index_fill_field_future_with_domain
void legion_runtime_index_fill_field_future_with_domain(legion_runtime_t runtime, legion_context_t ctx, legion_domain_t domain, legion_logical_partition_t handle, legion_logical_region_t parent, legion_field_id_t fid, legion_future_t f, legion_projection_id_t proj, legion_predicate_t pred, legion_mapper_id_t id, legion_mapping_tag_id_t launcher_tag)
legion_ptr_nil
legion_ptr_t legion_ptr_nil(void)
legion_index_copy_launcher_add_dst_field
void legion_index_copy_launcher_add_dst_field(legion_index_copy_launcher_t launcher, unsigned idx, legion_field_id_t fid, bool inst)
legion_task_get_arglen
size_t legion_task_get_arglen(legion_task_t task)
legion_processor_query_create
legion_processor_query_t legion_processor_query_create(legion_machine_t machine)
legion_must_epoch_launcher_execute
legion_future_map_t legion_must_epoch_launcher_execute(legion_runtime_t runtime, legion_context_t ctx, legion_must_epoch_launcher_t launcher)
legion_projection_functor_logical_partition_mappable_t
legion_logical_region_t(* legion_projection_functor_logical_partition_mappable_t)(legion_runtime_t, legion_mappable_t, unsigned, legion_logical_partition_t, legion_domain_point_t)
Definition legion_c.h:468
legion_layout_constraint_set_preregister
legion_layout_constraint_id_t legion_layout_constraint_set_preregister(legion_layout_constraint_set_t handle, const char *layout_name)
legion_runtime_register_task_variant_fnptr_with_registrar
legion_variant_id_t legion_runtime_register_task_variant_fnptr_with_registrar(legion_runtime_t runtime, legion_task_variant_registrar_t registrar, legion_task_pointer_wrapped_t wrapped_task_pointer, legion_variant_id_t variant_id, const void *userdata, size_t userlen, size_t return_type_size, bool has_return_type_size)
legion_future_get_untyped_size
size_t legion_future_get_untyped_size(legion_future_t handle)
legion_must_epoch_launcher_add_index_task
void legion_must_epoch_launcher_add_index_task(legion_must_epoch_launcher_t launcher, legion_index_launcher_t handle)
legion_index_launcher_intersect_flags
void legion_index_launcher_intersect_flags(legion_index_launcher_t launcher, unsigned idx, enum legion_region_flags_t flags)
legion_task_launcher_set_mapper
void legion_task_launcher_set_mapper(legion_task_launcher_t launcher, legion_mapper_id_t mapper_id)
legion_memory_query_create
legion_memory_query_t legion_memory_query_create(legion_machine_t machine)
legion_logger_want_info
bool legion_logger_want_info(legion_logger_t handle)
legion_logical_region_destroy
void legion_logical_region_destroy(legion_runtime_t runtime, legion_context_t ctx, legion_logical_region_t handle)
legion_logical_partition_attach_semantic_information
void legion_logical_partition_attach_semantic_information(legion_runtime_t runtime, legion_logical_partition_t handle, legion_semantic_tag_t tag, const void *buffer, size_t size, bool is_mutable)
legion_task_get_futures_size
unsigned legion_task_get_futures_size(legion_task_t task)
legion_field_space_has_fields
bool legion_field_space_has_fields(legion_runtime_t runtime, legion_context_t ctx, legion_field_space_t handle, const legion_field_id_t *fields, size_t fields_size)
legion_slice_task_output_slices_add
void legion_slice_task_output_slices_add(legion_slice_task_output_t output, legion_task_slice_t slice)
legion_copy_launcher_add_dst_region_requirement_logical_region_reduction
unsigned legion_copy_launcher_add_dst_region_requirement_logical_region_reduction(legion_copy_launcher_t launcher, legion_logical_region_t handle, legion_reduction_op_id_t redop, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_index_launcher_set_region_requirement_logical_region
void legion_index_launcher_set_region_requirement_logical_region(legion_index_launcher_t launcher, unsigned idx, legion_logical_region_t handle, legion_projection_id_t proj, legion_privilege_mode_t priv, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_execution_constraint_set_add_resource_constraint
void legion_execution_constraint_set_add_resource_constraint(legion_execution_constraint_set_t handle, legion_resource_constraint_t resource, legion_equality_kind_t eq, size_t value)
legion_machine_get_all_processors
void legion_machine_get_all_processors(legion_machine_t machine, legion_processor_t *processors, size_t processors_size)
legion_index_launcher_execute_outputs
legion_future_map_t legion_index_launcher_execute_outputs(legion_runtime_t runtime, legion_context_t ctx, legion_index_launcher_t launcher, legion_output_requirement_t *reqs, size_t reqs_size)
legion_phase_barrier_wait
void legion_phase_barrier_wait(legion_runtime_t runtime, legion_context_t ctx, legion_phase_barrier_t handle)
BUFFER_CREATE
#define BUFFER_CREATE(DIM)
Definition legion_c.h:2890
legion_runtime_end_trace
void legion_runtime_end_trace(legion_runtime_t runtime, legion_context_t ctx, legion_trace_id_t tid)
legion_ptr_safe_cast
legion_ptr_t legion_ptr_safe_cast(legion_runtime_t runtime, legion_context_t ctx, legion_ptr_t pointer, legion_logical_region_t region)
legion_runtime_unmap_all_regions
void legion_runtime_unmap_all_regions(legion_runtime_t runtime, legion_context_t ctx)
legion_phase_barrier_create
legion_phase_barrier_t legion_phase_barrier_create(legion_runtime_t runtime, legion_context_t ctx, unsigned arrivals)
legion_future_map_construct_from_buffers
legion_future_map_t legion_future_map_construct_from_buffers(legion_runtime_t runtime, legion_context_t ctx, legion_domain_t domain, legion_domain_point_t *points, legion_untyped_buffer_t *buffers, size_t num_points, bool collective, legion_sharding_id_t sid, bool implicit_sharding)
legion_task_launcher_execute_outputs
legion_future_t legion_task_launcher_execute_outputs(legion_runtime_t runtime, legion_context_t ctx, legion_task_launcher_t launcher, legion_output_requirement_t *reqs, size_t reqs_size)
legion_mapper_runtime_create_physical_instance_layout_constraint
bool legion_mapper_runtime_create_physical_instance_layout_constraint(legion_mapper_runtime_t runtime, legion_mapper_context_t ctx, legion_memory_t target_memory, legion_layout_constraint_set_t constraints, const legion_logical_region_t *regions, size_t regions_size, legion_physical_instance_t *result, bool acquire, legion_garbage_collection_priority_t priority)
legion_flush_detach_external_resource
legion_future_t legion_flush_detach_external_resource(legion_runtime_t runtime, legion_context_t ctx, legion_physical_region_t handle, bool flush)
legion_index_launcher_create_from_buffer
legion_index_launcher_t legion_index_launcher_create_from_buffer(legion_task_id_t tid, legion_domain_t domain, const void *buffer, size_t buffer_size, legion_argument_map_t map, legion_predicate_t pred, bool must, legion_mapper_id_t id, legion_mapping_tag_id_t tag)
legion_memory_query_destroy
void legion_memory_query_destroy(legion_memory_query_t handle)
legion_release_launcher_execute
void legion_release_launcher_execute(legion_runtime_t runtime, legion_context_t ctx, legion_release_launcher_t launcher)
legion_logger_spew
void legion_logger_spew(legion_logger_t handle, const char *msg)
legion_runtime_detach_hdf5
void legion_runtime_detach_hdf5(legion_runtime_t runtime, legion_context_t ctx, legion_physical_region_t region)
legion_field_allocator_create
legion_field_allocator_t legion_field_allocator_create(legion_runtime_t runtime, legion_context_t ctx, legion_field_space_t handle)
legion_projection_functor_logical_region_args_t
legion_logical_region_t(* legion_projection_functor_logical_region_args_t)(legion_runtime_t, legion_logical_region_t, legion_domain_point_t, legion_domain_t, const void *, size_t)
Definition legion_c.h:430
legion_detach_external_resource
legion_future_t legion_detach_external_resource(legion_runtime_t runtime, legion_context_t ctx, legion_physical_region_t handle)
legion_dynamic_collective_arrive
void legion_dynamic_collective_arrive(legion_runtime_t runtime, legion_context_t ctx, legion_dynamic_collective_t handle, const void *buffer, size_t size, unsigned count)
legion_task_create_empty
legion_task_mut_t legion_task_create_empty()
legion_index_attach_launcher_attach_hdf5
void legion_index_attach_launcher_attach_hdf5(legion_index_attach_launcher_t handle, legion_logical_region_t region, const char *filename, legion_field_map_t field_map, legion_file_mode_t mode)
legion_fill_launcher_add_field
void legion_fill_launcher_add_field(legion_fill_launcher_t handle, legion_field_id_t fid)
legion_index_partition_create_index_space_union_spaces
legion_index_space_t legion_index_partition_create_index_space_union_spaces(legion_runtime_t runtime, legion_context_t ctx, legion_index_partition_t parent, legion_domain_point_t color, const legion_index_space_t *spaces, size_t num_spaces)
legion_release_launcher_add_field
void legion_release_launcher_add_field(legion_release_launcher_t launcher, legion_field_id_t fid)
legion_index_fill_launcher_add_field
void legion_index_fill_launcher_add_field(legion_fill_launcher_t handle, legion_field_id_t fid)
legion_runtime_get_input_args
const legion_input_args_t legion_runtime_get_input_args(void)
legion_future_map_get_domain
legion_domain_t legion_future_map_get_domain(legion_future_map_t handle)
legion_index_copy_launcher_destroy
void legion_index_copy_launcher_destroy(legion_index_copy_launcher_t handle)
legion_runtime_register_task_variant_fnptr
legion_task_id_t legion_runtime_register_task_variant_fnptr(legion_runtime_t runtime, legion_task_id_t id, const char *task_name, const char *variant_name, bool global, legion_execution_constraint_set_t execution_constraints, legion_task_layout_constraint_set_t layout_constraints, legion_task_config_options_t options, legion_task_pointer_wrapped_t wrapped_task_pointer, const void *userdata, size_t userlen)
legion_must_epoch_launcher_create
legion_must_epoch_launcher_t legion_must_epoch_launcher_create(legion_mapper_id_t id, legion_mapping_tag_id_t launcher_tag)
legion_index_launcher_set_global_arg
void legion_index_launcher_set_global_arg(legion_index_launcher_t launcher, legion_untyped_buffer_t global_arg)
legion_index_launcher_destroy
void legion_index_launcher_destroy(legion_index_launcher_t handle)
legion_index_copy_launcher_set_possible_dst_indirect_out_of_range
void legion_index_copy_launcher_set_possible_dst_indirect_out_of_range(legion_index_copy_launcher_t launcher, bool flag)
legion_external_resources_size
size_t legion_external_resources_size(legion_external_resources_t handle)
legion_ptr_is_null
bool legion_ptr_is_null(legion_ptr_t ptr)
legion_runtime_begin_trace
void legion_runtime_begin_trace(legion_runtime_t runtime, legion_context_t ctx, legion_trace_id_t tid, bool logical_only)
legion_release_launcher_destroy
void legion_release_launcher_destroy(legion_release_launcher_t handle)
legion_layout_constraint_set_add_field_constraint
void legion_layout_constraint_set_add_field_constraint(legion_layout_constraint_set_t handle, const legion_field_id_t *fields, size_t num_fields, bool contiguous, bool inorder)
legion_index_space_get_dim
int legion_index_space_get_dim(legion_index_space_t handle)
legion_future_get_void_result
void legion_future_get_void_result(legion_future_t handle)
legion_logical_partition_destroy
void legion_logical_partition_destroy(legion_runtime_t runtime, legion_context_t ctx, legion_logical_partition_t handle)
legion_index_copy_launcher_set_provenance
void legion_index_copy_launcher_set_provenance(legion_index_copy_launcher_t launcher, const char *provenance)
legion_memory_query_same_address_space_as_processor
void legion_memory_query_same_address_space_as_processor(legion_memory_query_t query, legion_processor_t proc)
legion_copy_launcher_add_src_indirect_region_requirement_logical_region
unsigned legion_copy_launcher_add_src_indirect_region_requirement_logical_region(legion_copy_launcher_t launcher, legion_logical_region_t handle, legion_field_id_t fid, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool is_range_indirection, bool verified)
legion_coloring_delete_point
void legion_coloring_delete_point(legion_coloring_t handle, legion_color_t color, legion_ptr_t point)
legion_field_space_create_shared_ownership
void legion_field_space_create_shared_ownership(legion_runtime_t runtime, legion_context_t ctx, legion_field_space_t handle)
legion_execution_constraint_set_add_processor_constraint
void legion_execution_constraint_set_add_processor_constraint(legion_execution_constraint_set_t handle, legion_processor_kind_t proc_kind)
legion_acquire_launcher_set_mapper_arg
void legion_acquire_launcher_set_mapper_arg(legion_acquire_launcher_t launcher, legion_untyped_buffer_t arg)
legion_inline_launcher_set_mapper_arg
void legion_inline_launcher_set_mapper_arg(legion_inline_launcher_t launcher, legion_untyped_buffer_t arg)
legion_memory_query_next
legion_memory_t legion_memory_query_next(legion_memory_query_t query, legion_memory_t after)
ITERATOR_CREATE
#define ITERATOR_CREATE(DIM)
Definition legion_c.h:670
legion_task_postamble
void legion_task_postamble(legion_runtime_t runtime, legion_context_t ctx, const void *retval, size_t retsize)
legion_future_copy
legion_future_t legion_future_copy(legion_future_t handle)
legion_processor_query_local_address_space
void legion_processor_query_local_address_space(legion_processor_query_t query)
legion_field_space_retrieve_semantic_information
bool legion_field_space_retrieve_semantic_information(legion_runtime_t runtime, legion_field_space_t handle, legion_semantic_tag_t tag, const void **result, size_t *size, bool can_fail, bool wait_until_ready)
legion_field_allocator_allocate_field
legion_field_id_t legion_field_allocator_allocate_field(legion_field_allocator_t allocator, size_t field_size, legion_field_id_t desired_fieldid)
GET_RECT
#define GET_RECT(DIM)
Definition legion_c.h:530
legion_memory_query_count
size_t legion_memory_query_count(legion_memory_query_t query)
legion_layout_constraint_set_create
legion_layout_constraint_set_t legion_layout_constraint_set_create(void)
legion_domain_coloring_create
legion_domain_coloring_t legion_domain_coloring_create(void)
legion_index_space_intersection
legion_index_space_t legion_index_space_intersection(legion_runtime_t runtime, legion_context_t ctx, const legion_index_space_t *spaces, size_t num_spaces)
legion_index_fill_launcher_create_with_space
legion_index_fill_launcher_t legion_index_fill_launcher_create_with_space(legion_index_space_t space, legion_logical_partition_t handle, legion_logical_region_t parent, legion_field_id_t fid, const void *value, size_t value_size, legion_projection_id_t proj, legion_predicate_t pred, legion_mapper_id_t id, legion_mapping_tag_id_t launcher_tag)
legion_attach_launcher_set_mapped
void legion_attach_launcher_set_mapped(legion_attach_launcher_t handle, bool mapped)
legion_layout_constraint_set_add_dimension_constraint
void legion_layout_constraint_set_add_dimension_constraint(legion_layout_constraint_set_t handle, legion_dimension_kind_t dim, legion_equality_kind_t eq, size_t value)
legion_acquire_launcher_execute
void legion_acquire_launcher_execute(legion_runtime_t runtime, legion_context_t ctx, legion_acquire_launcher_t launcher)
legion_logical_partition_destroy_unordered
void legion_logical_partition_destroy_unordered(legion_runtime_t runtime, legion_context_t ctx, legion_logical_partition_t handle, bool unordered)
legion_region_requirement_add_field
void legion_region_requirement_add_field(legion_region_requirement_t handle, legion_field_id_t field, bool instance_field)
legion_auto_generate_id
legion_field_id_t legion_auto_generate_id(void)
legion_inline_get_requirement
legion_region_requirement_t legion_inline_get_requirement(legion_inline_t inline_operation)
legion_index_launcher_set_provenance
void legion_index_launcher_set_provenance(legion_index_launcher_t launcher, const char *provenance)
legion_field_space_get_fields
legion_field_id_t * legion_field_space_get_fields(legion_runtime_t runtime, legion_context_t ctx, legion_field_space_t handle, size_t *size)
legion_index_copy_launcher_add_arrival_barrier
void legion_index_copy_launcher_add_arrival_barrier(legion_index_copy_launcher_t launcher, legion_phase_barrier_t bar)
legion_task_get_mapper
legion_mapper_id_t legion_task_get_mapper(legion_task_t task)
legion_index_partition_attach_name
void legion_index_partition_attach_name(legion_runtime_t runtime, legion_index_partition_t handle, const char *name, bool is_mutable)
legion_domain_coloring_destroy
void legion_domain_coloring_destroy(legion_domain_coloring_t handle)
ITERATOR_OP
#define ITERATOR_OP(DIM)
Definition legion_c.h:708
legion_task_launcher_add_region_requirement_logical_region_reduction
unsigned legion_task_launcher_add_region_requirement_logical_region_reduction(legion_task_launcher_t launcher, legion_logical_region_t handle, legion_reduction_op_id_t redop, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_fill_launcher_set_sharding_space
void legion_fill_launcher_set_sharding_space(legion_fill_launcher_t launcher, legion_index_space_t space)
legion_task_launcher_set_provenance
void legion_task_launcher_set_provenance(legion_task_launcher_t launcher, const char *provenance)
legion_region_requirement_get_instance_fields_size
unsigned legion_region_requirement_get_instance_fields_size(legion_region_requirement_t handle)
legion_runtime_generate_library_mapper_ids
legion_mapper_id_t legion_runtime_generate_library_mapper_ids(legion_runtime_t runtime, const char *library_name, size_t count)
legion_field_space_destroy
void legion_field_space_destroy(legion_runtime_t runtime, legion_context_t ctx, legion_field_space_t handle)
legion_layout_constraint_set_add_pointer_constraint
void legion_layout_constraint_set_add_pointer_constraint(legion_layout_constraint_set_t handle, legion_memory_t memory, uintptr_t ptr)
legion_field_id_get_size
size_t legion_field_id_get_size(legion_runtime_t runtime, legion_context_t ctx, legion_field_space_t handle, legion_field_id_t id)
legion_index_launcher_add_future
void legion_index_launcher_add_future(legion_index_launcher_t launcher, legion_future_t future)
legion_copy_get_requirement
legion_region_requirement_t legion_copy_get_requirement(legion_copy_t copy, unsigned idx)
legion_future_wait
void legion_future_wait(legion_future_t handle, bool silence_warnings, const char *warning_string)
legion_detach_external_resources
legion_future_t legion_detach_external_resources(legion_runtime_t runtime, legion_context_t ctx, legion_external_resources_t, bool flush, bool unordered)
legion_logical_region_attach_semantic_information
void legion_logical_region_attach_semantic_information(legion_runtime_t runtime, legion_logical_region_t handle, legion_semantic_tag_t tag, const void *buffer, size_t size, bool is_mutable)
legion_logical_region_get_index_space
legion_index_space_t legion_logical_region_get_index_space(legion_logical_region_t handle)
legion_mappable_as_copy
legion_copy_t legion_mappable_as_copy(legion_mappable_t mappable)
legion_field_space_destroy_unordered
void legion_field_space_destroy_unordered(legion_runtime_t runtime, legion_context_t ctx, legion_field_space_t handle, bool unordered)
legion_fill_launcher_create_from_future
legion_fill_launcher_t legion_fill_launcher_create_from_future(legion_logical_region_t handle, legion_logical_region_t parent, legion_field_id_t fid, legion_future_t f, legion_predicate_t pred, legion_mapper_id_t id, legion_mapping_tag_id_t tag)
legion_region_requirement_get_partition
legion_logical_partition_t legion_region_requirement_get_partition(legion_region_requirement_t handle)
legion_task_launcher_add_region_requirement_logical_region
unsigned legion_task_launcher_add_region_requirement_logical_region(legion_task_launcher_t launcher, legion_logical_region_t handle, legion_privilege_mode_t priv, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_runtime_index_fill_field_with_space
void legion_runtime_index_fill_field_with_space(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t space, legion_logical_partition_t handle, legion_logical_region_t parent, legion_field_id_t fid, const void *value, size_t value_size, legion_projection_id_t proj, legion_predicate_t pred, legion_mapper_id_t id, legion_mapping_tag_id_t launcher_tag)
legion_runtime_total_shards
size_t legion_runtime_total_shards(legion_runtime_t runtime, legion_context_t ctx)
legion_region_requirement_get_projection
legion_projection_id_t legion_region_requirement_get_projection(legion_region_requirement_t handle)
legion_mapper_runtime_create_physical_instance_layout_constraint_id
bool legion_mapper_runtime_create_physical_instance_layout_constraint_id(legion_mapper_runtime_t runtime, legion_mapper_context_t ctx, legion_memory_t target_memory, legion_layout_constraint_id_t layout_id, const legion_logical_region_t *regions, size_t regions_size, legion_physical_instance_t *result, bool acquire, legion_garbage_collection_priority_t priority)
legion_index_space_create_domain
legion_index_space_t legion_index_space_create_domain(legion_runtime_t runtime, legion_context_t ctx, legion_domain_t domain)
legion_task_layout_constraint_set_add_layout_constraint
void legion_task_layout_constraint_set_add_layout_constraint(legion_task_layout_constraint_set_t handle, unsigned idx, legion_layout_constraint_id_t layout)
legion_region_requirement_get_instance_field
legion_field_id_t legion_region_requirement_get_instance_field(legion_region_requirement_t handle, unsigned idx)
legion_logical_partition_has_logical_subregion_by_color_domain_point
bool legion_logical_partition_has_logical_subregion_by_color_domain_point(legion_runtime_t runtime, legion_logical_partition_t parent, legion_domain_point_t c)
legion_logger_warning
void legion_logger_warning(legion_logger_t handle, const char *msg)
legion_copy_launcher_set_possible_src_indirect_out_of_range
void legion_copy_launcher_set_possible_src_indirect_out_of_range(legion_copy_launcher_t launcher, bool flag)
legion_index_partition_create_domain_point_coloring
legion_index_partition_t legion_index_partition_create_domain_point_coloring(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t parent, legion_domain_t color_space, legion_domain_point_coloring_t coloring, legion_partition_kind_t part_kind, legion_color_t color)
legion_processor_query_random
legion_processor_t legion_processor_query_random(legion_processor_query_t query)
legion_task_launcher_set_predicate_false_future
void legion_task_launcher_set_predicate_false_future(legion_task_launcher_t launcher, legion_future_t f)
legion_future_map_get_future
legion_future_t legion_future_map_get_future(legion_future_map_t handle, legion_domain_point_t point)
ITERATOR_VALID
#define ITERATOR_VALID(DIM)
Definition legion_c.h:690
legion_task_get_index_point
legion_domain_point_t legion_task_get_index_point(legion_task_t task)
legion_task_launcher_add_wait_barrier
void legion_task_launcher_add_wait_barrier(legion_task_launcher_t launcher, legion_phase_barrier_t bar)
legion_task_launcher_set_argument
void legion_task_launcher_set_argument(legion_task_launcher_t launcher, legion_untyped_buffer_t arg)
legion_layout_constraint_set_add_offset_constraint
void legion_layout_constraint_set_add_offset_constraint(legion_layout_constraint_set_t handle, legion_field_id_t field, size_t offset)
legion_region_requirement_get_parent
legion_logical_region_t legion_region_requirement_get_parent(legion_region_requirement_t handle)
legion_field_allocator_allocate_field_future
legion_field_id_t legion_field_allocator_allocate_field_future(legion_field_allocator_t allocator, legion_future_t field_size, legion_field_id_t desired_fieldid)
legion_index_copy_launcher_add_dst_region_requirement_logical_partition_reduction
unsigned legion_index_copy_launcher_add_dst_region_requirement_logical_partition_reduction(legion_index_copy_launcher_t launcher, legion_logical_partition_t handle, legion_projection_id_t proj, legion_reduction_op_id_t redop, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_copy_launcher_add_src_field
void legion_copy_launcher_add_src_field(legion_copy_launcher_t launcher, unsigned idx, legion_field_id_t fid, bool inst)
legion_logger_create
legion_logger_t legion_logger_create(const char *name)
legion_index_copy_launcher_add_src_region_requirement_logical_partition
unsigned legion_index_copy_launcher_add_src_region_requirement_logical_partition(legion_index_copy_launcher_t launcher, legion_logical_partition_t handle, legion_projection_id_t proj, legion_privilege_mode_t priv, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_index_partition_get_color_space
legion_index_space_t legion_index_partition_get_color_space(legion_runtime_t runtime, legion_index_partition_t handle)
legion_machine_create
legion_machine_t legion_machine_create(void)
legion_task_launcher_set_mapping_tag
void legion_task_launcher_set_mapping_tag(legion_task_launcher_t launcher, legion_mapping_tag_id_t tag)
legion_task_get_task_id
legion_task_id_t legion_task_get_task_id(legion_task_t task)
legion_mappable_as_task
legion_task_t legion_mappable_as_task(legion_mappable_t mappable)
legion_index_launcher_set_mapper
void legion_index_launcher_set_mapper(legion_index_launcher_t launcher, legion_mapper_id_t mapper_id)
legion_memory_kind
legion_memory_kind_t legion_memory_kind(legion_memory_t mem)
legion_field_map_create
legion_field_map_t legion_field_map_create(void)
legion_machine_get_all_memories_size
size_t legion_machine_get_all_memories_size(legion_machine_t machine)
legion_acquire_launcher_add_field
void legion_acquire_launcher_add_field(legion_acquire_launcher_t launcher, legion_field_id_t fid)
legion_map_task_output_chosen_instances_set
void legion_map_task_output_chosen_instances_set(legion_map_task_output_t output, size_t idx, legion_physical_instance_t *instances, size_t instances_size)
legion_region_requirement_create_logical_partition
legion_region_requirement_t legion_region_requirement_create_logical_partition(legion_logical_partition_t handle, legion_projection_id_t proj, legion_privilege_mode_t priv, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_index_partition_create_index_space_union_partition
legion_index_space_t legion_index_partition_create_index_space_union_partition(legion_runtime_t runtime, legion_context_t ctx, legion_index_partition_t parent, legion_domain_point_t color, legion_index_partition_t handle)
legion_index_launcher_set_region_requirement_logical_partition_reduction
void legion_index_launcher_set_region_requirement_logical_partition_reduction(legion_index_launcher_t launcher, unsigned idx, legion_logical_partition_t handle, legion_projection_id_t proj, legion_reduction_op_id_t redop, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_fill_get_requirement
legion_region_requirement_t legion_fill_get_requirement(legion_fill_t fill)
legion_must_epoch_launcher_set_launch_domain
void legion_must_epoch_launcher_set_launch_domain(legion_must_epoch_launcher_t launcher, legion_domain_t domain)
legion_index_partition_create_by_restriction
legion_index_partition_t legion_index_partition_create_by_restriction(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t parent, legion_index_space_t color_space, legion_domain_transform_t transform, legion_domain_t extent, legion_partition_kind_t part_kind, legion_color_t color)
FROM_RECT
#define FROM_RECT(DIM)
Definition legion_c.h:514
legion_task_launcher_add_future
void legion_task_launcher_add_future(legion_task_launcher_t launcher, legion_future_t future)
legion_logger_want_error
bool legion_logger_want_error(legion_logger_t handle)
legion_field_id_retrieve_name
void legion_field_id_retrieve_name(legion_runtime_t runtime, legion_field_space_t handle, legion_field_id_t id, const char **result)
legion_copy_launcher_set_point
void legion_copy_launcher_set_point(legion_copy_launcher_t launcher, legion_domain_point_t point)
legion_copy_launcher_add_arrival_barrier
void legion_copy_launcher_add_arrival_barrier(legion_copy_launcher_t launcher, legion_phase_barrier_t bar)
legion_memory_address_space
legion_address_space_t legion_memory_address_space(legion_memory_t mem)
legion_inline_launcher_set_provenance
void legion_inline_launcher_set_provenance(legion_inline_launcher_t launcher, const char *provenance)
legion_index_space_attach_name
void legion_index_space_attach_name(legion_runtime_t runtime, legion_index_space_t handle, const char *name, bool is_mutable)
legion_task_variant_registrar_set_execution_constraints
void legion_task_variant_registrar_set_execution_constraints(legion_task_variant_registrar_t registrar, legion_execution_constraint_set_t constraints)
legion_region_requirement_get_privilege
legion_privilege_mode_t legion_region_requirement_get_privilege(legion_region_requirement_t handle)
legion_logger_info
void legion_logger_info(legion_logger_t handle, const char *msg)
legion_task_set_args
void legion_task_set_args(legion_task_mut_t task, void *args)
legion_memory_query_only_kind
void legion_memory_query_only_kind(legion_memory_query_t query, legion_memory_kind_t kind)
legion_processor_query_same_address_space_as_memory
void legion_processor_query_same_address_space_as_memory(legion_processor_query_t query, legion_memory_t mem)
legion_runtime_initialize
void legion_runtime_initialize(int *argc, char ***argv, bool filter)
legion_index_partition_create_by_weights_future_map
legion_index_partition_t legion_index_partition_create_by_weights_future_map(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t parent, legion_future_map_t future_map, legion_index_space_t color_space, size_t granularity, legion_color_t color)
legion_region_requirement_get_region
legion_logical_region_t legion_region_requirement_get_region(legion_region_requirement_t handle)
legion_task_get_tag
legion_mapping_tag_id_t legion_task_get_tag(legion_task_t task)
legion_copy_launcher_add_src_region_requirement_logical_region
unsigned legion_copy_launcher_add_src_region_requirement_logical_region(legion_copy_launcher_t launcher, legion_logical_region_t handle, legion_privilege_mode_t priv, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_map_task_output_task_priority_set
void legion_map_task_output_task_priority_set(legion_map_task_output_t output, legion_task_priority_t priority)
legion_release_launcher_create
legion_release_launcher_t legion_release_launcher_create(legion_logical_region_t logical_region, legion_logical_region_t parent_region, legion_predicate_t pred, legion_mapper_id_t id, legion_mapping_tag_id_t tag)
legion_argument_map_set_future
void legion_argument_map_set_future(legion_argument_map_t map, legion_domain_point_t dp, legion_future_t future, bool replace)
legion_index_space_retrieve_semantic_information
bool legion_index_space_retrieve_semantic_information(legion_runtime_t runtime, legion_index_space_t handle, legion_semantic_tag_t tag, const void **result, size_t *size, bool can_fail, bool wait_until_ready)
legion_index_space_get_parent_index_partition
legion_index_partition_t legion_index_space_get_parent_index_partition(legion_runtime_t runtime, legion_index_space_t handle)
legion_index_partition_create_by_difference
legion_index_partition_t legion_index_partition_create_by_difference(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t parent, legion_index_partition_t handle1, legion_index_partition_t handle2, legion_index_space_t color_space, legion_partition_kind_t part_kind, legion_color_t color)
legion_index_copy_launcher_set_possible_src_indirect_out_of_range
void legion_index_copy_launcher_set_possible_src_indirect_out_of_range(legion_index_copy_launcher_t launcher, bool flag)
legion_task_launcher_set_sharding_space
void legion_task_launcher_set_sharding_space(legion_task_launcher_t launcher, legion_index_space_t is)
legion_runtime_print_once_fd
void legion_runtime_print_once_fd(legion_runtime_t runtime, legion_context_t ctx, int fd, const char *mode, const char *message)
legion_acquire_launcher_set_sharding_space
void legion_acquire_launcher_set_sharding_space(legion_acquire_launcher_t launcher, legion_index_space_t space)
legion_dynamic_collective_destroy
void legion_dynamic_collective_destroy(legion_runtime_t runtime, legion_context_t ctx, legion_dynamic_collective_t handle)
legion_get_physical_region_by_id
legion_physical_region_t legion_get_physical_region_by_id(legion_physical_region_t *regionptr, int id, int num_regions)
legion_index_space_destroy
void legion_index_space_destroy(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t handle)
legion_field_space_create
legion_field_space_t legion_field_space_create(legion_runtime_t runtime, legion_context_t ctx)
legion_execution_constraint_set_destroy
void legion_execution_constraint_set_destroy(legion_execution_constraint_set_t handle)
legion_processor_query_best_affinity_to_memory
void legion_processor_query_best_affinity_to_memory(legion_processor_query_t query, legion_memory_t mem, int bandwidth_weight, int latency_weight)
legion_mapper_runtime_acquire_instance
bool legion_mapper_runtime_acquire_instance(legion_mapper_runtime_t runtime, legion_mapper_context_t ctx, legion_physical_instance_t instance)
legion_index_partition_get_index_subspace_domain_point
legion_index_space_t legion_index_partition_get_index_subspace_domain_point(legion_runtime_t runtime, legion_index_partition_t handle, legion_domain_point_t color)
legion_machine_get_all_processors_size
size_t legion_machine_get_all_processors_size(legion_machine_t machine)
legion_index_partition_is_complete
bool legion_index_partition_is_complete(legion_runtime_t runtime, legion_index_partition_t handle)
legion_task_launcher_set_elide_future_return
void legion_task_launcher_set_elide_future_return(legion_task_launcher_t launcher, bool elide_future_return)
legion_index_partition_create_by_preimage
legion_index_partition_t legion_index_partition_create_by_preimage(legion_runtime_t runtime, legion_context_t ctx, legion_index_partition_t projection, legion_logical_region_t handle, legion_logical_region_t parent, legion_field_id_t fid, legion_index_space_t color_space, legion_partition_kind_t part_kind, legion_color_t color, legion_mapper_id_t id, legion_mapping_tag_id_t tag, legion_untyped_buffer_t map_arg)
legion_runtime_fill_field_future
void legion_runtime_fill_field_future(legion_runtime_t runtime, legion_context_t ctx, legion_logical_region_t handle, legion_logical_region_t parent, legion_field_id_t fid, legion_future_t f, legion_predicate_t pred)
legion_index_copy_launcher_add_src_region_requirement_logical_region
unsigned legion_index_copy_launcher_add_src_region_requirement_logical_region(legion_index_copy_launcher_t launcher, legion_logical_region_t handle, legion_projection_id_t proj, legion_privilege_mode_t priv, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_logger_error
void legion_logger_error(legion_logger_t handle, const char *msg)
legion_field_space_attach_name
void legion_field_space_attach_name(legion_runtime_t runtime, legion_field_space_t handle, const char *name, bool is_mutable)
legion_map_task_output_target_procs_clear
void legion_map_task_output_target_procs_clear(legion_map_task_output_t output)
legion_must_epoch_launcher_set_launch_space
void legion_must_epoch_launcher_set_launch_space(legion_must_epoch_launcher_t launcher, legion_index_space_t is)
legion_processor_query_destroy
void legion_processor_query_destroy(legion_processor_query_t handle)
legion_index_fill_launcher_set_provenance
void legion_index_fill_launcher_set_provenance(legion_index_fill_launcher_t launcher, const char *provenance)
legion_future_map_reduce
legion_future_t legion_future_map_reduce(legion_runtime_t runtime, legion_context_t ctx, legion_future_map_t handle, legion_reduction_op_id_t redop, bool deterministic, legion_mapper_id_t map_id, legion_mapping_tag_id_t tag)
legion_logger_want_fatal
bool legion_logger_want_fatal(legion_logger_t handle)
legion_physical_region_is_valid
bool legion_physical_region_is_valid(legion_physical_region_t handle)
legion_mapper_runtime_find_or_create_physical_instance_layout_constraint_id
bool legion_mapper_runtime_find_or_create_physical_instance_layout_constraint_id(legion_mapper_runtime_t runtime, legion_mapper_context_t ctx, legion_memory_t target_memory, legion_layout_constraint_id_t layout_id, const legion_logical_region_t *regions, size_t regions_size, legion_physical_instance_t *result, bool *created, bool acquire, legion_garbage_collection_priority_t priority, bool tight_region_bounds)
legion_task_launcher_add_flags
void legion_task_launcher_add_flags(legion_task_launcher_t launcher, unsigned idx, enum legion_region_flags_t flags)
legion_output_requirement_get_partition
legion_logical_partition_t legion_output_requirement_get_partition(legion_output_requirement_t handle)
legion_multi_domain_point_coloring_destroy
void legion_multi_domain_point_coloring_destroy(legion_multi_domain_point_coloring_t handle)
legion_logical_region_retrieve_semantic_information
bool legion_logical_region_retrieve_semantic_information(legion_runtime_t runtime, legion_logical_region_t handle, legion_semantic_tag_t tag, const void **result, size_t *size, bool can_fail, bool wait_until_ready)
legion_runtime_select_tunable_value
legion_future_t legion_runtime_select_tunable_value(legion_runtime_t runtime, legion_context_t ctx, legion_tunable_id_t tid, legion_mapper_id_t mapper, legion_mapping_tag_id_t tag)
legion_task_get_regions_size
unsigned legion_task_get_regions_size(legion_task_t task)
legion_task_id_retrieve_semantic_information
bool legion_task_id_retrieve_semantic_information(legion_runtime_t runtime, legion_task_id_t task_id, legion_semantic_tag_t tag, const void **result, size_t *size, bool can_fail, bool wait_until_ready)
legion_must_epoch_launcher_destroy
void legion_must_epoch_launcher_destroy(legion_must_epoch_launcher_t handle)
legion_physical_region_wait_until_valid
void legion_physical_region_wait_until_valid(legion_physical_region_t handle)
legion_attach_launcher_destroy
void legion_attach_launcher_destroy(legion_attach_launcher_t handle)
legion_index_launcher_create
legion_index_launcher_t legion_index_launcher_create(legion_task_id_t tid, legion_domain_t domain, legion_untyped_buffer_t global_arg, legion_argument_map_t map, legion_predicate_t pred, bool must, legion_mapper_id_t id, legion_mapping_tag_id_t tag)
legion_argument_map_create
legion_argument_map_t legion_argument_map_create(void)
legion_runtime_local_shard
legion_shard_id_t legion_runtime_local_shard(legion_runtime_t runtime, legion_context_t ctx)
FROM_POINT
#define FROM_POINT(DIM)
Definition legion_c.h:589
legion_task_launcher_destroy
void legion_task_launcher_destroy(legion_task_launcher_t handle)
legion_execution_constraint_set_add_launch_constraint
void legion_execution_constraint_set_add_launch_constraint(legion_execution_constraint_set_t handle, legion_launch_constraint_t kind, size_t value)
legion_dynamic_collective_advance
legion_dynamic_collective_t legion_dynamic_collective_advance(legion_runtime_t runtime, legion_context_t ctx, legion_dynamic_collective_t handle)
legion_domain_point_safe_cast
legion_domain_point_t legion_domain_point_safe_cast(legion_runtime_t runtime, legion_context_t ctx, legion_domain_point_t point, legion_logical_region_t region)
legion_processor_query_count
size_t legion_processor_query_count(legion_processor_query_t query)
ACCESSOR_ARRAY
#define ACCESSOR_ARRAY(DIM)
Definition legion_c.h:5186
legion_mapper_runtime_find_physical_instance_layout_constraint
bool legion_mapper_runtime_find_physical_instance_layout_constraint(legion_mapper_runtime_t runtime, legion_mapper_context_t ctx, legion_memory_t target_memory, legion_layout_constraint_set_t constraints, const legion_logical_region_t *regions, size_t regions_size, legion_physical_instance_t *result, bool acquire, bool tight_region_bounds)
legion_mapper_runtime_find_physical_instance_layout_constraint_id
bool legion_mapper_runtime_find_physical_instance_layout_constraint_id(legion_mapper_runtime_t runtime, legion_mapper_context_t ctx, legion_memory_t target_memory, legion_layout_constraint_id_t layout_id, const legion_logical_region_t *regions, size_t regions_size, legion_physical_instance_t *result, bool acquire, bool tight_region_bounds)
legion_runtime_get_runtime
legion_runtime_t legion_runtime_get_runtime(void)
legion_physical_region_destroy
void legion_physical_region_destroy(legion_physical_region_t handle)
legion_runtime_index_fill_field
void legion_runtime_index_fill_field(legion_runtime_t runtime, legion_context_t ctx, legion_logical_partition_t handle, legion_logical_region_t parent, legion_field_id_t fid, const void *value, size_t value_size, legion_projection_id_t proj, legion_predicate_t pred, legion_mapper_id_t id, legion_mapping_tag_id_t launcher_tag)
legion_layout_constraint_set_add_alignment_constraint
void legion_layout_constraint_set_add_alignment_constraint(legion_layout_constraint_set_t handle, legion_field_id_t field, legion_equality_kind_t eq, size_t byte_boundary)
legion_index_partition_create_by_field
legion_index_partition_t legion_index_partition_create_by_field(legion_runtime_t runtime, legion_context_t ctx, legion_logical_region_t handle, legion_logical_region_t parent, legion_field_id_t fid, legion_index_space_t color_space, legion_color_t color, legion_mapper_id_t id, legion_mapping_tag_id_t tag, legion_partition_kind_t part_kind, legion_untyped_buffer_t map_arg)
legion_future_map_wait_all_results
void legion_future_map_wait_all_results(legion_future_map_t handle)
legion_domain_empty
legion_domain_t legion_domain_empty(unsigned dim)
legion_index_launcher_set_elide_future_return
void legion_index_launcher_set_elide_future_return(legion_index_launcher_t launcher, bool elide_future_return)
legion_memory_query_best_affinity_to_processor
void legion_memory_query_best_affinity_to_processor(legion_memory_query_t query, legion_processor_t proc, int bandwidth_weight, int latency_weight)
legion_index_launcher_set_region_requirement_logical_region_reduction
void legion_index_launcher_set_region_requirement_logical_region_reduction(legion_index_launcher_t launcher, unsigned idx, legion_logical_region_t handle, legion_projection_id_t proj, legion_reduction_op_id_t redop, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_execution_constraint_set_add_colocation_constraint
void legion_execution_constraint_set_add_colocation_constraint(legion_execution_constraint_set_t handle, const unsigned *indexes, size_t num_indexes, const legion_field_id_t *fields, size_t num_fields)
legion_multi_domain_point_coloring_color_domain
void legion_multi_domain_point_coloring_color_domain(legion_multi_domain_point_coloring_t handle, legion_domain_point_t color, legion_domain_t domain)
legion_index_copy_launcher_add_dst_indirect_region_requirement_logical_partition
unsigned legion_index_copy_launcher_add_dst_indirect_region_requirement_logical_partition(legion_index_copy_launcher_t launcher, legion_logical_partition_t handle, legion_projection_id_t proj, legion_field_id_t fid, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool is_range_indirection, bool verified)
legion_logical_region_retrieve_name
void legion_logical_region_retrieve_name(legion_runtime_t runtime, legion_logical_region_t handle, const char **result)
legion_issue_timing_op_seconds
legion_future_t legion_issue_timing_op_seconds(legion_runtime_t runtime, legion_context_t ctx)
legion_index_copy_launcher_set_mapper_arg
void legion_index_copy_launcher_set_mapper_arg(legion_index_copy_launcher_t launcher, legion_untyped_buffer_t arg)
legion_release_launcher_add_arrival_barrier
void legion_release_launcher_add_arrival_barrier(legion_release_launcher_t launcher, legion_phase_barrier_t bar)
legion_copy_launcher_add_wait_barrier
void legion_copy_launcher_add_wait_barrier(legion_copy_launcher_t launcher, legion_phase_barrier_t bar)
legion_task_launcher_set_mapper_arg
void legion_task_launcher_set_mapper_arg(legion_task_launcher_t launcher, legion_untyped_buffer_t arg)
legion_output_requirement_get_parent
legion_logical_region_t legion_output_requirement_get_parent(legion_output_requirement_t handle)
legion_future_destroy
void legion_future_destroy(legion_future_t handle)
legion_task_launcher_add_arrival_barrier
void legion_task_launcher_add_arrival_barrier(legion_task_launcher_t launcher, legion_phase_barrier_t bar)
legion_runtime_register_projection_functor_mappable
void legion_runtime_register_projection_functor_mappable(legion_runtime_t runtime, legion_projection_id_t id, bool exclusive, unsigned depth, legion_projection_functor_logical_region_mappable_t region_functor, legion_projection_functor_logical_partition_mappable_t partition_functor)
legion_output_requirement_get_region
legion_logical_region_t legion_output_requirement_get_region(legion_output_requirement_t handle)
legion_runtime_register_projection_functor_args
void legion_runtime_register_projection_functor_args(legion_runtime_t runtime, legion_projection_id_t id, bool exclusive, unsigned depth, legion_projection_functor_logical_region_t region_functor, legion_projection_functor_logical_partition_t partition_functor)
legion_index_launcher_execute_reduction_and_outputs
legion_future_t legion_index_launcher_execute_reduction_and_outputs(legion_runtime_t runtime, legion_context_t ctx, legion_index_launcher_t launcher, legion_reduction_op_id_t redop, bool deterministic, legion_output_requirement_t *reqs, size_t reqs_size)
legion_task_launcher_set_region_requirement_logical_region_reduction
void legion_task_launcher_set_region_requirement_logical_region_reduction(legion_task_launcher_t launcher, unsigned idx, legion_logical_region_t handle, legion_reduction_op_id_t redop, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_runtime_get_executing_processor
legion_processor_t legion_runtime_get_executing_processor(legion_runtime_t runtime, legion_context_t ctx)
legion_index_launcher_add_flags
void legion_index_launcher_add_flags(legion_index_launcher_t launcher, unsigned idx, enum legion_region_flags_t flags)
legion_task_layout_constraint_set_create
legion_task_layout_constraint_set_t legion_task_layout_constraint_set_create(void)
legion_logical_partition_create
legion_logical_partition_t legion_logical_partition_create(legion_runtime_t runtime, legion_logical_region_t parent, legion_index_partition_t handle)
legion_reset_equivalence_sets
void legion_reset_equivalence_sets(legion_runtime_t runtime, legion_context_t ctx, legion_logical_region_t parent, legion_logical_region_t region, int num_fields, legion_field_id_t *fields)
legion_processor_query_create_copy
legion_processor_query_t legion_processor_query_create_copy(legion_processor_query_t query)
legion_mapper_runtime_acquire_instances
bool legion_mapper_runtime_acquire_instances(legion_mapper_runtime_t runtime, legion_mapper_context_t ctx, legion_physical_instance_t *instances, size_t instances_size)
legion_index_space_retrieve_name
void legion_index_space_retrieve_name(legion_runtime_t runtime, legion_index_space_t handle, const char **result)
legion_layout_constraint_set_release
void legion_layout_constraint_set_release(legion_runtime_t runtime, legion_layout_constraint_id_t handle)
legion_runtime_attach_hdf5
legion_physical_region_t legion_runtime_attach_hdf5(legion_runtime_t runtime, legion_context_t ctx, const char *filename, legion_logical_region_t handle, legion_logical_region_t parent, legion_field_map_t field_map, legion_file_mode_t mode)
legion_acquire_launcher_add_wait_barrier
void legion_acquire_launcher_add_wait_barrier(legion_acquire_launcher_t launcher, legion_phase_barrier_t bar)
legion_context_get_unique_id
legion_unique_id_t legion_context_get_unique_id(legion_context_t ctx)
legion_index_attach_launcher_create
legion_index_attach_launcher_t legion_index_attach_launcher_create(legion_logical_region_t parent_region, legion_external_resource_t resource, bool restricted)
legion_domain_point_is_null
bool legion_domain_point_is_null(legion_domain_point_t point)
legion_predicate_true
const legion_predicate_t legion_predicate_true(void)
legion_runtime_get_context
legion_context_t legion_runtime_get_context(void)
legion_index_launcher_set_projection_args
void legion_index_launcher_set_projection_args(legion_index_launcher_t launcher_, unsigned idx, const void *args, size_t size, bool own)
legion_field_id_retrieve_semantic_information
bool legion_field_id_retrieve_semantic_information(legion_runtime_t runtime, legion_field_space_t handle, legion_field_id_t id, legion_semantic_tag_t tag, const void **result, size_t *size, bool can_fail, bool wait_until_ready)
legion_index_fill_launcher_create_from_future_with_space
legion_index_fill_launcher_t legion_index_fill_launcher_create_from_future_with_space(legion_index_space_t space, legion_logical_partition_t handle, legion_logical_region_t parent, legion_field_id_t fid, legion_future_t future, legion_projection_id_t proj, legion_predicate_t pred, legion_mapper_id_t id, legion_mapping_tag_id_t launcher_tag)
legion_index_partition_get_parent_index_space
legion_index_space_t legion_index_partition_get_parent_index_space(legion_runtime_t runtime, legion_index_partition_t handle)
legion_multi_domain_point_coloring_create
legion_multi_domain_point_coloring_t legion_multi_domain_point_coloring_create(void)
legion_memory_query_create_copy
legion_memory_query_t legion_memory_query_create_copy(legion_memory_query_t query)
legion_index_partition_get_color
legion_color_t legion_index_partition_get_color(legion_runtime_t runtime, legion_index_partition_t handle)
legion_field_allocator_free_field_unordered
void legion_field_allocator_free_field_unordered(legion_field_allocator_t allocator, legion_field_id_t fid, bool unordered)
legion_domain_point_iterator_create
legion_domain_point_iterator_t legion_domain_point_iterator_create(legion_domain_t handle)
legion_release_launcher_set_mapper_arg
void legion_release_launcher_set_mapper_arg(legion_release_launcher_t launcher, legion_untyped_buffer_t arg)
legion_memory_query_first
legion_memory_t legion_memory_query_first(legion_memory_query_t query)
legion_coloring_destroy
void legion_coloring_destroy(legion_coloring_t handle)
legion_logical_partition_attach_name
void legion_logical_partition_attach_name(legion_runtime_t runtime, legion_logical_partition_t handle, const char *name, bool is_mutable)
legion_index_space_attach_semantic_information
void legion_index_space_attach_semantic_information(legion_runtime_t runtime, legion_index_space_t handle, legion_semantic_tag_t tag, const void *buffer, size_t size, bool is_mutable)
legion_logical_partition_retrieve_name
void legion_logical_partition_retrieve_name(legion_runtime_t runtime, legion_logical_partition_t handle, const char **result)
legion_point_coloring_add_point
void legion_point_coloring_add_point(legion_point_coloring_t handle, legion_domain_point_t color, legion_ptr_t point)
legion_index_attach_launcher_attach_array_aos
void legion_index_attach_launcher_attach_array_aos(legion_index_attach_launcher_t handle, legion_logical_region_t region, void *base_ptr, bool column_major, const legion_field_id_t *fields, size_t num_fields, legion_memory_t memory)
legion_runtime_preregister_projection_functor
void legion_runtime_preregister_projection_functor(legion_projection_id_t id, bool exclusive, unsigned depth, legion_projection_functor_logical_region_t region_functor, legion_projection_functor_logical_partition_t partition_functor)
legion_future_is_ready
bool legion_future_is_ready(legion_future_t handle)
legion_get_current_time_in_nanos
unsigned long long legion_get_current_time_in_nanos(void)
legion_release_launcher_set_sharding_space
void legion_release_launcher_set_sharding_space(legion_release_launcher_t launcher, legion_index_space_t space)
legion_index_partition_create_by_domain_future_map
legion_index_partition_t legion_index_partition_create_by_domain_future_map(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t parent, legion_future_map_t future_map, legion_index_space_t color_space, bool perform_intersections, legion_partition_kind_t part_kind, legion_color_t color)
legion_physical_region_get_memory_count
size_t legion_physical_region_get_memory_count(legion_physical_region_t handle)
legion_task_destroy
void legion_task_destroy(legion_task_mut_t handle)
legion_mappable_as_inline_mapping
legion_inline_t legion_mappable_as_inline_mapping(legion_mappable_t mappable)
legion_task_launcher_set_local_function_task
void legion_task_launcher_set_local_function_task(legion_task_launcher_t launcher, bool local_function_task)
legion_predicate_destroy
void legion_predicate_destroy(legion_predicate_t handle)
legion_index_launcher_add_wait_barrier
void legion_index_launcher_add_wait_barrier(legion_index_launcher_t launcher, legion_phase_barrier_t bar)
legion_issue_timing_op_nanoseconds
legion_future_t legion_issue_timing_op_nanoseconds(legion_runtime_t runtime, legion_context_t ctx)
legion_coloring_ensure_color
void legion_coloring_ensure_color(legion_coloring_t handle, legion_color_t color)
legion_region_requirement_get_redop
legion_reduction_op_id_t legion_region_requirement_get_redop(legion_region_requirement_t handle)
legion_runtime_has_runtime
bool legion_runtime_has_runtime(void)
legion_processor_kind
legion_processor_kind_t legion_processor_kind(legion_processor_t proc)
legion_task_variant_registrar_set_options
void legion_task_variant_registrar_set_options(legion_task_variant_registrar_t registrar, legion_task_config_options_t options)
legion_attach_launcher_attach_hdf5
void legion_attach_launcher_attach_hdf5(legion_attach_launcher_t handle, const char *filename, legion_field_map_t field_map, legion_file_mode_t mode)
legion_map_task_output_chosen_instances_clear_each
void legion_map_task_output_chosen_instances_clear_each(legion_map_task_output_t output, size_t idx)
legion_fill_launcher_set_mapper_arg
void legion_fill_launcher_set_mapper_arg(legion_fill_launcher_t launcher, legion_untyped_buffer_t arg)
legion_copy_launcher_execute
void legion_copy_launcher_execute(legion_runtime_t runtime, legion_context_t ctx, legion_copy_launcher_t launcher)
legion_discard_launcher_set_provenance
void legion_discard_launcher_set_provenance(legion_discard_launcher_t launcher, const char *provenance)
legion_execution_constraint_set_add_isa_constraint
void legion_execution_constraint_set_add_isa_constraint(legion_execution_constraint_set_t handle, uint64_t prop)
legion_index_copy_launcher_add_dst_region_requirement_logical_region
unsigned legion_index_copy_launcher_add_dst_region_requirement_logical_region(legion_index_copy_launcher_t launcher, legion_logical_region_t handle, legion_projection_id_t proj, legion_privilege_mode_t priv, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_task_get_args
void * legion_task_get_args(legion_task_t task)
legion_unordered_detach_external_resource
legion_future_t legion_unordered_detach_external_resource(legion_runtime_t runtime, legion_context_t ctx, legion_physical_region_t handle, bool flush, bool unordered)
legion_logical_partition_retrieve_semantic_information
bool legion_logical_partition_retrieve_semantic_information(legion_runtime_t runtime, legion_logical_partition_t handle, legion_semantic_tag_t tag, const void **result, size_t *size, bool can_fail, bool wait_until_ready)
legion_index_partition_create_pending_partition
legion_index_partition_t legion_index_partition_create_pending_partition(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t parent, legion_index_space_t color_space, legion_partition_kind_t part_kind, legion_color_t color)
legion_runtime_has_context
bool legion_runtime_has_context(void)
legion_region_requirement_destroy
void legion_region_requirement_destroy(legion_region_requirement_t handle)
legion_domain_point_iterator_has_next
bool legion_domain_point_iterator_has_next(legion_domain_point_iterator_t handle)
legion_index_space_union
legion_index_space_t legion_index_space_union(legion_runtime_t runtime, legion_context_t ctx, const legion_index_space_t *spaces, size_t num_spaces)
legion_logical_partition_get_logical_subregion
legion_logical_region_t legion_logical_partition_get_logical_subregion(legion_runtime_t runtime, legion_logical_partition_t parent, legion_index_space_t handle)
legion_index_launcher_execute_reduction
legion_future_t legion_index_launcher_execute_reduction(legion_runtime_t runtime, legion_context_t ctx, legion_index_launcher_t launcher, legion_reduction_op_id_t redop)
legion_logger_want_warning
bool legion_logger_want_warning(legion_logger_t handle)
legion_task_id_attach_name
void legion_task_id_attach_name(legion_runtime_t runtime, legion_task_id_t task_id, const char *name, bool is_mutable)
legion_logical_partition_get_parent_logical_region
legion_logical_region_t legion_logical_partition_get_parent_logical_region(legion_runtime_t runtime, legion_logical_partition_t handle)
legion_inline_launcher_add_field
void legion_inline_launcher_add_field(legion_inline_launcher_t launcher, legion_field_id_t fid, bool inst)
legion_inline_launcher_execute
legion_physical_region_t legion_inline_launcher_execute(legion_runtime_t runtime, legion_context_t ctx, legion_inline_launcher_t launcher)
legion_copy_launcher_set_possible_dst_indirect_out_of_range
void legion_copy_launcher_set_possible_dst_indirect_out_of_range(legion_copy_launcher_t launcher, bool flag)
legion_physical_region_copy
legion_physical_region_t legion_physical_region_copy(legion_physical_region_t handle)
legion_runtime_generate_library_reduction_ids
legion_reduction_op_id_t legion_runtime_generate_library_reduction_ids(legion_runtime_t runtime, const char *library_name, size_t count)
legion_registration_callback_pointer_t
void(* legion_registration_callback_pointer_t)(legion_machine_t, legion_runtime_t, const legion_processor_t *, unsigned)
Definition legion_c.h:391
legion_runtime_unmap_region
void legion_runtime_unmap_region(legion_runtime_t runtime, legion_context_t ctx, legion_physical_region_t region)
legion_task_launcher_set_predicate_false_result
void legion_task_launcher_set_predicate_false_result(legion_task_launcher_t launcher, legion_untyped_buffer_t arg)
legion_layout_constraint_set_add_ordering_constraint
void legion_layout_constraint_set_add_ordering_constraint(legion_layout_constraint_set_t handle, const legion_dimension_kind_t *dims, size_t num_dims, bool contiguous)
legion_discard_launcher_destroy
void legion_discard_launcher_destroy(legion_discard_launcher_t handle)
legion_processor_query_next
legion_processor_t legion_processor_query_next(legion_processor_query_t query, legion_processor_t after)
legion_logical_region_create_shared_ownership
void legion_logical_region_create_shared_ownership(legion_runtime_t runtime, legion_context_t ctx, legion_logical_region_t handle)
legion_task_get_local_arglen
size_t legion_task_get_local_arglen(legion_task_t task)
legion_index_copy_launcher_create
legion_index_copy_launcher_t legion_index_copy_launcher_create(legion_domain_t domain, legion_predicate_t pred, legion_mapper_id_t id, legion_mapping_tag_id_t launcher_tag)
legion_logger_want_debug
bool legion_logger_want_debug(legion_logger_t handle)
legion_future_get_untyped_pointer
const void * legion_future_get_untyped_pointer(legion_future_t handle)
legion_region_requirement_create_logical_region_projection
legion_region_requirement_t legion_region_requirement_create_logical_region_projection(legion_logical_region_t handle, legion_projection_id_t proj, legion_privilege_mode_t priv, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_index_launcher_set_sharding_space
void legion_index_launcher_set_sharding_space(legion_index_launcher_t launcher, legion_index_space_t is)
legion_task_launcher_create
legion_task_launcher_t legion_task_launcher_create(legion_task_id_t tid, legion_untyped_buffer_t arg, legion_predicate_t pred, legion_mapper_id_t id, legion_mapping_tag_id_t tag)
legion_phase_barrier_arrive
void legion_phase_barrier_arrive(legion_runtime_t runtime, legion_context_t ctx, legion_phase_barrier_t handle, unsigned count)
CREATE_BLOCKIFY
#define CREATE_BLOCKIFY(DIM)
Definition legion_c.h:1178
legion_runtime_generate_static_projection_id
legion_projection_id_t legion_runtime_generate_static_projection_id()
legion_index_launcher_get_projection_args
const void * legion_index_launcher_get_projection_args(legion_region_requirement_t requirement, size_t *size)
legion_copy_launcher_set_sharding_space
void legion_copy_launcher_set_sharding_space(legion_copy_launcher_t launcher, legion_index_space_t space)
legion_phase_barrier_destroy
void legion_phase_barrier_destroy(legion_runtime_t runtime, legion_context_t ctx, legion_phase_barrier_t handle)
legion_coloring_add_point
void legion_coloring_add_point(legion_coloring_t handle, legion_color_t color, legion_ptr_t point)
legion_field_map_destroy
void legion_field_map_destroy(legion_field_map_t handle)
legion_acquire_launcher_set_provenance
void legion_acquire_launcher_set_provenance(legion_acquire_launcher_t launcher, const char *provenance)
legion_task_get_future
legion_future_t legion_task_get_future(legion_task_t task, unsigned idx)
legion_point_coloring_destroy
void legion_point_coloring_destroy(legion_point_coloring_t handle)
legion_logger_print
void legion_logger_print(legion_logger_t handle, const char *msg)
legion_index_launcher_add_region_requirement_logical_region
unsigned legion_index_launcher_add_region_requirement_logical_region(legion_index_launcher_t launcher, legion_logical_region_t handle, legion_projection_id_t proj, legion_privilege_mode_t priv, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool verified)
legion_field_space_create_with_fields
legion_field_space_t legion_field_space_create_with_fields(legion_runtime_t runtime, legion_context_t ctx, size_t *field_sizes, legion_field_id_t *field_ids, size_t num_fields, legion_custom_serdez_id_t serdez)
legion_issue_timing_op_microseconds
legion_future_t legion_issue_timing_op_microseconds(legion_runtime_t runtime, legion_context_t ctx)
legion_copy_launcher_add_dst_indirect_region_requirement_logical_region
unsigned legion_copy_launcher_add_dst_indirect_region_requirement_logical_region(legion_copy_launcher_t launcher, legion_logical_region_t handle, legion_field_id_t fid, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool is_range_indirection, bool verified)
legion_index_copy_launcher_add_src_indirect_region_requirement_logical_region
unsigned legion_index_copy_launcher_add_src_indirect_region_requirement_logical_region(legion_index_copy_launcher_t launcher, legion_logical_region_t handle, legion_projection_id_t proj, legion_field_id_t fid, legion_coherence_property_t prop, legion_logical_region_t parent, legion_mapping_tag_id_t tag, bool is_range_indirection, bool verified)
legion_future_map_construct_from_futures
legion_future_map_t legion_future_map_construct_from_futures(legion_runtime_t runtime, legion_context_t ctx, legion_domain_t domain, legion_domain_point_t *points, legion_future_t *futures, size_t num_futures, bool collective, legion_sharding_id_t sid, bool implicit_sharding)
legion_index_fill_launcher_execute
void legion_index_fill_launcher_execute(legion_runtime_t runtime, legion_context_t ctx, legion_index_fill_launcher_t launcher)
legion_task_launcher_execute
legion_future_t legion_task_launcher_execute(legion_runtime_t runtime, legion_context_t ctx, legion_task_launcher_t launcher)
legion_coloring_add_range
void legion_coloring_add_range(legion_coloring_t handle, legion_color_t color, legion_ptr_t start, legion_ptr_t end)
legion_index_partition_create_shared_ownership
void legion_index_partition_create_shared_ownership(legion_runtime_t runtime, legion_context_t ctx, legion_index_partition_t handle)
legion_field_allocator_destroy
void legion_field_allocator_destroy(legion_field_allocator_t handle)
legion_runtime_set_return_code
void legion_runtime_set_return_code(int return_code)
legion_index_launcher_execute_deterministic_reduction
legion_future_t legion_index_launcher_execute_deterministic_reduction(legion_runtime_t runtime, legion_context_t ctx, legion_index_launcher_t launcher, legion_reduction_op_id_t redop, bool deterministic)
legion_memory_query_local_address_space
void legion_memory_query_local_address_space(legion_memory_query_t query)
legion_argument_map_set_point
void legion_argument_map_set_point(legion_argument_map_t map, legion_domain_point_t dp, legion_untyped_buffer_t arg, bool replace)
legion_task_launcher_add_field
void legion_task_launcher_add_field(legion_task_launcher_t launcher, unsigned idx, legion_field_id_t fid, bool inst)
legion_config.h
legion_byte_offset_t
Definition legion_c.h:300
legion_domain_affine_transform_t
Definition legion_c.h:241
legion_domain_point_t
Definition legion_c.h:196
legion_domain_t
Definition legion_c.h:157
legion_domain_transform_t
Definition legion_c.h:204
legion_dynamic_collective_t
Definition legion_c.h:359
legion_field_space_t
Definition legion_c.h:267
legion_index_partition_t
Definition legion_c.h:258
legion_index_space_t
Definition legion_c.h:249
legion_input_args_t
Definition legion_c.h:307
legion_logical_partition_t
Definition legion_c.h:283
legion_logical_region_t
Definition legion_c.h:274
legion_memory_t
Definition legion_c.h:332
legion_phase_barrier_t
Definition legion_c.h:349
legion_processor_t
Definition legion_c.h:325
legion_ptr_t
Definition legion_c.h:123
legion_slice_task_input_t
Definition legion_c.h:383
legion_task_config_options_t
Definition legion_c.h:315
legion_task_options_t
Definition legion_c.h:372
legion_task_slice_t
Definition legion_c.h:339
legion_untyped_buffer_t
Definition legion_c.h:292
Generated on Mon Jun 2 2025 16:27:37 for Legion Runtime by doxygen 1.9.8