對於數值模擬而言，無論是商軟或者開源軟體，平行計算都是非常重要的，
作為一名模擬工程師，如果想把自身數值模擬能力提升一個層次，需要對平行計算有很好的理解與應用
openfoam並行通訊主要透過Pstream類完成
Pstream類，類如其名，parallel_stream，平行計算時使用的資訊流
Openfoam對其的介紹是:
Inter-processor communications stream.
處理器間交換資訊流
類似的命名方法我們在c++檔案讀取時說過，std有fstream類讀取寫入檔案/二進位制檔案，比如說我們要讀取檔案，會把讀取內容放入快取區內進行操作
#include <iostream>
#include <fstream> // ifstream類需要包含的標頭檔案。
#include <string> // getline()函式需要包含的標頭檔案。
using namespace std;
int main()
{
string filename = R"(./test.txt)";
//ifstream fin(filename, ios::in);
ifstream fin;
fin.open(filename , ios::in);
// 判斷開啟檔案是否成功。
// 失敗的原因主要有：1）目錄不存在；2）檔案不存在；3）沒有許可權，Linux平臺下很常見。
if (fin.is_open() == false)
{
cout << "開啟檔案" << filename << "失敗。\n"; return 0;
}
string buffer;
while (fin >> buffer)
{
cout << buffer << endl;
}
fin.close(); // 關閉檔案，fin物件失效前會自動呼叫close()。
cout << "操作檔案完成。\n";
}
類似的openfoam也有PstreamBuffers類進行並行通訊緩衝
可以這樣使用：
PstreamBuffers pBuffers(Pstream::commsTypes::nonBlocking);
for (label proci = 0; proci < Pstream::nProcs(); proci++)
{
if (proci != Pstream::myProcNo())
{
someObject vals;
UOPstream str(proci, pBuffers);
str << vals;
}
}
pBuffers.finishedSends(); // no-op for blocking
for (label proci = 0; proci < Pstream::nProcs(); proci++)
{
if (proci != Pstream::myProcNo())
{
UIPstream str(proci, pBuffers);
someObject vals(str);
}
}
上面這個程式可以看到，先後使用UOPstream與UIPstream進行緩衝區的檔案輸出與讀取，這就很像ofstream類與ifstream類，甚至命名方式上都有幾分相似，我們開啟相應的繼承關係圖
二者分別服務於IPstream類與OPstream類,我們再開啟今天文章的主角，Pstream類繼承關係圖
發現IPstream類與OPstream類是Pstream類的衍生類，Pstream類是其基礎
開啟Pstream類的原始碼：
點選檢視程式碼
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class Pstream Declaration
\*---------------------------------------------------------------------------*/
class Pstream
:
public UPstream
{
protected:
// Protected data
//- Transfer buffer
DynamicList<char> buf_;
public:
// Declare name of the class and its debug switch
ClassName("Pstream");
// Constructors
//- Construct given optional buffer size
Pstream
(
const commsTypes commsType,
const label bufSize = 0
)
:
UPstream(commsType),
buf_(0)
{
if (bufSize)
{
buf_.setCapacity(bufSize + 2*sizeof(scalar) + 1);
}
}
// Gather and scatter
//- Gather data. Apply bop to combine Value
// from different processors
template<class T, class BinaryOp>
static void gather
(
const List<commsStruct>& comms,
T& Value,
const BinaryOp& bop,
const int tag,
const label comm
);
//- Like above but switches between linear/tree communication
template<class T, class BinaryOp>
static void gather
(
T& Value,
const BinaryOp& bop,
const int tag = Pstream::msgType(),
const label comm = Pstream::worldComm
);
//- Scatter data. Distribute without modification. Reverse of gather
template<class T>
static void scatter
(
const List<commsStruct>& comms,
T& Value,
const int tag,
const label comm
);
//- Like above but switches between linear/tree communication
template<class T>
static void scatter
(
T& Value,
const int tag = Pstream::msgType(),
const label comm = Pstream::worldComm
);
// Combine variants. Inplace combine values from processors.
// (Uses construct from Istream instead of <<)
template<class T, class CombineOp>
static void combineGather
(
const List<commsStruct>& comms,
T& Value,
const CombineOp& cop,
const int tag,
const label comm
);
//- Like above but switches between linear/tree communication
template<class T, class CombineOp>
static void combineGather
(
T& Value,
const CombineOp& cop,
const int tag = Pstream::msgType(),
const label comm = Pstream::worldComm
);
//- Scatter data. Reverse of combineGather
template<class T>
static void combineScatter
(
const List<commsStruct>& comms,
T& Value,
const int tag,
const label comm
);
//- Like above but switches between linear/tree communication
template<class T>
static void combineScatter
(
T& Value,
const int tag = Pstream::msgType(),
const label comm = Pstream::worldComm
);
// Combine variants working on whole List at a time.
template<class T, class CombineOp>
static void listCombineGather
(
const List<commsStruct>& comms,
List<T>& Value,
const CombineOp& cop,
const int tag,
const label comm
);
//- Like above but switches between linear/tree communication
template<class T, class CombineOp>
static void listCombineGather
(
List<T>& Value,
const CombineOp& cop,
const int tag = Pstream::msgType(),
const label comm = Pstream::worldComm
);
//- Scatter data. Reverse of combineGather
template<class T>
static void listCombineScatter
(
const List<commsStruct>& comms,
List<T>& Value,
const int tag,
const label comm
);
//- Like above but switches between linear/tree communication
template<class T>
static void listCombineScatter
(
List<T>& Value,
const int tag = Pstream::msgType(),
const label comm = Pstream::worldComm
);
// Combine variants working on whole map at a time. Container needs to
// have iterators and find() defined.
template<class Container, class CombineOp>
static void mapCombineGather
(
const List<commsStruct>& comms,
Container& Values,
const CombineOp& cop,
const int tag,
const label comm
);
//- Like above but switches between linear/tree communication
template<class Container, class CombineOp>
static void mapCombineGather
(
Container& Values,
const CombineOp& cop,
const int tag = Pstream::msgType(),
const label comm = UPstream::worldComm
);
//- Scatter data. Reverse of combineGather
template<class Container>
static void mapCombineScatter
(
const List<commsStruct>& comms,
Container& Values,
const int tag,
const label comm
);
//- Like above but switches between linear/tree communication
template<class Container>
static void mapCombineScatter
(
Container& Values,
const int tag = Pstream::msgType(),
const label comm = UPstream::worldComm
);
// Gather/scatter keeping the individual processor data separate.
// Values is a List of size UPstream::nProcs() where
// Values[UPstream::myProcNo()] is the data for the current processor.
//- Gather data but keep individual values separate
template<class T>
static void gatherList
(
const List<commsStruct>& comms,
List<T>& Values,
const int tag,
const label comm
);
//- Like above but switches between linear/tree communication
template<class T>
static void gatherList
(
List<T>& Values,
const int tag = Pstream::msgType(),
const label comm = UPstream::worldComm
);
//- Scatter data. Reverse of gatherList
template<class T>
static void scatterList
(
const List<commsStruct>& comms,
List<T>& Values,
const int tag,
const label comm
);
//- Like above but switches between linear/tree communication
template<class T>
static void scatterList
(
List<T>& Values,
const int tag = Pstream::msgType(),
const label comm = UPstream::worldComm
);
// Exchange
//- Helper: exchange contiguous data. Sends sendData, receives into
// recvData. If block=true will wait for all transfers to finish.
template<class Container, class T>
static void exchange
(
const UList<Container>& sendData,
const labelUList& recvSizes,
List<Container>& recvData,
const int tag = UPstream::msgType(),
const label comm = UPstream::worldComm,
const bool block = true
);
//- Helper: exchange sizes of sendData. sendData is the data per
// processor (in the communicator). Returns sizes of sendData
// on the sending processor.
template<class Container>
static void exchangeSizes
(
const Container& sendData,
labelList& sizes,
const label comm = UPstream::worldComm
);
//- Exchange contiguous data. Sends sendData, receives into
// recvData. Determines sizes to receive.
// If block=true will wait for all transfers to finish.
template<class Container, class T>
static void exchange
(
const UList<Container>& sendData,
List<Container>& recvData,
const int tag = UPstream::msgType(),
const label comm = UPstream::worldComm,
const bool block = true
);
};
我們看到Pstream類有一個建構函式，剩下的都是靜態成員函式，而這些成員函式就是並行通訊的工具箱
這裡多問一句，為什麼工具箱的函式都是靜態成員函式
為什麼這裡用靜態成員函式呢
用靜態成員可以變數實現多個物件間的資料共享，比全域性變數更安全
這裡我詳細說下，舉個例子
Time mytime1;
mytime1.hour=2;
Time mytime2;
mytime2.hour=4;
這段程式中成員變數是跟著物件走的，他們的物件各自佔用不同的記憶體地址，彼此互不影響
那我們想做類內的全域性變數滿足相互通訊需求，在不同物件mytime1和mytime2中共享一個副本，怎麼辦
這時static關鍵字就派上用場了，增加了static關鍵字或成員函式不隸屬整個物件，而隸屬於整個類
因為這個變數跟著類走，所以呼叫時用“類名：：成員變數名”或“類名：：成員變數函式”進行呼叫（當然也可用“物件名.靜態函式名”），表示明確的隸屬關係，不建立物件也可進行訪問編輯
在Pstream類呼叫工具箱中函式時，我們常見到這樣的呼叫方式，而且不建立Pstream物件也可進行呼叫
// 在head節點收集資訊
Pstream::gatherList(nInternalFaces);
Pstream::gatherList(nBoundaries);
因為類的靜態成員脫離了與物件的關係，普通成員變數的記憶體分配是在物件初始化時完成的，對於靜態成員必須在程式的全域性區進行清晰的初始化
全域性區的初始化過程可由某個.cpp原始檔的開頭的靜態成員函式完成，如下所示：
void Time::func(int testValue)
{
mystatic = testValue ;
}
或者在全域性區這樣寫：
int Time::mystatic=10;
這樣能保證這個靜態成員變數能夠被正常使用。
此外靜態成員函式只能呼叫靜態成員變數，也沒有this指標可以使用
這裡上一張圖可能更方便理解
C++程式執行時，靜態變數和全域性變數儲存在資料段，所以需要在全域性區透過直接分配記憶體或者靜態函式進行分配記憶體
因而靜態成員的生命週期與程式執行週期相同，在程式中只有一份，無論建立物件與否，或者建立多少物件
說到這裡可能大家對Openfoam的並行通訊多了一些理解，只要開始了平行計算那麼就可以透過Pstream類內的成員函式進行通訊呼叫，在同樣的資料段副本上進行資訊流溝通
接下來依次說下類中各個工具的使用
收發資料
Pstream::gather()與Pstream::scatter()分別有兩個過載，分別是收集以及散佈資料，不如後面Pstream::gatherList()與Pstream::scatterList()常用，這裡不細說了
Pstream::combineGather()、Pstream::combineScatter()過載情況與上同，用於就地集中收集或散佈的資料，不太常用
Pstream::listCombineGather()、Pstream::listCombineScatter()過載情況與上同，用於一次整合list容器中的變數
Pstream::mapCombineGather()、Pstream::mapCombineScatter()過載情況與上同，用於一次整合整個map容器中的變數
Pstream::gatherList()以及Pstream::scatterList()的第二個過載比較常用，
template<class T>
static void gatherList
(
List<T>& Values,
const int tag = Pstream::msgType(),
const label comm = UPstream::worldComm
);
template<class T>
static void scatterList
(
List<T>& Values,
const int tag = Pstream::msgType(),
const label comm = UPstream::worldComm
);
Pstream::gatherList()以及Pstream::scatterList()的輸入第一個引數是Values
這個Values需要自己整合下，Values是UPstream::nProcs()數量大小的List
List<label> nIternalFaces(Pstream::nProcs());
nIternalFaces[Pstream::myProcNo()] = mesh.Cf().size();//比如說看看每個節點分到了多少網格
Pstream::gatherList(nIternalFaces);//在頭結點收集資料
Pstream::scatterList()與之類似
Pstream::gatherList()以及Pstream::scatterList()的輸入第二個引數是Pstream::msgType()，預設為1，可以不輸入
int Foam::UPstream::msgType_(1);
Pstream::gatherList()以及Pstream::scatterList()的輸入第三個引數是Pstream::msgType()，預設為0，可以不輸入
Foam::label Foam::UPstream::worldComm(0);
交換資料
Pstream::exchange()有兩個過載，用於交換連續的資料，一般情況下等待其他所有傳輸完成再傳輸，可透過預設引數block()修改優先權
Pstream::exchangeSizes()用於交換資料的大小
下面是Pstream類函式相互關係
結語
並行開發遠不止收發資料這麼簡單，還有很多類可說的，後續會一一進行介紹，並對openfoam平行計算進行最佳化
一起探索openfoam也是相當有趣的一件事，非常歡迎私信討論
指正的價值要比打賞更重要，下面是個人聯絡方式，能結交到志同道合的朋友是我的榮幸
