Gpu2D.h

Go to the documentation of this file.

/*--------------------------------*- VM2D -*-----------------*---------------*\
| ##  ## ##   ##  ####  #####   |                            | Version 1.14   |
| ##  ## ### ### ##  ## ##  ##  |  VM2D: Vortex Method       | 2026/03/06     |
| ##  ## ## # ##    ##  ##  ##  |  for 2D Flow Simulation    *----------------*
|  ####  ##   ##   ##   ##  ##  |  Open Source Code                           |
|   ##   ##   ## ###### #####   |  https://www.github.com/vortexmethods/VM2D  |
|                                                                             |
| Copyright (C) 2017-2026 I. Marchevsky, K. Sokol, E. Ryatina, A. Kolganova   |
*-----------------------------------------------------------------------------*
| File name: Gpu2D.h                                                          |
| Info: Source code of VM2D                                                   |
|                                                                             |
| This file is part of VM2D.                                                  |
| VM2D 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.                                         |
|                                                                             |
| VM2D 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 VM2D.  If not, see <http://www.gnu.org/licenses/>.               |
\*---------------------------------------------------------------------------*/
 
 
#ifndef GPU2D_H
#define GPU2D_H
 
#include <limits>
#include <memory>
 
#include "cuLib2D.cuh"
#include "Gpudefs.h"
 
#include "cudaTreeInfo.h" 
 
namespace VM2D
{
 
    class World2D;
 
    class Gpu
    {
    private:
        const World2D& W;
 
    public:
 
        //static int nReserve; //Для контроля паритета выделения и освобождения памяти
 
#if defined(__CUDACC__) || defined(USE_CUDA)
 
        int blocks;
        int* dev_blocks;
 
        template<typename T>
        void ReleaseDevMem(T* ptr, int code)
        {
            cuDeleteFromDev(ptr, code);
            //--nReserve;
        }
 
 
        template<typename T, size_t dim>
        T* ReserveDevMem(size_t n, size_t& new_n, int code = 0)
        {
            size_t nBlocks = n / CUBLOCK;
            if (n % CUBLOCK)
                nBlocks++;
 
            new_n = nBlocks * CUBLOCK;
 
            void* ptr;
 
            cuReserveDevMem(ptr, new_n * dim * sizeof(T), code);            
            //++nReserve;
 
            return (T*)ptr;
        } //ReserveDevMem(...)
 
 
        template<typename T>
        T* ReserveDevMemAndCopyFixedArray(size_t n, T* host_src)
        {
            void* dev_ptr;
 
            cuReserveDevMem(dev_ptr, n * sizeof(T));
            //++nReserve;
 
            cuCopyFixedArray(dev_ptr, host_src, sizeof(T) * n, 116);
 
            return (T*)dev_ptr;
        }//ReserveDevMemAndCopyFixedArray(...)
 
 
        template<typename T, size_t dim>
        void CopyMemFromDev(size_t n, T* dev_ptr, T* host_ptr, int code = 0) const
        {
            cuCopyMemFromDev((void*)host_ptr, (void*)dev_ptr, sizeof(T) * n * dim, code);
        };//CopyMemFromDev(...)
 
        template<typename T, size_t dim>
        void CopyMemToDev(size_t n, T* host_ptr, T* dev_ptr) const
        {
            cuCopyFixedArray((void*)dev_ptr, (void*)host_ptr, sizeof(T) * n * dim, 117);
        };//CopyMemToDev(...)
 
 
        void RefreshWake(int code = 0);
        
        void RefreshAfls(int code = 0);
        void RefreshVirtualWakes(int code = 0);
 
        void RefreshVP(int code = 0);
 
 
        // Ниже - данные для вычисления скоростей   
 
                
 
        size_t* dev_ptr_nPanels;
        size_t* dev_ptr_nVortices;
 
 
        //Переменная, которая лежит на хосте и хранит адрес на видеокарте массива, в котором хранятся указатели на соответствующие массивы
        double** dev_ptr_ptr_vtx;
        double** dev_ptr_ptr_vel;
        double** dev_ptr_ptr_rad;
        double** dev_ptr_ptr_i0;
        float** dev_ptr_ptr_i0f;
        double** dev_ptr_ptr_i1;
        double** dev_ptr_ptr_i2;
        double** dev_ptr_ptr_i3;
        float** dev_ptr_ptr_i3f;
 
        double** dev_ptr_ptr_r;
        double** dev_ptr_ptr_rhs;
 
        double** dev_ptr_ptr_freeVortexSheet;
        double** dev_ptr_ptr_attachedVortexSheet;
        double** dev_ptr_ptr_attachedSourceSheet;
 
        double** dev_ptr_ptr_meanEpsOverPanel;
 
        double** dev_ptr_ptr_viscousStresses;
 
        std::vector<size_t> n_CUDA_virtWake;
        size_t n_CUDA_totalVirtWake;
 
        size_t n_CUDA_source;
 
        size_t n_CUDA_velVP;
 
 
        size_t n_CUDA_wake; 
        
        size_t n_CUDA_afls;
 
        size_t n_CUDA_pnls;
 
        std::unique_ptr<BHcu::CudaTreeInfo> inflTreeWake;
        std::unique_ptr<BHcu::CudaTreeInfo> cntrTreeWake; 
        
        std::unique_ptr<BHcu::CudaTreeInfo> cntrTreePnl; 
        std::unique_ptr<BHcu::CudaTreeInfo> inflTreePnlVortex; 
        std::unique_ptr<BHcu::CudaTreeInfo> inflTreePnlSource;
 
        std::unique_ptr<BHcu::CudaTreeInfo> cntrTreeVP; 
 
        //для вспомогательных операций
        std::unique_ptr<BHcu::CudaTreeInfo> auxTreePnl;
        std::unique_ptr<BHcu::CudaTreeInfo> cntrTreePoint;    //точки Point2, для которых ищутся ближайшие панели 
        std::unique_ptr<BHcu::CudaTreeInfo> cntrTreeSegment;  //отрезки 2 х Point2, для которых контролируются пересечения с профилем 
 
 
        void AllocateSolution(double*& dev_sol, size_t n); 
        void SetSolution(double* sol, double* dev_sol, size_t n);
        void ReleaseSolution(double* dev_sol);
 
        double* dev_sol;
        double* dev_solLin;
 
 
#endif
 
        Gpu(const World2D& W_);
 
        ~Gpu();
 
 
        void setAccelCoeff(double cft_)
        {
#if defined(__CUDACC__) || defined(USE_CUDA)        
            cuSetAccelCoeff(cft_);
#endif
        }
 
 
        void setCollapseCoeff(double pos_, double refLength_)
        {
#if defined(__CUDACC__) || defined(USE_CUDA)        
            cuSetCollapseCoeff(pos_, refLength_);
#endif
        }
 
 
        void setMaxGamma(double gam_)
        {
#if defined(__CUDACC__) || defined(USE_CUDA)        
            cuSetMaxGamma(gam_);
#endif
        }   
 
 
        void setSchemeSwitcher(int schemeSwitcher_)
        {
#if defined(__CUDACC__) || defined(USE_CUDA)        
            cuSetSchemeSwitcher(schemeSwitcher_, 1);
#endif
        }
    };
 
}//namespace VM2D
 
 
/*
namespace VM2D 
{
    template <class T>
    class MyAlloc {
    public:
        // type definitions
        typedef T              value_type;
        typedef T*             pointer;
        typedef const T*       const_pointer;
        typedef T&             reference;
        typedef const T&       const_reference;
        typedef std::size_t    size_type;
        typedef std::ptrdiff_t difference_type;
 
        // rebind allocator to type U
        template <class U>
        struct rebind {
            typedef MyAlloc<U> other;
        };
 
        // return address of values
        pointer address(reference value) const {
            return &value;
        }
        const_pointer address(const_reference value) const {
            return &value;
        }
 
        // constructors and destructor
        // nothing to do because the allocator has no state      
        MyAlloc() throw() {
        }
        MyAlloc(const MyAlloc&) throw() {
        }
        template <class U>
        MyAlloc(const MyAlloc<U>&) throw() {
        }
        ~MyAlloc() throw() {
        }
 
        // return maximum number of elements that can be allocated
        size_type max_size() const throw() {
            return std::numeric_limits<std::size_t>::max() / sizeof(T);
        }
 
        // allocate but don't initialize num elements of type T
        pointer allocate(size_type num, const void* = 0) {
            // print message and allocate memory with global new
            //std::cerr << "allocate " << num << " element(s)"  << " of size " << sizeof(T) << std::endl;
            
            pointer ret = (pointer)(::operator new(num * sizeof(T)));
 
            //pointer ret;
            //cudaHostAlloc((void**)&ret, num * sizeof(T), cudaHostAllocDefault);
            cuAlloc((void**)&ret, num * sizeof(T));
 
            //std::cerr << " allocated at: " << (void*)ret << std::endl;
            return ret;
        }
 
        // initialize elements of allocated storage p with value value
        void construct(pointer p, const T& value) {
            // initialize memory with placement new
            new((void*)p)T(value);
            //std::cerr << " construct " << std::endl;
        }
 
        // destroy elements of initialized storage p
        void destroy(pointer p) {
            // destroy objects by calling their destructor
            p->~T();
            //std::cerr << " destroy " << std::endl;
        }
 
        // deallocate storage p of deleted elements
        void deallocate(pointer p, size_type num) {
            // print message and deallocate memory with global delete
            
            //std::cerr << "deallocate " << num << " element(s)" << " of size " << sizeof(T) << " at: " << (void*)p << std::endl;
            
            //::operator delete((void*)p);
            cuDalloc((void*)p);
        }
    };
 
    // return that all specializations of this allocator are interchangeable
    template <class T1, class T2>
    bool operator== (const MyAlloc<T1>&,
        const MyAlloc<T2>&) throw() {
        return true;
    }
    template <class T1, class T2>
    bool operator!= (const MyAlloc<T1>&,
        const MyAlloc<T2>&) throw() {
        return false;
    }
 
 
    //{
    //  // create a vector, using MyAlloc<> as allocator
    //  std::vector<int, VM2D::MyAlloc<int> > v(5, 37);
 
    //  v.resize(0);
 
    //  // insert elements
    //  // - causes reallocations
    //  v.push_back(42);
    //  v.push_back(56);
 
    //  v.reserve(10);
 
    //  v.push_back(11);
    //  v.push_back(22);
    //  v.push_back(33);
    //  v.push_back(44);
    //} 
 
}
*/
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
#endif