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