KokkosBlas::axpy

Defined in header: KokkosBlas1_axpby.hpp

template <class execution_space, class AV, class XMV, class YMV>
void axpy(const execution_space& space, const AV& a, const XMV& X, const YMV& Y)

template <class AV, class XMV, class YMV>
void axpy(const AV& a, const XMV& X, const YMV& Y)

Add entries of X scaled by coeffecient a to entries of Y: Y += a*X

  1. iterate over the entries of Y and add the corresponding entries of X scaled by a using the resources of space

  2. iterate over the entries of Y and add the corresponding entries of X scaled by a using the resources of the default instance of typename XMV::execution_space

The function will throw a runtime exception if any of the following conditions are not met:

  • Y.extent(0) == X.extent(0) && Y.extent(1) == X.extent(1)

  • Kokkos::is_view_v<AV> && (a.extent(0) == 1 || a.extent(0) == X.extent(1)

Parameters

space:

execution space instance

a:

scaling factor

X, Y:

vector(s) of input and output values respectively

Type Requirements

  • execution_space must be a Kokkos execution space

  • XMV must be a Kokkos View of rank 1 or 2 that satisfies

    • Kokkos::SpaceAccessibility<execution_space, typename XMV::memory_space>::accessible == true

  • YMV must be a Kokkos View that satisfies

    • YMV::rank == XMV::rank

    • std::is_same_v<typename YMV::value_type, typename YMV::non_const_value_type> == true

    • Kokkos::SpaceAccessibility<execution_space, typename YMV::memory_space>::accessible == true

  • AV must be a scalar or a Kokkos View that satisfies

    • (AV::rank == XMV::rank - 1) || (AV::rank == 0)

    • Kokkos::SpaceAccessibility<execution_space, typename YMV::memory_space>::accessible == true

Example

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// SPDX-FileCopyrightText: Copyright Contributors to the Kokkos project

#include <Kokkos_Core.hpp>
#include <KokkosBlas1_axpby.hpp>

#include <iostream>

int main(int argc, char* argv[]) {
  Kokkos::initialize(argc, argv);
  {
    int N = 10;
    if (argc > 1) {
      N = atoi(argv[1]);
    }

    Kokkos::View<double*> x("X", N);
    Kokkos::View<double*> y("Y", N);
    Kokkos::deep_copy(x, 3.0);
    Kokkos::deep_copy(y, 2.0);

    double alpha = 1.5;

    KokkosBlas::axpy(alpha, x, y);

    double sum = 0.0;
    Kokkos::parallel_reduce(
        "CheckValue", N, KOKKOS_LAMBDA(const int& i, double& lsum) { lsum += y(i); }, sum);

    const double expected = N * (2.0 + 1.5 * 3.0);
    std::cout << "Sum: " << sum << ", Expected: " << expected << ", Diff: " << sum - expected << std::endl;
  }

  Kokkos::finalize();
}

output:

Sum: 65, Expected: 65, Diff: 0