Changeset 553

Timestamp:

02/11/15 16:23:12 (9 years ago)

Author:

mhnguyen

Message:

Seperating global index computation on client and server side

+) Create a class which do mapping in general manner, between client and server index global
+) Remove some redundant functions and variables
+) Add some comments to code

Test
+) On Curie. Only test_new_features.f90
+) Test passes and results are correct.
+) Need to change index from 1 to 0

Location:

XIOS/trunk

Files:

• inputs/Version2/iodef.xml (modified) (1 diff)
• src/client_server_mapping.cpp (added)
• src/client_server_mapping.hpp (added)
• src/distribution.cpp (modified) (2 diffs)
• src/distribution.hpp (modified) (4 diffs)
• src/node/axis.cpp (modified) (3 diffs)
• src/node/distribution_client.cpp (modified) (18 diffs)
• src/node/distribution_client.hpp (modified) (5 diffs)
• src/node/distribution_server.cpp (modified) (1 diff)
• src/node/distribution_server.hpp (modified) (2 diffs)
• src/node/domain.cpp (modified) (12 diffs)
• src/node/domain.hpp (modified) (2 diffs)
• src/node/grid.cpp (modified) (7 diffs)
• src/node/grid.hpp (modified) (3 diffs)
• src/server_distribution_description.cpp (added)
• src/server_distribution_description.hpp (added)
• src/test/test_new_features.f90 (modified) (2 diffs, 1 prop)

XIOS/trunk/inputs/Version2/iodef.xml

@@ -20 +20 @@
 
    <axis_definition>
-     <axis id="axis_A" />
+     <axis id="axis_A" zoom_size="2" zoom_end="2"/>
      <axis id="axis_B" zoom_size="2" zoom_end="3" />
    </axis_definition>

XIOS/trunk/src/distribution.cpp

@@ +1 @@
+/*!
+   \file distribution.hpp
+   \author Ha NGUYEN
+   \since 13 Jan 2015
+   \date 09 Feb 2015
+
+   \brief Index distribution on server side.
+ */
 #include "distribution.hpp"
 
@@ -18 +26 @@
 }
 
-//const CArray<size_t,1>* CDistribution::getGlobalIndex() const
-//{
-//  return globalIndex_;
-//}
+const CArray<size_t,1>& CDistribution::getGlobalIndex() const
+{
+  return (*globalIndex_);
+}
 
 int CDistribution::getDims() const

XIOS/trunk/src/distribution.hpp

@@ +1 @@
+/*!
+   \file distribution.hpp
+   \author Ha NGUYEN
+   \since 13 Jan 2015
+   \date 09 Feb 2015
+
+   \brief Index distribution on server side.
+ */
 #ifndef __XIOS_DISTRIBUTION_HPP__
 #define __XIOS_DISTRIBUTION_HPP__
@@ -6 +14 @@
 
 namespace xios {
+/*!
+ \class CDistribution
+ The parent class of CDistributionClient and CDistributionServer, which declares and defines
+some basic methods and properties for its children. This class allows its descendants to calculate
+distribution of index on client or server side.
+*/
 class CDistribution
 {
@@ -15 +29 @@
     virtual ~CDistribution();
 
-    int getDims() const;
-    int getRank() const;
+    int getDims() const; //! Get dimension size
+    int getRank() const; //! Get rank of current process
+
+    //! Get global index
+    const CArray<size_t,1>& getGlobalIndex() const;
   protected:
     virtual void createGlobalIndex() = 0;
@@ -23 +40 @@
     int dims_;
     int rank_;
-  private:
 };
 

XIOS/trunk/src/node/axis.cpp

@@ -75 +75 @@
       StdSize zoom_begin,zoom_end, zoom_size ;
 
-//      zoom_begin = (this->zoom_begin.isEmpty()) ?  1 : this->zoom_begin.getValue() ;
-//      zoom_end = (this->zoom_end.isEmpty()) ?  size : this->zoom_end.getValue() ;
-//      zoom_size = (this->zoom_size.isEmpty()) ?  size : this->zoom_size.getValue() ;
-
       // Maybe index begins at 0 (zero)
       zoom_begin = (this->zoom_begin.isEmpty()) ?  0 : this->zoom_begin.getValue() ;
@@ -87 +83 @@
       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 < 1) || (zoom_begin > size) || (zoom_end<1) || (zoom_end>size) || (zoom_size<1) || (zoom_size>size) || (zoom_begin>zoom_end))
-//        ERROR("CAxis::checkAttributes(void)",<< "One or more attribut of <zoom_begin>, <zoom_end>, <zoom_size>, are not well specified") ;
 
-      if ( (zoom_begin < 0) || (zoom_begin > size-1) || (zoom_end<1) || (zoom_end>size-1) || (zoom_size<1) || (zoom_size>size) || (zoom_begin>zoom_end))
+      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))
         ERROR("CAxis::checkAttributes(void)",<< "One or more attribut of <zoom_begin>, <zoom_end>, <zoom_size>, are not well specified") ;
 
@@ -117 +110 @@
       }
       else if (data_n.isEmpty())
-        data_n.setValue(zoom_size.getValue());
+        data_n.setValue(ni.getValue());
 
       if (data_index.isEmpty())

XIOS/trunk/src/node/distribution_client.cpp

@@ +1 @@
+/*!
+   \file distribution_client.cpp
+   \author Ha NGUYEN
+   \since 13 Jan 2015
+   \date 09 Feb 2015
+
+   \brief Index distribution on client side.
+ */
 #include "distribution_client.hpp"
 
@@ -5 +13 @@
 CDistributionClient::CDistributionClient(int rank, int dims, CArray<size_t,1>* globalIndex)
    : CDistribution(rank, dims, globalIndex),
-   localDataIndex_(0), indexGlobalOnServer_(), localIndexSend2Server_(), axisDomainOrder_(),
+   localDataIndex_(0), axisDomainOrder_(),
    nLocal_(), nGlob_(), nBeginLocal_(), nBeginGlobal_(),nZoomBegin_(), nZoomEnd_(),
    dataNIndex_(), dataDims_(), dataBegin_(), dataIndex_(), domainMasks_(), axisMasks_(),
-   gridMask_(), localDomainIndex_(), localAxisIndex_(), indexMap_(), connectedClients_(),
-   isConnectedServerComputed_(false), indexDomainData_()
+   gridMask_(), localDomainIndex_(), localAxisIndex_(), indexMap_(), indexDomainData_(), indexAxisData_()
 {
 }
@@ -15 +22 @@
 CDistributionClient::CDistributionClient(int rank, CGrid* grid)
    : CDistribution(rank, 0, 0),
-   localDataIndex_(0), indexGlobalOnServer_(), localIndexSend2Server_(), axisDomainOrder_(),
+   localDataIndex_(0), axisDomainOrder_(),
    nLocal_(), nGlob_(), nBeginLocal_(), nBeginGlobal_(),nZoomBegin_(), nZoomEnd_(),
    dataNIndex_(), dataDims_(), dataBegin_(), dataIndex_(), domainMasks_(), axisMasks_(),
-   gridMask_(), localDomainIndex_(), localAxisIndex_(), indexMap_(), connectedClients_(),
-   isConnectedServerComputed_(false), indexDomainData_()
+   gridMask_(), localDomainIndex_(), localAxisIndex_(), indexMap_(), indexDomainData_(), indexAxisData_()
 {
   readDistributionInfo(grid);
@@ -193 +199 @@
     else // So it's an axis
     {
-      nLocal_.at(indexMap_[idx]) = axisList[axisIndex]->zoom_size.getValue();
+      nLocal_.at(indexMap_[idx]) = axisList[axisIndex]->ni.getValue();
       nGlob_.at(indexMap_[idx]) = axisList[axisIndex]->size.getValue();
-      nBeginLocal_.at(indexMap_[idx]) = axisList[axisIndex]->zoom_begin.getValue(); //ibegin.getValue();
+      nBeginLocal_.at(indexMap_[idx]) = 0;
       nBeginGlobal_.at(indexMap_[idx]) = axisList[axisIndex]->ibegin.getValue();
       nZoomBegin_.at((indexMap_[idx])) = axisList[axisIndex]->zoom_begin;
@@ -263 +269 @@
 
   localAxisIndex_.resize(numAxis);
+  indexAxisData_.resize(numAxis);
 
   int idxAxis = 0;
@@ -270 +277 @@
     {
       int iIdx = 0;
+      indexAxisData_[idxAxis].resize(dataNIndex_[i], false);
       for (int j = 0; j < dataNIndex_[i]; ++j)
       {
@@ -277 +285 @@
         {
           localAxisIndex_[idxAxis].push_back(iIdx);
+          indexAxisData_[idxAxis][j] = true;
         }
       }
@@ -333 +342 @@
     }
 
-    // Outer index
+    // Find out outer index
     idxDomain = idxAxis = 0;
     for (int i = 1; i < numElement_; ++i)
@@ -376 +385 @@
   }
 
-  // Fill in the global index
+
+  // Now allocate these arrays
   this->globalIndex_ = new CArray<size_t,1>(indexSend2ServerCount);
   localDataIndex_ = new CArray<int,1>(indexLocalDataOnClientCount);
 
-  eachElementSize = dataNIndex_;
-  innerLoopSize = eachElementSize[0];
-  ssize = 1; for (int i = 0; i < numElement_; ++i) ssize *= eachElementSize[i];
+  // We need to loop with data index
+  innerLoopSize = dataNIndex_[0];
+  ssize = 1; for (int i = 0; i < numElement_; ++i) ssize *= dataNIndex_[i];
   idxLoop.assign(numElement_,0);
   idx = indexLocalDataOnClientCount = indexSend2ServerCount = 0;
-  int count = 0;
+  int count = 0, correctOuterIndexDomain = 0, correctOuterIndexAxis = 0;
   while (idx < ssize)
   {
     for (int i = 0; i < numElement_-1; ++i)
     {
-      if (idxLoop[i] == eachElementSize[i])
+      if (idxLoop[i] == dataNIndex_[i])
       {
         idxLoop[i] = 0;
@@ -399 +409 @@
     // Outer index
     idxDomain = idxAxis = 0;
-    bool isIndexDataCorrect = false;
+    bool isIndexDomainDataCorrect = false;
+    bool isIndexAxisDataCorrect = false;
+
     for (int i = 1; i < numElement_; ++i)
     {
@@ -406 +418 @@
         if (indexDomainData_[idxDomain][idxLoop[i]])
         {
-          currentIndex[indexMap_[i]]   = localDomainIndex_[idxDomain][idxLoop[i]];
-          currentIndex[indexMap_[i]+1] = localDomainIndex_[idxDomain*2+1][idxLoop[i]];
-          isIndexDataCorrect = true;
+          currentIndex[indexMap_[i]]   = localDomainIndex_[idxDomain][correctOuterIndexDomain];
+          currentIndex[indexMap_[i]+1] = localDomainIndex_[idxDomain*2+1][correctOuterIndexDomain];
+          isIndexDomainDataCorrect = true;
+          ++correctOuterIndexDomain;
         }
         ++idxDomain;
@@ -414 +427 @@
       else
       {
-        currentIndex[indexMap_[i]]   = localAxisIndex_[idxAxis][idxLoop[i]];
+        if (indexAxisData_[idxAxis][idxLoop[i]])
+        {
+          currentIndex[indexMap_[i]]   = localAxisIndex_[idxAxis][correctOuterIndexAxis];
+          isIndexAxisDataCorrect = true;
+          ++correctOuterIndexAxis;
+        }
         ++idxAxis;
       }
@@ -421 +439 @@
     // Inner most index
     idxDomain = idxAxis = 0;
-    int correctIndexDomain = 0;
+    int correctIndexDomain = 0, correctIndexAxis = 0;
     for (int i = 0; i < innerLoopSize; ++i)
     {
@@ -430 +448 @@
           currentIndex[0] = localDomainIndex_[idxDomain][correctIndexDomain];
           currentIndex[1] = localDomainIndex_[idxDomain+1][correctIndexDomain];
-          isIndexDataCorrect = true;
+          isIndexDomainDataCorrect = true;
           ++correctIndexDomain;
-        } else isIndexDataCorrect = false;
+        }
+        else isIndexDomainDataCorrect = false;
       }
       else
       {
-        currentIndex[0]   = localAxisIndex_[idxAxis][i];
-      }
-
-      if (isIndexDataCorrect && gridMask_(currentIndex[0], currentIndex[1], currentIndex[2]))
+        if (indexAxisData_[idxAxis][i])
+        {
+          currentIndex[0] = localAxisIndex_[idxAxis][correctIndexAxis];
+          isIndexAxisDataCorrect = true;
+          ++correctIndexAxis;
+        }
+        else isIndexAxisDataCorrect = false;
+      }
+
+      if (isIndexDomainDataCorrect &&
+          isIndexAxisDataCorrect &&
+          gridMask_(currentIndex[0], currentIndex[1], currentIndex[2]))
       {
         (*localDataIndex_)(indexLocalDataOnClientCount) = count;
@@ -446 +473 @@
         bool isIndexOnServer = true;
         for (int j = 0; j < this->dims_; ++j)
-          isIndexOnServer = isIndexOnServer && ((currentIndex[j]+nBeginGlobal_[j]) <= nZoomEnd_[j])
-                                            && (nZoomBegin_[j] <= (currentIndex[j]+nBeginGlobal_[j]));
+          isIndexOnServer = isIndexOnServer &&
+                            ((currentIndex[j]+nBeginGlobal_[j]) <= nZoomEnd_[j]) &&
+                            (nZoomBegin_[j] <= (currentIndex[j]+nBeginGlobal_[j]));
         if (isIndexOnServer)
         {
+          size_t globalIndex = currentIndex[0] + nBeginGlobal_[0];
           size_t mulDim = 1;
-          size_t globalIndex = currentIndex[0] + nBeginGlobal_[0];
           for (int k = 1; k < this->dims_; ++k)
           {
@@ -466 +494 @@
     idx += innerLoopSize;
   }
-
-//  std::cout << "global index " << *this->globalIndex_ << std::endl;
-//  std::cout << "local index " << *localDataIndex_ << std::endl;
 }
 
@@ -511 +536 @@
    int tempI = dataIndex + dataBegin;
    return ((tempI-1)%ni);
-//   return ((tempI)%ni);
-}
-
-/*!
-  Compute global index of each server distributed by band
-  The classic distribution of servers: each server takes charges of writing data divided
-into blocks on the second dimension of grid. If the grid contain a domain, this second dimension is nj.
-  \param [in] nServer number of server
-  \return vector of pointer to array of global index of servers
-*/
-std::vector<CArray<size_t,1>* > CDistributionClient::computeServerBandDistribution(int nServer)
-{
-  // It's not intelligent to allocate dynamic memory inside one function and dellocate in another
-  // but it's a way to free a large amount of unnecessary memory
-  // This function must NEVER made into public.
-  size_t ssize = 1, idx = 0;
-  for (int i = 0; i < nGlob_.size(); ++i) ssize *= nGlob_[i];
-  std::vector<int> idxLoop(this->dims_,0);
-  std::vector<int> indexServer(nServer,0);
-  int njRangeSize;
-  std::vector<int> njRangeBegin(nServer,0);
-  std::vector<int> njRangeEnd(nServer,0);
-  std::vector<CArray<size_t,1>* > globalIndexServer(nServer);
-
-  int innerLoopSize = nGlob_[0], idxServer;
-  if (1<nGlob_.size())
-  {
-    for (int i = 0; i < nServer; ++i)
-    {
-      if (0 < i) njRangeBegin[i] = njRangeEnd[i-1];
-      njRangeSize = nGlob_[1] / nServer;
-      if (i < nGlob_[1]%nServer) ++njRangeSize;
-      njRangeEnd[i] = njRangeSize + njRangeBegin[i];
-    }
-    njRangeEnd[nServer-1] = nGlob_[1];
-
-    // Compute size of each global index server array
-    while (idx < ssize)
-    {
-      for (int i = 0; i < this->dims_-1; ++i)
-      {
-        if (idxLoop[i] == nGlob_[i])
-        {
-          idxLoop[i] = 0;
-          ++idxLoop[i+1];
-        }
-      }
-
-      for (int i = 0; i < nServer; ++i)
-        if ((njRangeBegin[i]<=idxLoop[1]) && (idxLoop[1] < njRangeEnd[i]))
-        {
-          idxServer = i;
-          break;
-        }
-
-      indexServer[idxServer] += innerLoopSize;
-      idxLoop[0] += innerLoopSize;
-      idx += innerLoopSize;
-    }
-
-
-    for (int i = 0; i < nServer; ++i) globalIndexServer[i] = new CArray<size_t,1>(indexServer[i]);
-
-    // Fill in each global index server array
-    idx = 0;
-    idxLoop.assign(this->dims_,0);
-    indexServer.assign(nServer,0);
-    size_t globalIndex = 0;
-    while (idx < ssize)
-    {
-      for (int i = 0; i < this->dims_-1; ++i)
-      {
-        if (idxLoop[i] == nGlob_[i])
-        {
-          idxLoop[i] = 0;
-          ++idxLoop[i+1];
-        }
-      }
-
-      for (int i = 0; i < nServer; ++i)
-        if ((njRangeBegin[i]<=idxLoop[1]) && (idxLoop[1] < njRangeEnd[i]))
-        {
-          idxServer = i;
-          break;
-        }
-
-      for (int i = 0; i < innerLoopSize; ++i)
-      {
-        (*globalIndexServer[idxServer])(indexServer[idxServer]) = globalIndex;
-        ++indexServer[idxServer];
-        ++globalIndex;
-      }
-      idxLoop[0] += innerLoopSize;
-      idx += innerLoopSize;
-    }
-  }
-
-  return globalIndexServer;
-}
-
-/*!
-  Compute index mapping between cliens and servers
-  On using global index of data on clients and servers, each client calculates which part
-of data will be sent to the corresponding server. After the functions is called, client can use
-all computed information to send correct data to server
-  \param [in] nServer number of server
-  \param [in] distributionType type of distribution, like band or plan
-*/
-void CDistributionClient::computeServerIndexMapping(int nServer, ServerDistributionType distributionType)
-{
-  std::vector<CArray<size_t,1>* > globalIndexServer;
-
-  switch (distributionType)
-  {
-    case BAND_DISTRIBUTION:
-      globalIndexServer = computeServerBandDistribution(nServer);
-      break;
-    default:
-      break;
-  }
-
-  std::vector<CArray<size_t,1>::const_iterator> itBegin(nServer), itEnd(nServer), it(nServer);
-  for (int i = 0; i < nServer; ++i)
-  {
-    itBegin[i] = it[i] = globalIndexServer[i]->begin();
-    itEnd[i]   = globalIndexServer[i]->end();
-  }
-
-  size_t ssize = (this->globalIndex_)->numElements();
-  for (int i = 0; i < ssize; ++i)
-  {
-    for (int j = 0; j < nServer; ++j)
-    {
-      // Just temporarily, it's bad.
-
-      if (std::binary_search(itBegin[j], itEnd[j], (*this->globalIndex_)(i)))
-      {
-        // Just try to calculate local index server on client side
-        (indexGlobalOnServer_[j]).push_back((*this->globalIndex_)(i));
-        (localIndexSend2Server_[j]).push_back(i);
-        continue;
-      }
-    }
-  }
-
-  for (int i = 0; i < nServer; ++i)
-    if (0 != globalIndexServer[i]) delete globalIndexServer[i];
-}
-
-/*!
-  Compute how many clients each server will receive data from
-  On client can send data to several servers as well as one server can receive data originated from
-some clients. In order to write data correctly, each server must know from how many clients it receives data
-  \param [in] nbServer number of servers
-  \param [in] nClient number of clients
-  \param [in] clientIntraComm MPI communication of clients
-  \return mapping of server rank and the number of connected clients
-*/
-std::map<int,int> CDistributionClient::computeConnectedClients(int nbServer, int nbClient, MPI_Comm& clientIntraComm)
-{
-  if (isConnectedServerComputed_) return connectedClients_;
-  std::map<int, std::vector<size_t> >::const_iterator itbMap, iteMap, it;
-  itbMap = it = indexGlobalOnServer_.begin();
-  iteMap = indexGlobalOnServer_.end();
-
-  std::vector<int> connectedServer;
-  std::vector<bool> isConnected(nbServer,false);
-
-  for (it = itbMap; it != iteMap; ++it)
-  {
-    for (int serverNum = 0; serverNum < nbServer; ++serverNum)
-      if (it->first == serverNum) isConnected[serverNum] = true;
-  }
-
-  for(int serverNum = 0; serverNum<nbServer; ++serverNum)
-    if (isConnected[serverNum])
-      connectedServer.push_back(serverNum);
-
-
-  int nbConnectedServer=connectedServer.size();
-  int* recvCount=new int[nbClient];
-  int* displ=new int[nbClient];
-  int* sendBuff=new int[nbConnectedServer];
-  valarray<int> clientRes(0,nbServer);
-
-  for(int n=0;n<nbConnectedServer;n++) sendBuff[n]=connectedServer[n] ;
-
-  // get connected server for everybody
-  MPI_Allgather(&nbConnectedServer,1,MPI_INT,recvCount,1,MPI_INT,clientIntraComm) ;
-
-  displ[0]=0 ;
-  for(int n=1;n<nbClient;n++) displ[n]=displ[n-1]+recvCount[n-1] ;
-  int recvSize=displ[nbClient-1]+recvCount[nbClient-1] ;
-  int* recvBuff=new int[recvSize] ;
-
-
-  MPI_Allgatherv(sendBuff,nbConnectedServer,MPI_INT,recvBuff,recvCount,displ,MPI_INT,clientIntraComm) ;
-  for(int n=0;n<recvSize;n++) clientRes[recvBuff[n]]++ ;
-
-//  std::map<int,int> nbSenders;
-  for(int n=0;n<nbConnectedServer;n++)
-  {
-    connectedClients_[connectedServer[n]] = clientRes[connectedServer[n]];
-  }
-
-  isConnectedServerComputed_ = true;
-
-  delete [] recvCount ;
-  delete [] displ ;
-  delete [] sendBuff ;
-  delete [] recvBuff ;
-
-  return connectedClients_;
-}
-
-/*!
-  Return local index of data that is send to server
-  \return mapping of server rank and local index of sending data on the client
-*/
-const std::map<int, std::vector<int> >& CDistributionClient::getLocalIndexSendToServer() const
-{
-  return localIndexSend2Server_;
 }
 
@@ -743 +546 @@
 }
 
-/*!
-  Return global index of data on each connected server.
-  On receiving data sent from client(s), each server with this global index, is able to
-know where the data should be written.
-  \return mapping of server rank and its global index.
-*/
-const std::map<int, std::vector<size_t> >& CDistributionClient::getGlobalIndexOnServer() const
-{
-  return indexGlobalOnServer_;
-}
-
 } // namespace xios

XIOS/trunk/src/node/distribution_client.hpp

@@ +1 @@
+/*!
+   \file distribution_client.hpp
+   \author Ha NGUYEN
+   \since 13 Jan 2015
+   \date 09 Feb 2015
+
+   \brief Index distribution on client side.
+ */
 #ifndef __XIOS_DISTRIBUTIONCLIENT_HPP__
 #define __XIOS_DISTRIBUTIONCLIENT_HPP__
@@ -15 +23 @@
 /*!
   \class CDistributionClient
-  This class bases on the knowledge of distribution on client side as well as on server side
-to calculate the index mapping between client and server. Each client awaring of the existences of other clients
-and servers, firstly, computes the global index of its local data then use this information on taking into account of
-distribution of servers to calculate to which server(s) it connects (sends data)
+  This class bases on the knowledge of distribution on client side (decided by users)
+to calculate the global index of its local data.
 */
 class CDistributionClient : public CDistribution
 {
   public:
-    enum ServerDistributionType
-    {
-      BAND_DISTRIBUTION, PLAN_DISTRIBUTION
-    };
-
     /** Default constructor */
     CDistributionClient(int rank, int dims, CArray<size_t,1>* globalIndex = 0);
     CDistributionClient(int rank, CGrid* grid);
-    CDistributionClient(const CDistributionClient& distClient); //! Not implement
 
     /** Default destructor */
     virtual ~CDistributionClient();
 
-    void computeServerIndexMapping(int nServer, ServerDistributionType distType = BAND_DISTRIBUTION);
-    std::map<int,int> computeConnectedClients(int nbServer, int nbClient, MPI_Comm& clientIntraComm);
-
     const CArray<int,1>& getLocalDataIndexOnClient() const;
-    const std::map<int, std::vector<size_t> >& getGlobalIndexOnServer() const;
-    const std::map<int, std::vector<int> >& getLocalIndexSendToServer() const;
+    std::vector<int> getNGlob() { return nGlob_; }
 
   protected:
@@ -51 +47 @@
                               const CArray<bool,3>& gridMask);
 
+  private:
+    //! Create local index of a domain
+    void createLocalDomainDataIndex();
+
+    //! Create local index of an axis
+    void createLocalAxisDataIndex();
+
     inline int getDomainIndex(const int& dataIIndex, const int& dataJIndex,
                               const int& dataIBegin, const int& dataJBegin,
@@ -57 +60 @@
 
   private:
-    //! Create local index of a domain
-    void createLocalDomainDataIndex();
-    //! Create local index of an axis
-    void createLocalAxisDataIndex();
-
-    //! Compute band distribution on server
-    std::vector<CArray<size_t,1>* > computeServerBandDistribution(int nServer);
-  private:
     //!< LocalData index on client
     CArray<int,1>* localDataIndex_;
 
-    //! Index of the local data which will be sent to the corresponding server(s)
-    std::map<int, std::vector<int> >  localIndexSend2Server_;
-
-    //! Global index of data on SERVER, which are calculated by client(s)
-    std::map<int, std::vector<size_t> > indexGlobalOnServer_;
   private:
     /*! Domains and axis are considered elements.
      * A grid composed of 1 domain and 1 axis has 2 elements */
     int numElement_;
-    CArray<bool,1> axisDomainOrder_; //!<
+    CArray<bool,1> axisDomainOrder_; //!< Order of axis and domain of a grid
 
     std::vector<int> nLocal_; //!< Local size of each dimension (ni, nj, etc, ...)
@@ -102 +92 @@
     std::vector<int> indexMap_; //!< Mapping element index to dimension index
 
-    std::map<int, int> connectedClients_; //!< number of clients connected to a server
-    bool isConnectedServerComputed_; //!< Guard flag
+    // The correct index of a domain has true value, the ghost one has false value
+    std::vector<std::vector<bool> > indexDomainData_;
+    std::vector<std::vector<bool> > indexAxisData_;
 
-    // The real index of a domain has true value, the ghost one has false value
-    std::vector<std::vector<bool> > indexDomainData_;
+  private:
+    CDistributionClient(const CDistributionClient& distClient); //! Not implement
 };
 

XIOS/trunk/src/node/distribution_server.cpp

@@ +1 @@
+/*!
+   \file distribution_server.cpp
+   \author Ha NGUYEN
+   \since 13 Jan 2015
+   \date 04 Feb 2015
+
+   \brief Index distribution on server side.
+ */
 #include "distribution_server.hpp"
 
 namespace xios {
+
 CDistributionServer::CDistributionServer(int rank, int dims, CArray<size_t,1>* globalIndex)
   : CDistribution(rank, dims, globalIndex), nGlobal_(), nZoomSize_(), nZoomBegin_()

XIOS/trunk/src/node/distribution_server.hpp

@@ +1 @@
+/*!
+   \file distribution_server.hpp
+   \author Ha NGUYEN
+   \since 13 Jan 2015
+   \date 04 Feb 2015
+
+   \brief Index distribution on server side.
+ */
+
 #ifndef __XIOS_DISTRIBUTION_SERVER_HPP__
 #define __XIOS_DISTRIBUTION_SERVER_HPP__
@@ -5 +14 @@
 
 namespace xios {
+
 /*!
-\class CDistributionServer
- The class, for now, plays a role of computing local index for writing data on server
+  \class CDistributionServer
+  The class, for now, plays a role of computing local index for writing data on server
 */
 class CDistributionServer : public CDistribution

XIOS/trunk/src/node/domain.cpp

@@ -14 +14 @@
 #include "context_client.hpp"
 #include "array_new.hpp"
+#include "server_distribution_description.hpp"
 
 namespace xios {
@@ -21 +22 @@
    CDomain::CDomain(void)
       : CObjectTemplate<CDomain>(), CDomainAttributes()
-      , isChecked(false), relFiles(), isClientChecked(false)
+      , isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_()
    { /* Ne rien faire de plus */ }
 
    CDomain::CDomain(const StdString & id)
       : CObjectTemplate<CDomain>(id), CDomainAttributes()
-      , isChecked(false), relFiles(), isClientChecked(false)
+      , isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_()
          { /* Ne rien faire de plus */ }
 
@@ -612 +613 @@
   void CDomain::sendServerAttribut(void)
   {
+    std::vector<int> nGlobDomain(2);
+    nGlobDomain[0] = ni_glo.getValue();
+    nGlobDomain[1] = nj_glo.getValue();
+    CServerDistributionDescription serverDescription(nGlobDomain);
+
     int ni_srv=ni_glo.getValue() ;
     int ibegin_srv=0 ;
@@ -625 +631 @@
     int serverRank=client->getServerLeader() ;
 
-//    jend_srv=0 ;
-    jend_srv= -1 ;
-    for(int i=0;i<=serverRank;i++)
-    {
-      jbegin_srv=jend_srv+1 ;
-      nj_srv=nj_glo.getValue()/nbServer ;
-      if (i<nj_glo.getValue()%nbServer) nj_srv++ ;
-      jend_srv=jbegin_srv+nj_srv-1 ;
-    }
+     serverDescription.computeServerDistribution(nbServer);
+     std::vector<std::vector<int> > serverIndexBegin = serverDescription.getServerIndexBegin();
+     std::vector<std::vector<int> > serverDimensionSizes = serverDescription.getServerDimensionSizes();
+     ibegin_srv = (serverIndexBegin[serverRank])[0];
+     jbegin_srv = serverIndexBegin[serverRank][1];
+     ni_srv = serverDimensionSizes[serverRank][0];
+     nj_srv = serverDimensionSizes[serverRank][1];
+     iend_srv = ibegin_srv+ni_srv-1;
+     jend_srv = jbegin_srv+nj_srv-1;
 
      CEventClient event(getType(),EVENT_ID_SERVER_ATTRIBUT) ;
@@ -649 +655 @@
   void CDomain::computeConnectedServer(void)
   {
-    int i,j,i_ind,j_ind ;
-
     ibegin_client=ibegin ; iend_client=iend ; ni_client=ni ;
     jbegin_client=jbegin ; jend_client=jend ; nj_client=nj ;
 
-    CContext* context = CContext::getCurrent() ;
+    CContext* context=CContext::getCurrent() ;
     CContextClient* client=context->client ;
-    int nbServer=client->serverSize ;
-
-    // find how much client are connected to a server
+    int nbServer=client->serverSize;
+    bool doComputeGlobalIndexServer = true;
+
+    int i,j,i_ind,j_ind ;
     int zoom_iend=zoom_ibegin+zoom_ni-1 ;
     int zoom_jend=zoom_jbegin+zoom_nj-1 ;
 
-    int blockSize=nj_glo/nbServer ;
-    int ns=nj_glo%nbServer ;
-    int pos=ns*(blockSize+1) ;
-//    int pos=ns*(blockSize) ;
-    int serverNum ;
-
-    mapConnectedServer.resize(ni,nj) ;
-    vector<int> nbData(nbServer,0) ;
-    vector<int> indServer(nbServer,-1) ;
-    vector<bool> IsConnected(nbServer,false) ;
-
+    std::vector<int> nGlobDomain(2);
+    nGlobDomain[0] = ni_glo.getValue();
+    nGlobDomain[1] = nj_glo.getValue();
+    CServerDistributionDescription serverDescription(nGlobDomain);
+    serverDescription.computeServerDistribution(nbServer, doComputeGlobalIndexServer);
+
+    // Precompute number of index
+    int globalIndexCount = 0;
     for(j=0;j<nj;j++)
       for(i=0;i<ni;i++)
@@ -679 +681 @@
         j_ind=jbegin+j_index(i,j) ;
 
-        if (j_ind<pos) serverNum=j_ind/(blockSize+1) ;
-        else serverNum=ns+(j_ind-pos)/blockSize ;
-        IsConnected[serverNum]=true ;
-
         if (i_ind >= zoom_ibegin && i_ind <= zoom_iend && j_ind >= zoom_jbegin && j_ind <= zoom_jend)
         {
-          mapConnectedServer(i,j)=serverNum ;
-          nbData[serverNum]++ ;
+          ++globalIndexCount;
         }
-        else mapConnectedServer(i,j)=-1 ;
-      }
-
-
-    for(serverNum=0 ; serverNum<nbServer ; serverNum++)
-      if (IsConnected[serverNum])
-      {
-        ns=connectedServer.size() ;
-        indServer[serverNum]=ns;
-        connectedServer.push_back(serverNum) ;
-        nbDataSrv.push_back(nbData[serverNum]) ;
-      }
-
-     i_indSrv.resize(connectedServer.size()) ;
-     j_indSrv.resize(connectedServer.size()) ;
-
-     for(j=0;j<nj;j++)
+      }
+
+    // Fill in index
+    CArray<size_t,1> globalIndexDomain(globalIndexCount);
+    size_t globalIndex;
+    globalIndexCount = 0;
+
+    for(j=0;j<nj;j++)
       for(i=0;i<ni;i++)
       {
-        if (mapConnectedServer(i,j)>=0)
+        i_ind=ibegin+i_index(i,j) ;
+        j_ind=jbegin+j_index(i,j) ;
+
+        if (i_ind >= zoom_ibegin && i_ind <= zoom_iend && j_ind >= zoom_jbegin && j_ind <= zoom_jend)
         {
-          ns=indServer[mapConnectedServer(i,j)] ;
-          mapConnectedServer(i,j)= ns ;
-          i_indSrv[ns].push_back(i+ibegin) ;
-          j_indSrv[ns].push_back(j+jbegin) ;
+          globalIndex = i_ind + j_ind * ni_glo;
+          globalIndexDomain(globalIndexCount) = globalIndex;
+          ++globalIndexCount;
         }
       }
 
-    int nbConnectedServer=connectedServer.size() ;
-
-    int* recvCount=new int[client->clientSize] ;
-    int* displ=new int[client->clientSize] ;
-    int* sendBuff=new int[nbConnectedServer] ;
-    valarray<int> nbClient(0,client->serverSize) ;
-
-    for(int n=0;n<nbConnectedServer;n++) sendBuff[n]=connectedServer[n] ;
-
-    // get connected server for everybody
-    MPI_Allgather(&nbConnectedServer,1,MPI_INT,recvCount,1,MPI_INT,client->intraComm) ;
-
-    displ[0]=0 ;
-    for(int n=1;n<client->clientSize;n++) displ[n]=displ[n-1]+recvCount[n-1] ;
-    int recvSize=displ[client->clientSize-1]+recvCount[client->clientSize-1] ;
-    int* recvBuff=new int[recvSize] ;
-
-
-    MPI_Allgatherv(sendBuff,nbConnectedServer,MPI_INT,recvBuff,recvCount,displ,MPI_INT,client->intraComm) ;
-    for(int n=0;n<recvSize;n++) nbClient[recvBuff[n]]++ ;
-
-    for(int n=0;n<nbConnectedServer;n++) nbSenders.push_back(nbClient[connectedServer[n]]) ;
-
-    delete [] recvCount ;
-    delete [] displ ;
-    delete [] sendBuff ;
-    delete [] recvBuff ;
+    CClientServerMapping clientServerMap;
+    clientServerMap.computeServerIndexMapping(globalIndexDomain, serverDescription.getGlobalIndex());
+    const std::map<int, std::vector<size_t> >& globalIndexDomainOnServer = clientServerMap.getGlobalIndexOnServer();
+    std::vector<int> connectedServerRank;
+    for (std::map<int, std::vector<size_t> >::const_iterator it = globalIndexDomainOnServer.begin(); it != globalIndexDomainOnServer.end(); ++it) {
+      connectedServerRank.push_back(it->first);
+    }
+    nbConnectedClients_ = clientServerMap.computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank);
+    indSrv_ = globalIndexDomainOnServer;
   }
-
-
-//  void CDomain::sendLonLat(void)
-//  {
-//    int ns,n,i,j,ind,nv ;
-//    CContext* context = CContext::getCurrent() ;
-//    CContextClient* client=context->client ;
-//    // send lon lat for each connected server
-//
-//    CEventClient eventLon(getType(),EVENT_ID_LON) ;
-//    CEventClient eventLat(getType(),EVENT_ID_LAT) ;
-//
-//    list<shared_ptr<CMessage> > list_msgLon ;
-//    list<shared_ptr<CMessage> > list_msgLat ;
-//    list< CArray<int,1>* > list_indi,list_indj ;
-//    list< CArray<double,1>* >list_lon,list_lat ;
-//    list< CArray<double,2>* >list_boundslon,list_boundslat ;
-//
-//    for(int ns=0;ns<connectedServer.size();ns++)
-//    {
-//      int nbData = nbDataSrv[ns] ;
-//      CArray<int,1> indi(nbData) ;
-//      CArray<int,1> indj(nbData) ;
-//      CArray<double,1> lon(nbData) ;
-//      CArray<double,1> lat(nbData) ;
-//      CArray<double,2> boundslon(nvertex,nbData) ;
-//      CArray<double,2> boundslat(nvertex,nbData) ;
-//
-//      for(n=0;n<nbData;n++)
-//      {
-//        i=i_indSrv[ns][n] ;
-//        j=j_indSrv[ns][n] ;
-//        ind=(i-(zoom_ibegin_client-1))+(j-(zoom_jbegin_client-1))*zoom_ni_client ;
-//
-//        lon(n)=lonvalue(ind) ;
-//        lat(n)=latvalue(ind) ;
-//        if (hasBounds)
-//        {
-//          for(nv=0;nv<nvertex;nv++)
-//          {
-//            boundslon(nv,n)=bounds_lon(nv,ind);
-//            boundslat(nv,n)=bounds_lat(nv,ind);
-//          }
-//        }
-//        indi(n)=ibegin+i_index(i-ibegin+1,j-jbegin+1)-1  ;
-//        indj(n)=jbegin+j_index(i-ibegin+1,j-jbegin+1)-1  ;
-//      }
-//
-//      list_indi.push_back(new CArray<int,1>(indi.copy())) ;
-//      list_indj.push_back(new CArray<int,1>(indj.copy())) ;
-//      list_lon.push_back(new CArray<double,1>(lon.copy())) ;
-//      list_lat.push_back(new CArray<double,1>(lat.copy())) ;
-//      if (hasBounds) list_boundslon.push_back(new CArray<double,2>(boundslon.copy())) ;
-//      if (hasBounds) list_boundslat.push_back(new CArray<double,2>(boundslat.copy())) ;
-//
-//      list_msgLon.push_back(shared_ptr<CMessage>(new CMessage)) ;
-//      list_msgLat.push_back(shared_ptr<CMessage>(new CMessage)) ;
-//
-//      *list_msgLon.back()<<this->getId()<<(int)type ; // enum ne fonctionne pour les message => ToFix
-//      *list_msgLat.back()<<this->getId()<<(int)type ;
-//      *list_msgLon.back()<<isCurvilinear ;
-//      *list_msgLat.back()<<isCurvilinear ;
-//      *list_msgLon.back()<<*list_indi.back()<<*list_indj.back()<<*list_lon.back() ;
-//      *list_msgLat.back()<<*list_indi.back()<<*list_indj.back()<<*list_lat.back() ;
-//
-//      if (hasBounds)
-//      {
-//        *list_msgLon.back()<<*list_boundslon.back();
-//        *list_msgLat.back()<<*list_boundslat.back();
-//      }
-//      eventLon.push(connectedServer[ns],nbSenders[ns],*list_msgLon.back()) ;
-//      eventLat.push(connectedServer[ns],nbSenders[ns],*list_msgLat.back()) ;
-//    }
-//
-//    client->sendEvent(eventLon) ;
-//    client->sendEvent(eventLat) ;
-//
-//
-//    for(list<CArray<int,1>* >::iterator it=list_indi.begin();it!=list_indi.end();it++) delete *it;
-//    for(list<CArray<int,1>* >::iterator it=list_indj.begin();it!=list_indj.end();it++) delete *it;
-//    for(list<CArray<double,1>* >::iterator it=list_lon.begin();it!=list_lon.end();it++)   delete *it;
-//    for(list<CArray<double,1>* >::iterator it=list_lat.begin();it!=list_lat.end();it++)   delete *it;
-//    if (hasBounds) for(list<CArray<double,2>* >::iterator it=list_boundslon.begin();it!=list_boundslon.end();it++)   delete *it;
-//    if (hasBounds) for(list<CArray<double,2>* >::iterator it=list_boundslat.begin();it!=list_boundslat.end();it++)   delete *it;
-//
-//  }
 
   void CDomain::sendLonLat(void)
   {
-    int ns,n,i,j,ind,nv ;
+    int ns,n,i,j,ind,nv, idx;
     CContext* context = CContext::getCurrent() ;
     CContextClient* client=context->client ;
@@ -847 +733 @@
     list< CArray<double,2>* >list_boundslon,list_boundslat ;
 
-    for(int ns=0;ns<connectedServer.size();ns++)
+    std::map<int, std::vector<size_t> >::const_iterator it, itbMap, iteMap;
+    itbMap = indSrv_.begin();
+    iteMap = indSrv_.end();
+    for (it = itbMap; it != iteMap; ++it)
     {
-      int nbData = nbDataSrv[ns] ;
+      int rank = it->first;
+      int nbData = (it->second).size();
       CArray<int,1> indi(nbData) ;
       CArray<int,1> indj(nbData) ;
       CArray<double,1> lon(nbData) ;
       CArray<double,1> lat(nbData) ;
-      CArray<double,2> boundslon(nvertex,nbData) ;
-      CArray<double,2> boundslat(nvertex,nbData) ;
-
-      for(n=0;n<nbData;n++)
-      {
-        i=i_indSrv[ns][n] ;
-        j=j_indSrv[ns][n] ;
-//        ind=(i-(zoom_ibegin_client))+(j-(zoom_jbegin_client-1))*zoom_ni_client ;
+      CArray<double,2> boundslon(nvertex,nbData);
+      CArray<double,2> boundslat(nvertex,nbData);
+
+      for (n = 0; n < nbData; ++n)
+      {
+        idx = static_cast<int>((it->second)[n]);
+        i = idx%ni_glo;
+        j = idx/ni_glo;
         ind=(i-(zoom_ibegin_client))+(j-(zoom_jbegin_client))*zoom_ni_client ;
 
@@ -876 +766 @@
         indi(n)=ibegin+i_index(i-ibegin,j-jbegin)  ;
         indj(n)=jbegin+j_index(i-ibegin,j-jbegin)  ;
-//        indi(n)=ibegin+i_index(i-ibegin+1,j-jbegin+1)-1  ;
-//        indj(n)=jbegin+j_index(i-ibegin+1,j-jbegin+1)-1  ;
       }
 
@@ -902 +790 @@
         *list_msgLat.back()<<*list_boundslat.back();
       }
-      eventLon.push(connectedServer[ns],nbSenders[ns],*list_msgLon.back()) ;
-      eventLat.push(connectedServer[ns],nbSenders[ns],*list_msgLat.back()) ;
+      eventLon.push(rank,nbConnectedClients_[rank],*list_msgLon.back()) ;
+      eventLat.push(rank,nbConnectedClients_[rank],*list_msgLat.back()) ;
     }
 
@@ -916 +804 @@
     if (hasBounds) for(list<CArray<double,2>* >::iterator it=list_boundslon.begin();it!=list_boundslon.end();it++)   delete *it;
     if (hasBounds) for(list<CArray<double,2>* >::iterator it=list_boundslat.begin();it!=list_boundslat.end();it++)   delete *it;
-
   }
 
@@ -1052 +939 @@
     if (hasBounds) buffer>>boundslat ;
     type.setValue((type_attr::t_enum)type_int) ; // probleme des type enum avec les buffers : ToFix
-
     int i,j,ind_srv ;
     for(int ind=0;ind<indi.numElements();ind++)
@@ -1068 +954 @@
     }
   }
-//  void CDomain::recvLonLat(CEventServer& event)
-//  {
-//    list<CEventServer::SSubEvent>::iterator it ;
-//    for (it=event.subEvents.begin();it!=event.subEvents.end();++it)
-//    {
-//      CBufferIn* buffer=it->buffer;
-//      string domainId ;
-//      *buffer>>domainId ;
-//      get(domainId)->recvLonLat(*buffer) ;
-//    }
-//  }
-//
-//  void CDomain::recvLonLat(CBufferIn& buffer)
-//  {
-//    CArray<int,1> indi ;
-//    CArray<int,1> indj ;
-//    CArray<double,1> lon ;
-//    CArray<double,1> lat ;
-//    CArray<double,2> boundslon ;
-//    CArray<double,2> boundslat ;
-//
-//    int type_int ;
-//    buffer>>type_int>>isCurvilinear>>indi>>indj>>lon>>lat ;
-//    if (hasBounds) buffer>>boundslon>>boundslat ;
-//    type.setValue((type_attr::t_enum)type_int) ; // probleme des type enum avec les buffers : ToFix
-//
-//    int i,j,ind_srv ;
-//    for(int ind=0;ind<indi.numElements();ind++)
-//    {
-//      i=indi(ind) ; j=indj(ind) ;
-//      ind_srv=(i-(zoom_ibegin_srv-1))+(j-(zoom_jbegin_srv-1))*zoom_ni_srv ;
-//      lonvalue_srv(ind_srv)=lon(ind) ;
-//      latvalue_srv(ind_srv)=lat(ind) ;
-//      if (hasBounds)
-//      {
-//        for(int nv=0;nv<nvertex;nv++)
-//        {
-//          bounds_lon_srv(nv,ind_srv)=boundslon(nv,ind) ;
-//          bounds_lat_srv(nv,ind_srv)=boundslat(nv,ind) ;
-//        }
-//      }
-//    }
-//  }
+
    //----------------------------------------------------------------
 

XIOS/trunk/src/node/domain.hpp

@@ -113 +113 @@
         vector< vector<int> > j_indSrv ; // for each server, j global index to send
 
+
         CArray<int,2> mapConnectedServer ;  // (ni,nj) => mapped to connected server number, -1 if no server is target
+
 
 //        vector<int> ib_srv, ie_srv, in_srv ;
@@ -152 +154 @@
          std::set<StdString> relFiles;
          bool isClientChecked; // Verify whether all attributes of domain on the client side are good
+         std::map<int,int> nbConnectedClients_; // Mapping of number of communicating client to a server
+         std::map<int, vector<size_t> > indSrv_; // Global index of each client sent to server
 
          DECLARE_REF_FUNC(Domain,domain)

XIOS/trunk/src/node/grid.cpp

@@ -23 +23 @@
       , storeIndex(1), out_i_index(1), out_j_index(1), out_l_index(1), isDomConServerComputed_(false)
       , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false)
-      , serverDistribution_(0)
+      , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_()
    {
      setVirtualDomainGroup();
@@ -34 +34 @@
       , storeIndex(1), out_i_index(1), out_j_index(1), out_l_index(1), isDomConServerComputed_(false)
       , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false)
-      , serverDistribution_(0)
+      , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_()
    {
      setVirtualDomainGroup();
@@ -59 +59 @@
     if (0 != clientDistribution_) delete clientDistribution_;
     if (0 != serverDistribution_) delete serverDistribution_;
+    if (0 != serverDistributionDescription_) delete serverDistributionDescription_;
 
    }
@@ -187 +188 @@
      StdSize retVal;
      std::map<int, StdSize> ret;
-     const std::map<int, std::vector<int> >& distribution = clientDistribution_->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)
@@ -405 +406 @@
      CContext* context = CContext::getCurrent() ;
      CContextClient* client=context->client ;
+
+     // First of all, compute distribution on client side
      clientDistribution_ = new CDistributionClient(client->clientRank, this);
-     clientDistribution_->computeServerIndexMapping(client->serverSize);
-     nbSenders = clientDistribution_->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm);
-
+
+     // Then compute distribution on server side
+     serverDistributionDescription_ = new CServerDistributionDescription(clientDistribution_->getNGlob());
+     serverDistributionDescription_->computeServerDistribution(client->serverSize, true);
+
+     // Finally, compute index mapping between client(s) and server(s)
+     clientServerMap_.computeServerIndexMapping(clientDistribution_->getGlobalIndex(),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);
+
+     // Get local data index on client
      storeIndex_client.resize(clientDistribution_->getLocalDataIndexOnClient().numElements());
      storeIndex_client = (clientDistribution_->getLocalDataIndexOnClient());
@@ -715 +730 @@
     list<shared_ptr<CMessage> > list_msg ;
     list< CArray<size_t,1>* > listOutIndex;
-
-    const std::map<int, std::vector<size_t> >& globalIndexOnServer = clientDistribution_->getGlobalIndexOnServer();
-    const std::map<int, std::vector<int> >& localIndexSendToServer  = clientDistribution_->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;
@@ -724 +738 @@
     iteMap = globalIndexOnServer.end();
     itLocal = localIndexSendToServer.begin();
-
 
     for (int ns = 0; itGlobal != iteMap; ++itGlobal, ++itLocal, ++ns)

XIOS/trunk/src/node/grid.hpp

@@ -13 +13 @@
 #include "distribution_client.hpp"
 #include "distribution_server.hpp"
+#include "server_distribution_description.hpp"
+#include "client_server_mapping.hpp"
 
 namespace xios {
@@ -25 +27 @@
    class CDistributionClient;
    class CDistributionServer;
+   class CServerDistributionDescription;
+   class CClientServerMapping;
 
    ///--------------------------------------------------------------
@@ -220 +224 @@
         CDistributionClient* clientDistribution_;
         CDistributionServer* serverDistribution_;
+        CServerDistributionDescription* serverDistributionDescription_;
+        CClientServerMapping clientServerMap_;
    }; // class CGrid
 

XIOS/trunk/src/test/test_new_features.f90

@@ -13 +13 @@
   TYPE(xios_duration)      :: dtime
   TYPE(xios_context) :: ctx_hdl
-  INTEGER,PARAMETER :: ni_glo=100
-  INTEGER,PARAMETER :: nj_glo=100
+  INTEGER,PARAMETER :: ni_glo=5
+  INTEGER,PARAMETER :: nj_glo=5
   INTEGER,PARAMETER :: llm=5
   DOUBLE PRECISION  :: lval(llm)=1
@@ -70 +70 @@
   ALLOCATE(lon(ni,nj),lat(ni,nj),field_A(0:ni+1,-1:nj+2,llm),lonvalue(ni*nj))
 ! ALLOCATE(lon(ni,nj),lat(ni,nj),field_A(0:ni+1,-1:nj+2,llm,llm),lonvalue(ni*nj))
-  lon(:,:)=lon_glo(ibegin:iend,jbegin:jend)
-  lat(:,:)=lat_glo(ibegin:iend,jbegin:jend)
+  lon(:,:)=lon_glo(ibegin+1:iend+1,jbegin+1:jend+1)
+  lat(:,:)=lat_glo(ibegin+1:iend+1,jbegin+1:jend+1)
   field_A(1:ni,1:nj,:)=field_A_glo(ibegin+1:iend+1,jbegin+1:jend+1,:)