Legion Runtime
 All Classes Namespaces Files Functions Variables Typedefs Macros Pages
legion_c.h
Go to the documentation of this file.
1 /* Copyright 2023 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_acquire_launcher_t);
80  NEW_OPAQUE_TYPE(legion_release_launcher_t);
81  NEW_OPAQUE_TYPE(legion_attach_launcher_t);
82  NEW_OPAQUE_TYPE(legion_index_attach_launcher_t);
83  NEW_OPAQUE_TYPE(legion_must_epoch_launcher_t);
84  NEW_OPAQUE_TYPE(legion_physical_region_t);
85  NEW_OPAQUE_TYPE(legion_external_resources_t);
86 #define NEW_ACCESSOR_ARRAY_TYPE(DIM) \
87  NEW_OPAQUE_TYPE(legion_accessor_array_##DIM##d_t);
88  LEGION_FOREACH_N(NEW_ACCESSOR_ARRAY_TYPE)
89 #undef NEW_ACCESSOR_ARRAY_TYPE
90  NEW_OPAQUE_TYPE(legion_task_t);
91  NEW_OPAQUE_TYPE(legion_task_mut_t);
92  NEW_OPAQUE_TYPE(legion_copy_t);
93  NEW_OPAQUE_TYPE(legion_fill_t);
94  NEW_OPAQUE_TYPE(legion_inline_t);
95  NEW_OPAQUE_TYPE(legion_mappable_t);
96  NEW_OPAQUE_TYPE(legion_region_requirement_t);
97  NEW_OPAQUE_TYPE(legion_machine_t);
98  NEW_OPAQUE_TYPE(legion_mapper_t);
99  NEW_OPAQUE_TYPE(legion_default_mapper_t);
100  NEW_OPAQUE_TYPE(legion_processor_query_t);
101  NEW_OPAQUE_TYPE(legion_memory_query_t);
102  NEW_OPAQUE_TYPE(legion_machine_query_interface_t);
103  NEW_OPAQUE_TYPE(legion_execution_constraint_set_t);
104  NEW_OPAQUE_TYPE(legion_layout_constraint_set_t);
105  NEW_OPAQUE_TYPE(legion_task_layout_constraint_set_t);
106  NEW_OPAQUE_TYPE(legion_slice_task_output_t);
107  NEW_OPAQUE_TYPE(legion_map_task_input_t);
108  NEW_OPAQUE_TYPE(legion_map_task_output_t);
109  NEW_OPAQUE_TYPE(legion_physical_instance_t);
110  NEW_OPAQUE_TYPE(legion_mapper_runtime_t);
111  NEW_OPAQUE_TYPE(legion_mapper_context_t);
112  NEW_OPAQUE_TYPE(legion_field_map_t);
113 #undef NEW_OPAQUE_TYPE
114 
118  typedef struct legion_ptr_t {
119  long long int value;
120  } legion_ptr_t;
121 
122  typedef legion_coord_t coord_t;
123 
124 #define NEW_POINT_TYPE(DIM) typedef struct legion_point_##DIM##d_t { coord_t x[DIM]; } legion_point_##DIM##d_t;
125  LEGION_FOREACH_N(NEW_POINT_TYPE)
126 #undef NEW_POINT_TYPE
127 
128 #define NEW_RECT_TYPE(DIM) typedef struct legion_rect_##DIM##d_t { legion_point_##DIM##d_t lo, hi; } legion_rect_##DIM##d_t;
129  LEGION_FOREACH_N(NEW_RECT_TYPE)
130 #undef NEW_RECT_TYPE
131 
132 #define NEW_BLOCKIFY_TYPE(DIM) \
133  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;
134  LEGION_FOREACH_N(NEW_BLOCKIFY_TYPE)
135 #undef NEW_BLOCKIFY_TYPE
136 
137 #define NEW_TRANSFORM_TYPE(D1,D2) \
138  typedef struct legion_transform_##D1##x##D2##_t { coord_t trans[D1][D2]; } legion_transform_##D1##x##D2##_t;
139  LEGION_FOREACH_NN(NEW_TRANSFORM_TYPE)
140 #undef NEW_TRANSFORM_TYPE
141 
142 #define NEW_AFFINE_TRANSFORM_TYPE(D1,D2) \
143  typedef struct legion_affine_transform_##D1##x##D2##_t { \
144  legion_transform_##D1##x##D2##_t transform; legion_point_##D1##d_t offset; } \
145  legion_affine_transform_##D1##x##D2##_t;
146  LEGION_FOREACH_NN(NEW_AFFINE_TRANSFORM_TYPE)
147 #undef NEW_AFFINE_TRANSFORM_TYPE
148 
152  typedef struct legion_domain_t {
153  realm_id_t is_id;
154  legion_type_tag_t is_type;
155  int dim;
156 // Hack: Python CFFI isn't smart enough to do constant folding so we
157 // have to do this by hand here. To avoid this bitrotting, at least
158 // make the preprocessor check that the value is equal to what we
159 // expect.
160 #if LEGION_MAX_DIM == 1
161 #define MAX_DOMAIN_DIM 2 // 2 * LEGION_MAX_RECT_DIM
162 #elif LEGION_MAX_DIM == 2
163 #define MAX_DOMAIN_DIM 4 // 2 * LEGION_MAX_RECT_DIM
164 #elif LEGION_MAX_DIM == 3
165 #define MAX_DOMAIN_DIM 6 // 2 * LEGION_MAX_RECT_DIM
166 #elif LEGION_MAX_DIM == 4
167 #define MAX_DOMAIN_DIM 8 // 2 * LEGION_MAX_RECT_DIM
168 #elif LEGION_MAX_DIM == 5
169 #define MAX_DOMAIN_DIM 10 // 2 * LEGION_MAX_RECT_DIM
170 #elif LEGION_MAX_DIM == 6
171 #define MAX_DOMAIN_DIM 12 // 2 * LEGION_MAX_RECT_DIM
172 #elif LEGION_MAX_DIM == 7
173 #define MAX_DOMAIN_DIM 14 // 2 * LEGION_MAX_RECT_DIM
174 #elif LEGION_MAX_DIM == 8
175 #define MAX_DOMAIN_DIM 16 // 2 * LEGION_MAX_RECT_DIM
176 #elif LEGION_MAX_DIM == 9
177 #define MAX_DOMAIN_DIM 18 // 2 * LEGION_MAX_RECT_DIM
178 #else
179 #error "Illegal value of LEGION_MAX_DIM"
180 #endif
181 #if MAX_DOMAIN_DIM != 2 * LEGION_MAX_RECT_DIM // sanity check value
182 #error Mismatch in MAX_DOMAIN_DIM
183 #endif
184  coord_t rect_data[MAX_DOMAIN_DIM];
185 #undef MAX_DOMAIN_DIM
186  } legion_domain_t;
187 
191  typedef struct legion_domain_point_t {
192  int dim;
193  coord_t point_data[LEGION_MAX_DIM];
194  } legion_domain_point_t;
195 
199  typedef struct legion_domain_transform_t {
200  int m, n;
201 // Hack: Python CFFI isn't smart enough to do constant folding so we
202 // have to do this by hand here. To avoid this bitrotting, at least
203 // make the preprocessor check that the value is equal to what we
204 // expect.
205 #if LEGION_MAX_DIM == 1
206 #define MAX_MATRIX_DIM 1
207 #elif LEGION_MAX_DIM == 2
208 #define MAX_MATRIX_DIM 4
209 #elif LEGION_MAX_DIM == 3
210 #define MAX_MATRIX_DIM 9
211 #elif LEGION_MAX_DIM == 4
212 #define MAX_MATRIX_DIM 16
213 #elif LEGION_MAX_DIM == 5
214 #define MAX_MATRIX_DIM 25
215 #elif LEGION_MAX_DIM == 6
216 #define MAX_MATRIX_DIM 36
217 #elif LEGION_MAX_DIM == 7
218 #define MAX_MATRIX_DIM 49
219 #elif LEGION_MAX_DIM == 8
220 #define MAX_MATRIX_DIM 64
221 #elif LEGION_MAX_DIM == 9
222 #define MAX_MATRIX_DIM 81
223 #else
224 #error "Illegal value of LEGION_MAX_DIM"
225 #endif
226 #if MAX_MATRIX_DIM != LEGION_MAX_POINT_DIM * LEGION_MAX_POINT_DIM // sanity check
227 #error Mismatch in MAX_MATRIX_DIM
228 #endif
229  coord_t matrix[MAX_MATRIX_DIM];
230 #undef MAX_MATRIX_DIM
231  } legion_domain_transform_t;
232 
236  typedef struct legion_domain_affine_transform_t {
237  legion_domain_transform_t transform;
238  legion_domain_point_t offset;
239  } legion_domain_affine_transform_t;
240 
244  typedef struct legion_index_space_t {
245  legion_index_space_id_t id;
246  legion_index_tree_id_t tid;
247  legion_type_tag_t type_tag;
248  } legion_index_space_t;
249 
253  typedef struct legion_index_partition_t {
254  legion_index_partition_id_t id;
255  legion_index_tree_id_t tid;
256  legion_type_tag_t type_tag;
257  } legion_index_partition_t;
258 
262  typedef struct legion_field_space_t {
263  legion_field_space_id_t id;
264  } legion_field_space_t;
265 
269  typedef struct legion_logical_region_t {
270  legion_region_tree_id_t tree_id;
271  legion_index_space_t index_space;
272  legion_field_space_t field_space;
273  } legion_logical_region_t;
274 
278  typedef struct legion_logical_partition_t {
279  legion_region_tree_id_t tree_id;
280  legion_index_partition_t index_partition;
281  legion_field_space_t field_space;
282  } legion_logical_partition_t;
283 
287  typedef struct legion_untyped_buffer_t {
288  void *args;
289  size_t arglen;
290  } legion_untyped_buffer_t;
291  // This is for backwards compatibility when we used
292  // to call legion_untyped_buffer_t as legion_task_argument_t
293  typedef legion_untyped_buffer_t legion_task_argument_t;
294 
295  typedef struct legion_byte_offset_t {
296  int offset;
297  } legion_byte_offset_t;
298 
302  typedef struct legion_input_args_t {
303  char **argv;
304  int argc;
305  } legion_input_args_t;
306 
310  typedef struct legion_task_config_options_t {
311  bool leaf /* = false */;
312  bool inner /* = false */;
313  bool idempotent /* = false */;
314  bool replicable /* = false */;
315  } legion_task_config_options_t;
316 
320  typedef struct legion_processor_t {
321  realm_id_t id;
322  } legion_processor_t;
323 
327  typedef struct legion_memory_t {
328  realm_id_t id;
329  } legion_memory_t;
330 
334  typedef struct legion_task_slice_t {
335  legion_domain_t domain;
336  legion_processor_t proc;
337  bool recurse;
338  bool stealable;
339  } legion_task_slice_t;
340 
344  typedef struct legion_phase_barrier_t {
345  // From Realm::Event
346  realm_id_t id;
347  // From Realm::Barrier
348  realm_barrier_timestamp_t timestamp;
349  } legion_phase_barrier_t;
350 
354  typedef struct legion_dynamic_collective_t {
355  // From Legion::PhaseBarrier
356  // From Realm::Event
357  realm_id_t id;
358  // From Realm::Barrier
359  realm_barrier_timestamp_t timestamp;
360  // From Legion::DynamicCollective
361  legion_reduction_op_id_t redop;
362  } legion_dynamic_collective_t;
363 
367  typedef struct legion_task_options_t {
368  legion_processor_t initial_proc;
369  bool inline_task;
370  bool stealable;
371  bool map_locally;
372  bool valid_instances;
373  bool memoize;
374  bool replicate;
375  legion_task_priority_t parent_priority;
376  } legion_task_options_t;
377 
378  typedef struct legion_slice_task_input_t {
379  legion_domain_t domain;
380  } legion_slice_task_input_t;
381 
385  typedef
386  void (*legion_registration_callback_pointer_t)(
387  legion_machine_t /* machine */,
388  legion_runtime_t /* runtime */,
389  const legion_processor_t * /* local_procs */,
390  unsigned /* num_local_procs */);
391 
396  typedef realm_task_pointer_t legion_task_pointer_wrapped_t;
397 
402  typedef
403  legion_logical_region_t (*legion_projection_functor_logical_region_t)(
404  legion_runtime_t /* runtime */,
405  legion_logical_region_t /* upper_bound */,
406  legion_domain_point_t /* point */,
407  legion_domain_t /* launch domain */);
408 
413  typedef
414  legion_logical_region_t (*legion_projection_functor_logical_partition_t)(
415  legion_runtime_t /* runtime */,
416  legion_logical_partition_t /* upper_bound */,
417  legion_domain_point_t /* point */,
418  legion_domain_t /* launch domain */);
419 
424  typedef
425  legion_logical_region_t (*legion_projection_functor_logical_region_mappable_t)(
426  legion_runtime_t /* runtime */,
427  legion_mappable_t /* mappable */,
428  unsigned /* index */,
429  legion_logical_region_t /* upper_bound */,
430  legion_domain_point_t /* point */);
431 
436  typedef
437  legion_logical_region_t (*legion_projection_functor_logical_partition_mappable_t)(
438  legion_runtime_t /* runtime */,
439  legion_mappable_t /* mappable */,
440  unsigned /* index */,
441  legion_logical_partition_t /* upper_bound */,
442  legion_domain_point_t /* point */);
443 
444  // -----------------------------------------------------------------------
445  // Pointer Operations
446  // -----------------------------------------------------------------------
447 
451  legion_ptr_t
452  legion_ptr_nil(void);
453 
457  bool
458  legion_ptr_is_null(legion_ptr_t ptr);
459 
464  legion_ptr_t
465  legion_ptr_safe_cast(legion_runtime_t runtime,
466  legion_context_t ctx,
467  legion_ptr_t pointer,
468  legion_logical_region_t region);
469 
470  // -----------------------------------------------------------------------
471  // Domain Operations
472  // -----------------------------------------------------------------------
473 
477  legion_domain_t
478  legion_domain_empty(unsigned dim);
479 
483 #define FROM_RECT(DIM) \
484  legion_domain_t \
485  legion_domain_from_rect_##DIM##d(legion_rect_##DIM##d_t r);
486  LEGION_FOREACH_N(FROM_RECT)
487 #undef FROM_RECT
488 
492  legion_domain_t
493  legion_domain_from_index_space(legion_runtime_t runtime,
494  legion_index_space_t is);
495 
499 #define GET_RECT(DIM) \
500  legion_rect_##DIM##d_t \
501  legion_domain_get_rect_##DIM##d(legion_domain_t d);
502  LEGION_FOREACH_N(GET_RECT)
503 #undef GET_RECT
504 
505  bool
506  legion_domain_is_dense(legion_domain_t d);
507 
508  // These are the same as above but will ignore
509  // the existence of any sparsity map, whereas the
510  // ones above will fail if a sparsity map exists
511 #define GET_BOUNDS(DIM) \
512  legion_rect_##DIM##d_t \
513  legion_domain_get_bounds_##DIM##d(legion_domain_t d);
514  LEGION_FOREACH_N(GET_BOUNDS)
515 #undef GET_BOUNDS
516 
520  bool
521  legion_domain_contains(legion_domain_t d, legion_domain_point_t p);
522 
526  size_t
527  legion_domain_get_volume(legion_domain_t d);
528 
529  // -----------------------------------------------------------------------
530  // Domain Transform Operations
531  // -----------------------------------------------------------------------
532 
533  legion_domain_transform_t
534  legion_domain_transform_identity(unsigned m, unsigned n);
535 
536 #define FROM_TRANSFORM(D1,D2) \
537  legion_domain_transform_t \
538  legion_domain_transform_from_##D1##x##D2(legion_transform_##D1##x##D2##_t t);
539  LEGION_FOREACH_NN(FROM_TRANSFORM)
540 #undef FROM_TRANSFORM
541 
542  legion_domain_affine_transform_t
543  legion_domain_affine_transform_identity(unsigned m, unsigned n);
544 
545 #define FROM_AFFINE(D1,D2) \
546  legion_domain_affine_transform_t \
547  legion_domain_affine_transform_from_##D1##x##D2(legion_affine_transform_##D1##x##D2##_t t);
548  LEGION_FOREACH_NN(FROM_AFFINE)
549 #undef FROM_AFFINE
550 
551  // -----------------------------------------------------------------------
552  // Domain Point Operations
553  // -----------------------------------------------------------------------
554 
558 #define FROM_POINT(DIM) \
559  legion_domain_point_t \
560  legion_domain_point_from_point_##DIM##d(legion_point_##DIM##d_t p);
561  LEGION_FOREACH_N(FROM_POINT)
562 #undef FROM_POINT
563 
567 #define GET_POINT(DIM) \
568  legion_point_##DIM##d_t \
569  legion_domain_point_get_point_##DIM##d(legion_domain_point_t p);
570  LEGION_FOREACH_N(GET_POINT)
571 #undef GET_POINT
572 
573  legion_domain_point_t
574  legion_domain_point_origin(unsigned dim);
575 
579  legion_domain_point_t
580  legion_domain_point_nil(void);
581 
585  bool
586  legion_domain_point_is_null(legion_domain_point_t point);
587 
592  legion_domain_point_t
593  legion_domain_point_safe_cast(legion_runtime_t runtime,
594  legion_context_t ctx,
595  legion_domain_point_t point,
596  legion_logical_region_t region);
597 
598  // -----------------------------------------------------------------------
599  // Domain Point Iterator
600  // -----------------------------------------------------------------------
601 
607  legion_domain_point_iterator_t
608  legion_domain_point_iterator_create(legion_domain_t handle);
609 
615  void
616  legion_domain_point_iterator_destroy(legion_domain_point_iterator_t handle);
617 
621  bool
622  legion_domain_point_iterator_has_next(legion_domain_point_iterator_t handle);
623 
627  legion_domain_point_t
628  legion_domain_point_iterator_next(legion_domain_point_iterator_t handle);
629 
630  // -----------------------------------------------------------------------
631  // Rect in Domain Iterator
632  // -----------------------------------------------------------------------
633 
639 #define ITERATOR_CREATE(DIM) \
640  legion_rect_in_domain_iterator_##DIM##d_t \
641  legion_rect_in_domain_iterator_create_##DIM##d(legion_domain_t handle);
642  LEGION_FOREACH_N(ITERATOR_CREATE)
643 #undef ITERATOR_CREATE
644 
650 #define ITERATOR_DESTROY(DIM) \
651  void legion_rect_in_domain_iterator_destroy_##DIM##d( \
652  legion_rect_in_domain_iterator_##DIM##d_t handle);
653  LEGION_FOREACH_N(ITERATOR_DESTROY)
654 #undef ITERATOR_DESTROY
655 
659 #define ITERATOR_VALID(DIM) \
660  bool legion_rect_in_domain_iterator_valid_##DIM##d( \
661  legion_rect_in_domain_iterator_##DIM##d_t handle);
662  LEGION_FOREACH_N(ITERATOR_VALID)
663 #undef ITERATOR_VALID
664 
668 #define ITERATOR_STEP(DIM) \
669  bool legion_rect_in_domain_iterator_step_##DIM##d( \
670  legion_rect_in_domain_iterator_##DIM##d_t handle);
671  LEGION_FOREACH_N(ITERATOR_STEP)
672 #undef ITERATOR_STEP
673 
677 #define ITERATOR_OP(DIM) \
678  legion_rect_##DIM##d_t \
679  legion_rect_in_domain_iterator_get_rect_##DIM##d( \
680  legion_rect_in_domain_iterator_##DIM##d_t handle);
681  LEGION_FOREACH_N(ITERATOR_OP)
682 #undef ITERATOR_OP
683 
684  // -----------------------------------------------------------------------
685  // Coloring Operations
686  // -----------------------------------------------------------------------
687 
693  legion_coloring_t
694  legion_coloring_create(void);
695 
701  void
702  legion_coloring_destroy(legion_coloring_t handle);
703 
707  void
708  legion_coloring_ensure_color(legion_coloring_t handle,
709  legion_color_t color);
710 
714  void
715  legion_coloring_add_point(legion_coloring_t handle,
716  legion_color_t color,
717  legion_ptr_t point);
718 
722  void
723  legion_coloring_delete_point(legion_coloring_t handle,
724  legion_color_t color,
725  legion_ptr_t point);
726 
730  bool
731  legion_coloring_has_point(legion_coloring_t handle,
732  legion_color_t color,
733  legion_ptr_t point);
734 
738  void
739  legion_coloring_add_range(legion_coloring_t handle,
740  legion_color_t color,
741  legion_ptr_t start,
742  legion_ptr_t end );
743 
744  // -----------------------------------------------------------------------
745  // Domain Coloring Operations
746  // -----------------------------------------------------------------------
747 
753  legion_domain_coloring_t
754  legion_domain_coloring_create(void);
755 
761  void
762  legion_domain_coloring_destroy(legion_domain_coloring_t handle);
763 
767  void
768  legion_domain_coloring_color_domain(legion_domain_coloring_t handle,
769  legion_color_t color,
770  legion_domain_t domain);
771 
775  legion_domain_t
776  legion_domain_coloring_get_color_space(legion_domain_coloring_t handle);
777 
778  // -----------------------------------------------------------------------
779  // Point Coloring Operations
780  // -----------------------------------------------------------------------
781 
787  legion_point_coloring_t
788  legion_point_coloring_create(void);
789 
795  void
796  legion_point_coloring_destroy(
797  legion_point_coloring_t handle);
798 
802  void
803  legion_point_coloring_add_point(legion_point_coloring_t handle,
804  legion_domain_point_t color,
805  legion_ptr_t point);
806 
810  void
811  legion_point_coloring_add_range(legion_point_coloring_t handle,
812  legion_domain_point_t color,
813  legion_ptr_t start,
814  legion_ptr_t end );
815 
816  // -----------------------------------------------------------------------
817  // Domain Point Coloring Operations
818  // -----------------------------------------------------------------------
819 
825  legion_domain_point_coloring_t
826  legion_domain_point_coloring_create(void);
827 
833  void
834  legion_domain_point_coloring_destroy(
835  legion_domain_point_coloring_t handle);
836 
840  void
841  legion_domain_point_coloring_color_domain(
842  legion_domain_point_coloring_t handle,
843  legion_domain_point_t color,
844  legion_domain_t domain);
845 
846  // -----------------------------------------------------------------------
847  // Multi-Domain Point Coloring Operations
848  // -----------------------------------------------------------------------
849 
855  legion_multi_domain_point_coloring_t
856  legion_multi_domain_point_coloring_create(void);
857 
863  void
864  legion_multi_domain_point_coloring_destroy(
865  legion_multi_domain_point_coloring_t handle);
866 
870  void
871  legion_multi_domain_point_coloring_color_domain(
872  legion_multi_domain_point_coloring_t handle,
873  legion_domain_point_t color,
874  legion_domain_t domain);
875 
876  // -----------------------------------------------------------------------
877  // Index Space Operations
878  // ----------------------------------------------------------------------
879 
885  legion_index_space_t
886  legion_index_space_create(legion_runtime_t runtime,
887  legion_context_t ctx,
888  size_t max_num_elmts);
889 
895  legion_index_space_t
896  legion_index_space_create_domain(legion_runtime_t runtime,
897  legion_context_t ctx,
898  legion_domain_t domain);
899 
905  legion_index_space_t
906  legion_index_space_create_future(legion_runtime_t runtime,
907  legion_context_t ctx,
908  size_t dimensions,
909  legion_future_t future,
910  legion_type_tag_t type_tag/*=0*/);
911 
917  legion_index_space_t
918  legion_index_space_union(legion_runtime_t runtime,
919  legion_context_t ctx,
920  const legion_index_space_t *spaces,
921  size_t num_spaces);
922 
928  legion_index_space_t
929  legion_index_space_intersection(legion_runtime_t runtime,
930  legion_context_t ctx,
931  const legion_index_space_t *spaces,
932  size_t num_spaces);
933 
939  legion_index_space_t
940  legion_index_space_subtraction(legion_runtime_t runtime,
941  legion_context_t ctx,
942  legion_index_space_t left,
943  legion_index_space_t right);
944 
948  bool
949  legion_index_space_has_multiple_domains(legion_runtime_t runtime,
950  legion_index_space_t handle);
951 
957  legion_domain_t
958  legion_index_space_get_domain(legion_runtime_t runtime,
959  legion_index_space_t handle);
960 
966  bool
967  legion_index_space_has_parent_index_partition(legion_runtime_t runtime,
968  legion_index_space_t handle);
974  legion_index_partition_t
975  legion_index_space_get_parent_index_partition(legion_runtime_t runtime,
976  legion_index_space_t handle);
977 
983  void
984  legion_index_space_create_shared_ownership(legion_runtime_t runtime,
985  legion_context_t ctx,
986  legion_index_space_t handle);
987 
993  void
994  legion_index_space_destroy(legion_runtime_t runtime,
995  legion_context_t ctx,
996  legion_index_space_t handle);
997 
1003  void
1004  legion_index_space_destroy_unordered(legion_runtime_t runtime,
1005  legion_context_t ctx,
1006  legion_index_space_t handle,
1007  bool unordered);
1008 
1012  void
1013  legion_index_space_attach_semantic_information(legion_runtime_t runtime,
1014  legion_index_space_t handle,
1015  legion_semantic_tag_t tag,
1016  const void *buffer,
1017  size_t size,
1018  bool is_mutable /* = false */);
1019 
1023  bool
1024  legion_index_space_retrieve_semantic_information(
1025  legion_runtime_t runtime,
1026  legion_index_space_t handle,
1027  legion_semantic_tag_t tag,
1028  const void **result,
1029  size_t *size,
1030  bool can_fail /* = false */,
1031  bool wait_until_ready /* = false */);
1032 
1036  void
1037  legion_index_space_attach_name(legion_runtime_t runtime,
1038  legion_index_space_t handle,
1039  const char *name,
1040  bool is_mutable /* = false */);
1041 
1045  void
1046  legion_index_space_retrieve_name(legion_runtime_t runtime,
1047  legion_index_space_t handle,
1048  const char **result);
1049 
1055  int
1056  legion_index_space_get_dim(legion_index_space_t handle);
1057 
1058  // -----------------------------------------------------------------------
1059  // Index Partition Operations
1060  // -----------------------------------------------------------------------
1061 
1068  legion_index_partition_t
1069  legion_index_partition_create_coloring(
1070  legion_runtime_t runtime,
1071  legion_context_t ctx,
1072  legion_index_space_t parent,
1073  legion_coloring_t coloring,
1074  bool disjoint,
1075  legion_color_t part_color /* = AUTO_GENERATE_ID */);
1076 
1083  legion_index_partition_t
1084  legion_index_partition_create_domain_coloring(
1085  legion_runtime_t runtime,
1086  legion_context_t ctx,
1087  legion_index_space_t parent,
1088  legion_domain_t color_space,
1089  legion_domain_coloring_t coloring,
1090  bool disjoint,
1091  legion_color_t part_color /* = AUTO_GENERATE_ID */);
1092 
1099  legion_index_partition_t
1100  legion_index_partition_create_point_coloring(
1101  legion_runtime_t runtime,
1102  legion_context_t ctx,
1103  legion_index_space_t parent,
1104  legion_domain_t color_space,
1105  legion_point_coloring_t coloring,
1106  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1107  legion_color_t color /* = AUTO_GENERATE_ID */);
1108 
1115  legion_index_partition_t
1116  legion_index_partition_create_domain_point_coloring(
1117  legion_runtime_t runtime,
1118  legion_context_t ctx,
1119  legion_index_space_t parent,
1120  legion_domain_t color_space,
1121  legion_domain_point_coloring_t coloring,
1122  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1123  legion_color_t color /* = AUTO_GENERATE_ID */);
1124 
1131  legion_index_partition_t
1132  legion_index_partition_create_multi_domain_point_coloring(
1133  legion_runtime_t runtime,
1134  legion_context_t ctx,
1135  legion_index_space_t parent,
1136  legion_domain_t color_space,
1137  legion_multi_domain_point_coloring_t coloring,
1138  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1139  legion_color_t color /* = AUTO_GENERATE_ID */);
1140 
1147 #define CREATE_BLOCKIFY(DIM) \
1148  legion_index_partition_t \
1149  legion_index_partition_create_blockify_##DIM##d( \
1150  legion_runtime_t runtime, \
1151  legion_context_t ctx, \
1152  legion_index_space_t parent, \
1153  legion_blockify_##DIM##d_t blockify, \
1154  legion_color_t part_color /* = AUTO_GENERATE_ID */);
1155  LEGION_FOREACH_N(CREATE_BLOCKIFY)
1156 #undef CREATE_BLOCKIFY
1157 
1163  legion_index_partition_t
1164  legion_index_partition_create_equal(legion_runtime_t runtime,
1165  legion_context_t ctx,
1166  legion_index_space_t parent,
1167  legion_index_space_t color_space,
1168  size_t granularity,
1169  legion_color_t color /* = AUTO_GENERATE_ID */);
1170 
1176  legion_index_partition_t
1177  legion_index_partition_create_by_weights(
1178  legion_runtime_t runtime,
1179  legion_context_t ctx,
1180  legion_index_space_t parent,
1181  legion_domain_point_t *colors,
1182  int *weights,
1183  size_t num_colors,
1184  legion_index_space_t color_space,
1185  size_t granularity /* = 1 */,
1186  legion_color_t color /* = AUTO_GENERATE_ID */);
1187 
1193  legion_index_partition_t
1194  legion_index_partition_create_by_weights_future_map(
1195  legion_runtime_t runtime,
1196  legion_context_t ctx,
1197  legion_index_space_t parent,
1198  legion_future_map_t future_map,
1199  legion_index_space_t color_space,
1200  size_t granularity /* = 1 */,
1201  legion_color_t color /* = AUTO_GENERATE_ID */);
1202 
1208  legion_index_partition_t
1209  legion_index_partition_create_by_union(
1210  legion_runtime_t runtime,
1211  legion_context_t ctx,
1212  legion_index_space_t parent,
1213  legion_index_partition_t handle1,
1214  legion_index_partition_t handle2,
1215  legion_index_space_t color_space,
1216  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1217  legion_color_t color /* = AUTO_GENERATE_ID */);
1218 
1224  legion_index_partition_t
1225  legion_index_partition_create_by_intersection(
1226  legion_runtime_t runtime,
1227  legion_context_t ctx,
1228  legion_index_space_t parent,
1229  legion_index_partition_t handle1,
1230  legion_index_partition_t handle2,
1231  legion_index_space_t color_space,
1232  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1233  legion_color_t color /* = AUTO_GENERATE_ID */);
1234 
1240  legion_index_partition_t
1241  legion_index_partition_create_by_intersection_mirror(
1242  legion_runtime_t runtime,
1243  legion_context_t ctx,
1244  legion_index_space_t parent,
1245  legion_index_partition_t handle,
1246  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1247  legion_color_t color /* = AUTO_GENERATE_ID */,
1248  bool dominates /* = false */);
1249 
1255  legion_index_partition_t
1256  legion_index_partition_create_by_difference(
1257  legion_runtime_t runtime,
1258  legion_context_t ctx,
1259  legion_index_space_t parent,
1260  legion_index_partition_t handle1,
1261  legion_index_partition_t handle2,
1262  legion_index_space_t color_space,
1263  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1264  legion_color_t color /* = AUTO_GENERATE_ID */);
1265 
1271  legion_index_partition_t
1272  legion_index_partition_create_by_domain(
1273  legion_runtime_t runtime,
1274  legion_context_t ctx,
1275  legion_index_space_t parent,
1276  legion_domain_point_t *colors,
1277  legion_domain_t *domains,
1278  size_t num_color_domains,
1279  legion_index_space_t color_space,
1280  bool perform_intersections /* = true */,
1281  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1282  legion_color_t color /* = AUTO_GENERATE_ID */);
1283 
1289  legion_index_partition_t
1290  legion_index_partition_create_by_domain_future_map(
1291  legion_runtime_t runtime,
1292  legion_context_t ctx,
1293  legion_index_space_t parent,
1294  legion_future_map_t future_map,
1295  legion_index_space_t color_space,
1296  bool perform_intersections /* = true */,
1297  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1298  legion_color_t color /* = AUTO_GENERATE_ID */);
1299 
1305  legion_index_partition_t
1306  legion_index_partition_create_by_field(legion_runtime_t runtime,
1307  legion_context_t ctx,
1308  legion_logical_region_t handle,
1309  legion_logical_region_t parent,
1310  legion_field_id_t fid,
1311  legion_index_space_t color_space,
1312  legion_color_t color /* = AUTO_GENERATE_ID */,
1313  legion_mapper_id_t id /* = 0 */,
1314  legion_mapping_tag_id_t tag /* = 0 */,
1315  legion_partition_kind_t part_kind /* = DISJOINT_KIND */,
1316  legion_untyped_buffer_t map_arg);
1317 
1323  legion_index_partition_t
1324  legion_index_partition_create_by_image(
1325  legion_runtime_t runtime,
1326  legion_context_t ctx,
1327  legion_index_space_t handle,
1328  legion_logical_partition_t projection,
1329  legion_logical_region_t parent,
1330  legion_field_id_t fid,
1331  legion_index_space_t color_space,
1332  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1333  legion_color_t color /* = AUTO_GENERATE_ID */,
1334  legion_mapper_id_t id /* = 0 */,
1335  legion_mapping_tag_id_t tag /* = 0 */,
1336  legion_untyped_buffer_t map_arg);
1337 
1343  legion_index_partition_t
1344  legion_index_partition_create_by_preimage(
1345  legion_runtime_t runtime,
1346  legion_context_t ctx,
1347  legion_index_partition_t projection,
1348  legion_logical_region_t handle,
1349  legion_logical_region_t parent,
1350  legion_field_id_t fid,
1351  legion_index_space_t color_space,
1352  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1353  legion_color_t color /* = AUTO_GENERATE_ID */,
1354  legion_mapper_id_t id /* = 0 */,
1355  legion_mapping_tag_id_t tag /* = 0 */,
1356  legion_untyped_buffer_t map_arg);
1357 
1363  legion_index_partition_t
1364  legion_index_partition_create_by_image_range(
1365  legion_runtime_t runtime,
1366  legion_context_t ctx,
1367  legion_index_space_t handle,
1368  legion_logical_partition_t projection,
1369  legion_logical_region_t parent,
1370  legion_field_id_t fid,
1371  legion_index_space_t color_space,
1372  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1373  legion_color_t color /* = AUTO_GENERATE_ID */,
1374  legion_mapper_id_t id /* = 0 */,
1375  legion_mapping_tag_id_t tag /* = 0 */,
1376  legion_untyped_buffer_t map_arg);
1377 
1383  legion_index_partition_t
1384  legion_index_partition_create_by_preimage_range(
1385  legion_runtime_t runtime,
1386  legion_context_t ctx,
1387  legion_index_partition_t projection,
1388  legion_logical_region_t handle,
1389  legion_logical_region_t parent,
1390  legion_field_id_t fid,
1391  legion_index_space_t color_space,
1392  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1393  legion_color_t color /* = AUTO_GENERATE_ID */,
1394  legion_mapper_id_t id /* = 0 */,
1395  legion_mapping_tag_id_t tag /* = 0 */,
1396  legion_untyped_buffer_t map_arg);
1397 
1403  legion_index_partition_t
1404  legion_index_partition_create_by_restriction(
1405  legion_runtime_t runtime,
1406  legion_context_t ctx,
1407  legion_index_space_t parent,
1408  legion_index_space_t color_space,
1409  legion_domain_transform_t transform,
1410  legion_domain_t extent,
1411  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1412  legion_color_t color /* = AUTO_GENERATE_ID */);
1413 
1419  legion_index_partition_t
1420  legion_index_partition_create_pending_partition(
1421  legion_runtime_t runtime,
1422  legion_context_t ctx,
1423  legion_index_space_t parent,
1424  legion_index_space_t color_space,
1425  legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
1426  legion_color_t color /* = AUTO_GENERATE_ID */);
1427 
1431  legion_index_space_t
1432  legion_index_partition_create_index_space_union_spaces(
1433  legion_runtime_t runtime,
1434  legion_context_t ctx,
1435  legion_index_partition_t parent,
1436  legion_domain_point_t color,
1437  const legion_index_space_t *spaces,
1438  size_t num_spaces);
1439 
1443  legion_index_space_t
1444  legion_index_partition_create_index_space_union_partition(
1445  legion_runtime_t runtime,
1446  legion_context_t ctx,
1447  legion_index_partition_t parent,
1448  legion_domain_point_t color,
1449  legion_index_partition_t handle);
1450 
1454  legion_index_space_t
1455  legion_index_partition_create_index_space_intersection_spaces(
1456  legion_runtime_t runtime,
1457  legion_context_t ctx,
1458  legion_index_partition_t parent,
1459  legion_domain_point_t color,
1460  const legion_index_space_t *spaces,
1461  size_t num_spaces);
1462 
1466  legion_index_space_t
1467  legion_index_partition_create_index_space_intersection_partition(
1468  legion_runtime_t runtime,
1469  legion_context_t ctx,
1470  legion_index_partition_t parent,
1471  legion_domain_point_t color,
1472  legion_index_partition_t handle);
1473 
1477  legion_index_space_t
1478  legion_index_partition_create_index_space_difference(
1479  legion_runtime_t runtime,
1480  legion_context_t ctx,
1481  legion_index_partition_t parent,
1482  legion_domain_point_t color,
1483  legion_index_space_t initial,
1484  const legion_index_space_t *spaces,
1485  size_t num_spaces);
1486 
1490  bool
1491  legion_index_partition_is_disjoint(legion_runtime_t runtime,
1492  legion_index_partition_t handle);
1493 
1497  bool
1498  legion_index_partition_is_complete(legion_runtime_t runtime,
1499  legion_index_partition_t handle);
1500 
1506  legion_index_space_t
1507  legion_index_partition_get_index_subspace(legion_runtime_t runtime,
1508  legion_index_partition_t handle,
1509  legion_color_t color);
1510 
1516  legion_index_space_t
1517  legion_index_partition_get_index_subspace_domain_point(
1518  legion_runtime_t runtime,
1519  legion_index_partition_t handle,
1520  legion_domain_point_t color);
1521 
1525  bool
1526  legion_index_partition_has_index_subspace_domain_point(
1527  legion_runtime_t runtime,
1528  legion_index_partition_t handle,
1529  legion_domain_point_t color);
1530 
1534  legion_index_space_t
1535  legion_index_partition_get_color_space(legion_runtime_t runtime,
1536  legion_index_partition_t handle);
1537 
1541  legion_color_t
1542  legion_index_partition_get_color(legion_runtime_t runtime,
1543  legion_index_partition_t handle);
1544 
1550  legion_index_space_t
1551  legion_index_partition_get_parent_index_space(legion_runtime_t runtime,
1552  legion_index_partition_t handle);
1553 
1559  void
1560  legion_index_partition_create_shared_ownership(legion_runtime_t runtime,
1561  legion_context_t ctx,
1562  legion_index_partition_t handle);
1563 
1569  void
1570  legion_index_partition_destroy(legion_runtime_t runtime,
1571  legion_context_t ctx,
1572  legion_index_partition_t handle);
1573 
1579  void
1580  legion_index_partition_destroy_unordered(legion_runtime_t runtime,
1581  legion_context_t ctx,
1582  legion_index_partition_t handle,
1583  bool unordered /* = false */,
1584  bool recurse /* = true */);
1585 
1589  void
1590  legion_index_partition_attach_semantic_information(
1591  legion_runtime_t runtime,
1592  legion_index_partition_t handle,
1593  legion_semantic_tag_t tag,
1594  const void *buffer,
1595  size_t size,
1596  bool is_mutable /* = false */);
1597 
1601  bool
1602  legion_index_partition_retrieve_semantic_information(
1603  legion_runtime_t runtime,
1604  legion_index_partition_t handle,
1605  legion_semantic_tag_t tag,
1606  const void **result,
1607  size_t *size,
1608  bool can_fail /* = false */,
1609  bool wait_until_ready /* = false */);
1610 
1614  void
1615  legion_index_partition_attach_name(legion_runtime_t runtime,
1616  legion_index_partition_t handle,
1617  const char *name,
1618  bool is_mutable /* = false */);
1619 
1623  void
1624  legion_index_partition_retrieve_name(legion_runtime_t runtime,
1625  legion_index_partition_t handle,
1626  const char **result);
1627 
1628  // -----------------------------------------------------------------------
1629  // Field Space Operations
1630  // -----------------------------------------------------------------------
1631 
1637  legion_field_space_t
1638  legion_field_space_create(legion_runtime_t runtime,
1639  legion_context_t ctx);
1640 
1646  legion_field_space_t
1647  legion_field_space_create_with_fields(legion_runtime_t runtime,
1648  legion_context_t ctx,
1649  size_t *field_sizes,
1650  legion_field_id_t *field_ids,
1651  size_t num_fields,
1652  legion_custom_serdez_id_t serdez);
1653 
1659  legion_field_space_t
1660  legion_field_space_create_with_futures(legion_runtime_t runtime,
1661  legion_context_t ctx,
1662  legion_future_t *field_sizes,
1663  legion_field_id_t *field_ids,
1664  size_t num_fields,
1665  legion_custom_serdez_id_t serdez);
1666 
1670  legion_field_space_t
1671  legion_field_space_no_space();
1672 
1678  void
1679  legion_field_space_create_shared_ownership(legion_runtime_t runtime,
1680  legion_context_t ctx,
1681  legion_field_space_t handle);
1682 
1688  void
1689  legion_field_space_destroy(legion_runtime_t runtime,
1690  legion_context_t ctx,
1691  legion_field_space_t handle);
1692 
1698  void
1699  legion_field_space_destroy_unordered(legion_runtime_t runtime,
1700  legion_context_t ctx,
1701  legion_field_space_t handle,
1702  bool unordered);
1703 
1707  void
1708  legion_field_space_attach_semantic_information(
1709  legion_runtime_t runtime,
1710  legion_field_space_t handle,
1711  legion_semantic_tag_t tag,
1712  const void *buffer,
1713  size_t size,
1714  bool is_mutable /* = false */);
1715 
1719  bool
1720  legion_field_space_retrieve_semantic_information(
1721  legion_runtime_t runtime,
1722  legion_field_space_t handle,
1723  legion_semantic_tag_t tag,
1724  const void **result,
1725  size_t *size,
1726  bool can_fail /* = false */,
1727  bool wait_until_ready /* = false */);
1728 
1734  legion_field_id_t *
1735  legion_field_space_get_fields(legion_runtime_t runtime,
1736  legion_context_t ctx,
1737  legion_field_space_t handle,
1738  size_t *size);
1739 
1745  bool
1746  legion_field_space_has_fields(legion_runtime_t runtime,
1747  legion_context_t ctx,
1748  legion_field_space_t handle,
1749  const legion_field_id_t *fields,
1750  size_t fields_size);
1751 
1755  void
1756  legion_field_id_attach_semantic_information(legion_runtime_t runtime,
1757  legion_field_space_t handle,
1758  legion_field_id_t id,
1759  legion_semantic_tag_t tag,
1760  const void *buffer,
1761  size_t size,
1762  bool is_mutable /* = false */);
1763 
1767  bool
1768  legion_field_id_retrieve_semantic_information(
1769  legion_runtime_t runtime,
1770  legion_field_space_t handle,
1771  legion_field_id_t id,
1772  legion_semantic_tag_t tag,
1773  const void **result,
1774  size_t *size,
1775  bool can_fail /* = false */,
1776  bool wait_until_ready /* = false */);
1777 
1781  void
1782  legion_field_space_attach_name(legion_runtime_t runtime,
1783  legion_field_space_t handle,
1784  const char *name,
1785  bool is_mutable /* = false */);
1786 
1790  void
1791  legion_field_space_retrieve_name(legion_runtime_t runtime,
1792  legion_field_space_t handle,
1793  const char **result);
1794 
1798  void
1799  legion_field_id_attach_name(legion_runtime_t runtime,
1800  legion_field_space_t handle,
1801  legion_field_id_t id,
1802  const char *name,
1803  bool is_mutable /* = false */);
1804 
1808  void
1809  legion_field_id_retrieve_name(legion_runtime_t runtime,
1810  legion_field_space_t handle,
1811  legion_field_id_t id,
1812  const char **result);
1813 
1817  size_t
1818  legion_field_id_get_size(legion_runtime_t runtime,
1819  legion_context_t ctx,
1820  legion_field_space_t handle,
1821  legion_field_id_t id);
1822 
1823  // -----------------------------------------------------------------------
1824  // Logical Region Operations
1825  // -----------------------------------------------------------------------
1826 
1832  legion_logical_region_t
1833  legion_logical_region_create(legion_runtime_t runtime,
1834  legion_context_t ctx,
1835  legion_index_space_t index,
1836  legion_field_space_t fields,
1837  bool task_local);
1838 
1844  void
1845  legion_logical_region_create_shared_ownership(legion_runtime_t runtime,
1846  legion_context_t ctx,
1847  legion_logical_region_t handle);
1848 
1854  void
1855  legion_logical_region_destroy(legion_runtime_t runtime,
1856  legion_context_t ctx,
1857  legion_logical_region_t handle);
1858 
1864  void
1865  legion_logical_region_destroy_unordered(legion_runtime_t runtime,
1866  legion_context_t ctx,
1867  legion_logical_region_t handle,
1868  bool unordered);
1869 
1873  legion_color_t
1874  legion_logical_region_get_color(legion_runtime_t runtime,
1875  legion_logical_region_t handle);
1876 
1880  legion_domain_point_t
1881  legion_logical_region_get_color_domain_point(legion_runtime_t runtime_,
1882  legion_logical_region_t handle_);
1883 
1887  bool
1888  legion_logical_region_has_parent_logical_partition(
1889  legion_runtime_t runtime,
1890  legion_logical_region_t handle);
1891 
1895  legion_logical_partition_t
1896  legion_logical_region_get_parent_logical_partition(
1897  legion_runtime_t runtime,
1898  legion_logical_region_t handle);
1899 
1903  void
1904  legion_logical_region_attach_semantic_information(
1905  legion_runtime_t runtime,
1906  legion_logical_region_t handle,
1907  legion_semantic_tag_t tag,
1908  const void *buffer,
1909  size_t size,
1910  bool is_mutable /* = false */);
1911 
1915  bool
1916  legion_logical_region_retrieve_semantic_information(
1917  legion_runtime_t runtime,
1918  legion_logical_region_t handle,
1919  legion_semantic_tag_t tag,
1920  const void **result,
1921  size_t *size,
1922  bool can_fail /* = false */,
1923  bool wait_until_ready /* = false */);
1924 
1928  void
1929  legion_logical_region_attach_name(legion_runtime_t runtime,
1930  legion_logical_region_t handle,
1931  const char *name,
1932  bool is_mutable /* = false */);
1933 
1937  void
1938  legion_logical_region_retrieve_name(legion_runtime_t runtime,
1939  legion_logical_region_t handle,
1940  const char **result);
1941 
1945  legion_index_space_t
1946  legion_logical_region_get_index_space(legion_logical_region_t handle);
1947 
1948  // -----------------------------------------------------------------------
1949  // Logical Region Tree Traversal Operations
1950  // -----------------------------------------------------------------------
1951 
1957  legion_logical_partition_t
1958  legion_logical_partition_create(legion_runtime_t runtime,
1959  legion_logical_region_t parent,
1960  legion_index_partition_t handle);
1961 
1967  legion_logical_partition_t
1968  legion_logical_partition_create_by_tree(legion_runtime_t runtime,
1969  legion_context_t ctx,
1970  legion_index_partition_t handle,
1971  legion_field_space_t fspace,
1972  legion_region_tree_id_t tid);
1973 
1979  void
1980  legion_logical_partition_destroy(legion_runtime_t runtime,
1981  legion_context_t ctx,
1982  legion_logical_partition_t handle);
1983 
1989  void
1990  legion_logical_partition_destroy_unordered(legion_runtime_t runtime,
1991  legion_context_t ctx,
1992  legion_logical_partition_t handle,
1993  bool unordered);
1994 
2000  legion_logical_region_t
2001  legion_logical_partition_get_logical_subregion(
2002  legion_runtime_t runtime,
2003  legion_logical_partition_t parent,
2004  legion_index_space_t handle);
2005 
2011  legion_logical_region_t
2012  legion_logical_partition_get_logical_subregion_by_color(
2013  legion_runtime_t runtime,
2014  legion_logical_partition_t parent,
2015  legion_color_t c);
2016 
2022  legion_logical_region_t
2023  legion_logical_partition_get_logical_subregion_by_color_domain_point(
2024  legion_runtime_t runtime,
2025  legion_logical_partition_t parent,
2026  legion_domain_point_t c);
2027 
2031  bool
2032  legion_logical_partition_has_logical_subregion_by_color_domain_point(
2033  legion_runtime_t runtime,
2034  legion_logical_partition_t parent,
2035  legion_domain_point_t c);
2036 
2042  legion_logical_region_t
2043  legion_logical_partition_get_logical_subregion_by_tree(
2044  legion_runtime_t runtime,
2045  legion_index_space_t handle,
2046  legion_field_space_t fspace,
2047  legion_region_tree_id_t tid);
2048 
2052  legion_logical_region_t
2053  legion_logical_partition_get_parent_logical_region(
2054  legion_runtime_t runtime,
2055  legion_logical_partition_t handle);
2056 
2060  void
2061  legion_logical_partition_attach_semantic_information(
2062  legion_runtime_t runtime,
2063  legion_logical_partition_t handle,
2064  legion_semantic_tag_t tag,
2065  const void *buffer,
2066  size_t size,
2067  bool is_mutable /* = false */);
2068 
2072  bool
2073  legion_logical_partition_retrieve_semantic_information(
2074  legion_runtime_t runtime,
2075  legion_logical_partition_t handle,
2076  legion_semantic_tag_t tag,
2077  const void **result,
2078  size_t *size,
2079  bool can_fail /* = false */,
2080  bool wait_until_ready /* = false */);
2081 
2085  void
2086  legion_logical_partition_attach_name(legion_runtime_t runtime,
2087  legion_logical_partition_t handle,
2088  const char *name,
2089  bool is_mutable /* = false */);
2090 
2094  void
2095  legion_logical_partition_retrieve_name(legion_runtime_t runtime,
2096  legion_logical_partition_t handle,
2097  const char **result);
2098 
2099  // -----------------------------------------------------------------------
2100  // Region Requirement Operations
2101  // -----------------------------------------------------------------------
2102 
2106  legion_region_requirement_t
2107  legion_region_requirement_create_logical_region(
2108  legion_logical_region_t handle,
2109  legion_privilege_mode_t priv,
2110  legion_coherence_property_t prop,
2111  legion_logical_region_t parent,
2112  legion_mapping_tag_id_t tag /* = 0 */,
2113  bool verified /* = false*/);
2114 
2118  legion_region_requirement_t
2119  legion_region_requirement_create_logical_region_projection(
2120  legion_logical_region_t handle,
2121  legion_projection_id_t proj /* = 0 */,
2122  legion_privilege_mode_t priv,
2123  legion_coherence_property_t prop,
2124  legion_logical_region_t parent,
2125  legion_mapping_tag_id_t tag /* = 0 */,
2126  bool verified /* = false*/);
2127 
2131  legion_region_requirement_t
2132  legion_region_requirement_create_logical_partition(
2133  legion_logical_partition_t handle,
2134  legion_projection_id_t proj /* = 0 */,
2135  legion_privilege_mode_t priv,
2136  legion_coherence_property_t prop,
2137  legion_logical_region_t parent,
2138  legion_mapping_tag_id_t tag /* = 0 */,
2139  bool verified /* = false*/);
2140 
2144  void
2145  legion_region_requirement_destroy(legion_region_requirement_t handle);
2146 
2150  void
2151  legion_region_requirement_add_field(legion_region_requirement_t handle,
2152  legion_field_id_t field,
2153  bool instance_field);
2154 
2158  void
2159  legion_region_requirement_add_flags(legion_region_requirement_t handle,
2160  legion_region_flags_t flags);
2161 
2165  legion_logical_region_t
2166  legion_region_requirement_get_region(legion_region_requirement_t handle);
2167 
2171  legion_logical_region_t
2172  legion_region_requirement_get_parent(legion_region_requirement_t handle);
2173 
2177  legion_logical_partition_t
2178  legion_region_requirement_get_partition(legion_region_requirement_t handle);
2179 
2183  unsigned
2184  legion_region_requirement_get_privilege_fields_size(
2185  legion_region_requirement_t handle);
2186 
2198  void
2199  legion_region_requirement_get_privilege_fields(
2200  legion_region_requirement_t handle,
2201  legion_field_id_t* fields,
2202  unsigned fields_size);
2203 
2211  legion_field_id_t
2212  legion_region_requirement_get_privilege_field(
2213  legion_region_requirement_t handle,
2214  unsigned idx);
2215 
2219  unsigned
2220  legion_region_requirement_get_instance_fields_size(
2221  legion_region_requirement_t handle);
2222 
2234  void
2235  legion_region_requirement_get_instance_fields(
2236  legion_region_requirement_t handle,
2237  legion_field_id_t* fields,
2238  unsigned fields_size);
2239 
2245  legion_field_id_t
2246  legion_region_requirement_get_instance_field(
2247  legion_region_requirement_t handle,
2248  unsigned idx);
2249 
2253  legion_privilege_mode_t
2254  legion_region_requirement_get_privilege(legion_region_requirement_t handle);
2255 
2259  legion_coherence_property_t
2260  legion_region_requirement_get_prop(legion_region_requirement_t handle);
2261 
2265  legion_reduction_op_id_t
2266  legion_region_requirement_get_redop(legion_region_requirement_t handle);
2267 
2271  legion_mapping_tag_id_t
2272  legion_region_requirement_get_tag(legion_region_requirement_t handle);
2273 
2277  legion_handle_type_t
2278  legion_region_requirement_get_handle_type(legion_region_requirement_t handle);
2279 
2283  legion_projection_id_t
2284  legion_region_requirement_get_projection(legion_region_requirement_t handle);
2285 
2286  // -----------------------------------------------------------------------
2287  // Allocator and Argument Map Operations
2288  // -----------------------------------------------------------------------
2289 
2295  legion_field_allocator_t
2296  legion_field_allocator_create(legion_runtime_t runtime,
2297  legion_context_t ctx,
2298  legion_field_space_t handle);
2299 
2305  void
2306  legion_field_allocator_destroy(legion_field_allocator_t handle);
2307 
2311  legion_field_id_t
2312  legion_auto_generate_id(void);
2313 
2317  legion_field_id_t
2318  legion_field_allocator_allocate_field(
2319  legion_field_allocator_t allocator,
2320  size_t field_size,
2321  legion_field_id_t desired_fieldid /* = AUTO_GENERATE_ID */);
2322 
2326  legion_field_id_t
2327  legion_field_allocator_allocate_field_future(
2328  legion_field_allocator_t allocator,
2329  legion_future_t field_size,
2330  legion_field_id_t desired_fieldid /* = AUTO_GENERATE_ID */);
2331 
2335  void
2336  legion_field_allocator_free_field(legion_field_allocator_t allocator,
2337  legion_field_id_t fid);
2338 
2342  void
2343  legion_field_allocator_free_field_unordered(legion_field_allocator_t allocator,
2344  legion_field_id_t fid,
2345  bool unordered);
2346 
2350  legion_field_id_t
2351  legion_field_allocator_allocate_local_field(
2352  legion_field_allocator_t allocator,
2353  size_t field_size,
2354  legion_field_id_t desired_fieldid /* = AUTO_GENERATE_ID */);
2355 
2361  legion_argument_map_t
2362  legion_argument_map_create(void);
2363 
2369  legion_argument_map_t
2370  legion_argument_map_from_future_map(legion_future_map_t map);
2371 
2375  void
2376  legion_argument_map_set_point(legion_argument_map_t map,
2377  legion_domain_point_t dp,
2378  legion_untyped_buffer_t arg,
2379  bool replace /* = true */);
2380 
2384  void
2385  legion_argument_map_set_future(legion_argument_map_t map,
2386  legion_domain_point_t dp,
2387  legion_future_t future,
2388  bool replace /* = true */);
2389 
2395  void
2396  legion_argument_map_destroy(legion_argument_map_t handle);
2397 
2398  // -----------------------------------------------------------------------
2399  // Predicate Operations
2400  // -----------------------------------------------------------------------
2401 
2407  legion_predicate_t
2408  legion_predicate_create(legion_runtime_t runtime,
2409  legion_context_t ctx,
2410  legion_future_t f);
2411 
2417  void
2418  legion_predicate_destroy(legion_predicate_t handle);
2419 
2425  const legion_predicate_t
2426  legion_predicate_true(void);
2427 
2433  const legion_predicate_t
2434  legion_predicate_false(void);
2435 
2436  // -----------------------------------------------------------------------
2437  // Phase Barrier Operations
2438  // -----------------------------------------------------------------------
2439 
2445  legion_phase_barrier_t
2446  legion_phase_barrier_create(legion_runtime_t runtime,
2447  legion_context_t ctx,
2448  unsigned arrivals);
2449 
2455  void
2456  legion_phase_barrier_destroy(legion_runtime_t runtime,
2457  legion_context_t ctx,
2458  legion_phase_barrier_t handle);
2459 
2463  legion_phase_barrier_t
2464  legion_phase_barrier_alter_arrival_count(legion_runtime_t runtime,
2465  legion_context_t ctx,
2466  legion_phase_barrier_t handle,
2467  int delta);
2468 
2472  void
2473  legion_phase_barrier_arrive(legion_runtime_t runtime,
2474  legion_context_t ctx,
2475  legion_phase_barrier_t handle,
2476  unsigned count /* = 1 */);
2477 
2481  void
2482  legion_phase_barrier_wait(legion_runtime_t runtime,
2483  legion_context_t ctx,
2484  legion_phase_barrier_t handle);
2485 
2491  legion_phase_barrier_t
2492  legion_phase_barrier_advance(legion_runtime_t runtime,
2493  legion_context_t ctx,
2494  legion_phase_barrier_t handle);
2495 
2496  // -----------------------------------------------------------------------
2497  // Dynamic Collective Operations
2498  // -----------------------------------------------------------------------
2499 
2505  legion_dynamic_collective_t
2506  legion_dynamic_collective_create(legion_runtime_t runtime,
2507  legion_context_t ctx,
2508  unsigned arrivals,
2509  legion_reduction_op_id_t redop,
2510  const void *init_value,
2511  size_t init_size);
2512 
2518  void
2519  legion_dynamic_collective_destroy(legion_runtime_t runtime,
2520  legion_context_t ctx,
2521  legion_dynamic_collective_t handle);
2522 
2526  legion_dynamic_collective_t
2527  legion_dynamic_collective_alter_arrival_count(
2528  legion_runtime_t runtime,
2529  legion_context_t ctx,
2530  legion_dynamic_collective_t handle,
2531  int delta);
2532 
2536  void
2537  legion_dynamic_collective_arrive(legion_runtime_t runtime,
2538  legion_context_t ctx,
2539  legion_dynamic_collective_t handle,
2540  const void *buffer,
2541  size_t size,
2542  unsigned count /* = 1 */);
2543 
2547  void
2548  legion_dynamic_collective_defer_arrival(legion_runtime_t runtime,
2549  legion_context_t ctx,
2550  legion_dynamic_collective_t handle,
2551  legion_future_t f,
2552  unsigned count /* = 1 */);
2553 
2559  legion_future_t
2560  legion_dynamic_collective_get_result(legion_runtime_t runtime,
2561  legion_context_t ctx,
2562  legion_dynamic_collective_t handle);
2563 
2569  legion_dynamic_collective_t
2570  legion_dynamic_collective_advance(legion_runtime_t runtime,
2571  legion_context_t ctx,
2572  legion_dynamic_collective_t handle);
2573 
2574  // -----------------------------------------------------------------------
2575  // Future Operations
2576  // -----------------------------------------------------------------------
2577 
2583  legion_future_t
2584  legion_future_from_untyped_pointer(legion_runtime_t runtime,
2585  const void *buffer,
2586  size_t size);
2587 
2593  legion_future_t
2594  legion_future_copy(legion_future_t handle);
2595 
2601  void
2602  legion_future_destroy(legion_future_t handle);
2603 
2607  void
2608  legion_future_get_void_result(legion_future_t handle);
2609 
2613  void
2614  legion_future_wait(legion_future_t handle,
2615  bool silence_warnings /* = false */,
2616  const char *warning_string /* = NULL */);
2617 
2621  bool
2622  legion_future_is_empty(legion_future_t handle,
2623  bool block /* = false */);
2624 
2628  bool
2629  legion_future_is_ready(legion_future_t handle);
2630 
2634  bool
2635  legion_future_is_ready_subscribe(legion_future_t handle, bool subscribe);
2636 
2640  const void *
2641  legion_future_get_untyped_pointer(legion_future_t handle);
2642 
2646  size_t
2647  legion_future_get_untyped_size(legion_future_t handle);
2648 
2649  // -----------------------------------------------------------------------
2650  // Future Map Operations
2651  // -----------------------------------------------------------------------
2652 
2658  legion_future_map_t
2659  legion_future_map_copy(legion_future_map_t handle);
2660 
2666  void
2667  legion_future_map_destroy(legion_future_map_t handle);
2668 
2672  void
2673  legion_future_map_wait_all_results(legion_future_map_t handle);
2674 
2680  legion_future_t
2681  legion_future_map_get_future(legion_future_map_t handle,
2682  legion_domain_point_t point);
2683 
2689  legion_future_t
2690  legion_future_map_reduce(legion_runtime_t runtime,
2691  legion_context_t ctx,
2692  legion_future_map_t handle,
2693  legion_reduction_op_id_t redop,
2694  bool deterministic);
2695 
2701  legion_future_map_t
2702  legion_future_map_construct_from_buffers(legion_runtime_t runtime,
2703  legion_context_t ctx,
2704  legion_domain_t domain,
2705  legion_domain_point_t *points,
2706  legion_untyped_buffer_t *buffers,
2707  size_t num_points,
2708  bool collective,
2709  legion_sharding_id_t sid,
2710  bool implicit_sharding);
2711 
2717  legion_future_map_t
2718  legion_future_map_construct_from_futures(legion_runtime_t runtime,
2719  legion_context_t ctx,
2720  legion_domain_t domain,
2721  legion_domain_point_t *points,
2722  legion_future_t *futures,
2723  size_t num_futures,
2724  bool collective,
2725  legion_sharding_id_t sid,
2726  bool implicit_sharding);
2727 
2728  // -----------------------------------------------------------------------
2729  // Deferred Buffer Operations
2730  // -----------------------------------------------------------------------
2731 
2737 #define BUFFER_CREATE(DIM) \
2738  legion_deferred_buffer_char_##DIM##d_t \
2739  legion_deferred_buffer_char_##DIM##d_create( \
2740  legion_rect_##DIM##d_t bounds, \
2741  legion_memory_kind_t kind, \
2742  char *initial_value);
2743  LEGION_FOREACH_N(BUFFER_CREATE)
2744 #undef BUFFER_CREATE
2745 
2746  /*
2747  * @see Legion::DeferredBuffer::ptr()
2748  */
2749 #define BUFFER_PTR(DIM) \
2750  char* \
2751  legion_deferred_buffer_char_##DIM##d_ptr( \
2752  legion_deferred_buffer_char_##DIM##d_t buffer, \
2753  legion_point_##DIM##d_t p);
2754  LEGION_FOREACH_N(BUFFER_PTR)
2755 #undef BUFFER_PTR
2756 
2757  /*
2758  * @see Legion::DeferredBuffer::~DeferredBuffer()
2759  */
2760 #define BUFFER_DESTROY(DIM) \
2761  void \
2762  legion_deferred_buffer_char_##DIM##d_destroy( \
2763  legion_deferred_buffer_char_##DIM##d_t buffer);
2764  LEGION_FOREACH_N(BUFFER_DESTROY)
2765 #undef BUFFER_DESTROY
2766 
2767  // -----------------------------------------------------------------------
2768  // Task Launch Operations
2769  // -----------------------------------------------------------------------
2770 
2776  legion_task_launcher_t
2777  legion_task_launcher_create(
2778  legion_task_id_t tid,
2779  legion_untyped_buffer_t arg,
2780  legion_predicate_t pred /* = legion_predicate_true() */,
2781  legion_mapper_id_t id /* = 0 */,
2782  legion_mapping_tag_id_t tag /* = 0 */);
2783 
2789  legion_task_launcher_t
2790  legion_task_launcher_create_from_buffer(
2791  legion_task_id_t tid,
2792  const void *buffer,
2793  size_t buffer_size,
2794  legion_predicate_t pred /* = legion_predicate_true() */,
2795  legion_mapper_id_t id /* = 0 */,
2796  legion_mapping_tag_id_t tag /* = 0 */);
2797 
2803  void
2804  legion_task_launcher_destroy(legion_task_launcher_t handle);
2805 
2811  legion_future_t
2812  legion_task_launcher_execute(legion_runtime_t runtime,
2813  legion_context_t ctx,
2814  legion_task_launcher_t launcher);
2815 
2819  unsigned
2820  legion_task_launcher_add_region_requirement_logical_region(
2821  legion_task_launcher_t launcher,
2822  legion_logical_region_t handle,
2823  legion_privilege_mode_t priv,
2824  legion_coherence_property_t prop,
2825  legion_logical_region_t parent,
2826  legion_mapping_tag_id_t tag /* = 0 */,
2827  bool verified /* = false*/);
2828 
2832  unsigned
2833  legion_task_launcher_add_region_requirement_logical_region_reduction(
2834  legion_task_launcher_t launcher,
2835  legion_logical_region_t handle,
2836  legion_reduction_op_id_t redop,
2837  legion_coherence_property_t prop,
2838  legion_logical_region_t parent,
2839  legion_mapping_tag_id_t tag /* = 0 */,
2840  bool verified /* = false*/);
2841 
2845  void
2846  legion_task_launcher_set_region_requirement_logical_region(
2847  legion_task_launcher_t launcher,
2848  unsigned idx,
2849  legion_logical_region_t handle,
2850  legion_privilege_mode_t priv,
2851  legion_coherence_property_t prop,
2852  legion_logical_region_t parent,
2853  legion_mapping_tag_id_t tag /* = 0 */,
2854  bool verified /* = false*/);
2855 
2859  void
2860  legion_task_launcher_set_region_requirement_logical_region_reduction(
2861  legion_task_launcher_t launcher,
2862  unsigned idx,
2863  legion_logical_region_t handle,
2864  legion_reduction_op_id_t redop,
2865  legion_coherence_property_t prop,
2866  legion_logical_region_t parent,
2867  legion_mapping_tag_id_t tag /* = 0 */,
2868  bool verified /* = false*/);
2869 
2873  void
2874  legion_task_launcher_add_field(legion_task_launcher_t launcher,
2875  unsigned idx,
2876  legion_field_id_t fid,
2877  bool inst /* = true */);
2878 
2882  const void*
2883  legion_index_launcher_get_projection_args(legion_region_requirement_t requirement,
2884  size_t *size);
2885 
2889  void
2890  legion_index_launcher_set_projection_args(legion_index_launcher_t launcher_,
2891  unsigned idx,
2892  const void *args,
2893  size_t size,
2894  bool own);
2895 
2899  void
2900  legion_task_launcher_add_flags(legion_task_launcher_t launcher,
2901  unsigned idx,
2902  enum legion_region_flags_t flags);
2903 
2907  void
2908  legion_task_launcher_intersect_flags(legion_task_launcher_t launcher,
2909  unsigned idx,
2910  enum legion_region_flags_t flags);
2911 
2915  unsigned
2916  legion_task_launcher_add_index_requirement(
2917  legion_task_launcher_t launcher,
2918  legion_index_space_t handle,
2919  legion_allocate_mode_t priv,
2920  legion_index_space_t parent,
2921  bool verified /* = false*/);
2922 
2926  void
2927  legion_task_launcher_add_future(legion_task_launcher_t launcher,
2928  legion_future_t future);
2929 
2933  void
2934  legion_task_launcher_add_wait_barrier(legion_task_launcher_t launcher,
2935  legion_phase_barrier_t bar);
2936 
2940  void
2941  legion_task_launcher_add_arrival_barrier(legion_task_launcher_t launcher,
2942  legion_phase_barrier_t bar);
2943 
2947  void
2948  legion_task_launcher_set_argument(legion_task_launcher_t launcher,
2949  legion_untyped_buffer_t arg);
2950 
2954  void
2955  legion_task_launcher_set_point(legion_task_launcher_t launcher,
2956  legion_domain_point_t point);
2957 
2961  void
2962  legion_task_launcher_set_sharding_space(legion_task_launcher_t launcher,
2963  legion_index_space_t is);
2964 
2968  void
2969  legion_task_launcher_set_predicate_false_future(legion_task_launcher_t launcher,
2970  legion_future_t f);
2971 
2975  void
2976  legion_task_launcher_set_predicate_false_result(legion_task_launcher_t launcher,
2977  legion_untyped_buffer_t arg);
2978 
2982  void
2983  legion_task_launcher_set_mapper(legion_task_launcher_t launcher,
2984  legion_mapper_id_t mapper_id);
2985 
2989  void
2990  legion_task_launcher_set_mapping_tag(legion_task_launcher_t launcher,
2991  legion_mapping_tag_id_t tag);
2992 
2996  void
2997  legion_task_launcher_set_mapper_arg(legion_task_launcher_t launcher,
2998  legion_untyped_buffer_t arg);
2999 
3003  void
3004  legion_task_launcher_set_enable_inlining(legion_task_launcher_t launcher,
3005  bool enable_inlining);
3006 
3010  void
3011  legion_task_launcher_set_local_function_task(legion_task_launcher_t launcher,
3012  bool local_function_task);
3013 
3017  void
3018  legion_task_launcher_set_elide_future_return(legion_task_launcher_t launcher,
3019  bool elide_future_return);
3020 
3024  void
3025  legion_task_launcher_set_provenance(legion_task_launcher_t launcher,
3026  const char *provenance);
3027 
3033  legion_index_launcher_t
3034  legion_index_launcher_create(
3035  legion_task_id_t tid,
3036  legion_domain_t domain,
3037  legion_untyped_buffer_t global_arg,
3038  legion_argument_map_t map,
3039  legion_predicate_t pred /* = legion_predicate_true() */,
3040  bool must /* = false */,
3041  legion_mapper_id_t id /* = 0 */,
3042  legion_mapping_tag_id_t tag /* = 0 */);
3043 
3049  legion_index_launcher_t
3050  legion_index_launcher_create_from_buffer(
3051  legion_task_id_t tid,
3052  legion_domain_t domain,
3053  const void *buffer,
3054  size_t buffer_size,
3055  legion_argument_map_t map,
3056  legion_predicate_t pred /* = legion_predicate_true() */,
3057  bool must /* = false */,
3058  legion_mapper_id_t id /* = 0 */,
3059  legion_mapping_tag_id_t tag /* = 0 */);
3060 
3066  void
3067  legion_index_launcher_destroy(legion_index_launcher_t handle);
3068 
3074  legion_future_map_t
3075  legion_index_launcher_execute(legion_runtime_t runtime,
3076  legion_context_t ctx,
3077  legion_index_launcher_t launcher);
3078 
3084  legion_future_t
3085  legion_index_launcher_execute_reduction(legion_runtime_t runtime,
3086  legion_context_t ctx,
3087  legion_index_launcher_t launcher,
3088  legion_reduction_op_id_t redop);
3089 
3095  legion_future_t
3096  legion_index_launcher_execute_deterministic_reduction(legion_runtime_t runtime,
3097  legion_context_t ctx,
3098  legion_index_launcher_t launcher,
3099  legion_reduction_op_id_t redop,
3100  bool deterministic);
3101 
3105  unsigned
3106  legion_index_launcher_add_region_requirement_logical_region(
3107  legion_index_launcher_t launcher,
3108  legion_logical_region_t handle,
3109  legion_projection_id_t proj /* = 0 */,
3110  legion_privilege_mode_t priv,
3111  legion_coherence_property_t prop,
3112  legion_logical_region_t parent,
3113  legion_mapping_tag_id_t tag /* = 0 */,
3114  bool verified /* = false*/);
3115 
3119  unsigned
3120  legion_index_launcher_add_region_requirement_logical_partition(
3121  legion_index_launcher_t launcher,
3122  legion_logical_partition_t handle,
3123  legion_projection_id_t proj /* = 0 */,
3124  legion_privilege_mode_t priv,
3125  legion_coherence_property_t prop,
3126  legion_logical_region_t parent,
3127  legion_mapping_tag_id_t tag /* = 0 */,
3128  bool verified /* = false*/);
3129 
3133  unsigned
3134  legion_index_launcher_add_region_requirement_logical_region_reduction(
3135  legion_index_launcher_t launcher,
3136  legion_logical_region_t handle,
3137  legion_projection_id_t proj /* = 0 */,
3138  legion_reduction_op_id_t redop,
3139  legion_coherence_property_t prop,
3140  legion_logical_region_t parent,
3141  legion_mapping_tag_id_t tag /* = 0 */,
3142  bool verified /* = false*/);
3143 
3147  unsigned
3148  legion_index_launcher_add_region_requirement_logical_partition_reduction(
3149  legion_index_launcher_t launcher,
3150  legion_logical_partition_t handle,
3151  legion_projection_id_t proj /* = 0 */,
3152  legion_reduction_op_id_t redop,
3153  legion_coherence_property_t prop,
3154  legion_logical_region_t parent,
3155  legion_mapping_tag_id_t tag /* = 0 */,
3156  bool verified /* = false*/);
3157 
3161  void
3162  legion_index_launcher_set_region_requirement_logical_region(
3163  legion_index_launcher_t launcher,
3164  unsigned idx,
3165  legion_logical_region_t handle,
3166  legion_projection_id_t proj /* = 0 */,
3167  legion_privilege_mode_t priv,
3168  legion_coherence_property_t prop,
3169  legion_logical_region_t parent,
3170  legion_mapping_tag_id_t tag /* = 0 */,
3171  bool verified /* = false*/);
3172 
3176  void
3177  legion_index_launcher_set_region_requirement_logical_partition(
3178  legion_index_launcher_t launcher,
3179  unsigned idx,
3180  legion_logical_partition_t handle,
3181  legion_projection_id_t proj /* = 0 */,
3182  legion_privilege_mode_t priv,
3183  legion_coherence_property_t prop,
3184  legion_logical_region_t parent,
3185  legion_mapping_tag_id_t tag /* = 0 */,
3186  bool verified /* = false*/);
3187 
3191  void
3192  legion_index_launcher_set_region_requirement_logical_region_reduction(
3193  legion_index_launcher_t launcher,
3194  unsigned idx,
3195  legion_logical_region_t handle,
3196  legion_projection_id_t proj /* = 0 */,
3197  legion_reduction_op_id_t redop,
3198  legion_coherence_property_t prop,
3199  legion_logical_region_t parent,
3200  legion_mapping_tag_id_t tag /* = 0 */,
3201  bool verified /* = false*/);
3202 
3206  void
3207  legion_index_launcher_set_region_requirement_logical_partition_reduction(
3208  legion_index_launcher_t launcher,
3209  unsigned idx,
3210  legion_logical_partition_t handle,
3211  legion_projection_id_t proj /* = 0 */,
3212  legion_reduction_op_id_t redop,
3213  legion_coherence_property_t prop,
3214  legion_logical_region_t parent,
3215  legion_mapping_tag_id_t tag /* = 0 */,
3216  bool verified /* = false*/);
3217 
3221  void
3222  legion_index_launcher_add_field(legion_index_launcher_t launcher,
3223  unsigned idx,
3224  legion_field_id_t fid,
3225  bool inst /* = true */);
3226 
3230  void
3231  legion_index_launcher_add_flags(legion_index_launcher_t launcher,
3232  unsigned idx,
3233  enum legion_region_flags_t flags);
3234 
3238  void
3239  legion_index_launcher_intersect_flags(legion_index_launcher_t launcher,
3240  unsigned idx,
3241  enum legion_region_flags_t flags);
3242 
3246  unsigned
3247  legion_index_launcher_add_index_requirement(
3248  legion_index_launcher_t launcher,
3249  legion_index_space_t handle,
3250  legion_allocate_mode_t priv,
3251  legion_index_space_t parent,
3252  bool verified /* = false*/);
3253 
3257  void
3258  legion_index_launcher_add_future(legion_index_launcher_t launcher,
3259  legion_future_t future);
3260 
3264  void
3265  legion_index_launcher_add_wait_barrier(legion_index_launcher_t launcher,
3266  legion_phase_barrier_t bar);
3267 
3271  void
3272  legion_index_launcher_add_arrival_barrier(legion_index_launcher_t launcher,
3273  legion_phase_barrier_t bar);
3274 
3278  void
3279  legion_index_launcher_add_point_future(legion_index_launcher_t launcher,
3280  legion_argument_map_t map);
3281 
3285  void
3286  legion_index_launcher_set_global_arg(legion_index_launcher_t launcher,
3287  legion_untyped_buffer_t global_arg);
3288 
3292  void
3293  legion_index_launcher_set_sharding_space(legion_index_launcher_t launcher,
3294  legion_index_space_t is);
3295 
3299  void
3300  legion_index_launcher_set_mapper(legion_index_launcher_t launcher,
3301  legion_mapper_id_t mapper_id);
3302 
3306  void
3307  legion_index_launcher_set_mapping_tag(legion_index_launcher_t launcher,
3308  legion_mapping_tag_id_t tag);
3309 
3313  void
3314  legion_index_launcher_set_mapper_arg(legion_index_launcher_t launcher,
3315  legion_untyped_buffer_t map_arg);
3316 
3320  void
3321  legion_index_launcher_set_elide_future_return(legion_index_launcher_t launcher,
3322  bool elide_future_return);
3323 
3327  void
3328  legion_index_launcher_set_provenance(legion_index_launcher_t launcher,
3329  const char *provenance);
3330 
3331  // -----------------------------------------------------------------------
3332  // Inline Mapping Operations
3333  // -----------------------------------------------------------------------
3334 
3340  legion_inline_launcher_t
3341  legion_inline_launcher_create_logical_region(
3342  legion_logical_region_t handle,
3343  legion_privilege_mode_t priv,
3344  legion_coherence_property_t prop,
3345  legion_logical_region_t parent,
3346  legion_mapping_tag_id_t region_tag /* = 0 */,
3347  bool verified /* = false*/,
3348  legion_mapper_id_t id /* = 0 */,
3349  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3350 
3356  void
3357  legion_inline_launcher_destroy(legion_inline_launcher_t handle);
3358 
3364  legion_physical_region_t
3365  legion_inline_launcher_execute(legion_runtime_t runtime,
3366  legion_context_t ctx,
3367  legion_inline_launcher_t launcher);
3368 
3372  void
3373  legion_inline_launcher_add_field(legion_inline_launcher_t launcher,
3374  legion_field_id_t fid,
3375  bool inst /* = true */);
3376 
3380  void
3381  legion_inline_launcher_set_mapper_arg(legion_inline_launcher_t launcher,
3382  legion_untyped_buffer_t arg);
3383 
3387  void
3388  legion_inline_launcher_set_provenance(legion_inline_launcher_t launcher,
3389  const char *provenance);
3390 
3394  void
3395  legion_runtime_remap_region(legion_runtime_t runtime,
3396  legion_context_t ctx,
3397  legion_physical_region_t region);
3398 
3402  void
3403  legion_runtime_unmap_region(legion_runtime_t runtime,
3404  legion_context_t ctx,
3405  legion_physical_region_t region);
3406 
3410  void
3411  legion_runtime_unmap_all_regions(legion_runtime_t runtime,
3412  legion_context_t ctx);
3413 
3414  // -----------------------------------------------------------------------
3415  // Fill Field Operations
3416  // -----------------------------------------------------------------------
3417 
3421  void
3422  legion_runtime_fill_field(
3423  legion_runtime_t runtime,
3424  legion_context_t ctx,
3425  legion_logical_region_t handle,
3426  legion_logical_region_t parent,
3427  legion_field_id_t fid,
3428  const void *value,
3429  size_t value_size,
3430  legion_predicate_t pred /* = legion_predicate_true() */);
3431 
3435  void
3436  legion_runtime_fill_field_future(
3437  legion_runtime_t runtime,
3438  legion_context_t ctx,
3439  legion_logical_region_t handle,
3440  legion_logical_region_t parent,
3441  legion_field_id_t fid,
3442  legion_future_t f,
3443  legion_predicate_t pred /* = legion_predicate_true() */);
3444 
3450  legion_fill_launcher_t
3451  legion_fill_launcher_create(
3452  legion_logical_region_t handle,
3453  legion_logical_region_t parent,
3454  legion_field_id_t fid,
3455  const void *value,
3456  size_t value_size,
3457  legion_predicate_t pred /* = legion_predicate_true() */,
3458  legion_mapper_id_t id /* = 0 */,
3459  legion_mapping_tag_id_t tag /* = 0 */);
3460 
3466  legion_fill_launcher_t
3467  legion_fill_launcher_create_from_future(
3468  legion_logical_region_t handle,
3469  legion_logical_region_t parent,
3470  legion_field_id_t fid,
3471  legion_future_t f,
3472  legion_predicate_t pred /* = legion_predicate_true() */,
3473  legion_mapper_id_t id /* = 0 */,
3474  legion_mapping_tag_id_t tag /* = 0 */);
3475 
3481  void
3482  legion_fill_launcher_destroy(legion_fill_launcher_t handle);
3483 
3487  void
3488  legion_fill_launcher_add_field(legion_fill_launcher_t handle,
3489  legion_field_id_t fid);
3490 
3494  void
3495  legion_fill_launcher_execute(legion_runtime_t runtime,
3496  legion_context_t ctx,
3497  legion_fill_launcher_t launcher);
3498 
3502  void
3503  legion_fill_launcher_set_point(legion_fill_launcher_t launcher,
3504  legion_domain_point_t point);
3505 
3509  void legion_fill_launcher_set_sharding_space(legion_fill_launcher_t launcher,
3510  legion_index_space_t space);
3511 
3515  void
3516  legion_fill_launcher_set_mapper_arg(legion_fill_launcher_t launcher,
3517  legion_untyped_buffer_t arg);
3518 
3522  void
3523  legion_fill_launcher_set_provenance(legion_fill_launcher_t launcher,
3524  const char *provenance);
3525 
3526  // -----------------------------------------------------------------------
3527  // Index Fill Field Operations
3528  // -----------------------------------------------------------------------
3529 
3534  void
3535  legion_runtime_index_fill_field(
3536  legion_runtime_t runtime,
3537  legion_context_t ctx,
3538  legion_logical_partition_t handle,
3539  legion_logical_region_t parent,
3540  legion_field_id_t fid,
3541  const void *value,
3542  size_t value_size,
3543  legion_projection_id_t proj /* = 0 */,
3544  legion_predicate_t pred /* = legion_predicate_true() */,
3545  legion_mapper_id_t id /* = 0 */,
3546  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3547 
3552  void
3553  legion_runtime_index_fill_field_with_space(
3554  legion_runtime_t runtime,
3555  legion_context_t ctx,
3556  legion_index_space_t space,
3557  legion_logical_partition_t handle,
3558  legion_logical_region_t parent,
3559  legion_field_id_t fid,
3560  const void *value,
3561  size_t value_size,
3562  legion_projection_id_t proj /* = 0 */,
3563  legion_predicate_t pred /* = legion_predicate_true() */,
3564  legion_mapper_id_t id /* = 0 */,
3565  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3566 
3571  void
3572  legion_runtime_index_fill_field_with_domain(
3573  legion_runtime_t runtime,
3574  legion_context_t ctx,
3575  legion_domain_t domain,
3576  legion_logical_partition_t handle,
3577  legion_logical_region_t parent,
3578  legion_field_id_t fid,
3579  const void *value,
3580  size_t value_size,
3581  legion_projection_id_t proj /* = 0 */,
3582  legion_predicate_t pred /* = legion_predicate_true() */,
3583  legion_mapper_id_t id /* = 0 */,
3584  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3585 
3590  void
3591  legion_runtime_index_fill_field_future(
3592  legion_runtime_t runtime,
3593  legion_context_t ctx,
3594  legion_logical_partition_t handle,
3595  legion_logical_region_t parent,
3596  legion_field_id_t fid,
3597  legion_future_t f,
3598  legion_projection_id_t proj /* = 0 */,
3599  legion_predicate_t pred /* = legion_predicate_true() */,
3600  legion_mapper_id_t id /* = 0 */,
3601  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3602 
3607  void
3608  legion_runtime_index_fill_field_future_with_space(
3609  legion_runtime_t runtime,
3610  legion_context_t ctx,
3611  legion_index_space_t space,
3612  legion_logical_partition_t handle,
3613  legion_logical_region_t parent,
3614  legion_field_id_t fid,
3615  legion_future_t f,
3616  legion_projection_id_t proj /* = 0 */,
3617  legion_predicate_t pred /* = legion_predicate_true() */,
3618  legion_mapper_id_t id /* = 0 */,
3619  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3620 
3625  void
3626  legion_runtime_index_fill_field_future_with_domain(
3627  legion_runtime_t runtime,
3628  legion_context_t ctx,
3629  legion_domain_t domain,
3630  legion_logical_partition_t handle,
3631  legion_logical_region_t parent,
3632  legion_field_id_t fid,
3633  legion_future_t f,
3634  legion_projection_id_t proj /* = 0 */,
3635  legion_predicate_t pred /* = legion_predicate_true() */,
3636  legion_mapper_id_t id /* = 0 */,
3637  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3638 
3644  legion_index_fill_launcher_t
3645  legion_index_fill_launcher_create_with_space(
3646  legion_index_space_t space,
3647  legion_logical_partition_t handle,
3648  legion_logical_region_t parent,
3649  legion_field_id_t fid,
3650  const void *value,
3651  size_t value_size,
3652  legion_projection_id_t proj /* = 0 */,
3653  legion_predicate_t pred /* = legion_predicate_true() */,
3654  legion_mapper_id_t id /* = 0 */,
3655  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3656 
3662  legion_index_fill_launcher_t
3663  legion_index_fill_launcher_create_with_domain(
3664  legion_domain_t domain,
3665  legion_logical_partition_t handle,
3666  legion_logical_region_t parent,
3667  legion_field_id_t fid,
3668  const void *value,
3669  size_t value_size,
3670  legion_projection_id_t proj /* = 0 */,
3671  legion_predicate_t pred /* = legion_predicate_true() */,
3672  legion_mapper_id_t id /* = 0 */,
3673  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3674 
3680  legion_index_fill_launcher_t
3681  legion_index_fill_launcher_create_from_future_with_space(
3682  legion_index_space_t space,
3683  legion_logical_partition_t handle,
3684  legion_logical_region_t parent,
3685  legion_field_id_t fid,
3686  legion_future_t future,
3687  legion_projection_id_t proj /* = 0 */,
3688  legion_predicate_t pred /* = legion_predicate_true() */,
3689  legion_mapper_id_t id /* = 0 */,
3690  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3691 
3697  legion_index_fill_launcher_t
3698  legion_index_fill_launcher_create_from_future_with_domain(
3699  legion_domain_t domain,
3700  legion_logical_partition_t handle,
3701  legion_logical_region_t parent,
3702  legion_field_id_t fid,
3703  legion_future_t future,
3704  legion_projection_id_t proj /* = 0 */,
3705  legion_predicate_t pred /* = legion_predicate_true() */,
3706  legion_mapper_id_t id /* = 0 */,
3707  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3708 
3714  void
3715  legion_index_fill_launcher_destroy(legion_index_fill_launcher_t handle);
3716 
3720  void
3721  legion_index_fill_launcher_add_field(legion_fill_launcher_t handle,
3722  legion_field_id_t fid);
3723 
3727  void
3728  legion_index_fill_launcher_execute(legion_runtime_t runtime,
3729  legion_context_t ctx,
3730  legion_index_fill_launcher_t launcher);
3731 
3735  void legion_index_fill_launcher_set_sharding_space(legion_index_fill_launcher_t launcher,
3736  legion_index_space_t space);
3737 
3741  void
3742  legion_index_fill_launcher_set_mapper_arg(legion_index_fill_launcher_t launcher,
3743  legion_untyped_buffer_t arg);
3744 
3748  void
3749  legion_index_fill_launcher_set_provenance(legion_index_fill_launcher_t launcher,
3750  const char *provenance);
3751 
3757  legion_region_requirement_t
3758  legion_fill_get_requirement(legion_fill_t fill);
3759 
3760  // -----------------------------------------------------------------------
3761  // File Operations
3762  // -----------------------------------------------------------------------
3763 
3767  legion_field_map_t
3768  legion_field_map_create(void);
3769 
3773  void
3774  legion_field_map_destroy(legion_field_map_t handle);
3775 
3776  void
3777  legion_field_map_insert(legion_field_map_t handle,
3778  legion_field_id_t key,
3779  const char *value);
3780 
3786  legion_physical_region_t
3787  legion_runtime_attach_hdf5(
3788  legion_runtime_t runtime,
3789  legion_context_t ctx,
3790  const char *filename,
3791  legion_logical_region_t handle,
3792  legion_logical_region_t parent,
3793  legion_field_map_t field_map,
3794  legion_file_mode_t mode);
3795 
3799  void
3800  legion_runtime_detach_hdf5(
3801  legion_runtime_t runtime,
3802  legion_context_t ctx,
3803  legion_physical_region_t region);
3804 
3805  // -----------------------------------------------------------------------
3806  // Copy Operations
3807  // -----------------------------------------------------------------------
3808 
3814  legion_copy_launcher_t
3815  legion_copy_launcher_create(
3816  legion_predicate_t pred /* = legion_predicate_true() */,
3817  legion_mapper_id_t id /* = 0 */,
3818  legion_mapping_tag_id_t launcher_tag /* = 0 */);
3819 
3825  void
3826  legion_copy_launcher_destroy(legion_copy_launcher_t handle);
3827 
3833  void
3834  legion_copy_launcher_execute(legion_runtime_t runtime,
3835  legion_context_t ctx,
3836  legion_copy_launcher_t launcher);
3837 
3841  unsigned
3842  legion_copy_launcher_add_src_region_requirement_logical_region(
3843  legion_copy_launcher_t launcher,
3844  legion_logical_region_t handle,
3845  legion_privilege_mode_t priv,
3846  legion_coherence_property_t prop,
3847  legion_logical_region_t parent,
3848  legion_mapping_tag_id_t tag /* = 0 */,
3849  bool verified /* = false*/);
3850 
3854  unsigned
3855  legion_copy_launcher_add_dst_region_requirement_logical_region(
3856  legion_copy_launcher_t launcher,
3857  legion_logical_region_t handle,
3858  legion_privilege_mode_t priv,
3859  legion_coherence_property_t prop,
3860  legion_logical_region_t parent,
3861  legion_mapping_tag_id_t tag /* = 0 */,
3862  bool verified /* = false*/);
3863 
3867  unsigned
3868  legion_copy_launcher_add_dst_region_requirement_logical_region_reduction(
3869  legion_copy_launcher_t launcher,
3870  legion_logical_region_t handle,
3871  legion_reduction_op_id_t redop,
3872  legion_coherence_property_t prop,
3873  legion_logical_region_t parent,
3874  legion_mapping_tag_id_t tag /* = 0 */,
3875  bool verified /* = false*/);
3876 
3880  unsigned
3881  legion_copy_launcher_add_src_indirect_region_requirement_logical_region(
3882  legion_copy_launcher_t launcher,
3883  legion_logical_region_t handle,
3884  legion_field_id_t fid,
3885  legion_coherence_property_t prop,
3886  legion_logical_region_t parent,
3887  legion_mapping_tag_id_t tag /* = 0 */,
3888  bool is_range_indirection /* = false */,
3889  bool verified /* = false*/);
3890 
3894  unsigned
3895  legion_copy_launcher_add_dst_indirect_region_requirement_logical_region(
3896  legion_copy_launcher_t launcher,
3897  legion_logical_region_t handle,
3898  legion_field_id_t fid,
3899  legion_coherence_property_t prop,
3900  legion_logical_region_t parent,
3901  legion_mapping_tag_id_t tag /* = 0 */,
3902  bool is_range_indirection /* = false */,
3903  bool verified /* = false*/);
3904 
3908  void
3909  legion_copy_launcher_add_src_field(legion_copy_launcher_t launcher,
3910  unsigned idx,
3911  legion_field_id_t fid,
3912  bool inst /* = true */);
3913 
3917  void
3918  legion_copy_launcher_add_dst_field(legion_copy_launcher_t launcher,
3919  unsigned idx,
3920  legion_field_id_t fid,
3921  bool inst /* = true */);
3922 
3926  void
3927  legion_copy_launcher_add_wait_barrier(legion_copy_launcher_t launcher,
3928  legion_phase_barrier_t bar);
3929 
3933  void
3934  legion_copy_launcher_add_arrival_barrier(legion_copy_launcher_t launcher,
3935  legion_phase_barrier_t bar);
3936 
3940  void
3941  legion_copy_launcher_set_possible_src_indirect_out_of_range(
3942  legion_copy_launcher_t launcher, bool flag);
3943 
3947  void
3948  legion_copy_launcher_set_possible_dst_indirect_out_of_range(
3949  legion_copy_launcher_t launcher, bool flag);
3950 
3954  void
3955  legion_copy_launcher_set_point(legion_copy_launcher_t launcher,
3956  legion_domain_point_t point);
3957 
3961  void legion_copy_launcher_set_sharding_space(legion_copy_launcher_t launcher,
3962  legion_index_space_t space);
3963 
3967  void
3968  legion_copy_launcher_set_mapper_arg(legion_copy_launcher_t launcher,
3969  legion_untyped_buffer_t arg);
3970 
3974  void
3975  legion_copy_launcher_set_provenance(legion_copy_launcher_t launcher,
3976  const char *provenance);
3977 
3986  legion_region_requirement_t
3987  legion_copy_get_requirement(legion_copy_t copy, unsigned idx);
3988 
3989  // -----------------------------------------------------------------------
3990  // Index Copy Operations
3991  // -----------------------------------------------------------------------
3992 
3998  legion_index_copy_launcher_t
3999  legion_index_copy_launcher_create(
4000  legion_domain_t domain,
4001  legion_predicate_t pred /* = legion_predicate_true() */,
4002  legion_mapper_id_t id /* = 0 */,
4003  legion_mapping_tag_id_t launcher_tag /* = 0 */);
4004 
4010  void
4011  legion_index_copy_launcher_destroy(legion_index_copy_launcher_t handle);
4012 
4018  void
4019  legion_index_copy_launcher_execute(legion_runtime_t runtime,
4020  legion_context_t ctx,
4021  legion_index_copy_launcher_t launcher);
4022 
4026  unsigned
4027  legion_index_copy_launcher_add_src_region_requirement_logical_region(
4028  legion_index_copy_launcher_t launcher,
4029  legion_logical_region_t handle,
4030  legion_projection_id_t proj /* = 0 */,
4031  legion_privilege_mode_t priv,
4032  legion_coherence_property_t prop,
4033  legion_logical_region_t parent,
4034  legion_mapping_tag_id_t tag /* = 0 */,
4035  bool verified /* = false*/);
4036 
4040  unsigned
4041  legion_index_copy_launcher_add_dst_region_requirement_logical_region(
4042  legion_index_copy_launcher_t launcher,
4043  legion_logical_region_t handle,
4044  legion_projection_id_t proj /* = 0 */,
4045  legion_privilege_mode_t priv,
4046  legion_coherence_property_t prop,
4047  legion_logical_region_t parent,
4048  legion_mapping_tag_id_t tag /* = 0 */,
4049  bool verified /* = false*/);
4050 
4054  unsigned
4055  legion_index_copy_launcher_add_src_region_requirement_logical_partition(
4056  legion_index_copy_launcher_t launcher,
4057  legion_logical_partition_t handle,
4058  legion_projection_id_t proj /* = 0 */,
4059  legion_privilege_mode_t priv,
4060  legion_coherence_property_t prop,
4061  legion_logical_region_t parent,
4062  legion_mapping_tag_id_t tag /* = 0 */,
4063  bool verified /* = false*/);
4064 
4068  unsigned
4069  legion_index_copy_launcher_add_dst_region_requirement_logical_partition(
4070  legion_index_copy_launcher_t launcher,
4071  legion_logical_partition_t handle,
4072  legion_projection_id_t proj /* = 0 */,
4073  legion_privilege_mode_t priv,
4074  legion_coherence_property_t prop,
4075  legion_logical_region_t parent,
4076  legion_mapping_tag_id_t tag /* = 0 */,
4077  bool verified /* = false*/);
4078 
4082  unsigned
4083  legion_index_copy_launcher_add_dst_region_requirement_logical_region_reduction(
4084  legion_index_copy_launcher_t launcher,
4085  legion_logical_region_t handle,
4086  legion_projection_id_t proj /* = 0 */,
4087  legion_reduction_op_id_t redop,
4088  legion_coherence_property_t prop,
4089  legion_logical_region_t parent,
4090  legion_mapping_tag_id_t tag /* = 0 */,
4091  bool verified /* = false*/);
4092 
4096  unsigned
4097  legion_index_copy_launcher_add_dst_region_requirement_logical_partition_reduction(
4098  legion_index_copy_launcher_t launcher,
4099  legion_logical_partition_t handle,
4100  legion_projection_id_t proj /* = 0 */,
4101  legion_reduction_op_id_t redop,
4102  legion_coherence_property_t prop,
4103  legion_logical_region_t parent,
4104  legion_mapping_tag_id_t tag /* = 0 */,
4105  bool verified /* = false*/);
4106 
4110  unsigned
4111  legion_index_copy_launcher_add_src_indirect_region_requirement_logical_region(
4112  legion_index_copy_launcher_t launcher,
4113  legion_logical_region_t handle,
4114  legion_projection_id_t proj /* = 0 */,
4115  legion_field_id_t fid,
4116  legion_coherence_property_t prop,
4117  legion_logical_region_t parent,
4118  legion_mapping_tag_id_t tag /* = 0 */,
4119  bool is_range_indirection /* = false */,
4120  bool verified /* = false*/);
4121 
4125  unsigned
4126  legion_index_copy_launcher_add_dst_indirect_region_requirement_logical_region(
4127  legion_index_copy_launcher_t launcher,
4128  legion_logical_region_t handle,
4129  legion_projection_id_t proj /* = 0 */,
4130  legion_field_id_t fid,
4131  legion_coherence_property_t prop,
4132  legion_logical_region_t parent,
4133  legion_mapping_tag_id_t tag /* = 0 */,
4134  bool is_range_indirection /* = false */,
4135  bool verified /* = false*/);
4136 
4140  unsigned
4141  legion_index_copy_launcher_add_src_indirect_region_requirement_logical_partition(
4142  legion_index_copy_launcher_t launcher,
4143  legion_logical_partition_t handle,
4144  legion_projection_id_t proj /* = 0 */,
4145  legion_field_id_t fid,
4146  legion_coherence_property_t prop,
4147  legion_logical_region_t parent,
4148  legion_mapping_tag_id_t tag /* = 0 */,
4149  bool is_range_indirection /* = false */,
4150  bool verified /* = false*/);
4151 
4155  unsigned
4156  legion_index_copy_launcher_add_dst_indirect_region_requirement_logical_partition(
4157  legion_index_copy_launcher_t launcher,
4158  legion_logical_partition_t handle,
4159  legion_projection_id_t proj /* = 0 */,
4160  legion_field_id_t fid,
4161  legion_coherence_property_t prop,
4162  legion_logical_region_t parent,
4163  legion_mapping_tag_id_t tag /* = 0 */,
4164  bool is_range_indirection /* = false */,
4165  bool verified /* = false*/);
4166 
4170  void
4171  legion_index_copy_launcher_add_src_field(legion_index_copy_launcher_t launcher,
4172  unsigned idx,
4173  legion_field_id_t fid,
4174  bool inst /* = true */);
4175 
4179  void
4180  legion_index_copy_launcher_add_dst_field(legion_index_copy_launcher_t launcher,
4181  unsigned idx,
4182  legion_field_id_t fid,
4183  bool inst /* = true */);
4184 
4188  void
4189  legion_index_copy_launcher_add_wait_barrier(legion_index_copy_launcher_t launcher,
4190  legion_phase_barrier_t bar);
4191 
4195  void
4196  legion_index_copy_launcher_add_arrival_barrier(legion_index_copy_launcher_t launcher,
4197  legion_phase_barrier_t bar);
4198 
4202  void
4203  legion_index_copy_launcher_set_possible_src_indirect_out_of_range(
4204  legion_index_copy_launcher_t launcher, bool flag);
4205 
4209  void
4210  legion_index_copy_launcher_set_possible_dst_indirect_out_of_range(
4211  legion_index_copy_launcher_t launcher, bool flag);
4212 
4216  void
4217  legion_index_copy_launcher_set_sharding_space(legion_index_copy_launcher_t launcher,
4218  legion_index_space_t is);
4219 
4223  void
4224  legion_index_copy_launcher_set_mapper_arg(legion_index_copy_launcher_t launcher,
4225  legion_untyped_buffer_t arg);
4226 
4230  void
4231  legion_index_copy_launcher_set_provenance(legion_index_copy_launcher_t launcher,
4232  const char *provenance);
4233 
4234  // -----------------------------------------------------------------------
4235  // Acquire Operations
4236  // -----------------------------------------------------------------------
4237 
4243  legion_acquire_launcher_t
4244  legion_acquire_launcher_create(
4245  legion_logical_region_t logical_region,
4246  legion_logical_region_t parent_region,
4247  legion_predicate_t pred /* = legion_predicate_true() */,
4248  legion_mapper_id_t id /* = 0 */,
4249  legion_mapping_tag_id_t tag /* = 0 */);
4250 
4256  void
4257  legion_acquire_launcher_destroy(legion_acquire_launcher_t handle);
4258 
4264  void
4265  legion_acquire_launcher_execute(legion_runtime_t runtime,
4266  legion_context_t ctx,
4267  legion_acquire_launcher_t launcher);
4268 
4272  void
4273  legion_acquire_launcher_add_field(legion_acquire_launcher_t launcher,
4274  legion_field_id_t fid);
4275 
4279  void
4280  legion_acquire_launcher_add_wait_barrier(legion_acquire_launcher_t launcher,
4281  legion_phase_barrier_t bar);
4282 
4286  void
4287  legion_acquire_launcher_add_arrival_barrier(
4288  legion_acquire_launcher_t launcher,
4289  legion_phase_barrier_t bar);
4290 
4294  void
4295  legion_acquire_launcher_set_sharding_space(legion_acquire_launcher_t launcher,
4296  legion_index_space_t space);
4297 
4301  void
4302  legion_acquire_launcher_set_mapper_arg(legion_acquire_launcher_t launcher,
4303  legion_untyped_buffer_t arg);
4304 
4308  void
4309  legion_acquire_launcher_set_provenance(legion_acquire_launcher_t launcher,
4310  const char *provenance);
4311 
4312  // -----------------------------------------------------------------------
4313  // Release Operations
4314  // -----------------------------------------------------------------------
4315 
4321  legion_release_launcher_t
4322  legion_release_launcher_create(
4323  legion_logical_region_t logical_region,
4324  legion_logical_region_t parent_region,
4325  legion_predicate_t pred /* = legion_predicate_true() */,
4326  legion_mapper_id_t id /* = 0 */,
4327  legion_mapping_tag_id_t tag /* = 0 */);
4328 
4334  void
4335  legion_release_launcher_destroy(legion_release_launcher_t handle);
4336 
4342  void
4343  legion_release_launcher_execute(legion_runtime_t runtime,
4344  legion_context_t ctx,
4345  legion_release_launcher_t launcher);
4346 
4350  void
4351  legion_release_launcher_add_field(legion_release_launcher_t launcher,
4352  legion_field_id_t fid);
4353 
4357  void
4358  legion_release_launcher_add_wait_barrier(legion_release_launcher_t launcher,
4359  legion_phase_barrier_t bar);
4360 
4364  void
4365  legion_release_launcher_add_arrival_barrier(
4366  legion_release_launcher_t launcher,
4367  legion_phase_barrier_t bar);
4368 
4372  void
4373  legion_release_launcher_set_sharding_space(legion_release_launcher_t launcher,
4374  legion_index_space_t space);
4375 
4379  void
4380  legion_release_launcher_set_mapper_arg(legion_release_launcher_t launcher,
4381  legion_untyped_buffer_t arg);
4382 
4386  void
4387  legion_release_launcher_set_provenance(legion_release_launcher_t launcher,
4388  const char *provenance);
4389 
4390  // -----------------------------------------------------------------------
4391  // Attach/Detach Operations
4392  // -----------------------------------------------------------------------
4393 
4399  legion_attach_launcher_t
4400  legion_attach_launcher_create(
4401  legion_logical_region_t logical_region,
4402  legion_logical_region_t parent_region,
4403  legion_external_resource_t resource);
4404 
4408  void
4409  legion_attach_launcher_attach_hdf5(legion_attach_launcher_t handle,
4410  const char *filename,
4411  legion_field_map_t field_map,
4412  legion_file_mode_t mode);
4413 
4417  void
4418  legion_attach_launcher_set_restricted(legion_attach_launcher_t handle,
4419  bool restricted);
4420 
4424  void
4425  legion_attach_launcher_set_mapped(legion_attach_launcher_t handle,
4426  bool mapped);
4427 
4431  void
4432  legion_attach_launcher_set_provenance(legion_attach_launcher_t handle,
4433  const char *provenance);
4434 
4440  void
4441  legion_attach_launcher_destroy(legion_attach_launcher_t handle);
4442 
4448  legion_physical_region_t
4449  legion_attach_launcher_execute(legion_runtime_t runtime,
4450  legion_context_t ctx,
4451  legion_attach_launcher_t launcher);
4452 
4456  void
4457  legion_attach_launcher_add_cpu_soa_field(legion_attach_launcher_t launcher,
4458  legion_field_id_t fid,
4459  void *base_ptr,
4460  bool column_major);
4461 
4467  legion_future_t
4468  legion_detach_external_resource(legion_runtime_t runtime,
4469  legion_context_t ctx,
4470  legion_physical_region_t handle);
4471 
4477  legion_future_t
4478  legion_flush_detach_external_resource(legion_runtime_t runtime,
4479  legion_context_t ctx,
4480  legion_physical_region_t handle,
4481  bool flush);
4482 
4488  legion_future_t
4489  legion_unordered_detach_external_resource(legion_runtime_t runtime,
4490  legion_context_t ctx,
4491  legion_physical_region_t handle,
4492  bool flush,
4493  bool unordered);
4494 
4498  void
4499  legion_context_progress_unordered_operations(legion_runtime_t runtime,
4500  legion_context_t ctx);
4501 
4502  // -----------------------------------------------------------------------
4503  // Index Attach/Detach Operations
4504  // -----------------------------------------------------------------------
4505 
4511  legion_index_attach_launcher_t
4512  legion_index_attach_launcher_create(
4513  legion_logical_region_t parent_region,
4514  legion_external_resource_t resource,
4515  bool restricted/*=true*/);
4516 
4520  void
4521  legion_index_attach_launcher_set_restricted(
4522  legion_index_attach_launcher_t handle, bool restricted);
4523 
4527  void
4528  legion_index_attach_launcher_set_provenance(
4529  legion_index_attach_launcher_t handle, const char *provenance);
4530 
4534  void
4535  legion_index_attach_launcher_set_deduplicate_across_shards(
4536  legion_index_attach_launcher_t handle, bool deduplicate);
4537 
4541  void
4542  legion_index_attach_launcher_attach_file(legion_index_attach_launcher_t handle,
4543  legion_logical_region_t region,
4544  const char *filename,
4545  const legion_field_id_t *fields,
4546  size_t num_fields,
4547  legion_file_mode_t mode);
4548 
4552  void
4553  legion_index_attach_launcher_attach_hdf5(legion_index_attach_launcher_t handle,
4554  legion_logical_region_t region,
4555  const char *filename,
4556  legion_field_map_t field_map,
4557  legion_file_mode_t mode);
4558 
4562  void
4563  legion_index_attach_launcher_attach_array_soa(legion_index_attach_launcher_t handle,
4564  legion_logical_region_t region,
4565  void *base_ptr, bool column_major,
4566  const legion_field_id_t *fields,
4567  size_t num_fields,
4568  legion_memory_t memory);
4569 
4573  void
4574  legion_index_attach_launcher_attach_array_aos(legion_index_attach_launcher_t handle,
4575  legion_logical_region_t region,
4576  void *base_ptr, bool column_major,
4577  const legion_field_id_t *fields,
4578  size_t num_fields,
4579  legion_memory_t memory);
4580 
4586  void
4587  legion_index_attach_launcher_destroy(legion_index_attach_launcher_t handle);
4588 
4594  legion_external_resources_t
4595  legion_attach_external_resources(legion_runtime_t runtime,
4596  legion_context_t ctx,
4597  legion_index_attach_launcher_t launcher);
4598 
4604  legion_future_t
4605  legion_detach_external_resources(legion_runtime_t runtime,
4606  legion_context_t ctx,
4607  legion_external_resources_t,
4608  bool flush, bool unordered);
4609 
4610  // -----------------------------------------------------------------------
4611  // Must Epoch Operations
4612  // -----------------------------------------------------------------------
4613 
4619  legion_must_epoch_launcher_t
4620  legion_must_epoch_launcher_create(
4621  legion_mapper_id_t id /* = 0 */,
4622  legion_mapping_tag_id_t launcher_tag /* = 0 */);
4623 
4629  void
4630  legion_must_epoch_launcher_destroy(legion_must_epoch_launcher_t handle);
4631 
4637  legion_future_map_t
4638  legion_must_epoch_launcher_execute(legion_runtime_t runtime,
4639  legion_context_t ctx,
4640  legion_must_epoch_launcher_t launcher);
4641 
4647  void
4648  legion_must_epoch_launcher_add_single_task(
4649  legion_must_epoch_launcher_t launcher,
4650  legion_domain_point_t point,
4651  legion_task_launcher_t handle);
4652 
4658  void
4659  legion_must_epoch_launcher_add_index_task(
4660  legion_must_epoch_launcher_t launcher,
4661  legion_index_launcher_t handle);
4662 
4666  void
4667  legion_must_epoch_launcher_set_launch_domain(
4668  legion_must_epoch_launcher_t launcher,
4669  legion_domain_t domain);
4670 
4674  void
4675  legion_must_epoch_launcher_set_launch_space(
4676  legion_must_epoch_launcher_t launcher,
4677  legion_index_space_t is);
4678 
4682  void
4683  legion_must_epoch_launcher_set_provenance(
4684  legion_must_epoch_launcher_t launcher, const char *provenance);
4685 
4686  // -----------------------------------------------------------------------
4687  // Fence Operations
4688  // -----------------------------------------------------------------------
4689 
4693  legion_future_t
4694  legion_runtime_issue_mapping_fence(legion_runtime_t runtime,
4695  legion_context_t ctx);
4696 
4700  legion_future_t
4701  legion_runtime_issue_execution_fence(legion_runtime_t runtime,
4702  legion_context_t ctx);
4703 
4704  // -----------------------------------------------------------------------
4705  // Tracing Operations
4706  // -----------------------------------------------------------------------
4707 
4711  void
4712  legion_runtime_begin_trace(legion_runtime_t runtime,
4713  legion_context_t ctx,
4714  legion_trace_id_t tid,
4715  bool logical_only);
4716 
4720  void
4721  legion_runtime_end_trace(legion_runtime_t runtime,
4722  legion_context_t ctx,
4723  legion_trace_id_t tid);
4724 
4725  // -----------------------------------------------------------------------
4726  // Frame Operations
4727  // -----------------------------------------------------------------------
4728 
4729  void
4730  legion_runtime_complete_frame(legion_runtime_t runtime,
4731  legion_context_t ctx);
4732 
4733  // -----------------------------------------------------------------------
4734  // Tunable Variables
4735  // -----------------------------------------------------------------------
4736 
4742  legion_future_t
4743  legion_runtime_select_tunable_value(legion_runtime_t runtime,
4744  legion_context_t ctx,
4745  legion_tunable_id_t tid,
4746  legion_mapper_id_t mapper /* = 0 */,
4747  legion_mapping_tag_id_t tag /* = 0 */);
4748 
4749  // -----------------------------------------------------------------------
4750  // Miscellaneous Operations
4751  // -----------------------------------------------------------------------
4752 
4756  bool
4757  legion_runtime_has_runtime(void);
4758 
4762  legion_runtime_t
4763  legion_runtime_get_runtime(void);
4764 
4768  bool
4769  legion_runtime_has_context(void);
4770 
4776  legion_context_t
4777  legion_runtime_get_context(void);
4778 
4784  void
4785  legion_context_destroy(legion_context_t);
4786 
4790  legion_processor_t
4791  legion_runtime_get_executing_processor(legion_runtime_t runtime,
4792  legion_context_t ctx);
4793 
4797  void
4798  legion_runtime_yield(legion_runtime_t runtime, legion_context_t ctx);
4799 
4803  legion_shard_id_t
4804  legion_runtime_local_shard(legion_runtime_t runtime, legion_context_t ctx);
4805 
4809  size_t
4810  legion_runtime_total_shards(legion_runtime_t runtime, legion_context_t ctx);
4811 
4812  void
4813  legion_runtime_enable_scheduler_lock(void);
4814 
4815  void
4816  legion_runtime_disable_scheduler_lock(void);
4817 
4821  void
4822  legion_runtime_print_once(legion_runtime_t runtime,
4823  legion_context_t ctx,
4824  FILE *f,
4825  const char *message);
4829  void
4830  legion_runtime_print_once_fd(legion_runtime_t runtime,
4831  legion_context_t ctx,
4832  int fd, const char *mode,
4833  const char *message);
4834 
4835  // -----------------------------------------------------------------------
4836  // Physical Data Operations
4837  // -----------------------------------------------------------------------
4838 
4844  void
4845  legion_physical_region_destroy(legion_physical_region_t handle);
4846 
4852  legion_physical_region_t
4853  legion_physical_region_copy(legion_physical_region_t handle);
4854 
4858  bool
4859  legion_physical_region_is_mapped(legion_physical_region_t handle);
4860 
4864  void
4865  legion_physical_region_wait_until_valid(legion_physical_region_t handle);
4866 
4870  bool
4871  legion_physical_region_is_valid(legion_physical_region_t handle);
4872 
4876  legion_logical_region_t
4877  legion_physical_region_get_logical_region(legion_physical_region_t handle);
4878 
4882  size_t
4883  legion_physical_region_get_field_count(legion_physical_region_t handle);
4884  legion_field_id_t
4885  legion_physical_region_get_field_id(legion_physical_region_t handle, size_t index);
4886 
4890  size_t
4891  legion_physical_region_get_memory_count(legion_physical_region_t handle);
4892  legion_memory_t
4893  legion_physical_region_get_memory(legion_physical_region_t handle, size_t index);
4894 
4900 #define ACCESSOR_ARRAY(DIM) \
4901  legion_accessor_array_##DIM##d_t \
4902  legion_physical_region_get_field_accessor_array_##DIM##d( \
4903  legion_physical_region_t handle, \
4904  legion_field_id_t fid);
4905  LEGION_FOREACH_N(ACCESSOR_ARRAY)
4906 #undef ACCESSOR_ARRAY
4907 
4908 #define ACCESSOR_ARRAY(DIM) \
4909  legion_accessor_array_##DIM##d_t \
4910  legion_physical_region_get_field_accessor_array_##DIM##d_with_transform( \
4911  legion_physical_region_t handle, \
4912  legion_field_id_t fid, \
4913  legion_domain_affine_transform_t transform);
4914  LEGION_FOREACH_N(ACCESSOR_ARRAY)
4915 #undef ACCESSOR_ARRAY
4916 
4917 #define RAW_PTR(DIM) \
4918  void * \
4919  legion_accessor_array_##DIM##d_raw_rect_ptr(legion_accessor_array_##DIM##d_t handle, \
4920  legion_rect_##DIM##d_t rect, \
4921  legion_rect_##DIM##d_t *subrect, \
4922  legion_byte_offset_t *offsets);
4923  LEGION_FOREACH_N(RAW_PTR)
4924 #undef RAW_PTR
4925 
4926  // Read
4927  void
4928  legion_accessor_array_1d_read(legion_accessor_array_1d_t handle,
4929  legion_ptr_t ptr,
4930  void *dst, size_t bytes);
4931 
4932 #define READ_ARRAY(DIM) \
4933  void \
4934  legion_accessor_array_##DIM##d_read_point(legion_accessor_array_##DIM##d_t handle, \
4935  legion_point_##DIM##d_t point, \
4936  void *dst, size_t bytes);
4937  LEGION_FOREACH_N(READ_ARRAY)
4938 #undef READ_ARRAY
4939 
4940  // Write
4941  void
4942  legion_accessor_array_1d_write(legion_accessor_array_1d_t handle,
4943  legion_ptr_t ptr,
4944  const void *src, size_t bytes);
4945 
4946 #define WRITE_ARRAY(DIM) \
4947  void \
4948  legion_accessor_array_##DIM##d_write_point(legion_accessor_array_##DIM##d_t handle, \
4949  legion_point_##DIM##d_t point, \
4950  const void *src, size_t bytes);
4951  LEGION_FOREACH_N(WRITE_ARRAY)
4952 #undef WRITE_ARRAY
4953 
4954  // Ref
4955  void *
4956  legion_accessor_array_1d_ref(legion_accessor_array_1d_t handle,
4957  legion_ptr_t ptr);
4958 
4959 #define REF_ARRAY(DIM) \
4960  void * \
4961  legion_accessor_array_##DIM##d_ref_point(legion_accessor_array_##DIM##d_t handle, \
4962  legion_point_##DIM##d_t point);
4963  LEGION_FOREACH_N(REF_ARRAY)
4964 #undef REF_ARRAY
4965 
4969 #define DESTROY_ARRAY(DIM) \
4970  void \
4971  legion_accessor_array_##DIM##d_destroy(legion_accessor_array_##DIM##d_t handle);
4972  LEGION_FOREACH_N(DESTROY_ARRAY)
4973 #undef DESTROY_ARRAY
4974 
4975  // -----------------------------------------------------------------------
4976  // External Resource Operations
4977  // -----------------------------------------------------------------------
4978 
4982  void
4983  legion_external_resources_destroy(legion_external_resources_t handle);
4984 
4988  size_t
4989  legion_external_resources_size(legion_external_resources_t handle);
4990 
4996  legion_physical_region_t
4997  legion_external_resources_get_region(legion_external_resources_t handle,
4998  unsigned index);
4999 
5000  // -----------------------------------------------------------------------
5001  // Mappable Operations
5002  // -----------------------------------------------------------------------
5003 
5007  enum legion_mappable_type_id_t
5008  legion_mappable_get_type(legion_mappable_t mappable);
5009 
5013  legion_task_t
5014  legion_mappable_as_task(legion_mappable_t mappable);
5015 
5019  legion_copy_t
5020  legion_mappable_as_copy(legion_mappable_t mappable);
5021 
5025  legion_fill_t
5026  legion_mappable_as_fill(legion_mappable_t mappable);
5027 
5031  legion_inline_t
5032  legion_mappable_as_inline_mapping(legion_mappable_t mappable);
5033 
5034 
5035  // -----------------------------------------------------------------------
5036  // Task Operations
5037  // -----------------------------------------------------------------------
5038 
5042  legion_unique_id_t
5043  legion_context_get_unique_id(legion_context_t ctx);
5044 
5055  legion_task_mut_t
5056  legion_task_create_empty();
5057 
5063  void
5064  legion_task_destroy(legion_task_mut_t handle);
5065 
5071  legion_task_t
5072  legion_task_mut_as_task(legion_task_mut_t task);
5073 
5077  legion_unique_id_t
5078  legion_task_get_unique_id(legion_task_t task);
5079 
5083  int
5084  legion_task_get_depth(legion_task_t task);
5085 
5089  legion_mapper_id_t
5090  legion_task_get_mapper(legion_task_t task);
5091 
5095  legion_mapping_tag_id_t
5096  legion_task_get_tag(legion_task_t task);
5097 
5101  void
5102  legion_task_id_attach_semantic_information(legion_runtime_t runtime,
5103  legion_task_id_t task_id,
5104  legion_semantic_tag_t tag,
5105  const void *buffer,
5106  size_t size,
5107  bool is_mutable /* = false */);
5108 
5112  bool
5113  legion_task_id_retrieve_semantic_information(
5114  legion_runtime_t runtime,
5115  legion_task_id_t task_id,
5116  legion_semantic_tag_t tag,
5117  const void **result,
5118  size_t *size,
5119  bool can_fail /* = false */,
5120  bool wait_until_ready /* = false */);
5121 
5125  void
5126  legion_task_id_attach_name(legion_runtime_t runtime,
5127  legion_task_id_t task_id,
5128  const char *name,
5129  bool is_mutable /* = false */);
5130 
5134  void
5135  legion_task_id_retrieve_name(legion_runtime_t runtime,
5136  legion_task_id_t task_id,
5137  const char **result);
5138 
5142  void *
5143  legion_task_get_args(legion_task_t task);
5144 
5148  void
5149  legion_task_set_args(legion_task_mut_t task, void *args);
5150 
5154  size_t
5155  legion_task_get_arglen(legion_task_t task);
5156 
5160  void
5161  legion_task_set_arglen(legion_task_mut_t task, size_t arglen);
5162 
5166  legion_domain_t
5167  legion_task_get_index_domain(legion_task_t task);
5168 
5172  legion_domain_point_t
5173  legion_task_get_index_point(legion_task_t task);
5174 
5178  bool
5179  legion_task_get_is_index_space(legion_task_t task);
5180 
5184  void *
5185  legion_task_get_local_args(legion_task_t task);
5186 
5190  size_t
5191  legion_task_get_local_arglen(legion_task_t task);
5192 
5196  unsigned
5197  legion_task_get_regions_size(legion_task_t task);
5198 
5204  legion_region_requirement_t
5205  legion_task_get_requirement(legion_task_t task, unsigned idx);
5206 
5210  unsigned
5211  legion_task_get_futures_size(legion_task_t task);
5212 
5216  legion_future_t
5217  legion_task_get_future(legion_task_t task, unsigned idx);
5218 
5222  void
5223  legion_task_add_future(legion_task_mut_t task, legion_future_t future);
5224 
5228  legion_task_id_t
5229  legion_task_get_task_id(legion_task_t task);
5230 
5234  legion_processor_t
5235  legion_task_get_target_proc(legion_task_t task);
5236 
5240  const char *
5241  legion_task_get_name(legion_task_t task);
5242 
5243  // -----------------------------------------------------------------------
5244  // Inline Operations
5245  // -----------------------------------------------------------------------
5246 
5252  legion_region_requirement_t
5253  legion_inline_get_requirement(legion_inline_t inline_operation);
5254 
5255  // -----------------------------------------------------------------------
5256  // Execution Constraints
5257  // -----------------------------------------------------------------------
5258 
5264  legion_execution_constraint_set_t
5265  legion_execution_constraint_set_create(void);
5266 
5272  void
5273  legion_execution_constraint_set_destroy(
5274  legion_execution_constraint_set_t handle);
5275 
5279  void
5280  legion_execution_constraint_set_add_isa_constraint(
5281  legion_execution_constraint_set_t handle,
5282  uint64_t prop);
5283 
5288  void
5289  legion_execution_constraint_set_add_processor_constraint(
5290  legion_execution_constraint_set_t handle,
5291  legion_processor_kind_t proc_kind);
5292 
5297  void
5298  legion_execution_constraint_set_add_resource_constraint(
5299  legion_execution_constraint_set_t handle,
5300  legion_resource_constraint_t resource,
5301  legion_equality_kind_t eq,
5302  size_t value);
5303 
5308  void
5309  legion_execution_constraint_set_add_launch_constraint(
5310  legion_execution_constraint_set_t handle,
5311  legion_launch_constraint_t kind,
5312  size_t value);
5313 
5318  void
5319  legion_execution_constraint_set_add_launch_constraint_multi_dim(
5320  legion_execution_constraint_set_t handle,
5321  legion_launch_constraint_t kind,
5322  const size_t *values,
5323  int dims);
5324 
5329  void
5330  legion_execution_constraint_set_add_colocation_constraint(
5331  legion_execution_constraint_set_t handle,
5332  const unsigned *indexes,
5333  size_t num_indexes,
5334  const legion_field_id_t *fields,
5335  size_t num_fields);
5336 
5337  // -----------------------------------------------------------------------
5338  // Layout Constraints
5339  // -----------------------------------------------------------------------
5340 
5346  legion_layout_constraint_set_t
5347  legion_layout_constraint_set_create(void);
5348 
5354  void
5355  legion_layout_constraint_set_destroy(legion_layout_constraint_set_t handle);
5356 
5362  legion_layout_constraint_id_t
5363  legion_layout_constraint_set_register(
5364  legion_runtime_t runtime,
5365  legion_field_space_t fspace,
5366  legion_layout_constraint_set_t handle,
5367  const char *layout_name /* = NULL */);
5368 
5374  legion_layout_constraint_id_t
5375  legion_layout_constraint_set_preregister(
5376  legion_layout_constraint_set_t handle,
5377  const char *layout_name /* = NULL */);
5378 
5384  void
5385  legion_layout_constraint_set_release(legion_runtime_t runtime,
5386  legion_layout_constraint_id_t handle);
5387 
5392  void
5393  legion_layout_constraint_set_add_specialized_constraint(
5394  legion_layout_constraint_set_t handle,
5395  legion_specialized_constraint_t specialized,
5396  legion_reduction_op_id_t redop);
5397 
5402  void
5403  legion_layout_constraint_set_add_memory_constraint(
5404  legion_layout_constraint_set_t handle,
5405  legion_memory_kind_t kind);
5406 
5411  void
5412  legion_layout_constraint_set_add_field_constraint(
5413  legion_layout_constraint_set_t handle,
5414  const legion_field_id_t *fields,
5415  size_t num_fields,
5416  bool contiguous,
5417  bool inorder);
5418 
5423  void
5424  legion_layout_constraint_set_add_ordering_constraint(
5425  legion_layout_constraint_set_t handle,
5426  const legion_dimension_kind_t *dims,
5427  size_t num_dims,
5428  bool contiguous);
5429 
5434  void
5435  legion_layout_constraint_set_add_splitting_constraint(
5436  legion_layout_constraint_set_t handle,
5437  legion_dimension_kind_t dim);
5438 
5443  void
5444  legion_layout_constraint_set_add_full_splitting_constraint(
5445  legion_layout_constraint_set_t handle,
5446  legion_dimension_kind_t dim,
5447  size_t value);
5448 
5453  void
5454  legion_layout_constraint_set_add_dimension_constraint(
5455  legion_layout_constraint_set_t handle,
5456  legion_dimension_kind_t dim,
5457  legion_equality_kind_t eq,
5458  size_t value);
5459 
5464  void
5465  legion_layout_constraint_set_add_alignment_constraint(
5466  legion_layout_constraint_set_t handle,
5467  legion_field_id_t field,
5468  legion_equality_kind_t eq,
5469  size_t byte_boundary);
5470 
5475  void
5476  legion_layout_constraint_set_add_offset_constraint(
5477  legion_layout_constraint_set_t handle,
5478  legion_field_id_t field,
5479  size_t offset);
5480 
5485  void
5486  legion_layout_constraint_set_add_pointer_constraint(
5487  legion_layout_constraint_set_t handle,
5488  legion_memory_t memory,
5489  uintptr_t ptr);
5490 
5491  // -----------------------------------------------------------------------
5492  // Task Layout Constraints
5493  // -----------------------------------------------------------------------
5494 
5500  legion_task_layout_constraint_set_t
5501  legion_task_layout_constraint_set_create(void);
5502 
5508  void
5509  legion_task_layout_constraint_set_destroy(
5510  legion_task_layout_constraint_set_t handle);
5511 
5515  void
5516  legion_task_layout_constraint_set_add_layout_constraint(
5517  legion_task_layout_constraint_set_t handle,
5518  unsigned idx,
5519  legion_layout_constraint_id_t layout);
5520 
5521  // -----------------------------------------------------------------------
5522  // Start-up Operations
5523  // -----------------------------------------------------------------------
5524 
5528  void
5529  legion_runtime_initialize(int *argc,
5530  char ***argv,
5531  bool filter /* = false */);
5532 
5536  int
5537  legion_runtime_start(int argc,
5538  char **argv,
5539  bool background /* = false */);
5540 
5544  int
5545  legion_runtime_wait_for_shutdown(void);
5546 
5550  void
5551  legion_runtime_set_return_code(int return_code);
5552 
5556  void
5557  legion_runtime_set_top_level_task_id(legion_task_id_t top_id);
5558 
5562  size_t
5563  legion_runtime_get_maximum_dimension(void);
5564 
5568  const legion_input_args_t
5569  legion_runtime_get_input_args(void);
5570 
5574  void
5575  legion_runtime_add_registration_callback(
5576  legion_registration_callback_pointer_t callback);
5577 
5581  legion_mapper_id_t
5582  legion_runtime_generate_library_mapper_ids(
5583  legion_runtime_t runtime,
5584  const char *library_name,
5585  size_t count);
5586 
5590  void
5591  legion_runtime_replace_default_mapper(
5592  legion_runtime_t runtime,
5593  legion_mapper_t mapper,
5594  legion_processor_t proc);
5595 
5599  legion_projection_id_t
5600  legion_runtime_generate_static_projection_id();
5601 
5605  legion_projection_id_t
5606  legion_runtime_generate_library_projection_ids(
5607  legion_runtime_t runtime,
5608  const char *library_name,
5609  size_t count);
5610 
5614  legion_sharding_id_t
5615  legion_runtime_generate_library_sharding_ids(
5616  legion_runtime_t runtime,
5617  const char *library_name,
5618  size_t count);
5619 
5623  legion_reduction_op_id_t
5624  legion_runtime_generate_library_reduction_ids(
5625  legion_runtime_t runtime,
5626  const char *library_name,
5627  size_t count);
5628 
5632  void
5633  legion_runtime_preregister_projection_functor(
5634  legion_projection_id_t id,
5635  bool exclusive,
5636  unsigned depth,
5637  legion_projection_functor_logical_region_t region_functor,
5638  legion_projection_functor_logical_partition_t partition_functor);
5639 
5643  void
5644  legion_runtime_preregister_projection_functor_mappable(
5645  legion_projection_id_t id,
5646  bool exclusive,
5647  unsigned depth,
5648  legion_projection_functor_logical_region_mappable_t region_functor,
5649  legion_projection_functor_logical_partition_mappable_t partition_functor);
5650 
5654  void
5655  legion_runtime_register_projection_functor(
5656  legion_runtime_t runtime,
5657  legion_projection_id_t id,
5658  bool exclusive,
5659  unsigned depth,
5660  legion_projection_functor_logical_region_t region_functor,
5661  legion_projection_functor_logical_partition_t partition_functor);
5662 
5666  void
5667  legion_runtime_register_projection_functor_mappable(
5668  legion_runtime_t runtime,
5669  legion_projection_id_t id,
5670  bool exclusive,
5671  unsigned depth,
5672  legion_projection_functor_logical_region_mappable_t region_functor,
5673  legion_projection_functor_logical_partition_mappable_t partition_functor);
5674 
5678  legion_task_id_t
5679  legion_runtime_generate_library_task_ids(
5680  legion_runtime_t runtime,
5681  const char *library_name,
5682  size_t count);
5683 
5687  legion_task_id_t
5688  legion_runtime_register_task_variant_fnptr(
5689  legion_runtime_t runtime,
5690  legion_task_id_t id /* = AUTO_GENERATE_ID */,
5691  const char *task_name /* = NULL*/,
5692  const char *variant_name /* = NULL*/,
5693  bool global,
5694  legion_execution_constraint_set_t execution_constraints,
5695  legion_task_layout_constraint_set_t layout_constraints,
5696  legion_task_config_options_t options,
5697  legion_task_pointer_wrapped_t wrapped_task_pointer,
5698  const void *userdata,
5699  size_t userlen);
5700 
5704  legion_task_id_t
5705  legion_runtime_preregister_task_variant_fnptr(
5706  legion_task_id_t id /* = AUTO_GENERATE_ID */,
5707  legion_variant_id_t variant_id /* = AUTO_GENERATE_ID */,
5708  const char *task_name /* = NULL*/,
5709  const char *variant_name /* = NULL*/,
5710  legion_execution_constraint_set_t execution_constraints,
5711  legion_task_layout_constraint_set_t layout_constraints,
5712  legion_task_config_options_t options,
5713  legion_task_pointer_wrapped_t wrapped_task_pointer,
5714  const void *userdata,
5715  size_t userlen);
5716 
5717 #ifdef REALM_USE_LLVM
5718 
5721  legion_task_id_t
5722  legion_runtime_register_task_variant_llvmir(
5723  legion_runtime_t runtime,
5724  legion_task_id_t id /* = AUTO_GENERATE_ID */,
5725  const char *task_name /* = NULL*/,
5726  bool global,
5727  legion_execution_constraint_set_t execution_constraints,
5728  legion_task_layout_constraint_set_t layout_constraints,
5729  legion_task_config_options_t options,
5730  const char *llvmir,
5731  const char *entry_symbol,
5732  const void *userdata,
5733  size_t userlen);
5734 
5738  legion_task_id_t
5739  legion_runtime_preregister_task_variant_llvmir(
5740  legion_task_id_t id /* = AUTO_GENERATE_ID */,
5741  legion_variant_id_t variant_id /* = AUTO_GENERATE_ID */,
5742  const char *task_name /* = NULL*/,
5743  legion_execution_constraint_set_t execution_constraints,
5744  legion_task_layout_constraint_set_t layout_constraints,
5745  legion_task_config_options_t options,
5746  const char *llvmir,
5747  const char *entry_symbol,
5748  const void *userdata,
5749  size_t userlen);
5750 #endif
5751 
5752 #ifdef REALM_USE_PYTHON
5753 
5756  legion_task_id_t
5757  legion_runtime_register_task_variant_python_source(
5758  legion_runtime_t runtime,
5759  legion_task_id_t id /* = AUTO_GENERATE_ID */,
5760  const char *task_name /* = NULL*/,
5761  bool global,
5762  legion_execution_constraint_set_t execution_constraints,
5763  legion_task_layout_constraint_set_t layout_constraints,
5764  legion_task_config_options_t options,
5765  const char *module_name,
5766  const char *function_name,
5767  const void *userdata,
5768  size_t userlen);
5769 
5773  legion_task_id_t
5774  legion_runtime_register_task_variant_python_source_qualname(
5775  legion_runtime_t runtime,
5776  legion_task_id_t id /* = AUTO_GENERATE_ID */,
5777  const char *task_name /* = NULL*/,
5778  bool global,
5779  legion_execution_constraint_set_t execution_constraints,
5780  legion_task_layout_constraint_set_t layout_constraints,
5781  legion_task_config_options_t options,
5782  const char *module_name,
5783  const char **function_qualname,
5784  size_t function_qualname_len,
5785  const void *userdata,
5786  size_t userlen);
5787 #endif
5788 
5792  void
5793  legion_task_preamble(
5794  const void *data,
5795  size_t datalen,
5796  realm_id_t proc_id,
5797  legion_task_t *taskptr,
5798  const legion_physical_region_t **regionptr,
5799  unsigned * num_regions_ptr,
5800  legion_context_t * ctxptr,
5801  legion_runtime_t * runtimeptr);
5802 
5806  void
5807  legion_task_postamble(
5808  legion_runtime_t runtime,
5809  legion_context_t ctx,
5810  const void *retval,
5811  size_t retsize);
5812 
5813  // -----------------------------------------------------------------------
5814  // Timing Operations
5815  // -----------------------------------------------------------------------
5816 
5820  unsigned long long
5821  legion_get_current_time_in_micros(void);
5822 
5826  unsigned long long
5827  legion_get_current_time_in_nanos(void);
5828 
5832  legion_future_t
5833  legion_issue_timing_op_seconds(legion_runtime_t runtime,
5834  legion_context_t ctx);
5835 
5839  legion_future_t
5840  legion_issue_timing_op_microseconds(legion_runtime_t runtime,
5841  legion_context_t ctx);
5842 
5846  legion_future_t
5847  legion_issue_timing_op_nanoseconds(legion_runtime_t runtime,
5848  legion_context_t ctx);
5849 
5850  // -----------------------------------------------------------------------
5851  // Machine Operations
5852  // -----------------------------------------------------------------------
5853 
5859  legion_machine_t
5860  legion_machine_create(void);
5861 
5867  void
5868  legion_machine_destroy(legion_machine_t handle);
5869 
5873  void
5874  legion_machine_get_all_processors(
5875  legion_machine_t machine,
5876  legion_processor_t *processors,
5877  size_t processors_size);
5878 
5882  size_t
5883  legion_machine_get_all_processors_size(legion_machine_t machine);
5884 
5888  void
5889  legion_machine_get_all_memories(
5890  legion_machine_t machine,
5891  legion_memory_t *memories,
5892  size_t memories_size);
5893 
5897  size_t
5898  legion_machine_get_all_memories_size(legion_machine_t machine);
5899 
5900  // -----------------------------------------------------------------------
5901  // Processor Operations
5902  // -----------------------------------------------------------------------
5903 
5907  legion_processor_kind_t
5908  legion_processor_kind(legion_processor_t proc);
5909 
5913  legion_address_space_t
5914  legion_processor_address_space(legion_processor_t proc);
5915 
5916  // -----------------------------------------------------------------------
5917  // Memory Operations
5918  // -----------------------------------------------------------------------
5919 
5923  legion_memory_kind_t
5924  legion_memory_kind(legion_memory_t mem);
5925 
5929  legion_address_space_t
5930  legion_memory_address_space(legion_memory_t mem);
5931 
5932  // -----------------------------------------------------------------------
5933  // Processor Query Operations
5934  // -----------------------------------------------------------------------
5935 
5941  legion_processor_query_t
5942  legion_processor_query_create(legion_machine_t machine);
5943 
5949  legion_processor_query_t
5950  legion_processor_query_create_copy(legion_processor_query_t query);
5951 
5957  void
5958  legion_processor_query_destroy(legion_processor_query_t handle);
5959 
5965  void
5966  legion_processor_query_only_kind(legion_processor_query_t query,
5967  legion_processor_kind_t kind);
5968 
5974  void
5975  legion_processor_query_local_address_space(legion_processor_query_t query);
5976 
5982  void
5983  legion_processor_query_same_address_space_as_processor(legion_processor_query_t query,
5984  legion_processor_t proc);
5985 
5991  void
5992  legion_processor_query_same_address_space_as_memory(legion_processor_query_t query,
5993  legion_memory_t mem);
5994 
6000  void
6001  legion_processor_query_has_affinity_to_memory(legion_processor_query_t query,
6002  legion_memory_t mem,
6003  unsigned min_bandwidth /* = 0 */,
6004  unsigned max_latency /* = 0 */);
6005 
6011  void
6012  legion_processor_query_best_affinity_to_memory(legion_processor_query_t query,
6013  legion_memory_t mem,
6014  int bandwidth_weight /* = 0 */,
6015  int latency_weight /* = 0 */);
6016 
6020  size_t
6021  legion_processor_query_count(legion_processor_query_t query);
6022 
6026  legion_processor_t
6027  legion_processor_query_first(legion_processor_query_t query);
6028 
6032  legion_processor_t
6033  legion_processor_query_next(legion_processor_query_t query,
6034  legion_processor_t after);
6035 
6039  legion_processor_t
6040  legion_processor_query_random(legion_processor_query_t query);
6041 
6042  // -----------------------------------------------------------------------
6043  // Memory Query Operations
6044  // -----------------------------------------------------------------------
6045 
6051  legion_memory_query_t
6052  legion_memory_query_create(legion_machine_t machine);
6053 
6059  legion_memory_query_t
6060  legion_memory_query_create_copy(legion_memory_query_t query);
6061 
6067  void
6068  legion_memory_query_destroy(legion_memory_query_t handle);
6069 
6075  void
6076  legion_memory_query_only_kind(legion_memory_query_t query,
6077  legion_memory_kind_t kind);
6078 
6084  void
6085  legion_memory_query_local_address_space(legion_memory_query_t query);
6086 
6092  void
6093  legion_memory_query_same_address_space_as_processor(legion_memory_query_t query,
6094  legion_processor_t proc);
6095 
6101  void
6102  legion_memory_query_same_address_space_as_memory(legion_memory_query_t query,
6103  legion_memory_t mem);
6104 
6110  void
6111  legion_memory_query_has_affinity_to_processor(legion_memory_query_t query,
6112  legion_processor_t proc,
6113  unsigned min_bandwidth /* = 0 */,
6114  unsigned max_latency /* = 0 */);
6115 
6121  void
6122  legion_memory_query_has_affinity_to_memory(legion_memory_query_t query,
6123  legion_memory_t mem,
6124  unsigned min_bandwidth /* = 0 */,
6125  unsigned max_latency /* = 0 */);
6126 
6132  void
6133  legion_memory_query_best_affinity_to_processor(legion_memory_query_t query,
6134  legion_processor_t proc,
6135  int bandwidth_weight /* = 0 */,
6136  int latency_weight /* = 0 */);
6137 
6143  void
6144  legion_memory_query_best_affinity_to_memory(legion_memory_query_t query,
6145  legion_memory_t mem,
6146  int bandwidth_weight /* = 0 */,
6147  int latency_weight /* = 0 */);
6148 
6152  size_t
6153  legion_memory_query_count(legion_memory_query_t query);
6154 
6158  legion_memory_t
6159  legion_memory_query_first(legion_memory_query_t query);
6160 
6164  legion_memory_t
6165  legion_memory_query_next(legion_memory_query_t query,
6166  legion_memory_t after);
6167 
6171  legion_memory_t
6172  legion_memory_query_random(legion_memory_query_t query);
6173 
6174  // -----------------------------------------------------------------------
6175  // Physical Instance Operations
6176  // -----------------------------------------------------------------------
6177 
6178  /*
6179  * @param instance Caller must have ownership of parameter `instance`.
6180  *
6181  * @see Legion::Mapping::PhysicalInstance
6182  */
6183  void
6184  legion_physical_instance_destroy(legion_physical_instance_t instance);
6185 
6186  // -----------------------------------------------------------------------
6187  // Slice Task Output
6188  // -----------------------------------------------------------------------
6189 
6193  void
6194  legion_slice_task_output_slices_add(
6195  legion_slice_task_output_t output,
6196  legion_task_slice_t slice);
6197 
6201  void
6202  legion_slice_task_output_verify_correctness_set(
6203  legion_slice_task_output_t output,
6204  bool verify_correctness);
6205 
6206  // -----------------------------------------------------------------------
6207  // Map Task Input/Output
6208  // -----------------------------------------------------------------------
6209 
6213  void
6214  legion_map_task_output_chosen_instances_clear_all(
6215  legion_map_task_output_t output);
6216 
6220  void
6221  legion_map_task_output_chosen_instances_clear_each(
6222  legion_map_task_output_t output,
6223  size_t idx);
6224 
6228  void
6229  legion_map_task_output_chosen_instances_add(
6230  legion_map_task_output_t output,
6231  legion_physical_instance_t *instances,
6232  size_t instances_size);
6233 
6237  void
6238  legion_map_task_output_chosen_instances_set(
6239  legion_map_task_output_t output,
6240  size_t idx,
6241  legion_physical_instance_t *instances,
6242  size_t instances_size);
6243 
6247  void
6248  legion_map_task_output_target_procs_clear(
6249  legion_map_task_output_t output);
6250 
6254  void
6255  legion_map_task_output_target_procs_add(
6256  legion_map_task_output_t output,
6257  legion_processor_t proc);
6258 
6262  legion_processor_t
6263  legion_map_task_output_target_procs_get(
6264  legion_map_task_output_t output,
6265  size_t idx);
6266 
6270  void
6271  legion_map_task_output_task_priority_set(
6272  legion_map_task_output_t output,
6273  legion_task_priority_t priority);
6274 
6275  // -----------------------------------------------------------------------
6276  // MapperRuntime Operations
6277  // -----------------------------------------------------------------------
6278 
6284  bool
6285  legion_mapper_runtime_create_physical_instance_layout_constraint(
6286  legion_mapper_runtime_t runtime,
6287  legion_mapper_context_t ctx,
6288  legion_memory_t target_memory,
6289  legion_layout_constraint_set_t constraints,
6290  const legion_logical_region_t *regions,
6291  size_t regions_size,
6292  legion_physical_instance_t *result,
6293  bool acquire,
6294  legion_garbage_collection_priority_t priority);
6295 
6301  bool
6302  legion_mapper_runtime_create_physical_instance_layout_constraint_id(
6303  legion_mapper_runtime_t runtime,
6304  legion_mapper_context_t ctx,
6305  legion_memory_t target_memory,
6306  legion_layout_constraint_id_t layout_id,
6307  const legion_logical_region_t *regions,
6308  size_t regions_size,
6309  legion_physical_instance_t *result,
6310  bool acquire,
6311  legion_garbage_collection_priority_t priority);
6312 
6318  bool
6319  legion_mapper_runtime_find_or_create_physical_instance_layout_constraint(
6320  legion_mapper_runtime_t runtime,
6321  legion_mapper_context_t ctx,
6322  legion_memory_t target_memory,
6323  legion_layout_constraint_set_t constraints,
6324  const legion_logical_region_t *regions,
6325  size_t regions_size,
6326  legion_physical_instance_t *result,
6327  bool *created,
6328  bool acquire,
6329  legion_garbage_collection_priority_t priority,
6330  bool tight_region_bounds);
6331 
6337  bool
6338  legion_mapper_runtime_find_or_create_physical_instance_layout_constraint_id(
6339  legion_mapper_runtime_t runtime,
6340  legion_mapper_context_t ctx,
6341  legion_memory_t target_memory,
6342  legion_layout_constraint_id_t layout_id,
6343  const legion_logical_region_t *regions,
6344  size_t regions_size,
6345  legion_physical_instance_t *result,
6346  bool *created,
6347  bool acquire,
6348  legion_garbage_collection_priority_t priority,
6349  bool tight_region_bounds);
6350 
6356  bool
6357  legion_mapper_runtime_find_physical_instance_layout_constraint(
6358  legion_mapper_runtime_t runtime,
6359  legion_mapper_context_t ctx,
6360  legion_memory_t target_memory,
6361  legion_layout_constraint_set_t constraints,
6362  const legion_logical_region_t *regions,
6363  size_t regions_size,
6364  legion_physical_instance_t *result,
6365  bool acquire,
6366  bool tight_region_bounds);
6367 
6373  bool
6374  legion_mapper_runtime_find_physical_instance_layout_constraint_id(
6375  legion_mapper_runtime_t runtime,
6376  legion_mapper_context_t ctx,
6377  legion_memory_t target_memory,
6378  legion_layout_constraint_id_t layout_id,
6379  const legion_logical_region_t *regions,
6380  size_t regions_size,
6381  legion_physical_instance_t *result,
6382  bool acquire,
6383  bool tight_region_bounds);
6384 
6385 
6391  bool
6392  legion_mapper_runtime_acquire_instance(
6393  legion_mapper_runtime_t runtime,
6394  legion_mapper_context_t ctx,
6395  legion_physical_instance_t instance);
6396 
6402  bool
6403  legion_mapper_runtime_acquire_instances(
6404  legion_mapper_runtime_t runtime,
6405  legion_mapper_context_t ctx,
6406  legion_physical_instance_t *instances,
6407  size_t instances_size);
6408 
6409  // A hidden method here that hopefully nobody sees or ever needs
6410  // to use but its here anyway just in case
6411  legion_shard_id_t
6412  legion_context_get_shard_id(legion_runtime_t /*runtime*/,
6413  legion_context_t /*context*/,
6414  bool /*I know what I am doing*/);
6415  // Another hidden method for getting the number of shards
6416  size_t
6417  legion_context_get_num_shards(legion_runtime_t /*runtime*/,
6418  legion_context_t /*context*/,
6419  bool /*I know what I am doing*/);
6420 
6424  legion_physical_region_t
6425  legion_get_physical_region_by_id(
6426  legion_physical_region_t *regionptr,
6427  int id,
6428  int num_regions);
6429 #ifdef __cplusplus
6430 }
6431 #endif
6432 
6433 #endif // __LEGION_C_H__
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_future_is_ready
bool legion_future_is_ready(legion_future_t handle)
legion_future_get_untyped_pointer
const void * legion_future_get_untyped_pointer(legion_future_t handle)
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_field_space_destroy
void legion_field_space_destroy(legion_runtime_t runtime, legion_context_t ctx, legion_field_space_t handle)
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_region_requirement_get_projection
legion_projection_id_t legion_region_requirement_get_projection(legion_region_requirement_t handle)
ITERATOR_CREATE
#define ITERATOR_CREATE(DIM)
Definition: legion_c.h:639
legion_coloring_ensure_color
void legion_coloring_ensure_color(legion_coloring_t handle, legion_color_t color)
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_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_region_requirement_get_prop
legion_coherence_property_t legion_region_requirement_get_prop(legion_region_requirement_t handle)
legion_context_progress_unordered_operations
void legion_context_progress_unordered_operations(legion_runtime_t runtime, legion_context_t ctx)
legion_copy_launcher_add_wait_barrier
void legion_copy_launcher_add_wait_barrier(legion_copy_launcher_t launcher, legion_phase_barrier_t bar)
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_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_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_region_requirement_get_privilege
legion_privilege_mode_t legion_region_requirement_get_privilege(legion_region_requirement_t handle)
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_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_name
const char * legion_task_get_name(legion_task_t task)
legion_release_launcher_add_field
void legion_release_launcher_add_field(legion_release_launcher_t launcher, legion_field_id_t fid)
legion_inline_get_requirement
legion_region_requirement_t legion_inline_get_requirement(legion_inline_t inline_operation)
legion_index_space_retrieve_name
void legion_index_space_retrieve_name(legion_runtime_t runtime, legion_index_space_t handle, const char **result)
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_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_partition_destroy
void legion_index_partition_destroy(legion_runtime_t runtime, legion_context_t ctx, legion_index_partition_t handle)
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_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_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:403
legion_memory_address_space
legion_address_space_t legion_memory_address_space(legion_memory_t mem)
legion_execution_constraint_set_destroy
void legion_execution_constraint_set_destroy(legion_execution_constraint_set_t handle)
legion_task_get_futures_size
unsigned legion_task_get_futures_size(legion_task_t task)
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_set_mapper_arg
void legion_index_copy_launcher_set_mapper_arg(legion_index_copy_launcher_t launcher, legion_untyped_buffer_t arg)
legion_runtime_print_once
void legion_runtime_print_once(legion_runtime_t runtime, legion_context_t ctx, FILE *f, const char *message)
legion_task_get_is_index_space
bool legion_task_get_is_index_space(legion_task_t task)
legion_physical_region_get_field_count
size_t legion_physical_region_get_field_count(legion_physical_region_t handle)
legion_fill_launcher_set_point
void legion_fill_launcher_set_point(legion_fill_launcher_t launcher, legion_domain_point_t point)
legion_ptr_is_null
bool legion_ptr_is_null(legion_ptr_t ptr)
legion_domain_transform_t
struct legion_domain_transform_t legion_domain_transform_t
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_slice_task_input_t
Definition: legion_c.h:378
ITERATOR_OP
#define ITERATOR_OP(DIM)
Definition: legion_c.h:677
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_domain_coloring_get_color_space
legion_domain_t legion_domain_coloring_get_color_space(legion_domain_coloring_t handle)
legion_task_set_arglen
void legion_task_set_arglen(legion_task_mut_t task, size_t arglen)
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_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_fill_launcher_execute
void legion_fill_launcher_execute(legion_runtime_t runtime, legion_context_t ctx, legion_fill_launcher_t launcher)
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_field_map_destroy
void legion_field_map_destroy(legion_field_map_t handle)
FROM_POINT
#define FROM_POINT(DIM)
Definition: legion_c.h:558
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_point_coloring_create
legion_point_coloring_t legion_point_coloring_create(void)
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_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_execution_constraint_set_create
legion_execution_constraint_set_t legion_execution_constraint_set_create(void)
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_logical_region_retrieve_name
void legion_logical_region_retrieve_name(legion_runtime_t runtime, legion_logical_region_t handle, const char **result)
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_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_field_space_t
struct legion_field_space_t legion_field_space_t
legion_copy_launcher_destroy
void legion_copy_launcher_destroy(legion_copy_launcher_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_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_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_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_runtime_get_input_args
const legion_input_args_t legion_runtime_get_input_args(void)
legion_phase_barrier_destroy
void legion_phase_barrier_destroy(legion_runtime_t runtime, legion_context_t ctx, legion_phase_barrier_t handle)
legion_runtime_replace_default_mapper
void legion_runtime_replace_default_mapper(legion_runtime_t runtime, legion_mapper_t mapper, legion_processor_t proc)
legion_memory_t
Definition: legion_c.h:327
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_runtime_detach_hdf5
void legion_runtime_detach_hdf5(legion_runtime_t runtime, legion_context_t ctx, legion_physical_region_t region)
legion_runtime_start
int legion_runtime_start(int argc, char **argv, bool background)
legion_region_requirement_get_partition
legion_logical_partition_t legion_region_requirement_get_partition(legion_region_requirement_t handle)
legion_index_launcher_set_mapper
void legion_index_launcher_set_mapper(legion_index_launcher_t launcher, legion_mapper_id_t mapper_id)
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_field_space_retrieve_name
void legion_field_space_retrieve_name(legion_runtime_t runtime, legion_field_space_t handle, const char **result)
legion_future_get_untyped_size
size_t legion_future_get_untyped_size(legion_future_t handle)
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_runtime_issue_execution_fence
legion_future_t legion_runtime_issue_execution_fence(legion_runtime_t runtime, legion_context_t ctx)
legion_processor_query_local_address_space
void legion_processor_query_local_address_space(legion_processor_query_t query)
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_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_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_get_current_time_in_micros
unsigned long long legion_get_current_time_in_micros(void)
legion_fill_launcher_set_provenance
void legion_fill_launcher_set_provenance(legion_fill_launcher_t launcher, const char *provenance)
legion_domain_point_is_null
bool legion_domain_point_is_null(legion_domain_point_t point)
legion_task_launcher_add_future
void legion_task_launcher_add_future(legion_task_launcher_t launcher, legion_future_t future)
legion_field_allocator_destroy
void legion_field_allocator_destroy(legion_field_allocator_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_processor_query_create
legion_processor_query_t legion_processor_query_create(legion_machine_t machine)
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_acquire_launcher_add_arrival_barrier
void legion_acquire_launcher_add_arrival_barrier(legion_acquire_launcher_t launcher, legion_phase_barrier_t bar)
legion_runtime_wait_for_shutdown
int legion_runtime_wait_for_shutdown(void)
legion_domain_coloring_create
legion_domain_coloring_t legion_domain_coloring_create(void)
legion_mappable_as_inline_mapping
legion_inline_t legion_mappable_as_inline_mapping(legion_mappable_t mappable)
legion_release_launcher_set_sharding_space
void legion_release_launcher_set_sharding_space(legion_release_launcher_t launcher, legion_index_space_t space)
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_field_space_get_fields
legion_field_id_t * legion_field_space_get_fields(legion_runtime_t runtime, legion_context_t ctx, legion_field_space_t handle, size_t *size)
legion_index_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_copy_launcher_set_mapper_arg
void legion_copy_launcher_set_mapper_arg(legion_copy_launcher_t launcher, legion_untyped_buffer_t arg)
legion_future_map_copy
legion_future_map_t legion_future_map_copy(legion_future_map_t handle)
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_options_t
struct legion_task_options_t legion_task_options_t
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_index_launcher_add_future
void legion_index_launcher_add_future(legion_index_launcher_t launcher, legion_future_t future)
legion_input_args_t
struct legion_input_args_t legion_input_args_t
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_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_task_destroy
void legion_task_destroy(legion_task_mut_t handle)
legion_attach_launcher_set_mapped
void legion_attach_launcher_set_mapped(legion_attach_launcher_t handle, bool mapped)
ITERATOR_VALID
#define ITERATOR_VALID(DIM)
Definition: legion_c.h:659
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)
legion_layout_constraint_set_create
legion_layout_constraint_set_t legion_layout_constraint_set_create(void)
legion_domain_point_coloring_create
legion_domain_point_coloring_t legion_domain_point_coloring_create(void)
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:425
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_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_task_set_args
void legion_task_set_args(legion_task_mut_t task, void *args)
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_map_task_output_target_procs_clear
void legion_map_task_output_target_procs_clear(legion_map_task_output_t output)
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_logical_partition_retrieve_name
void legion_logical_partition_retrieve_name(legion_runtime_t runtime, legion_logical_partition_t handle, const char **result)
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_acquire_launcher_destroy
void legion_acquire_launcher_destroy(legion_acquire_launcher_t handle)
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_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_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_auto_generate_id
legion_field_id_t legion_auto_generate_id(void)
legion_coloring_delete_point
void legion_coloring_delete_point(legion_coloring_t handle, legion_color_t color, legion_ptr_t point)
legion_task_launcher_destroy
void legion_task_launcher_destroy(legion_task_launcher_t handle)
legion_processor_query_create_copy
legion_processor_query_t legion_processor_query_create_copy(legion_processor_query_t query)
legion_layout_constraint_set_destroy
void legion_layout_constraint_set_destroy(legion_layout_constraint_set_t handle)
legion_processor_query_first
legion_processor_t legion_processor_query_first(legion_processor_query_t query)
legion_map_task_output_chosen_instances_clear_all
void legion_map_task_output_chosen_instances_clear_all(legion_map_task_output_t output)
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_runtime_initialize
void legion_runtime_initialize(int *argc, char ***argv, bool filter)
GET_RECT
#define GET_RECT(DIM)
Definition: legion_c.h:499
legion_index_launcher_add_arrival_barrier
void legion_index_launcher_add_arrival_barrier(legion_index_launcher_t launcher, legion_phase_barrier_t bar)
legion_release_launcher_set_mapper_arg
void legion_release_launcher_set_mapper_arg(legion_release_launcher_t launcher, legion_untyped_buffer_t arg)
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_coloring_create
legion_coloring_t legion_coloring_create(void)
legion_index_launcher_set_sharding_space
void legion_index_launcher_set_sharding_space(legion_index_launcher_t launcher, legion_index_space_t is)
legion_predicate_create
legion_predicate_t legion_predicate_create(legion_runtime_t runtime, legion_context_t ctx, legion_future_t f)
legion_memory_query_random
legion_memory_t legion_memory_query_random(legion_memory_query_t query)
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_domain_coloring_destroy
void legion_domain_coloring_destroy(legion_domain_coloring_t handle)
legion_runtime_issue_mapping_fence
legion_future_t legion_runtime_issue_mapping_fence(legion_runtime_t runtime, legion_context_t ctx)
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_attach_launcher_destroy
void legion_attach_launcher_destroy(legion_attach_launcher_t handle)
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_runtime_end_trace
void legion_runtime_end_trace(legion_runtime_t runtime, legion_context_t ctx, legion_trace_id_t tid)
legion_inline_launcher_add_field
void legion_inline_launcher_add_field(legion_inline_launcher_t launcher, legion_field_id_t fid, bool inst)
legion_task_launcher_set_provenance
void legion_task_launcher_set_provenance(legion_task_launcher_t launcher, const char *provenance)
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_task_get_requirement
legion_region_requirement_t legion_task_get_requirement(legion_task_t task, unsigned idx)
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_task_launcher_set_local_function_task
void legion_task_launcher_set_local_function_task(legion_task_launcher_t launcher, bool local_function_task)
legion_machine_create
legion_machine_t legion_machine_create(void)
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_copy_launcher_set_provenance
void legion_copy_launcher_set_provenance(legion_copy_launcher_t launcher, const char *provenance)
legion_task_launcher_add_arrival_barrier
void legion_task_launcher_add_arrival_barrier(legion_task_launcher_t launcher, legion_phase_barrier_t bar)
legion_field_allocator_free_field
void legion_field_allocator_free_field(legion_field_allocator_t allocator, legion_field_id_t fid)
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_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_index_space_t
struct legion_index_space_t legion_index_space_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_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_external_resources_destroy
void legion_external_resources_destroy(legion_external_resources_t handle)
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_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_predicate_false
const legion_predicate_t legion_predicate_false(void)
legion_task_config_options_t
struct legion_task_config_options_t legion_task_config_options_t
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_physical_region_get_logical_region
legion_logical_region_t legion_physical_region_get_logical_region(legion_physical_region_t handle)
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_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_add_field
void legion_index_launcher_add_field(legion_index_launcher_t launcher, unsigned idx, legion_field_id_t fid, bool inst)
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_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_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_domain_transform_t
Definition: legion_c.h:199
legion_inline_launcher_set_mapper_arg
void legion_inline_launcher_set_mapper_arg(legion_inline_launcher_t launcher, legion_untyped_buffer_t arg)
legion_index_launcher_destroy
void legion_index_launcher_destroy(legion_index_launcher_t handle)
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_slice_t
struct legion_task_slice_t legion_task_slice_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_index_partition_t
struct legion_index_partition_t legion_index_partition_t
legion_region_requirement_get_region
legion_logical_region_t legion_region_requirement_get_region(legion_region_requirement_t handle)
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_release_launcher_add_arrival_barrier
void legion_release_launcher_add_arrival_barrier(legion_release_launcher_t launcher, legion_phase_barrier_t bar)
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_region_requirement_get_instance_field
legion_field_id_t legion_region_requirement_get_instance_field(legion_region_requirement_t handle, unsigned idx)
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_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_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_acquire_launcher_add_field
void legion_acquire_launcher_add_field(legion_acquire_launcher_t launcher, legion_field_id_t fid)
legion_task_get_target_proc
legion_processor_t legion_task_get_target_proc(legion_task_t task)
legion_region_requirement_get_tag
legion_mapping_tag_id_t legion_region_requirement_get_tag(legion_region_requirement_t handle)
legion_domain_empty
legion_domain_t legion_domain_empty(unsigned dim)
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_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_must_epoch_launcher_set_provenance
void legion_must_epoch_launcher_set_provenance(legion_must_epoch_launcher_t launcher, const char *provenance)
legion_domain_point_iterator_has_next
bool legion_domain_point_iterator_has_next(legion_domain_point_iterator_t handle)
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_external_resources_size
size_t legion_external_resources_size(legion_external_resources_t handle)
legion_fill_launcher_add_field
void legion_fill_launcher_add_field(legion_fill_launcher_t handle, legion_field_id_t fid)
legion_copy_launcher_set_sharding_space
void legion_copy_launcher_set_sharding_space(legion_copy_launcher_t launcher, legion_index_space_t space)
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_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_argument_map_destroy
void legion_argument_map_destroy(legion_argument_map_t handle)
legion_memory_t
struct legion_memory_t legion_memory_t
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_runtime_get_executing_processor
legion_processor_t legion_runtime_get_executing_processor(legion_runtime_t runtime, legion_context_t ctx)
legion_index_launcher_set_provenance
void legion_index_launcher_set_provenance(legion_index_launcher_t launcher, const char *provenance)
legion_index_space_get_dim
int legion_index_space_get_dim(legion_index_space_t handle)
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_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_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_task_launcher_add_wait_barrier
void legion_task_launcher_add_wait_barrier(legion_task_launcher_t launcher, legion_phase_barrier_t bar)
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_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_task_get_regions_size
unsigned legion_task_get_regions_size(legion_task_t task)
legion_index_space_t
Definition: legion_c.h:244
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_launcher_add_point_future
void legion_index_launcher_add_point_future(legion_index_launcher_t launcher, legion_argument_map_t map)
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_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_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_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_logical_partition_destroy
void legion_logical_partition_destroy(legion_runtime_t runtime, legion_context_t ctx, legion_logical_partition_t handle)
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_task_launcher_execute
legion_future_t legion_task_launcher_execute(legion_runtime_t runtime, legion_context_t ctx, legion_task_launcher_t launcher)
legion_phase_barrier_t
struct legion_phase_barrier_t legion_phase_barrier_t
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_task_slice_t
Definition: legion_c.h:334
legion_task_get_depth
int legion_task_get_depth(legion_task_t task)
legion_phase_barrier_wait
void legion_phase_barrier_wait(legion_runtime_t runtime, legion_context_t ctx, legion_phase_barrier_t handle)
legion_task_add_future
void legion_task_add_future(legion_task_mut_t task, legion_future_t future)
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_dynamic_collective_t
struct legion_dynamic_collective_t legion_dynamic_collective_t
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_argument_map_create
legion_argument_map_t legion_argument_map_create(void)
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_issue_timing_op_nanoseconds
legion_future_t legion_issue_timing_op_nanoseconds(legion_runtime_t runtime, legion_context_t ctx)
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_machine_destroy
void legion_machine_destroy(legion_machine_t handle)
legion_memory_query_count
size_t legion_memory_query_count(legion_memory_query_t query)
legion_task_layout_constraint_set_destroy
void legion_task_layout_constraint_set_destroy(legion_task_layout_constraint_set_t handle)
legion_mappable_as_task
legion_task_t legion_mappable_as_task(legion_mappable_t mappable)
legion_inline_launcher_destroy
void legion_inline_launcher_destroy(legion_inline_launcher_t handle)
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_memory_query_local_address_space
void legion_memory_query_local_address_space(legion_memory_query_t query)
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_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_region_requirement_get_instance_fields_size
unsigned legion_region_requirement_get_instance_fields_size(legion_region_requirement_t handle)
legion_processor_query_destroy
void legion_processor_query_destroy(legion_processor_query_t handle)
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_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_future_is_ready_subscribe
bool legion_future_is_ready_subscribe(legion_future_t handle, bool subscribe)
legion_processor_query_only_kind
void legion_processor_query_only_kind(legion_processor_query_t query, legion_processor_kind_t kind)
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_input_args_t
Definition: legion_c.h:302
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_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_fill_launcher_set_provenance
void legion_index_fill_launcher_set_provenance(legion_index_fill_launcher_t launcher, const char *provenance)
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_t region_functor, legion_projection_functor_logical_partition_t partition_functor)
legion_must_epoch_launcher_destroy
void legion_must_epoch_launcher_destroy(legion_must_epoch_launcher_t handle)
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_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_phase_barrier_arrive
void legion_phase_barrier_arrive(legion_runtime_t runtime, legion_context_t ctx, legion_phase_barrier_t handle, unsigned count)
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_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:437
legion_untyped_buffer_t
Definition: legion_c.h:287
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_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_processor_address_space
legion_address_space_t legion_processor_address_space(legion_processor_t proc)
legion_future_map_destroy
void legion_future_map_destroy(legion_future_map_t handle)
legion_domain_t
struct legion_domain_t legion_domain_t
legion_index_launcher_get_projection_args
const void * legion_index_launcher_get_projection_args(legion_region_requirement_t requirement, size_t *size)
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_task_get_tag
legion_mapping_tag_id_t legion_task_get_tag(legion_task_t task)
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_coloring_has_point
bool legion_coloring_has_point(legion_coloring_t handle, legion_color_t color, legion_ptr_t point)
legion_processor_t
struct legion_processor_t legion_processor_t
legion_untyped_buffer_t
struct legion_untyped_buffer_t legion_untyped_buffer_t
legion_region_requirement_get_privilege_fields_size
unsigned legion_region_requirement_get_privilege_fields_size(legion_region_requirement_t handle)
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_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_argument_map_from_future_map
legion_argument_map_t legion_argument_map_from_future_map(legion_future_map_t map)
legion_mappable_get_type
enum legion_mappable_type_id_t legion_mappable_get_type(legion_mappable_t mappable)
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_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_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_release_launcher_set_provenance
void legion_release_launcher_set_provenance(legion_release_launcher_t launcher, const char *provenance)
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_task_get_arglen
size_t legion_task_get_arglen(legion_task_t task)
legion_runtime_get_maximum_dimension
size_t legion_runtime_get_maximum_dimension(void)
legion_phase_barrier_create
legion_phase_barrier_t legion_phase_barrier_create(legion_runtime_t runtime, legion_context_t ctx, unsigned arrivals)
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_task_launcher_set_enable_inlining
void legion_task_launcher_set_enable_inlining(legion_task_launcher_t launcher, bool enable_inlining)
legion_logical_partition_t
Definition: legion_c.h:278
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_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_runtime_unmap_all_regions
void legion_runtime_unmap_all_regions(legion_runtime_t runtime, legion_context_t ctx)
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_task_get_local_args
void * legion_task_get_local_args(legion_task_t task)
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_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_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_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_physical_region_is_valid
bool legion_physical_region_is_valid(legion_physical_region_t handle)
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_task_options_t
Definition: legion_c.h:367
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_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)
BUFFER_CREATE
#define BUFFER_CREATE(DIM)
Definition: legion_c.h:2737
legion_index_partition_retrieve_name
void legion_index_partition_retrieve_name(legion_runtime_t runtime, legion_index_partition_t handle, const char **result)
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_physical_region_get_memory_count
size_t legion_physical_region_get_memory_count(legion_physical_region_t handle)
legion_region_requirement_destroy
void legion_region_requirement_destroy(legion_region_requirement_t handle)
legion_runtime_set_return_code
void legion_runtime_set_return_code(int return_code)
legion_layout_constraint_set_add_splitting_constraint
void legion_layout_constraint_set_add_splitting_constraint(legion_layout_constraint_set_t handle, legion_dimension_kind_t dim)
legion_logical_partition_t
struct legion_logical_partition_t legion_logical_partition_t
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_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_task_get_task_id
legion_task_id_t legion_task_get_task_id(legion_task_t task)
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_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_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_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_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_acquire_launcher_set_mapper_arg
void legion_acquire_launcher_set_mapper_arg(legion_acquire_launcher_t launcher, legion_untyped_buffer_t arg)
legion_context_destroy
void legion_context_destroy(legion_context_t)
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_acquire_launcher_set_sharding_space
void legion_acquire_launcher_set_sharding_space(legion_acquire_launcher_t launcher, legion_index_space_t space)
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_layout_constraint_set_add_full_splitting_constraint
void legion_layout_constraint_set_add_full_splitting_constraint(legion_layout_constraint_set_t handle, legion_dimension_kind_t dim, size_t value)
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_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_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_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_logical_region_t
Definition: legion_c.h:269
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_future_map_wait_all_results
void legion_future_map_wait_all_results(legion_future_map_t handle)
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_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_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_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_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_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_ptr_nil
legion_ptr_t legion_ptr_nil(void)
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_mut_as_task
legion_task_t legion_task_mut_as_task(legion_task_mut_t task)
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_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_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_domain_point_t
struct legion_domain_point_t legion_domain_point_t
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_domain_point_iterator_create
legion_domain_point_iterator_t legion_domain_point_iterator_create(legion_domain_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_copy_launcher_set_point
void legion_copy_launcher_set_point(legion_copy_launcher_t launcher, legion_domain_point_t point)
legion_fill_launcher_destroy
void legion_fill_launcher_destroy(legion_fill_launcher_t handle)
legion_index_partition_is_disjoint
bool legion_index_partition_is_disjoint(legion_runtime_t runtime, legion_index_partition_t handle)
legion_task_launcher_set_mapper
void legion_task_launcher_set_mapper(legion_task_launcher_t launcher, legion_mapper_id_t mapper_id)
legion_index_attach_launcher_destroy
void legion_index_attach_launcher_destroy(legion_index_attach_launcher_t handle)
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_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_runtime_has_runtime
bool legion_runtime_has_runtime(void)
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_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_coloring_color_domain
void legion_domain_coloring_color_domain(legion_domain_coloring_t handle, legion_color_t color, legion_domain_t domain)
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_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_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)
GET_POINT
#define GET_POINT(DIM)
Definition: legion_c.h:567
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_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)
ACCESSOR_ARRAY
#define ACCESSOR_ARRAY(DIM)
Definition: legion_c.h:4908
legion_task_launcher_set_sharding_space
void legion_task_launcher_set_sharding_space(legion_task_launcher_t launcher, legion_index_space_t is)
legion_coloring_add_point
void legion_coloring_add_point(legion_coloring_t handle, legion_color_t color, legion_ptr_t point)
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_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_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_future_from_untyped_pointer
legion_future_t legion_future_from_untyped_pointer(legion_runtime_t runtime, const void *buffer, size_t size)
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_t
Definition: legion_c.h:152
legion_domain_affine_transform_t
struct legion_domain_affine_transform_t legion_domain_affine_transform_t
legion_machine_get_all_processors_size
size_t legion_machine_get_all_processors_size(legion_machine_t machine)
legion_task_launcher_set_point
void legion_task_launcher_set_point(legion_task_launcher_t launcher, legion_domain_point_t point)
legion_future_get_void_result
void legion_future_get_void_result(legion_future_t handle)
legion_processor_query_count
size_t legion_processor_query_count(legion_processor_query_t query)
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_get_current_time_in_nanos
unsigned long long legion_get_current_time_in_nanos(void)
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_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_memory_query_first
legion_memory_t legion_memory_query_first(legion_memory_query_t query)
legion_predicate_destroy
void legion_predicate_destroy(legion_predicate_t handle)
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_runtime_remap_region
void legion_runtime_remap_region(legion_runtime_t runtime, legion_context_t ctx, legion_physical_region_t region)
legion_task_layout_constraint_set_create
legion_task_layout_constraint_set_t legion_task_layout_constraint_set_create(void)
legion_mappable_as_copy
legion_copy_t legion_mappable_as_copy(legion_mappable_t mappable)
legion_acquire_launcher_execute
void legion_acquire_launcher_execute(legion_runtime_t runtime, legion_context_t ctx, legion_acquire_launcher_t launcher)
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:414
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_runtime_set_top_level_task_id
void legion_runtime_set_top_level_task_id(legion_task_id_t top_id)
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_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_field_map_create
legion_field_map_t legion_field_map_create(void)
legion_attach_launcher_set_provenance
void legion_attach_launcher_set_provenance(legion_attach_launcher_t handle, const char *provenance)
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_config.h
legion_task_postamble
void legion_task_postamble(legion_runtime_t runtime, legion_context_t ctx, const void *retval, size_t retsize)
legion_fill_launcher_set_mapper_arg
void legion_fill_launcher_set_mapper_arg(legion_fill_launcher_t launcher, legion_untyped_buffer_t arg)
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_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_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_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_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_task_launcher_set_argument
void legion_task_launcher_set_argument(legion_task_launcher_t launcher, legion_untyped_buffer_t arg)
legion_future_destroy
void legion_future_destroy(legion_future_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_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)
legion_runtime_has_context
bool legion_runtime_has_context(void)
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_task_get_args
void * legion_task_get_args(legion_task_t task)
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_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_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_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_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_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_create_empty
legion_task_mut_t legion_task_create_empty()
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_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_processor_query_random
legion_processor_t legion_processor_query_random(legion_processor_query_t query)
legion_physical_region_copy
legion_physical_region_t legion_physical_region_copy(legion_physical_region_t handle)
legion_index_fill_launcher_add_field
void legion_index_fill_launcher_add_field(legion_fill_launcher_t handle, legion_field_id_t fid)
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_machine_get_all_memories_size
size_t legion_machine_get_all_memories_size(legion_machine_t machine)
legion_region_requirement_get_handle_type
legion_handle_type_t legion_region_requirement_get_handle_type(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_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_runtime_get_runtime
legion_runtime_t legion_runtime_get_runtime(void)
legion_field_space_no_space
legion_field_space_t legion_field_space_no_space()
legion_release_launcher_add_wait_barrier
void legion_release_launcher_add_wait_barrier(legion_release_launcher_t launcher, legion_phase_barrier_t bar)
legion_copy_launcher_add_arrival_barrier
void legion_copy_launcher_add_arrival_barrier(legion_copy_launcher_t launcher, legion_phase_barrier_t bar)
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_index_space_destroy
void legion_index_space_destroy(legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t handle)
legion_task_get_local_arglen
size_t legion_task_get_local_arglen(legion_task_t task)
legion_memory_query_destroy
void legion_memory_query_destroy(legion_memory_query_t handle)
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_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_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_task_get_index_point
legion_domain_point_t legion_task_get_index_point(legion_task_t task)
legion_mappable_as_fill
legion_fill_t legion_mappable_as_fill(legion_mappable_t mappable)
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_release_launcher_destroy
void legion_release_launcher_destroy(legion_release_launcher_t handle)
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_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_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_memory_query_only_kind
void legion_memory_query_only_kind(legion_memory_query_t query, legion_memory_kind_t kind)
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:386
legion_runtime_add_registration_callback
void legion_runtime_add_registration_callback(legion_registration_callback_pointer_t callback)
legion_runtime_get_context
legion_context_t legion_runtime_get_context(void)
legion_index_partition_is_complete
bool legion_index_partition_is_complete(legion_runtime_t runtime, legion_index_partition_t handle)
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_runtime_total_shards
size_t legion_runtime_total_shards(legion_runtime_t runtime, legion_context_t ctx)
legion_task_get_index_domain
legion_domain_t legion_task_get_index_domain(legion_task_t task)
legion_index_space_get_domain
legion_domain_t legion_index_space_get_domain(legion_runtime_t runtime, legion_index_space_t handle)
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_region_requirement_get_privilege_field
legion_field_id_t legion_region_requirement_get_privilege_field(legion_region_requirement_t handle, unsigned idx)
legion_physical_region_wait_until_valid
void legion_physical_region_wait_until_valid(legion_physical_region_t handle)
legion_index_partition_get_color
legion_color_t legion_index_partition_get_color(legion_runtime_t runtime, legion_index_partition_t handle)
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_domain_point_t
Definition: legion_c.h:191
legion_task_get_unique_id
legion_unique_id_t legion_task_get_unique_id(legion_task_t task)
CREATE_BLOCKIFY
#define CREATE_BLOCKIFY(DIM)
Definition: legion_c.h:1147
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_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_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_acquire_launcher_set_provenance
void legion_acquire_launcher_set_provenance(legion_acquire_launcher_t launcher, const char *provenance)
legion_task_config_options_t
Definition: legion_c.h:310
legion_multi_domain_point_coloring_create
legion_multi_domain_point_coloring_t legion_multi_domain_point_coloring_create(void)
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)
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_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_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_copy_launcher_execute
void legion_copy_launcher_execute(legion_runtime_t runtime, legion_context_t ctx, legion_copy_launcher_t launcher)
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_ptr_t
Definition: legion_c.h:118
legion_task_pointer_wrapped_t
realm_task_pointer_t legion_task_pointer_wrapped_t
Definition: legion_c.h:396
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_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_memory_query_next
legion_memory_t legion_memory_query_next(legion_memory_query_t query, legion_memory_t after)
legion_domain_point_coloring_destroy
void legion_domain_point_coloring_destroy(legion_domain_point_coloring_t handle)
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_runtime_generate_static_projection_id
legion_projection_id_t legion_runtime_generate_static_projection_id()
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_execution_constraint_set_add_isa_constraint
void legion_execution_constraint_set_add_isa_constraint(legion_execution_constraint_set_t handle, uint64_t prop)
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_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_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_processor_query_next
legion_processor_t legion_processor_query_next(legion_processor_query_t query, legion_processor_t after)
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_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_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_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_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_point_coloring_destroy
void legion_point_coloring_destroy(legion_point_coloring_t handle)
legion_domain_affine_transform_t
Definition: legion_c.h:236
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_index_launcher_set_mapping_tag
void legion_index_launcher_set_mapping_tag(legion_index_launcher_t launcher, legion_mapping_tag_id_t tag)
legion_fill_launcher_set_sharding_space
void legion_fill_launcher_set_sharding_space(legion_fill_launcher_t launcher, legion_index_space_t space)
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_copy_get_requirement
legion_region_requirement_t legion_copy_get_requirement(legion_copy_t copy, unsigned idx)
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_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_issue_timing_op_seconds
legion_future_t legion_issue_timing_op_seconds(legion_runtime_t runtime, legion_context_t ctx)
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_index_attach_launcher_set_provenance
void legion_index_attach_launcher_set_provenance(legion_index_attach_launcher_t handle, const char *provenance)
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_layout_constraint_set_release
void legion_layout_constraint_set_release(legion_runtime_t runtime, legion_layout_constraint_id_t handle)
legion_domain_get_volume
size_t legion_domain_get_volume(legion_domain_t d)
legion_dynamic_collective_destroy
void legion_dynamic_collective_destroy(legion_runtime_t runtime, legion_context_t ctx, legion_dynamic_collective_t handle)
ITERATOR_STEP
#define ITERATOR_STEP(DIM)
Definition: legion_c.h:668
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_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_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_region_requirement_add_flags
void legion_region_requirement_add_flags(legion_region_requirement_t handle, legion_region_flags_t flags)
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_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_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_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_index_copy_launcher_destroy
void legion_index_copy_launcher_destroy(legion_index_copy_launcher_t handle)
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_context_get_unique_id
legion_unique_id_t legion_context_get_unique_id(legion_context_t ctx)
legion_index_launcher_set_mapper_arg
void legion_index_launcher_set_mapper_arg(legion_index_launcher_t launcher, legion_untyped_buffer_t map_arg)
FROM_RECT
#define FROM_RECT(DIM)
Definition: legion_c.h:483
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_memory_kind
legion_memory_kind_t legion_memory_kind(legion_memory_t mem)
legion_domain_from_index_space
legion_domain_t legion_domain_from_index_space(legion_runtime_t runtime, legion_index_space_t is)
legion_region_requirement_get_parent
legion_logical_region_t legion_region_requirement_get_parent(legion_region_requirement_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_domain_point_iterator_destroy
void legion_domain_point_iterator_destroy(legion_domain_point_iterator_t handle)
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)
legion_memory_query_create_copy
legion_memory_query_t legion_memory_query_create_copy(legion_memory_query_t query)
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_kind
legion_processor_kind_t legion_processor_kind(legion_processor_t proc)
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_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_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_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_next
legion_domain_point_t legion_domain_point_iterator_next(legion_domain_point_iterator_t handle)
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_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_task_get_mapper
legion_mapper_id_t legion_task_get_mapper(legion_task_t task)
legion_multi_domain_point_coloring_destroy
void legion_multi_domain_point_coloring_destroy(legion_multi_domain_point_coloring_t handle)
legion_machine_get_all_memories
void legion_machine_get_all_memories(legion_machine_t machine, legion_memory_t *memories, size_t memories_size)
legion_task_get_future
legion_future_t legion_task_get_future(legion_task_t task, unsigned idx)
legion_domain_contains
bool legion_domain_contains(legion_domain_t d, legion_domain_point_t p)
legion_physical_region_is_mapped
bool legion_physical_region_is_mapped(legion_physical_region_t handle)
legion_logical_region_t
struct legion_logical_region_t legion_logical_region_t
legion_phase_barrier_t
Definition: legion_c.h:344
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)
ITERATOR_DESTROY
#define ITERATOR_DESTROY(DIM)
Definition: legion_c.h:650
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_fill_launcher_destroy
void legion_index_fill_launcher_destroy(legion_index_fill_launcher_t handle)
legion_fill_get_requirement
legion_region_requirement_t legion_fill_get_requirement(legion_fill_t fill)
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_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_field_space_t
Definition: legion_c.h:262
legion_ptr_t
struct legion_ptr_t legion_ptr_t
legion_inline_launcher_set_provenance
void legion_inline_launcher_set_provenance(legion_inline_launcher_t launcher, const char *provenance)
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_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_index_attach_launcher_set_restricted
void legion_index_attach_launcher_set_restricted(legion_index_attach_launcher_t handle, bool restricted)
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_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_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_future_is_empty
bool legion_future_is_empty(legion_future_t handle, bool block)
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_machine_get_all_processors
void legion_machine_get_all_processors(legion_machine_t machine, legion_processor_t *processors, size_t processors_size)
DESTROY_ARRAY
#define DESTROY_ARRAY(DIM)
Definition: legion_c.h:4969
legion_logical_region_get_color
legion_color_t legion_logical_region_get_color(legion_runtime_t runtime, legion_logical_region_t handle)
legion_physical_region_destroy
void legion_physical_region_destroy(legion_physical_region_t handle)
legion_attach_launcher_set_restricted
void legion_attach_launcher_set_restricted(legion_attach_launcher_t handle, bool restricted)
legion_acquire_launcher_add_wait_barrier
void legion_acquire_launcher_add_wait_barrier(legion_acquire_launcher_t launcher, legion_phase_barrier_t bar)
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_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_field_space_create
legion_field_space_t legion_field_space_create(legion_runtime_t runtime, legion_context_t ctx)
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_runtime_unmap_region
void legion_runtime_unmap_region(legion_runtime_t runtime, legion_context_t ctx, legion_physical_region_t region)
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_future_wait
void legion_future_wait(legion_future_t handle, bool silence_warnings, const char *warning_string)
legion_index_launcher_add_wait_barrier
void legion_index_launcher_add_wait_barrier(legion_index_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_predicate_true
const legion_predicate_t legion_predicate_true(void)
legion_processor_t
Definition: legion_c.h:320
legion_memory_query_create
legion_memory_query_t legion_memory_query_create(legion_machine_t machine)
legion_external_resources_get_region
legion_physical_region_t legion_external_resources_get_region(legion_external_resources_t handle, unsigned index)
legion_dynamic_collective_t
Definition: legion_c.h:354
legion_index_partition_t
Definition: legion_c.h:253
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_domain_point_nil
legion_domain_point_t legion_domain_point_nil(void)
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_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_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_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_region_requirement_get_redop
legion_reduction_op_id_t legion_region_requirement_get_redop(legion_region_requirement_t handle)
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_logical_region_get_index_space
legion_index_space_t legion_logical_region_get_index_space(legion_logical_region_t handle)
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_copy_launcher_set_provenance
void legion_index_copy_launcher_set_provenance(legion_index_copy_launcher_t launcher, const char *provenance)
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_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_issue_timing_op_microseconds
legion_future_t legion_issue_timing_op_microseconds(legion_runtime_t runtime, legion_context_t ctx)
legion_runtime_yield
void legion_runtime_yield(legion_runtime_t runtime, legion_context_t ctx)
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_future_map_get_future
legion_future_t legion_future_map_get_future(legion_future_map_t handle, legion_domain_point_t point)
legion_runtime_local_shard
legion_shard_id_t legion_runtime_local_shard(legion_runtime_t runtime, legion_context_t ctx)
legion_release_launcher_execute
void legion_release_launcher_execute(legion_runtime_t runtime, legion_context_t ctx, legion_release_launcher_t launcher)
legion_future_copy
legion_future_t legion_future_copy(legion_future_t handle)
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_coloring_destroy
void legion_coloring_destroy(legion_coloring_t handle)
legion_byte_offset_t
Definition: legion_c.h:295
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)
Generated on Thu Feb 23 2023 09:06:55 for Legion Runtime by   doxygen 1.8.6