matrix.cpp

Go to the documentation of this file.

/// @file core/matrix.cpp
/// @brief Backend dispatch for Matrix (= BasicMatrix<double>) operations.
///
/// Adding a new backend:
///   1. Add the enumerator to enum class Backend in include/core/policy.hpp
///   2. Create src/core/backends/<name>/ with impl.hpp and matrix.cpp
///   3. Add `case Backend::<name>:` to each switch below
///   4. Register the .cpp in cmake/sources.cmake
 
#include "core/matrix.hpp"
 
#include "backends/blas/impl.hpp"
#include "backends/gpu/impl.hpp"
#include "backends/omp/impl.hpp"
#include "backends/seq/impl.hpp"
#include "backends/simd/impl.hpp"
 
namespace num {
 
void matmul(const Matrix& A, const Matrix& B, Matrix& C, Backend b) {
    switch (b) {
        case Backend::seq:
            backends::seq::matmul(A, B, C);
            break;
        case Backend::blocked:
            backends::seq::matmul_blocked(A, B, C, 64);
            break;
        case Backend::simd:
            backends::simd::matmul(A, B, C, 64);
            break;
        case Backend::lapack:
            [[fallthrough]];
        case Backend::blas:
            backends::blas::matmul(A, B, C);
            break;
        case Backend::omp:
            backends::omp::matmul(A, B, C);
            break;
        case Backend::gpu:
            backends::gpu::matmul(A, B, C);
            break;
    }
}
 
void matvec(const Matrix& A, const Vector& x, Vector& y, Backend b) {
    switch (b) {
        case Backend::seq:
        case Backend::blocked:
            backends::seq::matvec(A, x, y);
            break;
        case Backend::simd:
            backends::simd::matvec(A, x, y);
            break;
        case Backend::lapack:
            [[fallthrough]];
        case Backend::blas:
            backends::blas::matvec(A, x, y);
            break;
        case Backend::omp:
            backends::omp::matvec(A, x, y);
            break;
        case Backend::gpu:
            backends::gpu::matvec(A, x, y);
            break;
    }
}
 
void matadd(real alpha,
            const Matrix& A,
            real beta,
            const Matrix& B,
            Matrix& C,
            Backend b) {
    switch (b) {
        case Backend::seq:
        case Backend::blocked:
        case Backend::simd:
            backends::seq::matadd(alpha, A, beta, B, C);
            break;
        case Backend::lapack:
            [[fallthrough]];
        case Backend::blas:
            backends::blas::matadd(alpha, A, beta, B, C);
            break;
        case Backend::omp:
            backends::omp::matadd(alpha, A, beta, B, C);
            break;
        case Backend::gpu:
            backends::seq::matadd(alpha, A, beta, B, C);
            break;
    }
}
 
void matmul_blocked(const Matrix& A, const Matrix& B, Matrix& C, idx block_size) {
    backends::seq::matmul_blocked(A, B, C, block_size);
}
 
void matmul_register_blocked(const Matrix& A,
                             const Matrix& B,
                             Matrix& C,
                             idx block_size,
                             idx reg_size) {
    backends::seq::matmul_register_blocked(A, B, C, block_size, reg_size);
}
 
void matmul_simd(const Matrix& A, const Matrix& B, Matrix& C, idx block_size) {
    backends::simd::matmul(A, B, C, block_size);
}
 
void matvec_simd(const Matrix& A, const Vector& x, Vector& y) {
    backends::simd::matvec(A, x, y);
}
 
} // namespace num