9
1
mirror of https://github.com/QuantumPackage/qp2.git synced 2024-11-14 01:13:38 +01:00
qp2/plugins/local/gpu_intel/gpu.sycl

178 lines
5.7 KiB
Plaintext
Raw Normal View History

2024-07-09 21:11:13 +02:00
#include <CL/sycl.hpp>
#include <cassert>
#include <limits>
#include <oneapi/mkl/blas.hpp>
extern "C" {
/* Generic functions */
int gpu_ndevices() {
return 1;
}
void gpu_set_device(int32_t igpu) {
}
/* Allocation functions */
void gpu_allocate(void** ptr, int64_t size) {
2024-07-09 22:02:13 +02:00
auto queue = sycl::queue(sycl::default_selector_v);
2024-07-09 21:11:13 +02:00
try {
*ptr = sycl::malloc_shared(size, queue);
assert(*ptr != nullptr);
} catch (const sycl::exception& e) {
std::cerr << "SYCL exception caught: " << e.what() << std::endl;
*ptr = nullptr; // If allocation fails, set pointer to nullptr
}
}
void gpu_deallocate(void** ptr) {
assert(*ptr != nullptr);
2024-07-09 22:02:13 +02:00
sycl::free(*ptr, sycl::queue(sycl::default_selector_v));
2024-07-09 21:11:13 +02:00
*ptr = nullptr;
}
/* Upload data from host to device */
void gpu_upload(const void* cpu_ptr, void* gpu_ptr, const int64_t n) {
2024-07-09 22:02:13 +02:00
sycl::queue queue(sycl::default_selector_v);
2024-07-09 21:11:13 +02:00
queue.memcpy(gpu_ptr, cpu_ptr, n).wait();
}
/* Download data from device to host */
void gpu_download(const void* gpu_ptr, void* cpu_ptr, const int64_t n) {
2024-07-09 22:02:13 +02:00
sycl::queue queue(sycl::default_selector_v);
2024-07-09 21:11:13 +02:00
queue.memcpy(cpu_ptr, gpu_ptr, n).wait();
}
/* Copy data from one GPU memory location to another */
void gpu_copy(const void* gpu_ptr_src, void* gpu_ptr_dest, const int64_t n) {
2024-07-09 22:02:13 +02:00
sycl::queue queue(sycl::default_selector_v);
2024-07-09 21:11:13 +02:00
queue.memcpy(gpu_ptr_dest, gpu_ptr_src, n).wait();
}
/* Queues */
/* SYCL queue as a replacement for CUDA stream */
void gpu_stream_create(sycl::queue** ptr) {
2024-07-09 22:02:13 +02:00
*ptr = new sycl::queue(sycl::default_selector_v);
2024-07-09 21:11:13 +02:00
}
void gpu_stream_destroy(sycl::queue** ptr) {
assert(*ptr != nullptr);
delete *ptr;
*ptr = nullptr;
}
void gpu_synchronize() {
2024-07-09 22:02:13 +02:00
sycl::queue queue(sycl::default_selector_v);
2024-07-09 21:11:13 +02:00
queue.wait_and_throw();
}
/* BLAS functions */
typedef struct {
sycl::queue* queue;
} blasHandle_t;
void gpu_set_stream(blasHandle_t* handle, sycl::queue* ptr) {
handle->queue = ptr;
}
2024-07-09 22:02:13 +02:00
void gpu_blas_create(blasHandle_t** ptr) {
*ptr = (blasHandle_t*) malloc(sizeof(blasHandle_t));
2024-07-09 21:11:13 +02:00
assert(*ptr != nullptr);
2024-07-09 22:02:13 +02:00
(*ptr)->queue = new sycl::queue(sycl::default_selector_v);
assert((*ptr)->queue != nullptr);
2024-07-09 21:11:13 +02:00
}
2024-07-09 22:02:13 +02:00
void gpu_blas_destroy(blasHandle_t** ptr) {
2024-07-09 21:11:13 +02:00
assert(*ptr != nullptr);
2024-07-09 22:02:13 +02:00
delete (*ptr)->queue;
free(*ptr);
2024-07-09 21:11:13 +02:00
*ptr = nullptr;
}
void gpu_ddot(blasHandle_t* handle, const int64_t n, const double* x, const int64_t incx,
const double* y, const int64_t incy, double* result) {
// Ensure input parameters are valid
assert(handle != nullptr);
assert(handle->queue != nullptr);
assert(n > 0);
assert(incx > 0);
assert(incy > 0);
assert(x != nullptr);
assert(y != nullptr);
assert(result != nullptr);
2024-07-09 22:02:13 +02:00
oneapi::mkl::blas::dot(*handle->queue, n, x, incx, y, incy, result);
2024-07-09 21:11:13 +02:00
}
void gpu_dgemv(blasHandle_t* handle, const char* transa, const int64_t m, const int64_t n, const double* alpha,
const double* a, const int64_t lda, const double* x, const int64_t incx, const double* beta, double* y, const int64_t incy) {
assert(handle != nullptr);
assert(handle->queue != nullptr);
// Validate matrix dimensions and increments to be positive
assert(m > 0 && n > 0 && lda > 0 && incx > 0 && incy > 0);
assert(a != nullptr && x != nullptr && y != nullptr && alpha != nullptr && beta != nullptr);
// Determine the operation type
oneapi::mkl::transpose transa_ = oneapi::mkl::transpose::nontrans;
if (*transa == 'T' || *transa == 't') {
transa_ = oneapi::mkl::transpose::trans;
}
// Perform DGEMV operation using oneMKL
2024-07-09 22:02:13 +02:00
oneapi::mkl::blas::column_major::gemv(*handle->queue, transa_, m, n, *alpha, a, lda, x, incx, *beta, y, incy);
2024-07-09 21:11:13 +02:00
}
void gpu_dgemm(blasHandle_t* handle, const char* transa, const char* transb, const int64_t m, const int64_t n, const int64_t k, const double* alpha,
const double* a, const int64_t lda, const double* b, const int64_t ldb, const double* beta, double* c, const int64_t ldc) {
assert(handle != nullptr && handle->queue != nullptr);
assert(m > 0 && n > 0 && k > 0 && lda > 0 && ldb > 0 && ldc > 0);
assert(a != nullptr && b != nullptr && c != nullptr && alpha != nullptr && beta != nullptr);
// Transpose operations
auto transa_ = (*transa == 'T' || *transa == 't') ? oneapi::mkl::transpose::trans : oneapi::mkl::transpose::nontrans;
auto transb_ = (*transb == 'T' || *transb == 't') ? oneapi::mkl::transpose::trans : oneapi::mkl::transpose::nontrans;
2024-07-09 22:02:13 +02:00
oneapi::mkl::blas::column_major::gemm(*handle->queue, transa_, transb_, m, n, k,
*alpha, a, lda, b, ldb, *beta, c, ldc);
2024-07-09 21:11:13 +02:00
}
2024-07-09 22:02:13 +02:00
2024-07-09 21:11:13 +02:00
void gpu_dgeam(blasHandle_t* handle, const char* transa, const char* transb, const int64_t m, const int64_t n, const double* alpha,
const double* a, const int64_t lda, const double* beta, const double* b, const int64_t ldb, double* c, const int64_t ldc) {
assert(handle != nullptr && handle->queue != nullptr);
assert(m > 0 && n > 0 && lda > 0 && ldb > 0 && ldc > 0);
assert(a != nullptr && b != nullptr && c != nullptr && alpha != nullptr && beta != nullptr);
// Determine transpose operations
bool transA = (*transa == 'T' || *transa == 't');
bool transB = (*transb == 'T' || *transb == 't');
handle->queue->submit([&](sycl::handler& cgh) {
cgh.parallel_for(sycl::range<2>(m, n), [=](sycl::id<2> idx) {
2024-07-09 22:02:13 +02:00
const int i = idx[0];
const int j = idx[1];
const int ai = transA ? j * lda + i : i * lda + j;
const int bi = transB ? j * ldb + i : i * ldb + j;
const int ci = i * ldc + j;
2024-07-09 21:11:13 +02:00
2024-07-09 22:02:13 +02:00
c[ci] = (*alpha) * a[ai] + (*beta) * b[bi];
2024-07-09 21:11:13 +02:00
});
});
}
} // extern C