Telegram-канал r_cpp - C++ - Reddit: Unsorted - каталог телеграмм

C++ - Reddit

28 May 2025 07:23

Kokkos vs OpenMP performance on multi-core CPUs?

Does anyone have experience on OpenMP vs Kokkos performance on multicore CPUs? I am seeing papers on its GPU performance, but when I tested Kokkos against a basic OpenMP implementation of 2D Laplace equation with Jacobi, I saw a 3-4x difference (with OpenMP being the faster one). Not sure if I am doing it right since I generated the Kokkos code using an LLM. I wanted to see if its worth it before getting into it.
The OpenMP code itself is slower than a pure MPI implementation, but from what I am reading in textbooks thats well expected. I am also seeing no difference in speed for the equivalent Fortran and C++ codes.

The Kokkos code: (generated via LLM): Takes about 6-7 seconds on my PC with 16 OMP threads

#include <iostream>
#include <cmath> // For std::abs, std::max (Kokkos::abs used in kernel)
#include <cstdlib> // For std::rand, RAND_MAX
#include <ctime> // For std::time
#include <utility> // For std::swap

#include <Kokkos_Core.hpp>

#define NX (128 * 8 + 2) // Grid points in X direction (including boundaries)
#define NY (128 * 6 + 2) // Grid points in Y direction (including boundaries)
#define MAX_ITER 10000 // Maximum number of iterations
#define TOL 1.0e-6 // Tolerance for convergence

int main(int argc, char* argv[]) {
// Initialize Kokkos. This should be done before any Kokkos operations.
Kokkos::initialize(argc, argv);
{

std::cout << "Using Kokkos with execution space: " << Kokkos::DefaultExecutionSpace::name() << std::endl;
Kokkos::View<double**> phi_A("phi_A", NX, NY);
Kokkos::View<double**> phi_B("phi_B", NX, NY);

// Host-side view for initialization.
Kokkos::View<double**, Kokkos::HostSpace> phi_init_host("phi_init_host", NX, NY);

std::srand(static_cast<unsigned int>(std::time(nullptr))); // Seed random number generator
for (int j = 0; j < NY; ++j) {
for (int i = 0; i < NX; ++i) {
phi_init_host(i, j) = static_cast<double>(std::rand()) / RAND_MAX;
}
}

for (int i = 0; i < NX; ++i) { // Iterate over x-direction
phi_init_host(i, 0) = 0.0;
phi_init_host(i, NY - 1) = 0.0;
}
// For columns (left and right boundaries: x=0 and x=NX-1)
for (int j = 0; j < NY; ++j) { // Iterate over y-direction
phi_init_host(0, j) = 0.0;
phi_init_host(NX - 1, j) = 0.0;
}

Kokkos::deep_copy(phi_A, phi_init_host);
Kokkos::deep_copy(phi_B, phi_init_host); .
Kokkos::fence("InitialDataCopyToDeviceComplete");

std::cout << "Start solving with Kokkos (optimized with ping-pong buffering)..." << std::endl;
Kokkos::Timer timer; // Kokkos timer for measuring wall clock time

Kokkos::View<double**>* phi_current_ptr = &phi_A;
Kokkos::View<double**>* phi_next_ptr = &phi_B;

int iter;
double maxres = 0.0; // Stores the maximum residual found in an iteration

for (iter = 1; iter <= MAX_ITER; ++iter) {
auto& P_old = *phi_current_ptr; // View to read from (previous iteration's values)
auto& P_new = *phi_next_ptr; // View to write to (current iteration's values)
Kokkos::parallel_for("JacobiUpdate",
Kokkos::MDRangePolicy<Kokkos::Rank<2>>({1, 1}, {NY - 1, NX - 1}),
// KOKKOS_FUNCTION: Marks lambda for device compilation.
[=] KOKKOS_FUNCTION (const int j, const int i) { // j: y-index, i: x-index
P_new(i, j) = 0.25 * (P_old(i + 1, j) + P_old(i - 1, j) +
P_old(i, j + 1) + P_old(i, j - 1));
});
maxres = 0.0; // Reset maxres for the current iteration's reduction (host