PSFEstimationwithCPSO
cl_factory.hpp
00001 /*
00002  * cl_factory.hpp
00003  *
00004  *  Created on: 15/07/2012
00005  *  Author: Peter Frank Perroni (pfperroni@inf.ufpr.br)
00006  */
00007 
00008 #ifndef CL_FACTORY_HPP_
00009 #define CL_FACTORY_HPP_
00010 
00011 #include <iostream>
00012 #include <map>
00013 #include <CL/cl.h>
00014 #include <CL/opencl.h>
00015 #include <CL/cl_platform.h>
00016 #include "viennacl/vector.hpp"
00017 #include "config.hpp"
00018 #include "util.hpp"
00019 
00020 using namespace std;
00021 
00026 typedef struct {
00027         cl_kernel kernel_instance;
00028         omp_lock_t *mutex;
00029 } kernel_t;
00030 
00035 typedef struct {
00036         cl_program program;
00037         kernel_t cl_generate_phase, cl_power_spec, cl_reduce, cl_multiply_complexarr, cl_resize_psf,
00038                 cl_multiply_doublearr, cl_multiply_fftw_complex_arrays, cl_calc_cost, cl_adjust_fft,
00039                 cl_calc_mismatch, cl_real2complex, cl_complex2real, cl_cpso, cl_real;
00040         omp_lock_t mutex;
00041 } kernel_set;
00042 
00043 typedef struct {
00044         cl_context context;
00045         cl_device_id *devices;
00046         int n_devices;
00047         kernel_set *kernels;
00048 } context_t;
00049 
00053 class clQueue{
00054         cl_context context;
00055         cl_device_id device;
00056         cl_command_queue command_queue;
00057 
00058 public:
00059         kernel_set *kernels;
00060 
00061         clQueue(cl_context _context, cl_device_id _device, cl_command_queue _command_queue){
00062                 context = _context;
00063                 device = _device;
00064                 command_queue = _command_queue;
00065         }
00066 
00067         cl_context getContext() {return context;}
00068 
00069         cl_command_queue getCommandQueue() {return command_queue;}
00070 
00071         cl_program getProgram() {return (kernels!=NULL) ? kernels->program : NULL;}
00072 
00073         cl_device_id getDevice() {return device;}
00074 };
00075 
00084 class clFactory{
00085         static cl_context *context;
00086         static map<cl_context, context_t*> contexts;
00087         static map<cl_device_id, omp_lock_t*> devices;
00088 
00089         static omp_lock_t mutex, mutex_queue;
00090         static int n_contexts;
00091         static int n_queues;
00092         static int curr_queue;
00093         static int curr_context;
00094         static vector<clQueue*> queues;
00095 
00096         static void initialize_gpu(vector<int> *_devices);
00097 
00098         static void createContext(vector<int> *_devices);
00099 
00100         static void  createCommandQueue(context_t *_context);
00101 
00102         static char* readCl();
00103 
00104         static cl_program createProgram(cl_context _context, cl_device_id _device, char *src);
00105 
00106         static cl_kernel createKernel(cl_program program, const char *kernel_name);
00107 
00108         static kernel_set* initialize_cl(cl_context context, cl_program program);
00109 
00110         static kernel_set* clone_kernels(kernel_set *kernels, omp_lock_t *_mutex);
00111 
00112         static void finalize_cl();
00113 
00114         static int countDevicesFromHardware();
00115 
00116         static void getDevices(cl_context _context, context_t *context_data);
00117 
00118 public:
00119         static void startup();
00120 
00121         static void startup(vector<int> *devices);
00122 
00123         static void shutdown();
00124 
00125         static clQueue* getQueue();
00126 
00127         static void disposeQueue(clQueue *clqueue);
00128 
00129         static void getDeviceName(clQueue* queues, char *deviceName, int nameSize);
00130 
00131         static int getNumAvailableContexts();
00132 
00133         static int getNumAvailableDevices();
00134 
00135 };
00136 
00137 #endif /* CL_FACTORY_HPP_ */
 All Classes Functions