SPSProxySpec.h

Go to the documentation of this file.

//===------- SPSProxySpec.h - SPS dispatch for orc::Proxy -------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// ProxySpec implements an orc::Proxy's dispatch by invoking an executor-side
// wrapper function in the runtime's controller interface, using Simple Packed
// Serialization to encode arguments and decode results.
//
// A ProxySpec pairs a Proxy with a controller-interface descriptor from
// Shared/SPSCI, which supplies the wrapper name and wire signature. Specs for
// specific operation families live alongside the utilities that use them (e.g.
// CallProxiesSPS.h, EPCGenericMemoryAccessSPS.h).
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_EXECUTIONENGINE_ORC_SPSPROXYSPEC_H
#define LLVM_EXECUTIONENGINE_ORC_SPSPROXYSPEC_H
 
#include "llvm/ExecutionEngine/Orc/Core.h"
#include "llvm/ExecutionEngine/Orc/Proxy.h"
#include "llvm/ExecutionEngine/Orc/Shared/SymbolNameSpec.h"
 
namespace llvm::orc::sps {
 
template <typename ProxyT, typename CI,
          typename FnType = typename ProxyT::FnType>
class ProxySpec;
 
template <typename ProxyT, typename CI, typename RetT, typename... ArgTs>
class ProxySpec<ProxyT, CI, RetT(ArgTs...)> {
 
  using SPSSigT = typename CI::SPSSig;
  using CalleeRetT = typename ProxyT::CalleeRetT;
  using ErrorRetT = typename ProxyT::ErrorRetT;
 
  static void consumeResult(Error &Err) { consumeError(std::move(Err)); }
 
  template <typename T> static void consumeResult(T &V) {}
 
  template <typename T> static void consumeResult(Expected<T> &E) {
    consumeError(E.takeError());
  }
 
public:
  static constexpr SymbolNameSpec Name = CI::Name;
 
  static void dispatch(unique_function<void(ErrorRetT)> OnComplete,
                       ExecutionSession &ES, ExecutorAddr CalleeAddr,
                       const ArgTs &...Args) {
    auto Caller = [&ES, CalleeAddr](auto &&SendResult, const char *ArgData,
                                    size_t ArgSize) {
      ES.callWrapperAsync(CalleeAddr,
                          std::forward<decltype(SendResult)>(SendResult),
                          ArrayRef<char>(ArgData, ArgSize));
    };
 
    if constexpr (std::is_void_v<CalleeRetT>) {
      // Void result: the executor-side function produces no value, so the only
      // thing to report is the dispatch error (success if the call ran).
      shared::WrapperFunction<SPSSigT>::callAsync(Caller, std::move(OnComplete),
                                                  Args...);
    } else {
      shared::WrapperFunction<SPSSigT>::callAsync(
          Caller,
          [OnComplete = std::move(OnComplete)](Error SerErr,
                                               CalleeRetT Result) mutable {
            if (SerErr) {
              consumeResult(Result);
              return OnComplete(std::move(SerErr));
            }
            // For an Error/Expected callee this forwards the callee's own
            // result; for a plain value it is wrapped into Expected.
            return OnComplete(std::move(Result));
          },
          Args...);
    }
  }
};
 
} // namespace llvm::orc::sps
 
#endif // LLVM_EXECUTIONENGINE_ORC_SPSPROXYSPEC_H