Changeset 815

Timestamp:

01/26/16 18:18:58 (9 years ago)

Author:

mhnguyen

Message:

Fixing the bug in ticket 72

+) The distributed axis on client side send info to correct corresponding server
+) Improve serverdistributiondescription class to make it more flexible
+) Create new test_basic_2D only for test cases of 2-d grid

Test
+) On Curie
+) All tests pass

Location:

XIOS/trunk

Files:

• inputs/Basic (added)
• inputs/Basic/iodef.xml (added)
• src/node/axis.cpp (modified) (6 diffs)
• src/node/axis.hpp (modified) (1 diff)
• src/node/domain.cpp (modified) (9 diffs)
• src/node/grid.cpp (modified) (1 diff)
• src/server_distribution_description.cpp (modified) (9 diffs)
• src/server_distribution_description.hpp (modified) (4 diffs)
• src/test/test_basic_2D.f90 (added)

XIOS/trunk/src/node/axis.cpp

@@ -351 +351 @@
      {
        sendServerAttribut(globalDim, orderPositionInGrid, distType);
-       sendValue();
+       sendValue(globalDim, orderPositionInGrid, distType);
      }
 
@@ -357 +357 @@
    }
 
-  void CAxis::sendValue()
+  void CAxis::sendValue(const std::vector<int>& globalDim, int orderPositionInGrid,
+                        CServerDistributionDescription::ServerDistributionType distType)
   {
      if (n.getValue() == n_glo.getValue())
@@ -365 +366 @@
      else
      {
-       computeConnectedServer();
+       computeConnectedServer(globalDim, orderPositionInGrid, distType);
        sendDistributedValue();
      }
   }
 
-  void CAxis::computeConnectedServer()
+  void CAxis::computeConnectedServer(const std::vector<int>& globalDim, int orderPositionInGrid,
+                                     CServerDistributionDescription::ServerDistributionType distType)
   {
     CContext* context = CContext::getCurrent();
@@ -418 +420 @@
     }
 
-    std::vector<int> nGlobDomain(1);
-    nGlobDomain[0] = n_glo.getValue();
-
-    size_t globalSizeIndex = 1, indexBegin, indexEnd;
-    for (int i = 0; i < nGlobDomain.size(); ++i) globalSizeIndex *= nGlobDomain[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;
-
-    CServerDistributionDescription serverDescription(nGlobDomain);
-    serverDescription.computeServerGlobalIndexInRange(nbServer, std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0);
-    CClientServerMapping* clientServerMap = new CClientServerMappingDistributed(serverDescription.getGlobalIndexRange(), client->intraComm);
-    clientServerMap->computeServerIndexMapping(globalIndexAxis);
-    const std::map<int, std::vector<size_t> >& globalIndexAxisOnServer = clientServerMap->getGlobalIndexOnServer();
+    CServerDistributionDescription serverDescriptionGlobal(globalDim, nbServer);
+    int distributedDimensionOnServer = serverDescriptionGlobal.getDimensionDistributed();
+    std::map<int, std::vector<size_t> > globalIndexAxisOnServer;
+    if (distributedDimensionOnServer == orderPositionInGrid) // So we have distributed axis on client side and also on server side*
+    {
+      std::vector<int> nGlobAxis(1);
+      nGlobAxis[0] = n_glo.getValue();
+
+      size_t globalSizeIndex = 1, indexBegin, indexEnd;
+      for (int i = 0; i < nGlobAxis.size(); ++i) globalSizeIndex *= nGlobAxis[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;
+
+      CServerDistributionDescription serverDescription(nGlobAxis, nbServer);
+      serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd));
+      CClientServerMapping* clientServerMap = new CClientServerMappingDistributed(serverDescription.getGlobalIndexRange(), client->intraComm);
+      clientServerMap->computeServerIndexMapping(globalIndexAxis);
+      globalIndexAxisOnServer = clientServerMap->getGlobalIndexOnServer();
+      delete clientServerMap;
+    }
+    else
+    {
+      std::vector<size_t> globalIndexServer(n_glo.getValue());
+      for (size_t idx = 0; idx < n_glo.getValue(); ++idx)
+      {
+        globalIndexServer[idx] = idx;
+      }
+
+      for (int idx = 0; idx < nbServer; ++idx)
+      {
+        globalIndexAxisOnServer[idx] = globalIndexServer;
+      }
+    }
 
     std::map<int, std::vector<size_t> >::const_iterator it = globalIndexAxisOnServer.begin(),
@@ -476 +498 @@
         connectedServerRank_.push_back(it->first);
     }
-    nbConnectedClients_ = clientServerMap->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_);
-    delete clientServerMap;
+    nbConnectedClients_ = CClientServerMapping::computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_);
   }
 
@@ -774 +795 @@
     CContext* context = CContext::getCurrent();
     CContextClient* client = context->client;
-
-    CServerDistributionDescription serverDescription(globalDim);
-
     int nbServer = client->serverSize;
 
-    serverDescription.computeServerDistribution(nbServer, false, distType);
+    CServerDistributionDescription serverDescription(globalDim, nbServer);
+    serverDescription.computeServerDistribution();
+
     std::vector<std::vector<int> > serverIndexBegin = serverDescription.getServerIndexBegin();
     std::vector<std::vector<int> > serverDimensionSizes = serverDescription.getServerDimensionSizes();

XIOS/trunk/src/node/axis.hpp

@@ -128 +128 @@
          void computeServerIndex(const std::vector<int>& globalDim, int orderPositionInGrid,
                                  CServerDistributionDescription::ServerDistributionType disType);
-         void sendValue();
-         void computeConnectedServer(void);
+         void sendValue(const std::vector<int>& globalDim, int orderPositionInGrid,
+                        CServerDistributionDescription::ServerDistributionType distType);
+         void computeConnectedServer(const std::vector<int>& globalDim, int orderPositionInGrid,
+                                     CServerDistributionDescription::ServerDistributionType distType);
          void sendDistributedValue();
          void sendNonDistributedValue();

XIOS/trunk/src/node/domain.cpp

@@ -465 +465 @@
           lon_g.resize(ni_glo) ;
           lat_g.resize(nj_glo) ;
-          
-          
+
+
           int* ibegin_g = new int[client->clientSize] ;
           int* jbegin_g = new int[client->clientSize] ;
@@ -480 +480 @@
           v=nj ;
           MPI_Allgather(&v,1,MPI_INT,nj_g,1,MPI_INT,client->intraComm) ;
-          
+
           MPI_Allgatherv(lon.dataFirst(),ni,MPI_DOUBLE,lon_g.dataFirst(),ni_g, ibegin_g,MPI_DOUBLE,client->intraComm) ;
           MPI_Allgatherv(lat.dataFirst(),nj,MPI_DOUBLE,lat_g.dataFirst(),nj_g, jbegin_g,MPI_DOUBLE,client->intraComm) ;
-   
+
       delete[] ibegin_g ;
       delete[] jbegin_g ;
@@ -494 +494 @@
    {
      int i,j,k;
-     
+
      const int nvertexValue = 4;
      boundsLon.resize(nvertexValue,ni*nj);
@@ -510 +510 @@
        bounds_lon_end= (lon(0) +360 + lon(ni_glo-1))/2 ;
      }
-       
+
      for(j=0;j<nj;++j)
        for(i=0;i<ni;++i)
@@ -520 +520 @@
                                                                         : (lon(ibegin + i + 1)+lon(ibegin + i))/2;
        }
-    
+
 
     boundsLat.resize(nvertexValue,nj*ni);
@@ -546 +546 @@
       }
     }
-    
+
     double latStepEnd = lat(nj_glo-1)-lat(nj_glo-2);
     if (isSouthPole) bounds_lat_end=lat(nj_glo-1);
@@ -563 +563 @@
         if ( -90 + bounds_lat_end <= 0.1*std::abs(latStepEnd)) bounds_lat_end=-90 ;
       }
-    }      
-      
+    }
+
     for(j=0;j<nj;++j)
       for(i=0;i<ni;++i)
@@ -1222 +1222 @@
   void CDomain::sendServerAttribut(void)
   {
-    CServerDistributionDescription serverDescription(nGlobDomain_);
-
     CContext* context = CContext::getCurrent();
     CContextClient* client = context->client;
     int nbServer = client->serverSize;
 
-    if (isUnstructed_) serverDescription.computeServerDistribution(nbServer,0);
-    else serverDescription.computeServerDistribution(nbServer,1);
+    CServerDistributionDescription serverDescription(nGlobDomain_, nbServer);
+    if (isUnstructed_) serverDescription.computeServerDistribution(false, 0);
+    else serverDescription.computeServerDistribution(false, 1);
 
     std::vector<std::vector<int> > serverIndexBegin = serverDescription.getServerIndexBegin();
@@ -1372 +1371 @@
     indexEnd = indexBegin + range - 1;
 
-    CServerDistributionDescription serverDescription(nGlobDomain_);
-    if (isUnstructed_) serverDescription.computeServerGlobalIndexInRange(nbServer, std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0);
-    else serverDescription.computeServerGlobalIndexInRange(nbServer, std::make_pair<size_t,size_t>(indexBegin, indexEnd), 1);
+    CServerDistributionDescription serverDescription(nGlobDomain_, nbServer);
+    if (isUnstructed_) serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0);
+    else serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 1);
 
     CClientServerMapping* clientServerMap = new CClientServerMappingDistributed(serverDescription.getGlobalIndexRange(),

XIOS/trunk/src/node/grid.cpp

@@ -419 +419 @@
 
      // Then compute distribution on server side
-     CServerDistributionDescription serverDistributionDescription(globalDim_);
-     serverDistributionDescription.computeServerGlobalIndexInRange(client->serverSize,
-                                                                   std::make_pair<size_t,size_t>(indexBegin, indexEnd),
-                                                                   positionDimensionDistributed_);
+     CServerDistributionDescription serverDistributionDescription(globalDim_, client->serverSize);
+     serverDistributionDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), positionDimensionDistributed_);
 
      // Finally, compute index mapping between client(s) and server(s)

XIOS/trunk/src/server_distribution_description.cpp

@@ -3 +3 @@
    \author Ha NGUYEN
    \since 04 Jan 2015
-   \date 24 Jul 2015
+   \date 11 Jan 2016
 
    \brief Description of index distribution on server(s).
@@ -13 +13 @@
 namespace xios
 {
-CServerDistributionDescription::CServerDistributionDescription(const std::vector<int>& globalDimensionSize)
-  : nGlobal_(globalDimensionSize), indexBegin_(), dimensionSizes_(), globalIndex_(), vecGlobalIndex_()
+  /*!
+  \param [in] globalDimensionSize global dimension of grid
+  \param [in] nServer number of server
+  \param [in] serType type of server distribution. For now, we can distribute server by band or plan
+  */
+CServerDistributionDescription::CServerDistributionDescription(const std::vector<int>& globalDimensionSize,
+                                                               int nServer,
+                                                               ServerDistributionType serType)
+  : nGlobal_(globalDimensionSize), indexBegin_(), dimensionSizes_(), globalIndex_(),
+    vecGlobalIndex_(), serverType_(serType), nServer_(nServer), positionDimensionDistributed_(1)
 {
 }
@@ -23 +31 @@
 /*!
   Compute pre-defined global index distribution of server(s).
-  \param [in] nServer number of server
   \param [in] doComputeGlobalIndex flag to compute global index on each server. By default, false
-  \param [in] serType type of server distribution. For now, we can distribute server by band or plan
-*/
-void CServerDistributionDescription::computeServerDistribution(int nServer,
-                                                               int positionDimensionDistributed,
-                                                               bool doComputeGlobalIndex,
-                                                               ServerDistributionType serType)
-{
-  switch (serType) {
+
+*/
+void CServerDistributionDescription::computeServerDistribution(bool doComputeGlobalIndex,
+                                                               int positionDimensionDistributed)
+{
+  switch (serverType_) {
     case BAND_DISTRIBUTION:
-      computeBandDistribution(nServer, positionDimensionDistributed);
+      computeBandDistribution(nServer_, positionDimensionDistributed);
       break;
     default:
@@ -42 +47 @@
   if (doComputeGlobalIndex)
   {
-    vecGlobalIndex_.resize(nServer);
+    vecGlobalIndex_.resize(nServer_);
     int dim = nGlobal_.size();
     std::vector<int> currentIndex(dim);
 
-    for (int idxServer = 0; idxServer < nServer; ++idxServer)
+    for (int idxServer = 0; idxServer < nServer_; ++idxServer)
     {
       size_t ssize = 1, idx = 0;
@@ -92 +97 @@
   Compute global index assigned to a server with a range.E.g: if a grid has 100 points and
   there are 2 servers, the first one takes index from 0 to 49, the second has index from 50 to 99
-  \param [in] nServer number of server
+
   \param [in] indexBeginEnd begining and ending index of range
-  \param [in] serType type of server distribution. For now, we can distribute server by band or plan
-*/
-void CServerDistributionDescription::computeServerGlobalIndexInRange(int nServer,
-                                                                     const std::pair<size_t, size_t>& indexBeginEnd,
-                                                                     int positionDimensionDistributed,
-                                                                     ServerDistributionType distributionType)
-{
-  switch (distributionType) {
+*/
+void CServerDistributionDescription::computeServerGlobalIndexInRange(const std::pair<size_t, size_t>& indexBeginEnd,
+                                                                     int positionDimensionDistributed)
+{
+  switch (serverType_) {
     case BAND_DISTRIBUTION:
-      computeBandDistribution(nServer, positionDimensionDistributed);
+      computeBandDistribution(nServer_, positionDimensionDistributed);
       break;
     default:
@@ -118 +120 @@
   std::vector<int> currentIndex(dim);
 
-  for (int idxServer = 0; idxServer < nServer; ++idxServer)
+  for (int idxServer = 0; idxServer < nServer_; ++idxServer)
   {
     size_t ssize = 1, idx = 0;
@@ -167 +169 @@
 {
   int dim = nGlobal_.size();
-  if (positionDimensionDistributed > dim)
+  positionDimensionDistributed_ = positionDimensionDistributed;
+  if (1 == dim) positionDimensionDistributed_ = 0;
+  if (positionDimensionDistributed_ > dim)
     ERROR("CServerDistributionDescription::computeBandDistribution(int nServer, int positionDimensionDistributed)",
           << "Position of distributed dimension is invalid" << std::endl
-          << "Position of distributed dimension is " << positionDimensionDistributed
+          << "Position of distributed dimension is " << positionDimensionDistributed_
           << "Dimension " << dim)
 
@@ -187 +191 @@
   std::vector<int> njRangeEnd(nServer,0);
 
-  int positionDistributed = (1<dim) ? positionDimensionDistributed : 0;
+  int positionDistributed = (1<dim) ? positionDimensionDistributed_ : 0;
   nGlobTemp = nGlobal_[positionDistributed];
 
@@ -259 +263 @@
   return globalIndex_;
 }
+
+int CServerDistributionDescription::getDimensionDistributed()
+{
+  return ((1<nGlobal_.size()) ? positionDimensionDistributed_ : 0);
+}
+
 } // namespace xios

XIOS/trunk/src/server_distribution_description.hpp

@@ -3 +3 @@
    \author Ha NGUYEN
    \since 04 Jan 2015
-   \date 24 Jul 2015
+   \date 11 Jan 2016
 
    \brief Description of index distribution on server(s).
@@ -30 +30 @@
 
     /** Default constructor */
-    CServerDistributionDescription(const std::vector<int>& globalDimensionSize);
+    CServerDistributionDescription(const std::vector<int>& globalDimensionSize,
+                                   int nServer,
+                                   ServerDistributionType serType=BAND_DISTRIBUTION);
+
     /** Default destructor */
     virtual ~CServerDistributionDescription();
 
-    void computeServerDistribution(int nServer, int positionDimensionDistributed = 1,
-                                   bool doComputeGlobalIndex = false,
-                                   ServerDistributionType type = BAND_DISTRIBUTION);
-
-    void computeServerGlobalIndexInRange(int nServer,
-                                         const std::pair<size_t, size_t>& indexBeginEnd,
-                                         int positionDimensionDistributed = 1,
-                                         ServerDistributionType = BAND_DISTRIBUTION);
+    void computeServerDistribution(bool doComputeGlobalIndex = false, int positionDimensionDistributed = 1);
+    void computeServerGlobalIndexInRange(const std::pair<size_t, size_t>& indexBeginEnd, int positionDimensionDistributed = 1);
 
     std::vector<std::vector<int> > getServerIndexBegin() const;
@@ -47 +44 @@
     const std::vector<CArray<size_t,1> >& getGlobalIndex() const;
     const boost::unordered_map<size_t,int>& getGlobalIndexRange() const;
+    int getDimensionDistributed();
 
   protected:
@@ -62 +60 @@
     //!< In case we need only global index of one server with specific rank
     boost::unordered_map<size_t,int> globalIndex_;
+
+    //!< Type of distribution on server side
+    ServerDistributionType serverType_;
+
+    //!< Number of server
+    int nServer_;
+
+    //!< Position of dimension distributed on server side (by default, the second dimension)
+    int positionDimensionDistributed_;
 };