backend_manager.hpp

Go to the documentation of this file.

#ifndef PARALUTION_BACKEND_MANAGER_HPP_
#define PARALUTION_BACKEND_MANAGER_HPP_

#include <iostream>
#include <fstream>

namespace paralution {

template <typename ValueType>
class AcceleratorVector;
template <typename ValueType>
class AcceleratorMatrix;
template <typename ValueType>
class HostMatrix;

struct Paralution_Backend_Descriptor {

  // set by initbackend();
  bool init;

  // current backend
  int backend;
  bool accelerator;
  bool disable_accelerator;

  // OpenMP threads
  int OpenMP_threads;
  // OpenMP threads before PARALUTION init
  int OpenMP_def_threads;
  // OpenMP nested before PARALUTION init
  int OpenMP_def_nested;
  // Host affinity (true-yes/false-no)
  bool OpenMP_affinity;
  // Host threshold size
  int OpenMP_threshold;

  // GPU section
  // gpu handles
  // cublasHandle_t casted in void **
  void *GPU_cublas_handle;
  // cusparseHandle_t casted in void **
  void *GPU_cusparse_handle;

  int GPU_dev;
  int GPU_warp;
  int GPU_block_size;
  int GPU_max_threads;

  // OCL section
  // ocl handle
  void *OCL_handle;

  int OCL_plat;
  int OCL_dev;
  size_t OCL_max_work_group_size;
  size_t OCL_computeUnits;
  int OCL_warp_size;

  // MIC section
  int MIC_dev;

  // Software marker 
  // DO NOT REMOVE
  char marker[15];
  
  std::ofstream *log_file;
};
  
extern struct Paralution_Backend_Descriptor _Backend_Descriptor;

extern const std::string _paralution_host_name [1];

extern const std::string _paralution_backend_name [4];

enum _paralution_backend_id {None=0,
                             GPU=1,
                             OCL=2,
                             MIC=3};



int init_paralution(void);

int stop_paralution(void);

int set_device_paralution(int dev);

void set_omp_threads_paralution(int nthreads);

void set_omp_affinity(bool affinity);

void set_gpu_cuda_paralution(int ngpu);

void set_ocl_paralution(int nplatform, int ndevice);

void set_ocl_platform_paralution(int platform);

void set_ocl_work_group_size_paralution(size_t size);

void set_ocl_compute_units_paralution(size_t cu);

void set_ocl_warp_size_paralution(int size);

void set_omp_threshold(const int threshold);

void info_paralution(void);

void info_paralution(const struct Paralution_Backend_Descriptor backend_descriptor);

bool _paralution_available_accelerator(void);

void disable_accelerator_paralution(const bool onoff=true);

struct Paralution_Backend_Descriptor *_get_backend_descriptor(void);

void _set_backend_descriptor(const struct Paralution_Backend_Descriptor backend_descriptor);

void _set_omp_backend_threads(const struct Paralution_Backend_Descriptor backend_descriptor,
                              const int size);

template <typename ValueType>
AcceleratorVector<ValueType>* _paralution_init_base_backend_vector(const struct Paralution_Backend_Descriptor backend_descriptor);

template <typename ValueType>
HostMatrix<ValueType>* _paralution_init_base_host_matrix(const struct Paralution_Backend_Descriptor backend_descriptor,
                                                         const unsigned int matrix_format);

template <typename ValueType>
AcceleratorMatrix<ValueType>* _paralution_init_base_backend_matrix(const struct Paralution_Backend_Descriptor backend_descriptor,
                                                                   const unsigned int matrix_format);

void _paralution_sync(void);

size_t _paralution_add_obj(class ParalutionObj* ptr);
bool _paralution_del_obj(class ParalutionObj* ptr,
                         size_t id);
void _paralution_delete_all_obj(void);
bool _paralution_check_if_any_obj(void);

}

#endif // PARALUTION_BACKEND_MANAGER_HPP_