repository·develop·Indexed 19 days ago
https://github.com/alpaka-group/alpakaA header-only C++20 abstraction library for parallel kernel acceleration. It provides performance portability across CPUs and GPUs (NVIDIA, AMD, Intel) using backends such as CUDA, HIP, SYCL, and OpenMP. The library utilizes a domain decomposition strategy based on a grid-blocks-threads model to allow a single kernel implementation to run on various hardware accelerators.
Catch2 provides several features that differentiate it from other C++ testing frameworks:
==, !=, etc.) but decomposes the full expression to log both the left-hand side (lhs) and right-hand side (rhs) values upon failure.Beyond basic testing, Catch2 includes several advanced capabilities:
main() is provided, but you can supply your own for integration with custom test runners or GUIs. A command line parser is still available even if you provide your own main().Catch::Approx and a full set of matchers for floating point testing.alpaka provides back-ends for several major technologies, including:
alpaka is designed for parallelization within shared memory (within a node). It is not a distributed computing library. For parallelization across nodes in a cluster, you should combine alpaka with a library like MPI (Message Passing Interface).alpaka does not handle differences in arithmetic operations (like rounding) and does not guarantee deterministic results. Reordering or repartitioning threads can lead to non-deterministic results due to the non-associativity of floating-point operations.The example/reduce directory contains a demonstration of a reduction operation designed to work across both CPU and GPU accelerators using the Alpaka library. This example showcases how to implement and execute parallel reduction kernels that are portable across different hardware back-ends.
Key components of the example include:
alpakaConfig.hpp: Manages configurations and settings specific to individual accelerators.iterator.hpp: Provides both CPU and GPU iterator implementations used to traverse data.kernel.hpp: Contains the optimized Alpaka reduction kernel implementation.reduce.cpp: The main entry point that orchestrates the reduction process.The alpaka library (Abstraction Library for Parallel Kernel Acceleration) implements an abstract interface for the hierarchical redundant parallelism model.
This model allows you to write a single version of an algorithm or kernel that can be executed across heterogeneous parallel systems (CPUs, GPUs, and other accelerators) by simply selecting the target device. It exploits task-parallelism, data-parallelism, and memory hierarchies at all levels of modern multi-core architectures.
Key benefits include:
When using the CUDA back-end in alpaka, most CUDA functionality maps directly to alpaka function calls. However, there are key differences in indexing and dimensionality:
(x, y, z) order for block and grid sizes, alpaka uses the mathematical C/C++ array indexing scheme [z][y][x]. In both systems, x is the innermost/fastest running index.Compilers may optimize away code if the result is not used. Catch2 provides a built-in way to prevent this: return the value from the benchmark block.
Any value returned by the user code in a BENCHMARK or meter.measure block is guaranteed to be evaluated and treated as an observable effect, preventing it from being optimized out. While you can still use volatile or output to stdout, returning the value is the preferred, idiomatic way.
// BAD: may be optimized away
BENCHMARK("no return"){ long_calculation(); };
// GOOD: result is guaranteed to be computed
BENCHMARK("with return"){ return long_calculation(); };cudaGetLastError or cudaGetErrorString, Alpaka handles error detection internally. When an error occurs, the details are captured and made available within the exception message thrown by the library. You do not need to call explicit error-checking functions in your application code.The SYCL back-end provides three main accelerators. These can be used to port existing alpaka code to SYCL-capable hardware:
alpaka::AccCpuSycl: Targets Intel and AMD CPUs using Intel's OpenCL implementation.alpaka::AccFpgaSyclIntel: Targets Intel FPGAs.alpaka::AccGpuSyclIntel: Targets Intel GPUs.Important Restrictions:
alpaka::AccFpgaSyclIntel cannot be used in the same project as the CPU or GPU back-ends due to different compilation requirements.double. You can enable software emulation via environment variables:export IGC_EnableDPEmulation=1
export OverrideDefaultFP64Settings=1Catch2 supports advanced testing patterns where test cases are driven by:
The SKIP macro can be used within SECTION blocks or when using GENERATE to skip specific branches of a test case without failing the entire test suite.
Behavioral Rules:
TEST_CASE is reported as skipped (unless a failing assertion occurred elsewhere in the test, in which case it is reported as failed).SKIP inside a generator's constructor to handle cases where the generator is empty without triggering a test failure.TEST_CASE("complex test case") {
int value = GENERATE(2, 4, 6);
SECTION("a") {
SECTION("a1") { CHECK(value < 8); }
SECTION("a2") {
if (value == 4) {
SKIP();
}
CHECK(value % 2 == 0);
}
}
}