linalg/async/reductions.hpp

Go to the documentation of this file.

#pragma once
 
#include <uni20/async/async.hpp>
#include <uni20/async/awaiters.hpp>
#include <uni20/async/debug_scheduler.hpp>
#include <uni20/common/trace.hpp>
#include <uni20/linalg/async/detail/output.hpp>
#include <uni20/tensor/reductions.hpp>
 
#include <concepts>
#include <cstddef>
#include <memory>
#include <tuple>
#include <utility>
 
namespace uni20
{
namespace detail
{
 
template <class OutputTensor, class InputTensor>
void validate_async_reduction_aliasing(async::Async<OutputTensor> const& output, async::Async<InputTensor> const& input)
{
  ERROR_IF(std::addressof(output.queue()) == std::addressof(input.queue()),
           "async reduction output must not share an epoch queue with its input");
}
 
template <AsyncTensorOutput OutputTensor, TensorView InputTensor, std::size_t InputRank, std::size_t ReducedRank>
[[nodiscard]] OutputTensor& prepare_async_sum_output(async::shared_storage<OutputTensor>& storage,
                                                     InputTensor const& input,
                                                     linalg::ReductionAxes<InputRank, ReducedRank> const& axes)
{
  auto const required = reduction_output_extents(input, axes);
  if (storage.constructed())
  {
    prepare_output(*storage, required);
    return *storage;
  }
 
  using extents_type = tensor_extents_t<OutputTensor>;
  if constexpr (std::constructible_from<OutputTensor, extents_type const&>)
  {
    auto const extents = convert_tensor_extents<extents_type>(required);
    if constexpr (std::constructible_from<OutputTensor, uninitialized_t, extents_type const&>)
      return storage.emplace(uninitialized, extents);
    else
      return storage.emplace(extents);
  }
  else
  {
    throw async::buffer_write_uninitialized{};
  }
}
 
template <class BackendSelector, AsyncTensorOutput OutputTensor, TensorView InputTensor, std::size_t InputRank,
          std::size_t ReducedRank>
async::AsyncTask co_sum(BackendSelector const selector, async::WriteBuffer<OutputTensor> output,
                        async::ReadBuffer<InputTensor> input, linalg::ReductionAxes<InputRank, ReducedRank> axes)
{
  if constexpr (async::is_async_alias_v<OutputTensor>)
  {
    AsyncAliasWriteDescriptorAwaiter output_descriptor_awaiter(output);
    auto awaited = co_await async::all(output_descriptor_awaiter, input);
    auto mutable_output = std::get<0>(awaited);
    auto const& input_value = std::get<1>(awaited);
    prepare_output(mutable_output, reduction_output_extents(input_value, axes));
    auto output_descriptor = mdspec_of(mutable_output);
    auto input_descriptor = mdspec_of(input_value);
    dispatch_sum(selector, output_descriptor, input_descriptor, std::move(axes));
  }
  else
  {
    auto output_storage = output.storage();
    auto awaited = co_await async::all(output_storage, input);
    auto& storage = std::get<0>(awaited);
    auto const& input_value = std::get<1>(awaited);
    auto& output_value = prepare_async_sum_output(storage, input_value, axes);
    auto output_descriptor = mdspec_of(output_value);
    auto input_descriptor = mdspec_of(input_value);
    dispatch_sum(selector, output_descriptor, input_descriptor, std::move(axes));
  }
  co_return;
}
 
template <class BackendSelector, TensorView InputTensor>
async::AsyncTask co_sum_host(BackendSelector const selector, async::WriteBuffer<tensor_element_t<InputTensor>> output,
                             async::ReadBuffer<InputTensor> input)
{
  auto output_storage = output.storage();
  auto awaited = co_await async::all(output_storage, input);
  auto& storage = std::get<0>(awaited);
  auto const& input_value = std::get<1>(awaited);
  auto result = uni20::sum_host(selector, input_value);
  storage.emplace(std::move(result));
  co_return;
}
 
template <class BackendSelector, class ResultTensor, TensorView LhsTensor, TensorView RhsTensor>
async::AsyncTask co_inner_product(BackendSelector const selector, async::WriteBuffer<ResultTensor> output,
                                  async::ReadBuffer<LhsTensor> lhs, async::ReadBuffer<RhsTensor> rhs)
{
  auto output_storage = output.storage();
  auto awaited = co_await async::all(output_storage, lhs, rhs);
  auto& storage = std::get<0>(awaited);
  auto const& lhs_value = std::get<1>(awaited);
  auto const& rhs_value = std::get<2>(awaited);
 
  auto result = uni20::inner_product(selector, lhs_value, rhs_value);
  storage.emplace(std::move(result));
  co_return;
}
 
template <class BackendSelector, TensorView LhsTensor, TensorView RhsTensor>
async::AsyncTask co_inner_product_host(BackendSelector const selector,
                                       async::WriteBuffer<tensor_element_t<LhsTensor>> output,
                                       async::ReadBuffer<LhsTensor> lhs, async::ReadBuffer<RhsTensor> rhs)
{
  auto output_storage = output.storage();
  auto awaited = co_await async::all(output_storage, lhs, rhs);
  auto& storage = std::get<0>(awaited);
  auto const& lhs_value = std::get<1>(awaited);
  auto const& rhs_value = std::get<2>(awaited);
 
  auto result = uni20::inner_product_host(selector, lhs_value, rhs_value);
  storage.emplace(std::move(result));
  co_return;
}
 
template <class BackendSelector, class ResultTensor, TensorView InputTensor>
async::AsyncTask co_norm(BackendSelector const selector, async::WriteBuffer<ResultTensor> output,
                         async::ReadBuffer<InputTensor> input)
{
  auto output_storage = output.storage();
  auto awaited = co_await async::all(output_storage, input);
  auto& storage = std::get<0>(awaited);
  auto const& input_value = std::get<1>(awaited);
 
  auto result = uni20::norm(selector, input_value);
  storage.emplace(std::move(result));
  co_return;
}
 
template <class BackendSelector, TensorView InputTensor>
async::AsyncTask co_norm_host(BackendSelector const selector,
                              async::WriteBuffer<make_real_t<tensor_element_t<InputTensor>>> output,
                              async::ReadBuffer<InputTensor> input)
{
  auto output_storage = output.storage();
  auto awaited = co_await async::all(output_storage, input);
  auto& storage = std::get<0>(awaited);
  auto const& input_value = std::get<1>(awaited);
 
  auto result = uni20::norm_host(selector, input_value);
  storage.emplace(std::move(result));
  co_return;
}
 
template <class BackendSelector, AsyncTensorOutput OutputTensor, TensorView LhsTensor, TensorView RhsTensor>
async::AsyncTask co_inner_product_output(BackendSelector const selector, async::WriteBuffer<OutputTensor> output,
                                         async::ReadBuffer<LhsTensor> lhs, async::ReadBuffer<RhsTensor> rhs)
{
  if constexpr (async::is_async_alias_v<OutputTensor>)
  {
    AsyncAliasWriteDescriptorAwaiter output_descriptor_awaiter(output);
    auto awaited = co_await async::all(output_descriptor_awaiter, lhs, rhs);
    auto output_value = std::get<0>(awaited);
    uni20::inner_product(selector, output_value, std::get<1>(awaited), std::get<2>(awaited));
  }
  else
  {
    auto output_storage = output.storage();
    auto awaited = co_await async::all(output_storage, lhs, rhs);
    auto& output_value = prepare_async_scalar_output<OutputTensor>(std::get<0>(awaited));
    uni20::inner_product(selector, output_value, std::get<1>(awaited), std::get<2>(awaited));
  }
  co_return;
}
 
template <class BackendSelector, AsyncTensorOutput OutputTensor, TensorView InputTensor>
async::AsyncTask co_norm_output(BackendSelector const selector, async::WriteBuffer<OutputTensor> output,
                                async::ReadBuffer<InputTensor> input)
{
  if constexpr (async::is_async_alias_v<OutputTensor>)
  {
    AsyncAliasWriteDescriptorAwaiter output_descriptor_awaiter(output);
    auto awaited = co_await async::all(output_descriptor_awaiter, input);
    auto output_value = std::get<0>(awaited);
    uni20::norm(selector, output_value, std::get<1>(awaited));
  }
  else
  {
    auto output_storage = output.storage();
    auto awaited = co_await async::all(output_storage, input);
    auto& output_value = prepare_async_scalar_output<OutputTensor>(std::get<0>(awaited));
    uni20::norm(selector, output_value, std::get<1>(awaited));
  }
  co_return;
}
 
template <class BackendSelector, AsyncTensorOutput OutputTensor, TensorView InputTensor, std::size_t InputRank,
          std::size_t ReducedRank>
void schedule_async_sum(BackendSelector selector, async::Async<OutputTensor>& output,
                        async::Async<InputTensor> const& input, linalg::ReductionAxes<InputRank, ReducedRank> axes)
{
  validate_async_reduction_aliasing(output, input);
  auto task = co_sum(std::move(selector), output.write(), input.read(), std::move(axes));
  task.debug_name("sum");
  async::schedule(std::move(task));
}
 
template <class BackendSelector, TensorView InputTensor>
[[nodiscard]] auto schedule_async_sum_host(BackendSelector selector, async::Async<InputTensor> const& input)
{
  async::Async<tensor_element_t<InputTensor>> output;
  output.debug_name("sum_host.result");
  auto task = co_sum_host(std::move(selector), output.write(), input.read());
  task.debug_name("sum_host");
  async::schedule(std::move(task));
  return output;
}
 
template <class BackendSelector, TensorView LhsTensor, TensorView RhsTensor>
[[nodiscard]] auto schedule_async_inner_product(BackendSelector selector, async::Async<LhsTensor> const& lhs,
                                                async::Async<RhsTensor> const& rhs)
{
  using result_type = std::remove_cvref_t<decltype(uni20::inner_product(std::declval<LhsTensor const&>(),
                                                                        std::declval<RhsTensor const&>()))>;
  async::Async<result_type> output;
  output.debug_name("inner_product.result");
  auto task = co_inner_product(std::move(selector), output.write(), lhs.read(), rhs.read());
  task.debug_name("inner_product");
  async::schedule(std::move(task));
  return output;
}
 
template <class BackendSelector, TensorView LhsTensor, TensorView RhsTensor>
[[nodiscard]] auto schedule_async_inner_product_host(BackendSelector selector, async::Async<LhsTensor> const& lhs,
                                                     async::Async<RhsTensor> const& rhs)
{
  async::Async<tensor_element_t<LhsTensor>> output;
  output.debug_name("inner_product_host.result");
  auto task = co_inner_product_host(std::move(selector), output.write(), lhs.read(), rhs.read());
  task.debug_name("inner_product_host");
  async::schedule(std::move(task));
  return output;
}
 
template <class BackendSelector, TensorView InputTensor>
[[nodiscard]] auto schedule_async_norm(BackendSelector selector, async::Async<InputTensor> const& input)
{
  using result_type = std::remove_cvref_t<decltype(uni20::norm(std::declval<InputTensor const&>()))>;
  async::Async<result_type> output;
  output.debug_name("norm.result");
  auto task = co_norm(std::move(selector), output.write(), input.read());
  task.debug_name("norm");
  async::schedule(std::move(task));
  return output;
}
 
template <class BackendSelector, TensorView InputTensor>
[[nodiscard]] auto schedule_async_norm_host(BackendSelector selector, async::Async<InputTensor> const& input)
{
  using result_type = make_real_t<tensor_element_t<InputTensor>>;
  async::Async<result_type> output;
  output.debug_name("norm_host.result");
  auto task = co_norm_host(std::move(selector), output.write(), input.read());
  task.debug_name("norm_host");
  async::schedule(std::move(task));
  return output;
}
 
template <class BackendSelector, AsyncTensorOutput OutputTensor, TensorView LhsTensor, TensorView RhsTensor>
void schedule_async_inner_product_output(BackendSelector selector, async::Async<OutputTensor>& output,
                                         async::Async<LhsTensor> const& lhs, async::Async<RhsTensor> const& rhs)
{
  auto const* const output_queue = std::addressof(output.queue());
  ERROR_IF(output_queue == std::addressof(lhs.queue()) || output_queue == std::addressof(rhs.queue()),
           "async inner-product output must not share an epoch queue with an input");
  auto task = co_inner_product_output(std::move(selector), output.write(), lhs.read(), rhs.read());
  task.debug_name("inner_product");
  async::schedule(std::move(task));
}
 
template <class BackendSelector, AsyncTensorOutput OutputTensor, TensorView InputTensor>
void schedule_async_norm_output(BackendSelector selector, async::Async<OutputTensor>& output,
                                async::Async<InputTensor> const& input)
{
  validate_async_reduction_aliasing(output, input);
  auto task = co_norm_output(std::move(selector), output.write(), input.read());
  task.debug_name("norm");
  async::schedule(std::move(task));
}
 
} // namespace detail
 
template <linalg::KernelBackendSelector BackendSelector, AsyncTensorOutput OutputTensor, TensorView InputTensor>
  requires MutableScalarTensorView<OutputTensor> && RealOrComplex<tensor_element_t<InputTensor>> &&
           std::same_as<tensor_element_t<OutputTensor>, tensor_element_t<InputTensor>>
void sum(BackendSelector selector, async::Async<OutputTensor>& output, async::Async<InputTensor> const& input)
{
  constexpr std::size_t input_rank = tensor_mdspec_t<InputTensor>::rank();
  detail::schedule_async_sum(std::move(selector), output, input, linalg::all_reduction_axes<input_rank>());
}
 
template <AsyncTensorOutput OutputTensor, TensorView InputTensor>
  requires MutableScalarTensorView<OutputTensor> && RealOrComplex<tensor_element_t<InputTensor>> &&
           std::same_as<tensor_element_t<OutputTensor>, tensor_element_t<InputTensor>>
void sum(async::Async<OutputTensor>& output, async::Async<InputTensor> const& input)
{
  constexpr std::size_t input_rank = tensor_mdspec_t<InputTensor>::rank();
  auto axes = linalg::all_reduction_axes<input_rank>();
  auto operation = linalg::sum_reduction_op<input_rank, input_rank>{.axes = axes};
  auto selector = linalg::select_backend_for<OutputTensor, InputTensor>(operation);
  detail::schedule_async_sum(std::move(selector), output, input, std::move(axes));
}
 
template <linalg::KernelBackendSelector BackendSelector, AsyncTensorOutput OutputTensor, TensorView InputTensor,
          linalg::ReductionAxis FirstAxis, linalg::ReductionAxis... RestAxes>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           std::same_as<tensor_element_t<OutputTensor>, tensor_element_t<InputTensor>> &&
           (1 + sizeof...(RestAxes) <= tensor_mdspec_t<InputTensor>::rank()) &&
           (mutable_tensor_mdspec_t<OutputTensor>::rank() + 1 + sizeof...(RestAxes) ==
            tensor_mdspec_t<InputTensor>::rank())
void sum(BackendSelector selector, async::Async<OutputTensor>& output, async::Async<InputTensor> const& input,
         FirstAxis first_axis, RestAxes... rest_axes)
{
  constexpr std::size_t input_rank = tensor_mdspec_t<InputTensor>::rank();
  auto axes = linalg::make_reduction_axes<input_rank>(first_axis, rest_axes...);
  detail::schedule_async_sum(std::move(selector), output, input, std::move(axes));
}
 
template <AsyncTensorOutput OutputTensor, TensorView InputTensor, linalg::ReductionAxis FirstAxis,
          linalg::ReductionAxis... RestAxes>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           std::same_as<tensor_element_t<OutputTensor>, tensor_element_t<InputTensor>> &&
           (1 + sizeof...(RestAxes) <= tensor_mdspec_t<InputTensor>::rank()) &&
           (mutable_tensor_mdspec_t<OutputTensor>::rank() + 1 + sizeof...(RestAxes) ==
            tensor_mdspec_t<InputTensor>::rank())
void sum(async::Async<OutputTensor>& output, async::Async<InputTensor> const& input, FirstAxis first_axis,
         RestAxes... rest_axes)
{
  constexpr std::size_t input_rank = tensor_mdspec_t<InputTensor>::rank();
  constexpr std::size_t reduced_rank = 1 + sizeof...(RestAxes);
  auto axes = linalg::make_reduction_axes<input_rank>(first_axis, rest_axes...);
  auto operation = linalg::sum_reduction_op<input_rank, reduced_rank>{.axes = axes};
  auto selector = linalg::select_backend_for<OutputTensor, InputTensor>(operation);
  detail::schedule_async_sum(std::move(selector), output, input, std::move(axes));
}
 
template <linalg::KernelBackendSelector BackendSelector, TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           detail::ReductionResultAvailable<tensor_element_t<InputTensor>, InputTensor>
[[nodiscard]] auto sum(BackendSelector selector, async::Async<InputTensor> const& input)
{
  constexpr std::size_t input_rank = tensor_mdspec_t<InputTensor>::rank();
  using result_type = detail::sum_reduction_result_t<InputTensor, input_rank>;
  async::Async<result_type> output;
  output.debug_name("sum.result");
  detail::schedule_async_sum(std::move(selector), output, input, linalg::all_reduction_axes<input_rank>());
  return output;
}
 
template <TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           detail::ReductionResultAvailable<tensor_element_t<InputTensor>, InputTensor>
[[nodiscard]] auto sum(async::Async<InputTensor> const& input)
{
  constexpr std::size_t input_rank = tensor_mdspec_t<InputTensor>::rank();
  auto axes = linalg::all_reduction_axes<input_rank>();
  auto operation = linalg::sum_reduction_op<input_rank, input_rank>{.axes = axes};
  auto selector = linalg::select_backend_for<InputTensor>(operation);
  return sum(std::move(selector), input);
}
 
template <linalg::KernelBackendSelector BackendSelector, TensorView InputTensor, linalg::ReductionAxis FirstAxis,
          linalg::ReductionAxis... RestAxes>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           (1 + sizeof...(RestAxes) <= tensor_mdspec_t<InputTensor>::rank()) &&
           detail::ReductionResultAvailable<tensor_element_t<InputTensor>, InputTensor>
[[nodiscard]] auto sum(BackendSelector selector, async::Async<InputTensor> const& input, FirstAxis first_axis,
                       RestAxes... rest_axes)
{
  constexpr std::size_t input_rank = tensor_mdspec_t<InputTensor>::rank();
  constexpr std::size_t reduced_rank = 1 + sizeof...(RestAxes);
  auto axes = linalg::make_reduction_axes<input_rank>(first_axis, rest_axes...);
  using result_type = detail::sum_reduction_result_t<InputTensor, reduced_rank>;
  async::Async<result_type> output;
  output.debug_name("sum.result");
  detail::schedule_async_sum(std::move(selector), output, input, std::move(axes));
  return output;
}
 
template <TensorView InputTensor, linalg::ReductionAxis FirstAxis, linalg::ReductionAxis... RestAxes>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           (1 + sizeof...(RestAxes) <= tensor_mdspec_t<InputTensor>::rank()) &&
           detail::ReductionResultAvailable<tensor_element_t<InputTensor>, InputTensor>
[[nodiscard]] auto sum(async::Async<InputTensor> const& input, FirstAxis first_axis, RestAxes... rest_axes)
{
  constexpr std::size_t input_rank = tensor_mdspec_t<InputTensor>::rank();
  constexpr std::size_t reduced_rank = 1 + sizeof...(RestAxes);
  auto axes = linalg::make_reduction_axes<input_rank>(first_axis, rest_axes...);
  auto operation = linalg::sum_reduction_op<input_rank, reduced_rank>{.axes = axes};
  auto selector = linalg::select_backend_for<InputTensor>(operation);
  return sum(std::move(selector), input, first_axis, rest_axes...);
}
 
template <linalg::KernelBackendSelector BackendSelector, TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>>
[[nodiscard]] auto sum_host(BackendSelector selector, async::Async<InputTensor> const& input)
{
  return detail::schedule_async_sum_host(std::move(selector), input);
}
 
template <TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>>
[[nodiscard]] auto sum_host(async::Async<InputTensor> const& input)
{
  constexpr std::size_t input_rank = tensor_mdspec_t<InputTensor>::rank();
  auto operation = linalg::sum_reduction_op<input_rank, input_rank>{.axes = linalg::all_reduction_axes<input_rank>()};
  auto selector = linalg::select_backend_for<InputTensor>(operation);
  return detail::schedule_async_sum_host(std::move(selector), input);
}
 
template <linalg::KernelBackendSelector BackendSelector, AsyncTensorOutput OutputTensor, TensorView LhsTensor,
          TensorView RhsTensor>
  requires MutableScalarTensorView<OutputTensor> && detail::CompatibleInnerProductTensors<LhsTensor, RhsTensor> &&
           std::same_as<tensor_element_t<OutputTensor>, tensor_element_t<LhsTensor>>
void inner_product(BackendSelector selector, async::Async<OutputTensor>& output, async::Async<LhsTensor> const& lhs,
                   async::Async<RhsTensor> const& rhs)
{
  detail::schedule_async_inner_product_output(std::move(selector), output, lhs, rhs);
}
 
template <AsyncTensorOutput OutputTensor, TensorView LhsTensor, TensorView RhsTensor>
  requires MutableScalarTensorView<OutputTensor> && detail::CompatibleInnerProductTensors<LhsTensor, RhsTensor> &&
           std::same_as<tensor_element_t<OutputTensor>, tensor_element_t<LhsTensor>>
void inner_product(async::Async<OutputTensor>& output, async::Async<LhsTensor> const& lhs,
                   async::Async<RhsTensor> const& rhs)
{
  auto selector = linalg::select_backend_for<OutputTensor, LhsTensor, RhsTensor>(linalg::inner_product_op{});
  detail::schedule_async_inner_product_output(std::move(selector), output, lhs, rhs);
}
 
template <linalg::KernelBackendSelector BackendSelector, TensorView LhsTensor, TensorView RhsTensor>
  requires detail::CompatibleInnerProductTensors<LhsTensor, RhsTensor> &&
           detail::ReductionResultAvailable<tensor_element_t<LhsTensor>, LhsTensor, RhsTensor>
[[nodiscard]] auto inner_product(BackendSelector selector, async::Async<LhsTensor> const& lhs,
                                 async::Async<RhsTensor> const& rhs)
{
  return detail::schedule_async_inner_product(std::move(selector), lhs, rhs);
}
 
template <TensorView LhsTensor, TensorView RhsTensor>
  requires detail::CompatibleInnerProductTensors<LhsTensor, RhsTensor> &&
           detail::ReductionResultAvailable<tensor_element_t<LhsTensor>, LhsTensor, RhsTensor>
[[nodiscard]] auto inner_product(async::Async<LhsTensor> const& lhs, async::Async<RhsTensor> const& rhs)
{
  auto selector = linalg::select_backend_for<LhsTensor, RhsTensor>(linalg::inner_product_op{});
  return detail::schedule_async_inner_product(std::move(selector), lhs, rhs);
}
 
template <linalg::KernelBackendSelector BackendSelector, TensorView LhsTensor, TensorView RhsTensor>
  requires detail::CompatibleInnerProductTensors<LhsTensor, RhsTensor>
[[nodiscard]] auto inner_product_host(BackendSelector selector, async::Async<LhsTensor> const& lhs,
                                      async::Async<RhsTensor> const& rhs)
{
  return detail::schedule_async_inner_product_host(std::move(selector), lhs, rhs);
}
 
template <TensorView LhsTensor, TensorView RhsTensor>
  requires detail::CompatibleInnerProductTensors<LhsTensor, RhsTensor>
[[nodiscard]] auto inner_product_host(async::Async<LhsTensor> const& lhs, async::Async<RhsTensor> const& rhs)
{
  auto selector = linalg::select_backend_for<LhsTensor, RhsTensor>(linalg::inner_product_op{});
  return detail::schedule_async_inner_product_host(std::move(selector), lhs, rhs);
}
 
template <linalg::KernelBackendSelector BackendSelector, AsyncTensorOutput OutputTensor, TensorView InputTensor>
  requires MutableScalarTensorView<OutputTensor> && RealOrComplex<tensor_element_t<InputTensor>> &&
           std::same_as<tensor_element_t<OutputTensor>, make_real_t<tensor_element_t<InputTensor>>>
void norm(BackendSelector selector, async::Async<OutputTensor>& output, async::Async<InputTensor> const& input)
{
  detail::schedule_async_norm_output(std::move(selector), output, input);
}
 
template <AsyncTensorOutput OutputTensor, TensorView InputTensor>
  requires MutableScalarTensorView<OutputTensor> && RealOrComplex<tensor_element_t<InputTensor>> &&
           std::same_as<tensor_element_t<OutputTensor>, make_real_t<tensor_element_t<InputTensor>>>
void norm(async::Async<OutputTensor>& output, async::Async<InputTensor> const& input)
{
  auto selector = linalg::select_backend_for<OutputTensor, InputTensor>(linalg::norm_op{});
  detail::schedule_async_norm_output(std::move(selector), output, input);
}
 
template <linalg::KernelBackendSelector BackendSelector, TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           detail::ReductionResultAvailable<make_real_t<tensor_element_t<InputTensor>>, InputTensor>
[[nodiscard]] auto norm(BackendSelector selector, async::Async<InputTensor> const& input)
{
  return detail::schedule_async_norm(std::move(selector), input);
}
 
template <TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>> &&
           detail::ReductionResultAvailable<make_real_t<tensor_element_t<InputTensor>>, InputTensor>
[[nodiscard]] auto norm(async::Async<InputTensor> const& input)
{
  auto selector = linalg::select_backend_for<InputTensor>(linalg::norm_op{});
  return detail::schedule_async_norm(std::move(selector), input);
}
 
template <linalg::KernelBackendSelector BackendSelector, TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>>
[[nodiscard]] auto norm_host(BackendSelector selector, async::Async<InputTensor> const& input)
{
  return detail::schedule_async_norm_host(std::move(selector), input);
}
 
template <TensorView InputTensor>
  requires RealOrComplex<tensor_element_t<InputTensor>>
[[nodiscard]] auto norm_host(async::Async<InputTensor> const& input)
{
  auto selector = linalg::select_backend_for<InputTensor>(linalg::norm_op{});
  return detail::schedule_async_norm_host(std::move(selector), input);
}
 
} // namespace uni20