CudaMemoryManager.h

Go to the documentation of this file.

//=======================================================================================
// ____          ____    __    ______     __________   __      __       __        __
// \    \       |    |  |  |  |   _   \  |___    ___| |  |    |  |     /  \      |  |
//  \    \      |    |  |  |  |  |_)   |     |  |     |  |    |  |    /    \     |  |
//   \    \     |    |  |  |  |   _   /      |  |     |  |    |  |   /  /\  \    |  |
//    \    \    |    |  |  |  |  | \  \      |  |     |   \__/   |  /  ____  \   |  |____
//     \    \   |    |  |__|  |__|  \__\     |__|      \________/  /__/    \__\  |_______|
//      \    \  |    |   ________________________________________________________________
//       \    \ |    |  |  ______________________________________________________________|
//        \    \|    |  |  |         __          __     __     __     ______      _______
//         \         |  |  |_____   |  |        |  |   |  |   |  |   |   _  \    /  _____)
//          \        |  |   _____|  |  |        |  |   |  |   |  |   |  | \  \   \_______
//           \       |  |  |        |  |_____   |   \_/   |   |  |   |  |_/  /    _____  |
//            \ _____|  |__|        |________|   \_______/    |__|   |______/    (_______/
//
//  This file is part of VirtualFluids. VirtualFluids 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.
//
//  VirtualFluids 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.
//
//  SPDX-License-Identifier: GPL-3.0-or-later
//  SPDX-FileCopyrightText: Copyright © VirtualFluids Project contributors, see AUTHORS.md in root folder
//
//=======================================================================================
#ifndef CudamemoryManager_H
#define CudamemoryManager_H
 
#include <memory>
#include <string>
#include <vector>
 
#include "Calculation/Calculation.h"
 
namespace vf::gpu {
 
class Parameter;
class ActuatorFarm;
class Forest;
class Probe;
class PlanarAverageProbe;
class VelocitySetter;
class PrecursorWriter;
class BuoyancyProviderPlanarAverage;
class DampingLayer;
class CudaMemoryManager
{
public:
    CudaMemoryManager(std::shared_ptr<Parameter> parameter);
    virtual ~CudaMemoryManager() = default;
 
    void setMemsizeGPU(double admem, bool reset);
    double getMemsizeGPU();
 
    void cudaCopyPrint(int lev);
    void cudaCopyMeanPrint(int lev);
 
    void cudaAllocCoord(int lev);
    void cudaCopyCoord(int lev);
    void cudaFreeCoord(int lev);
 
    void cudaAllocBodyForce(int lev);
    void cudaCopyBodyForce(int lev);
    void cudaFreeBodyForce(int lev);
 
    void cudaCopyDataToHost(int lev);
 
    void cudaAllocSP(int lev);
    void cudaCopySP(int lev);
    void cudaFreeSP(int lev);
 
    void cudaAllocNeighborWSB(int lev);
    void cudaCopyNeighborWSB(int lev);
    void cudaFreeNeighborWSB(int lev);
 
    void cudaAllocVeloBC(int lev);
    void cudaCopyVeloBC(int lev);
    void cudaFreeVeloBC(int lev);
 
    void cudaAllocOutflowBC(int lev);
    void cudaCopyOutflowBC(int lev);
    void cudaFreeOutflowBC(int lev);
 
    void cudaAllocNoSlipBC(int lev);
    void cudaCopyNoSlipBC(int lev);
    void cudaFreeNoSlipBC(int lev);
 
    void cudaAllocGeomBC(int lev);
    void cudaCopyGeomBC(int lev);
    void cudaFreeGeomBC(int lev);
 
    void cudaAllocPress(int lev);
    void cudaCopyPress(int lev);
    void cudaFreePress(int lev);
 
    void cudaAllocDirectionalBoundaryCondition(QforDirectionalBoundaryCondition& boundaryConditionHost, QforDirectionalBoundaryCondition& boundaryConditionDevice);
    void cudaCopyDirectionalBoundaryCondition(QforDirectionalBoundaryCondition& boundaryConditionHost, QforDirectionalBoundaryCondition& boundaryConditionDevice);
    void cudaFreeDirectionalBoundaryCondition(int level);
 
 
    void cudaAllocDirectionalADBoundaryCondition(QforDirectionalADBoundaryCondition& boundaryConditionHost, QforDirectionalADBoundaryCondition& boundaryConditionDevice);
    void cudaCopyDirectionalADBoundaryCondition(QforDirectionalADBoundaryCondition& boundaryConditionHost, QforDirectionalADBoundaryCondition& boundaryConditionDevice);
    void cudaFreeDirectionalADBoundaryCondition(int level);
 
    void cudaAllocForcing();
    void cudaCopyForcingToDevice();
    void cudaCopyForcingToHost();
    void cudaFreeForcing();
 
    void cudaAllocLevelForcing(int level);
    void cudaCopyLevelForcingToDevice(int level);
    void cudaFreeLevelForcing(int level);
 
    void cudaAllocQuadricLimiters();
    void cudaCopyQuadricLimitersToDevice();
    void cudaFreeQuadricLimiters();
 
    // 3D domain decomposition
    virtual void cudaAllocProcessNeighbor(const ProcessNeighbor27& neighborHost, const ProcessNeighbor27& neighborDevice);
    virtual void cudaCopyProcessNeighborIndex(const ProcessNeighbor27& neighborHost,
                                              const ProcessNeighbor27& neighborDevice) const;
    void cudaFreeProcessNeighbor(const ProcessNeighbor27& neighborHost, const ProcessNeighbor27& neighborDevice) const;
 
    void cudaCopyProcessNeighborFsDtoH(const ProcessNeighbor27& neighborHost, const ProcessNeighbor27& neighborDevice) const;
    void cudaCopyProcessNeighborFsHtoD(const ProcessNeighbor27& neighborHost, const ProcessNeighbor27& neighborDevice) const;
 
 
    void cudaAllocTurbulentViscosity(int lev);
    void cudaCopyTurbulentViscosityHD(int lev);
    void cudaCopyTurbulentViscosityDH(int lev);
    void cudaFreeTurbulentViscosity(int lev);
 
    void cudaAllocTurbulenceIntensity(int lev, uint size);
    void cudaCopyTurbulenceIntensityHD(int lev, uint size);
    void cudaCopyTurbulenceIntensityDH(int lev, uint size);
    void cudaFreeTurbulenceIntensity(int lev);
 
    void cudaAllocMeanSP(int lev);
    void cudaCopyMeanSP(int lev);
    void cudaFreeMeanSP(int lev);
 
    void cudaAllocMeanOut(int lev);
    void cudaFreeMeanOut(int lev);
 
    void cudaAllocMeanOutAD(int lev);
    void cudaFreeMeanOutAD(int lev);
 
    void cudaAllocInterfaceCF(int lev);
    void cudaCopyInterfaceCF(int lev);
    void cudaFreeInterfaceCF(int lev);
 
    void cudaAllocInterfaceFC(int lev);
    void cudaCopyInterfaceFC(int lev);
    void cudaCheckInterfaceFCBulk(int lev);
    void cudaFreeInterfaceFC(int lev);
 
    void cudaAllocInterfaceOffCF(int lev);
    void cudaCopyInterfaceOffCF(int lev);
    void cudaFreeInterfaceOffCF(int lev);
 
    void cudaAllocInterfaceOffFC(int lev);
    void cudaCopyInterfaceOffFC(int lev);
    void cudaFreeInterfaceOffFC(int lev);
 
    void cudaAllocSlipBC(int lev);
    void cudaCopySlipBC(int lev);
    void cudaFreeSlipBC(int lev);
 
    void cudaAllocStressBC(int lev);
    void cudaCopyStressBC(int lev);
    void cudaFreeStressBC(int lev);
 
    void cudaAllocSurfaceLayerBC(int lev);
    void cudaCopySurfaceLayerBC(int lev);
    void cudaFreeSurfaceLayerBC(int lev);
 
    void cudaAllocPrecursorBC(int lev);
    void cudaAllocPrecursorData(int lev);
    void cudaCopyPrecursorBC(int lev);
    void cudaCopyPrecursorData(int lev);
    void cudaFreePrecursorBC(int lev);
    void cudaFreePrecursorData(int lev);
 
    void cudaAllocWallModel(WallModelParameters& wallModelHost, WallModelParameters& wallModelDevice, uint numberOfNodes);
    void cudaCopyWallModel(WallModelParameters& wallModelHost, WallModelParameters& wallModelDevice, uint numberOfNodes);
    void cudaFreeWallModel(WallModelParameters& wallModelHost, WallModelParameters& wallModelDevice);
 
    void cudaAllocTemperatureWallModel(TemperatureWallModelParameters& wallModelHost, TemperatureWallModelParameters& wallModelDevice, uint numberOfNodes);
    void cudaCopyTemperatureWallModel(TemperatureWallModelParameters& wallModelHost, TemperatureWallModelParameters& wallModelDevice, uint numberOfNodes);
    void cudaFreeTemperatureWallModel(TemperatureWallModelParameters& wallModelHost, TemperatureWallModelParameters& wallModelDevice);
 
    void cudaAllocGeomValuesBC(int lev);
    void cudaCopyGeomValuesBC(int lev);
    void cudaFreeGeomValuesBC(int lev);
 
    void cudaAllocCpTop(int lev);
    void cudaCopyCpTopInit(int lev);
    void cudaCopyCpTop(int lev);
    void cudaFreeCpTop(int lev);
 
    void cudaAllocCpBottom(int lev);
    void cudaCopyCpBottomInit(int lev);
    void cudaCopyCpBottom(int lev);
    void cudaFreeCpBottom(int lev);
 
    void cudaAllocCpBottom2(int lev);
    void cudaCopyCpBottom2Init(int lev);
    void cudaCopyCpBottom2(int lev);
    void cudaFreeCpBottom2(int lev);
 
    void cudaAllocConcFile(int lev);
    void cudaCopyConcFile(int lev);
    void cudaFreeConcFile(int lev);
 
    void cudaAllocMeasurePointsIndex(int lev);
    void cudaCopyMeasurePointsIndex(int lev);
    void cudaCopyMeasurePointsToHost(int lev);
    void cudaFreeMeasurePointsIndex(int lev);
 
    void cudaAllocFsForCheckPointAndRestart(int lev) const;
    void cudaAllocFsForAllLevelsOnHost() const;
    void cudaCopyFsForRestart(int lev) const;
    void cudaCopyFsForCheckPoint(int lev) const;
    void cudaCopyFsForAllLevelsToHost() const;
    void cudaFreeFsForCheckPointAndRestart(int lev) const;
 
    void cudaAllocDragLift(int lev, int numofelem);
    void cudaCopyDragLift(int lev, int numofelem);
    void cudaFreeDragLift(int lev);
 
    void cudaAlloc2ndMoments(int lev, int numofelem);
    void cudaCopy2ndMoments(int lev, int numofelem);
    void cudaFree2ndMoments(int lev);
 
    void cudaAlloc3rdMoments(int lev, int numofelem);
    void cudaCopy3rdMoments(int lev, int numofelem);
    void cudaFree3rdMoments(int lev);
 
    void cudaAllocHigherMoments(int lev, int numofelem);
    void cudaCopyHigherMoments(int lev, int numofelem);
    void cudaFreeHigherMoments(int lev);
 
    void cudaAllocConcentration(int lev);
    void cudaCopyConcentrationDeviceToHost(int lev);
    void cudaCopyConcentrationHostToDevice(int lev);
    void cudaFreeConcentration(int lev);
 
    void cudaAllocConcentrationFs(int lev);
    void cudaAllocTurbulentDiffusivity(int lev);
    void cudaCopyTurbulentDiffusivityHostToDevice(int lev);
    void cudaCopyTurbulentDiffusivityDeviceToHost(int lev);
    void cudaFreeTurbulentDiffusivity(int lev);
 
    void cudaAllocConcentrationNoFluxBC(int lev);
    void cudaCopyConcentrationNoFluxBCHostToDevice(int lev);
    void cudaFreeConcentrationNoFluxBC(int lev);
 
    void cudaAllocConcentrationFluxBC(int lev);
    void cudaCopyConcentrationFluxBCHostToDevice(int lev);
    void cudaFreeConcentrationFluxBC(int lev);
 
    void cudaAllocConcentrationDirichletBC(int lev);
    void cudaCopyConcentrationDirichletBCHostToDevice(int lev);
    void cudaFreeConcentrationDirichletBC(int lev);
 
    void cudaAllocConcentrationNeumannBC(int lev);
    void cudaCopyConcentrationNeumannBCHostToDevice(int lev);
    void cudaFreeConcentrationNeumannBC(int lev);
 
    void cudaAllocLocalReferenceTemperature(int lev);
    void cudaCopyLocalReferenceTemperatureDeviceToHost(int lev);
    void cudaCopyLocalReferenceTemperatureHostToDevice(int lev);
    void cudaFreeLocalReferenceTemperature(int lev);
 
    void cudaAllocTaggedFluidNodeIndices(CollisionTemplate tag, int lev);
    void cudaCopyTaggedFluidNodeIndices(CollisionTemplate tag, int lev);
    void cudaFreeTaggedFluidNodeIndices(CollisionTemplate tag, int lev);
 
    // ActuatorFarm
    void cudaAllocBladeGeometries(ActuatorFarm* actuatorFarm);
    void cudaCopyBladeGeometriesHtoD(ActuatorFarm* actuatorFarm);
    void cudaCopyBladeGeometriesDtoH(ActuatorFarm* actuatorFarm);
    void cudaFreeBladeGeometries(ActuatorFarm* actuatorFarm);
 
    void cudaAllocBladeOrientations(ActuatorFarm* actuatorFarm);
    void cudaCopyBladeOrientationsHtoD(ActuatorFarm* actuatorFarm);
    void cudaCopyBladeOrientationsDtoH(ActuatorFarm* actuatorFarm);
    void cudaFreeBladeOrientations(ActuatorFarm* actuatorFarm);
 
    void cudaAllocCoords(ActuatorFarm* actuatorFarm);
    void cudaCopyCoordsHtoD(ActuatorFarm* actuatorFarm);
    void cudaCopyCoordsDtoH(ActuatorFarm* actuatorFarm);
    void cudaFreeCoords(ActuatorFarm* actuatorFarm);
 
    void cudaAllocIndices(ActuatorFarm* actuatorFarm);
    void cudaCopyIndicesHtoD(ActuatorFarm* actuatorFarm);
    void cudaFreeIndices(ActuatorFarm* actuatorFarm);
 
    void cudaAllocVelocities(ActuatorFarm* actuatorFarm);
    void cudaCopyVelocitiesHtoD(ActuatorFarm* actuatorFarm);
    void cudaCopyVelocitiesDtoH(ActuatorFarm* actuatorFarm);
    void cudaFreeVelocities(ActuatorFarm* actuatorFarm);
 
    void cudaAllocForces(ActuatorFarm* actuatorFarm);
    void cudaCopyForcesHtoD(ActuatorFarm* actuatorFarm);
    void cudaCopyForcesDtoH(ActuatorFarm* actuatorFarm);
    void cudaFreeForces(ActuatorFarm* actuatorFarm);
 
    void cudaAllocBoundingVolumeIndices(ActuatorFarm* actuatorFarm);
    void cudaCopyBoundingVolumeIndicesHtoD(ActuatorFarm* actuatorFarm);
    void cudaFreeBoundingVolumeIndices(ActuatorFarm* actuatorFarm);
 
    // Forest
 
    void cudaAllocForestIndices(Forest* forest);
    void cudaCopyForestIndicesHtoD(Forest* forest);
    void cudaFreeForestIndices(Forest* forest);
 
    void cudaAllocForestVelocities(Forest* forest);
    void cudaCopyForestVelocitiesHtoD(Forest* forest, std::vector<real>& velocitiesX,
                                     std::vector<real>& velocitiesY,
                                     std::vector<real>& velocitiesZ);
    void cudaFreeForestVelocities(Forest* forest);
 
    void cudaAllocLeafAreaDensity(Forest* forest);
    void cudaCopyLeafAreaDensityHtoD(Forest* forest);
    void cudaFreeLeafAreaDensity(Forest* forest);
 
    // BuoyancyProvider
    void cudaAllocBuoyancyProviderProfileParameters(BuoyancyProviderPlanarAverage* buoyancyProvider, int level);
    void cudaCopyBuoyancyProviderProfileParametersHtoD(BuoyancyProviderPlanarAverage* buoyancyProvider, int level);
    void cudaCopyBuoyancyProviderProfileParametersDtoH(BuoyancyProviderPlanarAverage* buoyancyProvider, int level);
    void cudaFreeBuoyancyProviderProfileParameters(BuoyancyProviderPlanarAverage* buoyancyProvider, int level);
    void cudaCopyBuoyancyProviderReferenceTemperaturesDtoHAsync(BuoyancyProviderPlanarAverage* buoyancyProvider, int level);
    void cudaCopyBuoyancyProviderReferenceTemperaturesHtoDAsync(BuoyancyProviderPlanarAverage* buoyancyProvider, int level);
 
    void cudaAllocBuoyancyProviderReductionParameters(BuoyancyProviderPlanarAverage* buoyancyProvider, int level);
    void cudaCopyBuoyancyProviderReductionParametersHtoD(BuoyancyProviderPlanarAverage* buoyancyProvider, int level);
    void cudaCopyBuoyancyProviderReductionParametersDtoH(BuoyancyProviderPlanarAverage* buoyancyProvider, int level);
    void cudaFreeBuoyancyProviderReductionParameters(BuoyancyProviderPlanarAverage* buoyancyProvider, int level);
 
    void cudaAllocDampingLayerData(DampingLayer* dampingLayer, int level);
    void cudaCopyDampingLayerDataHtoD(DampingLayer* dampingLayer, int level);
    void cudaFreeDampingLayerData(DampingLayer* dampingLayer, int level);
 
    // Probes
    void cudaAllocProbeData(Probe* probe, int level);
    void cudaCopyProbeDataHtoD(Probe* probe, int level);
    void cudaCopyProbeDataDtoH(Probe* probe, int level);
    void cudaFreeProbeData(Probe* probe, int level);
 
    void cudaAllocPlanarAverageProbeIndices(PlanarAverageProbe* planarAverageProbe, int level);
    void cudaFreePlanarAverageProbeIndices(PlanarAverageProbe* planarAverageProbe, int level);
    void cudaAllocPlanarAverageProbeSubgridScaleFluxes(PlanarAverageProbe* planarAverageProbe, int level);
    void cudaFreePlanarAverageProbeSubgridScaleFluxes(PlanarAverageProbe* planarAverageProbe, int level);
 
    // Precursor Writer
    void cudaAllocPrecursorWriter(PrecursorWriter* writer, int level);
    void cudaCopyPrecursorWriterIndicesHtoD(PrecursorWriter* writer, int level);
    void cudaCopyPrecursorWriterOutputVariablesDtoH(PrecursorWriter* writer, int level);
    void cudaFreePrecursorWriter(PrecursorWriter* writer, int level);
 
private:
    std::shared_ptr<Parameter> parameter;
    double memsizeGPU = 0.0;
};
 
}
 
#endif