host.h

Go to the documentation of this file.

 
#ifndef XPU_HOST_H
#define XPU_HOST_H
 
#include "defines.h"
#include "common.h"
#include "detail/common.h"
 
#include <numeric>
#include <cstddef>
#include <cstdio>
#include <cstring>
#include <functional>
#include <utility>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
namespace xpu {
 
enum direction {
    h2d = detail::dir_h2d,
 
    d2h = detail::dir_d2h,
};
 
class exception : public std::exception {
 
public:
    explicit exception(std::string_view message_) : message(message_) {}
 
    const char *what() const noexcept override { return message.c_str(); }
 
private:
    std::string message;
 
};
 
struct settings {
    std::string device = "cpu";
 
    bool verbose = false;
 
    std::function<void(std::string_view)> logging_sink = [](std::string_view msg) {
        // Use c functions for output to avoid including iostream in host.h ...
        std::fwrite(msg.data(), 1, msg.size(), stderr);
        std::fputc('\n', stderr);
    };
 
    bool profile = false;
 
    std::vector<driver_t> excluded_backends = {};
};
 
inline void initialize(settings = {});
 
template<typename I>
void preload();
 
void *malloc_device(size_t size_bytes);
 
template<typename T>
T *malloc_device(size_t elems);
 
void *malloc_pinned(size_t size_bytes);
 
template<typename T>
T *malloc_pinned(size_t elems);
 
template<typename T>
T *malloc_host(size_t elems);
 
void *malloc_managed(size_t size_bytes);
 
template<typename T>
T *malloc_managed(size_t elems);
 
inline void free(void *);
 
void stack_alloc(size_t size);
 
void stack_pop(void *head=nullptr);
 
class device {
 
public:
    static std::vector<device> all();
 
    static device active();
 
    device();
 
    explicit device(std::string_view xpuid);
 
    explicit device(int id);
 
    explicit device(driver_t driver, int device_nr);
 
    device(const device &) = default;
    device(device &&) = default;
    device &operator=(const device &) = default;
    device &operator=(device &&) = default;
 
    int id() const { return m_impl.id; }
 
    driver_t backend() const { return static_cast<driver_t>(m_impl.backend); }
 
    int device_nr() const { return m_impl.device_nr; }
 
private:
    detail::device m_impl;
 
public:
    explicit device(detail::device impl) : m_impl(std::move(impl)) {}
 
    detail::device &impl() { return m_impl; }
};
 
class device_prop {
 
public:
    device_prop() = delete;
 
    device_prop(device);
 
    std::string_view name() const { return m_prop.name; }
 
    driver_t backend() const { return static_cast<driver_t>(m_prop.driver); }
 
    std::string_view arch() const { return m_prop.arch; }
 
    size_t shared_mem_size() const { return m_prop.shared_mem_size; }
 
    size_t const_mem_size() const { return m_prop.const_mem_size; }
 
    size_t warp_size() const { return m_prop.warp_size; }
 
    size_t max_threads_per_block() const { return m_prop.max_threads_per_block; }
 
    std::array<size_t, 3> max_grid_size() const { return m_prop.max_grid_size; }
 
    std::string_view xpuid() const { return m_prop.xpuid; }
 
    int id() const { return m_prop.id; }
 
    int device_nr() const { return m_prop.device_nr; }
 
    size_t global_mem_total() const { return m_prop.global_mem_total; }
 
    size_t global_mem_available() const { return m_prop.global_mem_available; }
 
private:
    detail::device_prop m_prop;
};
 
class queue {
 
public:
    queue();
 
    explicit queue(device);
 
    template<typename T>
    void copy(buffer<T>, direction);
 
    template<typename T>
    void copy(const T *from, T *to, size_t size) { memcpy(to, from, size * sizeof(T)); }
 
    void memcpy(void *dst, const void *src, size_t size_bytes);
 
    void memset(void *dst, int value, size_t size_bytes);
 
    template<typename T>
    void memset(buffer<T>, int value);
 
    template<typename Kernel, typename... Args>
    void launch(grid params, Args&&... args);
 
    void wait();
 
private:
    std::shared_ptr<detail::queue_handle> m_handle;
 
    void do_copy(const void *from, void *to, size_t size, double *ms);
    void log_copy(const void *from, const void *to, size_t size);
};
 
template<typename Kernel>
const char *get_name();
 
template<typename Func, typename... Args>
void call(Args&&... args);
 
 
template<typename C>
void set(const typename C::data_t &symbol);
 
template<typename T>
class h_view {
 
public:
    using value_type = T;
 
    h_view() : m_data(nullptr), m_size(0) {}
 
    explicit h_view(buffer<T> &);
 
          T *data()       { return m_data; }
    const T *data() const { return m_data; }
 
    size_t size() const { return m_size; }
 
    size_t size_bytes() const { return m_size * sizeof(T); }
 
    bool empty() const { return m_size == 0; }
 
          T *begin()       { return m_data; }
    const T *begin() const { return m_data; }
 
          T *end()       { return m_data + m_size; }
    const T *end() const { return m_data + m_size; }
 
          T &front()       { return at(0); }
    const T &front() const { return at(0); }
 
          T &back()       { return at(m_size - 1); }
    const T &back() const { return at(m_size - 1); }
 
          T &operator[](size_t i);
    const T &operator[](size_t i) const;
 
          T &at(size_t i);
    const T &at(size_t i) const;
 
          T &unsafe_at(size_t i) { return m_data[i]; }
    const T &unsafe_at(size_t i) const { return m_data[i]; }
 
private:
    T *m_data;
    size_t m_size;
 
public:
    h_view(T *data, size_t size) : m_data(data), m_size(size) {}
};
 
enum class mem_type {
    pinned = detail::mem_pinned,
 
    device = detail::mem_device,
 
    managed = detail::mem_managed,
 
    host = detail::mem_host,
};
 
class ptr_prop {
 
public:
    ptr_prop() = delete;
 
    explicit ptr_prop(const void *);
 
    void *ptr() const { return m_prop.ptr; }
 
    mem_type type() const { return static_cast<mem_type>(m_prop.type); }
 
    bool is_host() const { return m_prop.type == detail::mem_host || m_prop.type == detail::mem_pinned; }
 
    xpu::device device() const { return xpu::device{m_prop.dev}; }
 
    driver_t backend() const { return static_cast<driver_t>(m_prop.dev.backend); }
 
private:
    detail::ptr_prop m_prop;
};
 
class buffer_prop {
 
public:
    buffer_prop() = delete;
    template<typename T>
    explicit buffer_prop(const buffer<T> &);
 
    size_t size() const { return m_size; }
    size_t size_bytes() const { return m_size_bytes; }
    buffer_type type() const { return m_type; }
    void *h_ptr() const { return m_host; }
    template<typename T>
    T *h_ptr() const { return static_cast<T *>(m_host); }
    void *d_ptr() const { return m_device; }
    template<typename T>
    T *d_ptr() const { return static_cast<T *>(m_device); }
 
    template<typename T>
    h_view<T> view() const { return h_view<T>{m_host, m_size}; }
 
private:
    size_t m_size_bytes;
    size_t m_size;
    void *m_host;
    void *m_device;
    buffer_type m_type;
};
 
class kernel_timings {
 
public:
    std::string_view name() const { return m_t.name; }
 
    double total() const { return std::accumulate(m_t.times.begin(), m_t.times.end(), 0.0); }
 
    const std::vector<double> &times() const { return m_t.times; }
 
    double throughput() const;
 
private:
    detail::kernel_timings m_t;
 
public:
    explicit kernel_timings(detail::kernel_timings t) : m_t(std::move(t)) {}
 
};
 
class timings {
 
public:
    timings() = default;
 
    std::string_view name() const { return m_t.name; }
 
    double wall() const { return m_t.wall; }
 
    double copy(direction dir) const {
        return dir == h2d ? m_t.copy_h2d : m_t.copy_d2h;
    }
 
    double memset() const { return m_t.memset; }
 
    template<typename K>
    kernel_timings kernel() const { return kernel(get_name<K>()); }
 
    std::vector<kernel_timings> kernels() const;
 
    double kernel_time() const {
        return std::accumulate(m_t.kernels.begin(), m_t.kernels.end(), 0.0,
            [](double a, const auto &b) { return a + std::accumulate(b.times.begin(), b.times.end(), 0.0); });
    }
 
    std::vector<timings> children() const;
 
    bool has_details() const { return m_t.has_details; }
 
    double throughput() const;
 
    double throughput_kernels() const;
 
    double throughput_copy(direction dir) const;
 
    double throughput_memset() const;
 
    void merge(const timings &other) { m_t.merge(other.m_t); }
 
private:
    detail::timings m_t;
    kernel_timings kernel(std::string_view name) const;
 
public:
    explicit timings(detail::timings t) : m_t(std::move(t)) {}
 
};
 
void push_timer(std::string_view name);
 
timings pop_timer();
 
class scoped_timer {
 
public:
    scoped_timer(std::string_view name, xpu::timings *t=nullptr);
    ~scoped_timer();
 
    scoped_timer(const scoped_timer&) = delete;
    scoped_timer& operator=(const scoped_timer&) = delete;
    scoped_timer(scoped_timer&&) = delete;
    scoped_timer& operator=(scoped_timer&&) = delete;
 
private:
    xpu::timings* m_t = nullptr;
};
 
void t_add_bytes(size_t bytes);
 
template<typename Kernel>
void k_add_bytes(size_t bytes);
 
} // namespace xpu
 
#include "impl/host.tpp"
 
#endif