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 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);
}
}  // 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