legion.h

Go to the documentation of this file.

/* Copyright 2024 Stanford University, NVIDIA Corporation
 *
 * 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.
 */
 
// decide whether we want C and/or C++ bindings (default matches host language)
//
// each set of bindings has its own include-once ifdef armor, allowing the
//  second set of bindings to be loaded even if the first already has been
#if !defined(LEGION_ENABLE_C_BINDINGS) && !defined(LEGION_DISABLE_C_BINDINGS)
  #ifndef __cplusplus
    #define LEGION_ENABLE_C_BINDINGS
  #endif
#endif
#if !defined(LEGION_ENABLE_CXX_BINDINGS) && !defined(LEGION_DISABLE_CXX_BINDINGS)
  #ifdef __cplusplus
    #define LEGION_ENABLE_CXX_BINDINGS
  #endif
#endif
 
#ifdef LEGION_ENABLE_C_BINDINGS
#include "legion/legion_c.h"
#endif
 
#ifdef LEGION_ENABLE_CXX_BINDINGS
#ifndef __LEGION_RUNTIME_H__
#define __LEGION_RUNTIME_H__
 
#if __cplusplus < 201103L
#error "Legion requires C++11 as the minimum standard version"
#endif
 
#include "legion/legion_types.h"
#include "legion/legion_domain.h"
#include "legion/legion_constraint.h"
#include "legion/legion_redop.h"
 
#define LEGION_PRINT_ONCE(runtime, ctx, file, fmt, ...)   \
{                                                         \
  char message[4096];                                     \
  snprintf(message, 4096, fmt, ##__VA_ARGS__);            \
  runtime->print_once(ctx, file, message);                \
}
 
namespace Legion {
 
    //==========================================================================
    //                       Data Description Classes
    //==========================================================================
 
    class IndexSpace {
    public:
      static const IndexSpace NO_SPACE; 
    protected:
      // Only the runtime should be allowed to make these
      FRIEND_ALL_RUNTIME_CLASSES
      IndexSpace(IndexSpaceID id, IndexTreeID tid, TypeTag tag);
    public:
      IndexSpace(void);
    public:
      inline bool operator==(const IndexSpace &rhs) const;
      inline bool operator!=(const IndexSpace &rhs) const;
      inline bool operator<(const IndexSpace &rhs) const;
      inline bool operator>(const IndexSpace &rhs) const;
      inline std::size_t hash(void) const;
      inline IndexSpaceID get_id(void) const { return id; }
      inline IndexTreeID get_tree_id(void) const { return tid; }
      inline bool exists(void) const { return (id != 0); }
      inline TypeTag get_type_tag(void) const { return type_tag; }
      inline int get_dim(void) const;
    protected:
      friend std::ostream& operator<<(std::ostream& os, 
                                      const IndexSpace& is);
      IndexSpaceID id;
      IndexTreeID tid;
      TypeTag type_tag;
    };
 
    template<int DIM, typename COORD_T = coord_t>
    class IndexSpaceT : public IndexSpace {
    private:
      static_assert(DIM > 0, "DIM must be positive");
      static_assert(std::is_integral<COORD_T>::value, "must be integral type");
    protected:
      // Only the runtime should be allowed to make these
      FRIEND_ALL_RUNTIME_CLASSES
      IndexSpaceT(IndexSpaceID id, IndexTreeID tid);
    public:
      IndexSpaceT(void);
      explicit IndexSpaceT(const IndexSpace &rhs);
    public:
      inline IndexSpaceT& operator=(const IndexSpace &rhs);
    };
 
    class IndexPartition {
    public:
      static const IndexPartition NO_PART;
    protected:
      // Only the runtime should be allowed to make these
      FRIEND_ALL_RUNTIME_CLASSES
      IndexPartition(IndexPartitionID id, IndexTreeID tid, TypeTag tag);
    public:
      IndexPartition(void);
    public:
      inline bool operator==(const IndexPartition &rhs) const;
      inline bool operator!=(const IndexPartition &rhs) const;
      inline bool operator<(const IndexPartition &rhs) const;
      inline bool operator>(const IndexPartition &rhs) const;
      inline std::size_t hash(void) const;
      inline IndexPartitionID get_id(void) const { return id; }
      inline IndexTreeID get_tree_id(void) const { return tid; }
      inline bool exists(void) const { return (id != 0); }
      inline TypeTag get_type_tag(void) const { return type_tag; }
      inline int get_dim(void) const;
    protected:
      friend std::ostream& operator<<(std::ostream& os, 
                                      const IndexPartition& ip);
      IndexPartitionID id;
      IndexTreeID tid;
      TypeTag type_tag;
    };
 
    template<int DIM, typename COORD_T = coord_t>
    class IndexPartitionT : public IndexPartition {
    private:
      static_assert(DIM > 0, "DIM must be positive");
      static_assert(std::is_integral<COORD_T>::value, "must be integral type");
    protected:
      // Only the runtime should be allowed to make these
      FRIEND_ALL_RUNTIME_CLASSES
      IndexPartitionT(IndexPartitionID id, IndexTreeID tid);
    public:
      IndexPartitionT(void);
      explicit IndexPartitionT(const IndexPartition &rhs);
    public:
      inline IndexPartitionT& operator=(const IndexPartition &rhs);
    };
 
    class FieldSpace {
    public:
      static const FieldSpace NO_SPACE; 
    protected:
      // Only the runtime should be allowed to make these
      FRIEND_ALL_RUNTIME_CLASSES
      FieldSpace(FieldSpaceID id);
    public:
      FieldSpace(void);
    public:
      inline bool operator==(const FieldSpace &rhs) const;
      inline bool operator!=(const FieldSpace &rhs) const;
      inline bool operator<(const FieldSpace &rhs) const;
      inline bool operator>(const FieldSpace &rhs) const;
      inline std::size_t hash(void) const;
      inline FieldSpaceID get_id(void) const { return id; }
      inline bool exists(void) const { return (id != 0); }
    private:
      friend std::ostream& operator<<(std::ostream& os, const FieldSpace& fs);
      FieldSpaceID id;
    };
 
    class LogicalRegion {
    public:
      static const LogicalRegion NO_REGION; 
    protected:
      // Only the runtime should be allowed to make these
      FRIEND_ALL_RUNTIME_CLASSES
      LogicalRegion(RegionTreeID tid, IndexSpace index, FieldSpace field);
    public:
      LogicalRegion(void);
    public:
      inline bool operator==(const LogicalRegion &rhs) const;
      inline bool operator!=(const LogicalRegion &rhs) const;
      inline bool operator<(const LogicalRegion &rhs) const;
      std::size_t hash(void) const;
    public:
      inline IndexSpace get_index_space(void) const { return index_space; }
      inline FieldSpace get_field_space(void) const { return field_space; }
      inline RegionTreeID get_tree_id(void) const { return tree_id; }
      inline bool exists(void) const { return (tree_id != 0); } 
      inline TypeTag get_type_tag(void) const 
        { return index_space.get_type_tag(); }
      inline int get_dim(void) const { return index_space.get_dim(); }
    protected:
      friend std::ostream& operator<<(std::ostream& os, 
                                      const LogicalRegion& lr);
      // These are private so the user can't just arbitrarily change them
      RegionTreeID tree_id;
      IndexSpace index_space;
      FieldSpace field_space;
    };
 
    template<int DIM, typename COORD_T = coord_t>
    class LogicalRegionT : public LogicalRegion {
    private:
      static_assert(DIM > 0, "DIM must be positive");
      static_assert(std::is_integral<COORD_T>::value, "must be integral type");
    protected:
      // Only the runtime should be allowed to make these
      FRIEND_ALL_RUNTIME_CLASSES
      LogicalRegionT(RegionTreeID tid, IndexSpace index, FieldSpace field);
    public:
      LogicalRegionT(void);
      explicit LogicalRegionT(const LogicalRegion &rhs);
    public:
      inline LogicalRegionT& operator=(const LogicalRegion &rhs);
    };
 
    class LogicalPartition {
    public:
      static const LogicalPartition NO_PART; 
    protected:
      // Only the runtime should be allowed to make these
      FRIEND_ALL_RUNTIME_CLASSES
      LogicalPartition(RegionTreeID tid, IndexPartition pid, FieldSpace field);
    public:
      LogicalPartition(void);
    public:
      inline bool operator==(const LogicalPartition &rhs) const;
      inline bool operator!=(const LogicalPartition &rhs) const;
      inline bool operator<(const LogicalPartition &rhs) const;
      std::size_t hash(void) const;
    public:
      inline IndexPartition get_index_partition(void) const 
        { return index_partition; }
      inline FieldSpace get_field_space(void) const { return field_space; }
      inline RegionTreeID get_tree_id(void) const { return tree_id; }
      inline bool exists(void) const { return (tree_id != 0); }
      inline TypeTag get_type_tag(void) const 
        { return index_partition.get_type_tag(); }
      inline int get_dim(void) const { return index_partition.get_dim(); }
    protected:
      friend std::ostream& operator<<(std::ostream& os, 
                                      const LogicalPartition& lp);
      // These are private so the user can't just arbitrary change them
      RegionTreeID tree_id;
      IndexPartition index_partition;
      FieldSpace field_space;
    };
 
    template<int DIM, typename COORD_T = coord_t>
    class LogicalPartitionT : public LogicalPartition {
    private:
      static_assert(DIM > 0, "DIM must be positive");
      static_assert(std::is_integral<COORD_T>::value, "must be integral type");
    protected:
      // Only the runtime should be allowed to make these
      FRIEND_ALL_RUNTIME_CLASSES
      LogicalPartitionT(RegionTreeID tid, IndexPartition pid, FieldSpace field);
    public:
      LogicalPartitionT(void);
      explicit LogicalPartitionT(const LogicalPartition &rhs);
    public:
      inline LogicalPartitionT& operator=(const LogicalPartition &rhs);
    };
 
    //==========================================================================
    //                       Data Allocation Classes
    //==========================================================================
 
    class FieldAllocator : public Unserializable<FieldAllocator> {
    public:
      FieldAllocator(void);
      FieldAllocator(const FieldAllocator &allocator);
      FieldAllocator(FieldAllocator &&allocator) noexcept;
      ~FieldAllocator(void);
    protected:
      FRIEND_ALL_RUNTIME_CLASSES
      // Only the Runtime should be able to make these
      FieldAllocator(Internal::FieldAllocatorImpl *impl);
    public:
      FieldAllocator& operator=(const FieldAllocator &allocator);
      FieldAllocator& operator=(FieldAllocator &&allocator) noexcept;
      inline bool operator<(const FieldAllocator &rhs) const;
      inline bool operator==(const FieldAllocator &rhs) const;
      inline bool exists(void) const { return (impl != NULL); }
    public:
 
      FieldID allocate_field(size_t field_size, 
                             FieldID desired_fieldid = LEGION_AUTO_GENERATE_ID,
                             CustomSerdezID serdez_id = 0,
                             bool local_field = false,
                             const char *provenance = NULL);
      FieldID allocate_field(const Future &field_size,
                             FieldID desired_fieldid = LEGION_AUTO_GENERATE_ID,
                             CustomSerdezID serdez_id = 0,
                             bool local_field = false,
                             const char *provenance = NULL);
 
      LEGION_DEPRECATED("We are considering removing support for freeing fields"
          "in a future Legion release. Please contact the Legion developer's "
          "list if field deletion is important for your application.") 
      void free_field(FieldID fid, const bool unordered = false,
                      const char *provenance = NULL);
 
      FieldID allocate_local_field(size_t field_size,
          FieldID desired_fieldid = LEGION_AUTO_GENERATE_ID,
          CustomSerdezID serdez_id = 0, const char *provenance = NULL);
 
      void allocate_fields(const std::vector<size_t> &field_sizes,
                           std::vector<FieldID> &resulting_fields,
                           CustomSerdezID serdez_id = 0,
                           bool local_fields = false,
                           const char *provenance = NULL);
      void allocate_fields(const std::vector<Future> &field_sizes,
                           std::vector<FieldID> &resulting_fields,
                           CustomSerdezID serdez_id = 0,
                           bool local_fields = false,
                           const char *provenance = NULL);
 
      LEGION_DEPRECATED("We are considering removing support for freeing fields"
          "in a future Legion release. Please contact the Legion developer's "
          "list if field deletion is important for your application.")
      void free_fields(const std::set<FieldID> &to_free, 
                       const bool unordered = false,
                       const char *provenance = NULL);
      void allocate_local_fields(const std::vector<size_t> &field_sizes,
                                 std::vector<FieldID> &resulting_fields,
                                 CustomSerdezID serdez_id = 0,
                                 const char *provenance = NULL);
      FieldSpace get_field_space(void) const;
    private:
      Internal::FieldAllocatorImpl *impl;
    };
 
    //==========================================================================
    //                    Pass-By-Value Argument Classes
    //==========================================================================
 
    class UntypedBuffer : public Unserializable<UntypedBuffer> {
      public:
      UntypedBuffer(void) : args(NULL), arglen(0) { }
      UntypedBuffer(const void *arg, size_t argsize)
        : args(const_cast<void*>(arg)), arglen(argsize) { }
      UntypedBuffer(const UntypedBuffer &rhs)
        : args(rhs.args), arglen(rhs.arglen) { }
      UntypedBuffer(UntypedBuffer &&rhs) noexcept
        : args(rhs.args), arglen(rhs.arglen) { }
    public:
      inline size_t get_size(void) const { return arglen; }
      inline void*  get_ptr(void) const { return args; }
    public:
      inline bool operator==(const UntypedBuffer &arg) const
        { return (args == arg.args) && (arglen == arg.arglen); }
      inline bool operator<(const UntypedBuffer &arg) const
        { return (args < arg.args) && (arglen < arg.arglen); }
      inline UntypedBuffer& operator=(const UntypedBuffer &rhs)
        { args = rhs.args; arglen = rhs.arglen; return *this; }
      inline UntypedBuffer& operator=(UntypedBuffer &&rhs) noexcept
        { args = rhs.args; arglen = rhs.arglen; return *this; }
    private:
      void *args;
      size_t arglen;
    };
    // This typedef is here for backwards compatibility since we
    // used to call an UntypedBuffer a TaskArgument
    typedef UntypedBuffer TaskArgument;
 
    class ArgumentMap : public Unserializable<ArgumentMap> {
    public:
      ArgumentMap(void);
      ArgumentMap(const FutureMap &rhs);
      ArgumentMap(const ArgumentMap &rhs);
      ArgumentMap(ArgumentMap &&rhs) noexcept;
      ~ArgumentMap(void);
    public:
      ArgumentMap& operator=(const FutureMap &rhs);
      ArgumentMap& operator=(const ArgumentMap &rhs);
      ArgumentMap& operator=(ArgumentMap &&rhs) noexcept;
      inline bool operator==(const ArgumentMap &rhs) const
        { return (impl == rhs.impl); }
      inline bool operator<(const ArgumentMap &rhs) const
        { return (impl < rhs.impl); }
      inline bool exists(void) const { return (impl != NULL); }
    public:
      bool has_point(const DomainPoint &point);
      void set_point(const DomainPoint &point, const UntypedBuffer &arg,
                     bool replace = true);
      void set_point(const DomainPoint &point, const Future &f,
                     bool replace = true);
      bool remove_point(const DomainPoint &point);
      UntypedBuffer get_point(const DomainPoint &point) const;
    public:
      template<typename PT, unsigned DIM>
      inline void set_point_arg(const PT point[DIM], const UntypedBuffer &arg,
                                bool replace = false);
      template<typename PT, unsigned DIM>
      inline bool remove_point(const PT point[DIM]);
    private:
      FRIEND_ALL_RUNTIME_CLASSES
      Internal::ArgumentMapImpl *impl;
    private:
      explicit ArgumentMap(Internal::ArgumentMapImpl *i);
    };
 
    //==========================================================================
    //                           Predicate Classes
    //==========================================================================
 
    class Predicate : public Unserializable<Predicate> {
    public:
      static const Predicate TRUE_PRED;
      static const Predicate FALSE_PRED;
    public:
      Predicate(void);
      Predicate(const Predicate &p);
      Predicate(Predicate &&p) noexcept;
      explicit Predicate(bool value);
      ~Predicate(void);
    protected:
      FRIEND_ALL_RUNTIME_CLASSES
      Internal::PredicateImpl *impl;
      // Only the runtime should be allowed to make these
      explicit Predicate(Internal::PredicateImpl *impl);
    public:
      Predicate& operator=(const Predicate &p);
      Predicate& operator=(Predicate &&p) noexcept;
      inline bool operator==(const Predicate &p) const;
      inline bool operator<(const Predicate &p) const;
      inline bool operator!=(const Predicate &p) const;
      inline bool exists(void) const { return (impl != NULL); }
    private:
      bool const_value;
    };
 
    //==========================================================================
    //             Simultaneous Coherence Synchronization Classes
    //==========================================================================
 
    class Lock {
    public:
      Lock(void);
    protected:
      // Only the runtime is allowed to make non-empty locks 
      FRIEND_ALL_RUNTIME_CLASSES
      Lock(Reservation r);
    public:
      bool operator<(const Lock &rhs) const;
      bool operator==(const Lock &rhs) const;
    public:
      void acquire(unsigned mode = 0, bool exclusive = true);
      void release(void);
    private:
      Reservation reservation_lock;
    };
 
    struct LockRequest {
    public:
      LockRequest(Lock l, unsigned mode = 0, bool exclusive = true);
    public:
      Lock lock;
      unsigned mode;
      bool exclusive;
    };
 
    class Grant {
    public:
      Grant(void);
      Grant(const Grant &g);
      ~Grant(void);
    protected:
      // Only the runtime is allowed to make non-empty grants
      FRIEND_ALL_RUNTIME_CLASSES
      explicit Grant(Internal::GrantImpl *impl);
    public:
      bool operator==(const Grant &g) const
        { return impl == g.impl; }
      bool operator<(const Grant &g) const
        { return impl < g.impl; }
      Grant& operator=(const Grant &g);
    protected:
      Internal::GrantImpl *impl;
    };
 
    class PhaseBarrier {
    public:
      PhaseBarrier(void);
    protected:
      // Only the runtime is allowed to make non-empty phase barriers
      FRIEND_ALL_RUNTIME_CLASSES
      PhaseBarrier(Internal::ApBarrier b);
    public:
      bool operator<(const PhaseBarrier &rhs) const;
      bool operator==(const PhaseBarrier &rhs) const;
      bool operator!=(const PhaseBarrier &rhs) const;
    public:
      void arrive(unsigned count = 1);
      void wait(void);
      void alter_arrival_count(int delta);
      Realm::Barrier get_barrier(void) const { return phase_barrier; }
      bool exists(void) const;
    protected:
      Internal::ApBarrier phase_barrier;
      friend std::ostream& operator<<(std::ostream& os, const PhaseBarrier& pb);
    };
 
    class DynamicCollective : public PhaseBarrier {
    public:
      DynamicCollective(void);
    protected:
      // Only the runtime is allowed to make non-empty dynamic collectives
      FRIEND_ALL_RUNTIME_CLASSES
      DynamicCollective(Internal::ApBarrier b, ReductionOpID redop);
    public:
      // All the same operations as a phase barrier
      void arrive(const void *value, size_t size, unsigned count = 1);
    protected:
      ReductionOpID redop;
    };
 
    //==========================================================================
    //                    Operation Requirement Classes
    //==========================================================================
 
    struct RegionRequirement {
    public: 
      RegionRequirement(void);
      RegionRequirement(LogicalRegion _handle,
                        const std::set<FieldID> &privilege_fields,
                        const std::vector<FieldID> &instance_fields,
                        PrivilegeMode _priv, CoherenceProperty _prop, 
                        LogicalRegion _parent, MappingTagID _tag = 0, 
                        bool _verified = false);
      RegionRequirement(LogicalPartition pid, ProjectionID _proj,
                        const std::set<FieldID> &privilege_fields,
                        const std::vector<FieldID> &instance_fields,
                        PrivilegeMode _priv, CoherenceProperty _prop,
                        LogicalRegion _parent, MappingTagID _tag = 0, 
                        bool _verified = false);
      RegionRequirement(LogicalRegion _handle, ProjectionID _proj,
                        const std::set<FieldID> &privilege_fields,
                        const std::vector<FieldID> &instance_fields,
                        PrivilegeMode _priv, CoherenceProperty _prop,
                        LogicalRegion _parent, MappingTagID _tag = 0,
                        bool _verified = false);
      RegionRequirement(LogicalRegion _handle,
                        const std::set<FieldID> &privilege_fields,
                        const std::vector<FieldID> &instance_fields,
                        ReductionOpID op, CoherenceProperty _prop, 
                        LogicalRegion _parent, MappingTagID _tag = 0, 
                        bool _verified = false);
      RegionRequirement(LogicalPartition pid, ProjectionID _proj, 
                        const std::set<FieldID> &privilege_fields,
                        const std::vector<FieldID> &instance_fields,
                        ReductionOpID op, CoherenceProperty _prop,
                        LogicalRegion _parent, MappingTagID _tag = 0, 
                        bool _verified = false);
      RegionRequirement(LogicalRegion _handle, ProjectionID _proj,
                        const std::set<FieldID> &privilege_fields,
                        const std::vector<FieldID> &instance_fields,
                        ReductionOpID op, CoherenceProperty _prop, 
                        LogicalRegion _parent, MappingTagID _tag = 0, 
                        bool _verified = false);
    public:
      // Analogous constructors without the privilege and instance fields
      RegionRequirement(LogicalRegion _handle, PrivilegeMode _priv, 
                        CoherenceProperty _prop, LogicalRegion _parent,
            MappingTagID _tag = 0, bool _verified = false);
      RegionRequirement(LogicalPartition pid, ProjectionID _proj,
                        PrivilegeMode _priv, CoherenceProperty _prop,
                        LogicalRegion _parent, MappingTagID _tag = 0, 
                        bool _verified = false);
      RegionRequirement(LogicalRegion _handle, ProjectionID _proj,
                        PrivilegeMode _priv, CoherenceProperty _prop, 
                        LogicalRegion _parent, MappingTagID _tag = 0, 
                        bool _verified = false);
      RegionRequirement(LogicalRegion _handle, ReductionOpID op, 
                        CoherenceProperty _prop, LogicalRegion _parent,
            MappingTagID _tag = 0, bool _verified = false);
      RegionRequirement(LogicalPartition pid, ProjectionID _proj, 
                        ReductionOpID op, CoherenceProperty _prop,
                        LogicalRegion _parent, MappingTagID _tag = 0, 
                        bool _verified = false);
      RegionRequirement(LogicalRegion _handle, ProjectionID _proj,
                        ReductionOpID op, CoherenceProperty _prop, 
                        LogicalRegion _parent, MappingTagID _tag = 0, 
                        bool _verified = false);
    public:
      RegionRequirement(const RegionRequirement &rhs);
      RegionRequirement(RegionRequirement &&rhs) noexcept;
      ~RegionRequirement(void);
      RegionRequirement& operator=(const RegionRequirement &rhs);
      RegionRequirement& operator=(RegionRequirement &&rhs) noexcept;
    public:
      bool operator==(const RegionRequirement &req) const;
      bool operator<(const RegionRequirement &req) const;
    public:
      inline RegionRequirement& add_field(FieldID fid, bool instance = true);
      inline RegionRequirement& add_fields(const std::vector<FieldID>& fids, 
                                           bool instance = true);
 
      inline RegionRequirement& add_flags(RegionFlags new_flags);
    public:
      inline bool is_verified(void) const 
        { return (flags & LEGION_VERIFIED_FLAG); }
      inline bool is_no_access(void) const 
        { return (flags & LEGION_NO_ACCESS_FLAG); }
      inline bool is_restricted(void) const 
        { return (flags & LEGION_RESTRICTED_FLAG); }
      LEGION_DEPRECATED("Premapping regions is no longer supported.") 
      inline bool must_premap(void) const
        { return false; }
    public:
      const void* get_projection_args(size_t *size) const;
      void set_projection_args(const void *args, size_t size, bool own = false);
    public:
      bool has_field_privilege(FieldID fid) const;
    public:
      // Fields used for controlling task launches
      LogicalRegion region; 
      LogicalPartition partition; 
      std::set<FieldID> privilege_fields; 
      std::vector<FieldID> instance_fields; 
      PrivilegeMode privilege; 
      CoherenceProperty prop; 
      LogicalRegion parent; 
      ReductionOpID redop; 
      MappingTagID tag; 
      RegionFlags flags; 
    public:
      ProjectionType handle_type; 
      ProjectionID projection; 
    public:
      void *projection_args; 
      size_t projection_args_size; 
    };
 
    struct OutputRequirement : public RegionRequirement {
    public:
      OutputRequirement(bool valid_requirement = false);
      OutputRequirement(const RegionRequirement &req);
      OutputRequirement(FieldSpace field_space,
                        const std::set<FieldID> &fields,
                        int dim = 1,
                        bool global_indexing = false);
    public:
      OutputRequirement(const OutputRequirement &rhs);
      ~OutputRequirement(void);
      OutputRequirement& operator=(const RegionRequirement &req);
      OutputRequirement& operator=(const OutputRequirement &req);
    public:
      bool operator==(const OutputRequirement &req) const;
      bool operator<(const OutputRequirement &req) const;
    public:
      template <int DIM, typename COORD_T>
      void set_type_tag();
      // Specifies a projection functor id for this requirement.
      // For a projection output requirement, a color space must be specified.
      // The projection functor must be a bijective mapping from the launch
      // domain to the color space. This implies that the launch domain's
      // volume must be the same as the color space's.
      void set_projection(ProjectionID projection, IndexSpace color_space);
    public:
      TypeTag type_tag;
      FieldSpace field_space; 
      bool global_indexing; 
      bool valid_requirement; 
      IndexSpace color_space; 
    };
 
    struct IndexSpaceRequirement {
    public:
      IndexSpace    handle;
      AllocateMode  privilege;
      IndexSpace    parent;
      bool          verified;
    public:
      IndexSpaceRequirement(void);
      IndexSpaceRequirement(IndexSpace _handle,
                            AllocateMode _priv,
                            IndexSpace _parent,
                            bool _verified = false);
    public:
      bool operator<(const IndexSpaceRequirement &req) const;
      bool operator==(const IndexSpaceRequirement &req) const;
    };
 
    struct FieldSpaceRequirement {
    public:
      FieldSpace   handle;
      AllocateMode privilege;
      bool         verified;
    public:
      FieldSpaceRequirement(void);
      FieldSpaceRequirement(FieldSpace _handle,
                            AllocateMode _priv,
                            bool _verified = false);
    public:
      bool operator<(const FieldSpaceRequirement &req) const;
      bool operator==(const FieldSpaceRequirement &req) const;
    };
 
    //==========================================================================
    //                          Future Value Classes
    //==========================================================================
 
    class Future : public Unserializable<Future> {
    public:
      Future(void);
      Future(const Future &f);
      Future(Future &&f) noexcept;
      ~Future(void);
    private:
      Internal::FutureImpl *impl;
    protected:
      // Only the runtime should be allowed to make these
      FRIEND_ALL_RUNTIME_CLASSES
      explicit Future(Internal::FutureImpl *impl);
    public:
      inline bool exists(void) const { return (impl != NULL); }
      inline bool operator==(const Future &f) const
        { return impl == f.impl; }
      inline bool operator<(const Future &f) const
        { return impl < f.impl; }
      Future& operator=(const Future &f);
      Future& operator=(Future &&f) noexcept;
      std::size_t hash(void) const;
    public:
      template<typename T> 
        inline T get_result(bool silence_warnings = false,
                            const char *warning_string = NULL) const;
      void get_void_result(bool silence_warnings = false,
                           const char *warning_string = NULL) const;
      bool is_empty(bool block = false, bool silence_warnings = false,
                    const char *warning_string = NULL) const;
      bool is_ready(bool subscribe = false) const;
    public:
      template<typename T, PrivilegeMode PM = LEGION_READ_ONLY>
        Span<T,PM> get_span(Memory::Kind memory,
                            bool silence_warnings = false,
                            const char *warning_string = NULL) const;
 
      const void* get_buffer(Memory::Kind memory, 
                             size_t *extent_in_bytes = NULL,
                             bool check_extent = false,
                             bool silence_warnings = false,
                             const char *warning_string = NULL) const;
 
      void get_memories(std::set<Memory> &memories,
                        bool silence_warnings = false,
                        const char *warning_string = NULL) const;
 
      template<typename T> 
        LEGION_DEPRECATED("Use 'Future::get_span' instead")
        inline const T& get_reference(bool silence_warnings = false,
                                      const char *warning_string = NULL) const;
      LEGION_DEPRECATED("Use 'Future::get_buffer' instead")
      inline const void* get_untyped_pointer(bool silence_warnings = false,
                                       const char *warning_string = NULL) const; 
 
      size_t get_untyped_size(void) const;
 
      const void* get_metadata(size_t *size = NULL) const;
    public:
      // These methods provide partial support the C++ future interface
      template<typename T>
      inline T get(void);
 
      inline bool valid(void) const;
 
      inline void wait(void) const;
    public:
      template<typename T>
      LEGION_DEPRECATED("Use the version without a runtime pointer argument")
      static inline Future from_value(Runtime *rt, const T &value);
      template<typename T>
      static inline Future from_value(const T &value);
      static Future from_domain(const Domain &d, bool take_ownership,
          const char *provenance = NULL, bool shard_local = false);
 
      LEGION_DEPRECATED("Use the version without a runtime pointer argument")
      static Future from_untyped_pointer(Runtime *rt,
          const void *buffer, size_t bytes, bool take_ownership = false);
      static Future from_untyped_pointer(
          const void *buffer, size_t bytes, bool take_ownership = false,
          const char *provenance = NULL, bool shard_local = false);
      static Future from_value(const void *buffer, size_t bytes, bool owned,
          const Realm::ExternalInstanceResource &resource,
          void (*freefunc)(const Realm::ExternalInstanceResource&) = NULL,
          const char *provenance = NULL, bool shard_local = false);
    private:
      // This should only be available for accessor classes
      template<PrivilegeMode, typename, int, typename, typename, bool>
      friend class FieldAccessor;
      Realm::RegionInstance get_instance(Memory::Kind kind,
          size_t field_size, bool check_field_size,
          const char *warning_string, bool silence_warnings) const;
      void report_incompatible_accessor(const char *accessor_kind,
                             Realm::RegionInstance instance) const;
    };
 
    class FutureMap : public Unserializable<FutureMap> {
    public:
      FutureMap(void);
      FutureMap(const FutureMap &map);
      FutureMap(FutureMap &&map) noexcept;
      ~FutureMap(void);
    private:
      Internal::FutureMapImpl *impl;
    protected:
      // Only the runtime should be allowed to make these
      FRIEND_ALL_RUNTIME_CLASSES
      explicit FutureMap(Internal::FutureMapImpl *impl);
    public:
      inline bool exists(void) const { return (impl != NULL); }
      inline bool operator==(const FutureMap &f) const
        { return impl == f.impl; }
      inline bool operator<(const FutureMap &f) const
        { return impl < f.impl; }
      inline Future operator[](const DomainPoint &point) const
        { return get_future(point); }
      FutureMap& operator=(const FutureMap &f);
      FutureMap& operator=(FutureMap &&f) noexcept;
      std::size_t hash(void) const;
    public:
      template<typename T>
        inline T get_result(const DomainPoint &point,
                            bool silence_warnings = false,
                            const char *warning_string = NULL) const;
      Future get_future(const DomainPoint &point) const;
      void get_void_result(const DomainPoint &point,
                           bool silence_warnings = false,
                           const char *warning_string = NULL) const;
    public:
      template<typename RT, typename PT, unsigned DIM> 
        inline RT get_result(const PT point[DIM]) const;
      template<typename PT, unsigned DIM>
        inline Future get_future(const PT point[DIM]) const;
      template<typename PT, unsigned DIM>
        inline void get_void_result(const PT point[DIM]) const;
    public:
      void wait_all_results(bool silence_warnings = false,
                            const char *warning_string = NULL) const; 
    public:
      Domain get_future_map_domain(void) const;
    }; 
 
 
    //==========================================================================
    //                    Operation Launcher Classes
    //==========================================================================
 
    struct StaticDependence : public Unserializable<StaticDependence> {
    public:
      StaticDependence(void);
      StaticDependence(unsigned previous_offset,
                       unsigned previous_req_index,
                       unsigned current_req_index,
                       DependenceType dtype,
                       bool validates = false,
                       bool shard_only = false);
    public:
      inline void add_field(FieldID fid);
    public:
      // The relative offset from this operation to 
      // previous operation in the stream of operations
      // (e.g. 1 is the operation launched immediately before)
      unsigned                      previous_offset;
      // Region requirement of the previous operation for the dependence
      unsigned                      previous_req_index;
      // Region requirement of the current operation for the dependence
      unsigned                      current_req_index;
      // The type of the dependence
      DependenceType                dependence_type;
      // Whether this requirement validates the previous writer
      bool                          validates;
      // Whether this dependence is a shard-only dependence for 
      // control replication or it depends on all other copies
      bool                          shard_only;
      // Fields that have the dependence
      std::set<FieldID>             dependent_fields;
    };
 
    struct TaskLauncher {
    public:
      TaskLauncher(void);
      TaskLauncher(TaskID tid, 
                   UntypedBuffer arg,
                   Predicate pred = Predicate::TRUE_PRED,
                   MapperID id = 0,
                   MappingTagID tag = 0,
                   UntypedBuffer map_arg = UntypedBuffer(),
                   const char *provenance = "");
    public:
      inline IndexSpaceRequirement&
              add_index_requirement(const IndexSpaceRequirement &req);
      inline RegionRequirement&
              add_region_requirement(const RegionRequirement &req);
      inline void add_field(unsigned idx, FieldID fid, bool inst = true);
    public:
      inline void add_future(Future f);
      inline void add_grant(Grant g);
      inline void add_wait_barrier(PhaseBarrier bar);
      inline void add_arrival_barrier(PhaseBarrier bar);
      inline void add_wait_handshake(LegionHandshake handshake);
      inline void add_arrival_handshake(LegionHandshake handshake);
    public:
      inline void set_predicate_false_future(Future f);
      inline void set_predicate_false_result(UntypedBuffer arg);
    public:
      inline void set_independent_requirements(bool independent);
    public:
      TaskID                             task_id;
      std::vector<IndexSpaceRequirement> index_requirements;
      std::vector<RegionRequirement>     region_requirements;
      std::vector<Future>                futures;
      std::vector<Grant>                 grants;
      std::vector<PhaseBarrier>          wait_barriers;
      std::vector<PhaseBarrier>          arrive_barriers;
      UntypedBuffer                      argument;
      Predicate                          predicate;
      MapperID                           map_id;
      MappingTagID                       tag;
      UntypedBuffer                      map_arg;
      DomainPoint                        point;
      // Only used in control replication contexts for
      // doing sharding. If left unspecified the runtime
      // will use an index space of size 1 containing 'point'
      IndexSpace                         sharding_space;
    public:
      // If the predicate is set to anything other than
      // Predicate::TRUE_PRED, then the application must 
      // specify a value for the future in the case that
      // the predicate resolves to false. UntypedBuffer(NULL,0)
      // can be used if the task's return type is void.
      Future                             predicate_false_future;
      UntypedBuffer                      predicate_false_result;
    public:
      // Provenance string for the runtime and tools to use
      std::string                        provenance;
    public:
      // Inform the runtime about any static dependences
      // These will be ignored outside of static traces
      const std::vector<StaticDependence> *static_dependences;
    public:
      // Users can tell the runtime this task is eligible
      // for inlining by the mapper. This will invoke the 
      // select_task_options call inline as part of the launch
      // logic for this task to allow the mapper to decide
      // whether to inline the task or not. Note that if the
      // mapper pre-empts during execution then resuming it
      // may take a long time if another long running task
      // gets scheduled on the processor that launched this task.
      bool                               enable_inlining;
    public:
      // In some cases users (most likely compilers) will want
      // to run a light-weight function (e.g. a continuation)
      // as a task that just depends on futures once those futures 
      // are ready on a local processor where the parent task
      // is executing. We call this a local function task and it 
      // must not have any region requirements. It must als be a 
      // pure function with no side effects. This task will
      // not have the option of being distributed to remote nodes.
      bool                               local_function_task;
    public:
      // Users can inform the runtime that all region requirements
      // are independent of each other in this task. Independent
      // means that either field sets are independent or region
      // requirements are disjoint based on the region tree.
      bool                               independent_requirements;
    public:
      // Instruct the runtime that it does not need to produce
      // a future or future map result for this index task
      bool                               elide_future_return;
      // Provide an optional future return size. In general you
      // shouldn't need to use this and should prefer specifying
      // the future return size when you register a task variant.
      std::optional<size_t>              future_return_size;
    public:
      bool                               silence_warnings;
    };
 
    struct IndexTaskLauncher {
    public:
      IndexTaskLauncher(void);
      IndexTaskLauncher(TaskID tid,
                        Domain domain,
                        UntypedBuffer global_arg,
                        ArgumentMap map,
                        Predicate pred = Predicate::TRUE_PRED,
                        bool must = false,
                        MapperID id = 0,
                        MappingTagID tag = 0,
                        UntypedBuffer map_arg = UntypedBuffer(),
                        const char *provenance = "");
      IndexTaskLauncher(TaskID tid,
                        IndexSpace launch_space,
                        UntypedBuffer global_arg,
                        ArgumentMap map,
                        Predicate pred = Predicate::TRUE_PRED,
                        bool must = false,
                        MapperID id = 0,
                        MappingTagID tag = 0,
                        UntypedBuffer map_arg = UntypedBuffer(),
                        const char *provenance = "");
    public:
      inline IndexSpaceRequirement&
                  add_index_requirement(const IndexSpaceRequirement &req);
      inline RegionRequirement&
                  add_region_requirement(const RegionRequirement &req);
      inline void add_field(unsigned idx, FieldID fid, bool inst = true);
    public:
      inline void add_future(Future f);
      inline void add_grant(Grant g);
      inline void add_wait_barrier(PhaseBarrier bar);
      inline void add_arrival_barrier(PhaseBarrier bar);
      inline void add_wait_handshake(LegionHandshake handshake);
      inline void add_arrival_handshake(LegionHandshake handshake);
    public:
      inline void set_predicate_false_future(Future f);
      inline void set_predicate_false_result(UntypedBuffer arg);
    public:
      inline void set_independent_requirements(bool independent);
    public:
      TaskID                             task_id;
      Domain                             launch_domain;
      IndexSpace                         launch_space;
      // Will only be used in control replication context. If left
      // unset the runtime will use launch_domain/launch_space
      IndexSpace                         sharding_space;
      std::vector<IndexSpaceRequirement> index_requirements;
      std::vector<RegionRequirement>     region_requirements;
      std::vector<Future>                futures;
      // These are appended to the futures for the point
      // task after the futures sent to all points above
      std::vector<ArgumentMap>           point_futures;
      std::vector<Grant>                 grants;
      std::vector<PhaseBarrier>          wait_barriers;
      std::vector<PhaseBarrier>          arrive_barriers;
      UntypedBuffer                      global_arg;
      ArgumentMap                        argument_map;
      Predicate                          predicate;
      // Specify that all the point tasks in this index launch be 
      // able to run concurrently, meaning they all must map to
      // different processors and they cannot have interfering region
      // requirements that might lead to dependences. Note that the
      // runtime guarantees that concurrent index launches will not
      // deadlock with other concurrent index launches which requires 
      // additional analysis. Currently concurrent index space launches
      // will only be allowed to map to leaf task variants currently.
      ConcurrentID                       concurrent_functor; // = 0
      bool                               concurrent; // = false
      // This will convert this index space launch into a must
      // epoch launch which supports interfering region requirements
      bool                               must_parallelism;
      MapperID                           map_id;
      MappingTagID                       tag;
      UntypedBuffer                      map_arg;
    public:
      // If the predicate is set to anything other than
      // Predicate::TRUE_PRED, then the application must 
      // specify a value for the future in the case that
      // the predicate resolves to false. UntypedBuffer(NULL,0)
      // can be used if the task's return type is void.
      Future                             predicate_false_future;
      UntypedBuffer                      predicate_false_result;
    public:
      // Provenance string for the runtime and tools to use
      std::string                        provenance;
    public:
      // Inform the runtime about any static dependences
      // These will be ignored outside of static traces
      const std::vector<StaticDependence> *static_dependences;
    public:
      // Users can tell the runtime this task is eligible
      // for inlining by the mapper. This will invoke the 
      // select_task_options call inline as part of the launch
      // logic for this task to allow the mapper to decide
      // whether to inline the task or not. Note that if the
      // mapper pre-empts during execution then resuming it
      // may take a long time if another long running task
      // gets scheduled on the processor that launched this task.
      bool                               enable_inlining;
    public:
      // Users can inform the runtime that all region requirements
      // are independent of each other in this task. Independent
      // means that either field sets are independent or region
      // requirements are disjoint based on the region tree.
      bool                               independent_requirements;
    public:
      bool                               silence_warnings;
    public:
      // Instruct the runtime that it does not need to produce
      // a future or future map result for this index task
      bool                               elide_future_return;
      // Provide an optional future return size. In general you
      // shouldn't need to use this and should prefer specifying
      // the future return size when you register a task variant.
      std::optional<size_t>              future_return_size;
    public:
      // Initial value for reduction
      Future                             initial_value;
    };
 
    struct InlineLauncher {
    public:
      InlineLauncher(void);
      InlineLauncher(const RegionRequirement &req,
                     MapperID id = 0,
                     MappingTagID tag = 0,
                     LayoutConstraintID layout_id = 0,
                     UntypedBuffer map_arg = UntypedBuffer(),
                     const char *provenance = "");
    public:
      inline void add_field(FieldID fid, bool inst = true);
    public:
      inline void add_grant(Grant g);
      inline void add_wait_barrier(PhaseBarrier bar);
      inline void add_arrival_barrier(PhaseBarrier bar);
      inline void add_wait_handshake(LegionHandshake handshake);
      inline void add_arrival_handshake(LegionHandshake handshake);
    public:
      RegionRequirement               requirement;
      std::vector<Grant>              grants;
      std::vector<PhaseBarrier>       wait_barriers;
      std::vector<PhaseBarrier>       arrive_barriers;
      MapperID                        map_id;
      MappingTagID                    tag;
      UntypedBuffer                   map_arg;
    public:
      LayoutConstraintID              layout_constraint_id;
    public:
      // Provenance string for the runtime and tools to use
      std::string                     provenance;
    public:
      // Inform the runtime about any static dependences
      // These will be ignored outside of static traces
      const std::vector<StaticDependence> *static_dependences;
    };
 
    struct CopyLauncher {
    public:
      CopyLauncher(Predicate pred = Predicate::TRUE_PRED,
                   MapperID id = 0, MappingTagID tag = 0,
                   UntypedBuffer map_arg = UntypedBuffer(),
                   const char *provenance = "");
    public:
      inline unsigned add_copy_requirements(const RegionRequirement &src,
                        const RegionRequirement &dst);
      inline void add_src_field(unsigned idx, FieldID fid, bool inst = true);
      inline void add_dst_field(unsigned idx, FieldID fid, bool inst = true);
    public:
      // Specify src/dst indirect requirements (must have exactly 1 field)
      inline void add_src_indirect_field(FieldID src_idx_fid,
                                         const RegionRequirement &src_idx_req,
                                         bool is_range_indirection = false,
                                         bool inst = true);
      inline void add_dst_indirect_field(FieldID dst_idx_fid,
                                         const RegionRequirement &dst_idx_req,
                                         bool is_range_indirection = false,
                                         bool inst = true);
      inline RegionRequirement& add_src_indirect_field(
                                         const RegionRequirement &src_idx_req,
                                         bool is_range_indirection = false);
      inline RegionRequirement& add_dst_indirect_field(
                                         const RegionRequirement &dst_idx_req,
                                         bool is_range_indirection = false);
    public:
      inline void add_grant(Grant g);
      inline void add_wait_barrier(PhaseBarrier bar);
      inline void add_arrival_barrier(PhaseBarrier bar);
      inline void add_wait_handshake(LegionHandshake handshake);
      inline void add_arrival_handshake(LegionHandshake handshake); 
    public:
      std::vector<RegionRequirement>  src_requirements;
      std::vector<RegionRequirement>  dst_requirements;
      std::vector<RegionRequirement>  src_indirect_requirements;
      std::vector<RegionRequirement>  dst_indirect_requirements;
      std::vector<bool>               src_indirect_is_range;
      std::vector<bool>               dst_indirect_is_range;
      std::vector<Grant>              grants;
      std::vector<PhaseBarrier>       wait_barriers;
      std::vector<PhaseBarrier>       arrive_barriers;
      Predicate                       predicate;
      MapperID                        map_id;
      MappingTagID                    tag;
      UntypedBuffer                   map_arg;
      DomainPoint                     point;
      // Only used in control replication contexts for
      // doing sharding. If left unspecified the runtime
      // will use an index space of size 1 containing 'point'
      IndexSpace                      sharding_space;
    public:
      // Provenance string for the runtime and tools to use
      std::string                     provenance;
    public:
      // Inform the runtime about any static dependences
      // These will be ignored outside of static traces
      const std::vector<StaticDependence> *static_dependences;
    public:
      // Whether the source and destination indirections can lead
      // to out-of-range access into the instances to skip
      bool                            possible_src_indirect_out_of_range;
      bool                            possible_dst_indirect_out_of_range;
      // Whether the destination indirection can lead to aliasing 
      // in the destination instances requiring synchronization
      bool                            possible_dst_indirect_aliasing;
    public:
      bool                            silence_warnings;
    };
 
    struct IndexCopyLauncher {
    public:
      IndexCopyLauncher(void);
      IndexCopyLauncher(Domain domain, Predicate pred = Predicate::TRUE_PRED,
                        MapperID id = 0, MappingTagID tag = 0,
                        UntypedBuffer map_arg = UntypedBuffer(),
                        const char *provenance = "");
      IndexCopyLauncher(IndexSpace space, Predicate pred = Predicate::TRUE_PRED,
                        MapperID id = 0, MappingTagID tag = 0,
                        UntypedBuffer map_arg = UntypedBuffer(),
                        const char *provenance = "");
    public:
      inline unsigned add_copy_requirements(const RegionRequirement &src,
                        const RegionRequirement &dst);
      inline void add_src_field(unsigned idx, FieldID fid, bool inst = true);
      inline void add_dst_field(unsigned idx, FieldID fid, bool inst = true);
    public:
      // Specify src/dst indirect requirements (must have exactly 1 field)
      inline void add_src_indirect_field(FieldID src_idx_fid,
                                         const RegionRequirement &src_idx_req,
                                         bool is_range_indirection = false,
                                         bool inst = true);
      inline void add_dst_indirect_field(FieldID dst_idx_fid,
                                         const RegionRequirement &dst_idx_req,
                                         bool is_range_indirection = false,
                                         bool inst = true);
      inline RegionRequirement& add_src_indirect_field(
                                         const RegionRequirement &src_idx_req,
                                         bool is_range_indirection = false);
      inline RegionRequirement& add_dst_indirect_field(
                                         const RegionRequirement &dst_idx_req,
                                         bool is_range_indirection = false);
    public:
      inline void add_grant(Grant g);
      inline void add_wait_barrier(PhaseBarrier bar);
      inline void add_arrival_barrier(PhaseBarrier bar);
      inline void add_wait_handshake(LegionHandshake handshake);
      inline void add_arrival_handshake(LegionHandshake handshake);
    public:
      std::vector<RegionRequirement>  src_requirements;
      std::vector<RegionRequirement>  dst_requirements;
      std::vector<RegionRequirement>  src_indirect_requirements;
      std::vector<RegionRequirement>  dst_indirect_requirements;
      std::vector<bool>               src_indirect_is_range;
      std::vector<bool>               dst_indirect_is_range;
      std::vector<Grant>              grants;
      std::vector<PhaseBarrier>       wait_barriers;
      std::vector<PhaseBarrier>       arrive_barriers;
      Domain                          launch_domain;
      IndexSpace                      launch_space;
      // Will only be used in control replication context. If left
      // unset the runtime will use launch_domain/launch_space
      IndexSpace                      sharding_space;
      Predicate                       predicate;
      MapperID                        map_id;
      MappingTagID                    tag;
      UntypedBuffer                   map_arg;
    public:
      // Provenance string for the runtime and tools to use
      std::string                     provenance;
    public:
      // Inform the runtime about any static dependences
      // These will be ignored outside of static traces
      const std::vector<StaticDependence> *static_dependences;
    public:
      // Whether the source and destination indirections can lead
      // to out-of-range access into the instances to skip
      bool                            possible_src_indirect_out_of_range;
      bool                            possible_dst_indirect_out_of_range;
      // Whether the destination indirection can lead to aliasing 
      // in the destination instances requiring synchronization
      bool                            possible_dst_indirect_aliasing;
      // Whether the individual point copies should operate collectively
      // together in the case of indirect copies (e.g. allow indirections
      // to refer to instances from other points). These settings have
      // no effect in the case of copies without indirections.
      bool                            collective_src_indirect_points;
      bool                            collective_dst_indirect_points;
    public:
      bool                            silence_warnings;
    };
 
    struct FillLauncher {
    public:
      FillLauncher(void);
      FillLauncher(LogicalRegion handle, LogicalRegion parent,
                   UntypedBuffer arg, Predicate pred = Predicate::TRUE_PRED,
                   MapperID id = 0, MappingTagID tag = 0,
                   UntypedBuffer map_arg = UntypedBuffer(),
                   const char *provenance = "");
      FillLauncher(LogicalRegion handle, LogicalRegion parent,
                   Future f, Predicate pred = Predicate::TRUE_PRED,
                   MapperID id = 0, MappingTagID tag = 0,
                   UntypedBuffer map_arg = UntypedBuffer(),
                   const char *provenance = "");
    public:
      inline void set_argument(UntypedBuffer arg);
      inline void set_future(Future f);
      inline void add_field(FieldID fid);
      inline void add_grant(Grant g);
      inline void add_wait_barrier(PhaseBarrier bar);
      inline void add_arrival_barrier(PhaseBarrier bar);
      inline void add_wait_handshake(LegionHandshake handshake);
      inline void add_arrival_handshake(LegionHandshake handshake);
    public:
      LogicalRegion                   handle;
      LogicalRegion                   parent;
      UntypedBuffer                   argument;
      Future                          future;
      Predicate                       predicate;
      std::set<FieldID>               fields;
      std::vector<Grant>              grants;
      std::vector<PhaseBarrier>       wait_barriers;
      std::vector<PhaseBarrier>       arrive_barriers;
      MapperID                        map_id;
      MappingTagID                    tag;
      UntypedBuffer                   map_arg;
      DomainPoint                     point;
      // Only used in control replication contexts for
      // doing sharding. If left unspecified the runtime
      // will use an index space of size 1 containing 'point'
      IndexSpace                      sharding_space;
    public:
      // Provenance string for the runtime and tools to use
      std::string                     provenance;
    public:
      // Inform the runtime about any static dependences
      // These will be ignored outside of static traces
      const std::vector<StaticDependence> *static_dependences;
    public:
      bool                            silence_warnings;
    };
 
    struct IndexFillLauncher {
    public:
      IndexFillLauncher(void);
      // Region projection
      IndexFillLauncher(Domain domain, LogicalRegion handle, 
                        LogicalRegion parent, UntypedBuffer arg,
                        ProjectionID projection = 0,
                        Predicate pred = Predicate::TRUE_PRED,
                        MapperID id = 0, MappingTagID tag = 0,
                        UntypedBuffer map_arg = UntypedBuffer(),
                        const char *provenance = "");
      IndexFillLauncher(Domain domain, LogicalRegion handle, 
                        LogicalRegion parent, Future f,
                        ProjectionID projection = 0,
                        Predicate pred = Predicate::TRUE_PRED,
                        MapperID id = 0, MappingTagID tag = 0,
                        UntypedBuffer map_arg = UntypedBuffer(),
                        const char *provenance = "");
      IndexFillLauncher(IndexSpace space, LogicalRegion handle, 
                        LogicalRegion parent, UntypedBuffer arg,
                        ProjectionID projection = 0,
                        Predicate pred = Predicate::TRUE_PRED,
                        MapperID id = 0, MappingTagID tag = 0,
                        UntypedBuffer map_arg = UntypedBuffer(),
                        const char *provenance = "");
      IndexFillLauncher(IndexSpace space, LogicalRegion handle, 
                        LogicalRegion parent, Future f,
                        ProjectionID projection = 0,
                        Predicate pred = Predicate::TRUE_PRED,
                        MapperID id = 0, MappingTagID tag = 0,
                        UntypedBuffer map_arg = UntypedBuffer(),
                        const char *provenance = "");
      // Partition projection
      IndexFillLauncher(Domain domain, LogicalPartition handle, 
                        LogicalRegion parent, UntypedBuffer arg,
                        ProjectionID projection = 0,
                        Predicate pred = Predicate::TRUE_PRED,
                        MapperID id = 0, MappingTagID tag = 0,
                        UntypedBuffer map_arg = UntypedBuffer(),
                        const char *provenance = "");
      IndexFillLauncher(Domain domain, LogicalPartition handle, 
                        LogicalRegion parent, Future f,
                        ProjectionID projection = 0,
                        Predicate pred = Predicate::TRUE_PRED,
                        MapperID id = 0, MappingTagID tag = 0,
                        UntypedBuffer map_arg = UntypedBuffer(),
                        const char *provenance = "");
      IndexFillLauncher(IndexSpace space, LogicalPartition handle, 
                        LogicalRegion parent, UntypedBuffer arg,
                        ProjectionID projection = 0,
                        Predicate pred = Predicate::TRUE_PRED,
                        MapperID id = 0, MappingTagID tag = 0,
                        UntypedBuffer map_arg = UntypedBuffer(),
                        const char *provenance = "");
      IndexFillLauncher(IndexSpace space, LogicalPartition handle, 
                        LogicalRegion parent, Future f,
                        ProjectionID projection = 0,
                        Predicate pred = Predicate::TRUE_PRED,
                        MapperID id = 0, MappingTagID tag = 0,
                        UntypedBuffer map_arg = UntypedBuffer(),
                        const char *provenance = "");
    public:
      inline void set_argument(UntypedBuffer arg);
      inline void set_future(Future f);
      inline void add_field(FieldID fid);
      inline void add_grant(Grant g);
      inline void add_wait_barrier(PhaseBarrier bar);
      inline void add_arrival_barrier(PhaseBarrier bar);
      inline void add_wait_handshake(LegionHandshake handshake);
      inline void add_arrival_handshake(LegionHandshake handshake);
    public:
      Domain                          launch_domain;
      IndexSpace                      launch_space;
      // Will only be used in control replication context. If left
      // unset the runtime will use launch_domain/launch_space
      IndexSpace                      sharding_space;
      LogicalRegion                   region;
      LogicalPartition                partition;
      LogicalRegion                   parent;
      ProjectionID                    projection;
      UntypedBuffer                   argument;
      Future                          future;
      Predicate                       predicate;
      std::set<FieldID>               fields;
      std::vector<Grant>              grants;
      std::vector<PhaseBarrier>       wait_barriers;
      std::vector<PhaseBarrier>       arrive_barriers;
      MapperID                        map_id;
      MappingTagID                    tag;
      UntypedBuffer                   map_arg;
    public:
      // Provenance string for the runtime and tools to use
      std::string                     provenance;
    public:
      // Inform the runtime about any static dependences
      // These will be ignored outside of static traces
      const std::vector<StaticDependence> *static_dependences;
    public:
      bool                            silence_warnings;
    };
 
    struct DiscardLauncher {
    public:
      DiscardLauncher(LogicalRegion handle, LogicalRegion parent);
    public:
      inline void add_field(FieldID fid);
    public:
      LogicalRegion                   handle;
      LogicalRegion                   parent;
      std::set<FieldID>               fields;
    public:
      // Provenance string for the runtime and tools to use
      std::string                     provenance;
    public:
      // Inform the runtime about any static dependences
      // These will be ignored outside of static traces
      const std::vector<StaticDependence> *static_dependences;
    public:
      bool                            silence_warnings;
    };
 
    struct AttachLauncher {
    public:
      AttachLauncher(ExternalResource resource, 
                     LogicalRegion handle, LogicalRegion parent,
                     const bool restricted = true,
                     const bool mapped = true);
      // Declared here to avoid superfluous compiler warnings
      // Can be remove after deprecated members are removed
      ~AttachLauncher(void);
    public:
      inline void initialize_constraints(bool column_major, bool soa,
                             const std::vector<FieldID> &fields,
                             const std::map<FieldID,size_t> *alignments = NULL);
      LEGION_DEPRECATED("Use Realm::ExternalFileResource instead")
      inline void attach_file(const char *file_name,
                              const std::vector<FieldID> &fields,
                              LegionFileMode mode);
      LEGION_DEPRECATED("Use Realm::ExternalHDF5Resource instead")
      inline void attach_hdf5(const char *file_name,
                              const std::map<FieldID,const char*> &field_map,
                              LegionFileMode mode);
      // Helper methods for AOS and SOA arrays, but it is totally 
      // acceptable to fill in the layout constraint set manually
      LEGION_DEPRECATED("Use Realm::ExternalMemoryResource instead")
      inline void attach_array_aos(void *base, bool column_major,
                             const std::vector<FieldID> &fields,
                             Memory memory = Memory::NO_MEMORY,
                             const std::map<FieldID,size_t> *alignments = NULL);
      LEGION_DEPRECATED("Use Realm::ExternalMemoryResource instead")
      inline void attach_array_soa(void *base, bool column_major,
                             const std::vector<FieldID> &fields,
                             Memory memory = Memory::NO_MEMORY,
                             const std::map<FieldID,size_t> *alignments = NULL); 
    public:
      ExternalResource                              resource;
      LogicalRegion                                 parent;
      LogicalRegion                                 handle;
      std::set<FieldID>                             privilege_fields;
    public:
      // This will be cloned each time you perform an attach with this launcher
      const Realm::ExternalInstanceResource*        external_resource;
    public:
      LayoutConstraintSet                           constraints;
    public:
      // Whether this instance will be restricted when attached
      bool                                          restricted /*= true*/;
      // Whether this region should be mapped by the calling task
      bool                                          mapped; /*= true*/
      // Only matters for control replicated parent tasks 
      // Indicate whether all the shards are providing the same data
      // or whether they are each providing different data
      // Collective means that each shard provides its own copy of the
      // data and non-collective means every shard provides the same data
      // Defaults to 'true' for external instances and 'false' for files
      bool                                          collective;
      // For collective cases, indicate whether the runtime should 
      // deduplicate data across shards in the same process
      // This is useful for cases where there is one file or external
      // instance per process but multiple shards per process
      bool                                          deduplicate_across_shards;
    public:
      // Provenance string for the runtime and tools to use
      std::string                                   provenance;
    public:
      // Data for files
      LEGION_DEPRECATED("file_name is deprecated, use external_resource")
      const char                                    *file_name;
      LEGION_DEPRECATED("mode is deprecated, use external_resource")
      LegionFileMode                                mode;
      LEGION_DEPRECATED("file_fields is deprecated, use external_resource")
      std::vector<FieldID>                          file_fields; // normal files
      // This member must still be populated if you're attaching to an HDF5 file
      std::map<FieldID,/*file name*/const char*>    field_files; // hdf5 files 
    public:
      // Optional footprint of the instance in memory in bytes
      size_t                                        footprint;
    public:
      // Inform the runtime about any static dependences
      // These will be ignored outside of static traces
      const std::vector<StaticDependence>           *static_dependences;
    };
 
    struct IndexAttachLauncher {
    public:
      IndexAttachLauncher(ExternalResource resource, 
                          LogicalRegion parent,
                          const bool restricted = true);
      // Declared here to avoid superfluous compiler warnings
      // Can be remove after deprecated members are removed
      ~IndexAttachLauncher(void);
    public:
      inline void initialize_constraints(bool column_major, bool soa,
                             const std::vector<FieldID> &fields,
                             const std::map<FieldID,size_t> *alignments = NULL);
      inline void add_external_resource(LogicalRegion handle,
                              const Realm::ExternalInstanceResource *resource);
      LEGION_DEPRECATED("Use Realm::ExternalFileResource instead")
      inline void attach_file(LogicalRegion handle,
                              const char *file_name,
                              const std::vector<FieldID> &fields,
                              LegionFileMode mode);
      LEGION_DEPRECATED("Use Realm::ExternalHDF5Resource instead")
      inline void attach_hdf5(LogicalRegion handle,
                              const char *file_name,
                              const std::map<FieldID,const char*> &field_map,
                              LegionFileMode mode);
      // Helper methods for AOS and SOA arrays, but it is totally 
      // acceptable to fill in the layout constraint set manually
      LEGION_DEPRECATED("Use Realm::ExternalMemoryResource instead")
      inline void attach_array_aos(LogicalRegion handle, 
                             void *base, bool column_major,
                             const std::vector<FieldID> &fields,
                             Memory memory = Memory::NO_MEMORY,
                             const std::map<FieldID,size_t> *alignments = NULL);
      LEGION_DEPRECATED("Use Realm::ExternalMemoryResource instead")
      inline void attach_array_soa(LogicalRegion handle,
                             void *base, bool column_major,
                             const std::vector<FieldID> &fields,
                             Memory memory = Memory::NO_MEMORY,
                             const std::map<FieldID,size_t> *alignments = NULL);
    public:
      ExternalResource                              resource;
      LogicalRegion                                 parent;
      std::set<FieldID>                             privilege_fields;
      std::vector<LogicalRegion>                    handles;
      // This is the vector external resource objects that are going to 
      // attached to the vector of logical region handles
      // These will be cloned each time you perform an attach with this launcher
      std::vector<const Realm::ExternalInstanceResource*> external_resources;
    public:
      LayoutConstraintSet                           constraints;
    public:
      // Whether these instances will be restricted when attached
      bool                                          restricted /*= true*/;
      // Whether the runtime should check for duplicate resources across 
      // the shards in a control replicated context, it is illegal to pass
      // in the same resource to different shards if this is set to false
      bool                                          deduplicate_across_shards;
    public:
      // Provenance string for the runtime and tools to use
      std::string                                   provenance;
    public:
      // Data for files
      LEGION_DEPRECATED("mode is deprecated, use external_resources")
      LegionFileMode                                mode;
      LEGION_DEPRECATED("file_names is deprecated, use external_resources")
      std::vector<const char*>                      file_names;
      LEGION_DEPRECATED("file_fields is deprecated, use external_resources")
      std::vector<FieldID>                          file_fields; // normal files
      // This data structure must still be filled in for using HDF5 files
      std::map<FieldID,
        std::vector</*file name*/const char*> >     field_files; // hdf5 files
    public:
      // Data for external instances
      LEGION_DEPRECATED("pointers is deprecated, use external_resources")
      std::vector<PointerConstraint>                pointers;  
    public:
      // Optional footprint of the instance in memory in bytes
      // You only need to fill this in when using depcreated fields
      std::vector<size_t>                           footprint;
    public:
      // Inform the runtime about any static dependences
      // These will be ignored outside of static traces
      const std::vector<StaticDependence>           *static_dependences;
    };
 
    struct PredicateLauncher {
    public:
      explicit PredicateLauncher(bool and_op = true);
    public:
      inline void add_predicate(const Predicate &pred); 
    public:
      bool                            and_op; // if not 'and' then 'or'
      std::vector<Predicate>          predicates;
      std::string                     provenance;
    };
 
    struct TimingLauncher {
    public:
      TimingLauncher(TimingMeasurement measurement);
    public:
      inline void add_precondition(const Future &f);
    public:
      TimingMeasurement               measurement;
      std::set<Future>                preconditions;
    public:
      // Provenance string for the runtime and tools to use
      std::string                     provenance;
    };
 
    struct TunableLauncher {
    public:
      TunableLauncher(TunableID tid,
                      MapperID mapper = 0,
                      MappingTagID tag = 0,
                      size_t return_type_size = SIZE_MAX);
    public:
      TunableID                           tunable;
      MapperID                            mapper;
      MappingTagID                        tag;
      UntypedBuffer                       arg;
      std::vector<Future>                 futures;
      size_t                              return_type_size;
    public:
      // Provenance string for the runtime and tools to use
      std::string                        provenance;
    };
 
    //==========================================================================
    //                          Task Variant Registrars 
    //==========================================================================
 
    struct LayoutConstraintRegistrar {
    public:
      LayoutConstraintRegistrar(void);
      LayoutConstraintRegistrar(FieldSpace handle, 
                                 const char *layout_name = NULL);
    public:
      inline LayoutConstraintRegistrar&
        add_constraint(const SpecializedConstraint &constraint);
      inline LayoutConstraintRegistrar&
        add_constraint(const MemoryConstraint &constraint);
      inline LayoutConstraintRegistrar&
        add_constraint(const OrderingConstraint &constraint);
      inline LayoutConstraintRegistrar&
        add_constraint(const TilingConstraint &constraint);
      inline LayoutConstraintRegistrar&
        add_constraint(const FieldConstraint &constraint);
      inline LayoutConstraintRegistrar&
        add_constraint(const DimensionConstraint &constraint);
      inline LayoutConstraintRegistrar&
        add_constraint(const AlignmentConstraint &constraint);
      inline LayoutConstraintRegistrar&
        add_constraint(const OffsetConstraint &constraint);
      inline LayoutConstraintRegistrar&
        add_constraint(const PointerConstraint &constraint); 
      inline LayoutConstraintRegistrar&
        add_constraint(const PaddingConstraint &constraint);
    public:
      FieldSpace                                handle;
      LayoutConstraintSet                       layout_constraints;
      const char*                               layout_name;
    };
 
    struct PoolBounds {
    public:
      PoolBounds(UnboundPoolScope u, size_t s = 0)
        : size(s), alignment(0), scope(u) { }
      PoolBounds(size_t s = 0, uint32_t a = 16)
        : size(s), alignment(a), scope(LEGION_BOUNDED_POOL) { }
      PoolBounds(const PoolBounds&) = default;
      PoolBounds(PoolBounds&&) = default;
      PoolBounds& operator=(const PoolBounds&) = default;
      PoolBounds& operator=(PoolBounds&&) = default;
      inline bool is_bounded(void) const
        { return (scope == LEGION_BOUNDED_POOL); }
    public:
      // If this is a bounded pool then size is the number of bytes in the pool 
      // If it is an unbounded pool then size is how many free bytes the pool 
      // is allowed to keep locally from freed instances without returning
      // them back to the Realm allocator, zero means that all freed instances
      // are immediately sent back to the Realm allocator
      size_t size; // upper bound of the pool in bytes
      uint32_t alignment; // maximum alignment supported
      UnboundPoolScope scope; // scope for unbound pools
    };
 
    struct TaskVariantRegistrar {
    public:
      TaskVariantRegistrar(void);
      TaskVariantRegistrar(TaskID task_id, bool global = true,
                           const char *variant_name = NULL);
      TaskVariantRegistrar(TaskID task_id, const char *variant_name,
               bool global = true);
    public: // Add execution constraints
      inline TaskVariantRegistrar& 
        add_constraint(const ISAConstraint &constraint);
      inline TaskVariantRegistrar&
        add_constraint(const ProcessorConstraint &constraint);
      inline TaskVariantRegistrar& 
        add_constraint(const ResourceConstraint &constraint);
      inline TaskVariantRegistrar&
        add_constraint(const LaunchConstraint &constraint);
      inline TaskVariantRegistrar&
        add_constraint(const ColocationConstraint &constraint);
    public: // Add layout constraint sets
      inline TaskVariantRegistrar&
        add_layout_constraint_set(unsigned index, LayoutConstraintID desc);
    public: // Set properties
      inline void set_leaf(bool is_leaf = true);
      inline void set_inner(bool is_inner = true);
      inline void set_idempotent(bool is_idempotent = true);
      inline void set_replicable(bool is_replicable = true);
      inline void set_concurrent(bool is_concurrent = true);
      inline void set_concurrent_barrier(bool needs_barrier = true);
    public: // Generator Task IDs
      inline void add_generator_task(TaskID tid);
    public:
      TaskID                            task_id;
      bool                              global_registration;
      const char*                       task_variant_name;
    public: // constraints
      ExecutionConstraintSet            execution_constraints; 
      TaskLayoutConstraintSet           layout_constraints;
    public:
      // If this is a leaf task variant then the application can
      // request that the runtime preserve a pool in the memory of
      // the corresponding kind with the closest affinity to the target
      // processor for handling dynamic memory allocations during the
      // execution of the task. Pool bounds can also be set to request
      // an unbounded pool allocation. Note that requesting an unbound 
      // memory allocation will likely result in severe performance degradation.
      std::map<Memory::Kind,PoolBounds> leaf_pool_bounds;
    public:
      // TaskIDs for which this variant can serve as a generator
      std::set<TaskID>                  generator_tasks;
    public: // properties
      bool                              leaf_variant;
      bool                              inner_variant;
      bool                              idempotent_variant;
      bool                              replicable_variant;
      bool                              concurrent_variant;
      bool                              concurrent_barrier;
    };
 
    //==========================================================================
    //                          Physical Data Classes
    //==========================================================================
 
    class PhysicalRegion : public Unserializable<PhysicalRegion> {
    public:
      PhysicalRegion(void);
      PhysicalRegion(const PhysicalRegion &rhs);
      PhysicalRegion(PhysicalRegion &&rhs) noexcept;
      ~PhysicalRegion(void);
    private:
      Internal::PhysicalRegionImpl *impl;
    protected:
      FRIEND_ALL_RUNTIME_CLASSES
      explicit PhysicalRegion(Internal::PhysicalRegionImpl *impl);
    public:
      PhysicalRegion& operator=(const PhysicalRegion &rhs);
      PhysicalRegion& operator=(PhysicalRegion &&rhs) noexcept;
      inline bool exists(void) const { return (impl != NULL); }
      inline bool operator==(const PhysicalRegion &reg) const
        { return (impl == reg.impl); }
      inline bool operator<(const PhysicalRegion &reg) const
        { return (impl < reg.impl); }
      std::size_t hash(void) const;
    public:
      bool is_mapped(void) const;
      void wait_until_valid(bool silence_warnings = false,
                            const char *warning_string = NULL);
      bool is_valid(void) const;
      LogicalRegion get_logical_region(void) const;
      PrivilegeMode get_privilege(void) const;
      void get_memories(std::set<Memory>& memories,
                        bool silence_warnings = false,
                        const char *warning_string = NULL) const;
      void get_fields(std::vector<FieldID>& fields) const; 
    public:
      template<int DIM, typename COORD_T>
      DomainT<DIM,COORD_T> get_bounds(void) const;
      // We'll also allow this to implicitly cast to a realm index space
      // so that users can easily iterate over the points
      template<int DIM, typename COORD_T>
      operator DomainT<DIM,COORD_T>(void) const;
      // They can implicitly cast to a rectangle if there is no
      // sparsity map, runtime will check for this
      template<int DIM, typename COORD_T>
      operator Rect<DIM,COORD_T>(void) const;
    protected:
      // These methods can only be accessed by accessor classes
      template<PrivilegeMode, typename, int, typename, typename, bool>
      friend class FieldAccessor;
      template<typename, bool, int, typename, typename, bool>
      friend class ReductionAccessor;
      template<typename, int, typename, typename, bool, bool, int>
      friend class MultiRegionAccessor;
      template<typename, int, typename, typename, bool>
      friend class PaddingAccessor;
      template<typename, int, typename, typename>
      friend class UnsafeFieldAccessor;
      template<typename, PrivilegeMode>
      friend class ArraySyntax::AccessorRefHelper;
      template<typename>
      friend class ArraySyntax::AffineRefHelper;
      friend class PieceIterator;
      template<PrivilegeMode, typename, int, typename>
      friend class SpanIterator;
      template<typename, int, typename>
      friend class UnsafeSpanIterator;
      Realm::RegionInstance get_instance_info(PrivilegeMode mode, 
                                              FieldID fid, size_t field_size,
                                              void *realm_is, TypeTag type_tag,
                                              const char *warning_string,
                                              bool silence_warnings,
                                              bool generic_accessor,
                                              bool check_field_size,
                                              ReductionOpID redop = 0) const;
      Realm::RegionInstance get_instance_info(PrivilegeMode mode, 
                              const std::vector<PhysicalRegion> &other_regions,
                                              FieldID fid, size_t field_size,
                                              void *realm_is, TypeTag type_tag,
                                              const char *warning_string,
                                              bool silence_warnings,
                                              bool generic_accessor,
                                              bool check_field_size,
                                              bool need_bounds,
                                              ReductionOpID redop = 0) const;
      Realm::RegionInstance get_padding_info(FieldID fid, size_t field_size,
                                              Domain *inner, Domain &outer,
                                              const char *warning_string,
                                              bool silence_warnings,
                                              bool generic_accessor,
                                              bool check_field_size) const;
      void report_incompatible_accessor(const char *accessor_kind,
                             Realm::RegionInstance instance, FieldID fid) const;
      void report_incompatible_multi_accessor(unsigned index, FieldID fid,
                             Realm::RegionInstance inst1, 
                             Realm::RegionInstance inst2) const;
      void report_colocation_violation(const char *accessor_kind, FieldID fid,
                             Realm::RegionInstance inst1,
                             Realm::RegionInstance inst2,
                             const PhysicalRegion &other,
                             bool reduction = false) const;
      static void empty_colocation_regions(const char *accessor_kind, 
                                           FieldID fid, bool reduction = false);
      static void fail_bounds_check(DomainPoint p, FieldID fid,
                                    PrivilegeMode mode, bool multi = false);
      static void fail_bounds_check(Domain d, FieldID fid,
                                    PrivilegeMode mode, bool multi = false);
      static void fail_privilege_check(DomainPoint p, FieldID fid,
                                       PrivilegeMode mode);
      static void fail_privilege_check(Domain d, FieldID fid,
                                       PrivilegeMode mode); 
      static void fail_padding_check(DomainPoint p, FieldID fid);
    protected:
      void get_bounds(void *realm_is, TypeTag type_tag) const;
    }; 
 
    class ExternalResources : public Unserializable<ExternalResources> {
    public:
      ExternalResources(void);
      ExternalResources(const ExternalResources &rhs);
      ExternalResources(ExternalResources &&rhs) noexcept;
      ~ExternalResources(void);
    private:
      Internal::ExternalResourcesImpl *impl;
    protected:
      FRIEND_ALL_RUNTIME_CLASSES
      explicit ExternalResources(Internal::ExternalResourcesImpl *impl);
    public:
      ExternalResources& operator=(const ExternalResources &rhs);
      ExternalResources& operator=(ExternalResources &&rhs) noexcept;
      inline bool exists(void) const { return (impl != NULL); }
      inline bool operator==(const ExternalResources &reg) const
        { return (impl == reg.impl); }
      inline bool operator<(const ExternalResources &reg) const
        { return (impl < reg.impl); }
    public:
      size_t size(void) const;
      PhysicalRegion operator[](unsigned index) const;
    };
 
    template<PrivilegeMode MODE, typename FT, int N, typename COORD_T = coord_t,
             typename A = Realm::GenericAccessor<FT,N,COORD_T>,
#ifdef LEGION_BOUNDS_CHECKS
             bool CHECK_BOUNDS = true>
#else
             bool CHECK_BOUNDS = false>
#endif
    class FieldAccessor {
    private:
      static_assert(N > 0, "N must be positive");
      static_assert(std::is_integral<COORD_T>::value, "must be integral type");
    public:
      FieldAccessor(void) { }
      FieldAccessor(const PhysicalRegion &region, FieldID fid,
                    // The actual field size in case it is different from the 
                    // one being used in FT and we still want to check it
                    size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                    bool check_field_size = true,
#else
                    bool check_field_size = false,
#endif
                    bool silence_warnings = false,
                    const char *warning_string = NULL,
                    size_t subfield_offset = 0) { }
      // For Realm::AffineAccessor specializations there are additional
      // methods for creating accessors with limited bounding boxes and
      // affine transformations for using alternative coordinates spaces
      // Specify a specific bounds rectangle to use for the accessor
      FieldAccessor(const PhysicalRegion &region, FieldID fid,
                    const Rect<N,COORD_T> bounds,
                    // The actual field size in case it is different from the 
                    // one being used in FT and we still want to check it
                    size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                    bool check_field_size = true,
#else
                    bool check_field_size = false,
#endif
                    bool silence_warnings = false,
                    const char *warning_string = NULL,
                    size_t subfield_offset = 0) { }
      // Specify a specific Affine transform to use for interpreting points
      // Not avalable for Realm::MultiAffineAccessor specializations
      template<int M>
      FieldAccessor(const PhysicalRegion &region, FieldID fid,
                    const AffineTransform<M,N,COORD_T> transform,
                    // The actual field size in case it is different from the 
                    // one being used in FT and we still want to check it
                    size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                    bool check_field_size = true,
#else
                    bool check_field_size = false,
#endif
                    bool silence_warnings = false,
                    const char *warning_string = NULL,
                    size_t subfield_offset = 0) { }
      // Specify both a transform and a bounds to use
      // Not avalable for Realm::MultiAffineAccessor specializations
      template<int M>
      FieldAccessor(const PhysicalRegion &region, FieldID fid,
                    const AffineTransform<M,N,COORD_T> transform,
                    const Rect<N,COORD_T> bounds,
                    // The actual field size in case it is different from the 
                    // one being used in FT and we still want to check it
                    size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                    bool check_field_size = true,
#else
                    bool check_field_size = false,
#endif
                    bool silence_warnings = false,
                    const char *warning_string = NULL,
                    size_t subfield_offset = 0) { }
      // Create a field accessor for a Future 
      // (only with READ-ONLY privileges and AffineAccessors)
      FieldAccessor(const Future &future,
                    Memory::Kind kind = Memory::NO_MEMKIND,
                    // The actual field size in case it is different from the 
                    // one being used in FT and we still want to check it
                    size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                    bool check_field_size = true,
#else
                    bool check_field_size = false,
#endif
                    bool silence_warnings = false,
                    const char *warning_string = NULL,
                    size_t subfield_offset = 0) { }
      // Create a field accessor for a Future
      // (only with READ-ONLY privileges and AffineAccessors)
      FieldAccessor(const Future &future,
                    const Rect<N,COORD_T> bounds,
                    Memory::Kind kind = Memory::NO_MEMKIND,
                    // The actual field size in case it is different from the 
                    // one being used in FT and we still want to check it
                    size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                    bool check_field_size = true,
#else
                    bool check_field_size = false,
#endif
                    bool silence_warnings = false,
                    const char *warning_string = NULL,
                    size_t subfield_offset = 0) { }
    public:
      // Variations of the above four methods but with multiple physical
      // regions specified using input iterators for colocation regions
      // Colocation regions from [start, stop)
      template<typename InputIterator>
      FieldAccessor(InputIterator start_region, 
                    InputIterator stop_region, FieldID fid,
                    // The actual field size in case it is different from the 
                    // one being used in FT and we still want to check it
                    size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                    bool check_field_size = true,
#else
                    bool check_field_size = false,
#endif
                    bool silence_warnings = false,
                    const char *warning_string = NULL,
                    size_t subfield_offset = 0) { }
      // For Realm::AffineAccessor specializations there are additional
      // methods for creating accessors with limited bounding boxes and
      // affine transformations for using alternative coordinates spaces
      // Specify a specific bounds rectangle to use for the accessor
      // Colocation regions from [start, stop)
      template<typename InputIterator>
      FieldAccessor(InputIterator start_region,
                    InputIterator stop_region, FieldID fid,
                    const Rect<N,COORD_T> bounds,
                    // The actual field size in case it is different from the 
                    // one being used in FT and we still want to check it
                    size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                    bool check_field_size = true,
#else
                    bool check_field_size = false,
#endif
                    bool silence_warnings = false,
                    const char *warning_string = NULL,
                    size_t subfield_offset = 0) { }
      // Specify a specific Affine transform to use for interpreting points
      // Not avalable for Realm::MultiAffineAccessor specializations
      // Colocation regions from [start, stop)
      template<typename InputIterator, int M>
      FieldAccessor(InputIterator start_region,
                    InputIterator stop_region, FieldID fid,
                    const AffineTransform<M,N,COORD_T> transform,
                    // The actual field size in case it is different from the 
                    // one being used in FT and we still want to check it
                    size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                    bool check_field_size = true,
#else
                    bool check_field_size = false,
#endif
                    bool silence_warnings = false,
                    const char *warning_string = NULL,
                    size_t subfield_offset = 0) { }
      // Specify both a transform and a bounds to use
      // Not avalable for Realm::MultiAffineAccessor specializations
      // Colocation regions from [start, stop)
      template<typename InputIterator, int M>
      FieldAccessor(InputIterator start_region, 
                    InputIterator stop_region, FieldID fid,
                    const AffineTransform<M,N,COORD_T> transform,
                    const Rect<N,COORD_T> bounds,
                    // The actual field size in case it is different from the 
                    // one being used in FT and we still want to check it
                    size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                    bool check_field_size = true,
#else
                    bool check_field_size = false,
#endif
                    bool silence_warnings = false,
                    const char *warning_string = NULL,
                    size_t subfield_offset = 0) { }
    public:
      // Create a FieldAccessor for an UntypedDeferredValue
      // (only with AffineAccessors)
      FieldAccessor(const UntypedDeferredValue &value,
                    // The actual field size in case it is different from the 
                    // one being used in FT and we still want to check it
                    size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                    bool check_field_size = true,
#else
                    bool check_field_size = false,
#endif
                    bool silence_warnings = false,
                    const char *warning_string = NULL,
                    size_t subfield_offset = 0) { }
      // Create a FieldAccessor for an UntypedDeferredValue
      // Specify a specific bounds rectangle to use for the accessor
      // (only with AffineAccessors)
      FieldAccessor(const UntypedDeferredValue &value,
                    const Rect<N,COORD_T> &bounds,
                    // The actual field size in case it is different from the 
                    // one being used in FT and we still want to check it
                    size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                    bool check_field_size = true,
#else
                    bool check_field_size = false,
#endif
                    bool silence_warnings = false,
                    const char *warning_string = NULL,
                    size_t subfield_offset = 0) { }
    public:
      // Create a FieldAccessor for UntypedDeferredBuffer
      // (only with AffineAccessors)
      FieldAccessor(const UntypedDeferredBuffer<COORD_T> &buffer,
                    // The actual field size in case it is different from the 
                    // one being used in FT and we still want to check it
                    size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                    bool check_field_size = true,
#else
                    bool check_field_size = false,
#endif
                    bool silence_warnings = false,
                    const char *warning_string = NULL,
                    size_t subfield_offset = 0) { }
      // Create a FieldAccessor for UntypedDeferredBuffer
      // Specify a specific bounds rectangle to use for the accessor
      // (only with AffineAccessors)
      FieldAccessor(const UntypedDeferredBuffer<COORD_T> &buffer,
                    const Rect<N,COORD_T> &bounds,
                    // The actual field size in case it is different from the 
                    // one being used in FT and we still want to check it
                    size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                    bool check_field_size = true,
#else
                    bool check_field_size = false,
#endif
                    bool silence_warnings = false,
                    const char *warning_string = NULL,
                    size_t subfield_offset = 0) { }
      // Create a FieldAccessor for UntypedDeferredBuffer
      // Specify a specific Affine transform to use for interpreting points
      // (only with AffineAccessors)
      template<int M>
      FieldAccessor(const UntypedDeferredBuffer<COORD_T> &buffer,
                    const AffineTransform<M,N,COORD_T> &transform,
                    // The actual field size in case it is different from the 
                    // one being used in FT and we still want to check it
                    size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                    bool check_field_size = true,
#else
                    bool check_field_size = false,
#endif
                    bool silence_warnings = false,
                    const char *warning_string = NULL,
                    size_t subfield_offset = 0) { }
      // Create a FieldAccessor for UntypedDeferredBuffer
      // Specify both a transform and a bounds to use
      // (only with AffineAccessors)
      template<int M>
      FieldAccessor(const UntypedDeferredBuffer<COORD_T> &buffer,
                    const AffineTransform<M,N,COORD_T> &transform,
                    const Rect<N,COORD_T> &bounds,
                    // The actual field size in case it is different from the 
                    // one being used in FT and we still want to check it
                    size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                    bool check_field_size = true,
#else
                    bool check_field_size = false,
#endif
                    bool silence_warnings = false,
                    const char *warning_string = NULL,
                    size_t subfield_offset = 0) { }
    public:
      typedef FT value_type;
      typedef FT& reference;
      typedef const FT& const_reference;
      static const int dim = N;
    };
 
    template<typename REDOP, bool EXCLUSIVE, int N, typename COORD_T = coord_t,
             typename A = Realm::GenericAccessor<typename REDOP::RHS,N,COORD_T>,
#ifdef LEGION_BOUNDS_CHECKS
             bool CHECK_BOUNDS = true>
#else
             bool CHECK_BOUNDS = false>
#endif
    class ReductionAccessor {
    private:
      static_assert(N > 0, "N must be positive");
      static_assert(std::is_integral<COORD_T>::value, "must be integral type");
    public:
      ReductionAccessor(void) { }
      ReductionAccessor(const PhysicalRegion &region, FieldID fid,
                        ReductionOpID redop, bool silence_warnings = false,
                        const char *warning_string = NULL,
                        size_t subfield_offset = 0,
                        size_t actual_field_size = sizeof(typename REDOP::RHS),
#ifdef DEBUG_LEGION
                        bool check_field_size = true
#else
                        bool check_field_size = false
#endif
                       ) { }
      // For Realm::AffineAccessor specializations there are additional
      // methods for creating accessors with limited bounding boxes and
      // affine transformations for using alternative coordinates spaces
      // Specify a specific bounds rectangle to use for the accessor
      ReductionAccessor(const PhysicalRegion &region, FieldID fid,
                        ReductionOpID redop, 
                        const Rect<N,COORD_T> bounds,
                        bool silence_warnings = false,
                        const char *warning_string = NULL,
                        size_t subfield_offset = 0,
                        size_t actual_field_size = sizeof(typename REDOP::RHS),
#ifdef DEBUG_LEGION
                        bool check_field_size = true
#else
                        bool check_field_size = false
#endif
                       ) { }
      // Specify a specific Affine transform to use for interpreting points
      // Not available for Realm::MultiAffineAccessor specializations
      template<int M>
      ReductionAccessor(const PhysicalRegion &region, FieldID fid,
                        ReductionOpID redop,
                        const AffineTransform<M,N,COORD_T> transform,
                        bool silence_warnings = false,
                        const char *warning_string = NULL,
                        size_t subfield_offset = 0,
                        size_t actual_field_size = sizeof(typename REDOP::RHS),
#ifdef DEBUG_LEGION
                        bool check_field_size = true
#else
                        bool check_field_size = false
#endif
                       ) { }
      // Specify both a transform and a bounds to use
      // Not available for Realm::MultiAffineAccessor specializations
      template<int M>
      ReductionAccessor(const PhysicalRegion &region, FieldID fid,
                        ReductionOpID redop,
                        const AffineTransform<M,N,COORD_T> transform,
                        const Rect<N,COORD_T> bounds,
                        bool silence_warnings = false,
                        const char *warning_string = NULL,
                        size_t subfield_offset = 0,
                        size_t actual_field_size = sizeof(typename REDOP::RHS),
#ifdef DEBUG_LEGION
                        bool check_field_size = true
#else
                        bool check_field_size = false
#endif
                       ) { }
    public:
      // Variations of the same four methods above but with multiple 
      // physical regions specified using input iterators for colocation regions
      // Colocation regions from [start, stop)
      template<typename InputIterator>
      ReductionAccessor(InputIterator start_region,
                        InputIterator stop_region, FieldID fid,
                        ReductionOpID redop, bool silence_warnings = false,
                        const char *warning_string = NULL,
                        size_t subfield_offset = 0,
                        size_t actual_field_size = sizeof(typename REDOP::RHS),
#ifdef DEBUG_LEGION
                        bool check_field_size = true
#else
                        bool check_field_size = false
#endif
                       ) { }
      // For Realm::AffineAccessor specializations there are additional
      // methods for creating accessors with limited bounding boxes and
      // affine transformations for using alternative coordinates spaces
      // Specify a specific bounds rectangle to use for the accessor
      // Colocation regions from [start, stop)
      template<typename InputIterator>
      ReductionAccessor(InputIterator start_region,
                        InputIterator stop_region, FieldID fid,
                        ReductionOpID redop, 
                        const Rect<N,COORD_T> bounds,
                        bool silence_warnings = false,
                        const char *warning_string = NULL,
                        size_t subfield_offset = 0,
                        size_t actual_field_size = sizeof(typename REDOP::RHS),
#ifdef DEBUG_LEGION
                        bool check_field_size = true
#else
                        bool check_field_size = false
#endif
                       ) { }
      // Specify a specific Affine transform to use for interpreting points
      // Not available for Realm::MultiAffineAccessor specializations
      // Colocation regions from [start, stop)
      template<typename InputIterator, int M>
      ReductionAccessor(InputIterator start_region,
                        InputIterator stop_region, FieldID fid,
                        ReductionOpID redop,
                        const AffineTransform<M,N,COORD_T> transform,
                        bool silence_warnings = false,
                        const char *warning_string = NULL,
                        size_t subfield_offset = 0,
                        size_t actual_field_size = sizeof(typename REDOP::RHS),
#ifdef DEBUG_LEGION
                        bool check_field_size = true
#else
                        bool check_field_size = false
#endif
                       ) { }
      // Specify both a transform and a bounds to use
      // Not available for Realm::MultiAffineAccessor specializations
      // Colocation regions from [start, stop)
      template<typename InputIterator, int M>
      ReductionAccessor(InputIterator start_region,
                        InputIterator stop_region, FieldID fid,
                        ReductionOpID redop,
                        const AffineTransform<M,N,COORD_T> transform,
                        const Rect<N,COORD_T> bounds,
                        bool silence_warnings = false,
                        const char *warning_string = NULL,
                        size_t subfield_offset = 0,
                        size_t actual_field_size = sizeof(typename REDOP::RHS),
#ifdef DEBUG_LEGION
                        bool check_field_size = true
#else
                        bool check_field_size = false
#endif
                       ) { }
    public:
      // Create a ReductionAccessor for an UntypedDeferredValue
      // (only with AffineAccessors)
      ReductionAccessor(const UntypedDeferredValue &value,
                        bool silence_warnings = false,
                        const char *warning_string = NULL,
                        size_t subfield_offset = 0,
                        size_t actual_field_size = sizeof(typename REDOP::RHS),
#ifdef DEBUG_LEGION
                        bool check_field_size = true
#else
                        bool check_field_size = false
#endif
                       ) { }
      // Create a ReductionAccessor for an UntypedDeferredValue
      // Specify a specific bounds rectangle to use for the accessor
      // (only with AffineAccessors)
      ReductionAccessor(const UntypedDeferredValue &value,
                        const Rect<N,COORD_T> &bounds,
                        bool silence_warnings = false,
                        const char *warning_string = NULL,
                        size_t subfield_offset = 0,
                        size_t actual_field_size = sizeof(typename REDOP::RHS),
#ifdef DEBUG_LEGION
                        bool check_field_size = true
#else
                        bool check_field_size = false
#endif
                       ) { }
    public:
      // Create a ReductionAccessor for an UntypedDeferredBuffer
      // (only with AffineAccessors)
      ReductionAccessor(const UntypedDeferredBuffer<COORD_T> &buffer,
                        bool silence_warnings = false,
                        const char *warning_string = NULL,
                        size_t subfield_offset = 0,
                        size_t actual_field_size = sizeof(typename REDOP::RHS),
#ifdef DEBUG_LEGION
                        bool check_field_size = true
#else
                        bool check_field_size = false
#endif
                       ) { }
      // Create a ReductionAccessor for an UntypedDeferredBuffer
      // Specify a specific bounds rectangle to use for the accessor
      // (only with AffineAccessors)
      ReductionAccessor(const UntypedDeferredBuffer<COORD_T> &buffer,
                        const Rect<N,COORD_T> &bounds,
                        bool silence_warnings = false,
                        const char *warning_string = NULL,
                        size_t subfield_offset = 0,
                        size_t actual_field_size = sizeof(typename REDOP::RHS),
#ifdef DEBUG_LEGION
                        bool check_field_size = true
#else
                        bool check_field_size = false
#endif
                       ) { }
      // Create a ReductionAccessor for an UntypedDeferredBuffer
      // Specify a specific Affine transform to use for interpreting points
      // (only with AffineAccessors)
      template<int M>
      ReductionAccessor(const UntypedDeferredBuffer<COORD_T> &buffer,
                        const AffineTransform<M,N,COORD_T> &transform, 
                        bool silence_warnings = false,
                        const char *warning_string = NULL,
                        size_t subfield_offset = 0,
                        size_t actual_field_size = sizeof(typename REDOP::RHS),
#ifdef DEBUG_LEGION
                        bool check_field_size = true
#else
                        bool check_field_size = false
#endif
                       ) { }
      // Create a ReductionAccessor for an UntypedDeferredBuffer
      // Specify both a transform and a bounds to use
      // (only with AffineAccessors)
      template<int M>
      ReductionAccessor(const UntypedDeferredBuffer<COORD_T> &buffer,
                        const AffineTransform<M,N,COORD_T> &transform, 
                        const Rect<N,COORD_T> &bounds,
                        bool silence_warnings = false,
                        const char *warning_string = NULL,
                        size_t subfield_offset = 0,
                        size_t actual_field_size = sizeof(typename REDOP::RHS),
#ifdef DEBUG_LEGION
                        bool check_field_size = true
#else
                        bool check_field_size = false
#endif
                       ) { }
    public:
      typedef typename REDOP::RHS value_type;
      typedef typename REDOP::RHS& reference;
      typedef const typename REDOP::RHS& const_reference;
      static const int dim = N;
    };
 
    template<typename FT, int N, typename COORD_T = coord_t,
             typename A = Realm::GenericAccessor<FT,N,COORD_T>,
#ifdef LEGION_BOUNDS_CHECKS
             bool CHECK_BOUNDS = true>
#else
             bool CHECK_BOUNDS = false>
#endif
    class PaddingAccessor {
    public:
      PaddingAccessor(void) { }
      PaddingAccessor(const PhysicalRegion &region, FieldID fid,
                      // The actual field size in case it is different from the
                      // one being used in FT and we still want to check it
                      size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                      bool check_field_size = true,
#else
                      bool check_field_size = false,
#endif
                      bool silence_warnings = false,
                      const char *warning_string = NULL,
                      size_t subfield_offset = 0) { }
    };
 
#ifdef LEGION_MULTI_REGION_ACCESSOR
    // Multi-Region Accessors are a provisional feature now and are likely
    // to be deprecated and removed in the near future. Instead of multi-region
    // accessors you should be able to use the new colocation constructors
    // on the traditional Field Accessors.
    template<typename FT, int N, typename COORD_T = coord_t,
             typename A = Realm::GenericAccessor<FT,N,COORD_T>,
#ifdef LEGION_BOUNDS_CHECKS
             bool CHECK_BOUNDS = true,
#else
             bool CHECK_BOUNDS = false,
#endif
#ifdef LEGION_PRIVILEGE_CHECKS
             bool CHECK_PRIVILEGES = true,
#else
             bool CHECK_PRIVILEGES = false,
#endif
             // Only used if bounds/privilege checks enabled
             // Can safely over-approximate, but may cost space
             // Especially GPU parameter space
             int MAX_REGIONS = 4>
    class MultiRegionAccessor {
    private:
      static_assert(N > 0, "N must be positive");
      static_assert(std::is_integral<COORD_T>::value, "must be integral type");
    public:
      MultiRegionAccessor(void) { }
    public: // iterator based construction of the multi-region accessors
      template<typename InputIterator>
      MultiRegionAccessor(InputIterator start, InputIterator stop,
                          // The actual field size in case it is different from 
                          // the one being used in FT and we still want to check
                          FieldID fid, size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                          bool check_field_size = true,
#else
                          bool check_field_size = false,
#endif
                          bool silence_warnings = false,
                          const char *warning_string = NULL,
                          size_t subfield_offset = 0) { }
      // Specify a specific bounds rectangle to use for the accessor
      template<typename InputIterator>
      MultiRegionAccessor(InputIterator start, InputIterator stop,
                          const Rect<N,COORD_T> bounds, FieldID fid,
                          // The actual field size in case it is different from 
                          // the one being used in FT and we still want to check
                          size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                          bool check_field_size = true,
#else
                          bool check_field_size = false,
#endif
                          bool silence_warnings = false,
                          const char *warning_string = NULL,
                          size_t subfield_offset = 0) { }
      // Specify a specific Affine transform to use for interpreting points
      template<int M, typename InputIterator>
      MultiRegionAccessor(InputIterator start, InputIterator stop,
                          const AffineTransform<M,N,COORD_T> transform,
                          // The actual field size in case it is different from 
                          // the one being used in FT and we still want to check
                          FieldID fid, size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                          bool check_field_size = true,
#else
                          bool check_field_size = false,
#endif
                          bool silence_warnings = false,
                          const char *warning_string = NULL,
                          size_t subfield_offset = 0) { }
      // Specify both a transform and a bounds to use
      template<int M, typename InputIterator>
      MultiRegionAccessor(InputIterator start, InputIterator stop,
                          const AffineTransform<M,N,COORD_T> transform,
                          const Rect<N,COORD_T> bounds, FieldID fid, 
                          // The actual field size in case it is different from the
                          // one being used in FT and we still want to check it
                          size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                          bool check_field_size = true,
#else
                          bool check_field_size = false,
#endif
                          bool silence_warnings = false,
                          const char *warning_string = NULL,
                          size_t subfield_offset = 0) { }
    public: // explicit data structure versions of the implicit iterators above
      MultiRegionAccessor(const std::vector<PhysicalRegion> &regions,
                          // The actual field size in case it is different from 
                          // the one being used in FT and we still want to check
                          FieldID fid, size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                          bool check_field_size = true,
#else
                          bool check_field_size = false,
#endif
                          bool silence_warnings = false,
                          const char *warning_string = NULL,
                          size_t subfield_offset = 0) { }
      // Specify a specific bounds rectangle to use for the accessor
      MultiRegionAccessor(const std::vector<PhysicalRegion> &regions,
                          const Rect<N,COORD_T> bounds, FieldID fid,
                          // The actual field size in case it is different from 
                          // the one being used in FT and we still want to check
                          size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                          bool check_field_size = true,
#else
                          bool check_field_size = false,
#endif
                          bool silence_warnings = false,
                          const char *warning_string = NULL,
                          size_t subfield_offset = 0) { }
      // Specify a specific Affine transform to use for interpreting points
      template<int M>
      MultiRegionAccessor(const std::vector<PhysicalRegion> &regions,
                          const AffineTransform<M,N,COORD_T> transform,
                          // The actual field size in case it is different from 
                          // the one being used in FT and we still want to check
                          FieldID fid, size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                          bool check_field_size = true,
#else
                          bool check_field_size = false,
#endif
                          bool silence_warnings = false,
                          const char *warning_string = NULL,
                          size_t subfield_offset = 0) { }
      // Specify both a transform and a bounds to use
      template<int M>
      MultiRegionAccessor(const std::vector<PhysicalRegion> &regions,
                          const AffineTransform<M,N,COORD_T> transform,
                          const Rect<N,COORD_T> bounds, FieldID fid, 
                          // The actual field size in case it is different from the
                          // one being used in FT and we still want to check it
                          size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                          bool check_field_size = true,
#else
                          bool check_field_size = false,
#endif
                          bool silence_warnings = false,
                          const char *warning_string = NULL,
                          size_t subfield_offset = 0) { }
    public:
      typedef FT value_type;
      typedef FT& reference;
      typedef const FT& const_reference;
      static const int dim = N;
    };
#endif // LEGION_MULTI_REGION_ACCESSOR
 
    class PieceIterator {
    public:
      PieceIterator(void);
      PieceIterator(const PieceIterator &rhs);
      PieceIterator(PieceIterator &&rhs) noexcept;
      PieceIterator(const PhysicalRegion &region, FieldID fid,
                    bool privilege_only = true,
                    bool silence_warnings = false,
                    const char *warning_string = NULL);
      ~PieceIterator(void);
    public:
      PieceIterator& operator=(const PieceIterator &rhs);
      PieceIterator& operator=(PieceIterator &&rhs) noexcept;
    public:
      inline bool valid(void) const;
      bool step(void);
    public:
      inline operator bool(void) const;
      inline bool operator()(void) const;
      inline const Domain& operator*(void) const;
      inline const Domain* operator->(void) const;
      inline PieceIterator& operator++(void);
      inline PieceIterator operator++(int/*postfix*/);
    public:
      bool operator<(const PieceIterator &rhs) const;
      bool operator==(const PieceIterator &rhs) const;
      bool operator!=(const PieceIterator &rhs) const;
    private:
      Internal::PieceIteratorImpl *impl;
      int index;
    protected:
      Domain current_piece;
    };
 
    template<int DIM, typename COORD_T = coord_t>
    class PieceIteratorT : public PieceIterator {
    private:
      static_assert(DIM > 0, "DIM must be positive");
      static_assert(std::is_integral<COORD_T>::value, "must be integral type");
    public:
      PieceIteratorT(void);
      PieceIteratorT(const PieceIteratorT &rhs);
      PieceIteratorT(PieceIteratorT &&rhs) noexcept;
      PieceIteratorT(const PhysicalRegion &region, FieldID fid,
                     bool privilege_only,
                     bool silence_warnings = false,
                     const char *warning_string = NULL);
    public:
      PieceIteratorT<DIM,COORD_T>& operator=(const PieceIteratorT &rhs);
      PieceIteratorT<DIM,COORD_T>& operator=(PieceIteratorT &&rhs) noexcept;
    public:
      inline bool step(void);
      inline const Rect<DIM,COORD_T>& operator*(void) const;
      inline const Rect<DIM,COORD_T>* operator->(void) const;
      inline PieceIteratorT<DIM,COORD_T>& operator++(void);
      inline PieceIteratorT<DIM,COORD_T> operator++(int/*postfix*/);
    protected:
      Rect<DIM,COORD_T> current_rect;
    };
 
    template<PrivilegeMode PM, typename FT, int DIM, typename COORD_T = coord_t>
    class SpanIterator {
    private:
      static_assert(DIM > 0, "DIM must be positive");
      static_assert(std::is_integral<COORD_T>::value, "must be integral type");
    public:
      SpanIterator(void) { }
      SpanIterator(const PhysicalRegion &region, FieldID fid,
                   // The actual field size in case it is different from the 
                   // one being used in FT and we still want to check it
                   size_t actual_field_size = sizeof(FT),
#ifdef DEBUG_LEGION
                   bool check_field_size = true,
#else
                   bool check_field_size = false,
#endif
                   // Iterate only the spans that we have privileges on
                   bool privileges_only = true,
                   bool silence_warnings = false,
                   const char *warning_string = NULL);
    public:
      inline bool valid(void) const;
      inline bool step(void);
    public:
      inline operator bool(void) const;
      inline bool operator()(void) const;
      inline const Span<FT,PM>& operator*(void) const;
      inline const Span<FT,PM>* operator->(void) const;
      inline SpanIterator<PM,FT,DIM,COORD_T>& operator++(void);
      inline SpanIterator<PM,FT,DIM,COORD_T> operator++(int);
    private:
      PieceIteratorT<DIM,COORD_T> piece_iterator;
      Realm::MultiAffineAccessor<FT,DIM,COORD_T> accessor;
      Span<FT,PM> current;
      Point<DIM,COORD_T> partial_step_point;
      int dim_order[DIM];
      int partial_step_dim;
      bool partial_piece;
    };
 
    class UntypedDeferredValue {
    public:
      UntypedDeferredValue(void);
      UntypedDeferredValue(size_t field_size, Memory target_memory,
                           const void *initial_value = NULL,
                           size_t alignment = 16);
      UntypedDeferredValue(size_t field_size,
                           Memory::Kind memory_kind = Memory::Z_COPY_MEM,
                           const void *initial_value = NULL,
                           size_t alignment = 16);
      UntypedDeferredValue(const UntypedDeferredValue &rhs);
    public:
      template<typename T>
      inline operator DeferredValue<T>(void) const;
      template<typename REDOP, bool EXCLUSIVE>
      inline operator DeferredReduction<REDOP,EXCLUSIVE>(void) const;
      inline size_t field_size(void) const;
    public:
      void finalize(Context ctx) const;
      Realm::RegionInstance get_instance(void) const;
    protected:
      Realm::RegionInstance instance;
    protected:
      // Helper methods for DeferredValues and DeferredBuffers
      static Memory get_memory_from_kind(Memory::Kind kind, bool value);
      static Realm::RegionInstance allocate_instance(Memory memory,
          Realm::InstanceLayoutGeneric *layout);
      static void destroy_instance(Realm::RegionInstance,
          Realm::Event precondition);
      static Domain get_index_space_bounds(IndexSpace space);
      template<PrivilegeMode,typename,int,typename,typename,bool>
      friend class FieldAccessor;
      template<typename,bool,int,typename,typename,bool>
      friend class ReductionAccessor;
      template<typename>
      friend class UntypedDeferredBuffer;
      template<typename,int,typename,bool>
      friend class DeferredBuffer;
    };
 
    template<typename T>
    class DeferredValue : public UntypedDeferredValue {
    public:
      DeferredValue(T initial_value,
                    size_t alignment = std::alignment_of<T>());
    public:
      __CUDA_HD__
      inline T read(void) const;
      __CUDA_HD__
      inline void write(T value) const;
      __CUDA_HD__
      inline T* ptr(void) const;
      __CUDA_HD__
      inline T& ref(void) const;
      __CUDA_HD__
      inline operator T(void) const;
      __CUDA_HD__
      inline DeferredValue<T>& operator=(T value);
    public:
      typedef T value_type;
      typedef T& reference;
      typedef const T& const_reference; 
    protected:
      friend class UntypedDeferredValue;
      DeferredValue(void);
      Realm::AffineAccessor<T,1,coord_t> accessor;
    };
 
    template<typename REDOP, bool EXCLUSIVE=false>
    class DeferredReduction: public DeferredValue<typename REDOP::RHS> {
    public:
      DeferredReduction(
          size_t alignment = std::alignment_of<typename REDOP::RHS>());
    public:
      __CUDA_HD__
      inline void reduce(typename REDOP::RHS val) const;
      __CUDA_HD__
      inline void operator<<=(typename REDOP::RHS val) const;
    public:
      typedef typename REDOP::RHS value_type;
      typedef typename REDOP::RHS& reference;
      typedef const typename REDOP::RHS& const_reference;
    }; 
 
    template<typename T, int DIM, typename COORD_T = coord_t, 
#ifdef LEGION_BOUNDS_CHECKS
             bool CHECK_BOUNDS = true>
#else
             bool CHECK_BOUNDS = false>
#endif
    class DeferredBuffer {
    private:
      static_assert(DIM > 0, "DIM must be positive");
      static_assert(std::is_integral<COORD_T>::value, "must be integral type");
    public:
      DeferredBuffer(void);
    public: // Constructors specifying a generic memory kind
      DeferredBuffer(Memory::Kind kind, 
                     const Domain &bounds,
                     const T *initial_value = NULL,
                     size_t alignment = std::alignment_of<T>(),
                     bool fortran_order_dims = false);
      DeferredBuffer(const Rect<DIM,COORD_T> &bounds, 
                     Memory::Kind kind,
                     const T *initial_value = NULL,
                     size_t alignment = std::alignment_of<T>(),
                     bool fortran_order_dims = false);
    public: // Constructors specifying a specific memory
      DeferredBuffer(Memory memory, 
                     const Domain &bounds,
                     const T *initial_value = NULL,
                     size_t alignment = std::alignment_of<T>(),
                     bool fortran_order_dims = false);
      DeferredBuffer(const Rect<DIM,COORD_T> &bounds, 
                     Memory memory,
                     const T *initial_value = NULL,
                     size_t alignment = std::alignment_of<T>(),
                     bool fortran_order_dims = false);
    public: // Constructors specifying a specific ordering
      DeferredBuffer(Memory::Kind kind,
                     const Domain &bounds,
                     std::array<DimensionKind,DIM> ordering,
                     const T *initial_value = NULL,
                     size_t alignment = std::alignment_of<T>());
      DeferredBuffer(const Rect<DIM,COORD_T> &bounds,
                     Memory::Kind kind,
                     std::array<DimensionKind,DIM> ordering,
                     const T *initial_value = NULL,
                     size_t alignment = std::alignment_of<T>());
      DeferredBuffer(Memory memory,
                     const Domain &bounds,
                     std::array<DimensionKind,DIM> ordering,
                     const T *initial_value = NULL,
                     size_t alignment = std::alignment_of<T>());
      DeferredBuffer(const Rect<DIM,COORD_T> &bounds,
                     Memory memory,
                     std::array<DimensionKind,DIM> ordering,
                     const T *initial_value = NULL,
                     size_t alignment = std::alignment_of<T>());
    protected:
      inline void initialize_layout(size_t alignment, bool fortran_order_dims);
      inline void initialize(Memory memory,
                             DomainT<DIM,COORD_T> bounds,
                      const T *initial_value);
    public:
      __CUDA_HD__
      inline T read(const Point<DIM,COORD_T> &p) const;
      __CUDA_HD__
      inline void write(const Point<DIM,COORD_T> &p, T value) const;
      __CUDA_HD__
      inline T* ptr(const Point<DIM,COORD_T> &p) const;
      __CUDA_HD__
      inline T* ptr(const Rect<DIM,COORD_T> &r) const; // must be dense
      __CUDA_HD__
      inline T* ptr(const Rect<DIM,COORD_T> &r, size_t strides[DIM]) const;
      __CUDA_HD__
      inline T& operator[](const Point<DIM,COORD_T> &p) const;
    public:
      inline void destroy(Realm::Event precondition = Realm::Event::NO_EVENT);
      __CUDA_HD__
      inline Realm::RegionInstance get_instance(void) const;
      __CUDA_HD__
      inline Rect<DIM,COORD_T> get_bounds(void) const;
    public:
      typedef T value_type;
      typedef T& reference;
      typedef const T& const_reference;
    protected:
      friend class OutputRegion;
      friend class UntypedDeferredBuffer<COORD_T>;
      Realm::RegionInstance instance;
      Realm::AffineAccessor<T,DIM,COORD_T> accessor;
      std::array<DimensionKind,DIM> ordering;
      Rect<DIM,COORD_T> bounds;
      size_t alignment;
    };
 
    template<typename COORD_T = coord_t>
    class UntypedDeferredBuffer {
    private:
      static_assert(std::is_integral<COORD_T>::value, "must be integral type");
    public:
      UntypedDeferredBuffer(void);
    public: // Constructors specifying a generic memory kind
      UntypedDeferredBuffer(size_t field_size, int dims,
                            Memory::Kind kind, 
                            const Domain &bounds,
                            const void *initial_value = NULL,
                            size_t alignment = 16,
                            bool fortran_order_dims = false);
      UntypedDeferredBuffer(size_t field_size, int dims,
                            Memory::Kind kind, 
                            IndexSpace bounds,
                            const void *initial_value = NULL,
                            size_t alignment = 16,
                            bool fortran_order_dims = false);
    public: // Constructors specifying a specific memory
      UntypedDeferredBuffer(size_t field_size, int dims,
                            Memory memory, 
                            const Domain &bounds,
                            const void *initial_value = NULL,
                            size_t alignment = 16,
                            bool fortran_order_dims = false);
      UntypedDeferredBuffer(size_t field_size, int dims,
                            Memory memory, 
                            IndexSpace bounds,
                            const void *initial_value = NULL,
                            size_t alignment = 16,
                            bool fortran_order_dims = false);
    public:
      template<typename T, int DIM>
      UntypedDeferredBuffer(const DeferredBuffer<T,DIM,COORD_T> &rhs);
    public:
      template<typename T, int DIM, bool BC>
      inline operator DeferredBuffer<T,DIM,COORD_T,BC>(void) const;
    public:
      inline void destroy(Realm::Event precondition = Realm::Event::NO_EVENT);
      inline Realm::RegionInstance get_instance(void) const { return instance; }
    private:
      template<PrivilegeMode,typename,int,typename,typename,bool>
      friend class FieldAccessor;
      template<typename,bool,int,typename,typename,bool>
      friend class ReductionAccessor;
      Realm::RegionInstance instance;
      size_t field_size;
      int dims; 
    };
 
    class OutputRegion : public Unserializable<OutputRegion> {
    public:
      OutputRegion(void);
      OutputRegion(const OutputRegion &rhs);
      ~OutputRegion(void);
    private:
      Internal::OutputRegionImpl *impl;
    protected:
      FRIEND_ALL_RUNTIME_CLASSES
      explicit OutputRegion(Internal::OutputRegionImpl *impl);
    public:
      OutputRegion& operator=(const OutputRegion &rhs);
    public:
      Memory target_memory(void) const;
      // Returns the logical region of this output region.
      // The call is legal only when the output region is valid and
      // will raise an error otherwise.
      LogicalRegion get_logical_region(void) const;
      bool is_valid_output_region(void) const;
    public:
      // Returns a deferred buffer that satisfies the layout constraints of
      // this output region. The caller still needs to pass this buffer to
      // a return_data call if the buffer needs to be bound to this output
      // region. The caller can optionally choose to bind the returned buffer
      // to the output region; such a call cannot be made more than once.
      template<typename T,
               int DIM,
               typename COORD_T = coord_t,
#ifdef LEGION_BOUNDS_CHECKS
               bool CHECK_BOUNDS = true>
#else
               bool CHECK_BOUNDS = false>
#endif
      DeferredBuffer<T,DIM,COORD_T,CHECK_BOUNDS>
      create_buffer(const Point<DIM, COORD_T> &extents,
                    FieldID field_id,
                    const T *initial_value = NULL,
                    bool return_buffer = false);
    private:
      void check_type_tag(TypeTag type_tag) const;
      void check_field_size(FieldID field_id, size_t field_size) const;
      void get_layout(FieldID field_id,
                      std::vector<DimensionKind> &ordering,
                      size_t &alignment) const;
    public:
      template<typename T,
               int DIM,
               typename COORD_T = coord_t,
#ifdef LEGION_BOUNDS_CHECKS
               bool CHECK_BOUNDS = true>
#else
               bool CHECK_BOUNDS = false>
#endif
      void return_data(const Point<DIM,COORD_T> &extents,
                       FieldID field_id,
                       DeferredBuffer<T,DIM,COORD_T,CHECK_BOUNDS> &buffer);
      void return_data(const DomainPoint &extents,
                       FieldID field_id,
                       Realm::RegionInstance instance,
                       bool check_constraints = true);
    private:
      void return_data(const DomainPoint &extents,
                       FieldID field_id,
                       Realm::RegionInstance instance,
                       const LayoutConstraintSet *constraints,
                       bool check_constraints);
    };
 
    //==========================================================================
    //                      Software Coherence Classes
    //==========================================================================
 
    struct AcquireLauncher {
    public:
      AcquireLauncher(LogicalRegion logical_region, 
                      LogicalRegion parent_region,
                      PhysicalRegion physical_region = PhysicalRegion(),
                      Predicate pred = Predicate::TRUE_PRED,
                      MapperID id = 0, MappingTagID tag = 0,
                      UntypedBuffer map_arg = UntypedBuffer(),
                      const char *provenance = "");
    public:
      inline void add_field(FieldID f);
      inline void add_grant(Grant g);
      inline void add_wait_barrier(PhaseBarrier pb);
      inline void add_arrival_barrier(PhaseBarrier pb);
      inline void add_wait_handshake(LegionHandshake handshake);
      inline void add_arrival_handshake(LegionHandshake handshake);
    public:
      LogicalRegion                   logical_region;
      LogicalRegion                   parent_region;
      std::set<FieldID>               fields;
    public:
      // This field is now optional (but required with control replication)
      PhysicalRegion                  physical_region;
    public:
      std::vector<Grant>              grants;
      std::vector<PhaseBarrier>       wait_barriers;
      std::vector<PhaseBarrier>       arrive_barriers;
      Predicate                       predicate;
      MapperID                        map_id;
      MappingTagID                    tag;
      UntypedBuffer                   map_arg;
    public:
      // Provenance string for the runtime and tools to use
      std::string                     provenance;
    public:
      // Inform the runtime about any static dependences
      // These will be ignored outside of static traces
      const std::vector<StaticDependence> *static_dependences;
    public:
      bool                            silence_warnings;
    };
 
    struct ReleaseLauncher {
    public:
      ReleaseLauncher(LogicalRegion logical_region, 
                      LogicalRegion parent_region,
                      PhysicalRegion physical_region = PhysicalRegion(),
                      Predicate pred = Predicate::TRUE_PRED,
                      MapperID id = 0, MappingTagID tag = 0,
                      UntypedBuffer map_arg = UntypedBuffer(),
                      const char *provenance = "");
    public:
      inline void add_field(FieldID f);
      inline void add_grant(Grant g);
      inline void add_wait_barrier(PhaseBarrier pb);
      inline void add_arrival_barrier(PhaseBarrier pb);
      inline void add_wait_handshake(LegionHandshake handshake);
      inline void add_arrival_handshake(LegionHandshake handshake);
    public:
      LogicalRegion                   logical_region;
      LogicalRegion                   parent_region;
      std::set<FieldID>               fields;
    public:
      // This field is now optional (but required with control replication)
      PhysicalRegion                  physical_region;
    public:
      std::vector<Grant>              grants;
      std::vector<PhaseBarrier>       wait_barriers;
      std::vector<PhaseBarrier>       arrive_barriers;
      Predicate                       predicate;
      MapperID                        map_id;
      MappingTagID                    tag;
      UntypedBuffer                   map_arg;
    public:
      // Provenance string for the runtime and tools to use
      std::string                     provenance;
    public:
      // Inform the runtime about any static dependences
      // These will be ignored outside of static traces
      const std::vector<StaticDependence> *static_dependences;
    public:
      bool                            silence_warnings;
    };
 
    //==========================================================================
    //                        Must Parallelism Classes
    //==========================================================================
    
    struct MustEpochLauncher {
    public:
      MustEpochLauncher(MapperID id = 0, MappingTagID tag = 0);
    public:
      inline void add_single_task(const DomainPoint &point,
                                  const TaskLauncher &launcher);
      inline void add_index_task(const IndexTaskLauncher &launcher);
    public:
      MapperID                       map_id;
      MappingTagID                   mapping_tag;
      std::vector<TaskLauncher>      single_tasks;
      std::vector<IndexTaskLauncher> index_tasks;
    public:
      Domain                         launch_domain;
      IndexSpace                     launch_space;
      // Will only be used in control replication context. If left
      // unset the runtime will use launch_space/launch_domain
      IndexSpace                     sharding_space;
    public:
      // Provenance string for the runtime and tools to use
      std::string                    provenance;
    public:
      bool                           silence_warnings;
    };
 
    //==========================================================================
    //                     Interoperability Classes
    //==========================================================================
 
    class LegionHandshake : public Unserializable<LegionHandshake> {
    public:
      LegionHandshake(void);
      LegionHandshake(const LegionHandshake &rhs);
      ~LegionHandshake(void);
    protected:
      Internal::LegionHandshakeImpl *impl;
    protected:
      // Only the runtime should be able to make these
      FRIEND_ALL_RUNTIME_CLASSES
      explicit LegionHandshake(Internal::LegionHandshakeImpl *impl);
    public:
      bool operator==(const LegionHandshake &h) const
        { return impl == h.impl; }
      bool operator<(const LegionHandshake &h) const
        { return impl < h.impl; }
      LegionHandshake& operator=(const LegionHandshake &rhs);
    public:
      void ext_handoff_to_legion(void) const;
      void ext_wait_on_legion(void) const;
    public:
      void legion_handoff_to_ext(void) const;
      void legion_wait_on_ext(void) const;
    public:
      /*
       * For asynchronous Legion execution, you can use these
       * methods to get a phase barrier associated with the 
       * handshake object instead of blocking on the legion side
       */
      PhaseBarrier get_legion_wait_phase_barrier(void) const;
      PhaseBarrier get_legion_arrive_phase_barrier(void) const;
      void advance_legion_handshake(void) const;
    };
 
    class MPILegionHandshake : public LegionHandshake {
    public:
      MPILegionHandshake(void);
      MPILegionHandshake(const MPILegionHandshake &rhs);
      ~MPILegionHandshake(void);
    protected:
      // Only the runtime should be able to make these
      FRIEND_ALL_RUNTIME_CLASSES
      explicit MPILegionHandshake(Internal::LegionHandshakeImpl *impl);
    public:
      bool operator==(const MPILegionHandshake &h) const
        { return impl == h.impl; }
      bool operator<(const MPILegionHandshake &h) const
        { return impl < h.impl; }
      MPILegionHandshake& operator=(const MPILegionHandshake &rhs);
    public:
      inline void mpi_handoff_to_legion(void) const { ext_handoff_to_legion(); }
      inline void mpi_wait_on_legion(void) const { ext_wait_on_legion(); }
    public:
      inline void legion_handoff_to_mpi(void) const { legion_handoff_to_ext(); }
      inline void legion_wait_on_mpi(void) const { legion_wait_on_ext(); }
    };
 
    //==========================================================================
    //                           Operation Classes
    //==========================================================================
 
    class Mappable {
    public:
      Mappable(void);
    public:
      // Return a globally unique ID for this operation
      virtual UniqueID get_unique_id(void) const = 0;
      // Return the number of operations that came before
      // this operation in the same context (close operations
      // return number of previous close operations)
      virtual uint64_t get_context_index(void) const = 0;
      // Return the depth of this operation in the task tree
      virtual int get_depth(void) const = 0;
      // Get the parent task associated with this mappable  
      virtual const Task* get_parent_task(void) const = 0;
      // Get the provenance string for this mappable
      // By default we return the human readable component but
      // you can also get the machine component as well
      virtual const std::string_view& get_provenance_string(
                                bool human = true) const = 0;
    public:
      virtual MappableType get_mappable_type(void) const = 0;
      virtual const Task* as_task(void) const { return NULL; }
      virtual const Copy* as_copy(void) const { return NULL; }
      virtual const InlineMapping* as_inline(void) const { return NULL; }
      virtual const Acquire* as_acquire(void) const { return NULL; }
      virtual const Release* as_release(void) const { return NULL; }
      virtual const Close* as_close(void) const { return NULL; }
      virtual const Fill* as_fill(void) const { return NULL; }
      virtual const Partition* as_partition(void) const { return NULL; }
      virtual const MustEpoch* as_must_epoch(void) const { return NULL; }
    public:
      MapperID                                  map_id;
      MappingTagID                              tag;
    public:
      // The 'parent_task' member is here for backwards compatibility
      // It's better to use the 'get_parent_task' method
      // as this may be NULL until that method is called
      mutable const Task*                       parent_task;
    public:
      // Mapper annotated data 
      void*                                     mapper_data;
      size_t                                    mapper_data_size;
    public:
      // These are here for backwards compatibility from a time when
      // the MappableType enum was inside of this class
#ifndef __GNUC__
      // GCC doesn't like this line even though it's just creating a
      // type alias, who knows what their problem is
      typedef Legion::MappableType MappableType;
#endif
      static const MappableType TASK_MAPPABLE = ::LEGION_TASK_MAPPABLE;
      static const MappableType COPY_MAPPABLE = ::LEGION_COPY_MAPPABLE;
      static const MappableType INLINE_MAPPABLE = ::LEGION_INLINE_MAPPABLE;
      static const MappableType ACQUIRE_MAPPABLE = ::LEGION_ACQUIRE_MAPPABLE;
      static const MappableType RELEASE_MAPPABLE = ::LEGION_RELEASE_MAPPABLE;
      static const MappableType CLOSE_MAPPABLE = ::LEGION_CLOSE_MAPPABLE;
      static const MappableType FILL_MAPPABLE = ::LEGION_FILL_MAPPABLE;
      static const MappableType PARTITION_MAPPABLE = 
                                        ::LEGION_PARTITION_MAPPABLE;
      static const MappableType MUST_EPOCH_MAPPABLE = 
                                        ::LEGION_MUST_EPOCH_MAPPABLE;
    };
 
    class Task : public Mappable {
    public:
      Task(void);
    public:
      // Check whether this task has a parent task.
      virtual bool has_parent_task(void) const = 0;
      // Return the name of the task.
      virtual const char* get_task_name(void) const = 0;
      // Returns the current slice of the index domain that this
      // task is operating over. This method will only return a
      // valid domain if this is part of an index space task.
      virtual Domain get_slice_domain(void) const = 0;
      //------------------------------------------------------------------------
      // Control Replication methods
      // In general SPMD-style programming in Legion is wrong. If you find
      // yourself writing SPMD-style code for large fractions of your program
      // then you're probably doing something wrong. There are a few exceptions:
      // 1. index attach/detach operations are collective and may need
      //    to do per-shard work
      // 2. I/O in general often needs to do per-shard work
      // 3. interaction with collective frameworks like MPI and NCCL
      // 4. others?
      // For these reasons we allow users to get access to sharding information
      // Please, please, please be careful with how you use it
      //------------------------------------------------------------------------
      virtual ShardID get_shard_id(void) const = 0;
      virtual size_t get_total_shards(void) const = 0;
      virtual DomainPoint get_shard_point(void) const = 0;
      virtual Domain get_shard_domain(void) const = 0;
    public:
      virtual MappableType get_mappable_type(void) const 
        { return LEGION_TASK_MAPPABLE; }
      virtual const Task* as_task(void) const { return this; }
    public:
      // Task argument information
      TaskID                              task_id; 
      std::vector<IndexSpaceRequirement>  indexes;
      std::vector<RegionRequirement>      regions;
      std::vector<OutputRequirement>      output_regions;
      std::vector<Future>                 futures;
      std::vector<Grant>                  grants;
      std::vector<PhaseBarrier>           wait_barriers;
      std::vector<PhaseBarrier>           arrive_barriers;
      void*                               args;                         
      size_t                              arglen;
    public:
      // Index task argument information
      bool                                is_index_space;
      bool                                concurrent_task;
      bool                                must_epoch_task; 
      Domain                              index_domain;
      DomainPoint                         index_point;
      IndexSpace                          sharding_space;
      void*                               local_args;
      size_t                              local_arglen;
    public:
      // Meta data information from the runtime
      Processor                           orig_proc;
      Processor                           current_proc;
      Processor                           target_proc;
      unsigned                            steal_count;
      bool                                stealable;
      bool                                speculated;
      bool                                local_function;
    };
 
    class Copy : public Mappable {
    public:
      Copy(void);
    public:
      virtual MappableType get_mappable_type(void) const 
        { return LEGION_COPY_MAPPABLE; }
      virtual const Copy* as_copy(void) const { return this; }
    public:
      // Copy Launcher arguments
      std::vector<RegionRequirement>    src_requirements;
      std::vector<RegionRequirement>    dst_requirements;
      std::vector<RegionRequirement>    src_indirect_requirements;
      std::vector<RegionRequirement>    dst_indirect_requirements;
      std::vector<Grant>                grants;
      std::vector<PhaseBarrier>         wait_barriers;
      std::vector<PhaseBarrier>         arrive_barriers;
    public:
      // Index copy argument information
      bool                              is_index_space;
      Domain                            index_domain;
      DomainPoint                       index_point;
      IndexSpace                        sharding_space;
    };
 
    class InlineMapping : public Mappable {
    public:
      InlineMapping(void);
    public:
      virtual MappableType get_mappable_type(void) const 
        { return LEGION_INLINE_MAPPABLE; }
      virtual const InlineMapping* as_inline(void) const { return this; }
      virtual ShardID get_parent_shard(void) const { return 0; }
    public:
      // Inline Launcher arguments
      RegionRequirement                 requirement;
      std::vector<Grant>                grants;
      std::vector<PhaseBarrier>         wait_barriers;
      std::vector<PhaseBarrier>         arrive_barriers;
      LayoutConstraintID                layout_constraint_id; 
    };
 
    class Acquire : public Mappable {
    public:
      Acquire(void);
    public:
      virtual MappableType get_mappable_type(void) const 
        { return LEGION_ACQUIRE_MAPPABLE; }
      virtual const Acquire* as_acquire(void) const { return this; }
    public:
      // Acquire Launcher arguments
      LogicalRegion                     logical_region;
      LogicalRegion                     parent_region;
      std::set<FieldID>                 fields;
      std::vector<Grant>                grants;
      std::vector<PhaseBarrier>         wait_barriers;
      std::vector<PhaseBarrier>         arrive_barriers;
    };
 
    class Release : public Mappable {
    public:
      Release(void);
    public:
      virtual MappableType get_mappable_type(void) const 
        { return LEGION_RELEASE_MAPPABLE; }
      virtual const Release* as_release(void) const { return this; }
    public:
      // Release Launcher arguments
      LogicalRegion                     logical_region;
      LogicalRegion                     parent_region;
      std::set<FieldID>                 fields;
      std::vector<Grant>                grants;
      std::vector<PhaseBarrier>         wait_barriers;
      std::vector<PhaseBarrier>         arrive_barriers;
    };
 
    class Close : public Mappable {
    public:
      Close(void);
    public:
      virtual MappableType get_mappable_type(void) const 
        { return LEGION_CLOSE_MAPPABLE; }
      virtual const Close* as_close(void) const { return this; }
    public:
      // Synthesized region requirement
      RegionRequirement                 requirement;
    };
 
    class Fill : public Mappable {
    public:
      Fill(void);
    public:
      virtual MappableType get_mappable_type(void) const 
        { return LEGION_FILL_MAPPABLE; }
      virtual const Fill* as_fill(void) const { return this; }
    public:
      // Synthesized region requirement
      RegionRequirement               requirement;
      std::vector<Grant>              grants;
      std::vector<PhaseBarrier>       wait_barriers;
      std::vector<PhaseBarrier>       arrive_barriers;
    public:
      // Index fill argument information
      bool                              is_index_space;
      Domain                            index_domain;
      DomainPoint                       index_point;
      IndexSpace                        sharding_space;
    };
 
    class Partition : public Mappable {
    public:
      Partition(void);
    public:
      virtual MappableType get_mappable_type(void) const 
        { return LEGION_PARTITION_MAPPABLE; }
      virtual const Partition* as_partition(void) const { return this; }
    public:
      enum PartitionKind {
        BY_FIELD, // create partition by field
        BY_IMAGE, // create partition by image
        BY_IMAGE_RANGE, // create partition by image range
        BY_PREIMAGE, // create partition by preimage
        BY_PREIMAGE_RANGE,  // create partition by preimage range
        BY_ASSOCIATION,  // create partition by association
      };
      virtual PartitionKind get_partition_kind(void) const = 0;
    public:
      // Synthesized region requirement
      RegionRequirement                   requirement;
    public:
      // Index partition argument information
      bool                                is_index_space;
      Domain                              index_domain;
      DomainPoint                         index_point;
    };
 
    class MustEpoch : public Mappable {
    public:
      MustEpoch(void);
    public:
      virtual MappableType get_mappable_type(void) const 
        { return LEGION_MUST_EPOCH_MAPPABLE; }
      virtual const MustEpoch* as_must_epoch(void) const { return this; }
    public:
      std::vector<const Task*>                  individual_tasks;
      std::vector<const Task*>                  index_space_tasks;
    public:
      // Index space of points for the must epoch operation
      Domain                                    launch_domain;
      IndexSpace                                sharding_space;
    };
 
    //==========================================================================
    //                           Runtime Classes
    //========================================================================== 
 
    struct InputArgs {
    public:
      char **argv;
      int argc;
    };
 
    struct RegistrationCallbackArgs {
      Machine machine;
      Runtime *runtime;
      std::set<Processor> local_procs;
      UntypedBuffer buffer;
    };
 
    struct TaskConfigOptions {
    public:
      TaskConfigOptions(bool leaf = false,
                        bool inner = false,
                        bool idempotent = false);
    public:
      bool leaf;
      bool inner;
      bool idempotent;
    };
 
    class ProjectionFunctor {
    public:
      ProjectionFunctor(void);
      ProjectionFunctor(Runtime *rt);
      virtual ~ProjectionFunctor(void);
    public:
      virtual LogicalRegion project(const Mappable *mappable, unsigned index,
                                    LogicalRegion upper_bound,
                                    const DomainPoint &point);
      virtual LogicalRegion project(const Mappable *mappable, unsigned index,
                                    LogicalPartition upper_bound,
                                    const DomainPoint &point);
 
      virtual LogicalRegion project(LogicalRegion upper_bound,
                                    const DomainPoint &point,
                                    const Domain &launch_domain);
 
      virtual LogicalRegion project(LogicalPartition upper_bound,
                                    const DomainPoint &point,
                                    const Domain &launch_domain);
 
      virtual LogicalRegion project(LogicalRegion upper_bound,
                                    const DomainPoint &point,
                                    const Domain &launch_domain,
                                    const void *args, size_t size);
 
      virtual LogicalRegion project(LogicalPartition upper_bound,
                                    const DomainPoint &point,
                                    const Domain &launch_domain,
                                    const void *args, size_t size);
 
      LEGION_DEPRECATED("The interface for projection functors has been "
                        "updated. Please use the new 'project' methods.")
      virtual LogicalRegion project(Context ctx, Task *task,
                                    unsigned index,
                                    LogicalRegion upper_bound,
                                    const DomainPoint &point);
      LEGION_DEPRECATED("The interface for projection functors has been "
                        "updated. Please use the new 'project' methods.")
      virtual LogicalRegion project(Context ctx, Task *task, 
                                    unsigned index,
                                    LogicalPartition upper_bound,
                                    const DomainPoint &point);
 
      virtual void invert(LogicalRegion region, LogicalRegion upper_bound,
                          const Domain &launch_domain,
                          std::vector<DomainPoint> &ordered_points);
      virtual void invert(LogicalRegion region, LogicalPartition upper_bound,
                          const Domain &launch_domain,
                          std::vector<DomainPoint> &ordered_points);
      
 
      virtual bool is_complete(LogicalRegion upper_bound, 
                               const Domain &launch_domain);
      virtual bool is_complete(LogicalPartition upper_bound,
                               const Domain &launch_domain);
      virtual bool is_complete(Mappable *mappable, unsigned index,
            LogicalRegion upper_bound, const Domain &launch_domain);
      virtual bool is_complete(Mappable *mappable, unsigned index,
            LogicalPartition upper_bound, const Domain &launch_domain); 
      
      virtual bool is_exclusive(void) const { return false; }
 
      /*
       * Indicate whether this is a functional projection
       * functor or whether it depends on the operation being
       * launched. This will determine which project method
       * is invoked by the runtime.
       */
      virtual bool is_functional(void) const { return false; }
 
      virtual bool is_invertible(void) const { return false; }
 
      virtual unsigned get_depth(void) const = 0;
    private:
      friend class Internal::Runtime;
      // For pre-registered projection functors the runtime will
      // use this to initialize the runtime pointer
      inline void set_runtime(Runtime *rt) { runtime = rt; }
    protected:
      Runtime *runtime;
    };
 
    class ShardingFunctor {
    public:
      ShardingFunctor(void);
      virtual ~ShardingFunctor(void);
    public:
      // Indicate whether this functor wants to use the ShardID or 
      // DomainPoint versions of these methods
      virtual bool use_points(void) const { return false; }
    public:
      // The ShardID version of this method
      virtual ShardID shard(const DomainPoint &index_point,
                            const Domain &index_domain,
                            const size_t total_shards);
      // The DomainPoint version of this method
      virtual DomainPoint shard_points(const DomainPoint &index_point,
                            const Domain &index_domain,
                            const std::vector<DomainPoint> &shard_points,
                            const Domain &shard_domain);
    public:
      virtual bool is_invertible(void) const { return false; }
      // The ShardID version of this method
      virtual void invert(ShardID shard,
                          const Domain &sharding_domain,
                          const Domain &index_domain,
                          const size_t total_shards,
                          std::vector<DomainPoint> &points);
      // The DomainPoint version of this method
      virtual void invert_points(const DomainPoint &shard_point,
                          const std::vector<DomainPoint> &shard_points,
                          const Domain &shard_domain,
                          const Domain &index_domain,
                          const Domain &sharding_domain,
                          std::vector<DomainPoint> &index_points);
    };
 
    class ConcurrentColoringFunctor {
    public:
      ConcurrentColoringFunctor(void);
      virtual ~ConcurrentColoringFunctor(void);
    public:
      virtual Color color(const DomainPoint &index_point,
                          const Domain &index_domain) = 0;
    public:
      // You can optionally implement these methods for better performance,
      // but they are not required for correctness. If 'has_max_color' 
      // returns 'true' then you must implement the 'max_color' method.
      virtual bool supports_max_color(void) { return false; }
      virtual Color max_color(const Domain &index_domain)
        { return std::numeric_limits<Color>::max(); }
    };
 
    class FutureFunctor {
    public:
      virtual ~FutureFunctor(void) { }
    public:
      virtual const void* callback_get_future(size_t &size, bool &owned,
          const Realm::ExternalInstanceResource *&resource,
          void (*&freefunc)(const Realm::ExternalInstanceResource&),
          const void *&metadata, size_t &metasize) = 0;
      virtual void callback_release_future(void) = 0;
    };
 
    class PointTransformFunctor {
    public:
      virtual ~PointTransformFunctor(void) { }
    public:
      virtual bool is_invertible(void) const { return false; }
      // Transform a point from the domain into a point in the range
      virtual DomainPoint transform_point(const DomainPoint &point,
                                          const Domain &domain,
                                          const Domain &range) = 0;
      // Invert a point from range and convert it into a point in the domain
      // This is only called if is_invertible returns true
      virtual DomainPoint invert_point(const DomainPoint &point,
                                       const Domain &domain,
                                       const Domain &range)
        { return DomainPoint(); }
    };
 
    class Runtime {
    protected:
      // The Runtime bootstraps itself and should
      // never need to be explicitly created.
      friend class Internal::Runtime;
      friend class Future;
      Runtime(Internal::Runtime *rt);
    public:
      //------------------------------------------------------------------------
      // Index Space Operations
      //------------------------------------------------------------------------
 
      IndexSpace create_index_space(Context ctx, const Domain &bounds,
                                    TypeTag type_tag = 0,
                                    const char *provenance = NULL,
                                    const bool take_ownership = false);
      // Template version
      template<int DIM, typename COORD_T>
      IndexSpaceT<DIM,COORD_T> create_index_space(Context ctx,
                                      const Rect<DIM,COORD_T> &bounds,
                                      const char *provenance = NULL);
      template<int DIM, typename COORD_T>
      IndexSpaceT<DIM,COORD_T> create_index_space(Context ctx,
                                    const DomainT<DIM,COORD_T> &bounds,
                                    const char *provenance = NULL,
                                    const bool take_ownership = false);
 
      IndexSpace create_index_space(Context ctx, size_t dimensions, 
                                    const Future &f, TypeTag type_tag = 0,
                                    const char *provenance = NULL);
      template<int DIM, typename COORD_T>
      IndexSpaceT<DIM,COORD_T> create_index_space(Context ctx, const Future &f,
                                                const char *provenance = NULL);
 
      IndexSpace create_index_space(Context ctx, 
                                    const std::vector<DomainPoint> &points,
                                    const char *provenance = NULL);
      // Template version
      template<int DIM, typename COORD_T>
      IndexSpaceT<DIM,COORD_T> create_index_space(Context ctx,
                      const std::vector<Point<DIM,COORD_T> > &points,
                      const char *provenance = NULL);
 
      IndexSpace create_index_space(Context ctx,
                                    const std::vector<Domain> &rects,
                                    const char *provenance = NULL);
      // Template version
      template<int DIM, typename COORD_T>
      IndexSpaceT<DIM,COORD_T> create_index_space(Context ctx,
                      const std::vector<Rect<DIM,COORD_T> > &rects,
                      const char *provenance = NULL);
 
      IndexSpace union_index_spaces(Context ctx, 
                                    const std::vector<IndexSpace> &spaces,
                                    const char *provenance = NULL);
      // Template version
      template<int DIM, typename COORD_T>
      IndexSpaceT<DIM,COORD_T> union_index_spaces(Context ctx,
                     const std::vector<IndexSpaceT<DIM,COORD_T> > &spaces,
                     const char *provenance = NULL);
 
      IndexSpace intersect_index_spaces(Context ctx,
                                        const std::vector<IndexSpace> &spaces,
                                        const char *provenance = NULL);
      // Template version
      template<int DIM, typename COORD_T>
      IndexSpaceT<DIM,COORD_T> intersect_index_spaces(Context ctx,
                         const std::vector<IndexSpaceT<DIM,COORD_T> > &spaces,
                         const char *provenance = NULL);
 
      IndexSpace subtract_index_spaces(Context ctx, 
                                       IndexSpace left, IndexSpace right,
                                       const char *provenance = NULL);
      // Template version
      template<int DIM, typename COORD_T>
      IndexSpaceT<DIM,COORD_T> subtract_index_spaces(Context ctx,
           IndexSpaceT<DIM,COORD_T> left, IndexSpaceT<DIM,COORD_T> right,
           const char *provenance = NULL);
 
      LEGION_DEPRECATED("Use the new index space creation routines with a "
                        "single domain or rectangle.")
      IndexSpace create_index_space(Context ctx, size_t max_num_elmts);
      LEGION_DEPRECATED("Use the new index space creation routines with a "
                        "single domain or rectangle.")
      IndexSpace create_index_space(Context ctx, 
                                    const std::set<Domain> &domains);
      void create_shared_ownership(Context ctx, IndexSpace handle);
      void destroy_index_space(Context ctx, IndexSpace handle,
                               const bool unordered = false,
                               const bool recurse = true,
                               const char *provenance = NULL);
    public:
      void create_shared_ownership(Context ctx, IndexPartition handle);
      void destroy_index_partition(Context ctx, IndexPartition handle,
                                   const bool unordered = false,
                                   const bool recurse = true,
                                   const char *provenance = NULL);
    public:
      //------------------------------------------------------------------------
      // Dependent Partitioning Operations
      //------------------------------------------------------------------------
 
      IndexPartition create_equal_partition(Context ctx, IndexSpace parent,
                                            IndexSpace color_space, 
                                            size_t granularity = 1,
                                            Color color = 
                                                    LEGION_AUTO_GENERATE_ID,
                                            const char *provenance = NULL);
      template<int DIM, typename COORD_T, 
               int COLOR_DIM, typename COLOR_COORD_T>
      IndexPartitionT<DIM,COORD_T> create_equal_partition(Context ctx,
                        IndexSpaceT<DIM,COORD_T> parent,
                        IndexSpaceT<COLOR_DIM,COLOR_COORD_T> color_space,
                        size_t granularity = 1, 
                        Color color = LEGION_AUTO_GENERATE_ID,
                        const char *provenance = NULL);
 
      IndexPartition create_partition_by_weights(Context ctx, IndexSpace parent,
                                       const std::map<DomainPoint,int> &weights,
                                       IndexSpace color_space,
                                       size_t granularity = 1,
                                       Color color = LEGION_AUTO_GENERATE_ID,
                                       const char *provenance = NULL);
      template<int DIM, typename COORD_T, int COLOR_DIM, typename COLOR_COORD_T>
      IndexPartitionT<DIM,COORD_T> create_partition_by_weights(Context ctx,
                    IndexSpaceT<DIM,COORD_T> parent,
                    const std::map<Point<COLOR_DIM,COLOR_COORD_T>,int> &weights,
                    IndexSpaceT<COLOR_DIM,COLOR_COORD_T> color_space,
                    size_t granularity = 1, 
                    Color color = LEGION_AUTO_GENERATE_ID,
                    const char *provenance = NULL);
      // 64-bit versions
      IndexPartition create_partition_by_weights(Context ctx, IndexSpace parent,
                                    const std::map<DomainPoint,size_t> &weights,
                                    IndexSpace color_space,
                                    size_t granularity = 1,
                                    Color color = LEGION_AUTO_GENERATE_ID,
                                    const char *provenance = NULL);
      template<int DIM, typename COORD_T, int COLOR_DIM, typename COLOR_COORD_T>
      IndexPartitionT<DIM,COORD_T> create_partition_by_weights(Context ctx,
                 IndexSpaceT<DIM,COORD_T> parent,
                 const std::map<Point<COLOR_DIM,COLOR_COORD_T>,size_t> &weights,
                 IndexSpaceT<COLOR_DIM,COLOR_COORD_T> color_space,
                 size_t granularity = 1, Color color = LEGION_AUTO_GENERATE_ID,
                 const char *provenance = NULL);
      // Alternate versions of the above method that take a future map where
      // the values in the future map will be interpretted as integer weights
      // You can use this method with both 32 and 64 bit weights
      IndexPartition create_partition_by_weights(Context ctx, IndexSpace parent,
                                                 const FutureMap &weights,
                                                 IndexSpace color_space,
                                                 size_t granularity = 1,
                                                 Color color =
                                                        LEGION_AUTO_GENERATE_ID,
                                                 const char *provenance = NULL);
      template<int DIM, typename COORD_T, int COLOR_DIM, typename COLOR_COORD_T>
      IndexPartitionT<DIM,COORD_T> create_partition_by_weights(Context ctx,
                               IndexSpaceT<DIM,COORD_T> parent,
                               const FutureMap &weights,
                               IndexSpaceT<COLOR_DIM,COLOR_COORD_T> color_space,
                               size_t granularity = 1, 
                               Color color = LEGION_AUTO_GENERATE_ID,
                               const char *provenance = NULL);
 
      IndexPartition create_partition_by_union(Context ctx,
                                 IndexSpace parent,
                                 IndexPartition handle1,
                                 IndexPartition handle2,
                                 IndexSpace color_space,
                                 PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                 Color color = LEGION_AUTO_GENERATE_ID,
                                 const char *provenance = NULL);
      template<int DIM, typename COORD_T,
               int COLOR_DIM, typename COLOR_COORD_T>
      IndexPartitionT<DIM,COORD_T> create_partition_by_union(Context ctx,
                              IndexSpaceT<DIM,COORD_T> parent,
                              IndexPartitionT<DIM,COORD_T> handle1,
                              IndexPartitionT<DIM,COORD_T> handle2,
                              IndexSpaceT<COLOR_DIM,COLOR_COORD_T> color_space,
                              PartitionKind part_kind = LEGION_COMPUTE_KIND,
                              Color color = LEGION_AUTO_GENERATE_ID,
                              const char *provenance = NULL);
 
      IndexPartition create_partition_by_intersection(Context ctx,
                                  IndexSpace parent,
                                  IndexPartition handle1,
                                  IndexPartition handle2,
                                  IndexSpace color_space,
                                  PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                  Color color = LEGION_AUTO_GENERATE_ID,
                                  const char *provenance = NULL);
      template<int DIM, typename COORD_T,
               int COLOR_DIM, typename COLOR_COORD_T>
      IndexPartitionT<DIM,COORD_T> create_partition_by_intersection(
                              Context ctx,
                              IndexSpaceT<DIM,COORD_T> parent,
                              IndexPartitionT<DIM,COORD_T> handle1,
                              IndexPartitionT<DIM,COORD_T> handle2,
                              IndexSpaceT<COLOR_DIM,COLOR_COORD_T> color_space,
                              PartitionKind part_kind = LEGION_COMPUTE_KIND,
                              Color color = LEGION_AUTO_GENERATE_ID,
                              const char *provenance = NULL);
 
      IndexPartition create_partition_by_intersection(Context ctx,
                                   IndexSpace parent,
                                   IndexPartition partition,
                                   PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                   Color color = LEGION_AUTO_GENERATE_ID,
                                   bool dominates = false,
                                   const char *provenance = NULL);
      template<int DIM, typename COORD_T>
      IndexPartitionT<DIM,COORD_T> create_partition_by_intersection(Context ctx,
                                 IndexSpaceT<DIM,COORD_T> parent,
                                 IndexPartitionT<DIM,COORD_T> partition,
                                 PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                 Color color = LEGION_AUTO_GENERATE_ID,
                                         bool dominates = false,
                                         const char *provenance = NULL);
 
      IndexPartition create_partition_by_difference(Context ctx,
                                  IndexSpace parent,
                                  IndexPartition handle1,
                                  IndexPartition handle2,
                                  IndexSpace color_space,
                                  PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                  Color color = LEGION_AUTO_GENERATE_ID,
                                  const char *provenance = NULL);
      template<int DIM, typename COORD_T,
               int COLOR_DIM, typename COLOR_COORD_T>
      IndexPartitionT<DIM,COORD_T> create_partition_by_difference(Context ctx,
                              IndexSpaceT<DIM,COORD_T> parent,
                              IndexPartitionT<DIM,COORD_T> handle1,
                              IndexPartitionT<DIM,COORD_T> handle2,
                              IndexSpaceT<COLOR_DIM,COLOR_COORD_T> color_space,
                              PartitionKind part_kind = LEGION_COMPUTE_KIND,
                              Color color = LEGION_AUTO_GENERATE_ID,
                              const char *provenance = NULL);
 
      Color create_cross_product_partitions(Context ctx,
                                  IndexPartition handle1,
                                  IndexPartition handle2,
                                  std::map<IndexSpace,IndexPartition> &handles,
                                  PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                  Color color = LEGION_AUTO_GENERATE_ID,
                                  const char *provenance = NULL);
      template<int DIM, typename COORD_T, 
               int COLOR_DIM, typename COLOR_COORD_T>
      Color create_cross_product_partitions(Context ctx,
                                  IndexPartitionT<DIM,COORD_T> handle1,
                                  IndexPartitionT<DIM,COORD_T> handle2,
                                  typename std::map<
                                    IndexSpaceT<DIM,COORD_T>,
                                    IndexPartitionT<DIM,COORD_T> > &handles,
                                  PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                  Color color = LEGION_AUTO_GENERATE_ID,
                                  const char *provenance = NULL);
 
      void create_association(Context ctx,
                              LogicalRegion domain,
                              LogicalRegion domain_parent,
                              FieldID domain_fid,
                              IndexSpace range,
                              MapperID id = 0,
                              MappingTagID tag = 0,
                              UntypedBuffer map_arg = UntypedBuffer(),
                              const char *provenance = NULL);
      void create_bidirectional_association(Context ctx,
                                            LogicalRegion domain,
                                            LogicalRegion domain_parent,
                                            FieldID domain_fid,
                                            LogicalRegion range,
                                            LogicalRegion range_parent,
                                            FieldID range_fid,
                                            MapperID id = 0,
                                            MappingTagID tag = 0,
                                            UntypedBuffer map_arg = 
                                                    UntypedBuffer(),
                                            const char *provenance = NULL);
      // Template versions
      template<int DIM1, typename COORD_T1, int DIM2, typename COORD_T2>
      void create_association(Context ctx,
                              LogicalRegionT<DIM1,COORD_T1> domain,
                              LogicalRegionT<DIM1,COORD_T1> domain_parent,
                              FieldID domain_fid, // type: Point<DIM2,COORD_T2>
                              IndexSpaceT<DIM2,COORD_T2> range,
                              MapperID id = 0,
                              MappingTagID tag = 0,
                              UntypedBuffer map_arg = UntypedBuffer(),
                              const char *provenance = NULL);
      template<int DIM1, typename COORD_T1, int DIM2, typename COORD_T2>
      void create_bidirectional_association(Context ctx,
                              LogicalRegionT<DIM1,COORD_T1> domain,
                              LogicalRegionT<DIM1,COORD_T1> domain_parent,
                              FieldID domain_fid, // type: Point<DIM2,COORD_T2>
                              LogicalRegionT<DIM2,COORD_T2> range,
                              LogicalRegionT<DIM2,COORD_T2> range_parent,
                              FieldID range_fid, // type: Point<DIM1,COORD_T1>
                              MapperID id = 0,
                              MappingTagID tag = 0,
                              UntypedBuffer map_arg = UntypedBuffer(),
                              const char *provenance = NULL);
 
      IndexPartition create_partition_by_restriction(Context ctx,
                                  IndexSpace parent,
                                  IndexSpace color_space,
                                  DomainTransform transform,
                                  Domain extent,
                                  PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                  Color color = LEGION_AUTO_GENERATE_ID,
                                  const char *provenance = NULL);
      // Template version
      template<int DIM, int COLOR_DIM, typename COORD_T>
      IndexPartitionT<DIM,COORD_T> create_partition_by_restriction(Context ctx,
                                IndexSpaceT<DIM,COORD_T> parent,
                                IndexSpaceT<COLOR_DIM,COORD_T> color_space,
                                Transform<DIM,COLOR_DIM,COORD_T> transform,
                                Rect<DIM,COORD_T> extent,
                                PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                Color color = LEGION_AUTO_GENERATE_ID,
                                const char *provenance = NULL);
 
      IndexPartition create_partition_by_blockify(Context ctx,
                                        IndexSpace parent,
                                        DomainPoint blocking_factor,
                                        Color color = LEGION_AUTO_GENERATE_ID,
                                        const char *provenance = NULL);
      // Template version
      template<int DIM, typename COORD_T>
      IndexPartitionT<DIM,COORD_T> create_partition_by_blockify(Context ctx,
                                    IndexSpaceT<DIM,COORD_T> parent,
                                    Point<DIM,COORD_T> blocking_factor,
                                    Color color = LEGION_AUTO_GENERATE_ID,
                                    const char *provenance = NULL);
      IndexPartition create_partition_by_blockify(Context ctx,
                                        IndexSpace parent,
                                        DomainPoint blockify_factor,
                                        DomainPoint origin,
                                        Color color = LEGION_AUTO_GENERATE_ID,
                                        const char *provenance = NULL);
      // Template version
      template<int DIM, typename COORD_T>
      IndexPartitionT<DIM,COORD_T> create_partition_by_blockify(Context ctx,
                                    IndexSpaceT<DIM,COORD_T> parent,
                                    Point<DIM,COORD_T> blocking_factor,
                                    Point<DIM,COORD_T> origin,
                                    Color color = LEGION_AUTO_GENERATE_ID,
                                    const char *provenance = NULL);
 
      IndexPartition create_partition_by_domain(Context ctx,
                                  IndexSpace parent,
                                  const std::map<DomainPoint,Domain> &domains,
                                  IndexSpace color_space,
                                  bool perform_intersections = true,
                                  PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                  Color color = LEGION_AUTO_GENERATE_ID,
                                  const char *provenance = NULL,
                                  bool take_ownership = false);
      template<int DIM, typename COORD_T, int COLOR_DIM, typename COLOR_COORD_T>
      IndexPartitionT<DIM,COORD_T> create_partition_by_domain(Context ctx,
                                  IndexSpaceT<DIM,COORD_T> parent,
                                  const std::map<
                                         Point<COLOR_DIM,COLOR_COORD_T>,
                                           DomainT<DIM,COORD_T> > &domains,
                                  IndexSpaceT<COLOR_DIM,
                                              COLOR_COORD_T> color_space,
                                  bool perform_intersections = true,
                                  PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                  Color color = LEGION_AUTO_GENERATE_ID,
                                  const char *provenance = NULL,
                                  bool take_ownership = false);
      IndexPartition create_partition_by_domain(Context ctx,
                                  IndexSpace parent,
                                  const FutureMap &domain_future_map,
                                  IndexSpace color_space,
                                  bool perform_intersections = true,
                                  PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                  Color color = LEGION_AUTO_GENERATE_ID,
                                  const char *provenance = NULL);
      template<int DIM, typename COORD_T, int COLOR_DIM, typename COLOR_COORD_T>
      IndexPartitionT<DIM,COORD_T> create_partition_by_domain(Context ctx,
                                  IndexSpaceT<DIM,COORD_T> parent,
                                  const FutureMap &domain_future_map,
                                  IndexSpaceT<COLOR_DIM,
                                              COLOR_COORD_T> color_space,
                                  bool perform_intersections = true,
                                  PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                  Color color = LEGION_AUTO_GENERATE_ID,
                                  const char *provenance = NULL);
 
      template<int DIM, typename COORD_T, int COLOR_DIM, typename COLOR_COORD_T>
      IndexPartitionT<DIM,COORD_T> create_partition_by_rectangles(Context ctx,
                                  IndexSpaceT<DIM,COORD_T> parent,
                                  const std::map<Point<COLOR_DIM,COLOR_COORD_T>,
                                  std::vector<Rect<DIM,COORD_T> > > &rectangles,
                                  IndexSpaceT<COLOR_DIM,
                                              COLOR_COORD_T> color_space,
                                  bool perform_intersections = true,
                                  PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                  Color color = LEGION_AUTO_GENERATE_ID,
                                  const char *provenance = NULL,
                                  bool collective = false);
 
      IndexPartition create_partition_by_field(Context ctx,
                                               LogicalRegion handle,
                                               LogicalRegion parent,
                                               FieldID fid, 
                                               IndexSpace color_space,
                                               Color color = 
                                                      LEGION_AUTO_GENERATE_ID,
                                               MapperID id = 0,
                                               MappingTagID tag = 0,
                                               PartitionKind part_kind = 
                                                         LEGION_DISJOINT_KIND,
                                               UntypedBuffer map_arg = 
                                                         UntypedBuffer(),
                                               const char *provenance = NULL);
      template<int DIM, typename COORD_T, 
               int COLOR_DIM, typename COLOR_COORD_T>
      IndexPartitionT<DIM,COORD_T> create_partition_by_field(Context ctx,
                          LogicalRegionT<DIM,COORD_T> handle,
                          LogicalRegionT<DIM,COORD_T> parent,
                          FieldID fid, // type: Point<COLOR_DIM,COLOR_COORD_T>
                          IndexSpaceT<COLOR_DIM,COLOR_COORD_T> color_space,
                          Color color = LEGION_AUTO_GENERATE_ID,
                          MapperID id = 0, MappingTagID tag = 0,
                          PartitionKind part_kind = LEGION_DISJOINT_KIND,
                          UntypedBuffer map_arg = UntypedBuffer(),
                          const char *provenance = NULL);
 
      IndexPartition create_partition_by_image(Context ctx,
                                 IndexSpace handle,
                                 LogicalPartition projection,
                                 LogicalRegion parent,
                                 FieldID fid,
                                 IndexSpace color_space,
                                 PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                 Color color = LEGION_AUTO_GENERATE_ID,
                                 MapperID id = 0, MappingTagID tag = 0,
                                 UntypedBuffer map_arg = UntypedBuffer(),
                                 const char *provenance = NULL);
      template<int DIM1, typename COORD_T1, 
               int DIM2, typename COORD_T2, 
               int COLOR_DIM, typename COLOR_COORD_T>
      IndexPartitionT<DIM2,COORD_T2> create_partition_by_image(Context ctx,
                              IndexSpaceT<DIM2,COORD_T2> handle,
                              LogicalPartitionT<DIM1,COORD_T1> projection,
                              LogicalRegionT<DIM1,COORD_T1> parent,
                              FieldID fid, // type: Point<DIM2,COORD_T2>
                              IndexSpaceT<COLOR_DIM,COLOR_COORD_T> color_space,
                              PartitionKind part_kind = LEGION_COMPUTE_KIND,
                              Color color = LEGION_AUTO_GENERATE_ID,
                              MapperID id = 0, MappingTagID tag = 0,
                              UntypedBuffer map_arg = UntypedBuffer(),
                              const char *provenance = NULL);
      // Range versions of image
      IndexPartition create_partition_by_image_range(Context ctx,
                                 IndexSpace handle,
                                 LogicalPartition projection,
                                 LogicalRegion parent,
                                 FieldID fid,
                                 IndexSpace color_space,
                                 PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                 Color color = LEGION_AUTO_GENERATE_ID,
                                 MapperID id = 0, MappingTagID tag = 0,
                                 UntypedBuffer map_arg = UntypedBuffer(),
                                 const char *provenance = NULL);
      template<int DIM1, typename COORD_T1, 
               int DIM2, typename COORD_T2, 
               int COLOR_DIM, typename COLOR_COORD_T>
      IndexPartitionT<DIM2,COORD_T2> create_partition_by_image_range(
                              Context ctx,
                              IndexSpaceT<DIM2,COORD_T2> handle,
                              LogicalPartitionT<DIM1,COORD_T1> projection,
                              LogicalRegionT<DIM1,COORD_T1> parent,
                              FieldID fid, // type: Rect<DIM2,COORD_T2>
                              IndexSpaceT<COLOR_DIM,COLOR_COORD_T> color_space,
                              PartitionKind part_kind = LEGION_COMPUTE_KIND,
                              Color color = LEGION_AUTO_GENERATE_ID,
                              MapperID id = 0, MappingTagID tag = 0,
                              UntypedBuffer map_arg = UntypedBuffer(),
                              const char *provenance = NULL);
 
      IndexPartition create_partition_by_preimage(Context ctx, 
                                  IndexPartition projection,
                                  LogicalRegion handle,
                                  LogicalRegion parent,
                                  FieldID fid,
                                  IndexSpace color_space,
                                  PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                  Color color = LEGION_AUTO_GENERATE_ID,
                                  MapperID id = 0, MappingTagID tag = 0,
                                  UntypedBuffer map_arg = UntypedBuffer(),
                                  const char *provenance = NULL);
      template<int DIM1, typename COORD_T1,
               int DIM2, typename COORD_T2,
               int COLOR_DIM, typename COLOR_COORD_T>
      IndexPartitionT<DIM1,COORD_T1> create_partition_by_preimage(Context ctx,
                              IndexPartitionT<DIM2,COORD_T2> projection,
                              LogicalRegionT<DIM1,COORD_T1> handle,
                              LogicalRegionT<DIM1,COORD_T1> parent,
                              FieldID fid, // type: Point<DIM2,COORD_T2>
                              IndexSpaceT<COLOR_DIM,COLOR_COORD_T> color_space,
                              PartitionKind part_kind = LEGION_COMPUTE_KIND,
                              Color color = LEGION_AUTO_GENERATE_ID,
                              MapperID id = 0, MappingTagID tag = 0,
                              UntypedBuffer map_arg = UntypedBuffer(),
                              const char *provenance = NULL);
      // Range versions of preimage 
      IndexPartition create_partition_by_preimage_range(Context ctx, 
                                  IndexPartition projection,
                                  LogicalRegion handle,
                                  LogicalRegion parent,
                                  FieldID fid,
                                  IndexSpace color_space,
                                  PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                  Color color = LEGION_AUTO_GENERATE_ID,
                                  MapperID id = 0, MappingTagID tag = 0,
                                  UntypedBuffer map_arg = UntypedBuffer(),
                                  const char *provenance = NULL);
      template<int DIM1, typename COORD_T1,
               int DIM2, typename COORD_T2,
               int COLOR_DIM, typename COLOR_COORD_T>
      IndexPartitionT<DIM1,COORD_T1> create_partition_by_preimage_range(
                              Context ctx,
                              IndexPartitionT<DIM2,COORD_T2> projection,
                              LogicalRegionT<DIM1,COORD_T1> handle,
                              LogicalRegionT<DIM1,COORD_T1> parent,
                              FieldID fid, // type: Rect<DIM2,COORD_T2>
                              IndexSpaceT<COLOR_DIM,COLOR_COORD_T> color_space,
                              PartitionKind part_kind = LEGION_COMPUTE_KIND,
                              Color color = LEGION_AUTO_GENERATE_ID,
                              MapperID id = 0, MappingTagID tag = 0,
                              UntypedBuffer map_arg = UntypedBuffer(),
                              const char *provenance = NULL);
    public:
      //------------------------------------------------------------------------
      // Computed Index Spaces and Partitions 
      //------------------------------------------------------------------------
 
      IndexPartition create_pending_partition(Context ctx,
                                              IndexSpace parent,
                                              IndexSpace color_space,
                                  PartitionKind part_kind = LEGION_COMPUTE_KIND,
                                  Color color = LEGION_AUTO_GENERATE_ID,
                                  const char *provenance = NULL);
      template<int DIM, typename COORD_T,
               int COLOR_DIM, typename COLOR_COORD_T>
      IndexPartitionT<DIM,COORD_T> create_pending_partition(Context ctx,
                              IndexSpaceT<DIM,COORD_T> parent,
                              IndexSpaceT<COLOR_DIM,COLOR_COORD_T> color_space,
                              PartitionKind part_kind = LEGION_COMPUTE_KIND,
                              Color color = LEGION_AUTO_GENERATE_ID,
                              const char *provenance = NULL);
 
      IndexSpace create_index_space_union(Context ctx, IndexPartition parent, 
                                        const DomainPoint &color,
                                        const std::vector<IndexSpace> &handles,
                                        const char *provenance = NULL);
      template<int DIM, typename COORD_T,
               int COLOR_DIM, typename COLOR_COORD_T>
      IndexSpaceT<DIM,COORD_T> create_index_space_union(Context ctx,
                                IndexPartitionT<DIM,COORD_T> parent,
                                Point<COLOR_DIM,COLOR_COORD_T> color,
                                const typename std::vector<
                                  IndexSpaceT<DIM,COORD_T> > &handles,
                                const char *provenance = NULL);
 
      IndexSpace create_index_space_union(Context ctx, IndexPartition parent,
                                          const DomainPoint &color,
                                          IndexPartition handle,
                                          const char *provenance = NULL);
      template<int DIM, typename COORD_T,
               int COLOR_DIM, typename COLOR_COORD_T>
      IndexSpaceT<DIM,COORD_T> create_index_space_union(Context ctx,
                                IndexPartitionT<DIM,COORD_T> parent,
                                Point<COLOR_DIM,COLOR_COORD_T> color,
                                IndexPartitionT<DIM,COORD_T> handle,
                                const char *provenance = NULL);
 
      IndexSpace create_index_space_intersection(Context ctx, 
                                                 IndexPartition parent,
                                                 const DomainPoint &color,
                                       const std::vector<IndexSpace> &handles,
                                       const char *provenance = NULL);
      template<int DIM, typename COORD_T,
               int COLOR_DIM, typename COLOR_COORD_T>
      IndexSpaceT<DIM,COORD_T> create_index_space_intersection(Context ctx,
                                IndexPartitionT<DIM,COORD_T> parent,
                                Point<COLOR_DIM,COLOR_COORD_T> color,
                                const typename std::vector<
                                  IndexSpaceT<DIM,COORD_T> > &handles,
                                const char *provenance = NULL);
 
      IndexSpace create_index_space_intersection(Context ctx, 
                                                 IndexPartition parent,
                                                 const DomainPoint &color,
                                                 IndexPartition handle,
                                                 const char *provenannce=NULL);
      template<int DIM, typename COORD_T,
               int COLOR_DIM, typename COLOR_COORD_T>
      IndexSpaceT<DIM,COORD_T> create_index_space_intersection(Context ctx,
                                IndexPartitionT<DIM,COORD_T> parent,
                                Point<COLOR_DIM,COLOR_COORD_T> color,
                                IndexPartitionT<DIM,COORD_T> handle,
                                const char *provenance = NULL);
 
      IndexSpace create_index_space_difference(Context ctx, 
                                               IndexPartition parent,
                                               const DomainPoint &color,
                                               IndexSpace initial,
                                        const std::vector<IndexSpace> &handles,
                                        const char *provenancne = NULL);
      template<int DIM, typename COORD_T,
               int COLOR_DIM, typename COLOR_COORD_T>
      IndexSpaceT<DIM,COORD_T> create_index_space_difference(Context ctx,
                                IndexPartitionT<DIM,COORD_T> parent,
                                Point<COLOR_DIM,COLOR_COORD_T> color,
                                IndexSpaceT<DIM,COORD_T> initial,
                                const typename std::vector<
                                  IndexSpaceT<DIM,COORD_T> > &handles,
                                const char *provenance = NULL);
    public:
      //------------------------------------------------------------------------
      // Index Tree Traversal Operations
      //------------------------------------------------------------------------
 
      IndexPartition get_index_partition(Context ctx, IndexSpace parent, 
                                         Color color);
      IndexPartition get_index_partition(Context ctx, IndexSpace parent,
                                         const DomainPoint &color);
      // Context free versions
      IndexPartition get_index_partition(IndexSpace parent, Color color);
      IndexPartition get_index_partition(IndexSpace parent, 
                                         const DomainPoint &color);
      // Template version
      template<int DIM, typename COORD_T>
      IndexPartitionT<DIM,COORD_T> get_index_partition(
                                  IndexSpaceT<DIM,COORD_T> parent, Color color);
 
      
 
      bool has_index_partition(Context ctx, IndexSpace parent, Color color);
      bool has_index_partition(Context ctx, IndexSpace parent,
                               const DomainPoint &color);
      // Context free
      bool has_index_partition(IndexSpace parent, Color color);
      bool has_index_partition(IndexSpace parent,
                               const DomainPoint &color);
      // Template version
      template<int DIM, typename COORD_T>
      bool has_index_partition(IndexSpaceT<DIM,COORD_T> parent, Color color);
 
 
      IndexSpace get_index_subspace(Context ctx, IndexPartition p, 
                                    Color color); 
      IndexSpace get_index_subspace(Context ctx, IndexPartition p,
                                    const DomainPoint &color);
      // Context free versions
      IndexSpace get_index_subspace(IndexPartition p, Color color);
      IndexSpace get_index_subspace(IndexPartition p,
                                    const DomainPoint &color);
      // Template version
      template<int DIM, typename COORD_T,
               int COLOR_DIM, typename COLOR_COORD_T>
      IndexSpaceT<DIM,COORD_T> get_index_subspace(
                                  IndexPartitionT<DIM,COORD_T> p,
                                  Point<COLOR_DIM,COLOR_COORD_T> color);
 
 
      bool has_index_subspace(Context ctx, IndexPartition p,
                              const DomainPoint &color);
      // Context free
      bool has_index_subspace(IndexPartition p,
                              const DomainPoint &color);
      // Template version
      template<int DIM, typename COORD_T,
               int COLOR_DIM, typename COLOR_COORD_T>
      bool has_index_subspace(IndexPartitionT<DIM,COORD_T> p,
                              Point<COLOR_DIM,COLOR_COORD_T> color);
 
 
      LEGION_DEPRECATED("Multiple domains are no longer supported.")
      bool has_multiple_domains(Context ctx, IndexSpace handle);
      // Context free
      LEGION_DEPRECATED("Multiple domains are no longer supported.")
      bool has_multiple_domains(IndexSpace handle);
 
 
      Domain get_index_space_domain(Context ctx, IndexSpace handle);
      // Context free
      Domain get_index_space_domain(IndexSpace handle);
      // Template version
      template<int DIM, typename COORD_T>
      DomainT<DIM,COORD_T> get_index_space_domain(
                                        IndexSpaceT<DIM,COORD_T> handle);
 
 
      LEGION_DEPRECATED("Multiple domains are no longer supported.")
      void get_index_space_domains(Context ctx, IndexSpace handle,
                                   std::vector<Domain> &domains);
      // Context free
      LEGION_DEPRECATED("Multiple domains are no longer supported.")
      void get_index_space_domains(IndexSpace handle,
                                   std::vector<Domain> &domains);
 
 
      Domain get_index_partition_color_space(Context ctx, IndexPartition p);
      // Context free
      Domain get_index_partition_color_space(IndexPartition p);
      // Template version
      template<int DIM, typename COORD_T,
               int COLOR_DIM, typename COLOR_COORD_T>
      DomainT<COLOR_DIM,COLOR_COORD_T>
             get_index_partition_color_space(IndexPartitionT<DIM,COORD_T> p);
 
 
      IndexSpace get_index_partition_color_space_name(Context ctx, 
                                                      IndexPartition p);
      // Context free
      IndexSpace get_index_partition_color_space_name(IndexPartition p);
      // Template version
      template<int DIM, typename COORD_T,
               int COLOR_DIM, typename COLOR_COORD_T>
      IndexSpaceT<COLOR_DIM,COLOR_COORD_T> 
           get_index_partition_color_space_name(IndexPartitionT<DIM,COORD_T> p);
 
 
      void get_index_space_partition_colors(Context ctx, IndexSpace sp,
                                            std::set<Color> &colors);
      void get_index_space_partition_colors(Context ctx, IndexSpace sp,
                                            std::set<DomainPoint> &colors);
      // Context free versions
      void get_index_space_partition_colors(IndexSpace sp,
                                            std::set<Color> &colors);
      void get_index_space_partition_colors(IndexSpace sp,
                                            std::set<DomainPoint> &colors);
 
 
      bool is_index_partition_disjoint(Context ctx, IndexPartition p);
      // Context free
      bool is_index_partition_disjoint(IndexPartition p);
 
 
      bool is_index_partition_complete(Context ctx, IndexPartition p);
      // Context free
      bool is_index_partition_complete(IndexPartition p);
 
 
      Color get_index_space_color(Context ctx, IndexSpace handle);
      DomainPoint get_index_space_color_point(Context ctx, IndexSpace handle);
      // Context free
      Color get_index_space_color(IndexSpace handle);
      DomainPoint get_index_space_color_point(IndexSpace handle);
      // Template version
      template<int DIM, typename COORD_T,
               int COLOR_DIM, typename COLOR_COORD_T>
      Point<COLOR_DIM,COLOR_COORD_T>
            get_index_space_color(IndexSpaceT<DIM,COORD_T> handle);
 
 
      Color get_index_partition_color(Context ctx, IndexPartition handle);
      DomainPoint get_index_partition_color_point(Context ctx,
                                                  IndexPartition handle);
      // Context free
      Color get_index_partition_color(IndexPartition handle);
      DomainPoint get_index_partition_color_point(IndexPartition handle);
 
 
      IndexSpace get_parent_index_space(Context ctx, IndexPartition handle);
      // Context free
      IndexSpace get_parent_index_space(IndexPartition handle);
      // Template version
      template<int DIM, typename COORD_T>
      IndexSpaceT<DIM,COORD_T> get_parent_index_space(
                                      IndexPartitionT<DIM,COORD_T> handle);
 
 
      bool has_parent_index_partition(Context ctx, IndexSpace handle);
      // Context free
      bool has_parent_index_partition(IndexSpace handle);
 
 
      IndexPartition get_parent_index_partition(Context ctx, IndexSpace handle);
      // Context free
      IndexPartition get_parent_index_partition(IndexSpace handle);
      // Template version
      template<int DIM, typename COORD_T>
      IndexPartitionT<DIM,COORD_T> get_parent_index_partition(
                                              IndexSpaceT<DIM,COORD_T> handle);
 
 
      unsigned get_index_space_depth(Context ctx, IndexSpace handle);
      // Context free
      unsigned get_index_space_depth(IndexSpace handle);
 
 
      unsigned get_index_partition_depth(Context ctx, IndexPartition handle);
      // Context free
      unsigned get_index_partition_depth(IndexPartition handle);
    public:
      //------------------------------------------------------------------------
      // Safe Cast Operations
      //------------------------------------------------------------------------
      DomainPoint safe_cast(Context ctx, DomainPoint point, 
                            LogicalRegion region);
      
      template<int DIM, typename COORD_T>
      bool safe_cast(Context ctx, 
                     Point<DIM,COORD_T> point,
                     LogicalRegionT<DIM,COORD_T> region);
    public:
      //------------------------------------------------------------------------
      // Field Space Operations
      //------------------------------------------------------------------------
      FieldSpace create_field_space(Context ctx, const char *provenance = NULL);
      FieldSpace create_field_space(Context ctx,
                                    const std::vector<size_t> &field_sizes,
                                    std::vector<FieldID> &resulting_fields,
                                    CustomSerdezID serdez_id = 0,
                                    const char *provenance = NULL);
      FieldSpace create_field_space(Context ctx,
                                    const std::vector<Future> &field_sizes,
                                    std::vector<FieldID> &resulting_fields,
                                    CustomSerdezID serdez_id = 0,
                                    const char *provenance = NULL);
      void create_shared_ownership(Context ctx, FieldSpace handle);
      void destroy_field_space(Context ctx, FieldSpace handle, 
                               const bool unordered = false,
                               const char *provenance = NULL);
 
 
      size_t get_field_size(Context ctx, FieldSpace handle, FieldID fid);
      // Context free
      size_t get_field_size(FieldSpace handle, FieldID fid);
 
 
      void get_field_space_fields(Context ctx, FieldSpace handle,
                                  std::vector<FieldID> &fields);
      // Context free
      void get_field_space_fields(FieldSpace handle,
                                  std::vector<FieldID> &fields);
 
 
      void get_field_space_fields(Context ctx, FieldSpace handle,
                                  std::set<FieldID> &fields);
      // Context free
      void get_field_space_fields(FieldSpace handle,
                                  std::set<FieldID> &fields);
    public:
      //------------------------------------------------------------------------
      // Logical Region Operations
      //------------------------------------------------------------------------
      LogicalRegion create_logical_region(Context ctx, IndexSpace index, 
                                          FieldSpace fields,
                                          bool task_local = false,
                                          const char *provenance = NULL);
      // Template version
      template<int DIM, typename COORD_T>
      LogicalRegionT<DIM,COORD_T> create_logical_region(Context ctx,
                                      IndexSpaceT<DIM,COORD_T> index,
                                      FieldSpace fields,
                                      bool task_local = false,
                                      const char *provenance = NULL);
      void create_shared_ownership(Context ctx, LogicalRegion handle);
      void destroy_logical_region(Context ctx, LogicalRegion handle,
                                  const bool unordered = false,
                                  const char *provenance = NULL);
 
      LEGION_DEPRECATED("Destruction of logical partitions are no-ops now."
          "Logical partitions are automatically destroyed when their root "
          "logical region or their index spartition are destroyed.")
      void destroy_logical_partition(Context ctx, LogicalPartition handle,
                                     const bool unordered = false);
 
      void reset_equivalence_sets(Context ctx, LogicalRegion parent, 
                                  LogicalRegion region,
                                  const std::set<FieldID> &fields);
    public:
      //------------------------------------------------------------------------
      // Logical Region Tree Traversal Operations
      //------------------------------------------------------------------------
 
      LogicalPartition get_logical_partition(Context ctx, LogicalRegion parent, 
                                             IndexPartition handle);
      // Context free
      LogicalPartition get_logical_partition(LogicalRegion parent,
                                             IndexPartition handle);
      // Template version
      template<int DIM, typename COORD_T>
      LogicalPartitionT<DIM,COORD_T> get_logical_partition(
                                      LogicalRegionT<DIM,COORD_T> parent,
                                      IndexPartitionT<DIM,COORD_T> handle);
      
 
      LogicalPartition get_logical_partition_by_color(Context ctx, 
                                                      LogicalRegion parent, 
                                                      Color c);
      LogicalPartition get_logical_partition_by_color(Context ctx,
                                                      LogicalRegion parent,
                                                      const DomainPoint &c);
      // Context free
      LogicalPartition get_logical_partition_by_color(LogicalRegion parent, 
                                                      Color c);
      LogicalPartition get_logical_partition_by_color(LogicalRegion parent,
                                                      const DomainPoint &c);
      // Template version
      template<int DIM, typename COORD_T>
      LogicalPartitionT<DIM,COORD_T> get_logical_partition_by_color(
                                        LogicalRegionT<DIM,COORD_T> parent,
                                        Color c);
 
 
      bool has_logical_partition_by_color(Context ctx,
                                          LogicalRegion parent,
                                          const DomainPoint &c);
      // Context free
      bool has_logical_partition_by_color(LogicalRegion parent,
                                          const DomainPoint &c);
      
 
      LogicalPartition get_logical_partition_by_tree(Context ctx, 
                                                     IndexPartition handle, 
                                                     FieldSpace fspace, 
                                                     RegionTreeID tid); 
      // Context free
      LogicalPartition get_logical_partition_by_tree(IndexPartition handle, 
                                                     FieldSpace fspace, 
                                                     RegionTreeID tid);
      // Template version
      template<int DIM, typename COORD_T>
      LogicalPartitionT<DIM,COORD_T> get_logical_partition_by_tree(
                                      IndexPartitionT<DIM,COORD_T> handle,
                                      FieldSpace fspace, RegionTreeID tid);
 
 
      LogicalRegion get_logical_subregion(Context ctx, LogicalPartition parent, 
                                          IndexSpace handle);
      // Context free
      LogicalRegion get_logical_subregion(LogicalPartition parent, 
                                          IndexSpace handle);
      // Template version
      template<int DIM, typename COORD_T>
      LogicalRegionT<DIM,COORD_T> get_logical_subregion(
                                          LogicalPartitionT<DIM,COORD_T> parent,
                                          IndexSpaceT<DIM,COORD_T> handle);
 
 
      LogicalRegion get_logical_subregion_by_color(Context ctx, 
                                                   LogicalPartition parent, 
                                                   Color c);
      LogicalRegion get_logical_subregion_by_color(Context ctx,
                                                   LogicalPartition parent,
                                                   const DomainPoint &c);
      // Context free
      LogicalRegion get_logical_subregion_by_color(LogicalPartition parent, 
                                                   Color c);
      LogicalRegion get_logical_subregion_by_color(LogicalPartition parent,
                                                   const DomainPoint &c);
      // Template version
      template<int DIM, typename COORD_T,
               int COLOR_DIM, typename COLOR_COORD_T>
      LogicalRegionT<DIM,COORD_T> get_logical_subregion_by_color(
                                  LogicalPartitionT<DIM,COORD_T> parent,
                                  Point<COLOR_DIM,COLOR_COORD_T> color);
 
 
      bool has_logical_subregion_by_color(Context ctx,
                                          LogicalPartition parent,
                                          const DomainPoint &c);
      // Context free
      bool has_logical_subregion_by_color(LogicalPartition parent,
                                          const DomainPoint &c);
      // Template version
      template<int DIM, typename COORD_T,
               int COLOR_DIM, typename COLOR_COORD_T>
      bool has_logical_subregion_by_color(LogicalPartitionT<DIM,COORD_T> parent,
                                  Point<COLOR_DIM,COLOR_COORD_T> color);
 
 
      LogicalRegion get_logical_subregion_by_tree(Context ctx, 
                                                  IndexSpace handle, 
                                                  FieldSpace fspace, 
                                                  RegionTreeID tid);
      // Context free
      LogicalRegion get_logical_subregion_by_tree(IndexSpace handle, 
                                                  FieldSpace fspace, 
                                                  RegionTreeID tid);
      // Template version
      template<int DIM, typename COORD_T>
      LogicalRegionT<DIM,COORD_T> get_logical_subregion_by_tree(
                                    IndexSpaceT<DIM,COORD_T> handle,
                                    FieldSpace space, RegionTreeID tid);
 
 
      Color get_logical_region_color(Context ctx, LogicalRegion handle);
      DomainPoint get_logical_region_color_point(Context ctx, 
                                                 LogicalRegion handle);
      // Context free versions
      Color get_logical_region_color(LogicalRegion handle);
      DomainPoint get_logical_region_color_point(LogicalRegion handle);
      // Template version
      template<int DIM, typename COORD_T,
               int COLOR_DIM, typename COLOR_COORD_T>
      Point<COLOR_DIM,COLOR_COORD_T>
        get_logical_region_color_point(LogicalRegionT<DIM,COORD_T> handle);
 
 
      Color get_logical_partition_color(Context ctx, LogicalPartition handle);
      DomainPoint get_logical_partition_color_point(Context ctx,
                                                    LogicalPartition handle);
      // Context free versions
      Color get_logical_partition_color(LogicalPartition handle);
      DomainPoint get_logical_partition_color_point(LogicalPartition handle);
 
 
      LogicalRegion get_parent_logical_region(Context ctx, 
                                              LogicalPartition handle);
      // Context free
      LogicalRegion get_parent_logical_region(LogicalPartition handle);
      // Template version
      template<int DIM, typename COORD_T>
      LogicalRegionT<DIM,COORD_T> get_parent_logical_region(
                                    LogicalPartitionT<DIM,COORD_T> handle);
 
 
      bool has_parent_logical_partition(Context ctx, LogicalRegion handle);
      // Context free
      bool has_parent_logical_partition(LogicalRegion handle);
 
 
      LogicalPartition get_parent_logical_partition(Context ctx, 
                                                    LogicalRegion handle);
      // Context free
      LogicalPartition get_parent_logical_partition(LogicalRegion handle);
      // Template version
      template<int DIM, typename COORD_T>
      LogicalPartitionT<DIM,COORD_T> get_parent_logical_partition(
                                          LogicalRegionT<DIM,COORD_T> handle);
    public:
      //------------------------------------------------------------------------
      // Allocator and Argument Map Operations 
      //------------------------------------------------------------------------
      FieldAllocator create_field_allocator(Context ctx, FieldSpace handle);
 
      LEGION_DEPRECATED("ArgumentMap can be constructed directly.")
      ArgumentMap create_argument_map(Context ctx);
    public:
      //------------------------------------------------------------------------
      // Task Launch Operations
      //------------------------------------------------------------------------
      Future execute_task(Context ctx,
                          const TaskLauncher &launcher,
                          std::vector<OutputRequirement> *outputs = NULL);
 
      FutureMap execute_index_space(
                                Context ctx, const IndexTaskLauncher &launcher,
                                std::vector<OutputRequirement> *outputs = NULL);
 
      Future execute_index_space(
                               Context ctx, const IndexTaskLauncher &launcher,
                               ReductionOpID redop, bool ordered = true,
                               std::vector<OutputRequirement> *outputs = NULL);
 
      Future reduce_future_map(Context ctx, const FutureMap &future_map,
                               ReductionOpID redop, bool ordered = true,
                               MapperID map_id = 0, MappingTagID tag = 0,
                               const char *provenance = NULL,
                               Future initial_value = Future());
 
      FutureMap construct_future_map(Context ctx, IndexSpace domain, 
                           const std::map<DomainPoint,UntypedBuffer> &data,
                           bool collective = false, ShardingID sid = 0,
                           bool implicit_sharding = false,
                           const char *provenance = NULL);
      LEGION_DEPRECATED("Use the version that takes an IndexSpace instead")
      FutureMap construct_future_map(Context ctx, const Domain &domain,
                           const std::map<DomainPoint,UntypedBuffer> &data,
                           bool collective = false, ShardingID sid = 0,
                           bool implicit_sharding = false);
 
      FutureMap construct_future_map(Context ctx, IndexSpace domain,
                           const std::map<DomainPoint,Future> &futures,
                           bool collective = false, ShardingID sid = 0,
                           bool implicit_sharding = false,
                           const char *provenance = NULL);
      LEGION_DEPRECATED("Use the version that takes an IndexSpace instead")
      FutureMap construct_future_map(Context ctx, const Domain &domain,
                           const std::map<DomainPoint,Future> &futures,
                           bool collective = false, ShardingID sid = 0,
                           bool implicit_sharding = false);
 
      typedef DomainPoint (*PointTransformFnptr)(const DomainPoint &point,
                                                 const Domain &domain,
                                                 const Domain &range);
      FutureMap transform_future_map(Context ctx, const FutureMap &fm,
                                     IndexSpace new_domain,
                                     PointTransformFnptr fnptr,
                                     const char *provenance = NULL);
      FutureMap transform_future_map(Context ctx, const FutureMap &fm,
                                     IndexSpace new_domain,
                                     PointTransformFunctor *functor,
                                     bool take_ownership = false,
                                     const char *provenance = NULL);
 
      LEGION_DEPRECATED("Launching tasks should be done with the new task "
                        "launcher interface.")
      Future execute_task(Context ctx, TaskID task_id,
                          const std::vector<IndexSpaceRequirement> &indexes,
                          const std::vector<FieldSpaceRequirement> &fields,
                          const std::vector<RegionRequirement> &regions,
                          const UntypedBuffer &arg, 
                          const Predicate &predicate = Predicate::TRUE_PRED,
                          MapperID id = 0, 
                          MappingTagID tag = 0);
 
      LEGION_DEPRECATED("Launching tasks should be done with the new task "
                        "launcher interface.")
      FutureMap execute_index_space(Context ctx, TaskID task_id,
                          const Domain domain,
                          const std::vector<IndexSpaceRequirement> &indexes,
                          const std::vector<FieldSpaceRequirement> &fields,
                          const std::vector<RegionRequirement> &regions,
                          const UntypedBuffer &global_arg, 
                          const ArgumentMap &arg_map,
                          const Predicate &predicate = Predicate::TRUE_PRED,
                          bool must_paralleism = false, 
                          MapperID id = 0, 
                          MappingTagID tag = 0);
 
      LEGION_DEPRECATED("Launching tasks should be done with the new task "
                        "launcher interface.")
      Future execute_index_space(Context ctx, TaskID task_id,
                          const Domain domain,
                          const std::vector<IndexSpaceRequirement> &indexes,
                          const std::vector<FieldSpaceRequirement> &fields,
                          const std::vector<RegionRequirement> &regions,
                          const UntypedBuffer &global_arg, 
                          const ArgumentMap &arg_map,
                          ReductionOpID reduction, 
                          const UntypedBuffer &initial_value,
                          const Predicate &predicate = Predicate::TRUE_PRED,
                          bool must_parallelism = false, 
                          MapperID id = 0, 
                          MappingTagID tag = 0);
    public:
      //------------------------------------------------------------------------
      // Inline Mapping Operations
      //------------------------------------------------------------------------
      PhysicalRegion map_region(Context ctx, const InlineLauncher &launcher);
 
      PhysicalRegion map_region(Context ctx, const RegionRequirement &req, 
                                MapperID id = 0, MappingTagID tag = 0,
                                const char *provenance = NULL);
 
      PhysicalRegion map_region(Context ctx, unsigned idx, 
                                MapperID id = 0, MappingTagID tag = 0,
                                const char *provenance = NULL);
 
      void remap_region(Context ctx, PhysicalRegion region,
                        const char *provenance = NULL);
 
      void unmap_region(Context ctx, PhysicalRegion region);
 
      void unmap_all_regions(Context ctx);
    public:
      //------------------------------------------------------------------------
      // Output Region Operations
      //------------------------------------------------------------------------
      OutputRegion get_output_region(Context ctx, unsigned index);
 
      void get_output_regions(Context ctx, std::vector<OutputRegion> &regions);
    public:
      //------------------------------------------------------------------------
      // Fill Field Operations
      //------------------------------------------------------------------------
      template<typename T>
      void fill_field(Context ctx, LogicalRegion handle, LogicalRegion parent, 
                      FieldID fid, const T &value, 
                      Predicate pred = Predicate::TRUE_PRED);
 
      void fill_field(Context ctx, LogicalRegion handle, LogicalRegion parent,
                      FieldID fid, const void *value, size_t value_size,
                      Predicate pred = Predicate::TRUE_PRED);
 
      void fill_field(Context ctx, LogicalRegion handle, LogicalRegion parent,
                      FieldID fid, Future f, 
                      Predicate pred = Predicate::TRUE_PRED);
 
      template<typename T>
      void fill_fields(Context ctx, LogicalRegion handle, LogicalRegion parent,
                        const std::set<FieldID> &fields, const T &value,
                        Predicate pred = Predicate::TRUE_PRED);
 
      void fill_fields(Context ctx, LogicalRegion handle, LogicalRegion parent,
                       const std::set<FieldID> &fields, 
                       const void *value, size_t value_size,
                       Predicate pred = Predicate::TRUE_PRED);
 
      void fill_fields(Context ctx, LogicalRegion handle, LogicalRegion parent,
                       const std::set<FieldID> &fields,
                       Future f, Predicate pred = Predicate::TRUE_PRED);
 
      void fill_fields(Context ctx, const FillLauncher &launcher);
 
      void fill_fields(Context ctx, const IndexFillLauncher &launcher);
 
      void discard_fields(Context ctx, const DiscardLauncher &launcher);
    public:
      //------------------------------------------------------------------------
      // Attach Operations
      //------------------------------------------------------------------------
 
      PhysicalRegion attach_external_resource(Context ctx, 
                                              const AttachLauncher &launcher);
 
      Future detach_external_resource(Context ctx, PhysicalRegion region,
                                      const bool flush = true,
                                      const bool unordered = false,
                                      const char *provenance = NULL);
 
      ExternalResources attach_external_resources(Context ctx,
                                     const IndexAttachLauncher &launcher);
 
      Future detach_external_resources(Context ctx, ExternalResources external,
                                       const bool flush = true,
                                       const bool unordered = false,
                                       const char *provenance = NULL);
 
      void progress_unordered_operations(Context ctx);
 
      LEGION_DEPRECATED("Attaching specific HDF5 file type is deprecated "
                        "in favor of generic attach launcher interface.")
      PhysicalRegion attach_hdf5(Context ctx, const char *file_name,
                                 LogicalRegion handle, LogicalRegion parent, 
                                 const std::map<FieldID,const char*> &field_map,
                                 LegionFileMode mode);
 
      LEGION_DEPRECATED("Detaching specific HDF5 file type is deprecated "
                        "in favor of generic detach interface.")
      void detach_hdf5(Context ctx, PhysicalRegion region);
 
      LEGION_DEPRECATED("Attaching generic file type is deprecated "
                        "in favor of generic attach launcher interface.")
      PhysicalRegion attach_file(Context ctx, const char *file_name,
                                 LogicalRegion handle, LogicalRegion parent,
                                 const std::vector<FieldID> &field_vec,
                                 LegionFileMode mode);
 
      LEGION_DEPRECATED("Detaching generic file type is deprecated "
                        "in favor of generic detach interface.")
      void detach_file(Context ctx, PhysicalRegion region);
    public:
      //------------------------------------------------------------------------
      // Copy Operations
      //------------------------------------------------------------------------
      void issue_copy_operation(Context ctx, const CopyLauncher &launcher);
 
      void issue_copy_operation(Context ctx, const IndexCopyLauncher &launcher);
    public:
      //------------------------------------------------------------------------
      // Predicate Operations
      //------------------------------------------------------------------------
      Predicate create_predicate(Context ctx, const Future &f,
                                 const char *provenance = NULL);
 
      Predicate predicate_not(Context ctx, const Predicate &p,
                              const char *provenance = NULL);
 
      Predicate predicate_and(Context ctx,
                              const Predicate &p1, const Predicate &p2,
                              const char *provenance = NULL);
 
      Predicate predicate_or(Context ctx,
                             const Predicate &p1, const Predicate &p2,
                             const char *provenance = NULL);
 
      Predicate create_predicate(Context ctx,const PredicateLauncher &launcher);
 
      Future get_predicate_future(Context ctx, const Predicate &p,
                                  const char *provenance = NULL);
    public:
      //------------------------------------------------------------------------
      // Lock Operations
      //------------------------------------------------------------------------
      Lock create_lock(Context ctx);
 
      void destroy_lock(Context ctx, Lock l);
 
      Grant acquire_grant(Context ctx, 
                          const std::vector<LockRequest> &requests);
 
      void release_grant(Context ctx, Grant grant);
    public:
      //------------------------------------------------------------------------
      // Phase Barrier operations
      //------------------------------------------------------------------------
      PhaseBarrier create_phase_barrier(Context ctx, unsigned arrivals);
 
      void destroy_phase_barrier(Context ctx, PhaseBarrier pb);
 
      PhaseBarrier advance_phase_barrier(Context ctx, PhaseBarrier pb);
    public:
      //------------------------------------------------------------------------
      // Dynamic Collective operations
      //------------------------------------------------------------------------
      DynamicCollective create_dynamic_collective(Context ctx, 
                                                  unsigned arrivals,
                                                  ReductionOpID redop,
                                                  const void *init_value,
                                                  size_t init_size);
 
      void destroy_dynamic_collective(Context ctx, DynamicCollective dc);
 
      void arrive_dynamic_collective(Context ctx,
                                     DynamicCollective dc,
                                     const void *buffer, 
                                     size_t size, unsigned count = 1);
 
      void defer_dynamic_collective_arrival(Context ctx, 
                                            DynamicCollective dc,
                                            const Future &f,
                                            unsigned count = 1);
 
      Future get_dynamic_collective_result(Context ctx, DynamicCollective dc,
                                           const char *provenance = NULL); 
 
      DynamicCollective advance_dynamic_collective(Context ctx, 
                                                   DynamicCollective dc);
    public:
      //------------------------------------------------------------------------
      // User-Managed Software Coherence 
      //------------------------------------------------------------------------
      void issue_acquire(Context ctx, const AcquireLauncher &launcher);
 
      void issue_release(Context ctx, const ReleaseLauncher &launcher);
    public:
      //------------------------------------------------------------------------
      // Fence Operations 
      //------------------------------------------------------------------------
      Future issue_mapping_fence(Context ctx, const char *provenance = NULL);
 
      Future issue_execution_fence(Context ctx, const char *provenance = NULL);
    public:
      //------------------------------------------------------------------------
      // Tracing Operations 
      //------------------------------------------------------------------------
      void begin_trace(Context ctx, TraceID tid, bool logical_only = false,
       bool static_trace = false, const std::set<RegionTreeID> *managed = NULL,
       const char *provenance = NULL);
      void end_trace(Context ctx, TraceID tid, const char *provenance = NULL);
      LEGION_DEPRECATED("Use begin_trace with static_trace=true")
      void begin_static_trace(Context ctx, 
                              const std::set<RegionTreeID> *managed = NULL);
      LEGION_DEPRECATED("Use end_trace")
      void end_static_trace(Context ctx);
 
      TraceID generate_dynamic_trace_id(void);
 
      TraceID generate_library_trace_ids(const char *name, size_t count);
 
      static TraceID generate_static_trace_id(void);
    public:
      //------------------------------------------------------------------------
      // Frame Operations 
      //------------------------------------------------------------------------
      void complete_frame(Context ctx, const char *provenance = NULL);
    public:
      //------------------------------------------------------------------------
      // Must Parallelism 
      //------------------------------------------------------------------------
      FutureMap execute_must_epoch(Context ctx, 
                                   const MustEpochLauncher &launcher);
    public:
      //------------------------------------------------------------------------
      // Tunable Variables 
      //------------------------------------------------------------------------
 
      Future select_tunable_value(Context ctx, TunableID tid,
                                  MapperID mapper = 0, MappingTagID tag = 0,
                                  const void *args = NULL, size_t argsize = 0);
      Future select_tunable_value(Context ctx, const TunableLauncher &launcher);
 
      LEGION_DEPRECATED("Tunable values should now be obtained via the "
                        "generic interface that returns a future result.")
      int get_tunable_value(Context ctx, TunableID tid, 
                            MapperID mapper = 0, MappingTagID tag = 0);
    public:
      //------------------------------------------------------------------------
      // Task Local Interface
      //------------------------------------------------------------------------
      const Task* get_local_task(Context ctx);
 
      void* get_local_task_variable_untyped(Context ctx, LocalVariableID id);
      template<typename T>
      T* get_local_task_variable(Context ctx, LocalVariableID id);
 
      void set_local_task_variable_untyped(Context ctx, LocalVariableID id, 
          const void *value, void (*destructor)(void*) = NULL);
      template<typename T>
      void set_local_task_variable(Context ctx, LocalVariableID id,
          const T* value, void (*destructor)(void*) = NULL);
    public:
      //------------------------------------------------------------------------
      // Timing Operations 
      //------------------------------------------------------------------------
      Future get_current_time(Context ctx, Future precondition = Future());
 
      Future get_current_time_in_microseconds(Context ctx, 
                                              Future precondition = Future());
 
      Future get_current_time_in_nanoseconds(Context ctx,
                                             Future precondition = Future());
 
      Future issue_timing_measurement(Context ctx, 
                                      const TimingLauncher &launcher);
 
      static long long get_zero_time(void);
    public:
      //------------------------------------------------------------------------
      // Miscellaneous Operations
      //------------------------------------------------------------------------
      Mapping::Mapper* get_mapper(Context ctx, MapperID id, 
                                  Processor target = Processor::NO_PROC);
 
      Mapping::MapperContext begin_mapper_call(Context ctx, MapperID id,
                                      Processor target = Processor::NO_PROC);
 
      void end_mapper_call(Mapping::MapperContext ctx);
      
      Processor get_executing_processor(Context ctx);
 
      const Task* get_current_task(Context ctx);
 
      size_t query_available_memory(Context ctx, Memory target);
 
      void release_memory_pool(Context ctx, Memory target);
 
      void raise_region_exception(Context ctx, PhysicalRegion region, 
                                  bool nuclear);
 
      void yield(Context ctx);
 
      void concurrent_task_barrier(Context ctx);
 
      void start_profiling_range(Context ctx);
      void stop_profiling_range(Context ctx, const char *provenance);
    public:
      //------------------------------------------------------------------------
      // MPI Interoperability 
      //------------------------------------------------------------------------
      bool is_MPI_interop_configured(void);
 
      const std::map<int/*rank*/,AddressSpace>& find_forward_MPI_mapping(void);
 
      const std::map<AddressSpace,int/*rank*/>& find_reverse_MPI_mapping(void);
 
      int find_local_MPI_rank(void);
    public:
      //------------------------------------------------------------------------
      // Semantic Information 
      //------------------------------------------------------------------------
      void attach_semantic_information(TaskID task_id, SemanticTag tag,
                     const void *buffer, size_t size, 
                     bool is_mutable = false, bool local_only = false);
 
      void attach_semantic_information(IndexSpace handle, SemanticTag tag,
                     const void *buffer, size_t size, bool is_mutable = false);
 
      void attach_semantic_information(IndexPartition handle, SemanticTag tag,
                     const void *buffer, size_t size, bool is_mutable = false);
 
      void attach_semantic_information(FieldSpace handle, SemanticTag tag,
                     const void *buffer, size_t size, bool is_mutable = false);
 
      void attach_semantic_information(FieldSpace handle, FieldID fid, 
                                       SemanticTag tag, const void *buffer, 
                                       size_t size, bool is_mutable = false);
 
      void attach_semantic_information(LogicalRegion handle, SemanticTag tag,
                     const void *buffer, size_t size, bool is_mutable = false);
      
      void attach_semantic_information(LogicalPartition handle, 
                                       SemanticTag tag, const void *buffer, 
                                       size_t size, bool is_mutable = false);
 
      void attach_name(TaskID task_id, const char *name, 
                       bool is_mutable = false,
                       bool local_only = false);
 
      void attach_name(IndexSpace handle, const char *name,
                       bool is_mutable = false);
 
      void attach_name(IndexPartition handle, const char *name,
                       bool is_mutable = false);
 
      void attach_name(FieldSpace handle, const char *name,
                       bool is_mutable = false);
 
      void attach_name(FieldSpace handle, FieldID fid, 
                       const char *name, bool is_mutable = false);
 
      void attach_name(LogicalRegion handle, const char *name,
                       bool is_mutable = false);
 
      void attach_name(LogicalPartition handle, const char *name,
                       bool is_mutable = false);
 
      bool retrieve_semantic_information(TaskID task_id, SemanticTag tag,
                                         const void *&result, size_t &size,
                                         bool can_fail = false,
                                         bool wait_until_ready = false);
 
      bool retrieve_semantic_information(IndexSpace handle, SemanticTag tag,
                                         const void *&result, size_t &size,
                                         bool can_fail = false,
                                         bool wait_until_ready = false);
 
      bool retrieve_semantic_information(IndexPartition handle, SemanticTag tag,
                                         const void *&result, size_t &size,
                                         bool can_fail = false,
                                         bool wait_until_ready = false);
 
      bool retrieve_semantic_information(FieldSpace handle, SemanticTag tag,
                                         const void *&result, size_t &size,
                                         bool can_fail = false,
                                         bool wait_until_ready = false);
 
      bool retrieve_semantic_information(FieldSpace handle, FieldID fid, 
                                         SemanticTag tag,
                                         const void *&result, size_t &size,
                                         bool can_fail = false,
                                         bool wait_until_ready = false);
 
      bool retrieve_semantic_information(LogicalRegion handle, SemanticTag tag,
                                         const void *&result, size_t &size,
                                         bool can_fail = false,
                                         bool wait_until_ready = false);
 
      bool retrieve_semantic_information(LogicalPartition handle, 
                                         SemanticTag tag,
                                         const void *&result, size_t &size,
                                         bool can_fail = false,
                                         bool wait_until_ready = false);
 
      void retrieve_name(TaskID task_id, const char *&result);
 
      void retrieve_name(IndexSpace handle, const char *&result);
 
      void retrieve_name(IndexPartition handle, const char *&result);
 
      void retrieve_name(FieldSpace handle, const char *&result);
 
      void retrieve_name(FieldSpace handle, FieldID fid, const char *&result);
 
      void retrieve_name(LogicalRegion handle, const char *&result);
 
      void retrieve_name(LogicalPartition handle, const char *&result);
 
    public:
      //------------------------------------------------------------------------
      // Printing operations, these are useful for only generating output
      // from a single task if the task has been replicated (either directly
      // or as part of control replication).
      //------------------------------------------------------------------------
      void print_once(Context ctx, FILE *f, const char *message);
 
      void log_once(Context ctx, Realm::LoggerMessage &message);
    public:
      //------------------------------------------------------------------------
      // Registration Callback Operations
      // All of these calls must be made while in the registration
      // function called before start-up.  This function is specified
      // by calling the 'set_registration_callback' static method.
      //------------------------------------------------------------------------
      
      Mapping::MapperRuntime* get_mapper_runtime(void);
 
      MapperID generate_dynamic_mapper_id(void);
 
      MapperID generate_library_mapper_ids(const char *name, size_t count);
 
      static MapperID generate_static_mapper_id(void);
 
      void add_mapper(MapperID map_id, Mapping::Mapper *mapper, 
                      Processor proc = Processor::NO_PROC);
      
      void replace_default_mapper(Mapping::Mapper *mapper, 
                                  Processor proc = Processor::NO_PROC);
 
    public:
      ProjectionID generate_dynamic_projection_id(void);
 
      ProjectionID generate_library_projection_ids(const char *name, 
                                                   size_t count);
 
      static ProjectionID generate_static_projection_id(void);
 
      void register_projection_functor(ProjectionID pid, 
                                       ProjectionFunctor *functor,
                                       bool silence_warnings = false,
                                       const char *warning_string = NULL);
 
      static void preregister_projection_functor(ProjectionID pid,
                                                 ProjectionFunctor *functor);
 
      static ProjectionFunctor* get_projection_functor(ProjectionID pid);
 
      ShardingID generate_dynamic_sharding_id(void);
 
      ShardingID generate_library_sharding_ids(const char *name, size_t count);
 
      static ShardingID generate_static_sharding_id(void);
      
      void register_sharding_functor(ShardingID sid,
                                     ShardingFunctor *functor,
                                     bool silence_warnings = false,
                                     const char *warning_string = NULL);
 
      static void preregister_sharding_functor(ShardingID sid,
                                               ShardingFunctor *functor);
 
      static ShardingFunctor* get_sharding_functor(ShardingID sid);
 
      ConcurrentID generate_dynamic_concurrent_id(void);
 
      ConcurrentID generate_library_concurrent_ids(const char *name, 
                                                   size_t count);
 
      static ConcurrentID generate_static_concurrent_id(void);
 
      void register_concurrent_coloring_functor(ConcurrentID cid,
                                     ConcurrentColoringFunctor *functor,
                                     bool silence_warnings = false,
                                     const char *warning_string = NULL);
 
      static void preregister_concurrent_coloring_functor(ConcurrentID cid,
                                       ConcurrentColoringFunctor *functor);
 
      static ConcurrentColoringFunctor* get_concurrent_coloring_functor(
                                                        ConcurrentID cid);
    public:
      ReductionOpID generate_dynamic_reduction_id(void);
 
      ReductionOpID generate_library_reduction_ids(const char *name, 
                                                   size_t count);
 
      static ReductionOpID generate_static_reduction_id(void);
 
      template<typename REDOP>
      static void register_reduction_op(ReductionOpID redop_id,
                                        bool permit_duplicates = false);
 
      static void register_reduction_op(ReductionOpID redop_id,
                                        ReductionOp *op,
                                        SerdezInitFnptr init_fnptr = NULL,
                                        SerdezFoldFnptr fold_fnptr = NULL,
                                        bool permit_duplicates = false);
 
      static const ReductionOp* get_reduction_op(ReductionOpID redop_id);
 
#ifdef LEGION_GPU_REDUCTIONS
      template<typename REDOP>
        LEGION_DEPRECATED("Use register_reduction_op instead")
      static void preregister_gpu_reduction_op(ReductionOpID redop_id);
#endif
    public:
      CustomSerdezID generate_dynamic_serdez_id(void);
 
      CustomSerdezID generate_library_serdez_ids(const char *name, 
                                                 size_t count);
 
      static CustomSerdezID generate_static_serdez_id(void);
      
      template<typename SERDEZ>
      static void register_custom_serdez_op(CustomSerdezID serdez_id,
                                            bool permit_duplicates = false);
 
      static void register_custom_serdez_op(CustomSerdezID serdez_id,
                                            SerdezOp *serdez_op, 
                                            bool permit_duplicates = false);
 
      static const SerdezOp* get_serdez_op(CustomSerdezID serdez_id);
    public:
      //------------------------------------------------------------------------
      // Start-up Operations
      // Everything below here is a static function that is used to configure
      // the runtime prior to calling the start method to begin execution.
      //------------------------------------------------------------------------
    public:
      static const char* get_legion_version(void);
 
      static int start(int argc, char **argv, bool background = false,
                       bool supply_default_mapper = true, bool filter = false);
 
      static void initialize(int *argc, char ***argv, 
                             bool filter = false, bool parse = true);
 
      static int wait_for_shutdown(void);  
 
      static void set_return_code(int return_code);
      
      static void set_top_level_task_id(TaskID top_id);
 
      static void set_top_level_task_mapper_id(MapperID mapper_id);
 
      Future launch_top_level_task(const TaskLauncher &launcher);
 
      Context begin_implicit_task(TaskID top_task_id,
                                  MapperID mapper_id,
                                  Processor::Kind proc_kind,
                                  const char *task_name = NULL,
                                  bool control_replicable = false,
                                  unsigned shard_per_address_space = 1,
                                  int shard_id = -1,
                                  DomainPoint shard_point = DomainPoint());
 
      void unbind_implicit_task_from_external_thread(Context ctx);
 
      void bind_implicit_task_to_external_thread(Context ctx);
 
      void finish_implicit_task(Context ctx,
                                Realm::Event effects = Realm::Event::NO_EVENT);
 
      static size_t get_maximum_dimension(void);
 
      static void configure_MPI_interoperability(int rank);
 
      static LegionHandshake create_external_handshake(bool init_in_ext = true,
                                                   int ext_participants = 1,
                                                   int legion_participants = 1);
 
      static MPILegionHandshake create_handshake(bool init_in_MPI = true,
                                                 int mpi_participants = 1,
                                                 int legion_participants = 1);
 
      template<LogicalRegion (*PROJ_PTR)(LogicalRegion, const DomainPoint&,
                                         Runtime*)>
      LEGION_DEPRECATED("Projection functions should now be specified "
                        "using projection functor objects")
      static ProjectionID register_region_function(ProjectionID handle);
 
      template<LogicalRegion (*PROJ_PTR)(LogicalPartition, const DomainPoint&,
                                         Runtime*)>
      LEGION_DEPRECATED("Projection functions should now be specified "
                        "using projection functor objects")
      static ProjectionID register_partition_function(ProjectionID handle);
    public:
      static void add_registration_callback(RegistrationCallbackFnptr callback,
                                      bool dedup = true, size_t dedup_tag = 0);
      static void add_registration_callback(
       RegistrationWithArgsCallbackFnptr callback, const UntypedBuffer &buffer,
                                      bool dedup = true, size_t dedup_tag = 0);
 
      static void perform_registration_callback(
                               RegistrationCallbackFnptr callback, bool global,
                               bool deduplicate = true, size_t dedup_tag = 0);
      static void perform_registration_callback(
                               RegistrationWithArgsCallbackFnptr callback,
                               const UntypedBuffer &buffer, bool global,
                               bool deduplicate = true , size_t dedup_tag = 0);
 
      LEGION_DEPRECATED("Legion now supports multiple registration callbacks "
                        "added via the add_registration_callback method.") 
      static void set_registration_callback(RegistrationCallbackFnptr callback);
 
      static const InputArgs& get_input_args(void);
    public:
      static void enable_profiling(void);
      static void disable_profiling(void);
      static void dump_profiling(void);
    public:
      //------------------------------------------------------------------------
      // Layout Registration Operations
      //------------------------------------------------------------------------
      LayoutConstraintID register_layout(
                                    const LayoutConstraintRegistrar &registrar);
 
      void release_layout(LayoutConstraintID layout_id);
 
      static LayoutConstraintID preregister_layout(
                               const LayoutConstraintRegistrar &registrar,
                               LayoutConstraintID layout_id = 
                                                    LEGION_AUTO_GENERATE_ID);
 
      FieldSpace get_layout_constraint_field_space(
                                  LayoutConstraintID layout_id);
 
      void get_layout_constraints(LayoutConstraintID layout_id,
                                  LayoutConstraintSet &layout_constraints);
 
      const char* get_layout_constraints_name(LayoutConstraintID layout_id);
    public:
      //------------------------------------------------------------------------
      // Task Registration Operations
      //------------------------------------------------------------------------
      
      TaskID generate_dynamic_task_id(void);
 
      TaskID generate_library_task_ids(const char *name, size_t count);
 
      static TaskID generate_static_task_id(void);
 
      template<typename T,
        T (*TASK_PTR)(const Task*, const std::vector<PhysicalRegion>&,
                      Context, Runtime*)>
      VariantID register_task_variant(const TaskVariantRegistrar &registrar,
                                      VariantID vid = LEGION_AUTO_GENERATE_ID);
 
      template<typename T, typename UDT,
        T (*TASK_PTR)(const Task*, const std::vector<PhysicalRegion>&,
                      Context, Runtime*, const UDT&)>
      VariantID register_task_variant(const TaskVariantRegistrar &registrar,
                                      const UDT &user_data,
                                      VariantID vid = LEGION_AUTO_GENERATE_ID);
 
      template<
        void (*TASK_PTR)(const Task*, const std::vector<PhysicalRegion>&,
                         Context, Runtime*)>
      VariantID register_task_variant(const TaskVariantRegistrar &registrar,
                                      VariantID vid = LEGION_AUTO_GENERATE_ID);
 
      template<typename UDT,
        void (*TASK_PTR)(const Task*, const std::vector<PhysicalRegion>&,
                         Context, Runtime*, const UDT&)>
      VariantID register_task_variant(const TaskVariantRegistrar &registrar,
                                      const UDT &user_data,
                                      VariantID vid = LEGION_AUTO_GENERATE_ID);
 
      VariantID register_task_variant(const TaskVariantRegistrar &registrar,
                      const CodeDescriptor &codedesc,
                      const void *user_data = NULL,
                      size_t user_len = 0,
                                      size_t return_type_size = 
                                                      LEGION_MAX_RETURN_SIZE,
                                      VariantID vid = LEGION_AUTO_GENERATE_ID,
                                      bool has_return_type_size = true);
 
      template<typename T,
        T (*TASK_PTR)(const Task*, const std::vector<PhysicalRegion>&,
                      Context, Runtime*)>
      static VariantID preregister_task_variant(
                                    const TaskVariantRegistrar &registrar,
                                    const char *task_name = NULL,
                                    VariantID vid = LEGION_AUTO_GENERATE_ID);
 
      template<typename T, typename UDT,
        T (*TASK_PTR)(const Task*, const std::vector<PhysicalRegion>&,
                      Context, Runtime*, const UDT&)>
      static VariantID preregister_task_variant(
                      const TaskVariantRegistrar &registrar, 
                      const UDT &user_data,
                      const char *task_name = NULL,
                      VariantID vid = LEGION_AUTO_GENERATE_ID);
       
      template<
        void (*TASK_PTR)(const Task*, const std::vector<PhysicalRegion>&,
                         Context, Runtime*)>
      static VariantID preregister_task_variant(
                                    const TaskVariantRegistrar &registrar,
                                    const char *task_name = NULL,
                                    VariantID vid = LEGION_AUTO_GENERATE_ID);
 
      template<typename UDT,
        void (*TASK_PTR)(const Task*, const std::vector<PhysicalRegion>&,
                         Context, Runtime*, const UDT&)>
      static VariantID preregister_task_variant(
              const TaskVariantRegistrar &registrar, const UDT &user_data, 
              const char *task_name = NULL, 
              VariantID vid = LEGION_AUTO_GENERATE_ID);
 
      static VariantID preregister_task_variant(
              const TaskVariantRegistrar &registrar,
          const CodeDescriptor &codedesc,
          const void *user_data = NULL,
          size_t user_len = 0,
          const char *task_name = NULL,
              VariantID vid = LEGION_AUTO_GENERATE_ID,
              size_t return_type_size = LEGION_MAX_RETURN_SIZE,
              bool has_return_type_size = true,
              bool check_task_id = true);
 
      static void legion_task_preamble(const void *data, size_t datalen,
                                       Processor p, const Task *& task,
                                       const std::vector<PhysicalRegion> *& reg,
                                       Context& ctx, Runtime *& runtime);
 
      static void legion_task_postamble(Context ctx,
                                        const void *retvalptr = NULL,
                                        size_t retvalsize = 0,
                                        bool owned = false,
                                        Realm::RegionInstance inst = 
                                          Realm::RegionInstance::NO_INST,
                                        const void *metadataptr = NULL,
                                        size_t metadatasize = 0);
 
      static void legion_task_postamble(Context ctx,
            const void *retvalptr, size_t retvalsize, bool owned,
            const Realm::ExternalInstanceResource &allocation,
            void (*freefunc)(const Realm::ExternalInstanceResource&) = NULL,
            const void *metadataptr = NULL, size_t metadatasize = 0);
 
      static void legion_task_postamble(Context ctx,
                                        FutureFunctor *callback_functor,
                                        bool owned = false);
 
      static void legion_task_postamble(Context ctx,
          const Domain &domain, bool take_ownership,
          const void *metadataptr = NULL, size_t metadatasize = 0);
    public:
      // ------------------ Deprecated task registration -----------------------
      template<typename T,
        T (*TASK_PTR)(const Task*, const std::vector<PhysicalRegion>&,
                      Context, Runtime*)>
      LEGION_DEPRECATED("Task registration should be done with "
                        "a TaskVariantRegistrar") 
      static TaskID register_legion_task(TaskID id, Processor::Kind proc_kind,
                                         bool single, bool index, 
                                         VariantID vid =LEGION_AUTO_GENERATE_ID,
                              TaskConfigOptions options = TaskConfigOptions(),
                                         const char *task_name = NULL);
      template<
        void (*TASK_PTR)(const Task*, const std::vector<PhysicalRegion>&,
                         Context, Runtime*)>
      LEGION_DEPRECATED("Task registration should be done with "
                        "a TaskVariantRegistrar")
      static TaskID register_legion_task(TaskID id, Processor::Kind proc_kind,
                                         bool single, bool index,
                                         VariantID vid =LEGION_AUTO_GENERATE_ID,
                             TaskConfigOptions options = TaskConfigOptions(),
                                         const char *task_name = NULL);
      template<typename T, typename UDT,
        T (*TASK_PTR)(const Task*, const std::vector<PhysicalRegion>&,
                      Context, Runtime*, const UDT&)>
      LEGION_DEPRECATED("Task registration should be done with "
                        "a TaskVariantRegistrar")
      static TaskID register_legion_task(TaskID id, Processor::Kind proc_kind,
                                         bool single, bool index,
                                         const UDT &user_data,
                                         VariantID vid =LEGION_AUTO_GENERATE_ID,
                              TaskConfigOptions options = TaskConfigOptions(),
                                         const char *task_name = NULL);
      template<typename UDT,
        void (*TASK_PTR)(const Task*,const std::vector<PhysicalRegion>&,
                         Context, Runtime*, const UDT&)>
      LEGION_DEPRECATED("Task registration should be done with "
                        "a TaskVariantRegistrar")
      static TaskID register_legion_task(TaskID id, Processor::Kind proc_kind,
                                         bool single, bool index,
                                         const UDT &user_data,
                                         VariantID vid =LEGION_AUTO_GENERATE_ID,
                              TaskConfigOptions options = TaskConfigOptions(),
                                         const char *task_name = NULL);
    public:
      static bool has_runtime(void);
 
      static Runtime* get_runtime(Processor p = Processor::NO_PROC);
 
      static bool has_context(void);
 
      static Context get_context(void);
 
      static const Task* get_context_task(Context ctx);
    private:
      IndexPartition create_restricted_partition(Context ctx,
                                      IndexSpace parent,
                                      IndexSpace color_space,
                                      const void *transform,
                                      size_t transform_size,
                                      const void *extent, 
                                      size_t extent_size,
                                      PartitionKind part_kind, Color color,
                                      const char *provenance);
      IndexSpace create_index_space_union_internal(Context ctx,
                                      IndexPartition parent,
                                      const void *realm_color,size_t color_size,
                                      TypeTag type_tag, const char *provenance,
                                      const std::vector<IndexSpace> &handles);
      IndexSpace create_index_space_union_internal(Context ctx, 
                                      IndexPartition parent, 
                                      const void *realm_color,size_t color_size,
                                      TypeTag type_tag, const char *provenance,
                                      IndexPartition handle);
      IndexSpace create_index_space_intersection_internal(Context ctx,
                                      IndexPartition parent,
                                      const void *realm_color,size_t color_size,
                                      TypeTag type_tag, const char *provenance,
                                      const std::vector<IndexSpace> &handles);
      IndexSpace create_index_space_intersection_internal(Context ctx, 
                                      IndexPartition parent, 
                                      const void *realm_color,size_t color_size,
                                      TypeTag type_tag, const char *provenance,
                                      IndexPartition handle);
      IndexSpace create_index_space_difference_internal(Context ctx,
                                      IndexPartition paretn,
                                      const void *realm_color, size_t color_size,
                                      TypeTag type_tag, const char *provenance,
                                      IndexSpace initial,
                                      const std::vector<IndexSpace> &handles);
      IndexSpace get_index_subspace_internal(IndexPartition handle, 
                                      const void *realm_color,TypeTag type_tag);
      bool has_index_subspace_internal(IndexPartition handle,
                                      const void *realm_color,TypeTag type_tag);
      void get_index_partition_color_space_internal(IndexPartition handle,
                                      void *realm_is, TypeTag type_tag);
      void get_index_space_domain_internal(IndexSpace handle, 
                                      void *realm_is, TypeTag type_tag);
      void get_index_space_color_internal(IndexSpace handle,
                                      void *realm_color, TypeTag type_tag);
      bool safe_cast_internal(Context ctx, LogicalRegion region,
                                      const void *realm_point,TypeTag type_tag);
      LogicalRegion get_logical_subregion_by_color_internal(
                                      LogicalPartition parent,
                                      const void *realm_color,TypeTag type_tag);
      bool has_logical_subregion_by_color_internal(
                                      LogicalPartition parent,
                                      const void *realm_color,TypeTag type_tag);
    private:
      // Methods for the wrapper functions to get information from the runtime
      friend class LegionTaskWrapper;
      friend class LegionSerialization;
    public:
      // This method is hidden down here and not publicly documented because
      // users shouldn't really need it for anything, however there are some
      // reasonable cases where it might be utilitized for things like doing
      // file I/O or printf that people might want it for so we've got it
      ShardID get_shard_id(Context ctx, bool I_know_what_I_am_doing = false);
      // We'll also allow users to get the total number of shards in the context
      // if they also ar willing to attest they know what they are doing
      size_t get_num_shards(Context ctx, bool I_know_what_I_am_doing = false);
      // This is another hidden method for control replication because it's
      // still somewhat experimental. In some cases there are unavoidable 
      // sources of randomness that can mess with the needed invariants for
      // control replication (e.g. garbage collectors). This method will 
      // allow the application to pass in an array of elements from each shard
      // and the runtime will fill in an output buffer with an ordered array of 
      // elements that were passed in by every shard. Each shard will get the 
      // same elements that were present in all the other shards in the same
      // order in the output array. The number of elements in the output buffer 
      // is returned as a future (of type size_t) as the runtime will return 
      // immediately and the application can continue running ahead. The 
      // application must keep the input and output buffers allocated until 
      // the future resolves. By definition the output buffer need be no bigger
      // than the input buffer since only elements that are in the input buffer
      // on any shard can appear in the output buffer. Note you can use this 
      // method safely in contexts that are not control replicated as well: 
      // the input will just be mem-copied to the output and num_elements 
      // returned as the future result.
      Future consensus_match(Context ctx, const void *input, void *output,
       size_t num_elements, size_t element_size, const char *provenance = NULL);
    private:
      friend class Mapper;
      Internal::Runtime *runtime;
    };
 
}; // namespace Legion
 
#include "legion/legion.inl"
 
// Include this here so we get the mapper interface in the header file
// We have to put it here though since the mapper interface depends
// on the rest of the legion interface
#include "legion/legion_mapping.h"
 
#endif // __LEGION_RUNTIME_H__
#endif // defined LEGION_ENABLE_CXX_BINDINGS
 
// EOF