c_bindings.h

Go to the documentation of this file.

/* Copyright 2026 Stanford University
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef __LEGION_C_H__
#define __LEGION_C_H__
 
// ******************** IMPORTANT **************************
//
// This file is PURE C, **NOT** C++.
//
// ******************** IMPORTANT **************************
 
#include "legion/api/config.h"
 
#include <stdbool.h>
#ifndef LEGION_USE_PYTHON_CFFI
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#endif  // LEGION_USE_PYTHON_CFFI
 
#ifdef __cplusplus
extern "C"
{
#endif
 
  // -----------------------------------------------------------------------
  // Proxy Types
  // -----------------------------------------------------------------------
 
// #define NEW_OPAQUE_TYPE(T) typedef void * T
#define NEW_OPAQUE_TYPE(T) \
  typedef struct T {       \
    void* impl;            \
  } T
  NEW_OPAQUE_TYPE(legion_runtime_t);
  NEW_OPAQUE_TYPE(legion_context_t);
  NEW_OPAQUE_TYPE(legion_domain_point_iterator_t);
#define NEW_ITERATOR_TYPE(DIM) \
  NEW_OPAQUE_TYPE(legion_rect_in_domain_iterator_##DIM##d_t);
  LEGION_FOREACH_N(NEW_ITERATOR_TYPE);
#undef NEW_ITERATOR_TYPE
  NEW_OPAQUE_TYPE(legion_coloring_t);
  NEW_OPAQUE_TYPE(legion_domain_coloring_t);
  NEW_OPAQUE_TYPE(legion_point_coloring_t);
  NEW_OPAQUE_TYPE(legion_domain_point_coloring_t);
  NEW_OPAQUE_TYPE(legion_multi_domain_point_coloring_t);
  NEW_OPAQUE_TYPE(legion_index_space_allocator_t);
  NEW_OPAQUE_TYPE(legion_field_allocator_t);
  NEW_OPAQUE_TYPE(legion_argument_map_t);
  NEW_OPAQUE_TYPE(legion_predicate_t);
  NEW_OPAQUE_TYPE(legion_future_t);
  NEW_OPAQUE_TYPE(legion_future_map_t);
#define NEW_DEFERRED_BUFFER_TYPE(DIM) \
  NEW_OPAQUE_TYPE(legion_deferred_buffer_char_##DIM##d_t);
  LEGION_FOREACH_N(NEW_DEFERRED_BUFFER_TYPE)
#undef NEW_DEFERRED_BUFFER_TYPE
  NEW_OPAQUE_TYPE(legion_task_launcher_t);
  NEW_OPAQUE_TYPE(legion_index_launcher_t);
  NEW_OPAQUE_TYPE(legion_inline_launcher_t);
  NEW_OPAQUE_TYPE(legion_copy_launcher_t);
  NEW_OPAQUE_TYPE(legion_index_copy_launcher_t);
  NEW_OPAQUE_TYPE(legion_fill_launcher_t);
  NEW_OPAQUE_TYPE(legion_index_fill_launcher_t);
  NEW_OPAQUE_TYPE(legion_discard_launcher_t);
  NEW_OPAQUE_TYPE(legion_acquire_launcher_t);
  NEW_OPAQUE_TYPE(legion_release_launcher_t);
  NEW_OPAQUE_TYPE(legion_attach_launcher_t);
  NEW_OPAQUE_TYPE(legion_index_attach_launcher_t);
  NEW_OPAQUE_TYPE(legion_must_epoch_launcher_t);
  NEW_OPAQUE_TYPE(legion_physical_region_t);
  NEW_OPAQUE_TYPE(legion_external_resources_t);
#define NEW_ACCESSOR_ARRAY_TYPE(DIM) \
  NEW_OPAQUE_TYPE(legion_accessor_array_##DIM##d_t);
  LEGION_FOREACH_N(NEW_ACCESSOR_ARRAY_TYPE)
#undef NEW_ACCESSOR_ARRAY_TYPE
  NEW_OPAQUE_TYPE(legion_task_t);
  NEW_OPAQUE_TYPE(legion_task_mut_t);
  NEW_OPAQUE_TYPE(legion_copy_t);
  NEW_OPAQUE_TYPE(legion_fill_t);
  NEW_OPAQUE_TYPE(legion_inline_t);
  NEW_OPAQUE_TYPE(legion_mappable_t);
  NEW_OPAQUE_TYPE(legion_region_requirement_t);
  NEW_OPAQUE_TYPE(legion_output_requirement_t);
  NEW_OPAQUE_TYPE(legion_machine_t);
  NEW_OPAQUE_TYPE(legion_logger_t);
  NEW_OPAQUE_TYPE(legion_mapper_t);
  NEW_OPAQUE_TYPE(legion_default_mapper_t);
  NEW_OPAQUE_TYPE(legion_processor_query_t);
  NEW_OPAQUE_TYPE(legion_memory_query_t);
  NEW_OPAQUE_TYPE(legion_machine_query_interface_t);
  NEW_OPAQUE_TYPE(legion_execution_constraint_set_t);
  NEW_OPAQUE_TYPE(legion_layout_constraint_set_t);
  NEW_OPAQUE_TYPE(legion_task_layout_constraint_set_t);
  NEW_OPAQUE_TYPE(legion_slice_task_output_t);
  NEW_OPAQUE_TYPE(legion_map_task_input_t);
  NEW_OPAQUE_TYPE(legion_map_task_output_t);
  NEW_OPAQUE_TYPE(legion_physical_instance_t);
  NEW_OPAQUE_TYPE(legion_mapper_runtime_t);
  NEW_OPAQUE_TYPE(legion_mapper_context_t);
  NEW_OPAQUE_TYPE(legion_field_map_t);
  NEW_OPAQUE_TYPE(legion_point_transform_functor_t);
  NEW_OPAQUE_TYPE(legion_task_variant_registrar_t);
#undef NEW_OPAQUE_TYPE
 
  typedef struct legion_ptr_t {
    long long int value;
  } legion_ptr_t;
 
  typedef legion_coord_t coord_t;
 
#define NEW_POINT_TYPE(DIM)                \
  typedef struct legion_point_##DIM##d_t { \
    coord_t x[DIM];                        \
  } legion_point_##DIM##d_t;
  LEGION_FOREACH_N(NEW_POINT_TYPE)
#undef NEW_POINT_TYPE
 
#define NEW_RECT_TYPE(DIM)                \
  typedef struct legion_rect_##DIM##d_t { \
    legion_point_##DIM##d_t lo, hi;       \
  } legion_rect_##DIM##d_t;
  LEGION_FOREACH_N(NEW_RECT_TYPE)
#undef NEW_RECT_TYPE
 
#define NEW_BLOCKIFY_TYPE(DIM)                \
  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;
  LEGION_FOREACH_N(NEW_BLOCKIFY_TYPE)
#undef NEW_BLOCKIFY_TYPE
 
#define NEW_TRANSFORM_TYPE(D1, D2)                  \
  typedef struct legion_transform_##D1##x##D2##_t { \
    coord_t trans[D1][D2];                          \
  } legion_transform_##D1##x##D2##_t;
  LEGION_FOREACH_NN(NEW_TRANSFORM_TYPE)
#undef NEW_TRANSFORM_TYPE
 
#define NEW_AFFINE_TRANSFORM_TYPE(D1, D2)                  \
  typedef struct legion_affine_transform_##D1##x##D2##_t { \
    legion_transform_##D1##x##D2##_t transform;            \
    legion_point_##D1##d_t offset;                         \
  } legion_affine_transform_##D1##x##D2##_t;
  LEGION_FOREACH_NN(NEW_AFFINE_TRANSFORM_TYPE)
#undef NEW_AFFINE_TRANSFORM_TYPE
 
  typedef struct legion_domain_t {
    realm_id_t is_id;
    legion_type_tag_t is_type;
    int dim;
// Hack: Python CFFI isn't smart enough to do constant folding so we
// have to do this by hand here. To avoid this bitrotting, at least
// make the preprocessor check that the value is equal to what we
// expect.
#if LEGION_MAX_DIM == 1
#define MAX_DOMAIN_DIM 2  // 2 * LEGION_MAX_RECT_DIM
#elif LEGION_MAX_DIM == 2
#define MAX_DOMAIN_DIM 4  // 2 * LEGION_MAX_RECT_DIM
#elif LEGION_MAX_DIM == 3
#define MAX_DOMAIN_DIM 6  // 2 * LEGION_MAX_RECT_DIM
#elif LEGION_MAX_DIM == 4
#define MAX_DOMAIN_DIM 8  // 2 * LEGION_MAX_RECT_DIM
#elif LEGION_MAX_DIM == 5
#define MAX_DOMAIN_DIM 10  // 2 * LEGION_MAX_RECT_DIM
#elif LEGION_MAX_DIM == 6
#define MAX_DOMAIN_DIM 12  // 2 * LEGION_MAX_RECT_DIM
#elif LEGION_MAX_DIM == 7
#define MAX_DOMAIN_DIM 14  // 2 * LEGION_MAX_RECT_DIM
#elif LEGION_MAX_DIM == 8
#define MAX_DOMAIN_DIM 16  // 2 * LEGION_MAX_RECT_DIM
#elif LEGION_MAX_DIM == 9
#define MAX_DOMAIN_DIM 18  // 2 * LEGION_MAX_RECT_DIM
#else
#error "Illegal value of LEGION_MAX_DIM"
#endif
#if MAX_DOMAIN_DIM != 2 * LEGION_MAX_RECT_DIM  // sanity check value
#error Mismatch in MAX_DOMAIN_DIM
#endif
    coord_t rect_data[MAX_DOMAIN_DIM];
#undef MAX_DOMAIN_DIM
  } legion_domain_t;
 
  typedef struct legion_domain_point_t {
    int dim;
    coord_t point_data[LEGION_MAX_DIM];
  } legion_domain_point_t;
 
  typedef struct legion_domain_transform_t {
    int m, n;
// Hack: Python CFFI isn't smart enough to do constant folding so we
// have to do this by hand here. To avoid this bitrotting, at least
// make the preprocessor check that the value is equal to what we
// expect.
#if LEGION_MAX_DIM == 1
#define MAX_MATRIX_DIM 1
#elif LEGION_MAX_DIM == 2
#define MAX_MATRIX_DIM 4
#elif LEGION_MAX_DIM == 3
#define MAX_MATRIX_DIM 9
#elif LEGION_MAX_DIM == 4
#define MAX_MATRIX_DIM 16
#elif LEGION_MAX_DIM == 5
#define MAX_MATRIX_DIM 25
#elif LEGION_MAX_DIM == 6
#define MAX_MATRIX_DIM 36
#elif LEGION_MAX_DIM == 7
#define MAX_MATRIX_DIM 49
#elif LEGION_MAX_DIM == 8
#define MAX_MATRIX_DIM 64
#elif LEGION_MAX_DIM == 9
#define MAX_MATRIX_DIM 81
#else
#error "Illegal value of LEGION_MAX_DIM"
#endif
#if MAX_MATRIX_DIM != \
    LEGION_MAX_POINT_DIM * LEGION_MAX_POINT_DIM  // sanity check
#error Mismatch in MAX_MATRIX_DIM
#endif
    coord_t matrix[MAX_MATRIX_DIM];
#undef MAX_MATRIX_DIM
  } legion_domain_transform_t;
 
  typedef struct legion_domain_affine_transform_t {
    legion_domain_transform_t transform;
    legion_domain_point_t offset;
  } legion_domain_affine_transform_t;
 
  typedef struct legion_index_space_t {
    legion_distributed_id_t id;
    legion_index_tree_id_t tid;
    legion_type_tag_t type_tag;
  } legion_index_space_t;
 
  typedef struct legion_index_partition_t {
    legion_distributed_id_t id;
    legion_index_tree_id_t tid;
    legion_type_tag_t type_tag;
  } legion_index_partition_t;
 
  typedef struct legion_field_space_t {
    legion_distributed_id_t id;
  } legion_field_space_t;
 
  typedef struct legion_logical_region_t {
    legion_distributed_id_t tree_id;
    legion_index_space_t index_space;
    legion_field_space_t field_space;
  } legion_logical_region_t;
 
  typedef struct legion_logical_partition_t {
    legion_distributed_id_t tree_id;
    legion_index_partition_t index_partition;
    legion_field_space_t field_space;
  } legion_logical_partition_t;
 
  typedef struct legion_untyped_buffer_t {
    void* args;
    size_t arglen;
  } legion_untyped_buffer_t;
  // This is for backwards compatibility when we used
  // to call legion_untyped_buffer_t as legion_task_argument_t
  typedef legion_untyped_buffer_t legion_task_argument_t;
 
  typedef struct legion_byte_offset_t {
    int offset;
  } legion_byte_offset_t;
 
  typedef struct legion_input_args_t {
    char** argv;
    int argc;
  } legion_input_args_t;
 
  typedef struct legion_task_config_options_t {
    bool leaf /* = false */;
    bool inner /* = false */;
    bool idempotent /* = false */;
    bool replicable /* = false */;
  } legion_task_config_options_t;
 
  typedef struct legion_processor_t {
    realm_id_t id;
  } legion_processor_t;
 
  typedef struct legion_memory_t {
    realm_id_t id;
  } legion_memory_t;
 
  typedef struct legion_task_slice_t {
    legion_domain_t domain;
    legion_processor_t proc;
    bool recurse;
    bool stealable;
  } legion_task_slice_t;
 
  typedef struct legion_phase_barrier_t {
    // From Realm::Event
    realm_id_t id;
    // From Realm::Barrier
    realm_barrier_timestamp_t timestamp;
  } legion_phase_barrier_t;
 
  typedef struct legion_dynamic_collective_t {
    // From Legion::PhaseBarrier
    //   From Realm::Event
    realm_id_t id;
    //   From Realm::Barrier
    realm_barrier_timestamp_t timestamp;
    // From Legion::DynamicCollective
    legion_reduction_op_id_t redop;
  } legion_dynamic_collective_t;
 
  typedef struct legion_task_options_t {
    legion_processor_t initial_proc;
    bool inline_task;
    bool stealable;
    bool map_locally;
    bool valid_instances;
    bool memoize;
    bool replicate;
    legion_task_priority_t parent_priority;
  } legion_task_options_t;
 
  typedef struct legion_slice_task_input_t {
    legion_domain_t domain;
  } legion_slice_task_input_t;
 
  typedef void (*legion_registration_callback_pointer_t)(
      legion_machine_t /* machine */, legion_runtime_t /* runtime */,
      const legion_processor_t* /* local_procs */,
      unsigned /* num_local_procs */);
 
  typedef realm_task_pointer_t legion_task_pointer_wrapped_t;
 
  typedef legion_logical_region_t (*legion_projection_functor_logical_region_t)(
      legion_runtime_t /* runtime */, legion_logical_region_t /* upper_bound */,
      legion_domain_point_t /* point */, legion_domain_t /* launch domain */);
 
  typedef legion_logical_region_t (
      *legion_projection_functor_logical_partition_t)(
      legion_runtime_t /* runtime */,
      legion_logical_partition_t /* upper_bound */,
      legion_domain_point_t /* point */, legion_domain_t /* launch domain */);
 
  typedef legion_logical_region_t (
      *legion_projection_functor_logical_region_args_t)(
      legion_runtime_t /* runtime */, legion_logical_region_t /* upper_bound */,
      legion_domain_point_t /* point */, legion_domain_t /* launch domain */,
      const void* /* args */, size_t /* size */);
 
  typedef legion_logical_region_t (
      *legion_projection_functor_logical_partition_args_t)(
      legion_runtime_t /* runtime */,
      legion_logical_partition_t /* upper_bound */,
      legion_domain_point_t /* point */, legion_domain_t /* launch domain */,
      const void* /* args */, size_t /* size */);
 
  typedef legion_logical_region_t (
      *legion_projection_functor_logical_region_mappable_t)(
      legion_runtime_t /* runtime */, legion_mappable_t /* mappable */,
      unsigned /* index */, legion_logical_region_t /* upper_bound */,
      legion_domain_point_t /* point */);
 
  typedef legion_logical_region_t (
      *legion_projection_functor_logical_partition_mappable_t)(
      legion_runtime_t /* runtime */, legion_mappable_t /* mappable */,
      unsigned /* index */, legion_logical_partition_t /* upper_bound */,
      legion_domain_point_t /* point */);
 
  // -----------------------------------------------------------------------
  // Pointer Operations
  // -----------------------------------------------------------------------
 
  legion_ptr_t legion_ptr_nil(void);
 
  bool legion_ptr_is_null(legion_ptr_t ptr);
 
  legion_ptr_t legion_ptr_safe_cast(
      legion_runtime_t runtime, legion_context_t ctx, legion_ptr_t pointer,
      legion_logical_region_t region);
 
  // -----------------------------------------------------------------------
  // Domain Operations
  // -----------------------------------------------------------------------
 
  legion_domain_t legion_domain_empty(unsigned dim);
 
#define FROM_RECT(DIM) \
  legion_domain_t legion_domain_from_rect_##DIM##d(legion_rect_##DIM##d_t r);
  LEGION_FOREACH_N(FROM_RECT)
#undef FROM_RECT
 
  legion_domain_t legion_domain_from_index_space(
      legion_runtime_t runtime, legion_index_space_t is);
 
#define GET_RECT(DIM) \
  legion_rect_##DIM##d_t legion_domain_get_rect_##DIM##d(legion_domain_t d);
  LEGION_FOREACH_N(GET_RECT)
#undef GET_RECT
 
  bool legion_domain_is_dense(legion_domain_t d);
 
  // These are the same as above but will ignore
  // the existence of any sparsity map, whereas the
  // ones above will fail if a sparsity map exists
#define GET_BOUNDS(DIM) \
  legion_rect_##DIM##d_t legion_domain_get_bounds_##DIM##d(legion_domain_t d);
  LEGION_FOREACH_N(GET_BOUNDS)
#undef GET_BOUNDS
 
  bool legion_domain_contains(legion_domain_t d, legion_domain_point_t p);
 
  size_t legion_domain_get_volume(legion_domain_t d);
 
  // -----------------------------------------------------------------------
  // Domain Transform Operations
  // -----------------------------------------------------------------------
 
  legion_domain_transform_t legion_domain_transform_identity(
      unsigned m, unsigned n);
 
#define FROM_TRANSFORM(D1, D2)                                        \
  legion_domain_transform_t legion_domain_transform_from_##D1##x##D2( \
      legion_transform_##D1##x##D2##_t t);
  LEGION_FOREACH_NN(FROM_TRANSFORM)
#undef FROM_TRANSFORM
 
  legion_domain_affine_transform_t legion_domain_affine_transform_identity(
      unsigned m, unsigned n);
 
#define FROM_AFFINE(D1, D2)                            \
  legion_domain_affine_transform_t                     \
      legion_domain_affine_transform_from_##D1##x##D2( \
          legion_affine_transform_##D1##x##D2##_t t);
  LEGION_FOREACH_NN(FROM_AFFINE)
#undef FROM_AFFINE
 
  // -----------------------------------------------------------------------
  // Domain Point Operations
  // -----------------------------------------------------------------------
 
#define FROM_POINT(DIM)                                          \
  legion_domain_point_t legion_domain_point_from_point_##DIM##d( \
      legion_point_##DIM##d_t p);
  LEGION_FOREACH_N(FROM_POINT)
#undef FROM_POINT
 
#define GET_POINT(DIM)                                            \
  legion_point_##DIM##d_t legion_domain_point_get_point_##DIM##d( \
      legion_domain_point_t p);
  LEGION_FOREACH_N(GET_POINT)
#undef GET_POINT
 
  legion_domain_point_t legion_domain_point_origin(unsigned dim);
 
  legion_domain_point_t legion_domain_point_nil(void);
 
  bool legion_domain_point_is_null(legion_domain_point_t point);
 
  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);
 
  // -----------------------------------------------------------------------
  // Domain Point Iterator
  // -----------------------------------------------------------------------
 
  legion_domain_point_iterator_t legion_domain_point_iterator_create(
      legion_domain_t handle);
 
  void legion_domain_point_iterator_destroy(
      legion_domain_point_iterator_t handle);
 
  bool legion_domain_point_iterator_has_next(
      legion_domain_point_iterator_t handle);
 
  legion_domain_point_t legion_domain_point_iterator_next(
      legion_domain_point_iterator_t handle);
 
  // -----------------------------------------------------------------------
  // Rect in Domain Iterator
  // -----------------------------------------------------------------------
 
#define ITERATOR_CREATE(DIM)                \
  legion_rect_in_domain_iterator_##DIM##d_t \
      legion_rect_in_domain_iterator_create_##DIM##d(legion_domain_t handle);
  LEGION_FOREACH_N(ITERATOR_CREATE)
#undef ITERATOR_CREATE
 
#define ITERATOR_DESTROY(DIM)                           \
  void legion_rect_in_domain_iterator_destroy_##DIM##d( \
      legion_rect_in_domain_iterator_##DIM##d_t handle);
  LEGION_FOREACH_N(ITERATOR_DESTROY)
#undef ITERATOR_DESTROY
 
#define ITERATOR_VALID(DIM)                           \
  bool legion_rect_in_domain_iterator_valid_##DIM##d( \
      legion_rect_in_domain_iterator_##DIM##d_t handle);
  LEGION_FOREACH_N(ITERATOR_VALID)
#undef ITERATOR_VALID
 
#define ITERATOR_STEP(DIM)                           \
  bool legion_rect_in_domain_iterator_step_##DIM##d( \
      legion_rect_in_domain_iterator_##DIM##d_t handle);
  LEGION_FOREACH_N(ITERATOR_STEP)
#undef ITERATOR_STEP
 
#define ITERATOR_OP(DIM)                                                   \
  legion_rect_##DIM##d_t legion_rect_in_domain_iterator_get_rect_##DIM##d( \
      legion_rect_in_domain_iterator_##DIM##d_t handle);
  LEGION_FOREACH_N(ITERATOR_OP)
#undef ITERATOR_OP
 
  // -----------------------------------------------------------------------
  // Coloring Operations
  // -----------------------------------------------------------------------
 
  legion_coloring_t legion_coloring_create(void);
 
  void legion_coloring_destroy(legion_coloring_t handle);
 
  void legion_coloring_ensure_color(
      legion_coloring_t handle, legion_color_t color);
 
  void legion_coloring_add_point(
      legion_coloring_t handle, legion_color_t color, legion_ptr_t point);
 
  void legion_coloring_delete_point(
      legion_coloring_t handle, legion_color_t color, legion_ptr_t point);
 
  bool legion_coloring_has_point(
      legion_coloring_t handle, legion_color_t color, legion_ptr_t point);
 
  void legion_coloring_add_range(
      legion_coloring_t handle, legion_color_t color, legion_ptr_t start,
      legion_ptr_t end );
 
  // -----------------------------------------------------------------------
  // Domain Coloring Operations
  // -----------------------------------------------------------------------
 
  legion_domain_coloring_t legion_domain_coloring_create(void);
 
  void legion_domain_coloring_destroy(legion_domain_coloring_t handle);
 
  void legion_domain_coloring_color_domain(
      legion_domain_coloring_t handle, legion_color_t color,
      legion_domain_t domain);
 
  legion_domain_t legion_domain_coloring_get_color_space(
      legion_domain_coloring_t handle);
 
  // -----------------------------------------------------------------------
  // Point Coloring Operations
  // -----------------------------------------------------------------------
 
  legion_point_coloring_t legion_point_coloring_create(void);
 
  void legion_point_coloring_destroy(legion_point_coloring_t handle);
 
  void legion_point_coloring_add_point(
      legion_point_coloring_t handle, legion_domain_point_t color,
      legion_ptr_t point);
 
  void legion_point_coloring_add_range(
      legion_point_coloring_t handle, legion_domain_point_t color,
      legion_ptr_t start, legion_ptr_t end );
 
  // -----------------------------------------------------------------------
  // Domain Point Coloring Operations
  // -----------------------------------------------------------------------
 
  legion_domain_point_coloring_t legion_domain_point_coloring_create(void);
 
  void legion_domain_point_coloring_destroy(
      legion_domain_point_coloring_t handle);
 
  void legion_domain_point_coloring_color_domain(
      legion_domain_point_coloring_t handle, legion_domain_point_t color,
      legion_domain_t domain);
 
  // -----------------------------------------------------------------------
  // Multi-Domain Point Coloring Operations
  // -----------------------------------------------------------------------
 
  legion_multi_domain_point_coloring_t
      legion_multi_domain_point_coloring_create(void);
 
  void legion_multi_domain_point_coloring_destroy(
      legion_multi_domain_point_coloring_t handle);
 
  void legion_multi_domain_point_coloring_color_domain(
      legion_multi_domain_point_coloring_t handle, legion_domain_point_t color,
      legion_domain_t domain);
 
  // -----------------------------------------------------------------------
  // Index Space Operations
  // ----------------------------------------------------------------------
 
  legion_index_space_t legion_index_space_create(
      legion_runtime_t runtime, legion_context_t ctx, size_t max_num_elmts);
 
  legion_index_space_t legion_index_space_create_domain(
      legion_runtime_t runtime, legion_context_t ctx, legion_domain_t domain);
 
  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 /*=0*/);
 
  legion_index_space_t legion_index_space_union(
      legion_runtime_t runtime, legion_context_t ctx,
      const legion_index_space_t* spaces, size_t num_spaces);
 
  legion_index_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_space_t legion_index_space_subtraction(
      legion_runtime_t runtime, legion_context_t ctx, legion_index_space_t left,
      legion_index_space_t right);
 
  bool legion_index_space_has_multiple_domains(
      legion_runtime_t runtime, legion_index_space_t handle);
 
  legion_domain_t legion_index_space_get_domain(
      legion_runtime_t runtime, legion_index_space_t handle);
 
  bool legion_index_space_has_parent_index_partition(
      legion_runtime_t runtime, legion_index_space_t handle);
  legion_index_partition_t legion_index_space_get_parent_index_partition(
      legion_runtime_t runtime, legion_index_space_t handle);
 
  void legion_index_space_create_shared_ownership(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_index_space_t handle);
 
  void legion_index_space_destroy(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_index_space_t handle);
 
  void legion_index_space_destroy_unordered(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_index_space_t handle, bool unordered);
 
  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 /* = false */);
 
  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 /* = false */, bool wait_until_ready /* = false */);
 
  void legion_index_space_attach_name(
      legion_runtime_t runtime, legion_index_space_t handle, const char* name,
      bool is_mutable /* = false */);
 
  void legion_index_space_retrieve_name(
      legion_runtime_t runtime, legion_index_space_t handle,
      const char** result);
 
  int legion_index_space_get_dim(legion_index_space_t handle);
 
  // -----------------------------------------------------------------------
  // Index Partition Operations
  // -----------------------------------------------------------------------
 
  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 /* = AUTO_GENERATE_ID */);
 
  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 /* = AUTO_GENERATE_ID */);
 
  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 /* = COMPUTE_KIND */,
      legion_color_t color /* = AUTO_GENERATE_ID */);
 
  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 /* = COMPUTE_KIND */,
      legion_color_t color /* = AUTO_GENERATE_ID */);
 
  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 /* = COMPUTE_KIND */,
          legion_color_t color /* = AUTO_GENERATE_ID */);
 
#define CREATE_BLOCKIFY(DIM)                                                \
  legion_index_partition_t legion_index_partition_create_blockify_##DIM##d( \
      legion_runtime_t runtime, legion_context_t ctx,                       \
      legion_index_space_t parent, legion_blockify_##DIM##d_t blockify,     \
      legion_color_t part_color /* = AUTO_GENERATE_ID */);
  LEGION_FOREACH_N(CREATE_BLOCKIFY)
#undef CREATE_BLOCKIFY
 
  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 /* = AUTO_GENERATE_ID */);
 
  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 /* = 1 */,
      legion_color_t color /* = AUTO_GENERATE_ID */);
 
  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 /* = 1 */,
      legion_color_t color /* = AUTO_GENERATE_ID */);
 
  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 /* = COMPUTE_KIND */,
      legion_color_t color /* = AUTO_GENERATE_ID */);
 
  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 /* = COMPUTE_KIND */,
      legion_color_t color /* = AUTO_GENERATE_ID */);
 
  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 /* = COMPUTE_KIND */,
      legion_color_t color /* = AUTO_GENERATE_ID */,
      bool dominates /* = false */);
 
  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 /* = COMPUTE_KIND */,
      legion_color_t color /* = AUTO_GENERATE_ID */);
 
  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 /* = true */,
      legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
      legion_color_t color /* = AUTO_GENERATE_ID */);
 
  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 /* = true */,
      legion_partition_kind_t part_kind /* = COMPUTE_KIND */,
      legion_color_t color /* = AUTO_GENERATE_ID */);
 
  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 /* = AUTO_GENERATE_ID */,
      legion_mapper_id_t id /* = 0 */, legion_mapping_tag_id_t tag /* = 0 */,
      legion_partition_kind_t part_kind /* = DISJOINT_KIND */,
      legion_untyped_buffer_t map_arg);
 
  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 /* = COMPUTE_KIND */,
      legion_color_t color /* = AUTO_GENERATE_ID */,
      legion_mapper_id_t id /* = 0 */, legion_mapping_tag_id_t tag /* = 0 */,
      legion_untyped_buffer_t map_arg);
 
  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 /* = COMPUTE_KIND */,
      legion_color_t color /* = AUTO_GENERATE_ID */,
      legion_mapper_id_t id /* = 0 */, legion_mapping_tag_id_t tag /* = 0 */,
      legion_untyped_buffer_t map_arg);
 
  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 /* = COMPUTE_KIND */,
      legion_color_t color /* = AUTO_GENERATE_ID */,
      legion_mapper_id_t id /* = 0 */, legion_mapping_tag_id_t tag /* = 0 */,
      legion_untyped_buffer_t map_arg);
 
  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 /* = COMPUTE_KIND */,
      legion_color_t color /* = AUTO_GENERATE_ID */,
      legion_mapper_id_t id /* = 0 */, legion_mapping_tag_id_t tag /* = 0 */,
      legion_untyped_buffer_t map_arg);
 
  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 /* = COMPUTE_KIND */,
      legion_color_t color /* = AUTO_GENERATE_ID */);
 
  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 /* = COMPUTE_KIND */,
      legion_color_t color /* = AUTO_GENERATE_ID */);
 
  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_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_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_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_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);
 
  bool legion_index_partition_is_disjoint(
      legion_runtime_t runtime, legion_index_partition_t handle);
 
  bool legion_index_partition_is_complete(
      legion_runtime_t runtime, legion_index_partition_t handle);
 
  legion_index_space_t legion_index_partition_get_index_subspace(
      legion_runtime_t runtime, legion_index_partition_t handle,
      legion_color_t color);
 
  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);
 
  bool legion_index_partition_has_index_subspace_domain_point(
      legion_runtime_t runtime, legion_index_partition_t handle,
      legion_domain_point_t color);
 
  legion_index_space_t legion_index_partition_get_color_space(
      legion_runtime_t runtime, legion_index_partition_t handle);
 
  legion_color_t legion_index_partition_get_color(
      legion_runtime_t runtime, legion_index_partition_t handle);
 
  legion_index_space_t legion_index_partition_get_parent_index_space(
      legion_runtime_t runtime, legion_index_partition_t handle);
 
  void legion_index_partition_create_shared_ownership(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_index_partition_t handle);
 
  void legion_index_partition_destroy(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_index_partition_t handle);
 
  void legion_index_partition_destroy_unordered(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_index_partition_t handle, bool unordered /* = false */,
      bool recurse /* = true */);
 
  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 /* = false */);
 
  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 /* = false */, bool wait_until_ready /* = false */);
 
  void legion_index_partition_attach_name(
      legion_runtime_t runtime, legion_index_partition_t handle,
      const char* name, bool is_mutable /* = false */);
 
  void legion_index_partition_retrieve_name(
      legion_runtime_t runtime, legion_index_partition_t handle,
      const char** result);
 
  // -----------------------------------------------------------------------
  // Field Space Operations
  // -----------------------------------------------------------------------
 
  legion_field_space_t legion_field_space_create(
      legion_runtime_t runtime, legion_context_t ctx);
 
  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_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_field_space_t legion_field_space_no_space();
 
  void legion_field_space_create_shared_ownership(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_field_space_t handle);
 
  void legion_field_space_destroy(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_field_space_t handle);
 
  void legion_field_space_destroy_unordered(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_field_space_t handle, bool unordered);
 
  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 /* = false */);
 
  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 /* = false */, bool wait_until_ready /* = false */);
 
  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);
 
  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);
 
  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 /* = false */);
 
  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 /* = false */,
      bool wait_until_ready /* = false */);
 
  void legion_field_space_attach_name(
      legion_runtime_t runtime, legion_field_space_t handle, const char* name,
      bool is_mutable /* = false */);
 
  void legion_field_space_retrieve_name(
      legion_runtime_t runtime, legion_field_space_t handle,
      const char** result);
 
  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 /* = false */);
 
  void legion_field_id_retrieve_name(
      legion_runtime_t runtime, legion_field_space_t handle,
      legion_field_id_t id, const char** result);
 
  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);
 
  // -----------------------------------------------------------------------
  // Logical Region Operations
  // -----------------------------------------------------------------------
 
  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);
 
  void legion_logical_region_create_shared_ownership(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_logical_region_t handle);
 
  void legion_logical_region_destroy(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_logical_region_t handle);
 
  void legion_logical_region_destroy_unordered(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_logical_region_t handle, bool unordered);
 
  legion_color_t legion_logical_region_get_color(
      legion_runtime_t runtime, legion_logical_region_t handle);
 
  legion_domain_point_t legion_logical_region_get_color_domain_point(
      legion_runtime_t runtime_, legion_logical_region_t handle_);
 
  bool legion_logical_region_has_parent_logical_partition(
      legion_runtime_t runtime, legion_logical_region_t handle);
 
  legion_logical_partition_t legion_logical_region_get_parent_logical_partition(
      legion_runtime_t runtime, legion_logical_region_t handle);
 
  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 /* = false */);
 
  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 /* = false */, bool wait_until_ready /* = false */);
 
  void legion_logical_region_attach_name(
      legion_runtime_t runtime, legion_logical_region_t handle,
      const char* name, bool is_mutable /* = false */);
 
  void legion_logical_region_retrieve_name(
      legion_runtime_t runtime, legion_logical_region_t handle,
      const char** result);
 
  legion_index_space_t legion_logical_region_get_index_space(
      legion_logical_region_t handle);
 
  // -----------------------------------------------------------------------
  // Logical Region Tree Traversal Operations
  // -----------------------------------------------------------------------
 
  legion_logical_partition_t legion_logical_partition_create(
      legion_runtime_t runtime, legion_logical_region_t parent,
      legion_index_partition_t handle);
 
  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);
 
  void legion_logical_partition_destroy(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_logical_partition_t handle);
 
  void legion_logical_partition_destroy_unordered(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_logical_partition_t handle, bool unordered);
 
  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_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_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);
 
  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_logical_region_t
      legion_logical_partition_get_logical_subregion_by_tree(
          legion_runtime_t runtime, legion_index_space_t handle,
          legion_field_space_t fspace, legion_region_tree_id_t tid);
 
  legion_logical_region_t legion_logical_partition_get_parent_logical_region(
      legion_runtime_t runtime, legion_logical_partition_t handle);
 
  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 /* = false */);
 
  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 /* = false */, bool wait_until_ready /* = false */);
 
  void legion_logical_partition_attach_name(
      legion_runtime_t runtime, legion_logical_partition_t handle,
      const char* name, bool is_mutable /* = false */);
 
  void legion_logical_partition_retrieve_name(
      legion_runtime_t runtime, legion_logical_partition_t handle,
      const char** result);
 
  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);
 
  // -----------------------------------------------------------------------
  // Region Requirement Operations
  // -----------------------------------------------------------------------
 
  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 /* = 0 */, bool verified /* = false*/);
 
  legion_region_requirement_t
      legion_region_requirement_create_logical_region_projection(
          legion_logical_region_t handle, legion_projection_id_t proj /* = 0 */,
          legion_privilege_mode_t priv, legion_coherence_property_t prop,
          legion_logical_region_t parent, legion_mapping_tag_id_t tag /* = 0 */,
          bool verified /* = false*/);
 
  legion_region_requirement_t
      legion_region_requirement_create_logical_partition(
          legion_logical_partition_t handle,
          legion_projection_id_t proj /* = 0 */, legion_privilege_mode_t priv,
          legion_coherence_property_t prop, legion_logical_region_t parent,
          legion_mapping_tag_id_t tag /* = 0 */, bool verified /* = false*/);
 
  void legion_region_requirement_destroy(legion_region_requirement_t handle);
 
  void legion_region_requirement_add_field(
      legion_region_requirement_t handle, legion_field_id_t field,
      bool instance_field);
 
  void legion_region_requirement_add_flags(
      legion_region_requirement_t handle, legion_region_flags_t flags);
 
  legion_logical_region_t legion_region_requirement_get_region(
      legion_region_requirement_t handle);
 
  legion_logical_region_t legion_region_requirement_get_parent(
      legion_region_requirement_t handle);
 
  legion_logical_partition_t legion_region_requirement_get_partition(
      legion_region_requirement_t handle);
 
  unsigned legion_region_requirement_get_privilege_fields_size(
      legion_region_requirement_t handle);
 
  void legion_region_requirement_get_privilege_fields(
      legion_region_requirement_t handle, legion_field_id_t* fields,
      unsigned fields_size);
 
  legion_field_id_t legion_region_requirement_get_privilege_field(
      legion_region_requirement_t handle, unsigned idx);
 
  unsigned legion_region_requirement_get_instance_fields_size(
      legion_region_requirement_t handle);
 
  void legion_region_requirement_get_instance_fields(
      legion_region_requirement_t handle, legion_field_id_t* fields,
      unsigned fields_size);
 
  legion_field_id_t legion_region_requirement_get_instance_field(
      legion_region_requirement_t handle, unsigned idx);
 
  legion_privilege_mode_t legion_region_requirement_get_privilege(
      legion_region_requirement_t handle);
 
  legion_coherence_property_t legion_region_requirement_get_prop(
      legion_region_requirement_t handle);
 
  legion_reduction_op_id_t legion_region_requirement_get_redop(
      legion_region_requirement_t handle);
 
  legion_mapping_tag_id_t legion_region_requirement_get_tag(
      legion_region_requirement_t handle);
 
  legion_handle_type_t legion_region_requirement_get_handle_type(
      legion_region_requirement_t handle);
 
  legion_projection_id_t legion_region_requirement_get_projection(
      legion_region_requirement_t handle);
 
  // -----------------------------------------------------------------------
  // Output Requirement Operations
  // -----------------------------------------------------------------------
 
  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_output_requirement_t
      legion_output_requirement_create_region_requirement(
          legion_region_requirement_t handle);
 
  void legion_output_requirement_destroy(legion_output_requirement_t handle);
 
  void legion_output_requirement_add_field(
      legion_output_requirement_t handle, legion_field_id_t field,
      bool instance);
 
  legion_logical_region_t legion_output_requirement_get_region(
      legion_output_requirement_t handle);
 
  legion_logical_region_t legion_output_requirement_get_parent(
      legion_output_requirement_t handle);
 
  legion_logical_partition_t legion_output_requirement_get_partition(
      legion_output_requirement_t handle);
 
  // -----------------------------------------------------------------------
  // Allocator and Argument Map Operations
  // -----------------------------------------------------------------------
 
  legion_field_allocator_t legion_field_allocator_create(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_field_space_t handle);
 
  void legion_field_allocator_destroy(legion_field_allocator_t handle);
 
  legion_field_id_t legion_auto_generate_id(void);
 
  legion_field_id_t legion_field_allocator_allocate_field(
      legion_field_allocator_t allocator, size_t field_size,
      legion_field_id_t desired_fieldid /* = AUTO_GENERATE_ID */);
 
  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 /* = AUTO_GENERATE_ID */);
 
  void legion_field_allocator_free_field(
      legion_field_allocator_t allocator, legion_field_id_t fid);
 
  void legion_field_allocator_free_field_unordered(
      legion_field_allocator_t allocator, legion_field_id_t fid,
      bool unordered);
 
  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 /* = AUTO_GENERATE_ID */);
 
  legion_argument_map_t legion_argument_map_create(void);
 
  legion_argument_map_t legion_argument_map_from_future_map(
      legion_future_map_t map);
 
  void legion_argument_map_set_point(
      legion_argument_map_t map, legion_domain_point_t dp,
      legion_untyped_buffer_t arg, bool replace /* = true */);
 
  void legion_argument_map_set_future(
      legion_argument_map_t map, legion_domain_point_t dp,
      legion_future_t future, bool replace /* = true */);
 
  void legion_argument_map_destroy(legion_argument_map_t handle);
 
  // -----------------------------------------------------------------------
  // Predicate Operations
  // -----------------------------------------------------------------------
 
  legion_predicate_t legion_predicate_create(
      legion_runtime_t runtime, legion_context_t ctx, legion_future_t f);
 
  void legion_predicate_destroy(legion_predicate_t handle);
 
  const legion_predicate_t legion_predicate_true(void);
 
  const legion_predicate_t legion_predicate_false(void);
 
  // -----------------------------------------------------------------------
  // Phase Barrier Operations
  // -----------------------------------------------------------------------
 
  legion_phase_barrier_t legion_phase_barrier_create(
      legion_runtime_t runtime, legion_context_t ctx, unsigned arrivals);
 
  void legion_phase_barrier_destroy(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_phase_barrier_t handle);
 
  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);
 
  void legion_phase_barrier_arrive(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_phase_barrier_t handle, unsigned count /* = 1 */);
 
  void legion_phase_barrier_wait(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_phase_barrier_t handle);
 
  legion_phase_barrier_t legion_phase_barrier_advance(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_phase_barrier_t handle);
 
  // -----------------------------------------------------------------------
  // Dynamic Collective Operations
  // -----------------------------------------------------------------------
 
  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);
 
  void legion_dynamic_collective_destroy(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_dynamic_collective_t handle);
 
  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);
 
  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 /* = 1 */);
 
  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 /* = 1 */);
 
  legion_future_t legion_dynamic_collective_get_result(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_dynamic_collective_t handle);
 
  legion_dynamic_collective_t legion_dynamic_collective_advance(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_dynamic_collective_t handle);
 
  // -----------------------------------------------------------------------
  // Future Operations
  // -----------------------------------------------------------------------
 
  legion_future_t legion_future_from_untyped_pointer(
      legion_runtime_t runtime, const void* buffer, size_t size);
 
  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_future_t legion_future_copy(legion_future_t handle);
 
  void legion_future_destroy(legion_future_t handle);
 
  void legion_future_get_void_result(legion_future_t handle);
 
  void legion_future_wait(
      legion_future_t handle, bool silence_warnings /* = false */,
      const char* warning_string /* = nullptr */);
 
  bool legion_future_is_empty(legion_future_t handle, bool block /* = false */);
 
  bool legion_future_is_ready(legion_future_t handle);
 
  bool legion_future_is_ready_subscribe(legion_future_t handle, bool subscribe);
 
  const void* legion_future_get_untyped_pointer(legion_future_t handle);
 
  size_t legion_future_get_untyped_size(legion_future_t handle);
 
  const void* legion_future_get_metadata(
      legion_future_t handle, size_t* size /*=nullptr*/);
 
  // -----------------------------------------------------------------------
  // Future Map Operations
  // -----------------------------------------------------------------------
 
  legion_future_map_t legion_future_map_copy(legion_future_map_t handle);
 
  void legion_future_map_destroy(legion_future_map_t handle);
 
  void legion_future_map_wait_all_results(legion_future_map_t handle);
 
  legion_future_t legion_future_map_get_future(
      legion_future_map_t handle, legion_domain_point_t point);
 
  legion_domain_t legion_future_map_get_domain(legion_future_map_t handle);
 
  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_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_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_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_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);
 
  // -----------------------------------------------------------------------
  // Deferred Buffer Operations
  // -----------------------------------------------------------------------
 
#define BUFFER_CREATE(DIM)                                          \
  legion_deferred_buffer_char_##DIM##d_t                            \
      legion_deferred_buffer_char_##DIM##d_create(                  \
          legion_rect_##DIM##d_t bounds, legion_memory_kind_t kind, \
          char* initial_value);
  LEGION_FOREACH_N(BUFFER_CREATE)
#undef BUFFER_CREATE
 
  /*
   * @see Legion::DeferredBuffer::ptr()
   */
#define BUFFER_PTR(DIM)                              \
  char* legion_deferred_buffer_char_##DIM##d_ptr(    \
      legion_deferred_buffer_char_##DIM##d_t buffer, \
      legion_point_##DIM##d_t p);
  LEGION_FOREACH_N(BUFFER_PTR)
#undef BUFFER_PTR
 
  /*
   * @see Legion::DeferredBuffer::~DeferredBuffer()
   */
#define BUFFER_DESTROY(DIM)                          \
  void legion_deferred_buffer_char_##DIM##d_destroy( \
      legion_deferred_buffer_char_##DIM##d_t buffer);
  LEGION_FOREACH_N(BUFFER_DESTROY)
#undef BUFFER_DESTROY
 
  // -----------------------------------------------------------------------
  // Task Launch Operations
  // -----------------------------------------------------------------------
 
  legion_task_launcher_t legion_task_launcher_create(
      legion_task_id_t tid, legion_untyped_buffer_t arg,
      legion_predicate_t pred /* = legion_predicate_true() */,
      legion_mapper_id_t id /* = 0 */, legion_mapping_tag_id_t tag /* = 0 */);
 
  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_predicate_true() */,
      legion_mapper_id_t id /* = 0 */, legion_mapping_tag_id_t tag /* = 0 */);
 
  void legion_task_launcher_destroy(legion_task_launcher_t handle);
 
  legion_future_t legion_task_launcher_execute(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_task_launcher_t launcher);
 
  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);
 
  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 /* = 0 */,
      bool verified /* = false*/);
 
  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 /* = 0 */,
      bool verified /* = false*/);
 
  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 /* = 0 */, bool verified /* = false*/);
 
  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 /* = 0 */, bool verified /* = false*/);
 
  void legion_task_launcher_add_field(
      legion_task_launcher_t launcher, unsigned idx, legion_field_id_t fid,
      bool inst /* = true */);
 
  const void* legion_index_launcher_get_projection_args(
      legion_region_requirement_t requirement, size_t* size);
 
  void legion_index_launcher_set_projection_args(
      legion_index_launcher_t launcher_, unsigned idx, const void* args,
      size_t size, bool own);
 
  void legion_task_launcher_add_flags(
      legion_task_launcher_t launcher, unsigned idx,
      enum legion_region_flags_t flags);
 
  void legion_task_launcher_intersect_flags(
      legion_task_launcher_t launcher, unsigned idx,
      enum legion_region_flags_t flags);
 
  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 /* = false*/);
 
  void legion_task_launcher_add_future(
      legion_task_launcher_t launcher, legion_future_t future);
 
  void legion_task_launcher_add_wait_barrier(
      legion_task_launcher_t launcher, legion_phase_barrier_t bar);
 
  void legion_task_launcher_add_arrival_barrier(
      legion_task_launcher_t launcher, legion_phase_barrier_t bar);
 
  void legion_task_launcher_set_argument(
      legion_task_launcher_t launcher, legion_untyped_buffer_t arg);
 
  void legion_task_launcher_set_point(
      legion_task_launcher_t launcher, legion_domain_point_t point);
 
  void legion_task_launcher_set_sharding_space(
      legion_task_launcher_t launcher, legion_index_space_t is);
 
  void legion_task_launcher_set_predicate_false_future(
      legion_task_launcher_t launcher, legion_future_t f);
 
  void legion_task_launcher_set_predicate_false_result(
      legion_task_launcher_t launcher, legion_untyped_buffer_t arg);
 
  void legion_task_launcher_set_mapper(
      legion_task_launcher_t launcher, legion_mapper_id_t mapper_id);
 
  void legion_task_launcher_set_mapping_tag(
      legion_task_launcher_t launcher, legion_mapping_tag_id_t tag);
 
  void legion_task_launcher_set_mapper_arg(
      legion_task_launcher_t launcher, legion_untyped_buffer_t arg);
 
  void legion_task_launcher_set_enable_inlining(
      legion_task_launcher_t launcher, bool enable_inlining);
 
  void legion_task_launcher_set_local_function_task(
      legion_task_launcher_t launcher, bool local_function_task);
 
  void legion_task_launcher_set_elide_future_return(
      legion_task_launcher_t launcher, bool elide_future_return);
 
  void legion_task_launcher_set_provenance(
      legion_task_launcher_t launcher, const char* provenance);
 
  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 /* = legion_predicate_true() */,
      bool must /* = false */, legion_mapper_id_t id /* = 0 */,
      legion_mapping_tag_id_t tag /* = 0 */);
 
  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 /* = legion_predicate_true() */,
      bool must /* = false */, legion_mapper_id_t id /* = 0 */,
      legion_mapping_tag_id_t tag /* = 0 */);
 
  void legion_index_launcher_destroy(legion_index_launcher_t handle);
 
  legion_future_map_t legion_index_launcher_execute(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_index_launcher_t launcher);
 
  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_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_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_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);
 
  unsigned legion_index_launcher_add_region_requirement_logical_region(
      legion_index_launcher_t launcher, legion_logical_region_t handle,
      legion_projection_id_t proj /* = 0 */, legion_privilege_mode_t priv,
      legion_coherence_property_t prop, legion_logical_region_t parent,
      legion_mapping_tag_id_t tag /* = 0 */, bool verified /* = false*/);
 
  unsigned legion_index_launcher_add_region_requirement_logical_partition(
      legion_index_launcher_t launcher, legion_logical_partition_t handle,
      legion_projection_id_t proj /* = 0 */, legion_privilege_mode_t priv,
      legion_coherence_property_t prop, legion_logical_region_t parent,
      legion_mapping_tag_id_t tag /* = 0 */, bool verified /* = false*/);
 
  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 /* = 0 */, legion_reduction_op_id_t redop,
          legion_coherence_property_t prop, legion_logical_region_t parent,
          legion_mapping_tag_id_t tag /* = 0 */, bool verified /* = false*/);
 
  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 /* = 0 */, legion_reduction_op_id_t redop,
          legion_coherence_property_t prop, legion_logical_region_t parent,
          legion_mapping_tag_id_t tag /* = 0 */, bool verified /* = false*/);
 
  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 /* = 0 */,
      legion_privilege_mode_t priv, legion_coherence_property_t prop,
      legion_logical_region_t parent, legion_mapping_tag_id_t tag /* = 0 */,
      bool verified /* = false*/);
 
  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 /* = 0 */,
      legion_privilege_mode_t priv, legion_coherence_property_t prop,
      legion_logical_region_t parent, legion_mapping_tag_id_t tag /* = 0 */,
      bool verified /* = false*/);
 
  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 /* = 0 */,
      legion_reduction_op_id_t redop, legion_coherence_property_t prop,
      legion_logical_region_t parent, legion_mapping_tag_id_t tag /* = 0 */,
      bool verified /* = false*/);
 
  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 /* = 0 */,
      legion_reduction_op_id_t redop, legion_coherence_property_t prop,
      legion_logical_region_t parent, legion_mapping_tag_id_t tag /* = 0 */,
      bool verified /* = false*/);
 
  void legion_index_launcher_add_field(
      legion_index_launcher_t launcher, unsigned idx, legion_field_id_t fid,
      bool inst /* = true */);
 
  void legion_index_launcher_add_flags(
      legion_index_launcher_t launcher, unsigned idx,
      enum legion_region_flags_t flags);
 
  void legion_index_launcher_intersect_flags(
      legion_index_launcher_t launcher, unsigned idx,
      enum legion_region_flags_t flags);
 
  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 /* = false*/);
 
  void legion_index_launcher_add_future(
      legion_index_launcher_t launcher, legion_future_t future);
 
  void legion_index_launcher_add_wait_barrier(
      legion_index_launcher_t launcher, legion_phase_barrier_t bar);
 
  void legion_index_launcher_add_arrival_barrier(
      legion_index_launcher_t launcher, legion_phase_barrier_t bar);
 
  void legion_index_launcher_add_point_future(
      legion_index_launcher_t launcher, legion_argument_map_t map);
 
  void legion_index_launcher_set_global_arg(
      legion_index_launcher_t launcher, legion_untyped_buffer_t global_arg);
 
  void legion_index_launcher_set_sharding_space(
      legion_index_launcher_t launcher, legion_index_space_t is);
 
  void legion_index_launcher_set_mapper(
      legion_index_launcher_t launcher, legion_mapper_id_t mapper_id);
 
  void legion_index_launcher_set_mapping_tag(
      legion_index_launcher_t launcher, legion_mapping_tag_id_t tag);
 
  void legion_index_launcher_set_mapper_arg(
      legion_index_launcher_t launcher, legion_untyped_buffer_t map_arg);
 
  void legion_index_launcher_set_elide_future_return(
      legion_index_launcher_t launcher, bool elide_future_return);
 
  void legion_index_launcher_set_provenance(
      legion_index_launcher_t launcher, const char* provenance);
 
  void legion_index_launcher_set_concurrent(
      legion_index_launcher_t launcher, bool concurrent);
 
  void legion_index_launcher_set_initial_value(
      legion_index_launcher_t launcher, legion_future_t initial_value);
 
  // -----------------------------------------------------------------------
  // Inline Mapping Operations
  // -----------------------------------------------------------------------
 
  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 /* = 0 */, bool verified /* = false*/,
      legion_mapper_id_t id /* = 0 */,
      legion_mapping_tag_id_t launcher_tag /* = 0 */);
 
  void legion_inline_launcher_destroy(legion_inline_launcher_t handle);
 
  legion_physical_region_t legion_inline_launcher_execute(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_inline_launcher_t launcher);
 
  void legion_inline_launcher_add_field(
      legion_inline_launcher_t launcher, legion_field_id_t fid,
      bool inst /* = true */);
 
  void legion_inline_launcher_set_mapper_arg(
      legion_inline_launcher_t launcher, legion_untyped_buffer_t arg);
 
  void legion_inline_launcher_set_provenance(
      legion_inline_launcher_t launcher, const char* provenance);
 
  void legion_runtime_remap_region(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_physical_region_t region);
 
  void legion_runtime_unmap_region(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_physical_region_t region);
 
  void legion_runtime_unmap_all_regions(
      legion_runtime_t runtime, legion_context_t ctx);
 
  // -----------------------------------------------------------------------
  // Fill Field Operations
  // -----------------------------------------------------------------------
 
  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_predicate_true() */);
 
  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_predicate_true() */);
 
  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_predicate_true() */,
      legion_mapper_id_t id /* = 0 */, legion_mapping_tag_id_t tag /* = 0 */);
 
  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_predicate_true() */,
      legion_mapper_id_t id /* = 0 */, legion_mapping_tag_id_t tag /* = 0 */);
 
  void legion_fill_launcher_destroy(legion_fill_launcher_t handle);
 
  void legion_fill_launcher_add_field(
      legion_fill_launcher_t handle, legion_field_id_t fid);
 
  void legion_fill_launcher_execute(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_fill_launcher_t launcher);
 
  void legion_fill_launcher_set_point(
      legion_fill_launcher_t launcher, legion_domain_point_t point);
 
  void legion_fill_launcher_set_sharding_space(
      legion_fill_launcher_t launcher, legion_index_space_t space);
 
  void legion_fill_launcher_set_mapper_arg(
      legion_fill_launcher_t launcher, legion_untyped_buffer_t arg);
 
  void legion_fill_launcher_set_provenance(
      legion_fill_launcher_t launcher, const char* provenance);
 
  // -----------------------------------------------------------------------
  // Index Fill Field Operations
  // -----------------------------------------------------------------------
 
  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 /* = 0 */,
      legion_predicate_t pred /* = legion_predicate_true() */,
      legion_mapper_id_t id /* = 0 */,
      legion_mapping_tag_id_t launcher_tag /* = 0 */);
 
  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 /* = 0 */,
      legion_predicate_t pred /* = legion_predicate_true() */,
      legion_mapper_id_t id /* = 0 */,
      legion_mapping_tag_id_t launcher_tag /* = 0 */);
 
  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 /* = 0 */,
      legion_predicate_t pred /* = legion_predicate_true() */,
      legion_mapper_id_t id /* = 0 */,
      legion_mapping_tag_id_t launcher_tag /* = 0 */);
 
  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 /* = 0 */,
      legion_predicate_t pred /* = legion_predicate_true() */,
      legion_mapper_id_t id /* = 0 */,
      legion_mapping_tag_id_t launcher_tag /* = 0 */);
 
  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 /* = 0 */,
      legion_predicate_t pred /* = legion_predicate_true() */,
      legion_mapper_id_t id /* = 0 */,
      legion_mapping_tag_id_t launcher_tag /* = 0 */);
 
  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 /* = 0 */,
      legion_predicate_t pred /* = legion_predicate_true() */,
      legion_mapper_id_t id /* = 0 */,
      legion_mapping_tag_id_t launcher_tag /* = 0 */);
 
  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 /* = 0 */,
      legion_predicate_t pred /* = legion_predicate_true() */,
      legion_mapper_id_t id /* = 0 */,
      legion_mapping_tag_id_t launcher_tag /* = 0 */);
 
  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 /* = 0 */,
      legion_predicate_t pred /* = legion_predicate_true() */,
      legion_mapper_id_t id /* = 0 */,
      legion_mapping_tag_id_t launcher_tag /* = 0 */);
 
  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 /* = 0 */,
          legion_predicate_t pred /* = legion_predicate_true() */,
          legion_mapper_id_t id /* = 0 */,
          legion_mapping_tag_id_t launcher_tag /* = 0 */);
 
  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 /* = 0 */,
          legion_predicate_t pred /* = legion_predicate_true() */,
          legion_mapper_id_t id /* = 0 */,
          legion_mapping_tag_id_t launcher_tag /* = 0 */);
 
  void legion_index_fill_launcher_destroy(legion_index_fill_launcher_t handle);
 
  void legion_index_fill_launcher_add_field(
      legion_fill_launcher_t handle, legion_field_id_t fid);
 
  void legion_index_fill_launcher_execute(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_index_fill_launcher_t launcher);
 
  void legion_index_fill_launcher_set_sharding_space(
      legion_index_fill_launcher_t launcher, legion_index_space_t space);
 
  void legion_index_fill_launcher_set_mapper_arg(
      legion_index_fill_launcher_t launcher, legion_untyped_buffer_t arg);
 
  void legion_index_fill_launcher_set_provenance(
      legion_index_fill_launcher_t launcher, const char* provenance);
 
  legion_region_requirement_t legion_fill_get_requirement(legion_fill_t fill);
 
  // -----------------------------------------------------------------------
  // Discard Operation
  // -----------------------------------------------------------------------
 
  legion_discard_launcher_t legion_discard_launcher_create(
      legion_logical_region_t handle, legion_logical_region_t parent);
 
  void legion_discard_launcher_destroy(legion_discard_launcher_t handle);
 
  void legion_discard_launcher_add_field(
      legion_discard_launcher_t handle, legion_field_id_t fid);
 
  void legion_discard_launcher_execute(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_discard_launcher_t launcher);
 
  void legion_discard_launcher_set_provenance(
      legion_discard_launcher_t launcher, const char* provenance);
 
  // -----------------------------------------------------------------------
  // File Operations
  // -----------------------------------------------------------------------
 
  legion_field_map_t legion_field_map_create(void);
 
  void legion_field_map_destroy(legion_field_map_t handle);
 
  void legion_field_map_insert(
      legion_field_map_t handle, legion_field_id_t key, const char* value);
 
  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);
 
  void legion_runtime_detach_hdf5(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_physical_region_t region);
 
  // -----------------------------------------------------------------------
  // Copy Operations
  // -----------------------------------------------------------------------
 
  legion_copy_launcher_t legion_copy_launcher_create(
      legion_predicate_t pred /* = legion_predicate_true() */,
      legion_mapper_id_t id /* = 0 */,
      legion_mapping_tag_id_t launcher_tag /* = 0 */);
 
  void legion_copy_launcher_destroy(legion_copy_launcher_t handle);
 
  void legion_copy_launcher_execute(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_copy_launcher_t launcher);
 
  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 /* = 0 */,
      bool verified /* = false*/);
 
  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 /* = 0 */,
      bool verified /* = false*/);
 
  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 /* = 0 */,
          bool verified /* = false*/);
 
  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 /* = 0 */,
          bool is_range_indirection /* = false */, bool verified /* = false*/);
 
  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 /* = 0 */,
          bool is_range_indirection /* = false */, bool verified /* = false*/);
 
  void legion_copy_launcher_add_src_field(
      legion_copy_launcher_t launcher, unsigned idx, legion_field_id_t fid,
      bool inst /* = true */);
 
  void legion_copy_launcher_add_dst_field(
      legion_copy_launcher_t launcher, unsigned idx, legion_field_id_t fid,
      bool inst /* = true */);
 
  void legion_copy_launcher_add_wait_barrier(
      legion_copy_launcher_t launcher, legion_phase_barrier_t bar);
 
  void legion_copy_launcher_add_arrival_barrier(
      legion_copy_launcher_t launcher, legion_phase_barrier_t bar);
 
  void legion_copy_launcher_set_possible_src_indirect_out_of_range(
      legion_copy_launcher_t launcher, bool flag);
 
  void legion_copy_launcher_set_possible_dst_indirect_out_of_range(
      legion_copy_launcher_t launcher, bool flag);
 
  void legion_copy_launcher_set_point(
      legion_copy_launcher_t launcher, legion_domain_point_t point);
 
  void legion_copy_launcher_set_sharding_space(
      legion_copy_launcher_t launcher, legion_index_space_t space);
 
  void legion_copy_launcher_set_mapper_arg(
      legion_copy_launcher_t launcher, legion_untyped_buffer_t arg);
 
  void legion_copy_launcher_set_provenance(
      legion_copy_launcher_t launcher, const char* provenance);
 
  legion_region_requirement_t legion_copy_get_requirement(
      legion_copy_t copy, unsigned idx);
 
  // -----------------------------------------------------------------------
  // Index Copy Operations
  // -----------------------------------------------------------------------
 
  legion_index_copy_launcher_t legion_index_copy_launcher_create(
      legion_domain_t domain,
      legion_predicate_t pred /* = legion_predicate_true() */,
      legion_mapper_id_t id /* = 0 */,
      legion_mapping_tag_id_t launcher_tag /* = 0 */);
 
  void legion_index_copy_launcher_destroy(legion_index_copy_launcher_t handle);
 
  void legion_index_copy_launcher_execute(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_index_copy_launcher_t launcher);
 
  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 /* = 0 */, legion_privilege_mode_t priv,
      legion_coherence_property_t prop, legion_logical_region_t parent,
      legion_mapping_tag_id_t tag /* = 0 */, bool verified /* = false*/);
 
  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 /* = 0 */, legion_privilege_mode_t priv,
      legion_coherence_property_t prop, legion_logical_region_t parent,
      legion_mapping_tag_id_t tag /* = 0 */, bool verified /* = false*/);
 
  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 /* = 0 */, legion_privilege_mode_t priv,
          legion_coherence_property_t prop, legion_logical_region_t parent,
          legion_mapping_tag_id_t tag /* = 0 */, bool verified /* = false*/);
 
  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 /* = 0 */, legion_privilege_mode_t priv,
          legion_coherence_property_t prop, legion_logical_region_t parent,
          legion_mapping_tag_id_t tag /* = 0 */, bool verified /* = false*/);
 
  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 /* = 0 */, legion_reduction_op_id_t redop,
          legion_coherence_property_t prop, legion_logical_region_t parent,
          legion_mapping_tag_id_t tag /* = 0 */, bool verified /* = false*/);
 
  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 /* = 0 */, legion_reduction_op_id_t redop,
          legion_coherence_property_t prop, legion_logical_region_t parent,
          legion_mapping_tag_id_t tag /* = 0 */, bool verified /* = false*/);
 
  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 /* = 0 */, legion_field_id_t fid,
          legion_coherence_property_t prop, legion_logical_region_t parent,
          legion_mapping_tag_id_t tag /* = 0 */,
          bool is_range_indirection /* = false */, bool verified /* = false*/);
 
  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 /* = 0 */, legion_field_id_t fid,
          legion_coherence_property_t prop, legion_logical_region_t parent,
          legion_mapping_tag_id_t tag /* = 0 */,
          bool is_range_indirection /* = false */, bool verified /* = false*/);
 
  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 /* = 0 */, legion_field_id_t fid,
          legion_coherence_property_t prop, legion_logical_region_t parent,
          legion_mapping_tag_id_t tag /* = 0 */,
          bool is_range_indirection /* = false */, bool verified /* = false*/);
 
  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 /* = 0 */, legion_field_id_t fid,
          legion_coherence_property_t prop, legion_logical_region_t parent,
          legion_mapping_tag_id_t tag /* = 0 */,
          bool is_range_indirection /* = false */, bool verified /* = false*/);
 
  void legion_index_copy_launcher_add_src_field(
      legion_index_copy_launcher_t launcher, unsigned idx,
      legion_field_id_t fid, bool inst /* = true */);
 
  void legion_index_copy_launcher_add_dst_field(
      legion_index_copy_launcher_t launcher, unsigned idx,
      legion_field_id_t fid, bool inst /* = true */);
 
  void legion_index_copy_launcher_add_wait_barrier(
      legion_index_copy_launcher_t launcher, legion_phase_barrier_t bar);
 
  void legion_index_copy_launcher_add_arrival_barrier(
      legion_index_copy_launcher_t launcher, legion_phase_barrier_t bar);
 
  void legion_index_copy_launcher_set_possible_src_indirect_out_of_range(
      legion_index_copy_launcher_t launcher, bool flag);
 
  void legion_index_copy_launcher_set_possible_dst_indirect_out_of_range(
      legion_index_copy_launcher_t launcher, bool flag);
 
  void legion_index_copy_launcher_set_sharding_space(
      legion_index_copy_launcher_t launcher, legion_index_space_t is);
 
  void legion_index_copy_launcher_set_mapper_arg(
      legion_index_copy_launcher_t launcher, legion_untyped_buffer_t arg);
 
  void legion_index_copy_launcher_set_provenance(
      legion_index_copy_launcher_t launcher, const char* provenance);
 
  // -----------------------------------------------------------------------
  // Acquire Operations
  // -----------------------------------------------------------------------
 
  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_predicate_true() */,
      legion_mapper_id_t id /* = 0 */, legion_mapping_tag_id_t tag /* = 0 */);
 
  void legion_acquire_launcher_destroy(legion_acquire_launcher_t handle);
 
  void legion_acquire_launcher_execute(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_acquire_launcher_t launcher);
 
  void legion_acquire_launcher_add_field(
      legion_acquire_launcher_t launcher, legion_field_id_t fid);
 
  void legion_acquire_launcher_add_wait_barrier(
      legion_acquire_launcher_t launcher, legion_phase_barrier_t bar);
 
  void legion_acquire_launcher_add_arrival_barrier(
      legion_acquire_launcher_t launcher, legion_phase_barrier_t bar);
 
  void legion_acquire_launcher_set_sharding_space(
      legion_acquire_launcher_t launcher, legion_index_space_t space);
 
  void legion_acquire_launcher_set_mapper_arg(
      legion_acquire_launcher_t launcher, legion_untyped_buffer_t arg);
 
  void legion_acquire_launcher_set_provenance(
      legion_acquire_launcher_t launcher, const char* provenance);
 
  // -----------------------------------------------------------------------
  // Release Operations
  // -----------------------------------------------------------------------
 
  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_predicate_true() */,
      legion_mapper_id_t id /* = 0 */, legion_mapping_tag_id_t tag /* = 0 */);
 
  void legion_release_launcher_destroy(legion_release_launcher_t handle);
 
  void legion_release_launcher_execute(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_release_launcher_t launcher);
 
  void legion_release_launcher_add_field(
      legion_release_launcher_t launcher, legion_field_id_t fid);
 
  void legion_release_launcher_add_wait_barrier(
      legion_release_launcher_t launcher, legion_phase_barrier_t bar);
 
  void legion_release_launcher_add_arrival_barrier(
      legion_release_launcher_t launcher, legion_phase_barrier_t bar);
 
  void legion_release_launcher_set_sharding_space(
      legion_release_launcher_t launcher, legion_index_space_t space);
 
  void legion_release_launcher_set_mapper_arg(
      legion_release_launcher_t launcher, legion_untyped_buffer_t arg);
 
  void legion_release_launcher_set_provenance(
      legion_release_launcher_t launcher, const char* provenance);
 
  // -----------------------------------------------------------------------
  // Attach/Detach Operations
  // -----------------------------------------------------------------------
 
  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);
 
  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);
 
  void legion_attach_launcher_set_restricted(
      legion_attach_launcher_t handle, bool restricted);
 
  void legion_attach_launcher_set_mapped(
      legion_attach_launcher_t handle, bool mapped);
 
  void legion_attach_launcher_set_provenance(
      legion_attach_launcher_t handle, const char* provenance);
 
  void legion_attach_launcher_destroy(legion_attach_launcher_t handle);
 
  legion_physical_region_t legion_attach_launcher_execute(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_attach_launcher_t launcher);
 
  void legion_attach_launcher_add_cpu_soa_field(
      legion_attach_launcher_t launcher, legion_field_id_t fid, void* base_ptr,
      bool column_major);
 
  void legion_attach_launcher_set_footprint(
      legion_attach_launcher_t launcher, size_t footprint);
 
  legion_future_t legion_detach_external_resource(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_physical_region_t handle);
 
  legion_future_t legion_flush_detach_external_resource(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_physical_region_t handle, bool flush);
 
  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);
 
  void legion_context_progress_unordered_operations(
      legion_runtime_t runtime, legion_context_t ctx);
 
  // -----------------------------------------------------------------------
  // Index Attach/Detach Operations
  // -----------------------------------------------------------------------
 
  legion_index_attach_launcher_t legion_index_attach_launcher_create(
      legion_logical_region_t parent_region,
      legion_external_resource_t resource, bool restricted /*=true*/);
 
  void legion_index_attach_launcher_set_restricted(
      legion_index_attach_launcher_t handle, bool restricted);
 
  void legion_index_attach_launcher_set_provenance(
      legion_index_attach_launcher_t handle, const char* provenance);
 
  void legion_index_attach_launcher_set_deduplicate_across_shards(
      legion_index_attach_launcher_t handle, bool deduplicate);
 
  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);
 
  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);
 
  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);
 
  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);
 
  void legion_index_attach_launcher_destroy(
      legion_index_attach_launcher_t handle);
 
  legion_external_resources_t legion_attach_external_resources(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_index_attach_launcher_t launcher);
 
  legion_future_t legion_detach_external_resources(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_external_resources_t, bool flush, bool unordered);
 
  // -----------------------------------------------------------------------
  // Must Epoch Operations
  // -----------------------------------------------------------------------
 
  legion_must_epoch_launcher_t legion_must_epoch_launcher_create(
      legion_mapper_id_t id /* = 0 */,
      legion_mapping_tag_id_t launcher_tag /* = 0 */);
 
  void legion_must_epoch_launcher_destroy(legion_must_epoch_launcher_t handle);
 
  legion_future_map_t legion_must_epoch_launcher_execute(
      legion_runtime_t runtime, legion_context_t ctx,
      legion_must_epoch_launcher_t launcher);
 
  void legion_must_epoch_launcher_add_single_task(
      legion_must_epoch_launcher_t launcher, legion_domain_point_t point,
      legion_task_launcher_t handle);
 
  void legion_must_epoch_launcher_add_index_task(
      legion_must_epoch_launcher_t launcher, legion_index_launcher_t handle);
 
  void legion_must_epoch_launcher_set_launch_domain(
      legion_must_epoch_launcher_t launcher, legion_domain_t domain);
 
  void legion_must_epoch_launcher_set_launch_space(
      legion_must_epoch_launcher_t launcher, legion_index_space_t is);
 
  void legion_must_epoch_launcher_set_provenance(
      legion_must_epoch_launcher_t launcher, const char* provenance);
 
  // -----------------------------------------------------------------------
  // Fence Operations
  // -----------------------------------------------------------------------
 
  legion_future_t legion_runtime_issue_mapping_fence(
      legion_runtime_t runtime, legion_context_t ctx);
 
  legion_future_t legion_runtime_issue_execution_fence(
      legion_runtime_t runtime, legion_context_t ctx);
 
  // -----------------------------------------------------------------------
  // Tracing Operations
  // -----------------------------------------------------------------------
 
  void legion_runtime_begin_trace(
      legion_runtime_t runtime, legion_context_t ctx, legion_trace_id_t tid,
      bool logical_only);
 
  void legion_runtime_end_trace(
      legion_runtime_t runtime, legion_context_t ctx, legion_trace_id_t tid);
 
  // -----------------------------------------------------------------------
  // Frame Operations
  // -----------------------------------------------------------------------
 
  void legion_runtime_complete_frame(
      legion_runtime_t runtime, legion_context_t ctx);
 
  // -----------------------------------------------------------------------
  // Tunable Variables
  // -----------------------------------------------------------------------
 
  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 /* = 0 */,
      legion_mapping_tag_id_t tag /* = 0 */);
 
  // -----------------------------------------------------------------------
  // Miscellaneous Operations
  // -----------------------------------------------------------------------
 
  bool legion_runtime_has_runtime(void);
 
  legion_runtime_t legion_runtime_get_runtime(void);
 
  bool legion_runtime_has_context(void);
 
  legion_context_t legion_runtime_get_context(void);
 
  void legion_context_destroy(legion_context_t);
 
  legion_processor_t legion_runtime_get_executing_processor(
      legion_runtime_t runtime, legion_context_t ctx);
 
  void legion_runtime_yield(legion_runtime_t runtime, legion_context_t ctx);
 
  legion_shard_id_t legion_runtime_local_shard(
      legion_runtime_t runtime, legion_context_t ctx);
 
  legion_shard_id_t legion_runtime_local_shard_without_context(void);
 
  size_t legion_runtime_total_shards(
      legion_runtime_t runtime, legion_context_t ctx);
 
  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);
 
  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);
 
  void legion_runtime_enable_scheduler_lock(void);
 
  void legion_runtime_disable_scheduler_lock(void);
 
  void legion_runtime_print_once(
      legion_runtime_t runtime, legion_context_t ctx, FILE* f,
      const char* message);
  void legion_runtime_print_once_fd(
      legion_runtime_t runtime, legion_context_t ctx, int fd, const char* mode,
      const char* message);
 
  // -----------------------------------------------------------------------
  // Physical Data Operations
  // -----------------------------------------------------------------------
 
  void legion_physical_region_destroy(legion_physical_region_t handle);
 
  legion_physical_region_t legion_physical_region_copy(
      legion_physical_region_t handle);
 
  bool legion_physical_region_is_mapped(legion_physical_region_t handle);
 
  void legion_physical_region_wait_until_valid(legion_physical_region_t handle);
 
  bool legion_physical_region_is_valid(legion_physical_region_t handle);
 
  legion_logical_region_t legion_physical_region_get_logical_region(
      legion_physical_region_t handle);
 
  size_t legion_physical_region_get_field_count(
      legion_physical_region_t handle);
  legion_field_id_t legion_physical_region_get_field_id(
      legion_physical_region_t handle, size_t index);
 
  size_t legion_physical_region_get_memory_count(
      legion_physical_region_t handle);
  legion_memory_t legion_physical_region_get_memory(
      legion_physical_region_t handle, size_t index);
 
#define ACCESSOR_ARRAY(DIM)                                     \
  legion_accessor_array_##DIM##d_t                              \
      legion_physical_region_get_field_accessor_array_##DIM##d( \
          legion_physical_region_t handle, legion_field_id_t fid);
  LEGION_FOREACH_N(ACCESSOR_ARRAY)
#undef ACCESSOR_ARRAY
 
#define ACCESSOR_ARRAY(DIM)                                                    \
  legion_accessor_array_##DIM##d_t                                             \
      legion_physical_region_get_field_accessor_array_##DIM##d_with_transform( \
          legion_physical_region_t handle, legion_field_id_t fid,              \
          legion_domain_affine_transform_t transform);
  LEGION_FOREACH_N(ACCESSOR_ARRAY)
#undef ACCESSOR_ARRAY
 
#define RAW_PTR(DIM)                                                        \
  void* legion_accessor_array_##DIM##d_raw_rect_ptr(                        \
      legion_accessor_array_##DIM##d_t handle, legion_rect_##DIM##d_t rect, \
      legion_rect_##DIM##d_t* subrect, legion_byte_offset_t* offsets);
  LEGION_FOREACH_N(RAW_PTR)
#undef RAW_PTR
 
  // Read
  void legion_accessor_array_1d_read(
      legion_accessor_array_1d_t handle, legion_ptr_t ptr, void* dst,
      size_t bytes);
 
#define READ_ARRAY(DIM)                                                       \
  void legion_accessor_array_##DIM##d_read_point(                             \
      legion_accessor_array_##DIM##d_t handle, legion_point_##DIM##d_t point, \
      void* dst, size_t bytes);
  LEGION_FOREACH_N(READ_ARRAY)
#undef READ_ARRAY
 
  // Write
  void legion_accessor_array_1d_write(
      legion_accessor_array_1d_t handle, legion_ptr_t ptr, const void* src,
      size_t bytes);
 
#define WRITE_ARRAY(DIM)                                                      \
  void legion_accessor_array_##DIM##d_write_point(                            \
      legion_accessor_array_##DIM##d_t handle, legion_point_##DIM##d_t point, \
      const void* src, size_t bytes);
  LEGION_FOREACH_N(WRITE_ARRAY)
#undef WRITE_ARRAY
 
  // Ref
  void* legion_accessor_array_1d_ref(
      legion_accessor_array_1d_t handle, legion_ptr_t ptr);
 
#define REF_ARRAY(DIM)                            \
  void* legion_accessor_array_##DIM##d_ref_point( \
      legion_accessor_array_##DIM##d_t handle, legion_point_##DIM##d_t point);
  LEGION_FOREACH_N(REF_ARRAY)
#undef REF_ARRAY
 
#define DESTROY_ARRAY(DIM)                     \
  void legion_accessor_array_##DIM##d_destroy( \
      legion_accessor_array_##DIM##d_t handle);
  LEGION_FOREACH_N(DESTROY_ARRAY)
#undef DESTROY_ARRAY
 
  // -----------------------------------------------------------------------
  // External Resource Operations
  // -----------------------------------------------------------------------
 
  void legion_external_resources_destroy(legion_external_resources_t handle);
 
  size_t legion_external_resources_size(legion_external_resources_t handle);
 
  legion_physical_region_t legion_external_resources_get_region(
      legion_external_resources_t handle, unsigned index);
 
  // -----------------------------------------------------------------------
  // Mappable Operations
  // -----------------------------------------------------------------------
 
  enum legion_mappable_type_id_t legion_mappable_get_type(
      legion_mappable_t mappable);
 
  legion_task_t legion_mappable_as_task(legion_mappable_t mappable);
 
  legion_copy_t legion_mappable_as_copy(legion_mappable_t mappable);
 
  legion_fill_t legion_mappable_as_fill(legion_mappable_t mappable);
 
  legion_inline_t legion_mappable_as_inline_mapping(legion_mappable_t mappable);
 
  // -----------------------------------------------------------------------
  // Task Operations
  // -----------------------------------------------------------------------
 
  legion_unique_id_t legion_context_get_unique_id(legion_context_t ctx);
 
  legion_task_mut_t legion_task_create_empty();
 
  void legion_task_destroy(legion_task_mut_t handle);
 
  legion_task_t legion_task_mut_as_task(legion_task_mut_t task);
 
  legion_unique_id_t legion_task_get_unique_id(legion_task_t task);
 
  int legion_task_get_depth(legion_task_t task);
 
  legion_mapper_id_t legion_task_get_mapper(legion_task_t task);
 
  legion_mapping_tag_id_t legion_task_get_tag(legion_task_t task);
 
  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 /* = false */);
 
  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 /* = false */, bool wait_until_ready /* = false */);
 
  void legion_task_id_attach_name(
      legion_runtime_t runtime, legion_task_id_t task_id, const char* name,
      bool is_mutable /* = false */);
 
  void legion_task_id_retrieve_name(
      legion_runtime_t runtime, legion_task_id_t task_id, const char** result);
 
  const void* legion_task_get_args(legion_task_t task);
 
  void legion_task_set_args(legion_task_mut_t task, void* args);
 
  size_t legion_task_get_arglen(legion_task_t task);
 
  void legion_task_set_arglen(legion_task_mut_t task, size_t arglen);
 
  legion_domain_t legion_task_get_index_domain(legion_task_t task);
 
  legion_domain_point_t legion_task_get_index_point(legion_task_t task);
 
  bool legion_task_get_is_index_space(legion_task_t task);
 
  const void* legion_task_get_local_args(legion_task_t task);
 
  size_t legion_task_get_local_arglen(legion_task_t task);
 
  unsigned legion_task_get_regions_size(legion_task_t task);
 
  legion_region_requirement_t legion_task_get_requirement(
      legion_task_t task, unsigned idx);
 
  unsigned legion_task_get_futures_size(legion_task_t task);
 
  legion_future_t legion_task_get_future(legion_task_t task, unsigned idx);
 
  void legion_task_add_future(legion_task_mut_t task, legion_future_t future);
 
  legion_task_id_t legion_task_get_task_id(legion_task_t task);
 
  legion_processor_t legion_task_get_target_proc(legion_task_t task);
 
  const char* legion_task_get_name(legion_task_t task);
 
  // -----------------------------------------------------------------------
  // Inline Operations
  // -----------------------------------------------------------------------
 
  legion_region_requirement_t legion_inline_get_requirement(
      legion_inline_t inline_operation);
 
  // -----------------------------------------------------------------------
  // Execution Constraints
  // -----------------------------------------------------------------------
 
  legion_execution_constraint_set_t legion_execution_constraint_set_create(
      void);
 
  void legion_execution_constraint_set_destroy(
      legion_execution_constraint_set_t handle);
 
  void legion_execution_constraint_set_add_isa_constraint(
      legion_execution_constraint_set_t handle, uint64_t prop);
 
  void legion_execution_constraint_set_add_processor_constraint(
      legion_execution_constraint_set_t handle,
      legion_processor_kind_t proc_kind);
 
  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);
 
  void legion_execution_constraint_set_add_launch_constraint(
      legion_execution_constraint_set_t handle, legion_launch_constraint_t kind,
      size_t value);
 
  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);
 
  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);
 
  // -----------------------------------------------------------------------
  // Layout Constraints
  // -----------------------------------------------------------------------
 
  legion_layout_constraint_set_t legion_layout_constraint_set_create(void);
 
  void legion_layout_constraint_set_destroy(
      legion_layout_constraint_set_t handle);
 
  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 /* = nullptr */);
 
  legion_layout_constraint_id_t legion_layout_constraint_set_preregister(
      legion_layout_constraint_set_t handle,
      const char* layout_name /* = nullptr */);
 
  void legion_layout_constraint_set_release(
      legion_runtime_t runtime, legion_layout_constraint_id_t handle);
 
  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);
 
  void legion_layout_constraint_set_add_memory_constraint(
      legion_layout_constraint_set_t handle, legion_memory_kind_t kind);
 
  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);
 
  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);
 
  void legion_layout_constraint_set_add_tiling_constraint(
      legion_layout_constraint_set_t handle, legion_dimension_kind_t dim,
      size_t value, bool tiles);
 
  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);
 
  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);
 
  void legion_layout_constraint_set_add_offset_constraint(
      legion_layout_constraint_set_t handle, legion_field_id_t field,
      size_t offset);
 
  void legion_layout_constraint_set_add_pointer_constraint(
      legion_layout_constraint_set_t handle, legion_memory_t memory,
      uintptr_t ptr);
 
  // -----------------------------------------------------------------------
  // Task Layout Constraints
  // -----------------------------------------------------------------------
 
  legion_task_layout_constraint_set_t legion_task_layout_constraint_set_create(
      void);
 
  void legion_task_layout_constraint_set_destroy(
      legion_task_layout_constraint_set_t handle);
 
  void legion_task_layout_constraint_set_add_layout_constraint(
      legion_task_layout_constraint_set_t handle, unsigned idx,
      legion_layout_constraint_id_t layout);
 
  // -----------------------------------------------------------------------
  // Start-up Operations
  // -----------------------------------------------------------------------
 
  void legion_runtime_initialize(
      int* argc, char*** argv, bool filter /* = false */);
 
  int legion_runtime_start(
      int argc, char** argv, bool background /* = false */);
 
  int legion_runtime_wait_for_shutdown(void);
 
  void legion_runtime_set_return_code(int return_code);
 
  void legion_runtime_set_top_level_task_id(legion_task_id_t top_id);
 
  size_t legion_runtime_get_maximum_dimension(void);
 
  const legion_input_args_t legion_runtime_get_input_args(void);
 
  void legion_runtime_add_registration_callback(
      legion_registration_callback_pointer_t callback);
 
  legion_mapper_id_t legion_runtime_generate_library_mapper_ids(
      legion_runtime_t runtime, const char* library_name, size_t count);
 
  void legion_runtime_replace_default_mapper(
      legion_runtime_t runtime, legion_mapper_t mapper,
      legion_processor_t proc);
 
  legion_projection_id_t legion_runtime_generate_static_projection_id();
 
  legion_projection_id_t legion_runtime_generate_library_projection_ids(
      legion_runtime_t runtime, const char* library_name, size_t count);
 
  legion_sharding_id_t legion_runtime_generate_library_sharding_ids(
      legion_runtime_t runtime, const char* library_name, size_t count);
 
  legion_reduction_op_id_t legion_runtime_generate_library_reduction_ids(
      legion_runtime_t runtime, const char* library_name, size_t count);
 
  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);
 
  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);
 
  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);
 
  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);
 
  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);
 
  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_task_id_t legion_runtime_generate_library_task_ids(
      legion_runtime_t runtime, const char* library_name, size_t count);
 
  legion_task_variant_registrar_t legion_task_variant_registrar_create(
      legion_task_id_t tid, bool global, const char* variant_name);
 
  void legion_task_variant_registrar_destroy(
      legion_task_variant_registrar_t registrar);
 
  void legion_task_variant_registrar_set_execution_constraints(
      legion_task_variant_registrar_t registrar,
      legion_execution_constraint_set_t constraints);
 
  void legion_task_variant_registrar_set_layout_constraints(
      legion_task_variant_registrar_t registrar,
      legion_task_layout_constraint_set_t constraints);
 
  void legion_task_variant_registrar_set_options(
      legion_task_variant_registrar_t registrar,
      legion_task_config_options_t options);
 
  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_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_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_task_id_t legion_runtime_register_task_variant_fnptr(
      legion_runtime_t runtime, legion_task_id_t id /* = AUTO_GENERATE_ID */,
      const char* task_name /* = nullptr*/,
      const char* variant_name /* = nullptr*/, 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_task_id_t legion_runtime_preregister_task_variant_fnptr(
      legion_task_id_t id /* = AUTO_GENERATE_ID */,
      legion_variant_id_t variant_id /* = AUTO_GENERATE_ID */,
      const char* task_name /* = nullptr*/,
      const char* variant_name /* = nullptr*/,
      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);
 
#ifdef REALM_USE_LLVM
  legion_task_id_t legion_runtime_register_task_variant_llvmir(
      legion_runtime_t runtime, legion_task_id_t id /* = AUTO_GENERATE_ID */,
      const char* task_name /* = nullptr*/, bool global,
      legion_execution_constraint_set_t execution_constraints,
      legion_task_layout_constraint_set_t layout_constraints,
      legion_task_config_options_t options, const char* llvmir,
      const char* entry_symbol, const void* userdata, size_t userlen);
 
  legion_task_id_t legion_runtime_preregister_task_variant_llvmir(
      legion_task_id_t id /* = AUTO_GENERATE_ID */,
      legion_variant_id_t variant_id /* = AUTO_GENERATE_ID */,
      const char* task_name /* = nullptr*/,
      legion_execution_constraint_set_t execution_constraints,
      legion_task_layout_constraint_set_t layout_constraints,
      legion_task_config_options_t options, const char* llvmir,
      const char* entry_symbol, const void* userdata, size_t userlen);
#endif
 
#ifdef REALM_USE_PYTHON
  legion_task_id_t legion_runtime_register_task_variant_python_source(
      legion_runtime_t runtime, legion_task_id_t id /* = AUTO_GENERATE_ID */,
      const char* task_name /* = nullptr*/, bool global,
      legion_execution_constraint_set_t execution_constraints,
      legion_task_layout_constraint_set_t layout_constraints,
      legion_task_config_options_t options, const char* module_name,
      const char* function_name, const void* userdata, size_t userlen);
 
  legion_task_id_t legion_runtime_register_task_variant_python_source_qualname(
      legion_runtime_t runtime, legion_task_id_t id /* = AUTO_GENERATE_ID */,
      const char* task_name /* = nullptr*/, bool global,
      legion_execution_constraint_set_t execution_constraints,
      legion_task_layout_constraint_set_t layout_constraints,
      legion_task_config_options_t options, const char* module_name,
      const char** function_qualname, size_t function_qualname_len,
      const void* userdata, size_t userlen);
#endif
 
  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);
 
  void legion_task_postamble(
      legion_runtime_t runtime, legion_context_t ctx, const void* retval,
      size_t retsize);
 
  // -----------------------------------------------------------------------
  // Timing Operations
  // -----------------------------------------------------------------------
 
  unsigned long long legion_get_current_time_in_micros(void);
 
  unsigned long long legion_get_current_time_in_nanos(void);
 
  legion_future_t legion_issue_timing_op_seconds(
      legion_runtime_t runtime, legion_context_t ctx);
 
  legion_future_t legion_issue_timing_op_microseconds(
      legion_runtime_t runtime, legion_context_t ctx);
 
  legion_future_t legion_issue_timing_op_nanoseconds(
      legion_runtime_t runtime, legion_context_t ctx);
 
  // -----------------------------------------------------------------------
  // Logging Operations
  // -----------------------------------------------------------------------
 
  legion_logger_t legion_logger_create(const char* name);
 
  void legion_logger_destroy(legion_logger_t handle);
 
  void legion_logger_spew(legion_logger_t handle, const char* msg);
 
  void legion_logger_debug(legion_logger_t handle, const char* msg);
 
  void legion_logger_info(legion_logger_t handle, const char* msg);
 
  void legion_logger_print(legion_logger_t handle, const char* msg);
 
  void legion_logger_warning(legion_logger_t handle, const char* msg);
 
  void legion_logger_error(legion_logger_t handle, const char* msg);
 
  void legion_logger_fatal(legion_logger_t handle, const char* msg);
 
  bool legion_logger_want_spew(legion_logger_t handle);
 
  bool legion_logger_want_debug(legion_logger_t handle);
 
  bool legion_logger_want_info(legion_logger_t handle);
 
  bool legion_logger_want_print(legion_logger_t handle);
 
  bool legion_logger_want_warning(legion_logger_t handle);
 
  bool legion_logger_want_error(legion_logger_t handle);
 
  bool legion_logger_want_fatal(legion_logger_t handle);
 
  // -----------------------------------------------------------------------
  // Machine Operations
  // -----------------------------------------------------------------------
 
  legion_machine_t legion_machine_create(void);
 
  void legion_machine_destroy(legion_machine_t handle);
 
  void legion_machine_get_all_processors(
      legion_machine_t machine, legion_processor_t* processors,
      size_t processors_size);
 
  size_t legion_machine_get_all_processors_size(legion_machine_t machine);
 
  void legion_machine_get_all_memories(
      legion_machine_t machine, legion_memory_t* memories,
      size_t memories_size);
 
  size_t legion_machine_get_all_memories_size(legion_machine_t machine);
 
  // -----------------------------------------------------------------------
  // Processor Operations
  // -----------------------------------------------------------------------
 
  legion_processor_kind_t legion_processor_kind(legion_processor_t proc);
 
  legion_address_space_t legion_processor_address_space(
      legion_processor_t proc);
 
  // -----------------------------------------------------------------------
  // Memory Operations
  // -----------------------------------------------------------------------
 
  legion_memory_kind_t legion_memory_kind(legion_memory_t mem);
 
  legion_address_space_t legion_memory_address_space(legion_memory_t mem);
 
  // -----------------------------------------------------------------------
  // Processor Query Operations
  // -----------------------------------------------------------------------
 
  legion_processor_query_t legion_processor_query_create(
      legion_machine_t machine);
 
  legion_processor_query_t legion_processor_query_create_copy(
      legion_processor_query_t query);
 
  void legion_processor_query_destroy(legion_processor_query_t handle);
 
  void legion_processor_query_only_kind(
      legion_processor_query_t query, legion_processor_kind_t kind);
 
  void legion_processor_query_local_address_space(
      legion_processor_query_t query);
 
  void legion_processor_query_same_address_space_as_processor(
      legion_processor_query_t query, legion_processor_t proc);
 
  void legion_processor_query_same_address_space_as_memory(
      legion_processor_query_t query, legion_memory_t mem);
 
  void legion_processor_query_has_affinity_to_memory(
      legion_processor_query_t query, legion_memory_t mem,
      unsigned min_bandwidth /* = 0 */, unsigned max_latency /* = 0 */);
 
  void legion_processor_query_best_affinity_to_memory(
      legion_processor_query_t query, legion_memory_t mem,
      int bandwidth_weight /* = 0 */, int latency_weight /* = 0 */);
 
  size_t legion_processor_query_count(legion_processor_query_t query);
 
  legion_processor_t legion_processor_query_first(
      legion_processor_query_t query);
 
  legion_processor_t legion_processor_query_next(
      legion_processor_query_t query, legion_processor_t after);
 
  legion_processor_t legion_processor_query_random(
      legion_processor_query_t query);
 
  // -----------------------------------------------------------------------
  // Memory Query Operations
  // -----------------------------------------------------------------------
 
  legion_memory_query_t legion_memory_query_create(legion_machine_t machine);
 
  legion_memory_query_t legion_memory_query_create_copy(
      legion_memory_query_t query);
 
  void legion_memory_query_destroy(legion_memory_query_t handle);
 
  void legion_memory_query_only_kind(
      legion_memory_query_t query, legion_memory_kind_t kind);
 
  void legion_memory_query_local_address_space(legion_memory_query_t query);
 
  void legion_memory_query_same_address_space_as_processor(
      legion_memory_query_t query, legion_processor_t proc);
 
  void legion_memory_query_same_address_space_as_memory(
      legion_memory_query_t query, legion_memory_t mem);
 
  void legion_memory_query_has_affinity_to_processor(
      legion_memory_query_t query, legion_processor_t proc,
      unsigned min_bandwidth /* = 0 */, unsigned max_latency /* = 0 */);
 
  void legion_memory_query_has_affinity_to_memory(
      legion_memory_query_t query, legion_memory_t mem,
      unsigned min_bandwidth /* = 0 */, unsigned max_latency /* = 0 */);
 
  void legion_memory_query_best_affinity_to_processor(
      legion_memory_query_t query, legion_processor_t proc,
      int bandwidth_weight /* = 0 */, int latency_weight /* = 0 */);
 
  void legion_memory_query_best_affinity_to_memory(
      legion_memory_query_t query, legion_memory_t mem,
      int bandwidth_weight /* = 0 */, int latency_weight /* = 0 */);
 
  size_t legion_memory_query_count(legion_memory_query_t query);
 
  legion_memory_t legion_memory_query_first(legion_memory_query_t query);
 
  legion_memory_t legion_memory_query_next(
      legion_memory_query_t query, legion_memory_t after);
 
  legion_memory_t legion_memory_query_random(legion_memory_query_t query);
 
  // -----------------------------------------------------------------------
  // Physical Instance Operations
  // -----------------------------------------------------------------------
 
  /*
   * @param instance Caller must have ownership of parameter `instance`.
   *
   * @see Legion::Mapping::PhysicalInstance
   */
  void legion_physical_instance_destroy(legion_physical_instance_t instance);
 
  // -----------------------------------------------------------------------
  // Slice Task Output
  // -----------------------------------------------------------------------
 
  void legion_slice_task_output_slices_add(
      legion_slice_task_output_t output, legion_task_slice_t slice);
 
  void legion_slice_task_output_verify_correctness_set(
      legion_slice_task_output_t output, bool verify_correctness);
 
  // -----------------------------------------------------------------------
  // Map Task Input/Output
  // -----------------------------------------------------------------------
 
  void legion_map_task_output_chosen_instances_clear_all(
      legion_map_task_output_t output);
 
  void legion_map_task_output_chosen_instances_clear_each(
      legion_map_task_output_t output, size_t idx);
 
  void legion_map_task_output_chosen_instances_add(
      legion_map_task_output_t output, legion_physical_instance_t* instances,
      size_t instances_size);
 
  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);
 
  void legion_map_task_output_target_procs_clear(
      legion_map_task_output_t output);
 
  void legion_map_task_output_target_procs_add(
      legion_map_task_output_t output, legion_processor_t proc);
 
  legion_processor_t legion_map_task_output_target_procs_get(
      legion_map_task_output_t output, size_t idx);
 
  void legion_map_task_output_task_priority_set(
      legion_map_task_output_t output, legion_task_priority_t priority);
 
  // -----------------------------------------------------------------------
  // MapperRuntime Operations
  // -----------------------------------------------------------------------
 
  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);
 
  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);
 
  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);
 
  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);
 
  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);
 
  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);
 
  bool legion_mapper_runtime_acquire_instance(
      legion_mapper_runtime_t runtime, legion_mapper_context_t ctx,
      legion_physical_instance_t instance);
 
  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);
 
  // A hidden method here that hopefully nobody sees or ever needs
  // to use but its here anyway just in case
  legion_shard_id_t legion_context_get_shard_id(
      legion_runtime_t /*runtime*/, legion_context_t /*context*/,
      bool /*I know what I am doing*/);
  // Another hidden method for getting the number of shards
  size_t legion_context_get_num_shards(
      legion_runtime_t /*runtime*/, legion_context_t /*context*/,
      bool /*I know what I am doing*/);
  // Another hidden method for control replication that most
  // people should not be using but for which there are legitamite
  // user, especially in garbage collected languages
  // Note the caller takes ownership of the future
  legion_future_t legion_context_consensus_match(
      legion_runtime_t /*runtime*/, legion_context_t /*context*/,
      const void* /*input*/, void* /*output*/, size_t /*num elements*/,
      size_t /*element size*/);
 
  legion_physical_region_t legion_get_physical_region_by_id(
      legion_physical_region_t* regionptr, int id, int num_regions);
#ifdef __cplusplus
}
#endif
 
#endif  // __LEGION_C_H__