CalcServer.hpp

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 <deque>
#include <map>
#include <string>
#include <iterator>
#include <chrono>
 
#include "aquagpusph/sphPrerequisites.hpp"
#include "aquagpusph/ProblemSetup.hpp"
#include "aquagpusph/TimeManager.hpp"
#include "aquagpusph/Variable.hpp"
#include "Tool.hpp"
 
#ifndef N_PROFILING_SNAPSHOTS
#define N_PROFILING_SNAPSHOTS 2
#endif
 
#define CHECK_OCL_OR_THROW(err_code, msg)                                      \
        if (err_code != CL_SUCCESS) {                                              \
                LOG(L_ERROR, std::string(msg) + "\n");                                 \
                Aqua::InputOutput::Logger::singleton()->printOpenCLError(err_code);    \
                throw std::runtime_error("OpenCL error");                              \
        }
 
namespace Aqua {
namespace CalcServer {
 
class UnSort;
typedef InputOutput::ProblemSetup::sphSettings::debug_opts debug_opts;

class user_interruption : public std::runtime_error
{
  public:
        user_interruption(const std::string msg)
          : std::runtime_error(msg){};
};

typedef struct _ProfilingSample
{
        Tool* tool;
        std::string name;
        cl_ulong start;
        cl_ulong end;
} ProfilingSample;

typedef struct _ProfilingSnapshot
{
        cl_ulong step;
        std::vector<ProfilingSample> samples;
} ProfilingSnapshot;

class ProfilingInfo
{
  public:
        ProfilingInfo(const cl_uint n = N_PROFILING_SNAPSHOTS)
          : _step(0)
          , _n(n)
        {
        }

        ~ProfilingInfo() {}

        inline cl_ulong step() const { return _step; }

        void sample(cl_ulong step,
                    Tool* tool,
                    std::string name,
                    cl_ulong start,
                    cl_ulong end);

        inline void sample(cl_ulong step,
                           Tool* tool,
                           Profile* substage,
                           cl_ulong start,
                           cl_ulong end)
        {
                std::string name = tool->name() + "::" + substage->name();
                auto parent = tool;
                while ((parent = parent->parent())) {
                        name = parent->name() + "::" + name;
                }
                sample(step, tool, name, start, end);
        }

        std::deque<ProfilingSnapshot> get() const;

        static inline cl_long delta(const cl_ulong& t, const cl_ulong& t0)
        {
                return (t > t0) ? t - t0 : -(cl_long)(t0 - t);
        }
 
  protected:
        void newStep();
 
  private:
        cl_ulong _step;
        cl_uint _n;
        std::deque<ProfilingSnapshot> _snapshots;
};

class DECLDIR CalcServer
  : public Aqua::CalcServer::ProfilingInfo
{
  public:
        CalcServer(const Aqua::InputOutput::ProblemSetup& sim_data);

        ~CalcServer();

        static CalcServer* singleton();

        void raiseSIGINT();

        void update(InputOutput::TimeManager& t_manager);


        void setup();

        inline InputOutput::Variables* variables() { return &_vars; }

        inline std::vector<std::string> definitions() const { return _definitions; }

        inline std::vector<Tool*> tools() const { return _tools; }

        inline cl_context context() const { return _context; }

        inline cl_platform_id platform() const { return _platform; }

        inline cl_device_id device() const { return _device; }

        inline cl_uint device_addr_bits() const { return _device_bits; }

        inline const char* device_compile_flags() const
        {
                return _device_compile_flags.c_str();
        }

        template <typename T>
        cl_int setKernelSizeArg(cl_kernel kernel,
                                cl_uint arg_index,
                                const T arg_value);
 
        enum cmd_queue
        {
                cmd_queue_current,
                cmd_queue_new,
                cmd_queue_mpi
        };

        cl_command_queue command_queue(
            cmd_queue which = cmd_queue::cmd_queue_current);

        inline cl_int finish() const
        {
                cl_int err_code = CL_SUCCESS;
                for (auto queue : _command_queues)
                        err_code |= clFinish(queue);
                err_code |= clFinish(_command_queue_parallel);
                return err_code;
        }

        std::vector<cl_event> all_events() const;

        cl_event marker() const;

        cl_event marker(cl_command_queue cmd, std::vector<cl_event> events) const;

        inline cl_ulong device_timer_offset() const { return _device_timer_offset; }

        static inline cl_ulong host_timer()
        {
                auto now = std::chrono::system_clock::now();
                return (cl_ulong)std::chrono::duration_cast<std::chrono::nanoseconds>(
                           now.time_since_epoch())
                    .count();
        }

        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 have_3d() const { return _sim_data.dims() == 3; }

        inline bool debug_mode() const
        {
                return _sim_data.settings.debug_tools;
        }

        inline bool debug_mode(debug_opts opt) const
        {
                return _sim_data.settings.debug_tools & opt;
        }

        std::tuple<std::vector<InputOutput::Variable*>,
                   std::vector<InputOutput::Variable*>>
        eventVars(cl_event event) const;

        Tool* eventTool(cl_event event) const;
 
  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_uint _device_bits;
        std::string _device_compile_flags;
        bool _is_nvidia;
        unsigned int _command_queue_current;
        std::vector<cl_command_queue> _command_queues;
        cl_command_queue _command_queue_parallel;

        cl_ulong _device_timer_offset;

        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;

        Aqua::InputOutput::ProblemSetup _sim_data;

        cl_mem __phony_mems[2];
};
 
}
} // namespace
 
#endif // CALCSERVER_H_INCLUDED