requirements.h

/* 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_REQUIREMENTS_H__
#define __LEGION_REQUIREMENTS_H__
 
#include "legion/api/data.h"
 
namespace Legion {
 
  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& req);
    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 bounded = 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 bounded_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;
  };
 
}  // namespace Legion
 
#include "legion/api/requirements.inl"
 
#endif  // __LEGION_REQUIREMENTS_H__