functors.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_FUNCTORS_H__
#define __LEGION_FUNCTORS_H__
 
#include "legion/api/geometry.h"
 
namespace Legion {
 
  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();
    }
  };
 
}  // namespace Legion
 
#endif  // __LEGION_FUNCTORS_H__