constraints.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_CONSTRAINT_H__
#define __LEGION_CONSTRAINT_H__
 
#include "legion/api/types.h"
#include "legion/api/geometry.h"
 
// clang-format off
#define LEGION_EXECUTION_CONSTRAINT_KINDS(__op__)                         \
  __op__(LEGION_ISA_CONSTRAINT, "ISA")                                    \
  __op__(LEGION_PROCESSOR_CONSTRAINT, "Processor")                        \
  __op__(LEGION_RESOURCE_CONSTRAINT, "Resource")                          \
  __op__(LEGION_LAUNCH_CONSTRAINT, "Launch")                              \
  __op__(LEGION_COLOCATION_CONSTRAINT, "Co-Location")
 
#define LEGION_LAYOUT_CONSTRAINT_KINDS(__op__)                            \
  __op__(LEGION_SPECIALIZED_CONSTRAINT, "Specialized")                    \
  __op__(LEGION_MEMORY_CONSTRAINT, "Memory")                              \
  __op__(LEGION_FIELD_CONSTRAINT, "Field")                                \
  __op__(LEGION_ORDERING_CONSTRAINT, "Ordering")                          \
  __op__(LEGION_TILING_CONSTRAINT, "Tiling")                              \
  __op__(LEGION_DIMENSION_CONSTRAINT, "Dimension")                        \
  __op__(LEGION_ALIGNMENT_CONSTRAINT, "Alignment")                        \
  __op__(LEGION_OFFSET_CONSTRAINT, "Offset")                              \
  __op__(LEGION_POINTER_CONSTRAINT, "Pointer")                            \
  __op__(LEGION_PADDING_CONSTRAINT, "Padding")
// clang-format on
 
namespace Legion {
 
  class ISAConstraint {
  public:
    static const ExecutionConstraintKind constraint_kind =
        LEGION_ISA_CONSTRAINT;
  public:
    ISAConstraint(uint64_t prop = 0);
  public:
    inline bool operator==(const ISAConstraint& other) const
    {
      return isa_prop == other.isa_prop;
    }
    inline bool operator!=(const ISAConstraint& other) const
    {
      return !(*this == other);
    }
  public:
    bool entails(const ISAConstraint& other) const;
    bool conflicts(const ISAConstraint& other) const;
  public:
    void swap(ISAConstraint& rhs);
    void serialize(Serializer& rez) const;
    void deserialize(Deserializer& derez);
  public:
    uint64_t isa_prop;
  };
 
  class ProcessorConstraint {
  public:
    static const ExecutionConstraintKind constraint_kind =
        LEGION_PROCESSOR_CONSTRAINT;
  public:
    ProcessorConstraint(Processor::Kind kind = Processor::NO_KIND);
  public:
    inline bool operator==(const ProcessorConstraint& other) const
    {
      return valid_kinds == other.valid_kinds;
    }
    inline bool operator!=(const ProcessorConstraint& other) const
    {
      return !(*this == other);
    }
  public:
    inline bool is_valid(void) const { return !valid_kinds.empty(); }
    void add_kind(Processor::Kind kind);
    bool can_use(Processor::Kind kind) const;
  public:
    bool entails(const ProcessorConstraint& other) const;
    bool conflicts(const ProcessorConstraint& other) const;
  public:
    void swap(ProcessorConstraint& rhs);
    void serialize(Serializer& rez) const;
    void deserialize(Deserializer& derez);
  public:
    std::vector<Processor::Kind> valid_kinds;
  };
 
  class ResourceConstraint {
  public:
    static const ExecutionConstraintKind constraint_kind =
        LEGION_RESOURCE_CONSTRAINT;
  public:
    ResourceConstraint(void);
    ResourceConstraint(
        ResourceKind resource_kind, EqualityKind eq_kind, size_t value);
  public:
    bool operator==(const ResourceConstraint& other) const;
    inline bool operator!=(const ResourceConstraint& other) const
    {
      return !(*this == other);
    }
  public:
    bool entails(const ResourceConstraint& other) const;
    bool conflicts(const ResourceConstraint& other) const;
  public:
    void swap(ResourceConstraint& rhs);
    void serialize(Serializer& rez) const;
    void deserialize(Deserializer& derez);
  public:
    ResourceKind resource_kind;
    EqualityKind equality_kind;
    size_t value;
  };
 
  class LaunchConstraint {
  public:
    static const ExecutionConstraintKind constraint_kind =
        LEGION_LAUNCH_CONSTRAINT;
  public:
    LaunchConstraint(void);
    LaunchConstraint(LaunchKind kind, size_t value);
    LaunchConstraint(LaunchKind kind, const size_t* value, int dims);
  public:
    bool operator==(const LaunchConstraint& other) const;
    inline bool operator!=(const LaunchConstraint& other) const
    {
      return !(*this == other);
    }
  public:
    bool entails(const LaunchConstraint& other) const;
    bool conflicts(const LaunchConstraint& other) const;
  public:
    void swap(LaunchConstraint& rhs);
    void serialize(Serializer& rez) const;
    void deserialize(Deserializer& derez);
  public:
    LaunchKind launch_kind;
    size_t values[3];
    int dims;
  };
 
  class ColocationConstraint {
  public:
    static const ExecutionConstraintKind constraint_kind =
        LEGION_COLOCATION_CONSTRAINT;
  public:
    ColocationConstraint(void);
    ColocationConstraint(unsigned index1, unsigned index2);
    ColocationConstraint(unsigned index1, unsigned index2, FieldID fid);
    ColocationConstraint(
        unsigned index1, unsigned index2, const std::set<FieldID>& fields);
    ColocationConstraint(
        const std::vector<unsigned>& indexes, const std::set<FieldID>& fields);
  public:
    inline bool operator==(const ColocationConstraint& o) const
    {
      return fields == o.fields && indexes == o.indexes;
    }
    inline bool operator!=(const ColocationConstraint& other) const
    {
      return !(*this == other);
    }
  public:
    bool entails(const ColocationConstraint& other) const;
    bool conflicts(const ColocationConstraint& other) const;
  public:
    void swap(ColocationConstraint& rhs);
    void serialize(Serializer& rez) const;
    void deserialize(Deserializer& derez);
  public:
    std::set<FieldID> fields;
    std::set<unsigned> indexes;
  };
 
  class ExecutionConstraintSet {
  public:
    // Make sure these methods return ourself so we
    // can easily chain together adding constraints
    ExecutionConstraintSet& add_constraint(const ISAConstraint& constraint);
    ExecutionConstraintSet& add_constraint(
        const ProcessorConstraint& constraint);
    ExecutionConstraintSet& add_constraint(
        const ResourceConstraint& constraint);
    ExecutionConstraintSet& add_constraint(const LaunchConstraint& constraint);
    ExecutionConstraintSet& add_constraint(
        const ColocationConstraint& constraint);
  public:
    bool operator==(const ExecutionConstraintSet& other) const;
    inline bool operator!=(const ExecutionConstraintSet& other) const
    {
      return !(*this == other);
    }
  public:
    void swap(ExecutionConstraintSet& rhs);
    void serialize(Serializer& rez) const;
    void deserialize(Deserializer& derez);
  public:
    ISAConstraint isa_constraint;
    ProcessorConstraint processor_constraint;
    std::vector<ResourceConstraint> resource_constraints;
    std::vector<LaunchConstraint> launch_constraints;
    std::vector<ColocationConstraint> colocation_constraints;
  };
 
  class LayoutConstraint {
  public:
    virtual ~LayoutConstraint(void) { }
  public:
    virtual LayoutConstraintKind get_constraint_kind(void) const = 0;
  public:
    virtual SpecializedConstraint* as_specialized_constraint(void)
    {
      return nullptr;
    }
    virtual MemoryConstraint* as_memory_constraint(void) { return nullptr; }
    virtual FieldConstraint* as_field_constraint(void) { return nullptr; }
    virtual OrderingConstraint* as_ordering_constraint(void) { return nullptr; }
    virtual TilingConstraint* as_tiling_constraint(void) { return nullptr; }
    virtual DimensionConstraint* as_dimension_constraint(void)
    {
      return nullptr;
    }
    virtual AlignmentConstraint* as_alignment_constraint(void)
    {
      return nullptr;
    }
    virtual OffsetConstraint* as_offset_constraint(void) { return nullptr; }
    virtual PointerConstraint* as_pointer_constraint(void) { return nullptr; }
    virtual PaddingConstraint* as_padding_constraint(void) { return nullptr; }
  public:
    virtual const SpecializedConstraint* as_specialized_constraint(void) const
    {
      return nullptr;
    }
    virtual const MemoryConstraint* as_memory_constraint(void) const
    {
      return nullptr;
    }
    virtual const FieldConstraint* as_field_constraint(void) const
    {
      return nullptr;
    }
    virtual const OrderingConstraint* as_ordering_constraint(void) const
    {
      return nullptr;
    }
    virtual const TilingConstraint* as_tiling_constraint(void) const
    {
      return nullptr;
    }
    virtual const DimensionConstraint* as_dimension_constraint(void) const
    {
      return nullptr;
    }
    virtual const AlignmentConstraint* as_alignment_constraint(void) const
    {
      return nullptr;
    }
    virtual const OffsetConstraint* as_offset_constraint(void) const
    {
      return nullptr;
    }
    virtual const PointerConstraint* as_pointer_constraint(void) const
    {
      return nullptr;
    }
    virtual const PaddingConstraint* as_padding_constraint(void) const
    {
      return nullptr;
    }
  };
 
  class SpecializedConstraint : public LayoutConstraint {
  public:
    static const LayoutConstraintKind constraint_kind =
        LEGION_SPECIALIZED_CONSTRAINT;
  public:
    SpecializedConstraint(
        SpecializedKind kind = LEGION_AFFINE_SPECIALIZE,
        ReductionOpID redop = 0, bool no_access = false, bool exact = false,
        size_t max_pieces = SIZE_MAX, int max_overhead = 0);
  public:
    bool operator==(const SpecializedConstraint& other) const;
    inline bool operator!=(const SpecializedConstraint& other) const
    {
      return !(*this == other);
    }
  public:
    virtual LayoutConstraintKind get_constraint_kind(void) const override
    {
      return constraint_kind;
    }
    virtual SpecializedConstraint* as_specialized_constraint(void) override
    {
      return this;
    }
    virtual const SpecializedConstraint* as_specialized_constraint(
        void) const override
    {
      return this;
    }
  public:
    bool entails(const SpecializedConstraint& other) const;
    bool conflicts(const SpecializedConstraint& other) const;
  public:
    inline SpecializedKind get_kind(void) const { return kind; }
    inline ReductionOpID get_reduction_op(void) const { return redop; }
  public:
    void swap(SpecializedConstraint& rhs);
    void serialize(Serializer& rez) const;
    void deserialize(Deserializer& derez);
  public:
    bool is_affine(void) const;
    bool is_compact(void) const;
    bool is_virtual(void) const;
    bool is_reduction(void) const;
    bool is_file(void) const;
    inline bool is_no_access(void) const { return no_access; }
    inline bool is_exact(void) const { return exact; }
    // For backwards compatibility
    bool is_normal(void) const;
  public:
    SpecializedKind kind;
    ReductionOpID redop;
    size_t max_pieces;
    int max_overhead;
    bool no_access;
    bool exact;
  };
 
  class MemoryConstraint : public LayoutConstraint {
  public:
    static const LayoutConstraintKind constraint_kind =
        LEGION_MEMORY_CONSTRAINT;
  public:
    MemoryConstraint(void);
    MemoryConstraint(Memory::Kind kind);
  public:
    inline bool operator==(const MemoryConstraint& other) const
    {
      return kind == other.kind && has_kind == other.has_kind;
    }
    inline bool operator!=(const MemoryConstraint& other) const
    {
      return !(*this == other);
    }
  public:
    virtual LayoutConstraintKind get_constraint_kind(void) const override
    {
      return constraint_kind;
    }
    virtual MemoryConstraint* as_memory_constraint(void) override
    {
      return this;
    }
    virtual const MemoryConstraint* as_memory_constraint(void) const override
    {
      return this;
    }
  public:
    inline bool is_valid(void) const { return has_kind; }
    inline Memory::Kind get_kind(void) const { return kind; }
  public:
    bool entails(const MemoryConstraint& other) const;
    bool conflicts(const MemoryConstraint& other) const;
  public:
    void swap(MemoryConstraint& rhs);
    void serialize(Serializer& rez) const;
    void deserialize(Deserializer& derez);
  public:
    Memory::Kind kind;
    bool has_kind;
  };
 
  class FieldConstraint : public LayoutConstraint {
  public:
    static const LayoutConstraintKind constraint_kind = LEGION_FIELD_CONSTRAINT;
  public:
    FieldConstraint(bool contiguous = false, bool inorder = false);
    FieldConstraint(
        const std::vector<FieldID>& field_set, bool contiguous,
        bool inorder = true);
    FieldConstraint(
        const std::set<FieldID>& field_set, bool contiguous,
        bool inorder = true);
  public:
    bool operator==(const FieldConstraint& other) const;
    inline bool operator!=(const FieldConstraint& other) const
    {
      return !(*this == other);
    }
  public:
    virtual LayoutConstraintKind get_constraint_kind(void) const override
    {
      return constraint_kind;
    }
    virtual FieldConstraint* as_field_constraint(void) override { return this; }
    virtual const FieldConstraint* as_field_constraint(void) const override
    {
      return this;
    }
  public:
    inline bool is_contiguous(void) const { return contiguous; }
    inline bool is_inorder(void) const { return inorder; }
    inline const std::vector<FieldID>& get_field_set(void) const
    {
      return field_set;
    }
  public:
    bool entails(const FieldConstraint& other) const;
    bool conflicts(const FieldConstraint& other) const;
  public:
    void swap(FieldConstraint& rhs);
    void serialize(Serializer& rez) const;
    void deserialize(Deserializer& derez);
  public:
    std::vector<FieldID> field_set;
    bool contiguous;
    bool inorder;
  };
 
  class OrderingConstraint : public LayoutConstraint {
  public:
    static const LayoutConstraintKind constraint_kind =
        LEGION_ORDERING_CONSTRAINT;
  public:
    OrderingConstraint(bool contiguous = false);
    OrderingConstraint(
        const std::vector<DimensionKind>& ordering, bool contiguous);
  public:
    inline bool operator==(const OrderingConstraint& other) const
    {
      return ordering == other.ordering && contiguous == other.contiguous;
    }
    inline bool operator!=(const OrderingConstraint& other) const
    {
      return !(*this == other);
    }
  public:
    virtual LayoutConstraintKind get_constraint_kind(void) const override
    {
      return constraint_kind;
    }
    virtual OrderingConstraint* as_ordering_constraint(void) override
    {
      return this;
    }
    virtual const OrderingConstraint* as_ordering_constraint(
        void) const override
    {
      return this;
    }
  public:
    bool entails(const OrderingConstraint& other, unsigned total_dims) const;
    bool conflicts(const OrderingConstraint& other, unsigned total_dims) const;
  public:
    void swap(OrderingConstraint& rhs);
    void serialize(Serializer& rez) const;
    void deserialize(Deserializer& derez);
  public:
    static bool is_skip_dimension(DimensionKind dim, unsigned total_dims);
  public:
    std::vector<DimensionKind> ordering;
    bool contiguous;
  };
 
  class TilingConstraint : public LayoutConstraint {
  public:
    static const LayoutConstraintKind constraint_kind =
        LEGION_TILING_CONSTRAINT;
  public:
    TilingConstraint(void);
    TilingConstraint(DimensionKind dim);  // tiles
    TilingConstraint(DimensionKind dim, size_t value, bool tiles = false);
  public:
    inline bool operator==(const TilingConstraint& o) const
    {
      return dim == o.dim && value == o.value && tiles == o.tiles;
    }
    inline bool operator!=(const TilingConstraint& other) const
    {
      return !(*this == other);
    }
  public:
    virtual LayoutConstraintKind get_constraint_kind(void) const override
    {
      return constraint_kind;
    }
    virtual TilingConstraint* as_tiling_constraint(void) override
    {
      return this;
    }
    virtual const TilingConstraint* as_tiling_constraint(void) const override
    {
      return this;
    }
  public:
    bool entails(const TilingConstraint& other) const;
    bool conflicts(const TilingConstraint& other) const;
  public:
    void swap(TilingConstraint& rhs);
    void serialize(Serializer& rez) const;
    void deserialize(Deserializer& derez);
  public:
    DimensionKind dim;
    size_t value;
    bool tiles;
  };
 
  class DimensionConstraint : public LayoutConstraint {
  public:
    static const LayoutConstraintKind constraint_kind =
        LEGION_DIMENSION_CONSTRAINT;
  public:
    DimensionConstraint(void);
    DimensionConstraint(DimensionKind dim, EqualityKind eq, size_t value);
  public:
    inline bool operator==(const DimensionConstraint& o) const
    {
      return kind == o.kind && eqk == o.eqk && value == o.value;
    }
    inline bool operator!=(const DimensionConstraint& other) const
    {
      return !(*this == other);
    }
  public:
    virtual LayoutConstraintKind get_constraint_kind(void) const override
    {
      return constraint_kind;
    }
    virtual DimensionConstraint* as_dimension_constraint(void) override
    {
      return this;
    }
    virtual const DimensionConstraint* as_dimension_constraint(
        void) const override
    {
      return this;
    }
  public:
    bool entails(const DimensionConstraint& other) const;
    bool conflicts(const DimensionConstraint& other) const;
  public:
    void swap(DimensionConstraint& rhs);
    void serialize(Serializer& rez) const;
    void deserialize(Deserializer& derez);
  public:
    DimensionKind kind;
    EqualityKind eqk;
    size_t value;
  };
 
  class AlignmentConstraint : public LayoutConstraint {
  public:
    static const LayoutConstraintKind constraint_kind =
        LEGION_ALIGNMENT_CONSTRAINT;
  public:
    AlignmentConstraint(void);
    AlignmentConstraint(FieldID fid, EqualityKind kind, size_t byte_boundary);
  public:
    inline bool operator==(const AlignmentConstraint& o) const
    {
      return fid == o.fid && eqk == o.eqk && alignment == o.alignment;
    }
    inline bool operator!=(const AlignmentConstraint& other) const
    {
      return !(*this == other);
    }
  public:
    virtual LayoutConstraintKind get_constraint_kind(void) const override
    {
      return constraint_kind;
    }
    virtual AlignmentConstraint* as_alignment_constraint(void) override
    {
      return this;
    }
    virtual const AlignmentConstraint* as_alignment_constraint(
        void) const override
    {
      return this;
    }
  public:
    bool entails(const AlignmentConstraint& other) const;
    bool conflicts(const AlignmentConstraint& other) const;
  public:
    void swap(AlignmentConstraint& rhs);
    void serialize(Serializer& rez) const;
    void deserialize(Deserializer& derez);
  public:
    FieldID fid;
    EqualityKind eqk;
    size_t alignment;
  };
 
  class OffsetConstraint : public LayoutConstraint {
  public:
    static const LayoutConstraintKind constraint_kind =
        LEGION_OFFSET_CONSTRAINT;
  public:
    OffsetConstraint(void);
    OffsetConstraint(FieldID fid, size_t offset);
  public:
    inline bool operator==(const OffsetConstraint& o) const
    {
      return fid == o.fid && offset == o.offset;
    }
    inline bool operator!=(const OffsetConstraint& other) const
    {
      return !(*this == other);
    }
  public:
    virtual LayoutConstraintKind get_constraint_kind(void) const override
    {
      return constraint_kind;
    }
    virtual OffsetConstraint* as_offset_constraint(void) override
    {
      return this;
    }
    virtual const OffsetConstraint* as_offset_constraint(void) const override
    {
      return this;
    }
  public:
    bool entails(const OffsetConstraint& other) const;
    bool conflicts(const OffsetConstraint& other) const;
  public:
    void swap(OffsetConstraint& rhs);
    void serialize(Serializer& rez) const;
    void deserialize(Deserializer& derez);
  public:
    FieldID fid;
    off_t offset;
  };
 
  class PointerConstraint : public LayoutConstraint {
  public:
    static const LayoutConstraintKind constraint_kind =
        LEGION_POINTER_CONSTRAINT;
  public:
    PointerConstraint(void);
    PointerConstraint(Memory memory, uintptr_t ptr);
  public:
    inline bool operator==(const PointerConstraint& o) const
    {
      return is_valid == o.is_valid && memory == o.memory && ptr == o.ptr;
    }
    inline bool operator!=(const PointerConstraint& other) const
    {
      return !(*this == other);
    }
  public:
    virtual LayoutConstraintKind get_constraint_kind(void) const override
    {
      return constraint_kind;
    }
    virtual PointerConstraint* as_pointer_constraint(void) override
    {
      return this;
    }
    virtual const PointerConstraint* as_pointer_constraint(void) const override
    {
      return this;
    }
  public:
    bool entails(const PointerConstraint& other) const;
    bool conflicts(const PointerConstraint& other) const;
  public:
    void swap(PointerConstraint& rhs);
    void serialize(Serializer& rez) const;
    void deserialize(Deserializer& derez);
  public:
    bool is_valid;
    Memory memory;
    uintptr_t ptr;
  };
 
  class PaddingConstraint : public LayoutConstraint {
  public:
    static const LayoutConstraintKind constraint_kind =
        LEGION_PADDING_CONSTRAINT;
  public:
    PaddingConstraint(void) = default;
    PaddingConstraint(const Domain& delta);
    PaddingConstraint(const DomainPoint& lower, const DomainPoint& upper);
  public:
    inline bool operator==(const PaddingConstraint& rhs) const
    {
      return (delta == rhs.delta);
    }
    inline bool operator!=(const PaddingConstraint& other) const
    {
      return !(*this == other);
    }
  public:
    virtual LayoutConstraintKind get_constraint_kind(void) const override
    {
      return constraint_kind;
    }
    virtual PaddingConstraint* as_padding_constraint(void) override
    {
      return this;
    }
    virtual const PaddingConstraint* as_padding_constraint(void) const override
    {
      return this;
    }
  public:
    bool entails(const PaddingConstraint& other) const;
    bool conflicts(const PaddingConstraint& other) const;
  public:
    void swap(PaddingConstraint& rhs);
    void serialize(Serializer& rez) const;
    void deserialize(Deserializer& derez);
  public:
    // Positive integers mean you must have that much padding
    // Zero means that there should never be any padding
    // Any negative integers will be interpreted as meaning that
    // you don't care whether there is any padding or not
    Domain delta;
  };
 
  class LayoutConstraintSet {
  public:
    LayoutConstraintSet(void) { }  // provided for dumb c++ compilers
  public:
    LayoutConstraintSet& add_constraint(
        const SpecializedConstraint& constraint);
    LayoutConstraintSet& add_constraint(const FieldConstraint& constraint);
    LayoutConstraintSet& add_constraint(const MemoryConstraint& constraint);
    LayoutConstraintSet& add_constraint(const OrderingConstraint& constraint);
    LayoutConstraintSet& add_constraint(const TilingConstraint& constraint);
    LayoutConstraintSet& add_constraint(const DimensionConstraint& constraint);
    LayoutConstraintSet& add_constraint(const AlignmentConstraint& constraint);
    LayoutConstraintSet& add_constraint(const OffsetConstraint& constraint);
    LayoutConstraintSet& add_constraint(const PointerConstraint& constraint);
    LayoutConstraintSet& add_constraint(const PaddingConstraint& constraint);
  public:
    bool operator==(const LayoutConstraintSet& other) const;
    bool operator!=(const LayoutConstraintSet& other) const;
    bool equals(
        const LayoutConstraintSet& other,
        LayoutConstraintKind* bad_kind = nullptr,
        size_t* bad_index = nullptr) const;
  public:
    // failed_constraint will be the one from 'other' that wasn't entailed
    bool entails(
        const LayoutConstraintSet& other, unsigned total_dims = 0,
        const LayoutConstraint** failed_constraint = nullptr,
        bool test_pointer = true) const;
    // conflict_constraint will be the one from 'this' that conficted
    // with a constraint from 'other'
    bool conflicts(
        const LayoutConstraintSet& other, unsigned total_dims = 0,
        const LayoutConstraint** conflict_constraint = nullptr) const;
    const LayoutConstraint* convert_unsatisfied(
        LayoutConstraintKind kind, unsigned index) const;
  public:
    void swap(LayoutConstraintSet& rhs);
    void serialize(Serializer& rez) const;
    void deserialize(Deserializer& derez);
  public:
    SpecializedConstraint specialized_constraint;
    FieldConstraint field_constraint;
    MemoryConstraint memory_constraint;
    PointerConstraint pointer_constraint;
    PaddingConstraint padding_constraint;
    OrderingConstraint ordering_constraint;
    std::vector<TilingConstraint> tiling_constraints;
    std::vector<DimensionConstraint> dimension_constraints;
    std::vector<AlignmentConstraint> alignment_constraints;
    std::vector<OffsetConstraint> offset_constraints;
  };
 
  class TaskLayoutConstraintSet {
  public:
    TaskLayoutConstraintSet& add_layout_constraint(
        unsigned idx, LayoutConstraintID desc);
  public:
    void swap(TaskLayoutConstraintSet& rhs);
    void serialize(Serializer& rez) const;
    void deserialize(Deserializer& derez);
  public:
    std::multimap<unsigned, LayoutConstraintID> layouts;
  };
 
  inline std::ostream& operator<<(
      std::ostream& os, ExecutionConstraintKind kind)
  {
#define CONSTRAINT_NAMES(name, desc) \
  case name:                         \
    return os << desc;
    switch (kind)
    {
      LEGION_EXECUTION_CONSTRAINT_KINDS(CONSTRAINT_NAMES)
    }
#undef CONSTRAINT_NAMES
    std::abort();
  }
 
  inline std::ostream& operator<<(std::ostream& os, LayoutConstraintKind kind)
  {
#define CONSTRAINT_NAMES(name, desc) \
  case name:                         \
    return os << desc;
    switch (kind)
    {
      LEGION_LAYOUT_CONSTRAINT_KINDS(CONSTRAINT_NAMES)
    }
#undef CONSTRAINT_NAMES
    std::abort();
  }
 
}  // namespace Legion
 
#endif  // __LEGION_CONSTRAINT_H__