VM2D::Gpu Class Reference

Класс, обеспечивающий возможность выполнения вычислений на GPU по технологии Nvidia CUDA. More...

#include <Gpu2D.h>

Collaboration diagram for VM2D::Gpu:

Public Member Functions
	Gpu (const World2D &W_)
	Конструктор
	~Gpu ()
void	setAccelCoeff (double cft_)
	Установка коэффициента разгона потока
void	setCollapseCoeff (double pos_, double refLength_)
	Установка правой границы самого правого профиля (для организации увеличения радиуса коллапса)
void	setMaxGamma (double gam_)
	Установка максимально допустимой циркуляции вихря
void	setSchemeSwitcher (int schemeSwitcher_)
	Установка переключателя расчетных схем

Private Attributes
const World2D &	W
	Константная ссылка на решаемую задачу

Detailed Description

Класс, обеспечивающий возможность выполнения вычислений на GPU по технологии Nvidia CUDA.

Author

Марчевский Илья Константинович

Сокол Ксения Сергеевна

Рятина Евгения Павловна

Колганова Александра Олеговна

\Version 1.14

Date

6 марта 2026 г.

Definition at line 68 of file Gpu2D.h.

Constructor & Destructor Documentation

Gpu()

Gpu::Gpu

(

const World2D &

W_

)

Конструктор

Parameters

[in]

W_

константная ссылка на решаемую задачу

Definition at line 56 of file Gpu2D.cpp.

    : W(W_)
{
#if defined(__CUDACC__) || defined(USE_CUDA)
 
 
// Откомментировать следующую строку, если запускается счет на кластере, каждый узел которого  
// имеет несколько видеокарт, при этом хочется одновременно решать несколько задач --- каждую на своей видеокарте ---
// каждая задача по своему номеру, деленному по модулю числа видеокарт на узле будет привязана к своей видеокарте;
// на каждый узел при этом отправлять СТОЛЬКО MPI-нитей, СКОЛЬКО ТАМ ВИДЕОКАРТ;
// число задач НАСТОЯТЕЛЬНО РЕКОМЕНДУЕТСЯ ВЫБИРАТЬ ТОЧНО РАВНЫМ СУММАРНОМУ ЧИСЛУ ВИДЕОКАРТ,
// т.е. чтобы все задачи стартовали сразу же.
//
// Uncomment the following string if the program runs on the computer cluster with several graphic cards on every node
// and you want to solve several tasks simultaneously --- EVERY TASK ON ITS OWN GRAPHIC CARD;
// every task will be associated with separate graphic card;
// send THE SAME AMOUNT OF MPI-THREADS for the node as THE NUMBER OF GRAPHIC CARDS on this node;
// IT IS STRONGLY RECOMMENDED TO CHOOSE THE NUMBER OF TASKS EXACTLY EQUAL TO TOTAL VIDEO CARDs NUMBERS,
// i.e. to start all the tasks simultaneously.
                                        
 
//  blocks = cuSelect(W.getPassport().problemNumber % 4); //The index of the used video card will be equal to the task number
                                             // in the task list (to modulo 4 --- number of graphic cards on each node) 
 
    blocks = cuSelect(0); //The index of the used video card will be equal to the task number
    cuReserveDevMem((void*&)dev_blocks, sizeof(int), 0);
    cuCopyFixedArray(dev_blocks, &blocks, sizeof(int), 0);
   
    cuSetConstants(sizeof(Vortex2D)/sizeof(double), Vortex2D::offsPos / sizeof(double), Vortex2D::offsGam / sizeof(double) );
    
    n_CUDA_wake = 0;
    inflTreeWake.reset(new BHcu::CudaTreeInfo(blocks, tree_T::vortex, object_T::point3, scheme_T::noScheme, true));
    cntrTreeWake.reset(new BHcu::CudaTreeInfo(blocks, tree_T::contr, object_T::point3, scheme_T::noScheme, false));
    
    scheme_T sch;
    switch (W.getPassport().numericalSchemes.boundaryCondition.second)
    {
    case 1:
        sch = scheme_T::constScheme;
        break;
    case 2:
        sch = scheme_T::linScheme;
        break;
    }
    cntrTreePnl.reset(new BHcu::CudaTreeInfo(blocks, tree_T::contr, object_T::panel, sch, false));
    inflTreePnlVortex.reset(new BHcu::CudaTreeInfo(blocks, tree_T::vortex, object_T::panel, sch, false));
    inflTreePnlSource.reset(new BHcu::CudaTreeInfo(blocks, tree_T::source, object_T::panel, sch, false));
 
    n_CUDA_velVP = 0;
    cntrTreeVP.reset(new BHcu::CudaTreeInfo(blocks, tree_T::contr, object_T::point2, scheme_T::noScheme, false));
 
    //вспомогательное дерево панелей для контроля протыкания
    auxTreePnl.reset(new BHcu::CudaTreeInfo(blocks, tree_T::aux, object_T::panel, scheme_T::noScheme, false));
    cntrTreePoint.reset(new BHcu::CudaTreeInfo(blocks, tree_T::contr, object_T::point2, scheme_T::noScheme, false));
    cntrTreeSegment.reset(new BHcu::CudaTreeInfo(blocks, tree_T::contr, object_T::panel, scheme_T::noScheme, false));
 
    n_CUDA_source = 0;
    n_CUDA_afls = 0;
    n_CUDA_pnls = 0;
 
#endif
}

Here is the call graph for this function:

~Gpu()

Gpu::~Gpu

(

)

Definition at line 120 of file Gpu2D.cpp.

{
#if defined(__CUDACC__) || defined(USE_CUDA)
    ReleaseDevMem(W.getWake().devVtxPtr, 1);
    ReleaseDevMem(W.getWake().devVelPtr, 2);
    ReleaseDevMem(W.getWake().devRadPtr, 3);
    ReleaseDevMem(W.getWake().devI0Ptr, 4);
    ReleaseDevMem(W.getWake().devI0fPtr, 4);
    ReleaseDevMem(W.getWake().devI1Ptr, 5);
    ReleaseDevMem(W.getWake().devI2Ptr, 6);
    ReleaseDevMem(W.getWake().devI3Ptr, 7);
    ReleaseDevMem(W.getWake().devI3fPtr, 7);
 
    ReleaseDevMem(W.getWake().devMeshPtr, 8);
    ReleaseDevMem(W.getWake().devNeiPtr, 9);
    ReleaseDevMem(W.getWake().devNearestPanelPtr, 9);
 
    if (W.getSource().vtx.size() > 0)
        ReleaseDevMem(W.getSource().devVtxPtr, 10);
 
    if (W.getNumberOfAirfoil() > 0)
    for (size_t s = 0; s < 1/*n_CUDA_afls*/; ++s)
    {
        ReleaseDevMem(W.getBoundary(s).virtualWake.devVtxPtr, 11);
        ReleaseDevMem(W.getBoundary(s).virtualWake.devVelPtr, 12);
        ReleaseDevMem(W.getBoundary(s).virtualWake.devRadPtr, 13);
        ReleaseDevMem(W.getBoundary(s).virtualWake.devI0Ptr, 14);
        ReleaseDevMem(W.getBoundary(s).virtualWake.devI0fPtr, 14);
        ReleaseDevMem(W.getBoundary(s).virtualWake.devI1Ptr, 15);
        ReleaseDevMem(W.getBoundary(s).virtualWake.devI2Ptr, 16);
        ReleaseDevMem(W.getBoundary(s).virtualWake.devI3Ptr, 17);
        ReleaseDevMem(W.getBoundary(s).virtualWake.devI3fPtr, 17);
 
        ReleaseDevMem(W.getBoundary(s).afl.devRPtr, 18);
        ReleaseDevMem(W.getBoundary(s).afl.devPsnPtr, 181);
        ReleaseDevMem(W.getBoundary(s).afl.devRhsPtr, 19);
        ReleaseDevMem(W.getBoundary(s).afl.devRhsLinPtr, 191);
 
        ReleaseDevMem(W.getBoundary(s).afl.devFreeVortexSheetPtr, 20);
        ReleaseDevMem(W.getBoundary(s).afl.devAttachedVortexSheetPtr, 21);
        ReleaseDevMem(W.getBoundary(s).afl.devAttachedSourceSheetPtr, 22);
 
        ReleaseDevMem(W.getBoundary(s).afl.devFreeVortexSheetLinPtr, 20);
        ReleaseDevMem(W.getBoundary(s).afl.devAttachedVortexSheetLinPtr, 21);
        ReleaseDevMem(W.getBoundary(s).afl.devAttachedSourceSheetLinPtr, 22);
 
        ReleaseDevMem(W.getBoundary(s).afl.devMeanEpsOverPanelPtr, 23);
        ReleaseDevMem(W.getBoundary(s).afl.devViscousStressesPtr, 24);
    }
 
    if (n_CUDA_afls)
    {       
        ReleaseDevMem(dev_ptr_nPanels, 25);
        ReleaseDevMem(dev_ptr_nVortices, 26);
 
        ReleaseDevMem(dev_ptr_ptr_vtx, 27);
        ReleaseDevMem(dev_ptr_ptr_vel, 28);
        ReleaseDevMem(dev_ptr_ptr_rad, 29);
        ReleaseDevMem(dev_ptr_ptr_i0, 30);
        ReleaseDevMem(dev_ptr_ptr_i0f, 30);
        ReleaseDevMem(dev_ptr_ptr_i1, 31);
        ReleaseDevMem(dev_ptr_ptr_i2, 32);
        ReleaseDevMem(dev_ptr_ptr_i3, 33);
        ReleaseDevMem(dev_ptr_ptr_i3f, 33);
                
        ReleaseDevMem(dev_ptr_ptr_r, 34);
        ReleaseDevMem(dev_ptr_ptr_rhs, 35);
 
        ReleaseDevMem(dev_ptr_ptr_freeVortexSheet, 36);
        ReleaseDevMem(dev_ptr_ptr_attachedVortexSheet, 37);
        ReleaseDevMem(dev_ptr_ptr_attachedSourceSheet, 38);
 
        ReleaseDevMem(dev_ptr_ptr_meanEpsOverPanel, 39);
 
        ReleaseDevMem(dev_ptr_ptr_viscousStresses, 40);
    }
        
    if (W.getMeasureVP().getWakeVP().vtx.size())
    {
        ReleaseDevMem(W.getMeasureVP().getWakeVP().devVtxPtr, 41);
        ReleaseDevMem(W.getMeasureVP().getWakeVP().devVelPtr, 42);
        ReleaseDevMem(W.getMeasureVP().getWakeVP().devRadPtr, 43);
    }
 
    ReleaseDevMem(dev_blocks, 44);
#endif
}

Here is the call graph for this function:

Member Function Documentation

setAccelCoeff()

void VM2D::Gpu::setAccelCoeff ( double  cft_ )

inline

Установка коэффициента разгона потока

Parameters

[in]

cft_

множитель, соответствующий степени разгона потока

Definition at line 272 of file Gpu2D.h.

        {
#if defined(__CUDACC__) || defined(USE_CUDA)        
            cuSetAccelCoeff(cft_);
#endif
        }

Here is the caller graph for this function:

setCollapseCoeff()

void VM2D::Gpu::setCollapseCoeff ( double  pos_, double  refLength_  )

inline

Установка правой границы самого правого профиля (для организации увеличения радиуса коллапса)

Parameters

[in]	pos_	абсцисса правой границы самого правого профиля
[in]	refLength_	характерная длина, на которой происходит увеличение радиуса коллапса

Definition at line 284 of file Gpu2D.h.

        {
#if defined(__CUDACC__) || defined(USE_CUDA)        
            cuSetCollapseCoeff(pos_, refLength_);
#endif
        }

Here is the caller graph for this function:

setMaxGamma()

void VM2D::Gpu::setMaxGamma ( double  gam_ )

inline

Установка максимально допустимой циркуляции вихря

Parameters

[in]

gam_

максимально допустимая циркуляция вихря

Definition at line 295 of file Gpu2D.h.

        {
#if defined(__CUDACC__) || defined(USE_CUDA)        
            cuSetMaxGamma(gam_);
#endif
        }   

Here is the caller graph for this function:

setSchemeSwitcher()

void VM2D::Gpu::setSchemeSwitcher ( int  schemeSwitcher_ )

inline

Установка переключателя расчетных схем

Parameters

[in]

schemeSwitcher_

тип схемы schemeSwitcher = 0 – схема типа МДВ schemeSwitcher = 1 – кусочно-постоянная схема schemeSwitcher = 2 – кусочно-линейная схема

Definition at line 309 of file Gpu2D.h.

        {
#if defined(__CUDACC__) || defined(USE_CUDA)        
            cuSetSchemeSwitcher(schemeSwitcher_, 1);
#endif
        }

Here is the caller graph for this function:

Member Data Documentation

W

const World2D& VM2D::Gpu::W

private

Константная ссылка на решаемую задачу

Definition at line 72 of file Gpu2D.h.

---

The documentation for this class was generated from the following files:

• VM2D/Gpu2D/Gpu2D.h
• VM2D/Gpu2D/Gpu2D.cpp