Files
llvm-tms34010/mlir/lib/CAPI/ExecutionEngine/ExecutionEngine.cpp
T
Mehdi Amini 7a4d630764 Add a "register_runtime" method to the mlir.execution_engine and show calling back from MLIR into Python
This exposes the ability to register Python functions with the JIT and
exposes them to the MLIR jitted code. The provided test case illustrates
the mechanism.

Differential Revision: https://reviews.llvm.org/D99562
2021-03-30 17:04:38 +00:00

69 lines
2.4 KiB
C++

//===- ExecutionEngine.cpp - C API for MLIR JIT ---------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "mlir-c/ExecutionEngine.h"
#include "mlir/CAPI/ExecutionEngine.h"
#include "mlir/CAPI/IR.h"
#include "mlir/CAPI/Support.h"
#include "mlir/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.h"
#include "llvm/ExecutionEngine/Orc/Mangling.h"
#include "llvm/Support/TargetSelect.h"
using namespace mlir;
extern "C" MlirExecutionEngine mlirExecutionEngineCreate(MlirModule op) {
static bool init_once = [] {
llvm::InitializeNativeTarget();
llvm::InitializeNativeTargetAsmPrinter();
return true;
}();
(void)init_once;
mlir::registerLLVMDialectTranslation(*unwrap(op)->getContext());
auto jitOrError = ExecutionEngine::create(unwrap(op));
if (!jitOrError) {
consumeError(jitOrError.takeError());
return MlirExecutionEngine{nullptr};
}
return wrap(jitOrError->release());
}
extern "C" void mlirExecutionEngineDestroy(MlirExecutionEngine jit) {
delete (unwrap(jit));
}
extern "C" MlirLogicalResult
mlirExecutionEngineInvokePacked(MlirExecutionEngine jit, MlirStringRef name,
void **arguments) {
const std::string ifaceName = ("_mlir_ciface_" + unwrap(name)).str();
llvm::Error error = unwrap(jit)->invokePacked(
ifaceName, MutableArrayRef<void *>{arguments, (size_t)0});
if (error)
return wrap(failure());
return wrap(success());
}
extern "C" void *mlirExecutionEngineLookup(MlirExecutionEngine jit,
MlirStringRef name) {
auto expectedFPtr = unwrap(jit)->lookup(unwrap(name));
if (!expectedFPtr)
return nullptr;
return reinterpret_cast<void *>(*expectedFPtr);
}
extern "C" void mlirExecutionEngineRegisterSymbol(MlirExecutionEngine jit,
MlirStringRef name,
void *sym) {
unwrap(jit)->registerSymbols([&](llvm::orc::MangleAndInterner interner) {
llvm::orc::SymbolMap symbolMap;
symbolMap[interner(unwrap(name))] =
llvm::JITEvaluatedSymbol::fromPointer(sym);
return symbolMap;
});
}