Commit: 8c5c2c662e821c33edad4f9f17a1abc96c25950c - MolDS (git)

Commit MetaInfo

• Revision: 8c5c2c662e821c33edad4f9f17a1abc96c25950c (tree)
• Zeit: 2013-10-09 14:15:29
• Autor: Mikiya Fujii <mikiya.fujii@gmai...>
• Commiter: Mikiya Fujii

Log Message

AsyncCommunicator is refactored: Rename of methods. #31814

git-svn-id: https://svn.sourceforge.jp/svnroot/molds/trunk@1538 1136aad2-a195-0410-b898-f5ea1d11b9d8

Ändern Zusammenfassung

• modified: src/cndo/Cndo2.cpp
• modified: src/mndo/Mndo.cpp
• modified: src/mpi/AsyncCommunicator.h
• modified: src/zindo/ZindoS.cpp

Diff

--- a/src/cndo/Cndo2.cpp
+++ b/src/cndo/Cndo2.cpp
@@ -1444,10 +1444,10 @@ void Cndo2::CalcFockMatrix(double** fockMatrix,
          double* buff                 = &fockMatrix[mu][mu];
          MolDS_mpi::molds_mpi_int num = totalNumberAOs-mu;
          if(mpiRank == mpiHeadRank && mpiRank != calcRank){
-            asyncCommunicator.SetRecvedVector(buff, num, source, tag);
+            asyncCommunicator.SetRecvedMessage(buff, num, source, tag);
          }
          if(mpiRank != mpiHeadRank && mpiRank == calcRank){
-            asyncCommunicator.SetSentVector(buff, num, dest, tag);
+            asyncCommunicator.SetSentMessage(buff, num, dest, tag);
          }
       }  // end of loop mu parallelized with MPI
    }  // end of loop A 
@@ -1672,10 +1672,10 @@ void Cndo2::CalcGammaAB(double** gammaAB, const Molecule& molecule) const{
       double* buff                 = &gammaAB[A][A];
       MolDS_mpi::molds_mpi_int num = totalAtomNumber-A;
       if(mpiRank == mpiHeadRank && mpiRank != calcRank){
-         asyncCommunicator.SetRecvedVector(buff, num, source, tag);
+         asyncCommunicator.SetRecvedMessage(buff, num, source, tag);
       }
       if(mpiRank != mpiHeadRank && mpiRank == calcRank){
-         asyncCommunicator.SetSentVector(buff, num, dest, tag);
+         asyncCommunicator.SetSentMessage(buff, num, dest, tag);
       }
    }  // end of loop A prallelized by MPI
    communicationThread.join();
@@ -1841,14 +1841,14 @@ void Cndo2::CalcCartesianMatrixByGTOExpansion(double*** cartesianMatrix,
       double* buffZ                = &cartesianMatrix[ZAxis][firstAOIndexA][0];
       MolDS_mpi::molds_mpi_int num = numValenceAOsA*totalAONumber;
       if(mpiRank == mpiHeadRank && mpiRank != calcRank){
-         asyncCommunicator.SetRecvedVector(buffX, num, source, tagX);
-         asyncCommunicator.SetRecvedVector(buffY, num, source, tagY);
-         asyncCommunicator.SetRecvedVector(buffZ, num, source, tagZ);
+         asyncCommunicator.SetRecvedMessage(buffX, num, source, tagX);
+         asyncCommunicator.SetRecvedMessage(buffY, num, source, tagY);
+         asyncCommunicator.SetRecvedMessage(buffZ, num, source, tagZ);
       }
       if(mpiRank != mpiHeadRank && mpiRank == calcRank){
-         asyncCommunicator.SetSentVector(buffX, num, dest, tagX);
-         asyncCommunicator.SetSentVector(buffY, num, dest, tagY);
-         asyncCommunicator.SetSentVector(buffZ, num, dest, tagZ);
+         asyncCommunicator.SetSentMessage(buffX, num, dest, tagX);
+         asyncCommunicator.SetSentMessage(buffY, num, dest, tagY);
+         asyncCommunicator.SetSentMessage(buffZ, num, dest, tagZ);
       }
    } // end of loop for int A with MPI
    // Delete the communication thread.
@@ -3965,10 +3965,10 @@ void Cndo2::CalcOverlapAOs(double** overlapAOs, const Molecule& molecule) const{
       double* buff                 = overlapAOs[firstAOIndexA];
       MolDS_mpi::molds_mpi_int num = totalAONumber*numValenceAOs;
       if(mpiRank == mpiHeadRank && mpiRank != calcRank){
-         asyncCommunicator.SetRecvedVector(buff, num, source, tag);
+         asyncCommunicator.SetRecvedMessage(buff, num, source, tag);
       }
       if(mpiRank != mpiHeadRank && mpiRank == calcRank){
-         asyncCommunicator.SetSentVector(buff, num, dest, tag);
+         asyncCommunicator.SetSentMessage(buff, num, dest, tag);
       }
    }  // end of loop A parallelized with MPI
    communicationThread.join();

--- a/src/mndo/Mndo.cpp
+++ b/src/mndo/Mndo.cpp
@@ -3515,7 +3515,7 @@ void Mndo::CalcTwoElecTwoCore(double****** twoElecTwoCore,
          OrbitalType twoElecLimit = dxy;
          int numBuff = (twoElecLimit+1)*twoElecLimit/2;
          int num = (totalNumberAtoms-b)*numBuff*numBuff;
-         asyncCommunicator.SetBroadcastedVector(&this->twoElecTwoCoreMpiBuff[a][b][0][0], num, calcRank);
+         asyncCommunicator.SetBroadcastedMessage(&this->twoElecTwoCoreMpiBuff[a][b][0][0], num, calcRank);
       }
    } // end of loop a parallelized with MPI
    communicationThread.join();

--- a/src/mpi/AsyncCommunicator.h
+++ b/src/mpi/AsyncCommunicator.h
@@ -33,23 +33,23 @@ public:
       while(0<passingTimes){
          boost::mutex::scoped_lock lk(this->stateGuard);
          try{
-            DataInfo dInfo = this->dataQueue.FrontPop();
-            if(dInfo.mpiFuncType == MolDS_base::Send){
-               MolDS_mpi::MpiProcess::GetInstance()->Send(dInfo.dest,
-                                                          dInfo.tag,
-                                                          reinterpret_cast<T*>(dInfo.vectorPtr), 
-                                                          dInfo.num);
+            MessageInfo mInfo = this->messageQueue.FrontPop();
+            if(mInfo.mpiFuncType == MolDS_base::Send){
+               MolDS_mpi::MpiProcess::GetInstance()->Send(mInfo.dest,
+                                                          mInfo.tag,
+                                                          reinterpret_cast<T*>(mInfo.vectorPtr), 
+                                                          mInfo.num);
             }
-            else if(dInfo.mpiFuncType == MolDS_base::Recv){
-               MolDS_mpi::MpiProcess::GetInstance()->Recv(dInfo.source,
-                                                          dInfo.tag,
-                                                          reinterpret_cast<T*>(dInfo.vectorPtr), 
-                                                          dInfo.num);
+            else if(mInfo.mpiFuncType == MolDS_base::Recv){
+               MolDS_mpi::MpiProcess::GetInstance()->Recv(mInfo.source,
+                                                          mInfo.tag,
+                                                          reinterpret_cast<T*>(mInfo.vectorPtr), 
+                                                          mInfo.num);
             }
-            else if(dInfo.mpiFuncType == MolDS_base::Broadcast){
-               MolDS_mpi::MpiProcess::GetInstance()->Broadcast(reinterpret_cast<T*>(dInfo.vectorPtr), 
-                                                               dInfo.num, 
-                                                               dInfo.source);
+            else if(mInfo.mpiFuncType == MolDS_base::Broadcast){
+               MolDS_mpi::MpiProcess::GetInstance()->Broadcast(reinterpret_cast<T*>(mInfo.vectorPtr), 
+                                                               mInfo.num, 
+                                                               mInfo.source);
             }
             else{
                std::stringstream ss;
@@ -72,51 +72,51 @@ public:
       }
    }
 
-   template<typename T> void SetSentVector(T* vector, 
-                                           molds_mpi_int num, 
-                                           int dest,
-                                           int tag){
+   template<typename T> void SetSentMessage(T* vector, 
+                                            molds_mpi_int num, 
+                                            int dest,
+                                            int tag){
       int source = NON_USED;
       MolDS_base::MpiFunctionType mpiFuncType = MolDS_base::Send;
-      this->SetVector(vector, num, source, dest, tag, mpiFuncType);
+      this->SetMessage(vector, num, source, dest, tag, mpiFuncType);
    }
 
-   template<typename T> void SetRecvedVector(T* vector, 
-                                             molds_mpi_int num, 
-                                             int source, 
-                                             int tag){
+   template<typename T> void SetRecvedMessage(T* vector, 
+                                              molds_mpi_int num, 
+                                              int source, 
+                                              int tag){
       int dest   = NON_USED;
       MolDS_base::MpiFunctionType mpiFuncType = MolDS_base::Recv;
-      this->SetVector(vector, num, source, dest, tag, mpiFuncType);
+      this->SetMessage(vector, num, source, dest, tag, mpiFuncType);
    }
 
-   template<typename T> void SetBroadcastedVector(T* vector, molds_mpi_int num, int root){
+   template<typename T> void SetBroadcastedMessage(T* vector, molds_mpi_int num, int root){
       int source = root;
       int dest   = NON_USED;
       int tag    = NON_USED;
       MolDS_base::MpiFunctionType mpiFuncType = MolDS_base::Broadcast;
-      this->SetVector(vector, num, source, dest, tag, mpiFuncType);
+      this->SetMessage(vector, num, source, dest, tag, mpiFuncType);
    }
 
 private:
-   struct DataInfo{intptr_t vectorPtr; 
-                   molds_mpi_int num; 
-                   int source; 
-                   int dest; 
-                   int tag;
-                   MolDS_base::MpiFunctionType mpiFuncType;};
+   struct MessageInfo{intptr_t vectorPtr; 
+                      molds_mpi_int num; 
+                      int source; 
+                      int dest; 
+                      int tag;
+                      MolDS_base::MpiFunctionType mpiFuncType;};
    boost::mutex     stateGuard;
    boost::condition stateChange;
-   MolDS_base_containers::ThreadSafeQueue<DataInfo> dataQueue;
-   template<typename T> void SetVector(T* vector, 
-                                       molds_mpi_int num, 
-                                       int source, 
-                                       int dest, 
-                                       int tag,
-                                       MolDS_base::MpiFunctionType mpiFuncType){
+   MolDS_base_containers::ThreadSafeQueue<MessageInfo> messageQueue;
+   template<typename T> void SetMessage(T* vector, 
+                                        molds_mpi_int num, 
+                                        int source, 
+                                        int dest, 
+                                        int tag,
+                                        MolDS_base::MpiFunctionType mpiFuncType){
       boost::mutex::scoped_lock lk(this->stateGuard);
-      DataInfo dInfo = {reinterpret_cast<intptr_t>(vector), num, source, dest, tag, mpiFuncType};
-      this->dataQueue.Push(dInfo);
+      MessageInfo mInfo = {reinterpret_cast<intptr_t>(vector), num, source, dest, tag, mpiFuncType};
+      this->messageQueue.Push(mInfo);
       this->stateChange.notify_all();
    }
 };

--- a/src/zindo/ZindoS.cpp
+++ b/src/zindo/ZindoS.cpp
@@ -2418,10 +2418,10 @@ void ZindoS::CalcCISMatrix(double** matrixCIS) const{
       int num      = this->matrixCISdimension - k;
       double* buff = &this->matrixCIS[k][k];
       if(mpiRank == mpiHeadRank && mpiRank != calcRank){
-         asyncCommunicator.SetRecvedVector(buff, num, source, tag);
+         asyncCommunicator.SetRecvedMessage(buff, num, source, tag);
       }
       if(mpiRank != mpiHeadRank && mpiRank == calcRank){
-         asyncCommunicator.SetSentVector(buff, num, dest, tag);
+         asyncCommunicator.SetSentMessage(buff, num, dest, tag);
       }
    } // end of k-loop which is MPI-parallelized
    communicationThread.join();
@@ -3361,10 +3361,10 @@ void ZindoS::CalcGammaNRMinusKNRMatrix(double** gammaNRMinusKNR, const vector<Mo
       int num    = nonRedundantQIndecesSize - i;
       double* buff = &gammaNRMinusKNR[i][i];
       if(mpiRank == mpiHeadRank && mpiRank != calcRank){
-         asyncCommunicator.SetRecvedVector(buff, num, source, tag);
+         asyncCommunicator.SetRecvedMessage(buff, num, source, tag);
       }
       if(mpiRank != mpiHeadRank && mpiRank == calcRank){
-         asyncCommunicator.SetSentVector(buff, num, dest, tag);
+         asyncCommunicator.SetSentMessage(buff, num, dest, tag);
       }
    } // end of loop-i parallelized with MPI
    communicationThread.join();
@@ -3425,10 +3425,10 @@ void ZindoS::CalcKRDagerGammaRInvMatrix(double** kRDagerGammaRInv,
       int num      = redundantQIndecesSize;
       double* buff = &kRDagerGammaRInv[i][0];
       if(mpiRank == mpiHeadRank && mpiRank != calcRank){
-         asyncCommunicator.SetRecvedVector(buff, num, source, tag);
+         asyncCommunicator.SetRecvedMessage(buff, num, source, tag);
       }
       if(mpiRank != mpiHeadRank && mpiRank == calcRank){
-         asyncCommunicator.SetSentVector(buff, num, dest, tag);
+         asyncCommunicator.SetSentMessage(buff, num, dest, tag);
       }
    } // end of loop-i parallelized with MPI
    communicationThread.join();