wrapper.inl

Go to the documentation of this file.

/* Copyright 2025 Northwestern University,
 *                   Carnegie Mellon University University
 *
 * 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.
 *
 * Author(s): David Krasowska <krasow@u.northwestern.edu>
 *            Ethan Meitz <emeitz@andrew.cmu.edu>
 */
 
#include "legate.h"
#include "legate/mapping/machine.h"
#include "legate/runtime/runtime.h"
#include "legate/timing/timing.h"
#include "legion.h"
#include "legion/legion_config.h"
 
using namespace legate;
namespace legate_wrapper {
namespace runtime {

inline void start_legate() { legate::start(); }

inline int32_t legate_finish() { return legate::finish(); }

inline Runtime* get_runtime() { return Runtime::get_runtime(); }

inline bool has_started() { return legate::has_started(); }

inline bool has_finished() { return legate::has_finished(); }
}  // namespace runtime
 
namespace tasking {
inline Constraint align(const Variable& a, const Variable& b) {
  return legate::align(a, b);
}

inline AutoTask create_auto_task(Runtime* rt, Library lib, LocalTaskID id) {
  return rt->create_task(lib, id);
}

inline ManualTask create_manual_task(Runtime* rt, Library lib, LocalTaskID id,
                                     const Domain& domain) {
  return rt->create_task(lib, id, domain);
}

inline Domain domain_from_shape(const Shape& shape) {
  if (shape.volume() == 0) return Domain::NO_DOMAIN;
  switch (shape.ndim()) {
    case 1: {
      Legion::Point<1> lo = Legion::Point<1>::ZEROES();
      Legion::Point<1> hi;
      hi[0] = shape[0] - 1;
      return Domain(Legion::Rect<1>(lo, hi));
    }
    case 2: {
      Legion::Point<2> lo = Legion::Point<2>::ZEROES();
      Legion::Point<2> hi;
      hi[0] = shape[0] - 1;
      hi[1] = shape[1] - 1;
      return Domain(Legion::Rect<2>(lo, hi));
    }
    case 3: {
      Legion::Point<3> lo = Legion::Point<3>::ZEROES();
      Legion::Point<3> hi;
      hi[0] = shape[0] - 1;
      hi[1] = shape[1] - 1;
      hi[2] = shape[2] - 1;
      return Domain(Legion::Rect<3>(lo, hi));
    }
    default:
      return Domain::NO_DOMAIN;
  }
}

inline auto submit_auto_task(Runtime* rt, AutoTask& task) {
  return rt->submit(std::move(task));
}

inline auto submit_manual_task(Runtime* rt, ManualTask& task) {
  return rt->submit(std::move(task));
}
 
}  // namespace tasking
 
namespace data {
inline Scalar string_to_scalar(std::string str) { return Scalar(str); }

inline LogicalArray create_unbound_array(const Type& ty, std::uint32_t dim = 1,
                                         bool nullable = false) {
  return Runtime::get_runtime()->create_array(ty, dim, nullable);
}

inline LogicalArray create_array(const Shape& shape, const Type& ty,
                                 bool nullable = false,
                                 bool optimize_scalar = false) {
  return Runtime::get_runtime()->create_array(shape, ty, nullable,
                                              optimize_scalar);
}

inline LogicalStore create_unbound_store(const Type& ty,
                                         std::uint32_t dim = 1) {
  return Runtime::get_runtime()->create_store(ty, dim);
}

inline LogicalStore create_store(const Shape& shape, const Type& ty,
                                 bool optimize_scalar = false) {
  return Runtime::get_runtime()->create_store(shape, ty, optimize_scalar);
}

inline LogicalStore store_from_scalar(const Scalar& scalar,
                                      const Shape& shape = Shape{1}) {
  return Runtime::get_runtime()->create_store(scalar, shape);
}

inline LogicalStore attach_external_store_sysmem(void* ptr, const Shape& shape,
                                                 const Type& ty) {
  legate::ExternalAllocation alloc = legate::ExternalAllocation::create_sysmem(
      ptr, shape.volume() * ty.size());
  legate::mapping::DimOrdering ordering =
      legate::mapping::DimOrdering::fortran_order();
 
  auto store =
      legate::Runtime::get_runtime()->create_store(shape, ty, alloc, ordering);
  return store;
}

inline LogicalStore attach_external_store_fbmem(int device_id, void* ptr,
                                                const Shape& shape,
                                                const Type& ty, bool readonly) {
  legate::ExternalAllocation alloc = legate::ExternalAllocation::create_fbmem(
      device_id, ptr, shape.volume() * ty.size(), readonly);
  legate::mapping::DimOrdering ordering =
      legate::mapping::DimOrdering::fortran_order();
 
  auto store =
      legate::Runtime::get_runtime()->create_store(shape, ty, alloc, ordering);
  return store;
}
 
struct GetPtrFunctor {
  template <legate::Type::Code CODE, int DIM>
  void* operator()(legate::PhysicalStore* store) {
#if !LEGATE_DEFINED(LEGATE_USE_CUDA)
    // Check if FLOAT16 is being used without CUDA support
    if (CODE == legate::Type::Code::FLOAT16) {
      throw std::runtime_error(
          "FLOAT16 type is not supported when building without CUDA");
    }
#endif
    using CppT = typename legate_util::code_to_cxx<CODE>::type;
    auto shp = store->shape<DIM>();
    return store->write_accessor<CppT, DIM>().ptr(Realm::Point<DIM>(shp.lo));
  }
};

inline void* get_ptr(legate::PhysicalStore* store) {
  int dim = store->dim();
  legate::Type::Code code = store->type().code();
  return legate::double_dispatch(dim, code, GetPtrFunctor{}, store);
}
 
}  // namespace data
 
namespace time {

inline uint64_t time_microseconds() {
  return legate::timing::measure_microseconds().value();
}

inline uint64_t time_nanoseconds() {
  return legate::timing::measure_nanoseconds().value();
}
}  // namespace time
}  // namespace legate_wrapper