Legion Runtime
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
41 extern "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 #undef NEW_OPAQUE_TYPE
118 
122  typedef struct legion_ptr_t {
123  long long int value;
124  } legion_ptr_t;
125 
126  typedef legion_coord_t coord_t;
127 
128 #define NEW_POINT_TYPE(DIM) typedef struct legion_point_##DIM##d_t { coord_t x[DIM]; } legion_point_##DIM##d_t;
129  LEGION_FOREACH_N(NEW_POINT_TYPE)
130 #undef NEW_POINT_TYPE
131 
132 #define NEW_RECT_TYPE(DIM) typedef struct legion_rect_##DIM##d_t { legion_point_##DIM##d_t lo, hi; } legion_rect_##DIM##d_t;
133  LEGION_FOREACH_N(NEW_RECT_TYPE)
134 #undef NEW_RECT_TYPE
135 
136 #define NEW_BLOCKIFY_TYPE(DIM) \
137  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;
138  LEGION_FOREACH_N(NEW_BLOCKIFY_TYPE)
139 #undef NEW_BLOCKIFY_TYPE
140 
141 #define NEW_TRANSFORM_TYPE(D1,D2) \
142  typedef struct legion_transform_##D1##x##D2##_t { coord_t trans[D1][D2]; } legion_transform_##D1##x##D2##_t;
143  LEGION_FOREACH_NN(NEW_TRANSFORM_TYPE)
144 #undef NEW_TRANSFORM_TYPE
145 
146 #define NEW_AFFINE_TRANSFORM_TYPE(D1,D2) \
147  typedef struct legion_affine_transform_##D1##x##D2##_t { \
148  legion_transform_##D1##x##D2##_t transform; legion_point_##D1##d_t offset; } \
149  legion_affine_transform_##D1##x##D2##_t;
150  LEGION_FOREACH_NN(NEW_AFFINE_TRANSFORM_TYPE)
151 #undef NEW_AFFINE_TRANSFORM_TYPE
152 
156  typedef struct legion_domain_t {
157  realm_id_t is_id;
158  legion_type_tag_t is_type;
159  int dim;
160 // Hack: Python CFFI isn't smart enough to do constant folding so we
161 // have to do this by hand here. To avoid this bitrotting, at least
162 // make the preprocessor check that the value is equal to what we
163 // expect.
164 #if LEGION_MAX_DIM == 1
165 #define MAX_DOMAIN_DIM 2 // 2 * LEGION_MAX_RECT_DIM
166 #elif LEGION_MAX_DIM == 2
167 #define MAX_DOMAIN_DIM 4 // 2 * LEGION_MAX_RECT_DIM
168 #elif LEGION_MAX_DIM == 3
169 #define MAX_DOMAIN_DIM 6 // 2 * LEGION_MAX_RECT_DIM
170 #elif LEGION_MAX_DIM == 4
171 #define MAX_DOMAIN_DIM 8 // 2 * LEGION_MAX_RECT_DIM
172 #elif LEGION_MAX_DIM == 5
173 #define MAX_DOMAIN_DIM 10 // 2 * LEGION_MAX_RECT_DIM
174 #elif LEGION_MAX_DIM == 6
175 #define MAX_DOMAIN_DIM 12 // 2 * LEGION_MAX_RECT_DIM
176 #elif LEGION_MAX_DIM == 7
177 #define MAX_DOMAIN_DIM 14 // 2 * LEGION_MAX_RECT_DIM
178 #elif LEGION_MAX_DIM == 8
179 #define MAX_DOMAIN_DIM 16 // 2 * LEGION_MAX_RECT_DIM
180 #elif LEGION_MAX_DIM == 9
181 #define MAX_DOMAIN_DIM 18 // 2 * LEGION_MAX_RECT_DIM
182 #else
183 #error "Illegal value of LEGION_MAX_DIM"
184 #endif
185 #if MAX_DOMAIN_DIM != 2 * LEGION_MAX_RECT_DIM // sanity check value
186 #error Mismatch in MAX_DOMAIN_DIM
187 #endif
188  coord_t rect_data[MAX_DOMAIN_DIM];
189 #undef MAX_DOMAIN_DIM
190  } legion_domain_t;
191 
195  typedef struct legion_domain_point_t {
196  int dim;
197  coord_t point_data[LEGION_MAX_DIM];
198  } legion_domain_point_t;
199 
203  typedef struct legion_domain_transform_t {
204  int m, n;
205 // Hack: Python CFFI isn't smart enough to do constant folding so we
206 // have to do this by hand here. To avoid this bitrotting, at least
207 // make the preprocessor check that the value is equal to what we
208 // expect.
209 #if LEGION_MAX_DIM == 1
210 #define MAX_MATRIX_DIM 1
211 #elif LEGION_MAX_DIM == 2
212 #define MAX_MATRIX_DIM 4
213 #elif LEGION_MAX_DIM == 3
214 #define MAX_MATRIX_DIM 9
215 #elif LEGION_MAX_DIM == 4
216 #define MAX_MATRIX_DIM 16
217 #elif LEGION_MAX_DIM == 5
218 #define MAX_MATRIX_DIM 25
219 #elif LEGION_MAX_DIM == 6
220 #define MAX_MATRIX_DIM 36
221 #elif LEGION_MAX_DIM == 7
222 #define MAX_MATRIX_DIM 49
223 #elif LEGION_MAX_DIM == 8
224 #define MAX_MATRIX_DIM 64
225 #elif LEGION_MAX_DIM == 9
226 #define MAX_MATRIX_DIM 81
227 #else
228 #error "Illegal value of LEGION_MAX_DIM"
229 #endif
230 #if MAX_MATRIX_DIM != LEGION_MAX_POINT_DIM * LEGION_MAX_POINT_DIM // sanity check
231 #error Mismatch in MAX_MATRIX_DIM
232 #endif
233  coord_t matrix[MAX_MATRIX_DIM];
234 #undef MAX_MATRIX_DIM
235  } legion_domain_transform_t;
236 
240  typedef struct legion_domain_affine_transform_t {
241  legion_domain_transform_t transform;
242  legion_domain_point_t offset;
243  } legion_domain_affine_transform_t;
244 
248  typedef struct legion_index_space_t {
249  legion_index_space_id_t id;
250  legion_index_tree_id_t tid;
251  legion_type_tag_t type_tag;
252  } legion_index_space_t;
253 
257  typedef struct legion_index_partition_t {
258  legion_index_partition_id_t id;
259  legion_index_tree_id_t tid;
260  legion_type_tag_t type_tag;
261  } legion_index_partition_t;
262 
266  typedef struct legion_field_space_t {
267  legion_field_space_id_t id;
268  } legion_field_space_t;
269 
273  typedef struct legion_logical_region_t {
274  legion_region_tree_id_t tree_id;
275  legion_index_space_t index_space;
276  legion_field_space_t field_space;
277  } legion_logical_region_t;
278 
282  typedef struct legion_logical_partition_t {
283  legion_region_tree_id_t tree_id;
284  legion_index_partition_t index_partition;
285  legion_field_space_t field_space;
286  } legion_logical_partition_t;
287 
291  typedef struct legion_untyped_buffer_t {
292  void *args;
293  size_t arglen;
294  } legion_untyped_buffer_t;
295  // This is for backwards compatibility when we used
296  // to call legion_untyped_buffer_t as legion_task_argument_t
297  typedef legion_untyped_buffer_t legion_task_argument_t;
298 
299  typedef struct legion_byte_offset_t {
300  int offset;
301  } legion_byte_offset_t;
302 
306  typedef struct legion_input_args_t {
307  char **argv;
308  int argc;
309  } legion_input_args_t;
310 
314  typedef struct legion_task_config_options_t {
315  bool leaf /* = false */;
316  bool inner /* = false */;
317  bool idempotent /* = false */;
318  bool replicable /* = false */;
319  } legion_task_config_options_t;
320 
324  typedef struct legion_processor_t {
325  realm_id_t id;
326  } legion_processor_t;
327 
331  typedef struct legion_memory_t {
332  realm_id_t id;
333  } legion_memory_t;
334 
338  typedef struct legion_task_slice_t {
339  legion_domain_t domain;
340  legion_processor_t proc;
341  bool recurse;
342  bool stealable;
343  } legion_task_slice_t;
344 
348  typedef struct legion_phase_barrier_t {
349  // From Realm::Event
350  realm_id_t id;
351  // From Realm::Barrier
352  realm_barrier_timestamp_t timestamp;
353  } legion_phase_barrier_t;
354 
358  typedef struct legion_dynamic_collective_t {
359  // From Legion::PhaseBarrier
360  // From Realm::Event
361  realm_id_t id;
362  // From Realm::Barrier
363  realm_barrier_timestamp_t timestamp;
364  // From Legion::DynamicCollective
365  legion_reduction_op_id_t redop;
366  } legion_dynamic_collective_t;
367 
371  typedef struct legion_task_options_t {
372  legion_processor_t initial_proc;
373  bool inline_task;
374  bool stealable;
375  bool map_locally;
376  bool valid_instances;
377  bool memoize;
378  bool replicate;
379  legion_task_priority_t parent_priority;
380  } legion_task_options_t;
381 
382  typedef struct legion_slice_task_input_t {
383  legion_domain_t domain;
384  } legion_slice_task_input_t;
385 
389  typedef
390  void (*legion_registration_callback_pointer_t)(
391  legion_machine_t /* machine */,
392  legion_runtime_t /* runtime */,
393  const legion_processor_t * /* local_procs */,
394  unsigned /* num_local_procs */);
395 
400  typedef realm_task_pointer_t legion_task_pointer_wrapped_t;
401 
406  typedef
407  legion_logical_region_t (*legion_projection_functor_logical_region_t)(
408  legion_runtime_t /* runtime */,
409  legion_logical_region_t /* upper_bound */,
410  legion_domain_point_t /* point */,
411  legion_domain_t /* launch domain */);
412 
417  typedef
418  legion_logical_region_t (*legion_projection_functor_logical_partition_t)(
419  legion_runtime_t /* runtime */,
420  legion_logical_partition_t /* upper_bound */,
421  legion_domain_point_t /* point */,
422  legion_domain_t /* launch domain */);
423 
428  typedef
429  legion_logical_region_t (*legion_projection_functor_logical_region_args_t)(
430  legion_runtime_t /* runtime */,
431  legion_logical_region_t /* upper_bound */,
432  legion_domain_point_t /* point */,
433  legion_domain_t /* launch domain */,
434  const void * /* args */,
435  size_t /* size */);
436 
441  typedef
442  legion_logical_region_t (*legion_projection_functor_logical_partition_args_t)(
443  legion_runtime_t /* runtime */,
444  legion_logical_partition_t /* upper_bound */,
445  legion_domain_point_t /* point */,
446  legion_domain_t /* launch domain */,
447  const void * /* args */,
448  size_t /* size */);
449 
454  typedef
455  legion_logical_region_t (*legion_projection_functor_logical_region_mappable_t)(
456  legion_runtime_t /* runtime */,
457  legion_mappable_t /* mappable */,
458  unsigned /* index */,
459  legion_logical_region_t /* upper_bound */,
460  legion_domain_point_t /* point */);
461 
466  typedef
467  legion_logical_region_t (*legion_projection_functor_logical_partition_mappable_t)(
468  legion_runtime_t /* runtime */,
469  legion_mappable_t /* mappable */,
470  unsigned /* index */,
471  legion_logical_partition_t /* upper_bound */,
472  legion_domain_point_t /* point */);
473 
474  // -----------------------------------------------------------------------
475  // Pointer Operations
476  // -----------------------------------------------------------------------
477 
481  legion_ptr_t
482  legion_ptr_nil(void);
483 
487  bool
488  legion_ptr_is_null(legion_ptr_t ptr);
489 
494  legion_ptr_t
495  legion_ptr_safe_cast(legion_runtime_t runtime,
496  legion_context_t ctx,
497  legion_ptr_t pointer,
498  legion_logical_region_t region);
499 
500  // -----------------------------------------------------------------------
501  // Domain Operations
502  // -----------------------------------------------------------------------
503 
507  legion_domain_t
508  legion_domain_empty(unsigned dim);
509 
513 #define FROM_RECT(DIM) \
514  legion_domain_t \
515  legion_domain_from_rect_##DIM##d(legion_rect_##DIM##d_t r);
516  LEGION_FOREACH_N(FROM_RECT)
517 #undef FROM_RECT
518 
522  legion_domain_t
523  legion_domain_from_index_space(legion_runtime_t runtime,
524  legion_index_space_t is);
525 
529 #define GET_RECT(DIM) \
530  legion_rect_##DIM##d_t \
531  legion_domain_get_rect_##DIM##d(legion_domain_t d);
532  LEGION_FOREACH_N(GET_RECT)
533 #undef GET_RECT
534 
535  bool
536  legion_domain_is_dense(legion_domain_t d);
537 
538  // These are the same as above but will ignore
539  // the existence of any sparsity map, whereas the
540  // ones above will fail if a sparsity map exists
541 #define GET_BOUNDS(DIM) \
542  legion_rect_##DIM##d_t \
543  legion_domain_get_bounds_##DIM##d(legion_domain_t d);
544  LEGION_FOREACH_N(GET_BOUNDS)
545 #undef GET_BOUNDS
546 
550  bool
551  legion_domain_contains(legion_domain_t d, legion_domain_point_t p);
552 
556  size_t
557  legion_domain_get_volume(legion_domain_t d);
558 
559  // -----------------------------------------------------------------------
560  // Domain Transform Operations
561  // -----------------------------------------------------------------------
562 
563  legion_domain_transform_t
564  legion_domain_transform_identity(unsigned m, unsigned n);
565 
566 #define FROM_TRANSFORM(D1,D2) \
567  legion_domain_transform_t \
568  legion_domain_transform_from_##D1##x##D2(legion_transform_##D1##x##D2##_t t);
569  LEGION_FOREACH_NN(FROM_TRANSFORM)
570 #undef FROM_TRANSFORM
571 
572  legion_domain_affine_transform_t
573  legion_domain_affine_transform_identity(unsigned m, unsigned n);
574 
575 #define FROM_AFFINE(D1,D2) \
576  legion_domain_affine_transform_t \
577  legion_domain_affine_transform_from_##D1##x##D2(legion_affine_transform_##D1##x##D2##_t t);
578  LEGION_FOREACH_NN(FROM_AFFINE)
579 #undef FROM_AFFINE
580 
581  // -----------------------------------------------------------------------
582  // Domain Point Operations
583  // -----------------------------------------------------------------------
584 
588 #define FROM_POINT(DIM) \
589  legion_domain_point_t \
590  legion_domain_point_from_point_##DIM##d(legion_point_##DIM##d_t p);
591  LEGION_FOREACH_N(FROM_POINT)
592 #undef FROM_POINT
593 
597 #define GET_POINT(DIM) \
598  legion_point_##DIM##d_t \
599  legion_domain_point_get_point_##DIM##d(legion_domain_point_t p);
600  LEGION_FOREACH_N(GET_POINT)
601 #undef GET_POINT
602 
603  legion_domain_point_t
604  legion_domain_point_origin(unsigned dim);
605 
609  legion_domain_point_t
610  legion_domain_point_nil(void);
611 
615  bool
616  legion_domain_point_is_null(legion_domain_point_t point);
617 
622  legion_domain_point_t
623  legion_domain_point_safe_cast(legion_runtime_t runtime,
624  legion_context_t ctx,
625  legion_domain_point_t point,
626  legion_logical_region_t region);
627 
628  // -----------------------------------------------------------------------
629  // Domain Point Iterator
630  // -----------------------------------------------------------------------
631 
637  legion_domain_point_iterator_t
638  legion_domain_point_iterator_create(legion_domain_t handle);
639 
645  void
646  legion_domain_point_iterator_destroy(legion_domain_point_iterator_t handle);
647 
651  bool
652  legion_domain_point_iterator_has_next(legion_domain_point_iterator_t handle);
653 
657  legion_domain_point_t
658  legion_domain_point_iterator_next(legion_domain_point_iterator_t handle);
659 
660  // -----------------------------------------------------------------------
661  // Rect in Domain Iterator
662  // -----------------------------------------------------------------------
663 
669 #define ITERATOR_CREATE(DIM) \
670  legion_rect_in_domain_iterator_##DIM##d_t \
671  legion_rect_in_domain_iterator_create_##DIM##d(legion_domain_t handle);
672  LEGION_FOREACH_N(ITERATOR_CREATE)
673 #undef ITERATOR_CREATE
674 
680 #define ITERATOR_DESTROY(DIM) \
681  void legion_rect_in_domain_iterator_destroy_##DIM##d( \
682  legion_rect_in_domain_iterator_##DIM##d_t handle);
683  LEGION_FOREACH_N(ITERATOR_DESTROY)
684 #undef ITERATOR_DESTROY
685 
689 #define ITERATOR_VALID(DIM) \
690  bool legion_rect_in_domain_iterator_valid_##DIM##d( \
691  legion_rect_in_domain_iterator_##DIM##d_t handle);
692  LEGION_FOREACH_N(ITERATOR_VALID)
693 #undef ITERATOR_VALID
694 
698 #define ITERATOR_STEP(DIM) \
699  bool legion_rect_in_domain_iterator_step_##DIM##d( \
700  legion_rect_in_domain_iterator_##DIM##d_t handle);
701  LEGION_FOREACH_N(ITERATOR_STEP)
702 #undef ITERATOR_STEP
703 
707 #define ITERATOR_OP(DIM) \
708  legion_rect_##DIM##d_t \
709  legion_rect_in_domain_iterator_get_rect_##DIM##d( \
710  legion_rect_in_domain_iterator_##DIM##d_t handle);
711  LEGION_FOREACH_N(ITERATOR_OP)
712 #undef ITERATOR_OP
713 
714  // -----------------------------------------------------------------------
715  // Coloring Operations
716  // -----------------------------------------------------------------------
717 
723  legion_coloring_t
724  legion_coloring_create(void);
725 
731  void
732  legion_coloring_destroy(legion_coloring_t handle);
733 
737  void
738  legion_coloring_ensure_color(legion_coloring_t handle,
739  legion_color_t color);
740 
744  void
745  legion_coloring_add_point(legion_coloring_t handle,
746  legion_color_t color,
747  legion_ptr_t point);
748 
752  void
753  legion_coloring_delete_point(legion_coloring_t handle,
754  legion_color_t color,
755  legion_ptr_t point);
756 
760  bool
761  legion_coloring_has_point(legion_coloring_t handle,
762  legion_color_t color,
763  legion_ptr_t point);
764 
768  void
769  legion_coloring_add_range(legion_coloring_t handle,
770  legion_color_t color,
771  legion_ptr_t start,
772  legion_ptr_t end );
773 
774  // -----------------------------------------------------------------------
775  // Domain Coloring Operations
776  // -----------------------------------------------------------------------
777 
783  legion_domain_coloring_t
784  legion_domain_coloring_create(void);
785 
791  void
792  legion_domain_coloring_destroy(legion_domain_coloring_t handle);
793 
797  void
798  legion_domain_coloring_color_domain(legion_domain_coloring_t handle,
799  legion_color_t color,
800  legion_domain_t domain);
801 
805  legion_domain_t
806  legion_domain_coloring_get_color_space(legion_domain_coloring_t handle);
807 
808  // -----------------------------------------------------------------------
809  // Point Coloring Operations
810  // -----------------------------------------------------------------------
811 
817  legion_point_coloring_t
818  legion_point_coloring_create(void);
819 
825  void
826  legion_point_coloring_destroy(
827  legion_point_coloring_t handle);
828 
832  void
833  legion_point_coloring_add_point(legion_point_coloring_t handle,
834  legion_domain_point_t color,
835  legion_ptr_t point);
836 
840  void
841  legion_point_coloring_add_range(legion_point_coloring_t handle,
842  legion_domain_point_t color,
843  legion_ptr_t start,
844  legion_ptr_t end );
845 
846  // -----------------------------------------------------------------------
847  // Domain Point Coloring Operations
848  // -----------------------------------------------------------------------
849 
855  legion_domain_point_coloring_t
856  legion_domain_point_coloring_create(void);
857 
863  void
864  legion_domain_point_coloring_destroy(
865  legion_domain_point_coloring_t handle);
866 
870  void
871  legion_domain_point_coloring_color_domain(
872  legion_domain_point_coloring_t handle,
873  legion_domain_point_t color,
874  legion_domain_t domain);
875 
876  // -----------------------------------------------------------------------
877  // Multi-Domain Point Coloring Operations
878  // -----------------------------------------------------------------------
879 
885  legion_multi_domain_point_coloring_t
886  legion_multi_domain_point_coloring_create(void);
887 
893  void
894  legion_multi_domain_point_coloring_destroy(
895  legion_multi_domain_point_coloring_t handle);
896 
900  void
901  legion_multi_domain_point_coloring_color_domain(
902  legion_multi_domain_point_coloring_t handle,
903  legion_domain_point_t color,
904  legion_domain_t domain);
905 
906  // -----------------------------------------------------------------------
907  // Index Space Operations
908  // ----------------------------------------------------------------------
909 
915  legion_index_space_t
916  legion_index_space_create(legion_runtime_t runtime,
917  legion_context_t ctx,
918  size_t max_num_elmts);
919 
925  legion_index_space_t
926  legion_index_space_create_domain(legion_runtime_t runtime,
927  legion_context_t ctx,
928  legion_domain_t domain);
929 
935  legion_index_space_t
936  legion_index_space_create_future(legion_runtime_t runtime,
937  legion_context_t ctx,
938  size_t dimensions,
939  legion_future_t future,
940  legion_type_tag_t type_tag/*=0*/);
941 
947  legion_index_space_t
948  legion_index_space_union(legion_runtime_t runtime,
949  legion_context_t ctx,
950  const legion_index_space_t *spaces,
951  size_t num_spaces);
952 
958  legion_index_space_t
959  legion_index_space_intersection(legion_runtime_t runtime,
960  legion_context_t ctx,
961  const legion_index_space_t *spaces,
962  size_t num_spaces);
963 
969  legion_index_space_t
970  legion_index_space_subtraction(legion_runtime_t runtime,
971  legion_context_t ctx,
972  legion_index_space_t left,
973  legion_index_space_t right);
974 
978  bool
979  legion_index_space_has_multiple_domains(legion_runtime_t runtime,
980  legion_index_space_t handle);
981 
987  legion_domain_t
988  legion_index_space_get_domain(legion_runtime_t runtime,
989  legion_index_space_t handle);
990 
996  bool
997  legion_index_space_has_parent_index_partition(legion_runtime_t runtime,
998  legion_index_space_t handle);
1004  legion_index_partition_t
1005  legion_index_space_get_parent_index_partition(legion_runtime_t runtime,
1006  legion_index_space_t handle);
1007 
1013  void
1014  legion_index_space_create_shared_ownership(legion_runtime_t runtime,
1015  legion_context_t ctx,
1016  legion_index_space_t handle);
1017 
1023  void
1024  legion_index_space_destroy(legion_runtime_t runtime,
1025  legion_context_t ctx,
1026  legion_index_space_t handle);
1027 
1033  void
1034  legion_index_space_destroy_unordered(legion_runtime_t runtime,
1035  legion_context_t ctx,
1036  legion_index_space_t handle,
1037  bool unordered);
1038 
1042  void
1043  legion_index_space_attach_semantic_information(legion_runtime_t runtime,
1044  legion_index_space_t handle,
1045  legion_semantic_tag_t tag,
1046  const void *buffer,
1047  size_t size,
1048  bool is_mutable /* = false */);
1049 
1053  bool
1054  legion_index_space_retrieve_semantic_information(
1055  legion_runtime_t runtime,
1056  legion_index_space_t handle,
1057  legion_semantic_tag_t tag,
1058  const void **result,
1059  size_t *size,
1060  bool can_fail /* = false */,
1061  bool wait_until_ready /* = false */);
1062 
1066  void
1067  legion_index_space_attach_name(legion_runtime_t runtime,
1068  legion_index_space_t handle,
1069  const char *name,
1070  bool is_mutable /* = false */);
1071 
1075  void
1076  legion_index_space_retrieve_name(legion_runtime_t runtime,
1077  legion_index_space_t handle,
1078  const char **result);
1079 
1085  int
1086  legion_index_space_get_dim(legion_index_space_t handle);
1087 
1088  // -----------------------------------------------------------------------
1089  // Index Partition Operations
1090  // -----------------------------------------------------------------------
1091 
1098  legion_index_partition_t
1099  legion_index_partition_create_coloring(
1100  legion_runtime_t runtime,
1101  legion_context_t ctx,
1102  legion_index_space_t parent,
1103  legion_coloring_t coloring,
1104  bool disjoint,
1105  legion_color_t part_color /* = AUTO_GENERATE_ID */);
1106 
1113  legion_index_partition_t
1114  legion_index_partition_create_domain_coloring(
1115  legion_runtime_t runtime,
1116  legion_context_t ctx,
1117  legion_index_space_t parent,
1118  legion_domain_t color_space,
1119  legion_domain_coloring_t coloring,
1120  bool disjoint,
1121  legion_color_t part_color /* = AUTO_GENERATE_ID */);
1122 
1129  legion_index_partition_t
1130  legion_index_partition_create_point_coloring(
1131  legion_runtime_t runtime,
1132  legion_context_t ctx,
1133  legion_index_space_t parent,
1134  legion_domain_t color_space,
1135  legion_point_coloring_t coloring,
1136  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1137  legion_color_t color /* = AUTO_GENERATE_ID */);
1138 
1145  legion_index_partition_t
1146  legion_index_partition_create_domain_point_coloring(
1147  legion_runtime_t runtime,
1148  legion_context_t ctx,
1149  legion_index_space_t parent,
1150  legion_domain_t color_space,
1151  legion_domain_point_coloring_t coloring,
1152  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1153  legion_color_t color /* = AUTO_GENERATE_ID */);
1154 
1161  legion_index_partition_t
1162  legion_index_partition_create_multi_domain_point_coloring(
1163  legion_runtime_t runtime,
1164  legion_context_t ctx,
1165  legion_index_space_t parent,
1166  legion_domain_t color_space,
1167  legion_multi_domain_point_coloring_t coloring,
1168  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1169  legion_color_t color /* = AUTO_GENERATE_ID */);
1170 
1177 #define CREATE_BLOCKIFY(DIM) \
1178  legion_index_partition_t \
1179  legion_index_partition_create_blockify_##DIM##d( \
1180  legion_runtime_t runtime, \
1181  legion_context_t ctx, \
1182  legion_index_space_t parent, \
1183  legion_blockify_##DIM##d_t blockify, \
1184  legion_color_t part_color /* = AUTO_GENERATE_ID */);
1185  LEGION_FOREACH_N(CREATE_BLOCKIFY)
1186 #undef CREATE_BLOCKIFY
1187 
1193  legion_index_partition_t
1194  legion_index_partition_create_equal(legion_runtime_t runtime,
1195  legion_context_t ctx,
1196  legion_index_space_t parent,
1197  legion_index_space_t color_space,
1198  size_t granularity,
1199  legion_color_t color /* = AUTO_GENERATE_ID */);
1200 
1206  legion_index_partition_t
1207  legion_index_partition_create_by_weights(
1208  legion_runtime_t runtime,
1209  legion_context_t ctx,
1210  legion_index_space_t parent,
1211  legion_domain_point_t *colors,
1212  int *weights,
1213  size_t num_colors,
1214  legion_index_space_t color_space,
1215  size_t granularity /* = 1 */,
1216  legion_color_t color /* = AUTO_GENERATE_ID */);
1217 
1223  legion_index_partition_t
1224  legion_index_partition_create_by_weights_future_map(
1225  legion_runtime_t runtime,
1226  legion_context_t ctx,
1227  legion_index_space_t parent,
1228  legion_future_map_t future_map,
1229  legion_index_space_t color_space,
1230  size_t granularity /* = 1 */,
1231  legion_color_t color /* = AUTO_GENERATE_ID */);
1232 
1238  legion_index_partition_t
1239  legion_index_partition_create_by_union(
1240  legion_runtime_t runtime,
1241  legion_context_t ctx,
1242  legion_index_space_t parent,
1243  legion_index_partition_t handle1,
1244  legion_index_partition_t handle2,
1245  legion_index_space_t color_space,
1246  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1247  legion_color_t color /* = AUTO_GENERATE_ID */);
1248 
1254  legion_index_partition_t
1255  legion_index_partition_create_by_intersection(
1256  legion_runtime_t runtime,
1257  legion_context_t ctx,
1258  legion_index_space_t parent,
1259  legion_index_partition_t handle1,
1260  legion_index_partition_t handle2,
1261  legion_index_space_t color_space,
1262  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1263  legion_color_t color /* = AUTO_GENERATE_ID */);
1264 
1270  legion_index_partition_t
1271  legion_index_partition_create_by_intersection_mirror(
1272  legion_runtime_t runtime,
1273  legion_context_t ctx,
1274  legion_index_space_t parent,
1275  legion_index_partition_t handle,
1276  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1277  legion_color_t color /* = AUTO_GENERATE_ID */,
1278  bool dominates /* = false */);
1279 
1285  legion_index_partition_t
1286  legion_index_partition_create_by_difference(
1287  legion_runtime_t runtime,
1288  legion_context_t ctx,
1289  legion_index_space_t parent,
1290  legion_index_partition_t handle1,
1291  legion_index_partition_t handle2,
1292  legion_index_space_t color_space,
1293  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1294  legion_color_t color /* = AUTO_GENERATE_ID */);
1295 
1301  legion_index_partition_t
1302  legion_index_partition_create_by_domain(
1303  legion_runtime_t runtime,
1304  legion_context_t ctx,
1305  legion_index_space_t parent,
1306  legion_domain_point_t *colors,
1307  legion_domain_t *domains,
1308  size_t num_color_domains,
1309  legion_index_space_t color_space,
1310  bool perform_intersections /* = true */,
1311  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1312  legion_color_t color /* = AUTO_GENERATE_ID */);
1313 
1319  legion_index_partition_t
1320  legion_index_partition_create_by_domain_future_map(
1321  legion_runtime_t runtime,
1322  legion_context_t ctx,
1323  legion_index_space_t parent,
1324  legion_future_map_t future_map,
1325  legion_index_space_t color_space,
1326  bool perform_intersections /* = true */,
1327  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1328  legion_color_t color /* = AUTO_GENERATE_ID */);
1329 
1335  legion_index_partition_t
1336  legion_index_partition_create_by_field(legion_runtime_t runtime,
1337  legion_context_t ctx,
1338  legion_logical_region_t handle,
1339  legion_logical_region_t parent,
1340  legion_field_id_t fid,
1341  legion_index_space_t color_space,
1342  legion_color_t color /* = AUTO_GENERATE_ID */,
1343  legion_mapper_id_t id /* = 0 */,
1344  legion_mapping_tag_id_t tag /* = 0 */,
1345  legion_partition_kind_t part_kind /* = DISJOINT_KIND */,
1346  legion_untyped_buffer_t map_arg);
1347 
1353  legion_index_partition_t
1354  legion_index_partition_create_by_image(
1355  legion_runtime_t runtime,
1356  legion_context_t ctx,
1357  legion_index_space_t handle,
1358  legion_logical_partition_t projection,
1359  legion_logical_region_t parent,
1360  legion_field_id_t fid,
1361  legion_index_space_t color_space,
1362  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1363  legion_color_t color /* = AUTO_GENERATE_ID */,
1364  legion_mapper_id_t id /* = 0 */,
1365  legion_mapping_tag_id_t tag /* = 0 */,
1366  legion_untyped_buffer_t map_arg);
1367 
1373  legion_index_partition_t
1374  legion_index_partition_create_by_preimage(
1375  legion_runtime_t runtime,
1376  legion_context_t ctx,
1377  legion_index_partition_t projection,
1378  legion_logical_region_t handle,
1379  legion_logical_region_t parent,
1380  legion_field_id_t fid,
1381  legion_index_space_t color_space,
1382  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1383  legion_color_t color /* = AUTO_GENERATE_ID */,
1384  legion_mapper_id_t id /* = 0 */,
1385  legion_mapping_tag_id_t tag /* = 0 */,
1386  legion_untyped_buffer_t map_arg);
1387 
1393  legion_index_partition_t
1394  legion_index_partition_create_by_image_range(
1395  legion_runtime_t runtime,
1396  legion_context_t ctx,
1397  legion_index_space_t handle,
1398  legion_logical_partition_t projection,
1399  legion_logical_region_t parent,
1400  legion_field_id_t fid,
1401  legion_index_space_t color_space,
1402  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1403  legion_color_t color /* = AUTO_GENERATE_ID */,
1404  legion_mapper_id_t id /* = 0 */,
1405  legion_mapping_tag_id_t tag /* = 0 */,
1406  legion_untyped_buffer_t map_arg);
1407 
1413  legion_index_partition_t
1414  legion_index_partition_create_by_preimage_range(
1415  legion_runtime_t runtime,
1416  legion_context_t ctx,
1417  legion_index_partition_t projection,
1418  legion_logical_region_t handle,
1419  legion_logical_region_t parent,
1420  legion_field_id_t fid,
1421  legion_index_space_t color_space,
1422  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1423  legion_color_t color /* = AUTO_GENERATE_ID */,
1424  legion_mapper_id_t id /* = 0 */,
1425  legion_mapping_tag_id_t tag /* = 0 */,
1426  legion_untyped_buffer_t map_arg);
1427 
1433  legion_index_partition_t
1434  legion_index_partition_create_by_restriction(
1435  legion_runtime_t runtime,
1436  legion_context_t ctx,
1437  legion_index_space_t parent,
1438  legion_index_space_t color_space,
1439  legion_domain_transform_t transform,
1440  legion_domain_t extent,
1441  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1442  legion_color_t color /* = AUTO_GENERATE_ID */);
1443 
1449  legion_index_partition_t
1450  legion_index_partition_create_pending_partition(
1451  legion_runtime_t runtime,
1452  legion_context_t ctx,
1453  legion_index_space_t parent,
1454  legion_index_space_t color_space,
1455  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1456  legion_color_t color /* = AUTO_GENERATE_ID */);
1457 
1461  legion_index_space_t
1462  legion_index_partition_create_index_space_union_spaces(
1463  legion_runtime_t runtime,
1464  legion_context_t ctx,
1465  legion_index_partition_t parent,
1466  legion_domain_point_t color,
1467  const legion_index_space_t *spaces,
1468  size_t num_spaces);
1469 
1473  legion_index_space_t
1474  legion_index_partition_create_index_space_union_partition(
1475  legion_runtime_t runtime,
1476  legion_context_t ctx,
1477  legion_index_partition_t parent,
1478  legion_domain_point_t color,
1479  legion_index_partition_t handle);
1480 
1484  legion_index_space_t
1485  legion_index_partition_create_index_space_intersection_spaces(
1486  legion_runtime_t runtime,
1487  legion_context_t ctx,
1488  legion_index_partition_t parent,
1489  legion_domain_point_t color,
1490  const legion_index_space_t *spaces,
1491  size_t num_spaces);
1492 
1496  legion_index_space_t
1497  legion_index_partition_create_index_space_intersection_partition(
1498  legion_runtime_t runtime,
1499  legion_context_t ctx,
1500  legion_index_partition_t parent,
1501  legion_domain_point_t color,
1502  legion_index_partition_t handle);
1503 
1507  legion_index_space_t
1508  legion_index_partition_create_index_space_difference(
1509  legion_runtime_t runtime,
1510  legion_context_t ctx,
1511  legion_index_partition_t parent,
1512  legion_domain_point_t color,
1513  legion_index_space_t initial,
1514  const legion_index_space_t *spaces,
1515  size_t num_spaces);
1516 
1520  bool
1521  legion_index_partition_is_disjoint(legion_runtime_t runtime,
1522  legion_index_partition_t handle);
1523 
1527  bool
1528  legion_index_partition_is_complete(legion_runtime_t runtime,
1529  legion_index_partition_t handle);
1530 
1536  legion_index_space_t
1537  legion_index_partition_get_index_subspace(legion_runtime_t runtime,
1538  legion_index_partition_t handle,
1539  legion_color_t color);
1540 
1546  legion_index_space_t
1547  legion_index_partition_get_index_subspace_domain_point(
1548  legion_runtime_t runtime,
1549  legion_index_partition_t handle,
1550  legion_domain_point_t color);
1551 
1555  bool
1556  legion_index_partition_has_index_subspace_domain_point(
1557  legion_runtime_t runtime,
1558  legion_index_partition_t handle,
1559  legion_domain_point_t color);
1560 
1564  legion_index_space_t
1565  legion_index_partition_get_color_space(legion_runtime_t runtime,
1566  legion_index_partition_t handle);
1567 
1571  legion_color_t
1572  legion_index_partition_get_color(legion_runtime_t runtime,
1573  legion_index_partition_t handle);
1574 
1580  legion_index_space_t
1581  legion_index_partition_get_parent_index_space(legion_runtime_t runtime,
1582  legion_index_partition_t handle);
1583 
1589  void
1590  legion_index_partition_create_shared_ownership(legion_runtime_t runtime,
1591  legion_context_t ctx,
1592  legion_index_partition_t handle);
1593 
1599  void
1600  legion_index_partition_destroy(legion_runtime_t runtime,
1601  legion_context_t ctx,
1602  legion_index_partition_t handle);
1603 
1609  void
1610  legion_index_partition_destroy_unordered(legion_runtime_t runtime,
1611  legion_context_t ctx,
1612  legion_index_partition_t handle,
1613  bool unordered /* = false */,
1614  bool recurse /* = true */);
1615 
1619  void
1620  legion_index_partition_attach_semantic_information(
1621  legion_runtime_t runtime,
1622  legion_index_partition_t handle,
1623  legion_semantic_tag_t tag,
1624  const void *buffer,
1625  size_t size,
1626  bool is_mutable /* = false */);
1627 
1631  bool
1632  legion_index_partition_retrieve_semantic_information(
1633  legion_runtime_t runtime,
1634  legion_index_partition_t handle,
1635  legion_semantic_tag_t tag,
1636  const void **result,
1637  size_t *size,
1638  bool can_fail /* = false */,
1639  bool wait_until_ready /* = false */);
1640 
1644  void
1645  legion_index_partition_attach_name(legion_runtime_t runtime,
1646  legion_index_partition_t handle,
1647  const char *name,
1648  bool is_mutable /* = false */);
1649 
1653  void
1654  legion_index_partition_retrieve_name(legion_runtime_t runtime,
1655  legion_index_partition_t handle,
1656  const char **result);
1657 
1658  // -----------------------------------------------------------------------
1659  // Field Space Operations
1660  // -----------------------------------------------------------------------
1661 
1667  legion_field_space_t
1668  legion_field_space_create(legion_runtime_t runtime,
1669  legion_context_t ctx);
1670 
1676  legion_field_space_t
1677  legion_field_space_create_with_fields(legion_runtime_t runtime,
1678  legion_context_t ctx,
1679  size_t *field_sizes,
1680  legion_field_id_t *field_ids,
1681  size_t num_fields,
1682  legion_custom_serdez_id_t serdez);
1683 
1689  legion_field_space_t
1690  legion_field_space_create_with_futures(legion_runtime_t runtime,
1691  legion_context_t ctx,
1692  legion_future_t *field_sizes,
1693  legion_field_id_t *field_ids,
1694  size_t num_fields,
1695  legion_custom_serdez_id_t serdez);
1696 
1700  legion_field_space_t
1701  legion_field_space_no_space();
1702 
1708  void
1709  legion_field_space_create_shared_ownership(legion_runtime_t runtime,
1710  legion_context_t ctx,
1711  legion_field_space_t handle);
1712 
1718  void
1719  legion_field_space_destroy(legion_runtime_t runtime,
1720  legion_context_t ctx,
1721  legion_field_space_t handle);
1722 
1728  void
1729  legion_field_space_destroy_unordered(legion_runtime_t runtime,
1730  legion_context_t ctx,
1731  legion_field_space_t handle,
1732  bool unordered);
1733 
1737  void
1738  legion_field_space_attach_semantic_information(
1739  legion_runtime_t runtime,
1740  legion_field_space_t handle,
1741  legion_semantic_tag_t tag,
1742  const void *buffer,
1743  size_t size,
1744  bool is_mutable /* = false */);
1745 
1749  bool
1750  legion_field_space_retrieve_semantic_information(
1751  legion_runtime_t runtime,
1752  legion_field_space_t handle,
1753  legion_semantic_tag_t tag,
1754  const void **result,
1755  size_t *size,
1756  bool can_fail /* = false */,
1757  bool wait_until_ready /* = false */);
1758 
1764  legion_field_id_t *
1765  legion_field_space_get_fields(legion_runtime_t runtime,
1766  legion_context_t ctx,
1767  legion_field_space_t handle,
1768  size_t *size);
1769 
1775  bool
1776  legion_field_space_has_fields(legion_runtime_t runtime,
1777  legion_context_t ctx,
1778  legion_field_space_t handle,
1779  const legion_field_id_t *fields,
1780  size_t fields_size);
1781 
1785  void
1786  legion_field_id_attach_semantic_information(legion_runtime_t runtime,
1787  legion_field_space_t handle,
1788  legion_field_id_t id,
1789  legion_semantic_tag_t tag,
1790  const void *buffer,
1791  size_t size,
1792  bool is_mutable /* = false */);
1793 
1797  bool
1798  legion_field_id_retrieve_semantic_information(
1799  legion_runtime_t runtime,
1800  legion_field_space_t handle,
1801  legion_field_id_t id,
1802  legion_semantic_tag_t tag,
1803  const void **result,
1804  size_t *size,
1805  bool can_fail /* = false */,
1806  bool wait_until_ready /* = false */);
1807 
1811  void
1812  legion_field_space_attach_name(legion_runtime_t runtime,
1813  legion_field_space_t handle,
1814  const char *name,
1815  bool is_mutable /* = false */);
1816 
1820  void
1821  legion_field_space_retrieve_name(legion_runtime_t runtime,
1822  legion_field_space_t handle,
1823  const char **result);
1824 
1828  void
1829  legion_field_id_attach_name(legion_runtime_t runtime,
1830  legion_field_space_t handle,
1831  legion_field_id_t id,
1832  const char *name,
1833  bool is_mutable /* = false */);
1834 
1838  void
1839  legion_field_id_retrieve_name(legion_runtime_t runtime,
1840  legion_field_space_t handle,
1841  legion_field_id_t id,
1842  const char **result);
1843 
1847  size_t
1848  legion_field_id_get_size(legion_runtime_t runtime,
1849  legion_context_t ctx,
1850  legion_field_space_t handle,
1851  legion_field_id_t id);
1852 
1853  // -----------------------------------------------------------------------
1854  // Logical Region Operations
1855  // -----------------------------------------------------------------------
1856 
1862  legion_logical_region_t
1863  legion_logical_region_create(legion_runtime_t runtime,
1864  legion_context_t ctx,
1865  legion_index_space_t index,
1866  legion_field_space_t fields,
1867  bool task_local);
1868 
1874  void
1875  legion_logical_region_create_shared_ownership(legion_runtime_t runtime,
1876  legion_context_t ctx,
1877  legion_logical_region_t handle);
1878 
1884  void
1885  legion_logical_region_destroy(legion_runtime_t runtime,
1886  legion_context_t ctx,
1887  legion_logical_region_t handle);
1888 
1894  void
1895  legion_logical_region_destroy_unordered(legion_runtime_t runtime,
1896  legion_context_t ctx,
1897  legion_logical_region_t handle,
1898  bool unordered);
1899 
1903  legion_color_t
1904  legion_logical_region_get_color(legion_runtime_t runtime,
1905  legion_logical_region_t handle);
1906 
1910  legion_domain_point_t
1911  legion_logical_region_get_color_domain_point(legion_runtime_t runtime_,
1912  legion_logical_region_t handle_);
1913 
1917  bool
1918  legion_logical_region_has_parent_logical_partition(
1919  legion_runtime_t runtime,
1920  legion_logical_region_t handle);
1921 
1925  legion_logical_partition_t
1926  legion_logical_region_get_parent_logical_partition(
1927  legion_runtime_t runtime,
1928  legion_logical_region_t handle);
1929 
1933  void
1934  legion_logical_region_attach_semantic_information(
1935  legion_runtime_t runtime,
1936  legion_logical_region_t handle,
1937  legion_semantic_tag_t tag,
1938  const void *buffer,
1939  size_t size,
1940  bool is_mutable /* = false */);
1941 
1945  bool
1946  legion_logical_region_retrieve_semantic_information(
1947  legion_runtime_t runtime,
1948  legion_logical_region_t handle,
1949  legion_semantic_tag_t tag,
1950  const void **result,
1951  size_t *size,
1952  bool can_fail /* = false */,
1953  bool wait_until_ready /* = false */);
1954 
1958  void
1959  legion_logical_region_attach_name(legion_runtime_t runtime,
1960  legion_logical_region_t handle,
1961  const char *name,
1962  bool is_mutable /* = false */);
1963 
1967  void
1968  legion_logical_region_retrieve_name(legion_runtime_t runtime,
1969  legion_logical_region_t handle,
1970  const char **result);
1971 
1975  legion_index_space_t
1976  legion_logical_region_get_index_space(legion_logical_region_t handle);
1977 
1978  // -----------------------------------------------------------------------
1979  // Logical Region Tree Traversal Operations
1980  // -----------------------------------------------------------------------
1981 
1987  legion_logical_partition_t
1988  legion_logical_partition_create(legion_runtime_t runtime,
1989  legion_logical_region_t parent,
1990  legion_index_partition_t handle);
1991 
1997  legion_logical_partition_t
1998  legion_logical_partition_create_by_tree(legion_runtime_t runtime,
1999  legion_context_t ctx,
2000  legion_index_partition_t handle,
2001  legion_field_space_t fspace,
2002  legion_region_tree_id_t tid);
2003 
2009  void
2010  legion_logical_partition_destroy(legion_runtime_t runtime,
2011  legion_context_t ctx,
2012  legion_logical_partition_t handle);
2013 
2019  void
2020  legion_logical_partition_destroy_unordered(legion_runtime_t runtime,
2021  legion_context_t ctx,
2022  legion_logical_partition_t handle,
2023  bool unordered);
2024 
2030  legion_logical_region_t
2031  legion_logical_partition_get_logical_subregion(
2032  legion_runtime_t runtime,
2033  legion_logical_partition_t parent,
2034  legion_index_space_t handle);
2035 
2041  legion_logical_region_t
2042  legion_logical_partition_get_logical_subregion_by_color(
2043  legion_runtime_t runtime,
2044  legion_logical_partition_t parent,
2045  legion_color_t c);
2046 
2052  legion_logical_region_t
2053  legion_logical_partition_get_logical_subregion_by_color_domain_point(
2054  legion_runtime_t runtime,
2055  legion_logical_partition_t parent,
2056  legion_domain_point_t c);
2057 
2061  bool
2062  legion_logical_partition_has_logical_subregion_by_color_domain_point(
2063  legion_runtime_t runtime,
2064  legion_logical_partition_t parent,
2065  legion_domain_point_t c);
2066 
2072  legion_logical_region_t
2073  legion_logical_partition_get_logical_subregion_by_tree(
2074  legion_runtime_t runtime,
2075  legion_index_space_t handle,
2076  legion_field_space_t fspace,
2077  legion_region_tree_id_t tid);
2078 
2082  legion_logical_region_t
2083  legion_logical_partition_get_parent_logical_region(
2084  legion_runtime_t runtime,
2085  legion_logical_partition_t handle);
2086 
2090  void
2091  legion_logical_partition_attach_semantic_information(
2092  legion_runtime_t runtime,
2093  legion_logical_partition_t handle,
2094  legion_semantic_tag_t tag,
2095  const void *buffer,
2096  size_t size,
2097  bool is_mutable /* = false */);
2098 
2102  bool
2103  legion_logical_partition_retrieve_semantic_information(
2104  legion_runtime_t runtime,
2105  legion_logical_partition_t handle,
2106  legion_semantic_tag_t tag,
2107  const void **result,
2108  size_t *size,
2109  bool can_fail /* = false */,
2110  bool wait_until_ready /* = false */);
2111 
2115  void
2116  legion_logical_partition_attach_name(legion_runtime_t runtime,
2117  legion_logical_partition_t handle,
2118  const char *name,
2119  bool is_mutable /* = false */);
2120 
2124  void
2125  legion_logical_partition_retrieve_name(legion_runtime_t runtime,
2126  legion_logical_partition_t handle,
2127  const char **result);
2128 
2135  void legion_reset_equivalence_sets(legion_runtime_t runtime,
2136  legion_context_t ctx,
2137  legion_logical_region_t parent,
2138  legion_logical_region_t region,
2139  int num_fields,
2140  legion_field_id_t* fields);
2141 
2142  // -----------------------------------------------------------------------
2143  // Region Requirement Operations
2144  // -----------------------------------------------------------------------
2145 
2149  legion_region_requirement_t
2150  legion_region_requirement_create_logical_region(
2151  legion_logical_region_t handle,
2152  legion_privilege_mode_t priv,
2153  legion_coherence_property_t prop,
2154  legion_logical_region_t parent,
2155  legion_mapping_tag_id_t tag /* = 0 */,
2156  bool verified /* = false*/);
2157 
2161  legion_region_requirement_t
2162  legion_region_requirement_create_logical_region_projection(
2163  legion_logical_region_t handle,
2164  legion_projection_id_t proj /* = 0 */,
2165  legion_privilege_mode_t priv,
2166  legion_coherence_property_t prop,
2167  legion_logical_region_t parent,
2168  legion_mapping_tag_id_t tag /* = 0 */,
2169  bool verified /* = false*/);
2170 
2174  legion_region_requirement_t
2175  legion_region_requirement_create_logical_partition(
2176  legion_logical_partition_t handle,
2177  legion_projection_id_t proj /* = 0 */,
2178  legion_privilege_mode_t priv,
2179  legion_coherence_property_t prop,
2180  legion_logical_region_t parent,
2181  legion_mapping_tag_id_t tag /* = 0 */,
2182  bool verified /* = false*/);
2183 
2187  void
2188  legion_region_requirement_destroy(legion_region_requirement_t handle);
2189 
2193  void
2194  legion_region_requirement_add_field(legion_region_requirement_t handle,
2195  legion_field_id_t field,
2196  bool instance_field);
2197 
2201  void
2202  legion_region_requirement_add_flags(legion_region_requirement_t handle,
2203  legion_region_flags_t flags);
2204 
2208  legion_logical_region_t
2209  legion_region_requirement_get_region(legion_region_requirement_t handle);
2210 
2214  legion_logical_region_t
2215  legion_region_requirement_get_parent(legion_region_requirement_t handle);
2216 
2220  legion_logical_partition_t
2221  legion_region_requirement_get_partition(legion_region_requirement_t handle);
2222 
2226  unsigned
2227  legion_region_requirement_get_privilege_fields_size(
2228  legion_region_requirement_t handle);
2229 
2241  void
2242  legion_region_requirement_get_privilege_fields(
2243  legion_region_requirement_t handle,
2244  legion_field_id_t* fields,
2245  unsigned fields_size);
2246 
2254  legion_field_id_t
2255  legion_region_requirement_get_privilege_field(
2256  legion_region_requirement_t handle,
2257  unsigned idx);
2258 
2262  unsigned
2263  legion_region_requirement_get_instance_fields_size(
2264  legion_region_requirement_t handle);
2265 
2277  void
2278  legion_region_requirement_get_instance_fields(
2279  legion_region_requirement_t handle,
2280  legion_field_id_t* fields,
2281  unsigned fields_size);
2282 
2288  legion_field_id_t
2289  legion_region_requirement_get_instance_field(
2290  legion_region_requirement_t handle,
2291  unsigned idx);
2292 
2296  legion_privilege_mode_t
2297  legion_region_requirement_get_privilege(legion_region_requirement_t handle);
2298 
2302  legion_coherence_property_t
2303  legion_region_requirement_get_prop(legion_region_requirement_t handle);
2304 
2308  legion_reduction_op_id_t
2309  legion_region_requirement_get_redop(legion_region_requirement_t handle);
2310 
2314  legion_mapping_tag_id_t
2315  legion_region_requirement_get_tag(legion_region_requirement_t handle);
2316 
2320  legion_handle_type_t
2321  legion_region_requirement_get_handle_type(legion_region_requirement_t handle);
2322 
2326  legion_projection_id_t
2327  legion_region_requirement_get_projection(legion_region_requirement_t handle);
2328 
2329  // -----------------------------------------------------------------------
2330  // Output Requirement Operations
2331  // -----------------------------------------------------------------------
2332 
2336  legion_output_requirement_t
2337  legion_output_requirement_create(legion_field_space_t field_space,
2338  legion_field_id_t *fields,
2339  size_t fields_size,
2340  int dim,
2341  bool global_indexing);
2342 
2346  legion_output_requirement_t
2347  legion_output_requirement_create_region_requirement(
2348  legion_region_requirement_t handle);
2349 
2353  void
2354  legion_output_requirement_destroy(legion_output_requirement_t handle);
2355 
2359  void
2360  legion_output_requirement_add_field(legion_output_requirement_t handle,
2361  legion_field_id_t field,
2362  bool instance);
2363 
2367  legion_logical_region_t
2368  legion_output_requirement_get_region(legion_output_requirement_t handle);
2369 
2373  legion_logical_region_t
2374  legion_output_requirement_get_parent(legion_output_requirement_t handle);
2375 
2379  legion_logical_partition_t
2380  legion_output_requirement_get_partition(legion_output_requirement_t handle);
2381 
2382  // -----------------------------------------------------------------------
2383  // Allocator and Argument Map Operations
2384  // -----------------------------------------------------------------------
2385 
2391  legion_field_allocator_t
2392  legion_field_allocator_create(legion_runtime_t runtime,
2393  legion_context_t ctx,
2394  legion_field_space_t handle);
2395 
2401  void
2402  legion_field_allocator_destroy(legion_field_allocator_t handle);
2403 
2407  legion_field_id_t
2408  legion_auto_generate_id(void);
2409 
2413  legion_field_id_t
2414  legion_field_allocator_allocate_field(
2415  legion_field_allocator_t allocator,
2416  size_t field_size,
2417  legion_field_id_t desired_fieldid /* = AUTO_GENERATE_ID */);
2418 
2422  legion_field_id_t
2423  legion_field_allocator_allocate_field_future(
2424  legion_field_allocator_t allocator,
2425  legion_future_t field_size,
2426  legion_field_id_t desired_fieldid /* = AUTO_GENERATE_ID */);
2427 
2431  void
2432  legion_field_allocator_free_field(legion_field_allocator_t allocator,
2433  legion_field_id_t fid);
2434 
2438  void
2439  legion_field_allocator_free_field_unordered(legion_field_allocator_t allocator,
2440  legion_field_id_t fid,
2441  bool unordered);
2442 
2446  legion_field_id_t
2447  legion_field_allocator_allocate_local_field(
2448  legion_field_allocator_t allocator,
2449  size_t field_size,
2450  legion_field_id_t desired_fieldid /* = AUTO_GENERATE_ID */);
2451 
2457  legion_argument_map_t
2458  legion_argument_map_create(void);
2459 
2465  legion_argument_map_t
2466  legion_argument_map_from_future_map(legion_future_map_t map);
2467 
2471  void
2472  legion_argument_map_set_point(legion_argument_map_t map,
2473  legion_domain_point_t dp,
2474  legion_untyped_buffer_t arg,
2475  bool replace /* = true */);
2476 
2480  void
2481  legion_argument_map_set_future(legion_argument_map_t map,
2482  legion_domain_point_t dp,
2483  legion_future_t future,
2484  bool replace /* = true */);
2485 
2491  void
2492  legion_argument_map_destroy(legion_argument_map_t handle);
2493 
2494  // -----------------------------------------------------------------------
2495  // Predicate Operations
2496  // -----------------------------------------------------------------------
2497 
2503  legion_predicate_t
2504  legion_predicate_create(legion_runtime_t runtime,
2505  legion_context_t ctx,
2506  legion_future_t f);
2507 
2513  void
2514  legion_predicate_destroy(legion_predicate_t handle);
2515 
2521  const legion_predicate_t
2522  legion_predicate_true(void);
2523 
2529  const legion_predicate_t
2530  legion_predicate_false(void);
2531 
2532  // -----------------------------------------------------------------------
2533  // Phase Barrier Operations
2534  // -----------------------------------------------------------------------
2535 
2541  legion_phase_barrier_t
2542  legion_phase_barrier_create(legion_runtime_t runtime,
2543  legion_context_t ctx,
2544  unsigned arrivals);
2545 
2551  void
2552  legion_phase_barrier_destroy(legion_runtime_t runtime,
2553  legion_context_t ctx,
2554  legion_phase_barrier_t handle);
2555 
2559  legion_phase_barrier_t
2560  legion_phase_barrier_alter_arrival_count(legion_runtime_t runtime,
2561  legion_context_t ctx,
2562  legion_phase_barrier_t handle,
2563  int delta);
2564 
2568  void
2569  legion_phase_barrier_arrive(legion_runtime_t runtime,
2570  legion_context_t ctx,
2571  legion_phase_barrier_t handle,
2572  unsigned count /* = 1 */);
2573 
2577  void
2578  legion_phase_barrier_wait(legion_runtime_t runtime,
2579  legion_context_t ctx,
2580  legion_phase_barrier_t handle);
2581 
2587  legion_phase_barrier_t
2588  legion_phase_barrier_advance(legion_runtime_t runtime,
2589  legion_context_t ctx,
2590  legion_phase_barrier_t handle);
2591 
2592  // -----------------------------------------------------------------------
2593  // Dynamic Collective Operations
2594  // -----------------------------------------------------------------------
2595 
2601  legion_dynamic_collective_t
2602  legion_dynamic_collective_create(legion_runtime_t runtime,
2603  legion_context_t ctx,
2604  unsigned arrivals,
2605  legion_reduction_op_id_t redop,
2606  const void *init_value,
2607  size_t init_size);
2608 
2614  void
2615  legion_dynamic_collective_destroy(legion_runtime_t runtime,
2616  legion_context_t ctx,
2617  legion_dynamic_collective_t handle);
2618 
2622  legion_dynamic_collective_t
2623  legion_dynamic_collective_alter_arrival_count(
2624  legion_runtime_t runtime,
2625  legion_context_t ctx,
2626  legion_dynamic_collective_t handle,
2627  int delta);
2628 
2632  void
2633  legion_dynamic_collective_arrive(legion_runtime_t runtime,
2634  legion_context_t ctx,
2635  legion_dynamic_collective_t handle,
2636  const void *buffer,
2637  size_t size,
2638  unsigned count /* = 1 */);
2639 
2643  void
2644  legion_dynamic_collective_defer_arrival(legion_runtime_t runtime,
2645  legion_context_t ctx,
2646  legion_dynamic_collective_t handle,
2647  legion_future_t f,
2648  unsigned count /* = 1 */);
2649 
2655  legion_future_t
2656  legion_dynamic_collective_get_result(legion_runtime_t runtime,
2657  legion_context_t ctx,
2658  legion_dynamic_collective_t handle);
2659 
2665  legion_dynamic_collective_t
2666  legion_dynamic_collective_advance(legion_runtime_t runtime,
2667  legion_context_t ctx,
2668  legion_dynamic_collective_t handle);
2669 
2670  // -----------------------------------------------------------------------
2671  // Future Operations
2672  // -----------------------------------------------------------------------
2673 
2679  legion_future_t
2680  legion_future_from_untyped_pointer(legion_runtime_t runtime,
2681  const void *buffer,
2682  size_t size);
2683 
2689  legion_future_t
2690  legion_future_from_untyped_pointer_detailed(legion_runtime_t runtime,
2691  const void *buffer,
2692  size_t size,
2693  bool take_ownership,
2694  const char *provenance,
2695  bool shard_local);
2696 
2702  legion_future_t
2703  legion_future_copy(legion_future_t handle);
2704 
2710  void
2711  legion_future_destroy(legion_future_t handle);
2712 
2716  void
2717  legion_future_get_void_result(legion_future_t handle);
2718 
2722  void
2723  legion_future_wait(legion_future_t handle,
2724  bool silence_warnings /* = false */,
2725  const char *warning_string /* = NULL */);
2726 
2730  bool
2731  legion_future_is_empty(legion_future_t handle,
2732  bool block /* = false */);
2733 
2737  bool
2738  legion_future_is_ready(legion_future_t handle);
2739 
2743  bool
2744  legion_future_is_ready_subscribe(legion_future_t handle, bool subscribe);
2745 
2749  const void *
2750  legion_future_get_untyped_pointer(legion_future_t handle);
2751 
2755  size_t
2756  legion_future_get_untyped_size(legion_future_t handle);
2757 
2761  const void *
2762  legion_future_get_metadata(legion_future_t handle, size_t *size/*=NULL*/);
2763 
2764  // -----------------------------------------------------------------------
2765  // Future Map Operations
2766  // -----------------------------------------------------------------------
2767 
2773  legion_future_map_t
2774  legion_future_map_copy(legion_future_map_t handle);
2775 
2781  void
2782  legion_future_map_destroy(legion_future_map_t handle);
2783 
2787  void
2788  legion_future_map_wait_all_results(legion_future_map_t handle);
2789 
2795  legion_future_t
2796  legion_future_map_get_future(legion_future_map_t handle,
2797  legion_domain_point_t point);
2798 
2802  legion_domain_t
2803  legion_future_map_get_domain(legion_future_map_t handle);
2804 
2810  legion_future_t
2811  legion_future_map_reduce(legion_runtime_t runtime,
2812  legion_context_t ctx,
2813  legion_future_map_t handle,
2814  legion_reduction_op_id_t redop,
2815  bool deterministic,
2816  legion_mapper_id_t map_id,
2817  legion_mapping_tag_id_t tag);
2818 
2824  legion_future_t
2825  legion_future_map_reduce_with_initial_value(legion_runtime_t runtime,
2826  legion_context_t ctx,
2827  legion_future_map_t handle,
2828  legion_reduction_op_id_t redop,
2829  bool deterministic,
2830  legion_mapper_id_t map_id,
2831  legion_mapping_tag_id_t tag,
2832  const char *provenance,
2833  legion_future_t initial_value);
2834 
2840  legion_future_map_t
2841  legion_future_map_construct_from_buffers(legion_runtime_t runtime,
2842  legion_context_t ctx,
2843  legion_domain_t domain,
2844  legion_domain_point_t *points,
2845  legion_untyped_buffer_t *buffers,
2846  size_t num_points,
2847  bool collective,
2848  legion_sharding_id_t sid,
2849  bool implicit_sharding);
2850 
2856  legion_future_map_t
2857  legion_future_map_construct_from_futures(legion_runtime_t runtime,
2858  legion_context_t ctx,
2859  legion_domain_t domain,
2860  legion_domain_point_t *points,
2861  legion_future_t *futures,
2862  size_t num_futures,
2863  bool collective,
2864  legion_sharding_id_t sid,
2865  bool implicit_sharding);
2866 
2872  legion_future_map_t
2873  legion_future_map_transform(legion_runtime_t runtime,
2874  legion_context_t ctx,
2875  legion_future_map_t fm,
2876  legion_index_space_t new_domain,
2877  legion_point_transform_functor_t functor,
2878  bool take_ownership);
2879 
2880  // -----------------------------------------------------------------------
2881  // Deferred Buffer Operations
2882  // -----------------------------------------------------------------------
2883 
2889 #define BUFFER_CREATE(DIM) \
2890  legion_deferred_buffer_char_##DIM##d_t \
2891  legion_deferred_buffer_char_##DIM##d_create( \
2892  legion_rect_##DIM##d_t bounds, \
2893  legion_memory_kind_t kind, \
2894  char *initial_value);
2895  LEGION_FOREACH_N(BUFFER_CREATE)
2896 #undef BUFFER_CREATE
2897 
2898  /*
2899  * @see Legion::DeferredBuffer::ptr()
2900  */
2901 #define BUFFER_PTR(DIM) \
2902  char* \
2903  legion_deferred_buffer_char_##DIM##d_ptr( \
2904  legion_deferred_buffer_char_##DIM##d_t buffer, \
2905  legion_point_##DIM##d_t p);
2906  LEGION_FOREACH_N(BUFFER_PTR)
2907 #undef BUFFER_PTR
2908 
2909  /*
2910  * @see Legion::DeferredBuffer::~DeferredBuffer()
2911  */
2912 #define BUFFER_DESTROY(DIM) \
2913  void \
2914  legion_deferred_buffer_char_##DIM##d_destroy( \
2915  legion_deferred_buffer_char_##DIM##d_t buffer);
2916  LEGION_FOREACH_N(BUFFER_DESTROY)
2917 #undef BUFFER_DESTROY
2918 
2919  // -----------------------------------------------------------------------
2920  // Task Launch Operations
2921  // -----------------------------------------------------------------------
2922 
2928  legion_task_launcher_t
2929  legion_task_launcher_create(
2930  legion_task_id_t tid,
2931  legion_untyped_buffer_t arg,
2932  legion_predicate_t pred /* = legion_predicate_true() */,
2933  legion_mapper_id_t id /* = 0 */,
2934  legion_mapping_tag_id_t tag /* = 0 */);
2935 
2941  legion_task_launcher_t
2942  legion_task_launcher_create_from_buffer(
2943  legion_task_id_t tid,
2944  const void *buffer,
2945  size_t buffer_size,
2946  legion_predicate_t pred /* = legion_predicate_true() */,
2947  legion_mapper_id_t id /* = 0 */,
2948  legion_mapping_tag_id_t tag /* = 0 */);
2949 
2955  void
2956  legion_task_launcher_destroy(legion_task_launcher_t handle);
2957 
2963  legion_future_t
2964  legion_task_launcher_execute(legion_runtime_t runtime,
2965  legion_context_t ctx,
2966  legion_task_launcher_t launcher);
2967 
2973  legion_future_t
2974  legion_task_launcher_execute_outputs(legion_runtime_t runtime,
2975  legion_context_t ctx,
2976  legion_task_launcher_t launcher,
2977  legion_output_requirement_t *reqs,
2978  size_t reqs_size);
2979 
2983  unsigned
2984  legion_task_launcher_add_region_requirement_logical_region(
2985  legion_task_launcher_t launcher,
2986  legion_logical_region_t handle,
2987  legion_privilege_mode_t priv,
2988  legion_coherence_property_t prop,
2989  legion_logical_region_t parent,
2990  legion_mapping_tag_id_t tag /* = 0 */,
2991  bool verified /* = false*/);
2992 
2996  unsigned
2997  legion_task_launcher_add_region_requirement_logical_region_reduction(
2998  legion_task_launcher_t launcher,
2999  legion_logical_region_t handle,
3000  legion_reduction_op_id_t redop,
3001  legion_coherence_property_t prop,
3002  legion_logical_region_t parent,
3003  legion_mapping_tag_id_t tag /* = 0 */,
3004  bool verified /* = false*/);
3005 
3009  void
3010  legion_task_launcher_set_region_requirement_logical_region(
3011  legion_task_launcher_t launcher,
3012  unsigned idx,
3013  legion_logical_region_t handle,
3014  legion_privilege_mode_t priv,
3015  legion_coherence_property_t prop,
3016  legion_logical_region_t parent,
3017  legion_mapping_tag_id_t tag /* = 0 */,
3018  bool verified /* = false*/);
3019 
3023  void
3024  legion_task_launcher_set_region_requirement_logical_region_reduction(
3025  legion_task_launcher_t launcher,
3026  unsigned idx,
3027  legion_logical_region_t handle,
3028  legion_reduction_op_id_t redop,
3029  legion_coherence_property_t prop,
3030  legion_logical_region_t parent,
3031  legion_mapping_tag_id_t tag /* = 0 */,
3032  bool verified /* = false*/);
3033 
3037  void
3038  legion_task_launcher_add_field(legion_task_launcher_t launcher,
3039  unsigned idx,
3040  legion_field_id_t fid,
3041  bool inst /* = true */);
3042 
3046  const void*
3047  legion_index_launcher_get_projection_args(legion_region_requirement_t requirement,
3048  size_t *size);
3049 
3053  void
3054  legion_index_launcher_set_projection_args(legion_index_launcher_t launcher_,
3055  unsigned idx,
3056  const void *args,
3057  size_t size,
3058  bool own);
3059 
3063  void
3064  legion_task_launcher_add_flags(legion_task_launcher_t launcher,
3065  unsigned idx,
3066  enum legion_region_flags_t flags);
3067 
3071  void
3072  legion_task_launcher_intersect_flags(legion_task_launcher_t launcher,
3073  unsigned idx,
3074  enum legion_region_flags_t flags);
3075 
3079  unsigned
3080  legion_task_launcher_add_index_requirement(
3081  legion_task_launcher_t launcher,
3082  legion_index_space_t handle,
3083  legion_allocate_mode_t priv,
3084  legion_index_space_t parent,
3085  bool verified /* = false*/);
3086 
3090  void
3091  legion_task_launcher_add_future(legion_task_launcher_t launcher,
3092  legion_future_t future);
3093 
3097  void
3098  legion_task_launcher_add_wait_barrier(legion_task_launcher_t launcher,
3099  legion_phase_barrier_t bar);
3100 
3104  void
3105  legion_task_launcher_add_arrival_barrier(legion_task_launcher_t launcher,
3106  legion_phase_barrier_t bar);
3107 
3111  void
3112  legion_task_launcher_set_argument(legion_task_launcher_t launcher,
3113  legion_untyped_buffer_t arg);
3114 
3118  void
3119  legion_task_launcher_set_point(legion_task_launcher_t launcher,
3120  legion_domain_point_t point);
3121 
3125  void
3126  legion_task_launcher_set_sharding_space(legion_task_launcher_t launcher,
3127  legion_index_space_t is);
3128 
3132  void
3133  legion_task_launcher_set_predicate_false_future(legion_task_launcher_t launcher,
3134  legion_future_t f);
3135 
3139  void
3140  legion_task_launcher_set_predicate_false_result(legion_task_launcher_t launcher,
3141  legion_untyped_buffer_t arg);
3142 
3146  void
3147  legion_task_launcher_set_mapper(legion_task_launcher_t launcher,
3148  legion_mapper_id_t mapper_id);
3149 
3153  void
3154  legion_task_launcher_set_mapping_tag(legion_task_launcher_t launcher,
3155  legion_mapping_tag_id_t tag);
3156 
3160  void
3161  legion_task_launcher_set_mapper_arg(legion_task_launcher_t launcher,
3162  legion_untyped_buffer_t arg);
3163 
3167  void
3168  legion_task_launcher_set_enable_inlining(legion_task_launcher_t launcher,
3169  bool enable_inlining);
3170 
3174  void
3175  legion_task_launcher_set_local_function_task(legion_task_launcher_t launcher,
3176  bool local_function_task);
3177 
3181  void
3182  legion_task_launcher_set_elide_future_return(legion_task_launcher_t launcher,
3183  bool elide_future_return);
3184 
3188  void
3189  legion_task_launcher_set_provenance(legion_task_launcher_t launcher,
3190  const char *provenance);
3191 
3197  legion_index_launcher_t
3198  legion_index_launcher_create(
3199  legion_task_id_t tid,
3200  legion_domain_t domain,
3201  legion_untyped_buffer_t global_arg,
3202  legion_argument_map_t map,
3203  legion_predicate_t pred /* = legion_predicate_true() */,
3204  bool must /* = false */,
3205  legion_mapper_id_t id /* = 0 */,
3206  legion_mapping_tag_id_t tag /* = 0 */);
3207 
3213  legion_index_launcher_t
3214  legion_index_launcher_create_from_buffer(
3215  legion_task_id_t tid,
3216  legion_domain_t domain,
3217  const void *buffer,
3218  size_t buffer_size,
3219  legion_argument_map_t map,
3220  legion_predicate_t pred /* = legion_predicate_true() */,
3221  bool must /* = false */,
3222  legion_mapper_id_t id /* = 0 */,
3223  legion_mapping_tag_id_t tag /* = 0 */);
3224 
3230  void
3231  legion_index_launcher_destroy(legion_index_launcher_t handle);
3232 
3238  legion_future_map_t
3239  legion_index_launcher_execute(legion_runtime_t runtime,
3240  legion_context_t ctx,
3241  legion_index_launcher_t launcher);
3242 
3248  legion_future_t
3249  legion_index_launcher_execute_reduction(legion_runtime_t runtime,
3250  legion_context_t ctx,
3251  legion_index_launcher_t launcher,
3252  legion_reduction_op_id_t redop);
3253 
3259  legion_future_map_t
3260  legion_index_launcher_execute_outputs(legion_runtime_t runtime,
3261  legion_context_t ctx,
3262  legion_index_launcher_t launcher,
3263  legion_output_requirement_t *reqs,
3264  size_t reqs_size);
3265 
3271  legion_future_t
3272  legion_index_launcher_execute_deterministic_reduction(legion_runtime_t runtime,
3273  legion_context_t ctx,
3274  legion_index_launcher_t launcher,
3275  legion_reduction_op_id_t redop,
3276  bool deterministic);
3277 
3283  legion_future_t
3284  legion_index_launcher_execute_reduction_and_outputs(legion_runtime_t runtime,
3285  legion_context_t ctx,
3286  legion_index_launcher_t launcher,
3287  legion_reduction_op_id_t redop,
3288  bool deterministic,
3289  legion_output_requirement_t *reqs,
3290  size_t reqs_size);
3291 
3295  unsigned
3296  legion_index_launcher_add_region_requirement_logical_region(
3297  legion_index_launcher_t launcher,
3298  legion_logical_region_t handle,
3299  legion_projection_id_t proj /* = 0 */,
3300  legion_privilege_mode_t priv,
3301  legion_coherence_property_t prop,
3302  legion_logical_region_t parent,
3303  legion_mapping_tag_id_t tag /* = 0 */,
3304  bool verified /* = false*/);
3305 
3309  unsigned
3310  legion_index_launcher_add_region_requirement_logical_partition(
3311  legion_index_launcher_t launcher,
3312  legion_logical_partition_t handle,
3313  legion_projection_id_t proj /* = 0 */,
3314  legion_privilege_mode_t priv,
3315  legion_coherence_property_t prop,
3316  legion_logical_region_t parent,
3317  legion_mapping_tag_id_t tag /* = 0 */,
3318  bool verified /* = false*/);
3319 
3323  unsigned
3324  legion_index_launcher_add_region_requirement_logical_region_reduction(
3325  legion_index_launcher_t launcher,
3326  legion_logical_region_t handle,
3327  legion_projection_id_t proj /* = 0 */,
3328  legion_reduction_op_id_t redop,
3329  legion_coherence_property_t prop,
3330  legion_logical_region_t parent,
3331  legion_mapping_tag_id_t tag /* = 0 */,
3332  bool verified /* = false*/);
3333 
3337  unsigned
3338  legion_index_launcher_add_region_requirement_logical_partition_reduction(
3339  legion_index_launcher_t launcher,
3340  legion_logical_partition_t handle,
3341  legion_projection_id_t proj /* = 0 */,
3342  legion_reduction_op_id_t redop,
3343  legion_coherence_property_t prop,
3344  legion_logical_region_t parent,
3345  legion_mapping_tag_id_t tag /* = 0 */,
3346  bool verified /* = false*/);
3347 
3351  void
3352  legion_index_launcher_set_region_requirement_logical_region(
3353  legion_index_launcher_t launcher,
3354  unsigned idx,
3355  legion_logical_region_t handle,
3356  legion_projection_id_t proj /* = 0 */,
3357  legion_privilege_mode_t priv,
3358  legion_coherence_property_t prop,
3359  legion_logical_region_t parent,
3360  legion_mapping_tag_id_t tag /* = 0 */,
3361  bool verified /* = false*/);
3362 
3366  void
3367  legion_index_launcher_set_region_requirement_logical_partition(
3368  legion_index_launcher_t launcher,
3369  unsigned idx,
3370  legion_logical_partition_t handle,
3371  legion_projection_id_t proj /* = 0 */,
3372  legion_privilege_mode_t priv,
3373  legion_coherence_property_t prop,
3374  legion_logical_region_t parent,
3375  legion_mapping_tag_id_t tag /* = 0 */,
3376  bool verified /* = false*/);
3377 
3381  void
3382  legion_index_launcher_set_region_requirement_logical_region_reduction(
3383  legion_index_launcher_t launcher,
3384  unsigned idx,
3385  legion_logical_region_t handle,
3386  legion_projection_id_t proj /* = 0 */,
3387  legion_reduction_op_id_t redop,
3388  legion_coherence_property_t prop,
3389  legion_logical_region_t parent,
3390  legion_mapping_tag_id_t tag /* = 0 */,
3391  bool verified /* = false*/);
3392 
3396  void
3397  legion_index_launcher_set_region_requirement_logical_partition_reduction(
3398  legion_index_launcher_t launcher,
3399  unsigned idx,
3400  legion_logical_partition_t handle,
3401  legion_projection_id_t proj /* = 0 */,
3402  legion_reduction_op_id_t redop,
3403  legion_coherence_property_t prop,
3404  legion_logical_region_t parent,
3405  legion_mapping_tag_id_t tag /* = 0 */,
3406  bool verified /* = false*/);
3407 
3411  void
3412  legion_index_launcher_add_field(legion_index_launcher_t launcher,
3413  unsigned idx,
3414  legion_field_id_t fid,
3415  bool inst /* = true */);
3416 
3420  void
3421  legion_index_launcher_add_flags(legion_index_launcher_t launcher,
3422  unsigned idx,
3423  enum legion_region_flags_t flags);
3424 
3428  void
3429  legion_index_launcher_intersect_flags(legion_index_launcher_t launcher,
3430  unsigned idx,
3431  enum legion_region_flags_t flags);
3432 
3436  unsigned
3437  legion_index_launcher_add_index_requirement(
3438  legion_index_launcher_t launcher,
3439  legion_index_space_t handle,
3440  legion_allocate_mode_t priv,
3441  legion_index_space_t parent,
3442  bool verified /* = false*/);
3443 
3447  void
3448  legion_index_launcher_add_future(legion_index_launcher_t launcher,
3449  legion_future_t future);
3450 
3454  void
3455  legion_index_launcher_add_wait_barrier(legion_index_launcher_t launcher,
3456  legion_phase_barrier_t bar);
3457 
3461  void
3462  legion_index_launcher_add_arrival_barrier(legion_index_launcher_t launcher,
3463  legion_phase_barrier_t bar);
3464 
3468  void
3469  legion_index_launcher_add_point_future(legion_index_launcher_t launcher,
3470  legion_argument_map_t map);
3471 
3475  void
3476  legion_index_launcher_set_global_arg(legion_index_launcher_t launcher,
3477  legion_untyped_buffer_t global_arg);
3478 
3482  void
3483  legion_index_launcher_set_sharding_space(legion_index_launcher_t launcher,
3484  legion_index_space_t is);
3485 
3489  void
3490  legion_index_launcher_set_mapper(legion_index_launcher_t launcher,
3491  legion_mapper_id_t mapper_id);
3492 
3496  void
3497  legion_index_launcher_set_mapping_tag(legion_index_launcher_t launcher,
3498  legion_mapping_tag_id_t tag);
3499 
3503  void
3504  legion_index_launcher_set_mapper_arg(legion_index_launcher_t launcher,
3505  legion_untyped_buffer_t map_arg);
3506 
3510  void
3511  legion_index_launcher_set_elide_future_return(legion_index_launcher_t launcher,
3512  bool elide_future_return);
3513 
3517  void
3518  legion_index_launcher_set_provenance(legion_index_launcher_t launcher,
3519  const char *provenance);
3520 
3524  void
3525  legion_index_launcher_set_concurrent(legion_index_launcher_t launcher,
3526  bool concurrent);
3527 
3531  void
3532  legion_index_launcher_set_initial_value(legion_index_launcher_t launcher,
3533  legion_future_t initial_value);
3534 
3535  // -----------------------------------------------------------------------
3536  // Inline Mapping Operations
3537  // -----------------------------------------------------------------------
3538 
3544  legion_inline_launcher_t
3545  legion_inline_launcher_create_logical_region(
3546  legion_logical_region_t handle,
3547  legion_privilege_mode_t priv,
3548  legion_coherence_property_t prop,
3549  legion_logical_region_t parent,
3550  legion_mapping_tag_id_t region_tag /* = 0 */,
3551  bool verified /* = false*/,
3552  legion_mapper_id_t id /* = 0 */,
3553  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3554 
3560  void
3561  legion_inline_launcher_destroy(legion_inline_launcher_t handle);
3562 
3568  legion_physical_region_t
3569  legion_inline_launcher_execute(legion_runtime_t runtime,
3570  legion_context_t ctx,
3571  legion_inline_launcher_t launcher);
3572 
3576  void
3577  legion_inline_launcher_add_field(legion_inline_launcher_t launcher,
3578  legion_field_id_t fid,
3579  bool inst /* = true */);
3580 
3584  void
3585  legion_inline_launcher_set_mapper_arg(legion_inline_launcher_t launcher,
3586  legion_untyped_buffer_t arg);
3587 
3591  void
3592  legion_inline_launcher_set_provenance(legion_inline_launcher_t launcher,
3593  const char *provenance);
3594 
3598  void
3599  legion_runtime_remap_region(legion_runtime_t runtime,
3600  legion_context_t ctx,
3601  legion_physical_region_t region);
3602 
3606  void
3607  legion_runtime_unmap_region(legion_runtime_t runtime,
3608  legion_context_t ctx,
3609  legion_physical_region_t region);
3610 
3614  void
3615  legion_runtime_unmap_all_regions(legion_runtime_t runtime,
3616  legion_context_t ctx);
3617 
3618  // -----------------------------------------------------------------------
3619  // Fill Field Operations
3620  // -----------------------------------------------------------------------
3621 
3625  void
3626  legion_runtime_fill_field(
3627  legion_runtime_t runtime,
3628  legion_context_t ctx,
3629  legion_logical_region_t handle,
3630  legion_logical_region_t parent,
3631  legion_field_id_t fid,
3632  const void *value,
3633  size_t value_size,
3634  legion_predicate_t pred /* = legion_predicate_true() */);
3635 
3639  void
3640  legion_runtime_fill_field_future(
3641  legion_runtime_t runtime,
3642  legion_context_t ctx,
3643  legion_logical_region_t handle,
3644  legion_logical_region_t parent,
3645  legion_field_id_t fid,
3646  legion_future_t f,
3647  legion_predicate_t pred /* = legion_predicate_true() */);
3648 
3654  legion_fill_launcher_t
3655  legion_fill_launcher_create(
3656  legion_logical_region_t handle,
3657  legion_logical_region_t parent,
3658  legion_field_id_t fid,
3659  const void *value,
3660  size_t value_size,
3661  legion_predicate_t pred /* = legion_predicate_true() */,
3662  legion_mapper_id_t id /* = 0 */,
3663  legion_mapping_tag_id_t tag /* = 0 */);
3664 
3670  legion_fill_launcher_t
3671  legion_fill_launcher_create_from_future(
3672  legion_logical_region_t handle,
3673  legion_logical_region_t parent,
3674  legion_field_id_t fid,
3675  legion_future_t f,
3676  legion_predicate_t pred /* = legion_predicate_true() */,
3677  legion_mapper_id_t id /* = 0 */,
3678  legion_mapping_tag_id_t tag /* = 0 */);
3679 
3685  void
3686  legion_fill_launcher_destroy(legion_fill_launcher_t handle);
3687 
3691  void
3692  legion_fill_launcher_add_field(legion_fill_launcher_t handle,
3693  legion_field_id_t fid);
3694 
3698  void
3699  legion_fill_launcher_execute(legion_runtime_t runtime,
3700  legion_context_t ctx,
3701  legion_fill_launcher_t launcher);
3702 
3706  void
3707  legion_fill_launcher_set_point(legion_fill_launcher_t launcher,
3708  legion_domain_point_t point);
3709 
3713  void legion_fill_launcher_set_sharding_space(legion_fill_launcher_t launcher,
3714  legion_index_space_t space);
3715 
3719  void
3720  legion_fill_launcher_set_mapper_arg(legion_fill_launcher_t launcher,
3721  legion_untyped_buffer_t arg);
3722 
3726  void
3727  legion_fill_launcher_set_provenance(legion_fill_launcher_t launcher,
3728  const char *provenance);
3729 
3730  // -----------------------------------------------------------------------
3731  // Index Fill Field Operations
3732  // -----------------------------------------------------------------------
3733 
3738  void
3739  legion_runtime_index_fill_field(
3740  legion_runtime_t runtime,
3741  legion_context_t ctx,
3742  legion_logical_partition_t handle,
3743  legion_logical_region_t parent,
3744  legion_field_id_t fid,
3745  const void *value,
3746  size_t value_size,
3747  legion_projection_id_t proj /* = 0 */,
3748  legion_predicate_t pred /* = legion_predicate_true() */,
3749  legion_mapper_id_t id /* = 0 */,
3750  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3751 
3756  void
3757  legion_runtime_index_fill_field_with_space(
3758  legion_runtime_t runtime,
3759  legion_context_t ctx,
3760  legion_index_space_t space,
3761  legion_logical_partition_t handle,
3762  legion_logical_region_t parent,
3763  legion_field_id_t fid,
3764  const void *value,
3765  size_t value_size,
3766  legion_projection_id_t proj /* = 0 */,
3767  legion_predicate_t pred /* = legion_predicate_true() */,
3768  legion_mapper_id_t id /* = 0 */,
3769  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3770 
3775  void
3776  legion_runtime_index_fill_field_with_domain(
3777  legion_runtime_t runtime,
3778  legion_context_t ctx,
3779  legion_domain_t domain,
3780  legion_logical_partition_t handle,
3781  legion_logical_region_t parent,
3782  legion_field_id_t fid,
3783  const void *value,
3784  size_t value_size,
3785  legion_projection_id_t proj /* = 0 */,
3786  legion_predicate_t pred /* = legion_predicate_true() */,
3787  legion_mapper_id_t id /* = 0 */,
3788  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3789 
3794  void
3795  legion_runtime_index_fill_field_future(
3796  legion_runtime_t runtime,
3797  legion_context_t ctx,
3798  legion_logical_partition_t handle,
3799  legion_logical_region_t parent,
3800  legion_field_id_t fid,
3801  legion_future_t f,
3802  legion_projection_id_t proj /* = 0 */,
3803  legion_predicate_t pred /* = legion_predicate_true() */,
3804  legion_mapper_id_t id /* = 0 */,
3805  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3806 
3811  void
3812  legion_runtime_index_fill_field_future_with_space(
3813  legion_runtime_t runtime,
3814  legion_context_t ctx,
3815  legion_index_space_t space,
3816  legion_logical_partition_t handle,
3817  legion_logical_region_t parent,
3818  legion_field_id_t fid,
3819  legion_future_t f,
3820  legion_projection_id_t proj /* = 0 */,
3821  legion_predicate_t pred /* = legion_predicate_true() */,
3822  legion_mapper_id_t id /* = 0 */,
3823  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3824 
3829  void
3830  legion_runtime_index_fill_field_future_with_domain(
3831  legion_runtime_t runtime,
3832  legion_context_t ctx,
3833  legion_domain_t domain,
3834  legion_logical_partition_t handle,
3835  legion_logical_region_t parent,
3836  legion_field_id_t fid,
3837  legion_future_t f,
3838  legion_projection_id_t proj /* = 0 */,
3839  legion_predicate_t pred /* = legion_predicate_true() */,
3840  legion_mapper_id_t id /* = 0 */,
3841  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3842 
3848  legion_index_fill_launcher_t
3849  legion_index_fill_launcher_create_with_space(
3850  legion_index_space_t space,
3851  legion_logical_partition_t handle,
3852  legion_logical_region_t parent,
3853  legion_field_id_t fid,
3854  const void *value,
3855  size_t value_size,
3856  legion_projection_id_t proj /* = 0 */,
3857  legion_predicate_t pred /* = legion_predicate_true() */,
3858  legion_mapper_id_t id /* = 0 */,
3859  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3860 
3866  legion_index_fill_launcher_t
3867  legion_index_fill_launcher_create_with_domain(
3868  legion_domain_t domain,
3869  legion_logical_partition_t handle,
3870  legion_logical_region_t parent,
3871  legion_field_id_t fid,
3872  const void *value,
3873  size_t value_size,
3874  legion_projection_id_t proj /* = 0 */,
3875  legion_predicate_t pred /* = legion_predicate_true() */,
3876  legion_mapper_id_t id /* = 0 */,
3877  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3878 
3884  legion_index_fill_launcher_t
3885  legion_index_fill_launcher_create_from_future_with_space(
3886  legion_index_space_t space,
3887  legion_logical_partition_t handle,
3888  legion_logical_region_t parent,
3889  legion_field_id_t fid,
3890  legion_future_t future,
3891  legion_projection_id_t proj /* = 0 */,
3892  legion_predicate_t pred /* = legion_predicate_true() */,
3893  legion_mapper_id_t id /* = 0 */,
3894  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3895 
3901  legion_index_fill_launcher_t
3902  legion_index_fill_launcher_create_from_future_with_domain(
3903  legion_domain_t domain,
3904  legion_logical_partition_t handle,
3905  legion_logical_region_t parent,
3906  legion_field_id_t fid,
3907  legion_future_t future,
3908  legion_projection_id_t proj /* = 0 */,
3909  legion_predicate_t pred /* = legion_predicate_true() */,
3910  legion_mapper_id_t id /* = 0 */,
3911  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3912 
3918  void
3919  legion_index_fill_launcher_destroy(legion_index_fill_launcher_t handle);
3920 
3924  void
3925  legion_index_fill_launcher_add_field(legion_fill_launcher_t handle,
3926  legion_field_id_t fid);
3927 
3931  void
3932  legion_index_fill_launcher_execute(legion_runtime_t runtime,
3933  legion_context_t ctx,
3934  legion_index_fill_launcher_t launcher);
3935 
3939  void legion_index_fill_launcher_set_sharding_space(legion_index_fill_launcher_t launcher,
3940  legion_index_space_t space);
3941 
3945  void
3946  legion_index_fill_launcher_set_mapper_arg(legion_index_fill_launcher_t launcher,
3947  legion_untyped_buffer_t arg);
3948 
3952  void
3953  legion_index_fill_launcher_set_provenance(legion_index_fill_launcher_t launcher,
3954  const char *provenance);
3955 
3961  legion_region_requirement_t
3962  legion_fill_get_requirement(legion_fill_t fill);
3963 
3964  // -----------------------------------------------------------------------
3965  // Discard Operation
3966  // -----------------------------------------------------------------------
3967 
3973  legion_discard_launcher_t
3974  legion_discard_launcher_create(
3975  legion_logical_region_t handle,
3976  legion_logical_region_t parent);
3977 
3983  void
3984  legion_discard_launcher_destroy(legion_discard_launcher_t handle);
3985 
3989  void
3990  legion_discard_launcher_add_field(legion_discard_launcher_t handle,
3991  legion_field_id_t fid);
3992 
3996  void
3997  legion_discard_launcher_execute(legion_runtime_t runtime,
3998  legion_context_t ctx,
3999  legion_discard_launcher_t launcher);
4000 
4004  void
4005  legion_discard_launcher_set_provenance(legion_discard_launcher_t launcher,
4006  const char *provenance);
4007 
4008  // -----------------------------------------------------------------------
4009  // File Operations
4010  // -----------------------------------------------------------------------
4011 
4015  legion_field_map_t
4016  legion_field_map_create(void);
4017 
4021  void
4022  legion_field_map_destroy(legion_field_map_t handle);
4023 
4024  void
4025  legion_field_map_insert(legion_field_map_t handle,
4026  legion_field_id_t key,
4027  const char *value);
4028 
4034  legion_physical_region_t
4035  legion_runtime_attach_hdf5(
4036  legion_runtime_t runtime,
4037  legion_context_t ctx,
4038  const char *filename,
4039  legion_logical_region_t handle,
4040  legion_logical_region_t parent,
4041  legion_field_map_t field_map,
4042  legion_file_mode_t mode);
4043 
4047  void
4048  legion_runtime_detach_hdf5(
4049  legion_runtime_t runtime,
4050  legion_context_t ctx,
4051  legion_physical_region_t region);
4052 
4053  // -----------------------------------------------------------------------
4054  // Copy Operations
4055  // -----------------------------------------------------------------------
4056 
4062  legion_copy_launcher_t
4063  legion_copy_launcher_create(
4064  legion_predicate_t pred /* = legion_predicate_true() */,
4065  legion_mapper_id_t id /* = 0 */,
4066  legion_mapping_tag_id_t launcher_tag /* = 0 */);
4067 
4073  void
4074  legion_copy_launcher_destroy(legion_copy_launcher_t handle);
4075 
4081  void
4082  legion_copy_launcher_execute(legion_runtime_t runtime,
4083  legion_context_t ctx,
4084  legion_copy_launcher_t launcher);
4085 
4089  unsigned
4090  legion_copy_launcher_add_src_region_requirement_logical_region(
4091  legion_copy_launcher_t launcher,
4092  legion_logical_region_t handle,
4093  legion_privilege_mode_t priv,
4094  legion_coherence_property_t prop,
4095  legion_logical_region_t parent,
4096  legion_mapping_tag_id_t tag /* = 0 */,
4097  bool verified /* = false*/);
4098 
4102  unsigned
4103  legion_copy_launcher_add_dst_region_requirement_logical_region(
4104  legion_copy_launcher_t launcher,
4105  legion_logical_region_t handle,
4106  legion_privilege_mode_t priv,
4107  legion_coherence_property_t prop,
4108  legion_logical_region_t parent,
4109  legion_mapping_tag_id_t tag /* = 0 */,
4110  bool verified /* = false*/);
4111 
4115  unsigned
4116  legion_copy_launcher_add_dst_region_requirement_logical_region_reduction(
4117  legion_copy_launcher_t launcher,
4118  legion_logical_region_t handle,
4119  legion_reduction_op_id_t redop,
4120  legion_coherence_property_t prop,
4121  legion_logical_region_t parent,
4122  legion_mapping_tag_id_t tag /* = 0 */,
4123  bool verified /* = false*/);
4124 
4128  unsigned
4129  legion_copy_launcher_add_src_indirect_region_requirement_logical_region(
4130  legion_copy_launcher_t launcher,
4131  legion_logical_region_t handle,
4132  legion_field_id_t fid,
4133  legion_coherence_property_t prop,
4134  legion_logical_region_t parent,
4135  legion_mapping_tag_id_t tag /* = 0 */,
4136  bool is_range_indirection /* = false */,
4137  bool verified /* = false*/);
4138 
4142  unsigned
4143  legion_copy_launcher_add_dst_indirect_region_requirement_logical_region(
4144  legion_copy_launcher_t launcher,
4145  legion_logical_region_t handle,
4146  legion_field_id_t fid,
4147  legion_coherence_property_t prop,
4148  legion_logical_region_t parent,
4149  legion_mapping_tag_id_t tag /* = 0 */,
4150  bool is_range_indirection /* = false */,
4151  bool verified /* = false*/);
4152 
4156  void
4157  legion_copy_launcher_add_src_field(legion_copy_launcher_t launcher,
4158  unsigned idx,
4159  legion_field_id_t fid,
4160  bool inst /* = true */);
4161 
4165  void
4166  legion_copy_launcher_add_dst_field(legion_copy_launcher_t launcher,
4167  unsigned idx,
4168  legion_field_id_t fid,
4169  bool inst /* = true */);
4170 
4174  void
4175  legion_copy_launcher_add_wait_barrier(legion_copy_launcher_t launcher,
4176  legion_phase_barrier_t bar);
4177 
4181  void
4182  legion_copy_launcher_add_arrival_barrier(legion_copy_launcher_t launcher,
4183  legion_phase_barrier_t bar);
4184 
4188  void
4189  legion_copy_launcher_set_possible_src_indirect_out_of_range(
4190  legion_copy_launcher_t launcher, bool flag);
4191 
4195  void
4196  legion_copy_launcher_set_possible_dst_indirect_out_of_range(
4197  legion_copy_launcher_t launcher, bool flag);
4198 
4202  void
4203  legion_copy_launcher_set_point(legion_copy_launcher_t launcher,
4204  legion_domain_point_t point);
4205 
4209  void legion_copy_launcher_set_sharding_space(legion_copy_launcher_t launcher,
4210  legion_index_space_t space);
4211 
4215  void
4216  legion_copy_launcher_set_mapper_arg(legion_copy_launcher_t launcher,
4217  legion_untyped_buffer_t arg);
4218 
4222  void
4223  legion_copy_launcher_set_provenance(legion_copy_launcher_t launcher,
4224  const char *provenance);
4225 
4234  legion_region_requirement_t
4235  legion_copy_get_requirement(legion_copy_t copy, unsigned idx);
4236 
4237  // -----------------------------------------------------------------------
4238  // Index Copy Operations
4239  // -----------------------------------------------------------------------
4240 
4246  legion_index_copy_launcher_t
4247  legion_index_copy_launcher_create(
4248  legion_domain_t domain,
4249  legion_predicate_t pred /* = legion_predicate_true() */,
4250  legion_mapper_id_t id /* = 0 */,
4251  legion_mapping_tag_id_t launcher_tag /* = 0 */);
4252 
4258  void
4259  legion_index_copy_launcher_destroy(legion_index_copy_launcher_t handle);
4260 
4266  void
4267  legion_index_copy_launcher_execute(legion_runtime_t runtime,
4268  legion_context_t ctx,
4269  legion_index_copy_launcher_t launcher);
4270 
4274  unsigned
4275  legion_index_copy_launcher_add_src_region_requirement_logical_region(
4276  legion_index_copy_launcher_t launcher,
4277  legion_logical_region_t handle,
4278  legion_projection_id_t proj /* = 0 */,
4279  legion_privilege_mode_t priv,
4280  legion_coherence_property_t prop,
4281  legion_logical_region_t parent,
4282  legion_mapping_tag_id_t tag /* = 0 */,
4283  bool verified /* = false*/);
4284 
4288  unsigned
4289  legion_index_copy_launcher_add_dst_region_requirement_logical_region(
4290  legion_index_copy_launcher_t launcher,
4291  legion_logical_region_t handle,
4292  legion_projection_id_t proj /* = 0 */,
4293  legion_privilege_mode_t priv,
4294  legion_coherence_property_t prop,
4295  legion_logical_region_t parent,
4296  legion_mapping_tag_id_t tag /* = 0 */,
4297  bool verified /* = false*/);
4298 
4302  unsigned
4303  legion_index_copy_launcher_add_src_region_requirement_logical_partition(
4304  legion_index_copy_launcher_t launcher,
4305  legion_logical_partition_t handle,
4306  legion_projection_id_t proj /* = 0 */,
4307  legion_privilege_mode_t priv,
4308  legion_coherence_property_t prop,
4309  legion_logical_region_t parent,
4310  legion_mapping_tag_id_t tag /* = 0 */,
4311  bool verified /* = false*/);
4312 
4316  unsigned
4317  legion_index_copy_launcher_add_dst_region_requirement_logical_partition(
4318  legion_index_copy_launcher_t launcher,
4319  legion_logical_partition_t handle,
4320  legion_projection_id_t proj /* = 0 */,
4321  legion_privilege_mode_t priv,
4322  legion_coherence_property_t prop,
4323  legion_logical_region_t parent,
4324  legion_mapping_tag_id_t tag /* = 0 */,
4325  bool verified /* = false*/);
4326 
4330  unsigned
4331  legion_index_copy_launcher_add_dst_region_requirement_logical_region_reduction(
4332  legion_index_copy_launcher_t launcher,
4333  legion_logical_region_t handle,
4334  legion_projection_id_t proj /* = 0 */,
4335  legion_reduction_op_id_t redop,
4336  legion_coherence_property_t prop,
4337  legion_logical_region_t parent,
4338  legion_mapping_tag_id_t tag /* = 0 */,
4339  bool verified /* = false*/);
4340 
4344  unsigned
4345  legion_index_copy_launcher_add_dst_region_requirement_logical_partition_reduction(
4346  legion_index_copy_launcher_t launcher,
4347  legion_logical_partition_t handle,
4348  legion_projection_id_t proj /* = 0 */,
4349  legion_reduction_op_id_t redop,
4350  legion_coherence_property_t prop,
4351  legion_logical_region_t parent,
4352  legion_mapping_tag_id_t tag /* = 0 */,
4353  bool verified /* = false*/);
4354 
4358  unsigned
4359  legion_index_copy_launcher_add_src_indirect_region_requirement_logical_region(
4360  legion_index_copy_launcher_t launcher,
4361  legion_logical_region_t handle,
4362  legion_projection_id_t proj /* = 0 */,
4363  legion_field_id_t fid,
4364  legion_coherence_property_t prop,
4365  legion_logical_region_t parent,
4366  legion_mapping_tag_id_t tag /* = 0 */,
4367  bool is_range_indirection /* = false */,
4368  bool verified /* = false*/);
4369 
4373  unsigned
4374  legion_index_copy_launcher_add_dst_indirect_region_requirement_logical_region(
4375  legion_index_copy_launcher_t launcher,
4376  legion_logical_region_t handle,
4377  legion_projection_id_t proj /* = 0 */,
4378  legion_field_id_t fid,
4379  legion_coherence_property_t prop,
4380  legion_logical_region_t parent,
4381  legion_mapping_tag_id_t tag /* = 0 */,
4382  bool is_range_indirection /* = false */,
4383  bool verified /* = false*/);
4384 
4388  unsigned
4389  legion_index_copy_launcher_add_src_indirect_region_requirement_logical_partition(
4390  legion_index_copy_launcher_t launcher,
4391  legion_logical_partition_t handle,
4392  legion_projection_id_t proj /* = 0 */,
4393  legion_field_id_t fid,
4394  legion_coherence_property_t prop,
4395  legion_logical_region_t parent,
4396  legion_mapping_tag_id_t tag /* = 0 */,
4397  bool is_range_indirection /* = false */,
4398  bool verified /* = false*/);
4399 
4403  unsigned
4404  legion_index_copy_launcher_add_dst_indirect_region_requirement_logical_partition(
4405  legion_index_copy_launcher_t launcher,
4406  legion_logical_partition_t handle,
4407  legion_projection_id_t proj /* = 0 */,
4408  legion_field_id_t fid,
4409  legion_coherence_property_t prop,
4410  legion_logical_region_t parent,
4411  legion_mapping_tag_id_t tag /* = 0 */,
4412  bool is_range_indirection /* = false */,
4413  bool verified /* = false*/);
4414 
4418  void
4419  legion_index_copy_launcher_add_src_field(legion_index_copy_launcher_t launcher,
4420  unsigned idx,
4421  legion_field_id_t fid,
4422  bool inst /* = true */);
4423 
4427  void
4428  legion_index_copy_launcher_add_dst_field(legion_index_copy_launcher_t launcher,
4429  unsigned idx,
4430  legion_field_id_t fid,
4431  bool inst /* = true */);
4432 
4436  void
4437  legion_index_copy_launcher_add_wait_barrier(legion_index_copy_launcher_t launcher,
4438  legion_phase_barrier_t bar);
4439 
4443  void
4444  legion_index_copy_launcher_add_arrival_barrier(legion_index_copy_launcher_t launcher,
4445  legion_phase_barrier_t bar);
4446 
4450  void
4451  legion_index_copy_launcher_set_possible_src_indirect_out_of_range(
4452  legion_index_copy_launcher_t launcher, bool flag);
4453 
4457  void
4458  legion_index_copy_launcher_set_possible_dst_indirect_out_of_range(
4459  legion_index_copy_launcher_t launcher, bool flag);
4460 
4464  void
4465  legion_index_copy_launcher_set_sharding_space(legion_index_copy_launcher_t launcher,
4466  legion_index_space_t is);
4467 
4471  void
4472  legion_index_copy_launcher_set_mapper_arg(legion_index_copy_launcher_t launcher,
4473  legion_untyped_buffer_t arg);
4474 
4478  void
4479  legion_index_copy_launcher_set_provenance(legion_index_copy_launcher_t launcher,
4480  const char *provenance);
4481 
4482  // -----------------------------------------------------------------------
4483  // Acquire Operations
4484  // -----------------------------------------------------------------------
4485 
4491  legion_acquire_launcher_t
4492  legion_acquire_launcher_create(
4493  legion_logical_region_t logical_region,
4494  legion_logical_region_t parent_region,
4495  legion_predicate_t pred /* = legion_predicate_true() */,
4496  legion_mapper_id_t id /* = 0 */,
4497  legion_mapping_tag_id_t tag /* = 0 */);
4498 
4504  void
4505  legion_acquire_launcher_destroy(legion_acquire_launcher_t handle);
4506 
4512  void
4513  legion_acquire_launcher_execute(legion_runtime_t runtime,
4514  legion_context_t ctx,
4515  legion_acquire_launcher_t launcher);
4516 
4520  void
4521  legion_acquire_launcher_add_field(legion_acquire_launcher_t launcher,
4522  legion_field_id_t fid);
4523 
4527  void
4528  legion_acquire_launcher_add_wait_barrier(legion_acquire_launcher_t launcher,
4529  legion_phase_barrier_t bar);
4530 
4534  void
4535  legion_acquire_launcher_add_arrival_barrier(
4536  legion_acquire_launcher_t launcher,
4537  legion_phase_barrier_t bar);
4538 
4542  void
4543  legion_acquire_launcher_set_sharding_space(legion_acquire_launcher_t launcher,
4544  legion_index_space_t space);
4545 
4549  void
4550  legion_acquire_launcher_set_mapper_arg(legion_acquire_launcher_t launcher,
4551  legion_untyped_buffer_t arg);
4552 
4556  void
4557  legion_acquire_launcher_set_provenance(legion_acquire_launcher_t launcher,
4558  const char *provenance);
4559 
4560  // -----------------------------------------------------------------------
4561  // Release Operations
4562  // -----------------------------------------------------------------------
4563 
4569  legion_release_launcher_t
4570  legion_release_launcher_create(
4571  legion_logical_region_t logical_region,
4572  legion_logical_region_t parent_region,
4573  legion_predicate_t pred /* = legion_predicate_true() */,
4574  legion_mapper_id_t id /* = 0 */,
4575  legion_mapping_tag_id_t tag /* = 0 */);
4576 
4582  void
4583  legion_release_launcher_destroy(legion_release_launcher_t handle);
4584 
4590  void
4591  legion_release_launcher_execute(legion_runtime_t runtime,
4592  legion_context_t ctx,
4593  legion_release_launcher_t launcher);
4594 
4598  void
4599  legion_release_launcher_add_field(legion_release_launcher_t launcher,
4600  legion_field_id_t fid);
4601 
4605  void
4606  legion_release_launcher_add_wait_barrier(legion_release_launcher_t launcher,
4607  legion_phase_barrier_t bar);
4608 
4612  void
4613  legion_release_launcher_add_arrival_barrier(
4614  legion_release_launcher_t launcher,
4615  legion_phase_barrier_t bar);
4616 
4620  void
4621  legion_release_launcher_set_sharding_space(legion_release_launcher_t launcher,
4622  legion_index_space_t space);
4623 
4627  void
4628  legion_release_launcher_set_mapper_arg(legion_release_launcher_t launcher,
4629  legion_untyped_buffer_t arg);
4630 
4634  void
4635  legion_release_launcher_set_provenance(legion_release_launcher_t launcher,
4636  const char *provenance);
4637 
4638  // -----------------------------------------------------------------------
4639  // Attach/Detach Operations
4640  // -----------------------------------------------------------------------
4641 
4647  legion_attach_launcher_t
4648  legion_attach_launcher_create(
4649  legion_logical_region_t logical_region,
4650  legion_logical_region_t parent_region,
4651  legion_external_resource_t resource);
4652 
4656  void
4657  legion_attach_launcher_attach_hdf5(legion_attach_launcher_t handle,
4658  const char *filename,
4659  legion_field_map_t field_map,
4660  legion_file_mode_t mode);
4661 
4665  void
4666  legion_attach_launcher_set_restricted(legion_attach_launcher_t handle,
4667  bool restricted);
4668 
4672  void
4673  legion_attach_launcher_set_mapped(legion_attach_launcher_t handle,
4674  bool mapped);
4675 
4679  void
4680  legion_attach_launcher_set_provenance(legion_attach_launcher_t handle,
4681  const char *provenance);
4682 
4688  void
4689  legion_attach_launcher_destroy(legion_attach_launcher_t handle);
4690 
4696  legion_physical_region_t
4697  legion_attach_launcher_execute(legion_runtime_t runtime,
4698  legion_context_t ctx,
4699  legion_attach_launcher_t launcher);
4700 
4704  void
4705  legion_attach_launcher_add_cpu_soa_field(legion_attach_launcher_t launcher,
4706  legion_field_id_t fid,
4707  void *base_ptr,
4708  bool column_major);
4709 
4715  legion_future_t
4716  legion_detach_external_resource(legion_runtime_t runtime,
4717  legion_context_t ctx,
4718  legion_physical_region_t handle);
4719 
4725  legion_future_t
4726  legion_flush_detach_external_resource(legion_runtime_t runtime,
4727  legion_context_t ctx,
4728  legion_physical_region_t handle,
4729  bool flush);
4730 
4736  legion_future_t
4737  legion_unordered_detach_external_resource(legion_runtime_t runtime,
4738  legion_context_t ctx,
4739  legion_physical_region_t handle,
4740  bool flush,
4741  bool unordered);
4742 
4746  void
4747  legion_context_progress_unordered_operations(legion_runtime_t runtime,
4748  legion_context_t ctx);
4749 
4750  // -----------------------------------------------------------------------
4751  // Index Attach/Detach Operations
4752  // -----------------------------------------------------------------------
4753 
4759  legion_index_attach_launcher_t
4760  legion_index_attach_launcher_create(
4761  legion_logical_region_t parent_region,
4762  legion_external_resource_t resource,
4763  bool restricted/*=true*/);
4764 
4768  void
4769  legion_index_attach_launcher_set_restricted(
4770  legion_index_attach_launcher_t handle, bool restricted);
4771 
4775  void
4776  legion_index_attach_launcher_set_provenance(
4777  legion_index_attach_launcher_t handle, const char *provenance);
4778 
4782  void
4783  legion_index_attach_launcher_set_deduplicate_across_shards(
4784  legion_index_attach_launcher_t handle, bool deduplicate);
4785 
4789  void
4790  legion_index_attach_launcher_attach_file(legion_index_attach_launcher_t handle,
4791  legion_logical_region_t region,
4792  const char *filename,
4793  const legion_field_id_t *fields,
4794  size_t num_fields,
4795  legion_file_mode_t mode);
4796 
4800  void
4801  legion_index_attach_launcher_attach_hdf5(legion_index_attach_launcher_t handle,
4802  legion_logical_region_t region,
4803  const char *filename,
4804  legion_field_map_t field_map,
4805  legion_file_mode_t mode);
4806 
4810  void
4811  legion_index_attach_launcher_attach_array_soa(legion_index_attach_launcher_t handle,
4812  legion_logical_region_t region,
4813  void *base_ptr, bool column_major,
4814  const legion_field_id_t *fields,
4815  size_t num_fields,
4816  legion_memory_t memory);
4817 
4821  void
4822  legion_index_attach_launcher_attach_array_aos(legion_index_attach_launcher_t handle,
4823  legion_logical_region_t region,
4824  void *base_ptr, bool column_major,
4825  const legion_field_id_t *fields,
4826  size_t num_fields,
4827  legion_memory_t memory);
4828 
4834  void
4835  legion_index_attach_launcher_destroy(legion_index_attach_launcher_t handle);
4836 
4842  legion_external_resources_t
4843  legion_attach_external_resources(legion_runtime_t runtime,
4844  legion_context_t ctx,
4845  legion_index_attach_launcher_t launcher);
4846 
4852  legion_future_t
4853  legion_detach_external_resources(legion_runtime_t runtime,
4854  legion_context_t ctx,
4855  legion_external_resources_t,
4856  bool flush, bool unordered);
4857 
4858  // -----------------------------------------------------------------------
4859  // Must Epoch Operations
4860  // -----------------------------------------------------------------------
4861 
4867  legion_must_epoch_launcher_t
4868  legion_must_epoch_launcher_create(
4869  legion_mapper_id_t id /* = 0 */,
4870  legion_mapping_tag_id_t launcher_tag /* = 0 */);
4871 
4877  void
4878  legion_must_epoch_launcher_destroy(legion_must_epoch_launcher_t handle);
4879 
4885  legion_future_map_t
4886  legion_must_epoch_launcher_execute(legion_runtime_t runtime,
4887  legion_context_t ctx,
4888  legion_must_epoch_launcher_t launcher);
4889 
4895  void
4896  legion_must_epoch_launcher_add_single_task(
4897  legion_must_epoch_launcher_t launcher,
4898  legion_domain_point_t point,
4899  legion_task_launcher_t handle);
4900 
4906  void
4907  legion_must_epoch_launcher_add_index_task(
4908  legion_must_epoch_launcher_t launcher,
4909  legion_index_launcher_t handle);
4910 
4914  void
4915  legion_must_epoch_launcher_set_launch_domain(
4916  legion_must_epoch_launcher_t launcher,
4917  legion_domain_t domain);
4918 
4922  void
4923  legion_must_epoch_launcher_set_launch_space(
4924  legion_must_epoch_launcher_t launcher,
4925  legion_index_space_t is);
4926 
4930  void
4931  legion_must_epoch_launcher_set_provenance(
4932  legion_must_epoch_launcher_t launcher, const char *provenance);
4933 
4934  // -----------------------------------------------------------------------
4935  // Fence Operations
4936  // -----------------------------------------------------------------------
4937 
4941  legion_future_t
4942  legion_runtime_issue_mapping_fence(legion_runtime_t runtime,
4943  legion_context_t ctx);
4944 
4948  legion_future_t
4949  legion_runtime_issue_execution_fence(legion_runtime_t runtime,
4950  legion_context_t ctx);
4951 
4952  // -----------------------------------------------------------------------
4953  // Tracing Operations
4954  // -----------------------------------------------------------------------
4955 
4959  void
4960  legion_runtime_begin_trace(legion_runtime_t runtime,
4961  legion_context_t ctx,
4962  legion_trace_id_t tid,
4963  bool logical_only);
4964 
4968  void
4969  legion_runtime_end_trace(legion_runtime_t runtime,
4970  legion_context_t ctx,
4971  legion_trace_id_t tid);
4972 
4973  // -----------------------------------------------------------------------
4974  // Frame Operations
4975  // -----------------------------------------------------------------------
4976 
4977  void
4978  legion_runtime_complete_frame(legion_runtime_t runtime,
4979  legion_context_t ctx);
4980 
4981  // -----------------------------------------------------------------------
4982  // Tunable Variables
4983  // -----------------------------------------------------------------------
4984 
4990  legion_future_t
4991  legion_runtime_select_tunable_value(legion_runtime_t runtime,
4992  legion_context_t ctx,
4993  legion_tunable_id_t tid,
4994  legion_mapper_id_t mapper /* = 0 */,
4995  legion_mapping_tag_id_t tag /* = 0 */);
4996 
4997  // -----------------------------------------------------------------------
4998  // Miscellaneous Operations
4999  // -----------------------------------------------------------------------
5000 
5004  bool
5005  legion_runtime_has_runtime(void);
5006 
5010  legion_runtime_t
5011  legion_runtime_get_runtime(void);
5012 
5016  bool
5017  legion_runtime_has_context(void);
5018 
5024  legion_context_t
5025  legion_runtime_get_context(void);
5026 
5032  void
5033  legion_context_destroy(legion_context_t);
5034 
5038  legion_processor_t
5039  legion_runtime_get_executing_processor(legion_runtime_t runtime,
5040  legion_context_t ctx);
5041 
5045  void
5046  legion_runtime_yield(legion_runtime_t runtime, legion_context_t ctx);
5047 
5051  legion_shard_id_t
5052  legion_runtime_local_shard(legion_runtime_t runtime, legion_context_t ctx);
5053 
5054  legion_shard_id_t
5055  legion_runtime_local_shard_without_context(void);
5056 
5060  size_t
5061  legion_runtime_total_shards(legion_runtime_t runtime, legion_context_t ctx);
5062 
5068  legion_shard_id_t
5069  legion_sharding_functor_shard(legion_sharding_id_t sid,
5070  legion_domain_point_t point,
5071  legion_domain_t full_space,
5072  size_t total_shards);
5073 
5088  void
5089  legion_sharding_functor_invert(legion_sharding_id_t sid,
5090  legion_shard_id_t shard,
5091  legion_domain_t shard_domain,
5092  legion_domain_t full_domain,
5093  size_t total_shards,
5094  legion_domain_point_t *points,
5095  size_t *points_size);
5096 
5097  void
5098  legion_runtime_enable_scheduler_lock(void);
5099 
5100  void
5101  legion_runtime_disable_scheduler_lock(void);
5102 
5106  void
5107  legion_runtime_print_once(legion_runtime_t runtime,
5108  legion_context_t ctx,
5109  FILE *f,
5110  const char *message);
5114  void
5115  legion_runtime_print_once_fd(legion_runtime_t runtime,
5116  legion_context_t ctx,
5117  int fd, const char *mode,
5118  const char *message);
5119 
5120  // -----------------------------------------------------------------------
5121  // Physical Data Operations
5122  // -----------------------------------------------------------------------
5123 
5129  void
5130  legion_physical_region_destroy(legion_physical_region_t handle);
5131 
5137  legion_physical_region_t
5138  legion_physical_region_copy(legion_physical_region_t handle);
5139 
5143  bool
5144  legion_physical_region_is_mapped(legion_physical_region_t handle);
5145 
5149  void
5150  legion_physical_region_wait_until_valid(legion_physical_region_t handle);
5151 
5155  bool
5156  legion_physical_region_is_valid(legion_physical_region_t handle);
5157 
5161  legion_logical_region_t
5162  legion_physical_region_get_logical_region(legion_physical_region_t handle);
5163 
5167  size_t
5168  legion_physical_region_get_field_count(legion_physical_region_t handle);
5169  legion_field_id_t
5170  legion_physical_region_get_field_id(legion_physical_region_t handle, size_t index);
5171 
5175  size_t
5176  legion_physical_region_get_memory_count(legion_physical_region_t handle);
5177  legion_memory_t
5178  legion_physical_region_get_memory(legion_physical_region_t handle, size_t index);
5179 
5185 #define ACCESSOR_ARRAY(DIM) \
5186  legion_accessor_array_##DIM##d_t \
5187  legion_physical_region_get_field_accessor_array_##DIM##d( \
5188  legion_physical_region_t handle, \
5189  legion_field_id_t fid);
5190  LEGION_FOREACH_N(ACCESSOR_ARRAY)
5191 #undef ACCESSOR_ARRAY
5192 
5193 #define ACCESSOR_ARRAY(DIM) \
5194  legion_accessor_array_##DIM##d_t \
5195  legion_physical_region_get_field_accessor_array_##DIM##d_with_transform( \
5196  legion_physical_region_t handle, \
5197  legion_field_id_t fid, \
5198  legion_domain_affine_transform_t transform);
5199  LEGION_FOREACH_N(ACCESSOR_ARRAY)
5200 #undef ACCESSOR_ARRAY
5201 
5202 #define RAW_PTR(DIM) \
5203  void * \
5204  legion_accessor_array_##DIM##d_raw_rect_ptr(legion_accessor_array_##DIM##d_t handle, \
5205  legion_rect_##DIM##d_t rect, \
5206  legion_rect_##DIM##d_t *subrect, \
5207  legion_byte_offset_t *offsets);
5208  LEGION_FOREACH_N(RAW_PTR)
5209 #undef RAW_PTR
5210 
5211  // Read
5212  void
5213  legion_accessor_array_1d_read(legion_accessor_array_1d_t handle,
5214  legion_ptr_t ptr,
5215  void *dst, size_t bytes);
5216 
5217 #define READ_ARRAY(DIM) \
5218  void \
5219  legion_accessor_array_##DIM##d_read_point(legion_accessor_array_##DIM##d_t handle, \
5220  legion_point_##DIM##d_t point, \
5221  void *dst, size_t bytes);
5222  LEGION_FOREACH_N(READ_ARRAY)
5223 #undef READ_ARRAY
5224 
5225  // Write
5226  void
5227  legion_accessor_array_1d_write(legion_accessor_array_1d_t handle,
5228  legion_ptr_t ptr,
5229  const void *src, size_t bytes);
5230 
5231 #define WRITE_ARRAY(DIM) \
5232  void \
5233  legion_accessor_array_##DIM##d_write_point(legion_accessor_array_##DIM##d_t handle, \
5234  legion_point_##DIM##d_t point, \
5235  const void *src, size_t bytes);
5236  LEGION_FOREACH_N(WRITE_ARRAY)
5237 #undef WRITE_ARRAY
5238 
5239  // Ref
5240  void *
5241  legion_accessor_array_1d_ref(legion_accessor_array_1d_t handle,
5242  legion_ptr_t ptr);
5243 
5244 #define REF_ARRAY(DIM) \
5245  void * \
5246  legion_accessor_array_##DIM##d_ref_point(legion_accessor_array_##DIM##d_t handle, \
5247  legion_point_##DIM##d_t point);
5248  LEGION_FOREACH_N(REF_ARRAY)
5249 #undef REF_ARRAY
5250 
5254 #define DESTROY_ARRAY(DIM) \
5255  void \
5256  legion_accessor_array_##DIM##d_destroy(legion_accessor_array_##DIM##d_t handle);
5257  LEGION_FOREACH_N(DESTROY_ARRAY)
5258 #undef DESTROY_ARRAY
5259 
5260  // -----------------------------------------------------------------------
5261  // External Resource Operations
5262  // -----------------------------------------------------------------------
5263 
5267  void
5268  legion_external_resources_destroy(legion_external_resources_t handle);
5269 
5273  size_t
5274  legion_external_resources_size(legion_external_resources_t handle);
5275 
5281  legion_physical_region_t
5282  legion_external_resources_get_region(legion_external_resources_t handle,
5283  unsigned index);
5284 
5285  // -----------------------------------------------------------------------
5286  // Mappable Operations
5287  // -----------------------------------------------------------------------
5288 
5292  enum legion_mappable_type_id_t
5293  legion_mappable_get_type(legion_mappable_t mappable);
5294 
5298  legion_task_t
5299  legion_mappable_as_task(legion_mappable_t mappable);
5300 
5304  legion_copy_t
5305  legion_mappable_as_copy(legion_mappable_t mappable);
5306 
5310  legion_fill_t
5311  legion_mappable_as_fill(legion_mappable_t mappable);
5312 
5316  legion_inline_t
5317  legion_mappable_as_inline_mapping(legion_mappable_t mappable);
5318 
5319 
5320  // -----------------------------------------------------------------------
5321  // Task Operations
5322  // -----------------------------------------------------------------------
5323 
5327  legion_unique_id_t
5328  legion_context_get_unique_id(legion_context_t ctx);
5329 
5340  legion_task_mut_t
5341  legion_task_create_empty();
5342 
5348  void
5349  legion_task_destroy(legion_task_mut_t handle);
5350 
5356  legion_task_t
5357  legion_task_mut_as_task(legion_task_mut_t task);
5358 
5362  legion_unique_id_t
5363  legion_task_get_unique_id(legion_task_t task);
5364 
5368  int
5369  legion_task_get_depth(legion_task_t task);
5370 
5374  legion_mapper_id_t
5375  legion_task_get_mapper(legion_task_t task);
5376 
5380  legion_mapping_tag_id_t
5381  legion_task_get_tag(legion_task_t task);
5382 
5386  void
5387  legion_task_id_attach_semantic_information(legion_runtime_t runtime,
5388  legion_task_id_t task_id,
5389  legion_semantic_tag_t tag,
5390  const void *buffer,
5391  size_t size,
5392  bool is_mutable /* = false */);
5393 
5397  bool
5398  legion_task_id_retrieve_semantic_information(
5399  legion_runtime_t runtime,
5400  legion_task_id_t task_id,
5401  legion_semantic_tag_t tag,
5402  const void **result,
5403  size_t *size,
5404  bool can_fail /* = false */,
5405  bool wait_until_ready /* = false */);
5406 
5410  void
5411  legion_task_id_attach_name(legion_runtime_t runtime,
5412  legion_task_id_t task_id,
5413  const char *name,
5414  bool is_mutable /* = false */);
5415 
5419  void
5420  legion_task_id_retrieve_name(legion_runtime_t runtime,
5421  legion_task_id_t task_id,
5422  const char **result);
5423 
5427  void *
5428  legion_task_get_args(legion_task_t task);
5429 
5433  void
5434  legion_task_set_args(legion_task_mut_t task, void *args);
5435 
5439  size_t
5440  legion_task_get_arglen(legion_task_t task);
5441 
5445  void
5446  legion_task_set_arglen(legion_task_mut_t task, size_t arglen);
5447 
5451  legion_domain_t
5452  legion_task_get_index_domain(legion_task_t task);
5453 
5457  legion_domain_point_t
5458  legion_task_get_index_point(legion_task_t task);
5459 
5463  bool
5464  legion_task_get_is_index_space(legion_task_t task);
5465 
5469  void *
5470  legion_task_get_local_args(legion_task_t task);
5471 
5475  size_t
5476  legion_task_get_local_arglen(legion_task_t task);
5477 
5481  unsigned
5482  legion_task_get_regions_size(legion_task_t task);
5483 
5489  legion_region_requirement_t
5490  legion_task_get_requirement(legion_task_t task, unsigned idx);
5491 
5495  unsigned
5496  legion_task_get_futures_size(legion_task_t task);
5497 
5501  legion_future_t
5502  legion_task_get_future(legion_task_t task, unsigned idx);
5503 
5507  void
5508  legion_task_add_future(legion_task_mut_t task, legion_future_t future);
5509 
5513  legion_task_id_t
5514  legion_task_get_task_id(legion_task_t task);
5515 
5519  legion_processor_t
5520  legion_task_get_target_proc(legion_task_t task);
5521 
5525  const char *
5526  legion_task_get_name(legion_task_t task);
5527 
5528  // -----------------------------------------------------------------------
5529  // Inline Operations
5530  // -----------------------------------------------------------------------
5531 
5537  legion_region_requirement_t
5538  legion_inline_get_requirement(legion_inline_t inline_operation);
5539 
5540  // -----------------------------------------------------------------------
5541  // Execution Constraints
5542  // -----------------------------------------------------------------------
5543 
5549  legion_execution_constraint_set_t
5550  legion_execution_constraint_set_create(void);
5551 
5557  void
5558  legion_execution_constraint_set_destroy(
5559  legion_execution_constraint_set_t handle);
5560 
5564  void
5565  legion_execution_constraint_set_add_isa_constraint(
5566  legion_execution_constraint_set_t handle,
5567  uint64_t prop);
5568 
5573  void
5574  legion_execution_constraint_set_add_processor_constraint(
5575  legion_execution_constraint_set_t handle,
5576  legion_processor_kind_t proc_kind);
5577 
5582  void
5583  legion_execution_constraint_set_add_resource_constraint(
5584  legion_execution_constraint_set_t handle,
5585  legion_resource_constraint_t resource,
5586  legion_equality_kind_t eq,
5587  size_t value);
5588 
5593  void
5594  legion_execution_constraint_set_add_launch_constraint(
5595  legion_execution_constraint_set_t handle,
5596  legion_launch_constraint_t kind,
5597  size_t value);
5598 
5603  void
5604  legion_execution_constraint_set_add_launch_constraint_multi_dim(
5605  legion_execution_constraint_set_t handle,
5606  legion_launch_constraint_t kind,
5607  const size_t *values,
5608  int dims);
5609 
5614  void
5615  legion_execution_constraint_set_add_colocation_constraint(
5616  legion_execution_constraint_set_t handle,
5617  const unsigned *indexes,
5618  size_t num_indexes,
5619  const legion_field_id_t *fields,
5620  size_t num_fields);
5621 
5622  // -----------------------------------------------------------------------
5623  // Layout Constraints
5624  // -----------------------------------------------------------------------
5625 
5631  legion_layout_constraint_set_t
5632  legion_layout_constraint_set_create(void);
5633 
5639  void
5640  legion_layout_constraint_set_destroy(legion_layout_constraint_set_t handle);
5641 
5647  legion_layout_constraint_id_t
5648  legion_layout_constraint_set_register(
5649  legion_runtime_t runtime,
5650  legion_field_space_t fspace,
5651  legion_layout_constraint_set_t handle,
5652  const char *layout_name /* = NULL */);
5653 
5659  legion_layout_constraint_id_t
5660  legion_layout_constraint_set_preregister(
5661  legion_layout_constraint_set_t handle,
5662  const char *layout_name /* = NULL */);
5663 
5669  void
5670  legion_layout_constraint_set_release(legion_runtime_t runtime,
5671  legion_layout_constraint_id_t handle);
5672 
5677  void
5678  legion_layout_constraint_set_add_specialized_constraint(
5679  legion_layout_constraint_set_t handle,
5680  legion_specialized_constraint_t specialized,
5681  legion_reduction_op_id_t redop);
5682 
5687  void
5688  legion_layout_constraint_set_add_memory_constraint(
5689  legion_layout_constraint_set_t handle,
5690  legion_memory_kind_t kind);
5691 
5696  void
5697  legion_layout_constraint_set_add_field_constraint(
5698  legion_layout_constraint_set_t handle,
5699  const legion_field_id_t *fields,
5700  size_t num_fields,
5701  bool contiguous,
5702  bool inorder);
5703 
5708  void
5709  legion_layout_constraint_set_add_ordering_constraint(
5710  legion_layout_constraint_set_t handle,
5711  const legion_dimension_kind_t *dims,
5712  size_t num_dims,
5713  bool contiguous);
5714 
5719  void
5720  legion_layout_constraint_set_add_tiling_constraint(
5721  legion_layout_constraint_set_t handle,
5722  legion_dimension_kind_t dim,
5723  size_t value, bool tiles);
5724 
5729  void
5730  legion_layout_constraint_set_add_dimension_constraint(
5731  legion_layout_constraint_set_t handle,
5732  legion_dimension_kind_t dim,
5733  legion_equality_kind_t eq,
5734  size_t value);
5735 
5740  void
5741  legion_layout_constraint_set_add_alignment_constraint(
5742  legion_layout_constraint_set_t handle,
5743  legion_field_id_t field,
5744  legion_equality_kind_t eq,
5745  size_t byte_boundary);
5746 
5751  void
5752  legion_layout_constraint_set_add_offset_constraint(
5753  legion_layout_constraint_set_t handle,
5754  legion_field_id_t field,
5755  size_t offset);
5756 
5761  void
5762  legion_layout_constraint_set_add_pointer_constraint(
5763  legion_layout_constraint_set_t handle,
5764  legion_memory_t memory,
5765  uintptr_t ptr);
5766 
5767  // -----------------------------------------------------------------------
5768  // Task Layout Constraints
5769  // -----------------------------------------------------------------------
5770 
5776  legion_task_layout_constraint_set_t
5777  legion_task_layout_constraint_set_create(void);
5778 
5784  void
5785  legion_task_layout_constraint_set_destroy(
5786  legion_task_layout_constraint_set_t handle);
5787 
5791  void
5792  legion_task_layout_constraint_set_add_layout_constraint(
5793  legion_task_layout_constraint_set_t handle,
5794  unsigned idx,
5795  legion_layout_constraint_id_t layout);
5796 
5797  // -----------------------------------------------------------------------
5798  // Start-up Operations
5799  // -----------------------------------------------------------------------
5800 
5804  void
5805  legion_runtime_initialize(int *argc,
5806  char ***argv,
5807  bool filter /* = false */);
5808 
5812  int
5813  legion_runtime_start(int argc,
5814  char **argv,
5815  bool background /* = false */);
5816 
5820  int
5821  legion_runtime_wait_for_shutdown(void);
5822 
5826  void
5827  legion_runtime_set_return_code(int return_code);
5828 
5832  void
5833  legion_runtime_set_top_level_task_id(legion_task_id_t top_id);
5834 
5838  size_t
5839  legion_runtime_get_maximum_dimension(void);
5840 
5844  const legion_input_args_t
5845  legion_runtime_get_input_args(void);
5846 
5850  void
5851  legion_runtime_add_registration_callback(
5852  legion_registration_callback_pointer_t callback);
5853 
5857  legion_mapper_id_t
5858  legion_runtime_generate_library_mapper_ids(
5859  legion_runtime_t runtime,
5860  const char *library_name,
5861  size_t count);
5862 
5866  void
5867  legion_runtime_replace_default_mapper(
5868  legion_runtime_t runtime,
5869  legion_mapper_t mapper,
5870  legion_processor_t proc);
5871 
5875  legion_projection_id_t
5876  legion_runtime_generate_static_projection_id();
5877 
5881  legion_projection_id_t
5882  legion_runtime_generate_library_projection_ids(
5883  legion_runtime_t runtime,
5884  const char *library_name,
5885  size_t count);
5886 
5890  legion_sharding_id_t
5891  legion_runtime_generate_library_sharding_ids(
5892  legion_runtime_t runtime,
5893  const char *library_name,
5894  size_t count);
5895 
5899  legion_reduction_op_id_t
5900  legion_runtime_generate_library_reduction_ids(
5901  legion_runtime_t runtime,
5902  const char *library_name,
5903  size_t count);
5904 
5908  void
5909  legion_runtime_preregister_projection_functor(
5910  legion_projection_id_t id,
5911  bool exclusive,
5912  unsigned depth,
5913  legion_projection_functor_logical_region_t region_functor,
5914  legion_projection_functor_logical_partition_t partition_functor);
5915 
5919  void
5920  legion_runtime_register_projection_functor(
5921  legion_runtime_t runtime,
5922  legion_projection_id_t id,
5923  bool exclusive,
5924  unsigned depth,
5925  legion_projection_functor_logical_region_args_t region_functor,
5926  legion_projection_functor_logical_partition_args_t partition_functor);
5927 
5931  void
5932  legion_runtime_preregister_projection_functor_args(
5933  legion_projection_id_t id,
5934  bool exclusive,
5935  unsigned depth,
5936  legion_projection_functor_logical_region_args_t region_functor,
5937  legion_projection_functor_logical_partition_args_t partition_functor);
5938 
5942  void
5943  legion_runtime_register_projection_functor_args(
5944  legion_runtime_t runtime,
5945  legion_projection_id_t id,
5946  bool exclusive,
5947  unsigned depth,
5948  legion_projection_functor_logical_region_t region_functor,
5949  legion_projection_functor_logical_partition_t partition_functor);
5950 
5954  void
5955  legion_runtime_preregister_projection_functor_mappable(
5956  legion_projection_id_t id,
5957  bool exclusive,
5958  unsigned depth,
5959  legion_projection_functor_logical_region_mappable_t region_functor,
5960  legion_projection_functor_logical_partition_mappable_t partition_functor);
5961 
5965  void
5966  legion_runtime_register_projection_functor_mappable(
5967  legion_runtime_t runtime,
5968  legion_projection_id_t id,
5969  bool exclusive,
5970  unsigned depth,
5971  legion_projection_functor_logical_region_mappable_t region_functor,
5972  legion_projection_functor_logical_partition_mappable_t partition_functor);
5973 
5977  legion_task_id_t
5978  legion_runtime_generate_library_task_ids(
5979  legion_runtime_t runtime,
5980  const char *library_name,
5981  size_t count);
5982 
5986  legion_task_id_t
5987  legion_runtime_register_task_variant_fnptr(
5988  legion_runtime_t runtime,
5989  legion_task_id_t id /* = AUTO_GENERATE_ID */,
5990  const char *task_name /* = NULL*/,
5991  const char *variant_name /* = NULL*/,
5992  bool global,
5993  legion_execution_constraint_set_t execution_constraints,
5994  legion_task_layout_constraint_set_t layout_constraints,
5995  legion_task_config_options_t options,
5996  legion_task_pointer_wrapped_t wrapped_task_pointer,
5997  const void *userdata,
5998  size_t userlen);
5999 
6003  legion_task_id_t
6004  legion_runtime_preregister_task_variant_fnptr(
6005  legion_task_id_t id /* = AUTO_GENERATE_ID */,
6006  legion_variant_id_t variant_id /* = AUTO_GENERATE_ID */,
6007  const char *task_name /* = NULL*/,
6008  const char *variant_name /* = NULL*/,
6009  legion_execution_constraint_set_t execution_constraints,
6010  legion_task_layout_constraint_set_t layout_constraints,
6011  legion_task_config_options_t options,
6012  legion_task_pointer_wrapped_t wrapped_task_pointer,
6013  const void *userdata,
6014  size_t userlen);
6015 
6016 #ifdef REALM_USE_LLVM
6020  legion_task_id_t
6021  legion_runtime_register_task_variant_llvmir(
6022  legion_runtime_t runtime,
6023  legion_task_id_t id /* = AUTO_GENERATE_ID */,
6024  const char *task_name /* = NULL*/,
6025  bool global,
6026  legion_execution_constraint_set_t execution_constraints,
6027  legion_task_layout_constraint_set_t layout_constraints,
6028  legion_task_config_options_t options,
6029  const char *llvmir,
6030  const char *entry_symbol,
6031  const void *userdata,
6032  size_t userlen);
6033 
6037  legion_task_id_t
6038  legion_runtime_preregister_task_variant_llvmir(
6039  legion_task_id_t id /* = AUTO_GENERATE_ID */,
6040  legion_variant_id_t variant_id /* = AUTO_GENERATE_ID */,
6041  const char *task_name /* = NULL*/,
6042  legion_execution_constraint_set_t execution_constraints,
6043  legion_task_layout_constraint_set_t layout_constraints,
6044  legion_task_config_options_t options,
6045  const char *llvmir,
6046  const char *entry_symbol,
6047  const void *userdata,
6048  size_t userlen);
6049 #endif
6050 
6051 #ifdef REALM_USE_PYTHON
6055  legion_task_id_t
6056  legion_runtime_register_task_variant_python_source(
6057  legion_runtime_t runtime,
6058  legion_task_id_t id /* = AUTO_GENERATE_ID */,
6059  const char *task_name /* = NULL*/,
6060  bool global,
6061  legion_execution_constraint_set_t execution_constraints,
6062  legion_task_layout_constraint_set_t layout_constraints,
6063  legion_task_config_options_t options,
6064  const char *module_name,
6065  const char *function_name,
6066  const void *userdata,
6067  size_t userlen);
6068 
6072  legion_task_id_t
6073  legion_runtime_register_task_variant_python_source_qualname(
6074  legion_runtime_t runtime,
6075  legion_task_id_t id /* = AUTO_GENERATE_ID */,
6076  const char *task_name /* = NULL*/,
6077  bool global,
6078  legion_execution_constraint_set_t execution_constraints,
6079  legion_task_layout_constraint_set_t layout_constraints,
6080  legion_task_config_options_t options,
6081  const char *module_name,
6082  const char **function_qualname,
6083  size_t function_qualname_len,
6084  const void *userdata,
6085  size_t userlen);
6086 #endif
6087 
6091  void
6092  legion_task_preamble(
6093  const void *data,
6094  size_t datalen,
6095  realm_id_t proc_id,
6096  legion_task_t *taskptr,
6097  const legion_physical_region_t **regionptr,
6098  unsigned * num_regions_ptr,
6099  legion_context_t * ctxptr,
6100  legion_runtime_t * runtimeptr);
6101 
6105  void
6106  legion_task_postamble(
6107  legion_runtime_t runtime,
6108  legion_context_t ctx,
6109  const void *retval,
6110  size_t retsize);
6111 
6112  // -----------------------------------------------------------------------
6113  // Timing Operations
6114  // -----------------------------------------------------------------------
6115 
6119  unsigned long long
6120  legion_get_current_time_in_micros(void);
6121 
6125  unsigned long long
6126  legion_get_current_time_in_nanos(void);
6127 
6131  legion_future_t
6132  legion_issue_timing_op_seconds(legion_runtime_t runtime,
6133  legion_context_t ctx);
6134 
6138  legion_future_t
6139  legion_issue_timing_op_microseconds(legion_runtime_t runtime,
6140  legion_context_t ctx);
6141 
6145  legion_future_t
6146  legion_issue_timing_op_nanoseconds(legion_runtime_t runtime,
6147  legion_context_t ctx);
6148 
6149  // -----------------------------------------------------------------------
6150  // Logging Operations
6151  // -----------------------------------------------------------------------
6152 
6158  legion_logger_t
6159  legion_logger_create(const char* name);
6160 
6166  void
6167  legion_logger_destroy(legion_logger_t handle);
6168 
6172  void
6173  legion_logger_spew(legion_logger_t handle, const char *msg);
6174 
6178  void
6179  legion_logger_debug(legion_logger_t handle, const char *msg);
6180 
6184  void
6185  legion_logger_info(legion_logger_t handle, const char *msg);
6186 
6190  void
6191  legion_logger_print(legion_logger_t handle, const char *msg);
6192 
6196  void
6197  legion_logger_warning(legion_logger_t handle, const char *msg);
6198 
6202  void
6203  legion_logger_error(legion_logger_t handle, const char *msg);
6204 
6208  void
6209  legion_logger_fatal(legion_logger_t handle, const char *msg);
6210 
6214  bool
6215  legion_logger_want_spew(legion_logger_t handle);
6216 
6220  bool
6221  legion_logger_want_debug(legion_logger_t handle);
6222 
6226  bool
6227  legion_logger_want_info(legion_logger_t handle);
6228 
6232  bool
6233  legion_logger_want_print(legion_logger_t handle);
6234 
6238  bool
6239  legion_logger_want_warning(legion_logger_t handle);
6240 
6244  bool
6245  legion_logger_want_error(legion_logger_t handle);
6246 
6250  bool
6251  legion_logger_want_fatal(legion_logger_t handle);
6252 
6253  // -----------------------------------------------------------------------
6254  // Machine Operations
6255  // -----------------------------------------------------------------------
6256 
6262  legion_machine_t
6263  legion_machine_create(void);
6264 
6270  void
6271  legion_machine_destroy(legion_machine_t handle);
6272 
6276  void
6277  legion_machine_get_all_processors(
6278  legion_machine_t machine,
6279  legion_processor_t *processors,
6280  size_t processors_size);
6281 
6285  size_t
6286  legion_machine_get_all_processors_size(legion_machine_t machine);
6287 
6291  void
6292  legion_machine_get_all_memories(
6293  legion_machine_t machine,
6294  legion_memory_t *memories,
6295  size_t memories_size);
6296 
6300  size_t
6301  legion_machine_get_all_memories_size(legion_machine_t machine);
6302 
6303  // -----------------------------------------------------------------------
6304  // Processor Operations
6305  // -----------------------------------------------------------------------
6306 
6310  legion_processor_kind_t
6311  legion_processor_kind(legion_processor_t proc);
6312 
6316  legion_address_space_t
6317  legion_processor_address_space(legion_processor_t proc);
6318 
6319  // -----------------------------------------------------------------------
6320  // Memory Operations
6321  // -----------------------------------------------------------------------
6322 
6326  legion_memory_kind_t
6327  legion_memory_kind(legion_memory_t mem);
6328 
6332  legion_address_space_t
6333  legion_memory_address_space(legion_memory_t mem);
6334 
6335  // -----------------------------------------------------------------------
6336  // Processor Query Operations
6337  // -----------------------------------------------------------------------
6338 
6344  legion_processor_query_t
6345  legion_processor_query_create(legion_machine_t machine);
6346 
6352  legion_processor_query_t
6353  legion_processor_query_create_copy(legion_processor_query_t query);
6354 
6360  void
6361  legion_processor_query_destroy(legion_processor_query_t handle);
6362 
6368  void
6369  legion_processor_query_only_kind(legion_processor_query_t query,
6370  legion_processor_kind_t kind);
6371 
6377  void
6378  legion_processor_query_local_address_space(legion_processor_query_t query);
6379 
6385  void
6386  legion_processor_query_same_address_space_as_processor(legion_processor_query_t query,
6387  legion_processor_t proc);
6388 
6394  void
6395  legion_processor_query_same_address_space_as_memory(legion_processor_query_t query,
6396  legion_memory_t mem);
6397 
6403  void
6404  legion_processor_query_has_affinity_to_memory(legion_processor_query_t query,
6405  legion_memory_t mem,
6406  unsigned min_bandwidth /* = 0 */,
6407  unsigned max_latency /* = 0 */);
6408 
6414  void
6415  legion_processor_query_best_affinity_to_memory(legion_processor_query_t query,
6416  legion_memory_t mem,
6417  int bandwidth_weight /* = 0 */,
6418  int latency_weight /* = 0 */);
6419 
6423  size_t
6424  legion_processor_query_count(legion_processor_query_t query);
6425 
6429  legion_processor_t
6430  legion_processor_query_first(legion_processor_query_t query);
6431 
6435  legion_processor_t
6436  legion_processor_query_next(legion_processor_query_t query,
6437  legion_processor_t after);
6438 
6442  legion_processor_t
6443  legion_processor_query_random(legion_processor_query_t query);
6444 
6445  // -----------------------------------------------------------------------
6446  // Memory Query Operations
6447  // -----------------------------------------------------------------------
6448 
6454  legion_memory_query_t
6455  legion_memory_query_create(legion_machine_t machine);
6456 
6462  legion_memory_query_t
6463  legion_memory_query_create_copy(legion_memory_query_t query);
6464 
6470  void
6471  legion_memory_query_destroy(legion_memory_query_t handle);
6472 
6478  void
6479  legion_memory_query_only_kind(legion_memory_query_t query,
6480  legion_memory_kind_t kind);
6481 
6487  void
6488  legion_memory_query_local_address_space(legion_memory_query_t query);
6489 
6495  void
6496  legion_memory_query_same_address_space_as_processor(legion_memory_query_t query,
6497  legion_processor_t proc);
6498 
6504  void
6505  legion_memory_query_same_address_space_as_memory(legion_memory_query_t query,
6506  legion_memory_t mem);
6507 
6513  void
6514  legion_memory_query_has_affinity_to_processor(legion_memory_query_t query,
6515  legion_processor_t proc,
6516  unsigned min_bandwidth /* = 0 */,
6517  unsigned max_latency /* = 0 */);
6518 
6524  void
6525  legion_memory_query_has_affinity_to_memory(legion_memory_query_t query,
6526  legion_memory_t mem,
6527  unsigned min_bandwidth /* = 0 */,
6528  unsigned max_latency /* = 0 */);
6529 
6535  void
6536  legion_memory_query_best_affinity_to_processor(legion_memory_query_t query,
6537  legion_processor_t proc,
6538  int bandwidth_weight /* = 0 */,
6539  int latency_weight /* = 0 */);
6540 
6546  void
6547  legion_memory_query_best_affinity_to_memory(legion_memory_query_t query,
6548  legion_memory_t mem,
6549  int bandwidth_weight /* = 0 */,
6550  int latency_weight /* = 0 */);
6551 
6555  size_t
6556  legion_memory_query_count(legion_memory_query_t query);
6557 
6561  legion_memory_t
6562  legion_memory_query_first(legion_memory_query_t query);
6563 
6567  legion_memory_t
6568  legion_memory_query_next(legion_memory_query_t query,
6569  legion_memory_t after);
6570 
6574  legion_memory_t
6575  legion_memory_query_random(legion_memory_query_t query);
6576 
6577  // -----------------------------------------------------------------------
6578  // Physical Instance Operations
6579  // -----------------------------------------------------------------------
6580 
6581  /*
6582  * @param instance Caller must have ownership of parameter `instance`.
6583  *
6584  * @see Legion::Mapping::PhysicalInstance
6585  */
6586  void
6587  legion_physical_instance_destroy(legion_physical_instance_t instance);
6588 
6589  // -----------------------------------------------------------------------
6590  // Slice Task Output
6591  // -----------------------------------------------------------------------
6592 
6596  void
6597  legion_slice_task_output_slices_add(
6598  legion_slice_task_output_t output,
6599  legion_task_slice_t slice);
6600 
6604  void
6605  legion_slice_task_output_verify_correctness_set(
6606  legion_slice_task_output_t output,
6607  bool verify_correctness);
6608 
6609  // -----------------------------------------------------------------------
6610  // Map Task Input/Output
6611  // -----------------------------------------------------------------------
6612 
6616  void
6617  legion_map_task_output_chosen_instances_clear_all(
6618  legion_map_task_output_t output);
6619 
6623  void
6624  legion_map_task_output_chosen_instances_clear_each(
6625  legion_map_task_output_t output,
6626  size_t idx);
6627 
6631  void
6632  legion_map_task_output_chosen_instances_add(
6633  legion_map_task_output_t output,
6634  legion_physical_instance_t *instances,
6635  size_t instances_size);
6636 
6640  void
6641  legion_map_task_output_chosen_instances_set(
6642  legion_map_task_output_t output,
6643  size_t idx,
6644  legion_physical_instance_t *instances,
6645  size_t instances_size);
6646 
6650  void
6651  legion_map_task_output_target_procs_clear(
6652  legion_map_task_output_t output);
6653 
6657  void
6658  legion_map_task_output_target_procs_add(
6659  legion_map_task_output_t output,
6660  legion_processor_t proc);
6661 
6665  legion_processor_t
6666  legion_map_task_output_target_procs_get(
6667  legion_map_task_output_t output,
6668  size_t idx);
6669 
6673  void
6674  legion_map_task_output_task_priority_set(
6675  legion_map_task_output_t output,
6676  legion_task_priority_t priority);
6677 
6678  // -----------------------------------------------------------------------
6679  // MapperRuntime Operations
6680  // -----------------------------------------------------------------------
6681 
6687  bool
6688  legion_mapper_runtime_create_physical_instance_layout_constraint(
6689  legion_mapper_runtime_t runtime,
6690  legion_mapper_context_t ctx,
6691  legion_memory_t target_memory,
6692  legion_layout_constraint_set_t constraints,
6693  const legion_logical_region_t *regions,
6694  size_t regions_size,
6695  legion_physical_instance_t *result,
6696  bool acquire,
6697  legion_garbage_collection_priority_t priority);
6698 
6704  bool
6705  legion_mapper_runtime_create_physical_instance_layout_constraint_id(
6706  legion_mapper_runtime_t runtime,
6707  legion_mapper_context_t ctx,
6708  legion_memory_t target_memory,
6709  legion_layout_constraint_id_t layout_id,
6710  const legion_logical_region_t *regions,
6711  size_t regions_size,
6712  legion_physical_instance_t *result,
6713  bool acquire,
6714  legion_garbage_collection_priority_t priority);
6715 
6721  bool
6722  legion_mapper_runtime_find_or_create_physical_instance_layout_constraint(
6723  legion_mapper_runtime_t runtime,
6724  legion_mapper_context_t ctx,
6725  legion_memory_t target_memory,
6726  legion_layout_constraint_set_t constraints,
6727  const legion_logical_region_t *regions,
6728  size_t regions_size,
6729  legion_physical_instance_t *result,
6730  bool *created,
6731  bool acquire,
6732  legion_garbage_collection_priority_t priority,
6733  bool tight_region_bounds);
6734 
6740  bool
6741  legion_mapper_runtime_find_or_create_physical_instance_layout_constraint_id(
6742  legion_mapper_runtime_t runtime,
6743  legion_mapper_context_t ctx,
6744  legion_memory_t target_memory,
6745  legion_layout_constraint_id_t layout_id,
6746  const legion_logical_region_t *regions,
6747  size_t regions_size,
6748  legion_physical_instance_t *result,
6749  bool *created,
6750  bool acquire,
6751  legion_garbage_collection_priority_t priority,
6752  bool tight_region_bounds);
6753 
6759  bool
6760  legion_mapper_runtime_find_physical_instance_layout_constraint(
6761  legion_mapper_runtime_t runtime,
6762  legion_mapper_context_t ctx,
6763  legion_memory_t target_memory,
6764  legion_layout_constraint_set_t constraints,
6765  const legion_logical_region_t *regions,
6766  size_t regions_size,
6767  legion_physical_instance_t *result,
6768  bool acquire,
6769  bool tight_region_bounds);
6770 
6776  bool
6777  legion_mapper_runtime_find_physical_instance_layout_constraint_id(
6778  legion_mapper_runtime_t runtime,
6779  legion_mapper_context_t ctx,
6780  legion_memory_t target_memory,
6781  legion_layout_constraint_id_t layout_id,
6782  const legion_logical_region_t *regions,
6783  size_t regions_size,
6784  legion_physical_instance_t *result,
6785  bool acquire,
6786  bool tight_region_bounds);
6787 
6788 
6794  bool
6795  legion_mapper_runtime_acquire_instance(
6796  legion_mapper_runtime_t runtime,
6797  legion_mapper_context_t ctx,
6798  legion_physical_instance_t instance);
6799 
6805  bool
6806  legion_mapper_runtime_acquire_instances(
6807  legion_mapper_runtime_t runtime,
6808  legion_mapper_context_t ctx,
6809  legion_physical_instance_t *instances,
6810  size_t instances_size);
6811 
6812  // A hidden method here that hopefully nobody sees or ever needs
6813  // to use but its here anyway just in case
6814  legion_shard_id_t
6815  legion_context_get_shard_id(legion_runtime_t /*runtime*/,
6816  legion_context_t /*context*/,
6817  bool /*I know what I am doing*/);
6818  // Another hidden method for getting the number of shards
6819  size_t
6820  legion_context_get_num_shards(legion_runtime_t /*runtime*/,
6821  legion_context_t /*context*/,
6822  bool /*I know what I am doing*/);
6823  // Another hidden method for control replication that most
6824  // people should not be using but for which there are legitamite
6825  // user, especially in garbage collected languages
6826  // Note the caller takes ownership of the future
6827  legion_future_t
6828  legion_context_consensus_match(legion_runtime_t /*runtime*/,
6829  legion_context_t /*context*/,
6830  const void* /*input*/,
6831  void* /*output*/,
6832  size_t /*num elements*/,
6833  size_t /*element size*/);
6834 
6838  legion_physical_region_t
6839  legion_get_physical_region_by_id(
6840  legion_physical_region_t *regionptr,
6841  int id,
6842  int num_regions);
6843 #ifdef __cplusplus
6844 }
6845 #endif
6846 
6847 #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_phase_barrier_t
struct legion_phase_barrier_t legion_phase_barrier_t
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_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:455
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_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_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:5254
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_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_task_options_t
struct legion_task_options_t legion_task_options_t
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_ptr_t
struct legion_ptr_t legion_ptr_t
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:418
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_task_get_name
const char * legion_task_get_name(legion_task_t task)
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_logical_partition_t
struct legion_logical_partition_t legion_logical_partition_t
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:407
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:442
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_processor_t
struct legion_processor_t legion_processor_t
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_get_projection_args
const void * legion_index_launcher_get_projection_args(legion_region_requirement_t requirement, size_t *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_domain_transform_t
struct legion_domain_transform_t legion_domain_transform_t
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:680
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_input_args_t
struct legion_input_args_t legion_input_args_t
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_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_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_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:597
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_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:698
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_pointer_wrapped_t
realm_task_pointer_t legion_task_pointer_wrapped_t
Definition: legion_c.h:400
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_domain_affine_transform_t
struct legion_domain_affine_transform_t legion_domain_affine_transform_t
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_task_config_options_t
struct legion_task_config_options_t legion_task_config_options_t
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:467
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_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_task_get_args
void * legion_task_get_args(legion_task_t task)
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:2889
legion_logical_region_t
struct legion_logical_region_t legion_logical_region_t
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:429
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_field_space_t
struct legion_field_space_t legion_field_space_t
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:669
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:529
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_task_get_local_args
void * legion_task_get_local_args(legion_task_t task)
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_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)
legion_untyped_buffer_t
struct legion_untyped_buffer_t legion_untyped_buffer_t
ITERATOR_OP
#define ITERATOR_OP(DIM)
Definition: legion_c.h:707
legion_future_get_untyped_pointer
const void * legion_future_get_untyped_pointer(legion_future_t handle)
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:689
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:513
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_index_partition_t
struct legion_index_partition_t legion_index_partition_t
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_memory_t
struct legion_memory_t legion_memory_t
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_future_get_metadata
const void * legion_future_get_metadata(legion_future_t handle, size_t *size)
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:588
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:5193
legion_task_slice_t
struct legion_task_slice_t legion_task_slice_t
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_domain_t
struct legion_domain_t legion_domain_t
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_t
struct legion_domain_point_t legion_domain_point_t
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_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_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:390
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_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:1177
legion_runtime_generate_static_projection_id
legion_projection_id_t legion_runtime_generate_static_projection_id()
legion_index_space_t
struct legion_index_space_t legion_index_space_t
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_dynamic_collective_t
struct legion_dynamic_collective_t legion_dynamic_collective_t
legion_config.h
legion_byte_offset_t
Definition: legion_c.h:299
legion_domain_affine_transform_t
Definition: legion_c.h:240
legion_domain_point_t
Definition: legion_c.h:195
legion_domain_t
Definition: legion_c.h:156
legion_domain_transform_t
Definition: legion_c.h:203
legion_dynamic_collective_t
Definition: legion_c.h:358
legion_field_space_t
Definition: legion_c.h:266
legion_index_partition_t
Definition: legion_c.h:257
legion_index_space_t
Definition: legion_c.h:248
legion_input_args_t
Definition: legion_c.h:306
legion_logical_partition_t
Definition: legion_c.h:282
legion_logical_region_t
Definition: legion_c.h:273
legion_memory_t
Definition: legion_c.h:331
legion_phase_barrier_t
Definition: legion_c.h:348
legion_processor_t
Definition: legion_c.h:324
legion_ptr_t
Definition: legion_c.h:122
legion_slice_task_input_t
Definition: legion_c.h:382
legion_task_config_options_t
Definition: legion_c.h:314
legion_task_options_t
Definition: legion_c.h:371
legion_task_slice_t
Definition: legion_c.h:338
legion_untyped_buffer_t
Definition: legion_c.h:291
Generated on Fri Mar 15 2024 18:08:35 for Legion Runtime by doxygen 1.9.1