Variable.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 VARIABLE_H_INCLUDED
#define VARIABLE_H_INCLUDED
 
#include <Python.h>
#include <string>
#include <vector>

#define PY_ARRAY_UNIQUE_SYMBOL AQUA_ARRAY_API
#define NO_IMPORT_ARRAY
#include <numpy/npy_no_deprecated_api.h>
#include <numpy/ndarraytypes.h>
#include <numpy/ufuncobject.h>
#include <numpy/npy_3kcompat.h>
 
#include "sphPrerequisites.hpp"
#include "Tokenizer/Tokenizer.hpp"
 
#ifndef MAX_TYPE_NAME_LEN
#define MAX_TYPE_NAME_LEN 128
#endif
 
namespace Aqua {
namespace InputOutput {

class DECLDIR Variable
{
  public:
        Variable(const std::string varname, const std::string vartype);

        virtual ~Variable();

        virtual bool isArray() = 0;

        inline bool isScalar() { return !isArray(); }

        std::string name() const { return _name; }

        virtual std::string type() const { return _typename; }

        virtual size_t typesize() const { return 0; }

        virtual size_t size() const { return typesize(); }

        virtual inline void* get(bool UNUSED_PARAM synced = true) { return NULL; }

        inline void* get_async() { return get(false); }

        virtual void set(void* ptr, bool synced = true);

        inline void set_async(void* ptr) { set(ptr, false); }

        virtual PyObject* getPythonObject(int UNUSED_PARAM i0 = 0,
                                          int UNUSED_PARAM n = 0)
        {
                return NULL;
        }

        virtual bool setFromPythonObject(PyObject UNUSED_PARAM *obj,
                                         int UNUSED_PARAM i0 = 0,
                                         int UNUSED_PARAM n = 0)
        {
                return true;
        }

        virtual const std::string asString(bool UNUSED_PARAM synced = true)
        {
                return "";
        }


        void setEvent(cl_event event);

        inline void setWritingEvent(cl_event event) { setEvent(event); }

        inline cl_event getEvent() const { return _event; }

        inline cl_event getWritingEvent() const { return getEvent(); }

        void addReadingEvent(cl_event event);

        inline std::vector<cl_event> getReadingEvents() const
        {
                return _reading_events;
        }

        void sync(bool readonly = false);

  protected:
        void cleanReadingEvents();

        static cl_event createDummyEvent();
 
  private:
        std::string _name;

        std::string _typename;

        cl_event _event;

        std::vector<cl_event> _reading_events;

        bool _synced;

        bool _synced_for_read;
};

template<class T>
class DECLDIR ScalarVariable : public Variable
{
  public:
        ScalarVariable(const std::string varname, const std::string vartype)
          : Variable(varname, vartype)
        {
        }

        ~ScalarVariable() {};

        inline bool isArray() { return false; }

        size_t typesize() const { return sizeof(T); }

        inline void* get(bool synced = true)
        {
                if (synced)
                        sync(true);
                return &_value;
        }

        inline void get(T& value, bool synced = true)
        {
                if (synced)
                        sync(true);
                value = _value;
        }

        inline void set(void* ptr, bool synced = true)
        {
                if (synced)
                        sync();
                memcpy(&_value, ptr, sizeof(T));
                this->Variable::set(ptr, synced);
        }

        inline void set(T& value, bool synced = true)
        {
                if (synced)
                        sync();
                _value = value;
                this->Variable::set(NULL, synced);
        }

        inline T value(bool synced = true)
        {
                if (synced)
                        sync(true);
                return _value;
        }

        inline void value(T& value, bool synced = true)
        {
                this->set(value, synced);
        }

        virtual PyObject* getPythonObject(int i0 = 0, int n = 0) = 0;

        virtual bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0) = 0;

        virtual const std::string asString(bool synced) = 0;
 
  protected:
        T _value;
};

template<class T>
class DECLDIR ScalarNumberVariable : public ScalarVariable<T>
{
  public:
        ScalarNumberVariable(const std::string varname, const std::string vartype)
          : ScalarVariable<T>(varname, vartype)
        {
        }

        ~ScalarNumberVariable(){};

        virtual const std::string asString(bool synced = true);
};

class DECLDIR IntVariable final : public ScalarNumberVariable<icl>
{
  public:
        IntVariable(const std::string varname);

        ~IntVariable(){};

        PyObject* getPythonObject(int i0 = 0, int n = 0);

        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
};

class DECLDIR LongVariable final : public ScalarNumberVariable<lcl>
{
  public:
        LongVariable(const std::string varname);

        ~LongVariable(){};

        PyObject* getPythonObject(int i0 = 0, int n = 0);

        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
};

class DECLDIR UIntVariable final : public ScalarNumberVariable<uicl>
{
  public:
        UIntVariable(const std::string varname);

        ~UIntVariable(){};

        PyObject* getPythonObject(int i0 = 0, int n = 0);

        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
};

class DECLDIR ULongVariable final : public ScalarNumberVariable<ulcl>
{
  public:
        ULongVariable(const std::string varname);

        ~ULongVariable(){};

        PyObject* getPythonObject(int i0 = 0, int n = 0);

        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
};

class DECLDIR FloatVariable final : public ScalarNumberVariable<fcl>
{
  public:
        FloatVariable(const std::string varname);

        ~FloatVariable(){};

        PyObject* getPythonObject(int i0 = 0, int n = 0);

        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
};

class DECLDIR DoubleVariable final : public ScalarNumberVariable<dcl>
{
  public:
        DoubleVariable(const std::string varname);

        ~DoubleVariable(){};

        PyObject* getPythonObject(int i0 = 0, int n = 0);

        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);
};

template<class T>
class DECLDIR ScalarVecVariable : public ScalarVariable<T>
{
  public:
        ScalarVecVariable(const std::string varname,
                          const std::string vartype,
                          const unsigned int dims,
                          int np_type);

        ~ScalarVecVariable(){};

        PyObject* getPythonObject(int i0 = 0, int n = 0);

        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);

        virtual const std::string asString(bool synced = true);
 
  protected:
        bool checkPyhonObjectDims(PyObject* obj);
 
  private:
        unsigned int _dims;
        int _np_type;
};
 
#define __DECLARE_AQUA_VEC(NAME, TYPE)                                         \
        class DECLDIR NAME final : public ScalarVecVariable<TYPE>                  \
        {                                                                          \
        public:                                                                    \
                NAME(const std::string varname);                                       \
                ~NAME(){};                                                             \
        };

__DECLARE_AQUA_VEC(IVec2Variable, ivec2)
 

__DECLARE_AQUA_VEC(IVec3Variable, ivec3)

__DECLARE_AQUA_VEC(IVec4Variable, ivec4)

__DECLARE_AQUA_VEC(IVec8Variable, ivec8)

__DECLARE_AQUA_VEC(LVec2Variable, lvec2)

__DECLARE_AQUA_VEC(LVec3Variable, lvec3)

__DECLARE_AQUA_VEC(LVec4Variable, lvec4)

__DECLARE_AQUA_VEC(LVec8Variable, lvec8)

__DECLARE_AQUA_VEC(UIVec2Variable, uivec2)

__DECLARE_AQUA_VEC(UIVec3Variable, uivec3)

__DECLARE_AQUA_VEC(UIVec4Variable, uivec4)

__DECLARE_AQUA_VEC(UIVec8Variable, uivec8)

__DECLARE_AQUA_VEC(ULVec2Variable, ulvec2)

__DECLARE_AQUA_VEC(ULVec3Variable, ulvec3)

__DECLARE_AQUA_VEC(ULVec4Variable, ulvec4)

__DECLARE_AQUA_VEC(ULVec8Variable, ulvec8)

__DECLARE_AQUA_VEC(Vec2Variable, vec2)

__DECLARE_AQUA_VEC(Vec3Variable, vec3)

__DECLARE_AQUA_VEC(Vec4Variable, vec4)

__DECLARE_AQUA_VEC(Vec8Variable, vec8)

__DECLARE_AQUA_VEC(DVec2Variable, dvec2)

__DECLARE_AQUA_VEC(DVec3Variable, dvec3)

__DECLARE_AQUA_VEC(DVec4Variable, dvec4)

__DECLARE_AQUA_VEC(DVec8Variable, dvec8)

typedef IntVariable iclVariable;
typedef LongVariable lclVariable;
typedef UIntVariable uiclVariable;
typedef ULongVariable ulclVariable;
typedef FloatVariable fclVariable;
typedef DoubleVariable dclVariable;
typedef IVec2Variable ivec2Variable;
typedef IVec3Variable ivec3Variable;
typedef IVec4Variable ivec4Variable;
typedef IVec8Variable ivec8Variable;
typedef LVec2Variable lvec2Variable;
typedef LVec3Variable lvec3Variable;
typedef LVec4Variable lvec4Variable;
typedef LVec8Variable lvec8Variable;
typedef UIVec2Variable uivec2Variable;
typedef UIVec3Variable uivec3Variable;
typedef UIVec4Variable uivec4Variable;
typedef UIVec8Variable uivec8Variable;
typedef ULVec2Variable ulvec2Variable;
typedef ULVec3Variable ulvec3Variable;
typedef ULVec4Variable ulvec4Variable;
typedef ULVec8Variable ulvec8Variable;
typedef Vec2Variable vec2Variable;
typedef Vec3Variable vec3Variable;
typedef Vec4Variable vec4Variable;
typedef Vec8Variable vec8Variable;
typedef DVec2Variable dvec2Variable;
typedef DVec3Variable dvec3Variable;
typedef DVec4Variable dvec4Variable;
typedef DVec8Variable dvec8Variable;

class DECLDIR ArrayVariable : public Variable
{
  public:
        ArrayVariable(const std::string varname, const std::string vartype);

        ~ArrayVariable();

        bool isArray();

        size_t typesize() const { return sizeof(cl_mem); }

        size_t size() const;

        void* get(bool UNUSED_PARAM synced = false) { return &_value; }

        void set(void* ptr, bool synced = false);

        inline bool reallocatable() const { return _reallocatable; }

        inline void reallocatable(bool is) { _reallocatable = is; }

        PyObject* getPythonObject(int i0 = 0, int n = 0);

        bool setFromPythonObject(PyObject* obj, int i0 = 0, int n = 0);

        const std::string asString(bool synced = true);

        const std::string asString(size_t i, bool synced = true);
 
  private:
        void cleanMem();

        cl_mem _value;

        bool _reallocatable;

        std::vector<void*> _data;

        std::vector<PyObject*> _objects;
};
 
// ---------------------------------------------------------------------------
// Variables manager
// ---------------------------------------------------------------------------

class DECLDIR Variables
{
  public:
        Variables();

        ~Variables();

        void registerVariable(const std::string name,
                              const std::string type,
                              const std::string length,
                              const std::string value);

        Variable* get(unsigned int index);

        Variable* get(const std::string name);

        std::vector<Variable*> getAll() const { return _vars; }

        unsigned int size() const { return _vars.size(); }

        size_t allocatedMemory();

        static size_t typeToBytes(const std::string type);

        static unsigned int typeToN(const std::string type);

        static bool isSameType(const std::string type_a,
                               const std::string type_b,
                               bool ignore_asterisk = true);

        std::vector<Variable*> exprVariables(const std::string& expr);

        void solve(const std::string type_name,
                   const std::string value,
                   void* data,
                   const std::string name = "NULL");

        void populate(const std::string name = "");

        void populate(Variable* var);

        static std::string typeAlias(const std::string& t);
 
  private:
        void registerScalar(const std::string name,
                            const std::string type,
                            const std::string value);
        void registerClMem(const std::string name,
                           const std::string type,
                           const std::string length);

        template<typename T>
        T solve(const std::string& name, const std::string& value);

        std::vector<Variable*> _vars;
        Tokenizer tok;
};
 
}
} // namespace
 
#endif // VARIABLE_H_INCLUDED