common.h

Go to the documentation of this file.

 
#ifndef XPU_COMMON_H
#define XPU_COMMON_H
 
#include "detail/common.h"
#include "defines.h"
#include "detail/buffer_registry.h"
 
namespace xpu {
 
enum driver_t {
    cpu = detail::cpu,
    cuda = detail::cuda,
    hip = detail::hip,
    sycl = detail::sycl,
};
 
struct dim {
    int x = -1;
    int y = -1;
    int z = -1;
 
    dim() = default;
    constexpr dim(int _x) : x(_x) {}
    constexpr dim(int _x, int _y) : x(_x), y(_y) {}
    constexpr dim(int _x, int _y, int _z) : x(_x), y(_y), z(_z) {}
 
    constexpr int ndims() const { return 3 - (y < 0) - (z < 0); }
 
    constexpr int linear() const {
        return x * (y <= 0 ? 1 : y) * (z <= 0 ? 1 : z);
    }
 
    #if XPU_IS_HIP || XPU_IS_CUDA
    ::dim3 as_cuda_grid() const { return ::dim3{(unsigned int)x, (unsigned int)y, (unsigned int)z}; }
    #endif
};
 
struct grid {
 
    dim nblocks;
    dim nthreads;
 
    inline void get_compute_grid(dim &block_dim, dim &grid_dim) const;
 
private:
    friend inline grid n_blocks(dim);
    friend inline grid n_threads(dim);
    grid(dim b, dim t);
 
};
 
inline grid n_blocks(dim nblocks);
 
inline grid n_threads(dim nthreads);
 
enum buffer_type {
    buf_pinned = detail::buf_pinned,
    buf_device = detail::buf_device,
    buf_managed = detail::buf_managed,
    buf_io = detail::buf_io,
    buf_stack = detail::buf_stack,
};
 
template<typename T>
class buffer {
 
public:
    using value_type = T;
 
    buffer() = default;
 
    buffer(size_t N, buffer_type type, T *data = nullptr);
 
    #if XPU_IS_CUDA || XPU_IS_HIP
    // Hack to allow putting buffers into constant memory
    ~buffer() = default;
    #else
    XPU_H XPU_D ~buffer() {
        #if !XPU_IS_DEVICE_CODE
        remove_ref();
        #endif
    }
    #endif
 
    XPU_H XPU_D buffer(const buffer &other);
    XPU_H XPU_D buffer(buffer &&other);
    XPU_H XPU_D buffer &operator=(const buffer &other);
    XPU_H XPU_D buffer &operator=(buffer &&other);
 
    template<typename U>
    XPU_H XPU_D buffer(const buffer<U> &other);
 
    template<typename U>
    XPU_H XPU_D buffer(buffer<U> &&other);
 
    template<typename U>
    XPU_H XPU_D buffer &operator=(const buffer<U> &other);
 
    template<typename U>
    XPU_H XPU_D buffer &operator=(buffer<U> &&other);
 
    XPU_H XPU_D void reset();
    void reset(size_t N, buffer_type type, T *data = nullptr);
 
    XPU_H XPU_D T *get() const { return m_data; }
 
    XPU_H XPU_D T &operator*() const { return *m_data; }
    XPU_H XPU_D T *operator->() const { return m_data; }
 
    XPU_H XPU_D T &operator[](size_t i) const { return m_data[i]; }
 
private:
    // Don't initialize buffer in cuda & hip, so it can be used in constant and shared memory
    T *m_data
        #if !XPU_IS_CUDA && !XPU_IS_HIP
            = nullptr
        #endif
    ;
 
    XPU_H XPU_D void add_ref();
    XPU_H XPU_D void remove_ref();
};
 
} // namespace xpu
 
#include "impl/common.tpp"
 
#endif