dispatch_error.hpp

Go to the documentation of this file.

#pragma once
 
#include <uni20/common/diagnostic_error.hpp>
#include <uni20/linalg/kernel_attempt.hpp>
 
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace uni20::linalg
{
 
enum class KernelTypeAcceptance
{
  no,
  maybe,
  yes
};
 
template <KernelTypeAcceptance Value> using KernelAcceptance = std::integral_constant<KernelTypeAcceptance, Value>;
 
inline constexpr KernelAcceptance<KernelTypeAcceptance::no> kernel_types_no{};
 
inline constexpr KernelAcceptance<KernelTypeAcceptance::maybe> kernel_types_maybe{};
 
inline constexpr KernelAcceptance<KernelTypeAcceptance::yes> kernel_types_yes{};
 
enum class KernelDispatchFailure
{
  no_eligible_backend,
  all_candidates_declined
};
 
struct KernelBackendAttempt
{
    std::string backend;
    KernelTypeAcceptance type_acceptance = KernelTypeAcceptance::no;
    std::optional<KernelAttempt> runtime_result = std::nullopt;
};
 
namespace detail
{
inline std::string_view kernel_dispatch_failure_name(KernelDispatchFailure failure) noexcept
{
  switch (failure)
  {
    case KernelDispatchFailure::no_eligible_backend:
      return "no backend accepts these argument types";
    case KernelDispatchFailure::all_candidates_declined:
      return "all runtime candidates declined";
  }
  return "unknown dispatch failure";
}
 
inline std::string_view kernel_type_acceptance_name(KernelTypeAcceptance acceptance) noexcept
{
  switch (acceptance)
  {
    case KernelTypeAcceptance::no:
      return "no";
    case KernelTypeAcceptance::maybe:
      return "maybe";
    case KernelTypeAcceptance::yes:
      return "yes";
  }
  return "unknown";
}
 
inline std::string kernel_dispatch_error_message(std::string_view operation, KernelDispatchFailure failure)
{
  return "kernel dispatch failed for operation '" + std::string(operation) +
         "': " + std::string(kernel_dispatch_failure_name(failure));
}
} // namespace detail
 
class KernelDispatchError : public uni20::diagnostic_error {
  public:
    KernelDispatchError(std::string operation, KernelDispatchFailure failure,
                        std::vector<KernelBackendAttempt> backend_attempts)
        : diagnostic_error(detail::kernel_dispatch_error_message(operation, failure)), operation_(std::move(operation)),
          failure_(failure), backend_attempts_(std::move(backend_attempts))
    {}
 
    [[nodiscard]] std::string const& operation() const noexcept { return operation_; }
 
    [[nodiscard]] KernelDispatchFailure failure() const noexcept { return failure_; }
 
    [[nodiscard]] std::vector<KernelBackendAttempt> const& backend_attempts() const noexcept
    {
      return backend_attempts_;
    }
 
  private:
    std::string operation_;
    KernelDispatchFailure failure_;
    std::vector<KernelBackendAttempt> backend_attempts_;
};
 
} // namespace uni20::linalg