heffte_common.h

/*
    -- heFFTe --
       Univ. of Tennessee, Knoxville
       @date
*/
 
#ifndef HEFFFTE_COMMON_H
#define HEFFFTE_COMMON_H
 
#include "heffte_geometry.h"
#include "heffte_trace.h"
 
namespace heffte {
 
namespace tag {
 
struct cpu{};
struct gpu{};
 
}
 
namespace backend {
 
    template<typename location_tag> struct data_manipulator{};
 
    template<> struct data_manipulator<tag::cpu> {
        using stream_type = void*;
        template<typename source_type, typename destination_type>
        static void copy_n(void*, source_type const source[], size_t num_entries, destination_type destination[]){
            std::copy_n(source, num_entries, destination);
        }
        template<typename source_type, typename destination_type>
        static void copy_n(source_type const source[], size_t num_entries, destination_type destination[]){
            std::copy_n(source, num_entries, destination);
        }
        template<typename source_type, typename destination_type>
        static void copy_device_to_host(void*, source_type const source[], size_t num_entries, destination_type destination[]){
            std::copy_n(source, num_entries, destination);
        }
        template<typename source_type, typename destination_type>
        static void copy_device_to_device(void*, source_type const source[], size_t num_entries, destination_type destination[]){
            std::copy_n(source, num_entries, destination);
        }
        template<typename source_type, typename destination_type>
        static void copy_host_to_device(void*, source_type const source[], size_t num_entries, destination_type destination[]){
            std::copy_n(source, num_entries, destination);
        }
    };
 
    struct fftw{};
    struct fftw_cos{};
    struct fftw_sin{};
 
    struct stock{};
    struct stock_cos{};
    struct stock_sin{};
 
    struct mkl{};
    struct mkl_cos{};
    struct mkl_sin{};
 
    struct cufft{};
 
    struct cufft_cos{};
    struct cufft_sin{};
 
    struct rocfft{};
    struct rocfft_cos{};
    struct rocfft_sin{};
 
    struct onemkl{};
    struct onemkl_cos{};
    struct onemkl_sin{};
 
    template<typename tag>
    struct is_enabled : std::false_type{};
 
    template<typename backend_tag, typename std::enable_if<is_enabled<backend_tag>::value, void*>::type = nullptr>
    struct buffer_traits{
        using location = tag::cpu;
        template<typename T> using container = std::vector<T>;
    };
 
    template<typename backend_tag, typename = void>
    struct uses_gpu : std::false_type{};
 
    template<typename backend_tag>
    struct uses_gpu<backend_tag,
                    typename std::enable_if<std::is_same<typename buffer_traits<backend_tag>::location, tag::gpu>::value, void>::type>
    : std::true_type{};
 
    template<typename backend_tag>
    inline std::string name(){ return "unknown"; }
 
    template<> inline std::string name<fftw>(){ return "fftw"; }
    template<> inline std::string name<fftw_cos>(){ return "fftw-cos"; }
    template<> inline std::string name<fftw_sin>(){ return "fftw-sin"; }
 
    template<> inline std::string name<stock>(){ return "stock"; }
    template<> inline std::string name<stock_cos>(){ return "stock-cos"; }
    template<> inline std::string name<stock_sin>(){ return "stock-sin"; }
 
    template<> inline std::string name<mkl>(){ return "mkl"; }
    template<> inline std::string name<mkl_cos>(){ return "mkl-cos"; }
    template<> inline std::string name<mkl_sin>(){ return "mkl-sin"; }
    template<> inline std::string name<cufft>(){ return "cufft"; }
    template<> inline std::string name<cufft_cos>(){ return "cufft-cos"; }
    template<> inline std::string name<cufft_sin>(){ return "cufft-sin"; }
 
    template<> inline std::string name<rocfft>(){ return "rocfft"; }
    template<> inline std::string name<rocfft_cos>(){ return "rocfft-cos"; }
    template<> inline std::string name<rocfft_sin>(){ return "rocfft-sin"; }
 
    template<> inline std::string name<onemkl>(){ return "onemkl"; }
    template<> inline std::string name<onemkl_cos>(){ return "onemkl-cos"; }
    template<> inline std::string name<onemkl_sin>(){ return "onemkl-sin"; }
 
    template<> inline std::string name<tag::cpu>(){ return "cpu"; }
    template<> inline std::string name<tag::gpu>(){ return "gpu"; }
 
    template<typename backend_tag>
    struct device_instance{
        device_instance(void* = nullptr){}
        virtual ~device_instance() = default;
        void* stream(){ return nullptr; }
        void* stream() const{ return nullptr; }
        void synchronize_device() const{}
        using stream_type = void*;
    };
 
    template<typename location_tag> struct default_backend{
        using type = stock;
    };
 
    template<typename backend_tag> struct uses_fft_types : std::true_type{};
 
    template<typename backend_tag, typename input, typename output, typename = void> struct check_types : std::false_type{};
 
    template<typename backend_tag, typename input, typename output> struct check_types<backend_tag, input, output,
        typename std::enable_if<uses_fft_types<backend_tag>::value and (
                      (std::is_same<input, float>::value and is_ccomplex<output>::value)
                   or (std::is_same<input, double>::value and is_zcomplex<output>::value)
                   or (is_ccomplex<input>::value and is_ccomplex<output>::value)
                   or (is_zcomplex<input>::value and is_zcomplex<output>::value)
                  )>::type> : std::true_type{};
 
    template<> struct uses_fft_types<fftw_cos> : std::false_type{};
    template<> struct uses_fft_types<fftw_sin> : std::false_type{};
    template<> struct uses_fft_types<stock_cos> : std::false_type{};
    template<> struct uses_fft_types<stock_sin> : std::false_type{};
    template<> struct uses_fft_types<mkl_cos> : std::false_type{};
    template<> struct uses_fft_types<mkl_sin> : std::false_type{};
    template<> struct uses_fft_types<cufft_cos> : std::false_type{};
    template<> struct uses_fft_types<cufft_sin> : std::false_type{};
    template<> struct uses_fft_types<rocfft_cos> : std::false_type{};
    template<> struct uses_fft_types<rocfft_sin> : std::false_type{};
    template<> struct uses_fft_types<onemkl_cos> : std::false_type{};
    template<> struct uses_fft_types<onemkl_sin> : std::false_type{};
 
    template<typename backend_tag, typename input, typename output> struct check_types<backend_tag, input, output,
        typename std::enable_if<not uses_fft_types<backend_tag>::value and (
                      (std::is_same<input, float>::value and std::is_same<output, float>::value)
                   or (std::is_same<input, double>::value and std::is_same<output, double>::value)
                  )>::type> : std::true_type{};
 
}
 
class executor_base{
public:
    virtual ~executor_base() = default;
    virtual void forward(float[], float*) const{}
    virtual void forward(double[], double*) const{}
    virtual void backward(float[], float*) const{}
    virtual void backward(double[], double*) const{}
    virtual void forward(std::complex<float>[], std::complex<float>*) const{}
    virtual void forward(std::complex<double>[], std::complex<double>*) const{}
    virtual void backward(std::complex<float>[], std::complex<float>*) const{}
    virtual void backward(std::complex<double>[], std::complex<double>*) const{}
    virtual void forward(float const[], std::complex<float>[], std::complex<float>*) const{}
    virtual void forward(double const[], std::complex<double>[], std::complex<double>*) const{}
    virtual void backward(std::complex<float>[], float[], std::complex<float>*) const{}
    virtual void backward(std::complex<double>[], double[], std::complex<double>*) const{}
    virtual int box_size() const{ return 0; }
    virtual size_t workspace_size() const{ return 0; }
    virtual int complex_size() const{ return box_size(); }
};
 
template<typename scalar_type>
std::vector<scalar_type> make_buffer_container(void*, size_t size){
    return std::vector<scalar_type>(size);
}
 
enum class direction {
    forward,
    backward
};
 
template<typename> struct one_dim_backend{};
 
template<typename backend_tag, typename index>
static std::unique_ptr<typename one_dim_backend<backend_tag>::executor> make_executor(typename backend::device_instance<typename backend::buffer_traits<backend_tag>::location>::stream_type stream,
                                                                                  box3d<index> const box, int dimension){
    return (box.empty()) ?
        std::unique_ptr<typename one_dim_backend<backend_tag>::executor>() :
        std::unique_ptr<typename one_dim_backend<backend_tag>::executor>(new typename one_dim_backend<backend_tag>::executor(stream, box, dimension));
}
template<typename backend_tag, typename index>
static std::unique_ptr<typename one_dim_backend<backend_tag>::executor> make_executor(typename backend::device_instance<typename backend::buffer_traits<backend_tag>::location>::stream_type stream,
                                                                                  box3d<index> const box, int dir1, int dir2){
    return (box.empty()) ?
        std::unique_ptr<typename one_dim_backend<backend_tag>::executor>() :
        std::unique_ptr<typename one_dim_backend<backend_tag>::executor>(new typename one_dim_backend<backend_tag>::executor(stream, box, dir1, dir2));
}
template<typename backend_tag, typename index>
static std::unique_ptr<typename one_dim_backend<backend_tag>::executor> make_executor(typename backend::device_instance<typename backend::buffer_traits<backend_tag>::location>::stream_type stream,
                                                                                  box3d<index> const box){
    return (box.empty()) ?
        std::unique_ptr<typename one_dim_backend<backend_tag>::executor>() :
        std::unique_ptr<typename one_dim_backend<backend_tag>::executor>(new typename one_dim_backend<backend_tag>::executor(stream, box));
}
template<typename backend_tag, typename index>
static std::unique_ptr<typename one_dim_backend<backend_tag>::executor_r2c> make_executor_r2c(typename backend::device_instance<typename backend::buffer_traits<backend_tag>::location>::stream_type stream,
                                                                                          box3d<index> const box, int dimension){
    return (box.empty()) ?
        std::unique_ptr<typename one_dim_backend<backend_tag>::executor_r2c>() :
        std::unique_ptr<typename one_dim_backend<backend_tag>::executor_r2c>(new typename one_dim_backend<backend_tag>::executor_r2c(stream, box, dimension));
}
 
template<typename backend_tag>
constexpr bool has_executor2d(){
    // cosine transform variants don't have a 2D/3D version yet (due to the missing kernels)
    // most backends are OK with the variants for 2D and 3D (stock isn't)
    return not (std::is_same<backend_tag, backend::stock>::value
            or std::is_same<backend_tag, backend::stock_cos>::value
            or std::is_same<backend_tag, backend::fftw_cos>::value
            or std::is_same<backend_tag, backend::mkl_cos>::value
            or std::is_same<backend_tag, backend::cufft_cos>::value
            or std::is_same<backend_tag, backend::rocfft_cos>::value
            or std::is_same<backend_tag, backend::onemkl_cos>::value
            or std::is_same<backend_tag, backend::stock_sin>::value
            or std::is_same<backend_tag, backend::fftw_sin>::value
            or std::is_same<backend_tag, backend::mkl_sin>::value
            or std::is_same<backend_tag, backend::cufft_sin>::value
            or std::is_same<backend_tag, backend::rocfft_sin>::value
            or std::is_same<backend_tag, backend::onemkl_sin>::value
            );
}
template<typename backend_tag>
constexpr bool has_executor3d(){
    return not (std::is_same<backend_tag, backend::stock>::value
            or std::is_same<backend_tag, backend::stock_cos>::value
            or std::is_same<backend_tag, backend::fftw_cos>::value
            or std::is_same<backend_tag, backend::mkl_cos>::value
            or std::is_same<backend_tag, backend::cufft_cos>::value
            or std::is_same<backend_tag, backend::rocfft_cos>::value
            or std::is_same<backend_tag, backend::onemkl_cos>::value
            or std::is_same<backend_tag, backend::stock_sin>::value
            or std::is_same<backend_tag, backend::fftw_sin>::value
            or std::is_same<backend_tag, backend::mkl_sin>::value
            or std::is_same<backend_tag, backend::cufft_sin>::value
            or std::is_same<backend_tag, backend::rocfft_sin>::value
            or std::is_same<backend_tag, backend::onemkl_sin>::value
            );
}
 
template<typename> struct default_plan_options{};
 
}
 
#endif   //  #ifndef HEFFTE_COMMON_H