linalg/backends/lapack/common.hpp

Go to the documentation of this file.

#pragma once
 
#include <uni20/backend/backend.hpp>
#include <uni20/common/trace.hpp>
#include <uni20/core/math.hpp>
#include <uni20/linalg/kernel_attempt.hpp>
#include <uni20/tensor/access.hpp>
 
#include <concepts>
#include <cstddef>
#include <functional>
#include <optional>
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace uni20::linalg::lapack_detail
{
 
template <class Function, uni20::HostWritableMdspec... Mdspecs>
  requires std::same_as<std::invoke_result_t<Function&&, uni20::host_write_mdspan_t<Mdspecs>&...>, KernelAttempt>
KernelAttempt with_host_write_mdspans(Function&& function, Mdspecs&... mdspecs)
{
  auto accesses = std::tuple{acquire_host_write_access_sync(mdspecs)...};
  return std::apply(
      [&](auto&... access) -> KernelAttempt {
        auto mdspans = std::tuple{access.mdspan()...};
        return std::apply(
            [&](auto&... mdspan) -> KernelAttempt { return std::invoke(std::forward<Function>(function), mdspan...); },
            mdspans);
      },
      accesses);
}
 
template <class Scalar> blas_int workspace_size(Scalar const& query)
{
  auto const recommended = uni20::real(query);
  using real_type = std::remove_cv_t<decltype(recommended)>;
  CHECK(uni20::isfinite(recommended), recommended);
  CHECK(recommended >= real_type{1}, recommended);
 
  auto const maximum = static_cast<real_type>(uni20::numeric_limits<blas_int>::max());
  if (uni20::numeric_limits<real_type>::digits(recommended) < uni20::numeric_limits<blas_int>::digits())
  {
    // A low-precision real may round max(blas_int) up to the first
    // unrepresentable integer, so equality is not a safe conversion bound.
    CHECK(recommended < maximum, recommended);
  }
  else
  {
    CHECK(recommended <= maximum, recommended);
  }
 
  blas_int const result = static_cast<blas_int>(recommended);
  CHECK(result >= 1, result);
  CHECK(std::in_range<std::size_t>(result), result);
  return result;
}
 
constexpr std::optional<std::size_t> try_size_product(std::size_t left, std::size_t right) noexcept
{
  if (left != 0 && right > uni20::numeric_limits<std::size_t>::max() / left)
  {
    return std::nullopt;
  }
  return left * right;
}
 
} // namespace uni20::linalg::lapack_detail