data.h

Go to the documentation of this file.

/* Copyright 2026 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.
 */
 
#ifndef __LEGION_DATA_H__
#define __LEGION_DATA_H__
 
#include "legion/api/types.h"
 
namespace Legion {
 
  class IndexSpace {
  public:
    static const IndexSpace NO_SPACE; 
  protected:
    // Only the runtime should be allowed to make these
    FRIEND_ALL_RUNTIME_CLASSES
    IndexSpace(DistributedID 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 DistributedID get_id(bool filter = true) const;
    inline IndexTreeID get_tree_id(void) const { return tid; }
    inline bool exists(void) const { return (did != 0); }
    inline TypeTag get_type_tag(void) const { return type_tag; }
    inline int get_dim(void) const;
    bool valid(void) const;
  protected:
    friend std::ostream& operator<<(std::ostream& os, const IndexSpace& is);
    DistributedID did;
    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(DIM <= LEGION_MAX_DIM, "DIM must be <= LEGION_MAX_DIM");
    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(DistributedID 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(DistributedID 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 DistributedID get_id(bool filter = true) const;
    inline IndexTreeID get_tree_id(void) const { return tid; }
    inline bool exists(void) const { return (did != 0); }
    inline TypeTag get_type_tag(void) const { return type_tag; }
    inline int get_dim(void) const;
    bool valid(void) const;
  protected:
    friend std::ostream& operator<<(std::ostream& os, const IndexPartition& ip);
    DistributedID did;
    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(DIM <= LEGION_MAX_DIM, "DIM must be <= LEGION_MAX_DIM");
    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(DistributedID 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(DistributedID 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 DistributedID get_id(bool filter = true) const;
    inline bool exists(void) const { return (did != 0); }
    bool valid(void) const;
  private:
    friend std::ostream& operator<<(std::ostream& os, const FieldSpace& fs);
    DistributedID did;
  };
 
  class LogicalRegion {
  public:
    static const LogicalRegion NO_REGION; 
  protected:
    // Only the runtime should be allowed to make these
    FRIEND_ALL_RUNTIME_CLASSES
    LogicalRegion(DistributedID 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(bool filter = true) const;
    inline bool exists(void) const { return (tree_did != 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(); }
    bool valid(void) const;
  protected:
    friend std::ostream& operator<<(std::ostream& os, const LogicalRegion& lr);
    // These are private so the user can't just arbitrarily change them
    DistributedID tree_did;
    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(DIM <= LEGION_MAX_DIM, "DIM must be <= LEGION_MAX_DIM");
    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(DistributedID 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(DistributedID 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(bool filter = true) const;
    inline bool exists(void) const { return (tree_did != 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(); }
    bool valid(void) const;
  protected:
    friend std::ostream& operator<<(
        std::ostream& os, const LogicalPartition& lp);
    // These are private so the user can't just arbitrary change them
    DistributedID tree_did;
    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(DIM <= LEGION_MAX_DIM, "DIM must be <= LEGION_MAX_DIM");
    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(DistributedID tid, IndexPartition pid, FieldSpace field);
  public:
    LogicalPartitionT(void);
    explicit LogicalPartitionT(const LogicalPartition& rhs);
  public:
    inline LogicalPartitionT& operator=(const LogicalPartition& rhs);
  };
 
  class FieldAllocator : public Unserializable {
  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 != nullptr); }
  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 = nullptr);
    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 = nullptr);
 
    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 = nullptr);
 
    FieldID allocate_local_field(
        size_t field_size, FieldID desired_fieldid = LEGION_AUTO_GENERATE_ID,
        CustomSerdezID serdez_id = 0, const char* provenance = nullptr);
 
    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 = nullptr);
    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 = nullptr);
 
    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 = nullptr);
    void allocate_local_fields(
        const std::vector<size_t>& field_sizes,
        std::vector<FieldID>& resulting_fields, CustomSerdezID serdez_id = 0,
        const char* provenance = nullptr);
    FieldSpace get_field_space(void) const;
  private:
    Internal::FieldAllocatorImpl* impl;
  };
 
}  // namespace Legion
 
#include "legion/api/data.inl"
 
#endif  // __LEGION_DATA_H__