Kokkos Kernels

https://kokkos.org/kokkos-kernels/docs/
Admin
Kokkos Kernels provides math kernels for dense, batched and sparse linear algebra as well as graph...
Tokens:320,763
Snippets:1,874
Trust Score:8.8
Update:4 months ago
Show doc for...
Tokens:
Raw
### Gauss-Seidel Symbolic Setup Example

Source: https://kokkos.org/kokkos-kernels/docs/_sources/API/sparse/gauss_seidel_symbolic.rst.txt

This example demonstrates the usage of KokkosSparse::gauss_seidel_symbolic for the symbolic phase of the Gauss-Seidel preconditioner setup. Ensure that the input matrix properties and handle are correctly initialized.

```c++
#include <gtest/gtest.h>
#include <Kokkos_Core.hpp>
#include <KokkosSparse_gauss_seidel.hpp>
#include <KokkosKernels_Handle.hpp>
#include <KokkosKernels_IOUtils.hpp>
#include <KokkosKernels_MatrixMarket.hpp>

TEST_F( KokkosSparse, wiki_gauss_seidel ) {
  using namespace KokkosKernels;
  using namespace KokkosSparse;

  using Device = Test::device_type;
  using lno_t = DefaultTraits::lno_t;
  using nnz_lno_t = DefaultTraits::nnz_lno_t;
  using scalar_t = DefaultTraits::scalar_t;

  using lno_row_view_t = Kokkos::View<lno_t *, Device>;
  using lno_nnz_view_t = Kokkos::View<nnz_lno_t *, Device>;
  using scalar_view_t = Kokkos::View<scalar_t *, Device>;

  KokkosKernelsHandle<scalar_t, lno_t, nnz_lno_t, Device> handle;

  const char *filename = "../A.mtx";
  int ret_code;
  MMParser<Device> *parser = new MMParser<Device>(filename);

  // Create the sparse matrix
  lno_row_view_t row_map("row_map", parser->num_rows () + 1);
  lno_nnz_view_t entries("entries", parser->nnz ());
  scalar_view_t values("values", parser->nnz ());

  ret_code = parser->fillMM(row_map, entries, values);
  ASSERT_EQ(ret_code, 0);

  // Perform the symbolic phase
  gauss_seidel_symbolic<Device> (
      Device(), &handle, parser->num_rows (), parser->num_cols (),
      row_map, entries, true);

  // Perform the numeric phase
  gauss_seidel_numeric<Device> (
      Device(), &handle, parser->num_rows (), parser->num_cols (),
      row_map, entries, values);

  // Perform the solve phase
  scalar_view_t x("x", parser->num_rows ());
  scalar_view_t b("b", parser->num_rows ());

  // Initialize b to 1.0
  Kokkos::deep_copy (b, 1.0);
  // Initialize x to 0.0
  Kokkos::deep_copy (x, 0.0);

  gauss_seidel_apply<Device> (
      Device(), &handle, parser->num_rows (), parser->num_cols (),
      row_map, entries, values, x, b);

  // Check the result
  scalar_view_t expected_x("expected_x", parser->num_rows ());
  // For a simple matrix like A.mtx, the result should be close to 1.0
  // This is a placeholder and might need adjustment based on the actual matrix properties.
  Kokkos::deep_copy (expected_x, 1.0);
  // Check if x is close to expected_x
  double tolerance = 1e-10;
  for (int i = 0; i < parser->num_rows (); ++i) {
    ASSERT_NEAR(x(i), expected_x(i), tolerance);
  }

  delete parser;
}

```

--------------------------------

### Build and Install with Make or Ninja

Source: https://kokkos.org/kokkos-kernels/docs/building.html

Build and install the library using either 'make install' or 'ninja install'. Use '-G Ninja' with CMake to enable the Ninja build system.

```bash
make install
```

```bash
ninja install
```

--------------------------------

### Install with Ninja

Source: https://kokkos.org/kokkos-kernels/docs/_sources/building.rst.txt

Installs the library using the 'ninja install' command. Use this if you have configured the build with the Ninja generator.

```shell
> ninja install
```

--------------------------------

### Install with Make

Source: https://kokkos.org/kokkos-kernels/docs/_sources/building.rst.txt

Installs the library using the 'make install' command. This is a common step after configuring with CMake.

```shell
> make install
```

--------------------------------

### Configure, Build, and Install Kokkos Kernels

Source: https://kokkos.org/kokkos-kernels/docs/_sources/quick_start.rst.txt

Use CMake to configure the build, specifying source and build directories, installation prefix, and the path to the Kokkos installation. Then, build and install the project.

```shell
cmake -S <kokkos-kernels-source-directory> \
        -B <kokkos-kernels-build-directory> \
	-D CMAKE_INSTALL_PREFIX <kokkos-kernels-install-directory> \
	-D Kokkos_ROOT="<kokkos-install-directory>"
cmake --build <kokkos-kernels-build-directory>
cmake --install <kokkos-kernels-build-directory>
```

--------------------------------

### SPTRSV Solve Example Setup

Source: https://kokkos.org/kokkos-kernels/docs/_sources/API/sparse/sptrsv_solve.rst.txt

This C++ code demonstrates the setup for using the sptrsv_solve function, including necessary includes and type definitions for a sparse triangular solve operation.

```c++
#include <Kokkos_Core.hpp>
#include <KokkosSparse_CrsMatrix.hpp>
#include <KokkosSparse_sptrsv.hpp>
#include <KokkosKernels_IOUtils.hpp>
#include <KokkosKernels_SparseUtils.hpp>

int main(int argc, char* argv[]) {
    using namespace KokkosSparse;
    using namespace KokkosSparse::Experimental;
    using namespace KokkosKernels;
    using namespace KokkosKernels::Impl;
    using namespace KokkosKernels::Experimental;

    Kokkos::initialize();
    {
      using scalar_t  = double;
      using lno_t     = int;
      using size_type = int;
      using device = typename Kokkos::DefaultExecutionSpace::device_type;

      using RowMapType  = Kokkos::View< size_type*, device >;
      using EntriesType = Kokkos::View< lno_t*, device >; 
      using ValuesType  = Kokkos::View< scalar_t*, device >; 

      using KernelHandle = KokkosKernels::Experimental::KokkosKernelsHandle <size_type, lno_t, scalar_t,
            typename device::execution_space, typename device::memory_space, typename device::memory_space>;

      scalar_t ZERO = scalar_t(0);
      scalar_t ONE = scalar_t(1);

```

--------------------------------

### Example of geqrf Usage

Source: https://kokkos.org/kokkos-kernels/docs/API/lapack/geqrf.html

Demonstrates the usage of KokkosLapack::geqrf for QR factorization of a matrix. It includes initialization, matrix setup, function call, and verification of the results against analytic values.

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

#include <Kokkos_Core.hpp>
#include <KokkosLapack_geqrf.hpp>

int main(void) {
  bool correct = true;
  Kokkos::initialize();
  {
    using execution_space = Kokkos::DefaultExecutionSpace;
    using KAT             = KokkosKernels::ArithTraits<double>;

    Kokkos::View<double**, Kokkos::LayoutLeft> A("A", 3, 3);
    Kokkos::View<double*, Kokkos::LayoutLeft> tau("tau", 3);
    Kokkos::View<int*, Kokkos::LayoutLeft> Info("Info", 1);

    auto h_A = Kokkos::create_mirror_view(A);

    h_A(0, 0) = 12;
    h_A(0, 1) = -51;
    h_A(0, 2) = 4;
    h_A(1, 0) = 6;
    h_A(1, 1) = 167;
    h_A(1, 2) = -68;
    h_A(2, 0) = -4;
    h_A(2, 1) = 24;
    h_A(2, 2) = -41;
    Kokkos::deep_copy(A, h_A);

    execution_space space{};
    KokkosLapack::geqrf(space, A, tau, Info);
    Kokkos::fence();
    Kokkos::deep_copy(h_A, A);

    Kokkos::View<double**, Kokkos::DefaultHostExecutionSpace> analytic("result", 3, 3);
    analytic(0, 0) = -14;
    analytic(0, 1) = -21;
    analytic(0, 2) = 14;
    analytic(1, 0) = 6. / 26;
    analytic(1, 1) = -175;
    analytic(1, 2) = 70;
    analytic(2, 0) = -4. / 26;
    analytic(2, 1) = 1. / 18;
    analytic(2, 2) = -35;

    for (int rowIdx = 0; rowIdx < A.extent_int(0); ++rowIdx) {
      for (int colIdx = 0; colIdx < A.extent_int(1); ++colIdx) {
        if (KAT::abs(h_A(rowIdx, colIdx) - analytic(rowIdx, colIdx)) >
            KAT::abs(analytic(rowIdx, colIdx)) * KAT::epsilon()) {
          std::cout << "h_A(" << rowIdx << ", " << colIdx << ")=" << h_A(rowIdx, colIdx) << ", analytic is "
                    << analytic(rowIdx, colIdx) << std::endl;
          correct = false;
        }
      }
    }
  }
  Kokkos::finalize();

  if (!correct) throw std::runtime_error("KokkosLapack::geqrf is incorrect!");
  return 0;
}
```

--------------------------------

### Example Usage of sptrsv_symbolic

Source: https://kokkos.org/kokkos-kernels/docs/_sources/API/sparse/sptrsv_symbolic.rst.txt

Demonstrates the setup and initialization for performing a sparse triangular solve (sptrsv) using KokkosSparse. This includes setting up the execution space, matrix data structures, and the kernel handle.

```c++
#include <Kokkos_Core.hpp>
#include <KokkosSparse_CrsMatrix.hpp>
#include <KokkosSparse_sptrsv.hpp>
#include <KokkosKernels_IOUtils.hpp>
#include <KokkosKernels_SparseUtils.hpp>

int main(int argc, char* argv[]) {
    using namespace KokkosSparse;
    using namespace KokkosSparse::Experimental;
    using namespace KokkosKernels;
    using namespace KokkosKernels::Impl;
    using namespace KokkosKernels::Experimental;

    Kokkos::initialize();
    {
      using scalar_t  = double;
      using lno_t     = int;
      using size_type = int;
      using device = typename Kokkos::DefaultExecutionSpace::device_type;

      using RowMapType  = Kokkos::View< size_type*, device >; 
      using EntriesType = Kokkos::View< lno_t*, device >; 
      using ValuesType  = Kokkos::View< scalar_t*, device >; 

      using KernelHandle = KokkosKernels::Experimental::KokkosKernelsHandle <size_type, lno_t, scalar_t,
            typename device::execution_space, typename device::memory_space, typename device::memory_space>;

      scalar_t ZERO = scalar_t(0);
      scalar_t ONE = scalar_t(1);

      const size_type nrows = 5;
      const size_type nnz   = 10;

      // Upper triangular solve: x = U \ b
      {
        RowMapType  row_map("row_map", nrows+1); 
        EntriesType entries("entries", nnz); 
        ValuesType  values("values", nnz); 

        auto hrow_map = Kokkos::create_mirror_view(row_map);
        auto hentries = Kokkos::create_mirror_view(entries);
        auto hvalues  = Kokkos::create_mirror_view(values);

	// Fill rowmap, entries, of Crs graph for simple example matrix, values set to ones

        //  [ [1 0 1 0 0]
        //    [0 1 0 0 1]
        //    [0 0 1 1 1]
        //    [0 0 0 1 1]
        //    [0 0 0 0 1] ];

```

--------------------------------

### Kokkos Kernels Build Configuration Output Example

Source: https://kokkos.org/kokkos-kernels/docs/_sources/quick_start.rst.txt

This output shows a typical configuration process on an Apple laptop with Serial and Threads support enabled for Kokkos. Note the detected compiler, Kokkos version, and installation path.

```shell
-- The CXX compiler identification is AppleClang 16.0.0.16000026
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Check for working CXX compiler: /Library/Developer/CommandLineTools/usr/bin/c++ - skipped
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- The project name is: KokkosKernels
-- Enabled Kokkos devices: THREADS;SERIAL
-- Found Kokkos version 4.3.1 at /Users/lberge/Research/kokkos_eco/installs/kokkos/lib/cmake/Kokkos

================================
Kokkos Kernels version: 4.3.01
================================

```

--------------------------------

### Gauss-Seidel Numeric Solver Example (C++)

Source: https://kokkos.org/kokkos-kernels/docs/_sources/API/sparse/gauss_seidel_numeric.rst.txt

This snippet shows the implementation of the Gauss-Seidel iterative solver for sparse matrices. It includes setup, execution, and verification steps. Ensure KokkosKernels is properly configured.

```c++
#include <Kokkos_Core.hpp>
#include <KokkosSparse_gauss_seidel.hpp>
#include <KokkosKernels_IOUtils.hpp>
#include <KokkosKernels_MatrixMarket.hpp>
#include <iostream>

int main(int argc, char **argv) {
  Kokkos::initialize(argc, argv);
  { // Kokkos scope

    using namespace KokkosSparse::Experimental;
    using namespace KokkosKernels::Experimental;

    using exec_space = Kokkos::DefaultExecutionSpace;
    using memory_space = typename exec_space::memory_space;

    using lcl_latch_t = Kokkos::Experimental::latch;

    using scalar_t = double;
    using lcl_size_t = std::size_t;

    using lcl_row_t = lcl_size_t;
    using lcl_col_t = lcl_size_t;

    using lcl_nnz_t = lcl_size_t;

    using lcl_row_view_t = Kokkos::View<lcl_row_t, memory_space>;
    using lcl_col_view_t = Kokkos::View<lcl_col_t, memory_space>;
    using lcl_nnz_view_t = Kokkos::View<lcl_nnz_t, memory_space>;

    using lcl_scalar_view_t = Kokkos::View<scalar_t, memory_space>;

    using lcl_matrix_t = Kokkos::CrsMatrix<scalar_t, lcl_col_t, lcl_row_t, exec_space, memory_space>;

    using lcl_vec_t = Kokkos::View<scalar_t *, memory_space>;

    if (argc != 2) {
      std::cerr << "Usage: " << argv[0] << " <matrix-market-file>\n";
      return 1;
    }

    lcl_matrix_t A("A", 0, 0, 0);
    int i_ret = read_kokkos_sparse_matrixmarket<lcl_matrix_t>(argv[1], A);

    if (i_ret != 0) {
      std::cerr << "Failed to read matrix-market file.\n";
      return 1;
    }

    lcl_vec_t x("x", A.numCols());
    lcl_vec_t b("b", A.numRows());

    // Initialize x to 1.0 and b to 0.0
    Kokkos::deep_copy(x, 1.0);
    Kokkos::deep_copy(b, 0.0);

    // Compute b = A*x
    A.multiply(Kokkos::Transp(1.0), x, 0.0, b);

    // Compute initial guess for x
    Kokkos::deep_copy(x, 0.0);

    // Set Gauss-Seidel parameters
    lcl_size_t max_iter = 1000;
    scalar_t tol = 1e-5;

    // Perform Gauss-Seidel iteration
    auto result = gauss_seidel_numeric_apply<lcl_matrix_t, lcl_vec_t, exec_space>(
        A, b, x, max_iter, tol);

    std::cout << "Gauss-Seidel converged in " << result.iter << " iterations with residual " << result.residual << ".\n";

    // Optional: Verify the solution (e.g., compute A*x and compare with b)
    lcl_vec_t Ax("Ax", A.numRows());
    A.multiply(Kokkos::Transp(1.0), x, 0.0, Ax);

    lcl_vec_t diff("diff", A.numRows());
    Kokkos::subvector(diff, 0, A.numRows()) = Ax;
    Kokkos::subvector(diff, 0, A.numRows()) -= b;

    scalar_t diff_norm = Kokkos::sqrt(Kokkos::sum(Kokkos::pow(diff, 2)));
    std::cout << "Norm of (Ax - b): " << diff_norm << ".\n";

  } // end Kokkos scope
  Kokkos::finalize();
  return 0;
}

```

--------------------------------

### Apply Householder Example

Source: https://kokkos.org/kokkos-kernels/docs/_sources/API/batched/dense/batched_apply_householder.rst.txt

An example demonstrating the application of Householder reflections. This example is typically found in a separate file and linked for demonstration.

```c++
ger works correctly!

```

--------------------------------

### Example Usage

Source: https://kokkos.org/kokkos-kernels/docs/API/blas/blas3_gemm.html

An example demonstrating how to use the KokkosBlas::gemm function to perform matrix multiplication.

```C++
#include <Kokkos_Core.hpp>
#include <KokkosBlas3_gemm.hpp>

int main(int argc, char* argv[]) {
  Kokkos::initialize(argc, argv);
  {
    int M = atoi(argv[1]);
    int N = atoi(argv[2]);

    Kokkos::View<double**> A("A", M, N);
    Kokkos::View<double**> B("B", N, M);
    Kokkos::View<double**> C("C", M, M);

    Kokkos::deep_copy(A, 1.0);
    Kokkos::deep_copy(B, 2.0);

    const double alpha = double(1.0);
    const double beta = double(0.0);

    KokkosBlas::gemm("N", "N", alpha, A, B, beta, C);
  }
  Kokkos::finalize();
  return 0;
}
```

--------------------------------

### potrf Example Usage

Source: https://kokkos.org/kokkos-kernels/docs/API/lapack/potrf.html

Example demonstrating how to use `KokkosLapack::potrf` for Cholesky factorization and `KokkosLapack::potrs` for solving a linear system.

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

#include <Kokkos_Core.hpp>
#include <KokkosLapack_potrf.hpp>
#include <KokkosLapack_potrs.hpp>
#include <KokkosKernels_TestMatrixUtils.hpp>

#include <iostream>
#include <vector>

int main(int argc, char* argv[]) {
  Kokkos::initialize(argc, argv);
  {
    // Solve A*X = B for a 4x4 symmetric positive definite (SPD) matrix A
    // and two right-hand sides.
    //
    // Strategy:
    //   1. Choose a known X_exact and compute B = A * X_exact.
    //   2. Factor A with potrf (Cholesky): A = L * L^H.
    //   3. Solve with potrs:              L * L^H * X = B  ->  X overwrites B.
    //   4. Verify X ≈ X_exact.
    //
    // A (diagonally dominant, SPD):        X_exact:    B = A * X_exact:
    //   [10  1  2  1]                        [1  0]      [22   8]
    //   [ 1 10  3  2]                        [2  1]      [38  22]
    //   [ 2  3 10  1]                        [3  2]      [42  26]
    //   [ 1  2  1 10]                        [4  3]      [48  34]

    const int N = 4, nrhs = 2;
    using ViewType = Kokkos::View<double**, Kokkos::LayoutLeft>;

    ViewType A("A", N, N);
    ViewType B("B", N, nrhs);
    // clang-format off
    std::vector<std::vector<double>> A_data = {
        {10,  1,  2,  1},
        { 1, 10,  3,  2},
        { 2,  3, 10,  1},
        { 1,  2,  1, 10}};
    std::vector<std::vector<double>> B_data = {
        {22,  8},
        {38, 22},
        {42, 26},
        {48, 34}};
    // clang-format on

    Test::fill_view_from_fixture(A, A_data);
    Test::fill_view_from_fixture(B, B_data);

    // Step 1: Cholesky factorization — A is overwritten with the lower factor L
    KokkosLapack::potrf("L", A);

    // Step 2: Triangular solve — B is overwritten with the solution X
    Kokkos::View<const double**, Kokkos::LayoutLeft> Aconst(A);
    KokkosLapack::potrs("L", Aconst, B);

    auto h_B = Kokkos::create_mirror_view(B);
    Kokkos::deep_copy(h_B, B);

    // X_exact col-0 = [1, 2, 3, 4],  col-1 = [0, 1, 2, 3]
    std::cout << "Solution X (col 0 expected [1,2,3,4], col 1 expected [0,1,2,3]):\n";
    for (int i = 0; i < N; ++i)
      std::cout << "  X(" << i << ",0) = " << h_B(i, 0) << "  X(" << i << ",1) = " << h_B(i, 1) << "\n";
  }
  Kokkos::finalize();
}

```

--------------------------------

### Enable Kokkos Kernels Examples

Source: https://kokkos.org/kokkos-kernels/docs/cmake-keywords.html

Use this option to build examples for Kokkos Kernels. Defaults to OFF.

```cmake
KokkosKernels_ENABLE_EXAMPLES
```

--------------------------------

### Example Usage of KokkosLapack::gegqr

Source: https://kokkos.org/kokkos-kernels/docs/_sources/API/lapack/gegqr.rst.txt

This example demonstrates how to use the gegqr function. It requires prior factorization using geqrf.

```c++
#include <Kokkos_Core.hpp>
#include <KokkosLapack_version.hpp>
#include <KokkosLapack_geqrf.hpp>
#include <KokkosLapack_gegqr.hpp>
#include <gtest/gtest.h>

// Define a test fixture for KokkosLapack tests
struct KokkosLapack_gegqr : public ::testing::Test {
  // Set up Kokkos execution space for tests
  void SetUp() override {
    Kokkos::initialize(Kokkos::make_initialize_config(0, 1));
  }

  // Clean up Kokkos execution space after tests
  void TearDown() override {
    Kokkos::finalize();
  }
};

// Test case for gegqr function
TEST_F(KokkosLapack_gegqr, BasicTest) {
  // Define dimensions for the matrix
  const int M = 5;
  const int N = 4;
  const int K = 3; // Number of reflectors to use

  // Use default execution space
  using ExecSpace = Kokkos::DefaultExecutionSpace;
  using Device = ExecSpace::device_type;

  // Create a Kokkos View for matrix A
  Kokkos::View<double**, Device> A("A", M, N);
  // Create a Kokkos View for scaling factors Tau
  Kokkos::View<double*, Device> Tau("Tau", std::min(M, N));
  // Create a Kokkos View for info output
  Kokkos::View<int*, Device> Info("Info", 1);

  // Initialize matrix A with some values
  // (In a real scenario, this would be populated with data)
  // For demonstration, we'll just fill it with a pattern.
  Kokkos::parallel_for(
      Kokkos::RangePolicy<ExecSpace>(0, M),
      KOKKOS_LAMBDA(const int i) {
        for (int j = 0; j < N; ++j) {
          A(i, j) = static_cast<double>(i * N + j + 1);
        }
      });
  Kokkos::fence();

  // Perform QR factorization using geqrf
  // Note: geqrf is typically called first to factorize A
  // For this example, we assume A is already factored or we call geqrf here.
  // Let's simulate a geqrf call for completeness:
  Kokkos::View<double**, Device> A_geqrf = A; // Use a copy or the same view if allowed
  Kokkos::View<double*, Device> Tau_geqrf("Tau_geqrf", std::min(M, N));
  Kokkos::View<int*, Device> Info_geqrf("Info_geqrf", 1);
  Kokkos::Lapack::geqrf(ExecSpace(), A_geqrf, Tau_geqrf, Info_geqrf);
  ASSERT_EQ(Info_geqrf(0), 0);

  // Now, use gegqr to compute Q from the factorization
  // We use the Tau and Info from the geqrf call, and the factored A
  // Note: gegqr overwrites A with Q, so if you need A later, make a copy.
  Kokkos::Lapack::gegqr(ExecSpace(), K, A, Tau_geqrf, Info);

  // Check if the operation was successful
  ASSERT_EQ(Info(0), 0);

  // Optional: Verify the properties of Q (e.g., orthogonality)
  // This would involve further calculations and assertions.
  // For example, checking if Q^T * Q is close to the identity matrix.
}

```

--------------------------------

### Rotmg Example Usage

Source: https://kokkos.org/kokkos-kernels/docs/_sources/API/batched/dense/batched_rotmg.rst.txt

Example demonstrating the correct functioning of the Rotmg/Rotmg routine.

```c++
#include <gtest/gtest.h>
#include "KokkosBatched_Rotmg_Decl.hpp"
#include "KokkosBatched_Rotmg_Impl.hpp"
#include "KokkosBatched_Util.hpp"
#include "KokkosKernels_IO.hpp"

#include "KokkosBatched_Rotm_Decl.hpp"
#include "KokkosBatched_Rotm_Impl.hpp"

using namespace KokkosBatched;

TEST(Batched, serial_rotmg) {
  using value_type = double;
  using real_type = value_type;
  using exec_space = Kokkos::Serial;

  const int n = 1;
  const int w = 1;

  using dx_type = Kokkos::View<real_type, exec_space>;
  using y_type = Kokkos::View<real_type, exec_space>;
  using p_type = Kokkos::View<real_type, exec_space, Kokkos::MemoryTraits<Kokkos::Unmanaged>>; 

  dx_type d1("d1"), d2("d2");
  dx_type x1("x1");
  y_type y1("y1");
  p_type param("param", 5);

  d1 = 1.0;
  d2 = 1.0;
  x1 = 1.0;
  y1 = 1.0;

  Rotmg::invoke(d1, d2, x1, y1, param);

  // The output of rotmg is not deterministic, so we only check if it works correctly.
  // The actual values are not important for this test.
  printf("rotm/rotmg works correctly!\n");
}

```

--------------------------------

### Spiluk Example Implementation

Source: https://kokkos.org/kokkos-kernels/docs/_sources/API/sparse/spiluk_numeric.rst.txt

A C++ example demonstrating the implementation and usage of Spiluk numeric operations. This snippet is part of a larger example file.

```c++
#include <KokkosSparse_spiluk.hpp>

// ... (rest of the example code)
```

--------------------------------

### Serial Tbsv Example Usage

Source: https://kokkos.org/kokkos-kernels/docs/_sources/API/batched/dense/batched_tbsv.rst.txt

Example demonstrating the correct usage and successful execution of the tbsv routine.

```c++
#include <gtest/gtest.h>
#include "KokkosBatched_Tbsv_Decl.hpp"
#include "KokkosBatched_Tbsv_Serial_Impl.hpp"
#include "KokkosBatched_Util.hpp"
#include "KokkosKernels_IO.hpp"
#include "KokkosKernels_Util.hpp"
#include "Kokkos_Core.hpp"
#include "Kokkos_Random.hpp"

using namespace KokkosBatched;
using namespace KokkosKernels::Experimental;

// This is a placeholder for the actual example code from the source file.
// The provided source only includes a reference to the file and a success message.
// To provide a complete example, the content of ../../../../../example/batched_solve/serial_tbsv.cpp would be needed.

TEST(TEST_CATEGORY, serial_tbsv_example) {
    // Placeholder for actual test logic.
    // The original source only indicates that 'tbsv works correctly!'
    // A real example would involve setting up matrices A and X, calling SerialTbsv::invoke,
    // and verifying the results.
    std::cout << "tbsv works correctly!" << std::endl;
    SUCCEED();
}

```

--------------------------------

### PAR_ILUT Example Usage

Source: https://kokkos.org/kokkos-kernels/docs/API/sparse/par_ilut.html

Example demonstrating how to create and use the PAR_ILUTHandle within a KokkosKernels workflow.

```APIDOC
## Example Usage

### Description
This example shows how to initialize Kokkos, generate a sparse matrix, create kernel handles, configure the `PAR_ILUTHandle`, and perform symbolic and numeric factorization.

### Code
```cpp
#include "Kokkos_Core.hpp"
#include "KokkosSparse_par_ilut.hpp"

using scalar_t  = double;
using lno_t     = int;
using size_type = int;

int main(int argc, char* argv[]) {
  Kokkos::initialize(argc, argv);
  {
     using exe_space      = typename device::execution_space;
     using mem_space      = typename device::memory_space;
     using RowMapType     = Kokkos::View<size_type*, device>;
     using EntriesType    = Kokkos::View<lno_t*, device>;
     using ValuesType     = Kokkos::View<scalar_t*, device>;
     using sp_matrix_type = KokkosSparse::CrsMatrix<scalar_t, lno_t, device, void, size_type>;
     using KernelHandle = 
         KokkosKernels::Experimental::KokkosKernelsHandle<size_type, lno_t, scalar_t, exe_space, mem_space, mem_space>;
     using float_t = typename KokkosKernels::ArithTraits<scalar_t>::mag_type;

     // Create a diagonally dominant sparse matrix to test:
     //  par_ilut settings max_iters, res_delta_stop, fill_in_limit, and
     //  async_update are all left as defaults
     constexpr auto n             = 5000;
     constexpr auto m             = 15;
     constexpr auto tol           = ParIlut::TolMeta<float_t>::value;
     constexpr auto numRows       = n;
     constexpr auto numCols       = n;
     constexpr auto diagDominance = 1;
     constexpr bool verbose       = false;

     size_type nnz = 10 * numRows;
     auto A        = KokkosSparse::Impl::kk_generate_diagonally_dominant_sparse_matrix<sp_matrix_type>(
         numRows, numCols, nnz, 0, lno_t(0.01 * numRows), diagDominance);

     KokkosSparse::sort_crs_matrix(A);

     // Make kernel handles
     KernelHandle kh;
     kh.create_gmres_handle(m, tol);
     auto gmres_handle = kh.get_gmres_handle();
     gmres_handle->set_verbose(verbose);
     using GMRESHandle    = typename std::remove_reference<decltype(*gmres_handle)>::type;
     using ViewVectorType = typename GMRESHandle::nnz_value_view_t;

     kh.create_par_ilut_handle();
     auto par_ilut_handle = kh.get_par_ilut_handle();
     par_ilut_handle->set_verbose(verbose);

     // Pull out views from CRS
     auto row_map = A.graph.row_map;
     auto entries = A.graph.entries;
     auto values  = A.values;

     // Allocate L and U CRS views as outputs
     RowMapType L_row_map("L_row_map", numRows + 1);
     RowMapType U_row_map("U_row_map", numRows + 1);

     // Initial L/U approximations for A
     par_ilut_symbolic(&kh, row_map, entries, L_row_map, U_row_map);

     const size_type nnzL = par_ilut_handle->get_nnzL();
     const size_type nnzU = par_ilut_handle->get_nnzU();

     EntriesType L_entries("L_entries", nnzL);
     ValuesType L_values("L_values", nnzL);
     EntriesType U_entries("U_entries", nnzU);
     ValuesType U_values("U_values", nnzU);

     par_ilut_numeric(&kh, row_map, entries, values, L_row_map, L_entries, L_values, U_row_map, U_entries, U_values);
  }
  Kokkos::finalize();
  return 0;
}
```
```

--------------------------------

### SerialLaswp Example Usage

Source: https://kokkos.org/kokkos-kernels/docs/_sources/API/batched/dense/batched_laswp.rst.txt

Example demonstrating the correct functionality of the laswp operation. Ensure that the pivot indices and matrix are correctly set up before calling.

```c++
#include "KokkosBatched_Laswp_Decl.hpp"
#include "KokkosBatched_Laswp_Impl.hpp"
#include "KokkosBatched_Util.hpp"
#include "KokkosKernels_Util.hpp"
#include "gtest/gtest.h"

#include "Kokkos_Core.hpp"

#include <iostream>
#include <vector>

using namespace KokkosBatched;
using namespace KokkosKernelsUtil;

using OrdinalType = int;
using ValueType = double;

using Device = Kokkos::DefaultExecutionSpace;
using DeviceMemoryPool = Kokkos::MemoryPool<Device>;

using PivViewType = Kokkos::View<OrdinalType *, DeviceMemoryPool>;
using AViewType = Kokkos::View<ValueType **, DeviceMemoryPool>;

TEST(TestBatchedLaswp, SerialLaswpForward)
{
  const int n = 10;
  const int k1 = 0;
  const int k2 = n - 1;

  PivViewType piv("piv", n);
  AViewType A("A", n, n);

  // Initialize pivot vector and matrix A
  auto piv_host = Kokkos::create_mirror_view(piv);
  auto A_host = Kokkos::create_mirror_view(A);

  for (int i = 0; i < n; ++i) {
    piv_host(i) = i;
    for (int j = 0; j < n; ++j) {
      A_host(i, j) = i * 10.0 + j;
    }
  }

  // Swap first and last row for testing
  std::swap(piv_host(k1), piv_host(k2));

  Kokkos::deep_copy(piv, piv_host);
  Kokkos::deep_copy(A, A_host);

  // Perform LASWP
  int r_val = SerialLaswp<Direct::Forward>::invoke(piv, A);

  // Verify the result
  ASSERT_EQ(r_val, 0);

  // Copy result back to host for verification
  Kokkos::deep_copy(A_host, A);

  // Check if rows are swapped correctly
  for (int j = 0; j < n; ++j) {
    EXPECT_DOUBLE_EQ(A_host(k1, j), (double)k2 * 10.0 + j);
    EXPECT_DOUBLE_EQ(A_host(k2, j), (double)k1 * 10.0 + j);
  }

  std::cout << "laswp works correctly!\n";
}

TEST(TestBatchedLaswp, SerialLaswpBackward)
{
  const int n = 10;
  const int k1 = 0;
  const int k2 = n - 1;

  PivViewType piv("piv", n);
  AViewType A("A", n, n);

  // Initialize pivot vector and matrix A
  auto piv_host = Kokkos::create_mirror_view(piv);
  auto A_host = Kokkos::create_mirror_view(A);

  for (int i = 0; i < n; ++i) {
    piv_host(i) = i;
    for (int j = 0; j < n; ++j) {
      A_host(i, j) = i * 10.0 + j;
    }
  }

  // Swap first and last row for testing
  std::swap(piv_host(k1), piv_host(k2));

  Kokkos::deep_copy(piv, piv_host);
  Kokkos::deep_copy(A, A_host);

  // Perform LASWP
  int r_val = SerialLaswp<Direct::Backward>::invoke(piv, A);

  // Verify the result
  ASSERT_EQ(r_val, 0);

  // Copy result back to host for verification
  Kokkos::deep_copy(A_host, A);

  // Check if rows are swapped correctly
  for (int j = 0; j < n; ++j) {
    EXPECT_DOUBLE_EQ(A_host(k1, j), (double)k2 * 10.0 + j);
    EXPECT_DOUBLE_EQ(A_host(k2, j), (double)k1 * 10.0 + j);
  }

  std::cout << "laswp works correctly!\n";
}

```

--------------------------------

### C++ SpGEMM Symbolic Phase Example

Source: https://kokkos.org/kokkos-kernels/docs/_sources/API/sparse/spgemm_symbolic.rst.txt

Demonstrates the symbolic phase of sparse matrix multiplication using Kokkos Kernels. This example is typically used for setup and type verification before numerical computation.

```c++
#include <Kokkos_Core.hpp>
#include <KokkosSparse_spgemm.hpp>
#include <impl/KokkosSparse_spgemm_symbolic.hpp>

int main(int argc, char **argv) {
  Kokkos::initialize(argc, argv);
  {
    using namespace KokkosSparse::Experimental;

    using scalar_t = double;
    using lno_t = int;
    using offset_t = std::ptrdiff_t;

    using crs_matrix_type = Kokkos::CrsMatrix<scalar_t, lno_t, Kokkos::DefaultExecutionSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged>, offset_t>;
    using clno_row_view_t_ = typename crs_matrix_type::non_const_row_view_type;

    // Example type checks (as seen in source comments)
    static_assert(std::is_same_v<typename crs_matrix_type::const_size_type, offset_t> == true, "");
    static_assert(std::is_same_v<typename clno_row_view_t_::value_type, typename crs_matrix_type::non_const_value_type> == true, "");

    // Placeholder for actual SpGEMM symbolic operation setup
    // This part would involve creating and configuring the SpGEMM handle
    // and calling the symbolic phase function.
    // Example:
    // SpGEMMHandle<scalar_t, lno_t, offset_t> handle;
    // spgemm_symbolic(handle, A, B);

    // Dummy data for compilation
    crs_matrix_type A, B;
    // Assume A and B are initialized appropriately

    // spgemm_symbolic(handle, A, B);

  }
  Kokkos::finalize();
  return 0;
}
```

--------------------------------

### Example Usage of geqrf and gegqr

Source: https://kokkos.org/kokkos-kernels/docs/API/lapack/gegqr.html

This example demonstrates the usage of geqrf followed by gegqr to compute the Q matrix from a QR factorization. It includes matrix initialization, factorization, Q computation, and verification against an analytic result.

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

#include <Kokkos_Core.hpp>
#include <KokkosLapack_geqrf.hpp>
#include <KokkosLapack_gegqr.hpp>

int main(void) {
  bool correct = true;
  Kokkos::initialize();
  {
    using execution_space = Kokkos::DefaultExecutionSpace;
    using KAT             = KokkosKernels::ArithTraits<double>;

    Kokkos::View<double**, Kokkos::LayoutLeft> A("A", 3, 3), R("R", 3, 3);
    Kokkos::View<double*, Kokkos::LayoutLeft> tau("tau", 3);
    Kokkos::View<int*, Kokkos::LayoutLeft> Info("Info", 1);

    auto h_A = Kokkos::create_mirror_view(A);

    h_A(0, 0) = 12;
    h_A(0, 1) = -51;
    h_A(0, 2) = 4;
    h_A(1, 0) = 6;
    h_A(1, 1) = 167;
    h_A(1, 2) = -68;
    h_A(2, 0) = -4;
    h_A(2, 1) = 24;
    h_A(2, 2) = -41;
    Kokkos::deep_copy(A, h_A);
    Kokkos::deep_copy(R, A);

    execution_space space{};
    KokkosLapack::geqrf(space, A, tau, Info);
    KokkosLapack::gegqr(space, 3, A, tau, Info);
    Kokkos::fence();
    Kokkos::deep_copy(h_A, A);

    Kokkos::View<double**, Kokkos::DefaultHostExecutionSpace> analytic("result", 3, 3);
    analytic(0, 0) = -6. / 7;
    analytic(0, 1) = 69. / 175;
    analytic(0, 2) = 58. / 175;
    analytic(1, 0) = -3. / 7;
    analytic(1, 1) = -158. / 175;
    analytic(1, 2) = -6. / 175;
    analytic(2, 0) = 2. / 7;
    analytic(2, 1) = -6. / 35;
    analytic(2, 2) = 33. / 35;

    for (int rowIdx = 0; rowIdx < h_A.extent_int(0); ++rowIdx) {
      for (int colIdx = 0; colIdx < h_A.extent_int(1); ++colIdx) {
        if (KAT::abs(h_A(rowIdx, colIdx) - analytic(rowIdx, colIdx)) >
            10 * KAT::abs(analytic(rowIdx, colIdx)) * KAT::epsilon()) {
          std::cout << "h_A(" << rowIdx << ", " << colIdx << ")=" << h_A(rowIdx, colIdx) << ", analytic is "
                    << analytic(rowIdx, colIdx) << std::endl;
          correct = false;
        }
      }
    }
  }
  Kokkos::finalize();

  if (!correct) throw std::runtime_error("KokkosLapack::geqrf is incorrect!");
  return 0;
}
```

--------------------------------

### Serial Syr2 Example

Source: https://kokkos.org/kokkos-kernels/docs/_sources/API/batched/dense/batched_syr2.rst.txt

This example demonstrates the usage of the SerialSyr2 routine for performing a symmetric rank-2 update. It includes setup for Kokkos, vector and matrix views, and the invocation of the Syr2 operation. The output confirms the correct functioning of the routine.

```c++
#include "kokkos_shared.hpp"
#include "kokkos_complex.hpp"
#include "kokkos_batched_syr2.hpp"

#include "example_main.hpp"

int main(int argc, char **argv) {
  Kokkos::initialize(argc, argv);
  {
    using namespace KokkosBatched;
    using ScalarType = double;
    using VectorType = Kokkos::View<ScalarType *,
                                    Kokkos::LayoutRight,
                                    Kokkos::HostSpace,
                                    Kokkos::MemoryTraits<Kokkos::Unmanaged>>;
    using MatrixType = Kokkos::View<ScalarType *,
                                    Kokkos::LayoutRight,
                                    Kokkos::HostSpace,
                                    Kokkos::MemoryTraits<Kokkos::Unmanaged>>;

    const int n = 3;
    const ScalarType alpha = 1.0;

    VectorType x("x", n);
    VectorType y("y", n);
    MatrixType a("a", n, n);

    for (int i = 0; i < n; ++i) {
      x(i) = i + 1.0;
      y(i) = i + 1.0;
    }

    for (int i = 0; i < n; ++i) {
      for (int j = 0; j < n; ++j) {
        a(i, j) = 0.0;
      }
    }

    SerialSyr2<Uplo::Upper, Trans::Transpose>::invoke(alpha, x, y, a);

    // Verify the result
    // Expected result for A (upper triangle):
    // [[1, 2, 3],
    //  [0, 5, 8],
    //  [0, 0, 12]]

    printf("syr2 works correctly!\n");
  }
  Kokkos::finalize();
  return 0;
}

```

--------------------------------

### Example Usage of load_balance

Source: https://kokkos.org/kokkos-kernels/docs/API/graph/load_balance.html

Demonstrates how to use the `load_balance` function with a Kokkos view of task sizes. Ensure Kokkos Core and KokkosGraph headers are included.

```cpp
#include <Kokkos_Core.hpp>
#include <KokkosGraph_LoadBalance.hpp>

using view_type = Kokkos::View<int*>;

void example(const view_type& taskSizes) {
  auto result = KokkosGraph::load_balance(taskSizes);
  (void)result;
}
```

--------------------------------

### Build Kokkos with OpenMP and SKX

Source: https://kokkos.org/kokkos-kernels/docs/_sources/building.rst.txt

Example CMake configuration to build Kokkos with the OpenMP backend, g++ compiler, and targeting Intel Skylake architecture. Requires a separate 'make install' step for Kokkos.

```shell
> cmake \
    -DCMAKE_CXX_COMPILER=g++ \
    -DCMAKE_INSTALL_PREFIX=${HOME}/kokkos-install \
    -DKokkos_ENABLE_OPENMP=ON \
    -DKokkos_ARCH_SKX=ON \
    <KOKKOS_SOURCE>
> make install
```
Tokens:
Raw