Changeset 568

Timestamp:

03/10/15 10:49:09 (9 years ago)

Author:

mhnguyen

Message:

Implementing discovering algorithm of server index

+) Implement the algorithm with only one level
+) Remove some redundant functions, corrects some interface

Test
+) On Curie
+) Test passed and results are correct

Location:

XIOS/trunk/src

Files:

• client_server_mapping.cpp (modified) (3 diffs)
• client_server_mapping.hpp (modified) (3 diffs)
• client_server_mapping_distributed.cpp (added)
• client_server_mapping_distributed.hpp (added)
• node/axis.cpp (modified) (2 diffs)
• node/grid.cpp (modified) (7 diffs)
• node/grid.hpp (modified) (1 diff)
• server_distribution_description.cpp (modified) (4 diffs)
• server_distribution_description.hpp (modified) (3 diffs)

XIOS/trunk/src/client_server_mapping.cpp

@@ -21 +21 @@
 
 void CClientServerMapping::computeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClient,
+                                                     const CArray<int,1>& localIndexOnClient)
+{
+//  defaultComputeServerIndexMapping(globalIndexOnClient, globalIndexServer);
+}
+
+
+void CClientServerMapping::computeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClient,
                                                      const std::vector<CArray<size_t,1>* >& globalIndexServer)
 {
@@ -26 +33 @@
 }
 
-void CClientServerMapping::computeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClient,
-                                                     const CArray<int,1>& localIndexOnClient,
-                                                     const std::vector<CArray<size_t,1>* >& globalIndexOnServer)
-{
-  defaultComputeServerIndexMapping(globalIndexOnClient, globalIndexOnServer, &localIndexOnClient);
-}
+//void CClientServerMapping::computeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClient,
+//                                                     const CArray<int,1>& localIndexOnClient,
+//                                                     const std::vector<CArray<size_t,1>* >& globalIndexOfServer)
+//{
+//  defaultComputeServerIndexMapping(globalIndexOnClient, globalIndexOfServer, &localIndexOnClient);
+//}
 
 /*!
@@ -68 +75 @@
   }
 }
-
 
 /*!

XIOS/trunk/src/client_server_mapping.hpp

@@ -13 +13 @@
 #include "array_new.hpp"
 #include "mpi.hpp"
+#include <boost/unordered_map.hpp>
 
 namespace xios {
@@ -34 +35 @@
 
     virtual void computeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClient,
-                                           const CArray<int,1>& localIndexOnClient,
-                                           const std::vector<CArray<size_t,1>* >& globalIndexOnServer);
+                                           const CArray<int,1>& localIndexOnClient);
+
+//    virtual void computeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClient,
+//                                           const CArray<int,1>& localIndexOnClient,
+//                                           const std::vector<CArray<size_t,1>* >& globalIndexOnServer);
 
     std::map<int,int> computeConnectedClients(int nbServer, int nbClient,
@@ -49 +53 @@
                                           const CArray<int,1>* localIndexOnClient = 0);
 
-  private:
+  protected:
     //! Global index of data on SERVER, which are calculated by client(s)
     std::map<int, std::vector<size_t> > indexGlobalOnServer_;

XIOS/trunk/src/node/axis.cpp

@@ -109 +109 @@
    void CAxis::checkZoom(void)
    {
-      StdSize zoom_begin,zoom_end, zoom_size;
+      StdSize zoom_begin,zoom_end, zoom_size, axisSize;
 
       zoom_begin = (this->zoom_begin.isEmpty()) ?  0 : this->zoom_begin.getValue() ;
@@ -118 +118 @@
       if (this->zoom_end.isEmpty()) zoom_end=zoom_begin+zoom_size-1 ;
       if (this->zoom_size.isEmpty()) zoom_size=zoom_end-zoom_begin+1 ;
-
-      if ( (zoom_begin < 0) || (zoom_begin > size-1) || (zoom_end<0) || (zoom_end>size-1) || (zoom_size<1) || (zoom_size>size) || (zoom_begin>zoom_end))
+      axisSize = size.getValue();
+
+      if ( (zoom_begin < 0) || (zoom_begin > axisSize-1) || (zoom_end<0) || (zoom_end>axisSize-1) || (zoom_size<1) || (zoom_size>axisSize) || (zoom_begin>zoom_end))
         ERROR("CAxis::checkAttributes(void)",<< "One or more attribut of <zoom_begin>, <zoom_end>, <zoom_size>, are not well specified") ;
 

XIOS/trunk/src/node/grid.cpp

@@ -13 +13 @@
 #include "context_server.hpp"
 #include "array_new.hpp"
+#include "client_server_mapping_distributed.hpp"
 
 namespace xios {
@@ -22 +23 @@
       , isChecked(false), isDomainAxisChecked(false), storeIndex(1)
       , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false)
-      , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_(), writtenDataSize_(0), globalDim_()
+      , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_(0), writtenDataSize_(0), globalDim_()
    {
      setVirtualDomainGroup();
@@ -32 +33 @@
       , isChecked(false), isDomainAxisChecked(false), storeIndex(1)
       , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false)
-      , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_(), writtenDataSize_(0), globalDim_()
+      , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_(0), writtenDataSize_(0), globalDim_()
    {
      setVirtualDomainGroup();
@@ -174 +175 @@
      StdSize retVal;
      std::map<int, StdSize> ret;
-     const std::map<int, std::vector<int> >& distribution = clientServerMap_.getLocalIndexSendToServer();
+     const std::map<int, std::vector<int> >& distribution = clientServerMap_->getLocalIndexSendToServer();
      std::map<int, std::vector<int> >::const_iterator it = distribution.begin(), itE = distribution.end();
      for (; it != itE; ++it)
@@ -280 +281 @@
       {
         int idx = 0;
+        std::vector<int> axisPositionMap;
+        for (int i = 0; i < axisDomainOrder.numElements(); ++i)
+        {
+          if (false == axisDomainOrder(i))
+          {
+            axisPositionMap.push_back(idx);
+            ++idx;
+          }
+          else idx += 2;
+        }
+
         computeGridGlobalDimension(getDomains(), getAxis(), axisDomainOrder);
         for (int i = 0; i < axisListP.size(); ++i)
         {
-          while (this->axisDomainOrder(idx)) idx += 2;
           if (sendAtt)
-            axisListP[i]->sendCheckedAttributes(globalDim_,idx);
+            axisListP[i]->sendCheckedAttributes(globalDim_,axisPositionMap[i]);
           else
-            axisListP[i]->checkAttributesOnClient(globalDim_,idx);
+            axisListP[i]->checkAttributesOnClient(globalDim_,axisPositionMap[i]);
           ++idx;
         }
@@ -303 +314 @@
      // First of all, compute distribution on client side
      clientDistribution_ = new CDistributionClient(client->clientRank, this);
+     size_t globalSizeIndex = 1, indexBegin, indexEnd;
+     int range, clientSize = client->clientSize;
+     for (int i = 0; i < globalDim_.size(); ++i) globalSizeIndex *= globalDim_[i];
+     indexBegin = 0;
+     for (int i = 0; i < clientSize; ++i)
+     {
+       range = globalSizeIndex / clientSize;
+       if (i < (globalSizeIndex%clientSize)) ++range;
+       if (i == client->clientRank) break;
+       indexBegin += range;
+     }
+     indexEnd = indexBegin + range - 1;
 
      // Then compute distribution on server side
      serverDistributionDescription_ = new CServerDistributionDescription(clientDistribution_->getNGlob());
      serverDistributionDescription_->computeServerDistribution(client->serverSize, true);
+     serverDistributionDescription_->computeServerGlobalIndexInRange(client->serverSize,
+                                                                     std::make_pair<size_t,size_t>(indexBegin, indexEnd));
 
      // Finally, compute index mapping between client(s) and server(s)
-     clientServerMap_.computeServerIndexMapping(clientDistribution_->getGlobalIndex(),
-                                                clientDistribution_->getLocalDataIndexSendToServerOnClient(),
-                                                serverDistributionDescription_->getGlobalIndex());
-     const std::map<int, std::vector<size_t> >& globalIndexOnServer = clientServerMap_.getGlobalIndexOnServer();
+     clientServerMap_ = new CClientServerMappingDistributed(serverDistributionDescription_->getGlobalIndexRange(),
+                                                            client->intraComm);
+
+     clientServerMap_->computeServerIndexMapping(clientDistribution_->getGlobalIndex(),
+                                                 clientDistribution_->getLocalDataIndexSendToServerOnClient());
+
+//     clientServerMap_->computeServerIndexMapping(clientDistribution_->getGlobalIndex(),
+//                                                 clientDistribution_->getLocalDataIndexSendToServerOnClient(),
+//                                                 serverDistributionDescription_->getGlobalIndex());
+     const std::map<int, std::vector<size_t> >& globalIndexOnServer = clientServerMap_->getGlobalIndexOnServer();
      std::vector<int> connectedServerRank;
      for (std::map<int, std::vector<size_t> >::const_iterator it = globalIndexOnServer.begin(); it != globalIndexOnServer.end(); ++it) {
        connectedServerRank.push_back(it->first);
      }
-     nbSenders = clientServerMap_.computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank);
+     nbSenders = clientServerMap_->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank);
 
      // Get local data index on client
@@ -415 +446 @@
     list<shared_ptr<CMessage> > list_msg ;
     list< CArray<size_t,1>* > listOutIndex;
-    const std::map<int, std::vector<size_t> >& globalIndexOnServer = clientServerMap_.getGlobalIndexOnServer();
-    const std::map<int, std::vector<int> >& localIndexSendToServer  = clientServerMap_.getLocalIndexSendToServer();
+    const std::map<int, std::vector<size_t> >& globalIndexOnServer = clientServerMap_->getGlobalIndexOnServer();
+    const std::map<int, std::vector<int> >& localIndexSendToServer  = clientServerMap_->getLocalIndexSendToServer();
 
     std::map<int, std::vector<size_t> >::const_iterator iteMap, itbMap, itGlobal;

XIOS/trunk/src/node/grid.hpp

@@ -221 +221 @@
         CDistributionServer* serverDistribution_;
         CServerDistributionDescription* serverDistributionDescription_;
-        CClientServerMapping clientServerMap_;
+        CClientServerMapping* clientServerMap_;
         size_t writtenDataSize_;
    }; // class CGrid

XIOS/trunk/src/server_distribution_description.cpp

@@ -13 +13 @@
 {
 CServerDistributionDescription::CServerDistributionDescription(const std::vector<int>& globalDimensionSize)
-  : nGlobal_(globalDimensionSize), indexBegin_(), dimensionSizes_(), globalIndex_(0), vecGlobalIndex_()
+  : nGlobal_(globalDimensionSize), indexBegin_(), dimensionSizes_(), globalIndex_(), vecGlobalIndex_()
 {
 
@@ -20 +20 @@
 CServerDistributionDescription::~CServerDistributionDescription()
 {
-  if (0 != globalIndex_) delete globalIndex_;
+//  if (0 != globalIndex_) delete globalIndex_;
   if (!vecGlobalIndex_.empty())
     for (int i = 0; i < vecGlobalIndex_.size(); ++i) delete vecGlobalIndex_[i];
@@ -92 +92 @@
 }
 
+void CServerDistributionDescription::computeServerGlobalIndexInRange(int nServer,
+                                        const std::pair<size_t, size_t>& indexBeginEnd,
+                                        ServerDistributionType distributionType)
+{
+  switch (distributionType) {
+    case BAND_DISTRIBUTION:
+      computeBandDistribution(nServer);
+      break;
+    default:
+      break;
+  }
+
+  size_t indexBegin = indexBeginEnd.first;
+  size_t indexEnd   = indexBeginEnd.second;
+  if (indexBegin > indexEnd)
+     ERROR("CServerDistributionDescription::computeServerGlobalIndexInRange",
+           << "Index begin is larger than index end");
+
+  int dim = nGlobal_.size();
+  std::vector<int> currentIndex(dim);
+
+  for (int idxServer = 0; idxServer < nServer; ++idxServer)
+  {
+    size_t ssize = 1, idx = 0;
+    for (int j = 0; j < dim; ++j) ssize *= dimensionSizes_[idxServer][j];
+    vecGlobalIndex_[idxServer] = new CArray<size_t,1>(ssize);
+
+    std::vector<int> idxLoop(dim,0);
+
+    int innerLoopSize = dimensionSizes_[idxServer][0];
+
+    while (idx<ssize)
+    {
+      for (int idxDim = 0; idxDim < dim-1; ++idxDim)
+      {
+        if (idxLoop[idxDim] == dimensionSizes_[idxServer][idxDim])
+        {
+          idxLoop[idxDim] = 0;
+          ++idxLoop[idxDim+1];
+        }
+      }
+
+      for (int idxDim = 1; idxDim < dim; ++idxDim)  currentIndex[idxDim] = idxLoop[idxDim] + indexBegin_[idxServer][idxDim];
+
+      size_t mulDim, globalIndex;
+      for (int j = 0; j < innerLoopSize; ++j)
+      {
+        mulDim = 1;
+        globalIndex = j + indexBegin_[idxServer][0];
+
+        for (int k = 1; k < dim; ++k)
+        {
+          mulDim *= nGlobal_[k-1];
+          globalIndex += (currentIndex[k])*mulDim;
+        }
+        if ((indexBegin <= globalIndex) && (globalIndex <= indexEnd))
+          globalIndex_.insert(std::make_pair<size_t,int>(globalIndex, idxServer));
+        ++idx;
+      }
+      idxLoop[0] += innerLoopSize;
+    }
+  }
+
+}
+
 /*!
   Compute global index of servers with band distribution
@@ -178 +243 @@
 }
 
+const boost::unordered_map<size_t,int>& CServerDistributionDescription::getGlobalIndexRange() const
+{
+  return globalIndex_;
+}
 } // namespace xios

XIOS/trunk/src/server_distribution_description.hpp

@@ -13 +13 @@
 #include "xmlioserver_spl.hpp"
 #include "array_new.hpp"
+#include <boost/unordered_map.hpp>
 
 namespace xios
@@ -36 +37 @@
                                    ServerDistributionType type = BAND_DISTRIBUTION);
 
-    const CArray<size_t,1>& computeServerGlobalIndex(int nServer, int serverRank,
-                                                     ServerDistributionType = BAND_DISTRIBUTION);
+    void computeServerGlobalIndexInRange(int nServer,
+                                         const std::pair<size_t, size_t>& indexBeginEnd,
+                                         ServerDistributionType = BAND_DISTRIBUTION);
 
     std::vector<std::vector<int> > getServerIndexBegin() const;
     std::vector<std::vector<int> > getServerDimensionSizes() const;
     const std::vector<CArray<size_t,1>* >& getGlobalIndex() const;
+    const boost::unordered_map<size_t,int>& getGlobalIndexRange() const;
 
   protected:
@@ -56 +59 @@
 
     //!< In case we need only global index of one server with specific rank
-    CArray<size_t,1>* globalIndex_;
+    boost::unordered_map<size_t,int> globalIndex_;
 };