#include <cstddef>
#include <cuda_runtime.h>
#include "cfunc_linerec.cuh"
#include "cfunc_fourierrec.cuh"
#include "cfunc_filter.cuh"
namespace {
inline size_t as_size(void* p) { return reinterpret_cast<size_t>(p); }
inline size_t as_size(const void* p) { return reinterpret_cast<size_t>(p); }
}
extern "C" {
int tomoxide_cuda_device_count() {
int n = 0;
if (cudaGetDeviceCount(&n) != cudaSuccess) return 0;
return n;
}
int tomoxide_cuda_set_device(int dev) { return (int) cudaSetDevice(dev); }
int tomoxide_cuda_device_name(char* buf, size_t len) {
if (!buf || len == 0) return (int) cudaErrorInvalidValue;
int dev = 0;
cudaError_t e = cudaGetDevice(&dev);
if (e != cudaSuccess) return (int) e;
cudaDeviceProp prop;
e = cudaGetDeviceProperties(&prop, dev);
if (e != cudaSuccess) return (int) e;
size_t i = 0;
for (; i + 1 < len && prop.name[i] != '\0'; ++i) buf[i] = prop.name[i];
buf[i] = '\0';
return 0;
}
void* tomoxide_cuda_malloc(size_t bytes) {
void* p = nullptr;
if (cudaMalloc(&p, bytes) != cudaSuccess) return nullptr;
return p;
}
void tomoxide_cuda_free(void* p) { cudaFree(p); }
int tomoxide_cuda_memcpy_h2d(void* dst, const void* src, size_t bytes) {
return (int) cudaMemcpy(dst, src, bytes, cudaMemcpyHostToDevice);
}
int tomoxide_cuda_memcpy_d2h(void* dst, const void* src, size_t bytes) {
return (int) cudaMemcpy(dst, src, bytes, cudaMemcpyDeviceToHost);
}
int tomoxide_cuda_memcpy_d2d_async(void* dst, const void* src, size_t bytes, void* stream) {
return (int) cudaMemcpyAsync(dst, src, bytes, cudaMemcpyDeviceToDevice, (cudaStream_t) stream);
}
int tomoxide_cuda_memset(void* p, int value, size_t bytes) {
return (int) cudaMemset(p, value, bytes);
}
int tomoxide_cuda_sync() { return (int) cudaDeviceSynchronize(); }
int tomoxide_cuda_mem_info(size_t* free_bytes, size_t* total_bytes) {
return (int) cudaMemGetInfo(free_bytes, total_bytes);
}
void* tomoxide_cuda_stream_create() {
cudaStream_t s = nullptr;
if (cudaStreamCreate(&s) != cudaSuccess) return nullptr;
return reinterpret_cast<void*>(s);
}
void tomoxide_cuda_stream_destroy(void* s) {
if (s) cudaStreamDestroy(static_cast<cudaStream_t>(s));
}
int tomoxide_cuda_stream_sync(void* s) {
return (int) cudaStreamSynchronize(static_cast<cudaStream_t>(s));
}
void* tomoxide_cuda_host_alloc(size_t bytes) {
void* p = nullptr;
if (cudaHostAlloc(&p, bytes, cudaHostAllocDefault) != cudaSuccess) return nullptr;
return p;
}
void tomoxide_cuda_host_free(void* p) { cudaFreeHost(p); }
int tomoxide_cuda_memcpy_h2d_async(void* dst, const void* src, size_t bytes, void* stream) {
return (int) cudaMemcpyAsync(dst, src, bytes, cudaMemcpyHostToDevice,
static_cast<cudaStream_t>(stream));
}
int tomoxide_cuda_memcpy_d2h_async(void* dst, const void* src, size_t bytes, void* stream) {
return (int) cudaMemcpyAsync(dst, src, bytes, cudaMemcpyDeviceToHost,
static_cast<cudaStream_t>(stream));
}
int tomoxide_cuda_memset_async(void* p, int value, size_t bytes, void* stream) {
return (int) cudaMemsetAsync(p, value, bytes, static_cast<cudaStream_t>(stream));
}
void* tomoxide_cuda_event_create() {
cudaEvent_t e = nullptr;
if (cudaEventCreateWithFlags(&e, cudaEventDisableTiming) != cudaSuccess) return nullptr;
return reinterpret_cast<void*>(e);
}
void tomoxide_cuda_event_destroy(void* e) {
if (e) cudaEventDestroy(static_cast<cudaEvent_t>(e));
}
int tomoxide_cuda_event_record(void* e, void* stream) {
return (int) cudaEventRecord(static_cast<cudaEvent_t>(e), static_cast<cudaStream_t>(stream));
}
int tomoxide_cuda_stream_wait_event(void* stream, void* e) {
return (int) cudaStreamWaitEvent(static_cast<cudaStream_t>(stream), static_cast<cudaEvent_t>(e), 0);
}
int tomoxide_cuda_event_sync(void* e) {
return (int) cudaEventSynchronize(static_cast<cudaEvent_t>(e));
}
void* tomoxide_linerec_new(size_t nproj, size_t nz, size_t n, size_t ncproj, size_t ncz) {
return new cfunc_linerec(nproj, nz, n, ncproj, ncz);
}
int tomoxide_linerec_backproject(void* h, void* f, const void* g, const float* theta, float phi,
float axis, float gain, int sz, int rh, void* stream) {
return static_cast<cfunc_linerec*>(h)->backprojection(as_size(f), as_size(g), as_size(theta),
phi, axis, gain, sz, rh, as_size(stream));
}
int tomoxide_linerec_backproject_try(void* h, void* f, const void* g, const float* theta,
const float* sh, float phi, int sz, int rh, void* stream) {
return static_cast<cfunc_linerec*>(h)->backprojection_try(as_size(f), as_size(g), as_size(theta),
as_size(sh), phi, sz, rh,
as_size(stream));
}
int tomoxide_linerec_backproject_try_lamino(void* h, void* f, const void* g, const float* theta,
const float* phi, int sz, const int* rh, void* stream) {
return static_cast<cfunc_linerec*>(h)->backprojection_try_lamino(
as_size(f), as_size(g), as_size(theta), as_size(phi), sz, as_size(rh), as_size(stream));
}
void tomoxide_linerec_free(void* h) { delete static_cast<cfunc_linerec*>(h); }
void* tomoxide_fourierrec_new(size_t nproj, size_t nz, size_t n, const float* theta) {
auto* h = new cfunc_fourierrec(nproj, nz, n, as_size(theta));
if (!h->valid()) { delete h; return nullptr; } return h;
}
int tomoxide_fourierrec_backproject(void* h, void* f, const void* g, void* stream) {
return static_cast<cfunc_fourierrec*>(h)->backprojection(as_size(f), as_size(g), as_size(stream));
}
void tomoxide_fourierrec_free(void* h) { delete static_cast<cfunc_fourierrec*>(h); }
void* tomoxide_filter_new(size_t nproj, size_t nz, size_t n) {
auto* h = new cfunc_filter(nproj, nz, n);
if (!h->valid()) { delete h; return nullptr; } return h;
}
int tomoxide_filter_apply(void* h, void* g, const void* w, void* stream) {
return static_cast<cfunc_filter*>(h)->filter(as_size(g), as_size(w), as_size(stream));
}
void tomoxide_filter_free(void* h) { delete static_cast<cfunc_filter*>(h); }
}