CalcServer.h

Go to the documentation of this file.

/*
 *  This file is part of AQUAgpusph, a free CFD program based on SPH.
 *  Copyright (C) 2012  Jose Luis Cercos Pita <jl.cercos@upm.es>
 *
 *  AQUAgpusph is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  AQUAgpusph is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with AQUAgpusph.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef CALCSERVER_H_INCLUDED
#define CALCSERVER_H_INCLUDED
 
#include <vector>
#include <map>
#include <string>
#include <iterator>
 
#include <sphPrerequisites.h>
#include <ProblemSetup.h>
#include <TimeManager.h>
#include <Variable.h>
#include <Singleton.h>
#include <CalcServer/Tool.h>
 
#ifndef _ITEMS
#define _ITEMS 128
#endif
 
#ifndef _GROUPS
#define _GROUPS 32
#endif
 
namespace Aqua {
namespace CalcServer {
 
class UnSort;
 
class user_interruption : public std::runtime_error
{
  public:
        user_interruption(const std::string msg)
          : std::runtime_error(msg){};
};
 
class CalcServer : public Aqua::Singleton<Aqua::CalcServer::CalcServer>
{
  public:
        CalcServer(const Aqua::InputOutput::ProblemSetup& sim_data);
 
        ~CalcServer();
 
        void update(InputOutput::TimeManager& t_manager);
 
 
        void setup();
 
        InputOutput::Variables* variables() { return &_vars; }
 
        std::vector<std::string> definitions() const { return _definitions; }
 
        std::vector<Tool*> tools() const { return _tools; }
 
        cl_context context() const { return _context; }
 
        cl_platform_id platform() const { return _platform; }
 
        cl_device_id device() const { return _device; }
 
        cl_command_queue command_queue(bool parallel = false) const
        {
                if (parallel)
                        return _command_queue_parallel;
                return _command_queue;
        }
 
        cl_event getUnsortedMem(const std::string var_name,
                                size_t offset,
                                size_t cb,
                                void* ptr);
 
        const std::string base_path() const { return _base_path.c_str(); }
 
        inline bool debug_mode() const { return _sim_data.settings.debug_tools; }
  private:
        void setupOpenCL();
        void queryOpenCL();
        void setupPlatform();
        void setupDevices();
 
        cl_uint _num_platforms;
        cl_platform_id* _platforms;
        cl_uint _num_devices;
        cl_device_id* _devices;
        cl_context _context;
        cl_platform_id _platform;
        cl_device_id _device;
        cl_command_queue _command_queue;
        cl_command_queue _command_queue_parallel;
 
        InputOutput::Variables _vars;
 
        std::vector<std::string> _definitions;
 
        std::vector<Tool*> _tools;
 
        std::string _base_path;
 
        char* _current_tool_name;
 
        std::map<std::string, UnSort*> unsorters;
 
  private:
        Aqua::InputOutput::ProblemSetup _sim_data;
};
 
}
} // namespace
 
#endif // CALCSERVER_H_INCLUDED