Skip to content
Snippets Groups Projects
Commit 1c7fa7ff authored by Anna Wellmann's avatar Anna Wellmann
Browse files

Merge branch 'develop' into 'develop' 

Fix formatting in doxygen documentation

See merge request irmb/VirtualFluids_dev!105
parents 4a9a7be3 f47759c8
No related branches found
No related tags found
1 merge request!105Fix formatting in doxygen documentation
Hide whitespace changes
Inline Side-by-side
src/gpu/VirtualFluids_GPU/Communication/ExchangeData27.h
+ 22
− 21
View file @ 1c7fa7ff
......@@ -10,7 +10,7 @@
//! \file ExchangeData27.h
//! \ingroup GPU
//! \author Martin Schoenherr, Anna Wellmann
//! \brief routines for data exchange when running simulations on multiple GPUs
//! \brief Routines for data exchange when running simulations on multiple GPUs
//////////////////////////////////////////////////////////////////////////
// 1D domain decomposition
......@@ -23,19 +23,19 @@ extern "C" void exchangePostCollDataGPU27(Parameter *para, vf::gpu::Communicator
// functions used for all directions
//! \brief collect the send nodes in a buffer on the gpu
//! \brief Collect the send nodes in a buffer on the gpu
extern "C" void collectNodesInSendBufferGPU(Parameter *para, int level, int streamIndex,
std::vector<ProcessNeighbor27> *sendProcessNeighbor,
unsigned int numberOfSendProcessNeighbors);
//! \brief distribute the receive nodes from the buffer on the gpu
//! \brief Distribute the receive nodes from the buffer on the gpu
extern "C" void scatterNodesFromRecvBufferGPU(Parameter *para, int level, int streamIndex,
std::vector<ProcessNeighbor27> *recvProcessNeighborDev,
unsigned int numberOfRecvProcessNeighbors);
//! \brief copy nodes which are part of the communication in multiple directions
//! \brief Copy nodes which are part of the communication in multiple directions
//! \details The nodes are copied from the receive buffer in one direction to the send buffer in another direction. The
//! copy operation is conducted on the cpu.
//! \ref see master thesis of Anna Wellmann (p. 56f: "Communication Hiding bei
//! der Verwendung eines uniformen Simulationsgitters")
//! See [master thesis of Anna Wellmann (p. 56f: "Communication Hiding bei
//! der Verwendung eines uniformen Simulationsgitters")]
//! \param edgeNodes determines from where to where the nodes are
//! copied
//! \param recvProcessNeighborHost is a reference to the receive buffer on the host, nodes are copied from here
......@@ -47,16 +47,16 @@ extern "C" void copyEdgeNodes(std::vector<LBMSimulationParameter::EdgeNodePositi
//////////////////////////////////////////////////////////////////////////
// x
//! \brief collect the send nodes for communication in the x direction in a buffer on the gpu
//! \details needed to exchange all nodes, used in the communication after collision step
//! \brief Collect the send nodes for communication in the x direction in a buffer on the gpu
//! \details Needed to exchange all nodes, used in the communication after collision step
extern "C" void prepareExchangeCollDataXGPU27AllNodes(Parameter *para, int level, int streamIndex);
//! \brief collect the send nodes for communication in the x direction in a buffer on the gpu
//! \brief Collect the send nodes for communication in the x direction in a buffer on the gpu
//! \details Only exchange nodes which are part of the interpolation process on refined grids. This function is used in
//! the exchange which takes place after the interpolation fine to coarse and before the interpolation coarse to fine.
//! \ref see master thesis of Anna Wellmann
//! See [master thesis of Anna Wellmann]
extern "C" void prepareExchangeCollDataXGPU27AfterFtoC(Parameter *para, int level, int streamIndex);
//! \brief exchange routine in x direction for simulations on multiple gpus
//! \details send and receive the nodes from the communication buffers on the gpus
//! \brief Exchange routine in x direction for simulations on multiple gpus
//! \details Send and receive the nodes from the communication buffers on the gpus.
//! \param Communicator is needed for the communication between the processes with mpi
//! \param CudaMemoryManager is needed for moving the data between host and device
//! \param streamIndex is the index of a CUDA Stream, which is needed for communication hiding
......@@ -68,23 +68,24 @@ extern "C" void exchangeCollDataXGPU27(Parameter *para, vf::gpu::Communicator &c
std::vector<ProcessNeighbor27> *recvProcessNeighborDev,
std::vector<ProcessNeighbor27> *sendProcessNeighborHost,
std::vector<ProcessNeighbor27> *recvProcessNeighborHost);
//! \brief calls exchangeCollDataXGPU27() for exchanging all nodes
//! \details used in the communication after collision step
//! \brief Calls exchangeCollDataXGPU27() for exchanging all nodes
//! \details Used in the communication after collision step
extern "C" void exchangeCollDataXGPU27AllNodes(Parameter *para, vf::gpu::Communicator &comm,
CudaMemoryManager *cudaManager, int level, int streamIndex);
//! \brief calls exchangeCollDataXGPU27() for exchanging the nodes, which are part of the communication between the two
//! interpolation processes on refined grids \details Only exchange nodes which are part of the interpolation process on
//! \brief Calls exchangeCollDataXGPU27() for exchanging the nodes, which are part of the communication between the two
//! interpolation processes on refined grids
//! \details Only exchange nodes which are part of the interpolation process on
//! refined grids. This function is used in the exchange which takes place after the interpolation fine to coarse and
//! before the interpolation coarse to fine. \ref see master thesis of Anna Wellmann
//! before the interpolation coarse to fine. See [master thesis of Anna Wellmann]
extern "C" void exchangeCollDataXGPU27AfterFtoC(Parameter *para, vf::gpu::Communicator &comm,
CudaMemoryManager *cudaManager, int level, int streamIndex);
//! \brief distribute the receive nodes (x direction) from the buffer on the gpu
//! \details needed to exchange all nodes, used in the communication after collision step
//! \brief Distribute the receive nodes (x direction) from the buffer on the gpu
//! \details Needed to exchange all nodes, used in the communication after collision step
extern "C" void scatterNodesFromRecvBufferXGPU27AllNodes(Parameter *para, int level, int streamIndex);
//! \brief distribute the receive nodes (x direction) from the buffer on the gpu
//! \brief Distribute the receive nodes (x direction) from the buffer on the gpu
//! \details Only exchange nodes which are part of the interpolation process on refined grids. This function is used in
//! the exchange which takes place after the interpolation fine to coarse and before the interpolation coarse to fine.
//! \ref see master thesis of Anna Wellmann
//! See [master thesis of Anna Wellmann]
extern "C" void scatterNodesFromRecvBufferXGPU27AfterFtoC(Parameter *para, int level, int streamIndex);
//////////////////////////////////////////////////////////////////////////
......
src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/IndexRearrangementForStreams.h
+ 18
− 20
View file @ 1c7fa7ff
//! \file IndexRearrangementForStreams.h
//! \ingroup GPU
//! \author Anna Wellmann
//! \ref master thesis of Anna Wellmann
//! \details See [master thesis of Anna Wellmann]
#ifndef IndexRearrangementForStreams_H
#define IndexRearrangementForStreams_H
......@@ -24,24 +24,22 @@ class Communicator;
class IndexRearrangementForStreams
{
public:
//! \brief construct IndexRearrangementForStreams object
//! \brief Construct IndexRearrangementForStreams object
IndexRearrangementForStreams(std::shared_ptr<Parameter> para, std::shared_ptr<GridBuilder> builder, vf::gpu::Communicator& communicator);
//////////////////////////////////////////////////////////////////////////
// communication after coarse to fine
//////////////////////////////////////////////////////////////////////////
//! \brief initialize the arrays for the communication after the interpolation from fine to coarse in x direction
//! \brief Initialize the arrays for the communication after the interpolation from fine to coarse in x direction
//! \details Only the nodes involved in the interpolation need to be exchanged. Therefore in this method all nodes,
//! which are part of the interpolation as well as the communication, are identified.
//!
//! \ref see master thesis of Anna
//! Wellmann (p. 59-62: "Reduzieren der auszutauschenden Knoten")
//!See [master thesis of Anna Wellmann (p. 59-62: "Reduzieren der auszutauschenden Knoten")]
void initCommunicationArraysForCommAfterFinetoCoarseX(const uint &level, int j, int direction);
//! \brief initialize the arrays for the communication after the interpolation from fine to coarse in y direction
//! \brief Initialize the arrays for the communication after the interpolation from fine to coarse in y direction
//! \details --> see x direction
void initCommunicationArraysForCommAfterFinetoCoarseY(const uint &level, int j, int direction);
//! \brief initialize the arrays for the communication after the interpolation from fine to coarse in z direction
//! \brief Initialize the arrays for the communication after the interpolation from fine to coarse in z direction
//! \details --> see x direction
void initCommunicationArraysForCommAfterFinetoCoarseZ(const uint &level, int j, int direction);
......@@ -50,7 +48,7 @@ public:
// split interpolation cells
//////////////////////////////////////////////////////////////////////////
//! \brief split the interpolation cells from coarse to fine into border an bulk
//! \brief Split the interpolation cells from coarse to fine into border an bulk
//! \details For communication hiding, the interpolation cells from the coarse to the fine grid need to be split
//! into two groups:
//!
......@@ -58,10 +56,10 @@ public:
//!
//! - the other cells which are not directly related to the communication between the two gpus --> "bulk"
//!
//! \ref see master thesis of Anna Wellmann (p. 62-68: "Überdeckung der reduzierten Kommunikation")
//! see [master thesis of Anna Wellmann (p. 62-68: "Überdeckung der reduzierten Kommunikation")]
void splitCoarseToFineIntoBorderAndBulk(const uint &level);
//! \brief split the interpolation cells from fine to coarse into border an bulk
//! \brief Split the interpolation cells from fine to coarse into border an bulk
//! \details For communication hiding, the interpolation cells from the fine to the coarse grid need to be split
//! into two groups:
//!
......@@ -69,7 +67,7 @@ public:
//!
//! - the other cells which are not directly related to the communication between the two gpus --> "bulk"
//!
//! \ref see master thesis of Anna Wellmann (p. 62-68: "Überdeckung der reduzierten Kommunikation")
//! See [master thesis of Anna Wellmann (p. 62-68: "Überdeckung der reduzierten Kommunikation")]
void splitFineToCoarseIntoBorderAndBulk(const uint &level);
private:
......@@ -77,7 +75,7 @@ private:
// communication after coarse to fine
//////////////////////////////////////////////////////////////////////////
//! \brief inits pointers for reduced communication after interpolation fine to coarse by copying them from "normal"
//! \brief Initializes pointers for reduced communication after interpolation fine to coarse by copying them from "normal"
//! communication
void copyProcessNeighborToCommAfterFtoCX(const uint &level, int indexOfProcessNeighbor);
void copyProcessNeighborToCommAfterFtoCY(const uint &level, int indexOfProcessNeighbor);
......@@ -90,7 +88,7 @@ private:
void reorderSendIndicesForCommAfterFtoCZ(int direction, int level, int indexOfProcessNeighbor,
std::vector<uint> &sendIndicesForCommAfterFtoCPositions);
//! \brief the send indices are reordered for the communication after the interpolation from fine to coarse
//! \brief The send indices are reordered for the communication after the interpolation from fine to coarse
//! \details The indices of nodes which are part of the interpolation are moved to the front of vector with the send
//! indices.
//! \pre para->getParH(level)->intCF needs to be inititalized
......@@ -99,22 +97,22 @@ private:
//! \param sendIndicesForCommAfterFtoCPositions stores each sendIndex's positions before reordering
void reorderSendIndicesForCommAfterFtoC(int *sendIndices, int &numberOfSendNodesAfterFtoC, int direction,
int level, std::vector<uint> &sendIndicesForCommAfterFtoCPositions);
//! \brief check if a sparse index occurs in the ICellFCC
//! \brief Check if a sparse index occurs in the ICellFCC
bool isSparseIndexInICellFCC(uint sizeOfICellFCC, int sparseIndexSend, int level);
//! \brief aggregate all nodes in the coarse cells for the interpolation in coarse to fine
//! \brief Aggregate all nodes in the coarse cells for the interpolation in coarse to fine
//! \details For the coarse cells in the interpolation from coarse to fine only one node is stored. This methods
//! looks for the other nodes of each cell and puts them into vector. Duplicate nodes are only stored once.
void aggregateNodesInICellCFC(int level, std::vector<uint> &nodesCFC);
//! \brief add index to sendIndicesAfterFtoC and sendIndicesForCommAfterFtoCPositions, but omit indices which are already in sendIndicesAfterFtoC
//! \brief Add index to sendIndicesAfterFtoC and sendIndicesForCommAfterFtoCPositions, but omit indices which are already in sendIndicesAfterFtoC
void addUniqueIndexToCommunicationVectors(std::vector<int> &sendIndicesAfterFtoC, int &sparseIndexSend,
std::vector<unsigned int> &sendIndicesForCommAfterFtoCPositions,
uint &posInSendIndices) const;
//! \brief find if a sparse index is a send index. If true, call addUniqueIndexToCommunicationVectors()
//! \brief Find if a sparse index is a send index. If true, call addUniqueIndexToCommunicationVectors()
void
findIfSparseIndexIsInSendIndicesAndAddToCommVectors(int sparseIndex, int *sendIndices, uint numberOfSendIndices,
std::vector<int> &sendIndicesAfterFtoC,
std::vector<uint> &sendIndicesForCommAfterFtoCPositions) const;
//! \brief find all indices which are not part of the communication after the interpolation from fine to coarse
//! \brief Find all indices which are not part of the communication after the interpolation from fine to coarse
void findIndicesNotInCommAfterFtoC(const uint &numberOfSendOrRecvIndices, int *sendOrReceiveIndices,
std::vector<int> &sendOrReceiveIndicesAfterFtoC,
std::vector<int> &sendOrIndicesOther);
......@@ -126,7 +124,7 @@ private:
void reorderRecvIndicesForCommAfterFtoCZ(int direction, int level, int indexOfProcessNeighbor,
std::vector<uint> &sendIndicesForCommAfterFtoCPositions);
//! \brief reorder the receive indices in the same way that the send indices were reordered.
//! \brief Reorder the receive indices in the same way that the send indices were reordered.
//! \details When the send indices are reordered, the receive indices need to be reordered accordingly.
//! \pre sendIndicesForCommAfterFtoCPositions should not be empty
//! \param recvIndices is the pointer to the vector with the receive indices, which will be reordered in this function
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment