Changeset 731 for XIOS/trunk/src/node

Timestamp:

10/13/15 15:14:23 (9 years ago)

Author:

rlacroix

Message:

Correctly estimate the needed buffer sizes.

The attributes were not considered which could lead to incorrect estimations.

Location:

XIOS/trunk/src/node

Files:

• axis.cpp (modified) (1 diff)
• axis.hpp (modified) (1 diff)
• context.cpp (modified) (5 diffs)
• context.hpp (modified) (1 diff)
• domain.cpp (modified) (1 diff)
• domain.hpp (modified) (1 diff)
• field.cpp (modified) (1 diff)
• field.hpp (modified) (1 diff)
• grid.cpp (modified) (1 diff)
• grid.hpp (modified) (1 diff)

XIOS/trunk/src/node/axis.cpp

@@ -116 +116 @@
    {
      return offsetWrittenIndexes_;
+   }
+
+   //----------------------------------------------------------------
+
+   /*!
+    * Compute the minimum buffer size required to send the attributes to the server(s).
+    *
+    * \return A map associating the server rank with its minimum buffer size.
+    */
+   std::map<int, StdSize> CAxis::getAttributesBufferSize()
+   {
+     CContextClient* client = CContext::getCurrent()->client;
+
+     std::map<int, StdSize> attributesSizes = getMinimumBufferSizeForAttributes();
+
+     bool isNonDistributed = (n == n_glo);
+
+     if (client->isServerLeader())
+     {
+       // size estimation for sendServerAttribut
+       size_t size = 6 * sizeof(size_t);
+       // size estimation for sendNonDistributedValue
+       if (isNonDistributed)
+         size = std::max(size, CArray<double,1>::size(n_glo) + (isCompressible_ ? CArray<int,1>::size(n_glo) : 0));
+       size += CEventClient::headerSize + getId().size() + sizeof(size_t);
+
+       const std::list<int>& ranks = client->getRanksServerLeader();
+       for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+       {
+         if (size > attributesSizes[*itRank])
+           attributesSizes[*itRank] = size;
+       }
+     }
+
+     if (!isNonDistributed)
+     {
+       // size estimation for sendDistributedValue
+       std::map<int, std::vector<size_t> >::const_iterator it, ite = indSrv_.end();
+       for (it = indSrv_.begin(); it != ite; ++it)
+       {
+         size_t sizeIndexEvent = CArray<int,1>::size(it->second.size());
+         if (isCompressible_)
+           sizeIndexEvent += CArray<int,1>::size(indWrittenSrv_[it->first].size());
+
+         size_t sizeValEvent = CArray<double,1>::size(it->second.size());
+         if (hasBounds_)
+           sizeValEvent += CArray<double,2>::size(it->second.size());
+
+         size_t size = CEventClient::headerSize + getId().size() + sizeof(size_t) + std::max(sizeIndexEvent, sizeValEvent);
+         if (size > attributesSizes[it->first])
+           attributesSizes[it->first] = size;
+       }
+     }
+
+     return attributesSizes;
    }
 

XIOS/trunk/src/node/axis.hpp

@@ -71 +71 @@
          int getTotalNumberWrittenIndexes() const;
          int getOffsetWrittenIndexes() const;
+
+         std::map<int, StdSize> getAttributesBufferSize();
 
          /// Test ///

XIOS/trunk/src/node/context.cpp

@@ -266 +266 @@
    void CContext::setClientServerBuffer()
    {
-     size_t bufferSizeMin = CXios::minBufferSize;
+     size_t minBufferSize = CXios::minBufferSize;
 #define DECLARE_NODE(Name_, name_)    \
-     if (bufferSizeMin < sizeof(C##Name_##Definition)) bufferSizeMin = sizeof(C##Name_##Definition);
+     if (minBufferSize < sizeof(C##Name_##Definition)) minBufferSize = sizeof(C##Name_##Definition);
 #define DECLARE_NODE_PAR(Name_, name_)
 #include "node_type.conf"
@@ -274 +274 @@
 #undef DECLARE_NODE_PAR
 
-     std::map<int, StdSize> bufferSize = getDataSize();
-     std::map<int, StdSize>::iterator it  = bufferSize.begin(),
-                                      ite = bufferSize.end();
-     for (; it != ite; ++it)
-       if (it->second < bufferSizeMin) it->second = bufferSizeMin;
+     std::map<int, StdSize> bufferSize = getAttributesBufferSize();
+     std::map<int, StdSize>::iterator it, ite = bufferSize.end();
+     for (it = bufferSize.begin(); it != ite; ++it)
+       if (it->second < minBufferSize) it->second = minBufferSize;
+
+     std::map<int, StdSize> dataBufferSize = getDataBufferSize();
+     ite = dataBufferSize.end();
+     for (it = dataBufferSize.begin(); it != ite; ++it)
+       if (it->second > bufferSize[it->first]) bufferSize[it->first] = it->second;
 
      if (client->isServerLeader())
@@ -284 +288 @@
        const std::list<int>& ranks = client->getRanksServerLeader();
        for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
-         if (!bufferSize.count(*itRank)) bufferSize[*itRank] = bufferSizeMin;
+         if (!bufferSize.count(*itRank)) bufferSize[*itRank] = minBufferSize;
      }
 
@@ -791 +795 @@
    }
 
-   std::map<int, StdSize>& CContext::getDataSize()
+   std::map<int, StdSize>& CContext::getAttributesBufferSize()
+   {
+     std::map<int, StdSize> attributesSize;
+
+     size_t numEnabledFiles = this->enabledFiles.size();
+     for (size_t i = 0; i < numEnabledFiles; ++i)
+     {
+       CFile* file = this->enabledFiles[i];
+
+       std::vector<CField*> enabledFields = file->getEnabledFields();
+       size_t numEnabledFields = enabledFields.size();
+       for (size_t j = 0; j < numEnabledFields; ++j)
+       {
+         const std::map<int, StdSize> mapSize = enabledFields[j]->getGridAttributesBufferSize();
+         std::map<int, StdSize>::const_iterator it = mapSize.begin(), itE = mapSize.end();
+         for (; it != itE; ++it)
+         {
+           // If attributesSize[it->first] does not exist, it will be zero-initialized
+           // so we can use it safely without checking for its existance
+           if (attributesSize[it->first] < it->second)
+             attributesSize[it->first] = it->second;
+         }
+       }
+     }
+
+     return attributesSize;
+   }
+
+   std::map<int, StdSize>& CContext::getDataBufferSize()
    {
      CFile::mode_attr::t_enum mode = hasClient ? CFile::mode_attr::write : CFile::mode_attr::read;
@@ -810 +842 @@
          for (size_t j = 0; j < numEnabledFields; ++j)
          {
-           const std::map<int, StdSize> mapSize = enabledFields[j]->getGridDataSize();
+           const std::map<int, StdSize> mapSize = enabledFields[j]->getGridDataBufferSize();
            std::map<int, StdSize>::const_iterator it = mapSize.begin(), itE = mapSize.end();
            for (; it != itE; ++it)

XIOS/trunk/src/node/context.hpp

@@ -120 +120 @@
          void postProcessing();
 
-         std::map<int, StdSize>& getDataSize();
+         std::map<int, StdSize>& getAttributesBufferSize();
+         std::map<int, StdSize>& getDataBufferSize();
          void setClientServerBuffer();
 

XIOS/trunk/src/node/domain.cpp

@@ -102 +102 @@
    {
      return offsetWrittenIndexes_;
+   }
+
+   //----------------------------------------------------------------
+
+   /*!
+    * Compute the minimum buffer size required to send the attributes to the server(s).
+    *
+    * \return A map associating the server rank with its minimum buffer size.
+    */
+   std::map<int, StdSize> CDomain::getAttributesBufferSize()
+   {
+     CContextClient* client = CContext::getCurrent()->client;
+
+     std::map<int, StdSize> attributesSizes = getMinimumBufferSizeForAttributes();
+
+     if (client->isServerLeader())
+     {
+       // size estimation for sendServerAttribut
+       size_t size = 11 * sizeof(size_t);
+
+       const std::list<int>& ranks = client->getRanksServerLeader();
+       for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+       {
+         if (size > attributesSizes[*itRank])
+           attributesSizes[*itRank] = size;
+       }
+     }
+
+     std::map<int, std::vector<size_t> >::const_iterator it, ite = indSrv_.end();
+     for (it = indSrv_.begin(); it != ite; ++it)
+     {
+       // size estimation for sendIndex (and sendArea which is always smaller or equal)
+       size_t sizeIndexEvent = 2 * sizeof(size_t) + 2 * CArray<int,1>::size(it->second.size());
+       if (isCompressible_)
+         sizeIndexEvent += CArray<int,1>::size(indWrittenSrv_[it->first].size());
+
+       // size estimation for sendLonLat
+       size_t sizeLonLatEvent = CArray<double,1>::size(it->second.size());
+       if (hasBounds)
+         sizeLonLatEvent += CArray<double,2>::size(it->second.size());
+
+       size_t size = CEventClient::headerSize + getId().size() + sizeof(size_t) + std::max(sizeIndexEvent, sizeLonLatEvent);
+       if (size > attributesSizes[it->first])
+         attributesSizes[it->first] = size;
+     }
+
+     return attributesSizes;
    }
 

XIOS/trunk/src/node/domain.hpp

@@ -90 +90 @@
          int getTotalNumberWrittenIndexes() const;
          int getOffsetWrittenIndexes() const;
+
+         std::map<int, StdSize> getAttributesBufferSize();
 
          bool isEmpty(void) const;

XIOS/trunk/src/node/field.cpp

@@ -527 +527 @@
    }
 
-   std::map<int, StdSize> CField::getGridDataSize()
-   {
-     return grid->getConnectedServerDataSize();
+   std::map<int, StdSize> CField::getGridAttributesBufferSize()
+   {
+     return grid->getAttributesBufferSize();
+   }
+
+   std::map<int, StdSize> CField::getGridDataBufferSize()
+   {
+     return grid->getDataBufferSize(getId());
    }
 

XIOS/trunk/src/node/field.hpp

@@ -93 +93 @@
          void resetNStepMax();
 
-         std::map<int, StdSize> getGridDataSize();
+         std::map<int, StdSize> getGridAttributesBufferSize();
+         std::map<int, StdSize> getGridDataBufferSize();
 
        public:

XIOS/trunk/src/node/grid.cpp

@@ -84 +84 @@
    }
 
-   std::map<int, StdSize> CGrid::getConnectedServerDataSize()
-   {
-     double secureFactor = 2.5 * sizeof(double) * CXios::bufferSizeFactor;
-     StdSize retVal = 1;
-     std::map<int, StdSize> ret;
-     std::map<int, size_t >::const_iterator itb = connectedDataSize_.begin(), it, itE = connectedDataSize_.end();
-
-     if (isScalarGrid())
+   /*!
+    * Compute the minimum buffer size required to send the attributes to the server(s).
+    *
+    * \return A map associating the server rank with its minimum buffer size.
+    */
+   std::map<int, StdSize> CGrid::getAttributesBufferSize()
+   {
+     std::map<int, StdSize> attributesSizes = getMinimumBufferSizeForAttributes();
+
+     // The grid indexes require a similar size as the actual data
+     std::map<int, StdSize> dataSizes = getDataBufferSize();
+     std::map<int, StdSize>::iterator it, itE = dataSizes.end();
+     for (it = dataSizes.begin(); it != itE; ++it)
      {
-       for (it = itb; it != itE; ++it)
+       it->second += 2 * sizeof(bool);
+       if (it->second > attributesSizes[it->first])
+         attributesSizes[it->first] = it->second;
+     }
+
+     // Account for the axis attributes
+     std::vector<CAxis*> axisList = getAxis();
+     for (size_t i = 0; i < axisList.size(); ++i)
+     {
+       std::map<int, StdSize> axisAttBuffSize = axisList[i]->getAttributesBufferSize();
+       for (it = axisAttBuffSize.begin(), itE = axisAttBuffSize.end(); it != itE; ++it)
        {
-         retVal *= secureFactor;
-         ret.insert(std::make_pair(it->first, retVal));
-       }
-       return ret;
-     }
-
-     for (it = itb; it != itE; ++it)
-     {
-        retVal = it->second;
-        retVal *= secureFactor;
-        ret.insert(std::make_pair<int,StdSize>(it->first, retVal));
-     }
-
-     if (connectedDataSize_.empty())
-     {
-       for (int i = 0; i < connectedServerRank_.size(); ++i)
-       {
-         retVal = 1;
-         retVal *= secureFactor;
-         ret.insert(std::make_pair<int,StdSize>(connectedServerRank_[i], retVal));
+         if (it->second > attributesSizes[it->first])
+           attributesSizes[it->first] = it->second;
        }
      }
 
-     // In some cases in which domain is masked, we need to count for connected server for longitude and latitude
-     std::vector<CDomain*> domListP = this->getDomains();
-     if (!domListP.empty())
+     // Account for the domain attributes
+     std::vector<CDomain*> domList = getDomains();
+     for (size_t i = 0; i < domList.size(); ++i)
      {
-       for (int i = 0; i < domListP.size(); ++i)
+       std::map<int, StdSize> domAttBuffSize = domList[i]->getAttributesBufferSize();
+       for (it = domAttBuffSize.begin(), itE = domAttBuffSize.end(); it != itE; ++it)
        {
-         const std::map<int, vector<size_t> >& indexDomainServer = domListP[i]->getIndexServer();
-         std::map<int, vector<size_t> >::const_iterator itDom = indexDomainServer.begin(), iteDom = indexDomainServer.end();
-         for (; itDom != iteDom; ++itDom)
-         {
-           if (ret.end() == ret.find(itDom->first))
-           {
-              retVal = (itDom->second).size();
-              retVal *= secureFactor;
-              ret.insert(std::make_pair<int,StdSize>(itDom->first, retVal));
-           }
-         }
+         if (it->second > attributesSizes[it->first])
+           attributesSizes[it->first] = it->second;
        }
      }
-
-     return ret;
+     
+     return attributesSizes;
+   }
+
+   /*!
+    * Compute the minimum buffer size required to send the data to the server(s).
+    *
+    * \param id the id used to tag the data
+    * \return A map associating the server rank with its minimum buffer size.
+    */
+   std::map<int, StdSize> CGrid::getDataBufferSize(const std::string& id /*= ""*/)
+   {
+     std::map<int, StdSize> dataSizes;
+     const size_t extraSize = CEventClient::headerSize + (id.empty() ? getId() : id).size() + sizeof(size_t);
+
+     std::map<int, size_t>::const_iterator itb = connectedDataSize_.begin(), it, itE = connectedDataSize_.end();
+     for (it = itb; it != itE; ++it)
+       dataSizes.insert(std::make_pair(it->first, extraSize + CArray<double,1>::size(it->second)));
+
+     return dataSizes;
    }
 

XIOS/trunk/src/node/grid.hpp

@@ -158 +158 @@
          void computeDomConServer();
          std::map<int, int> getDomConServerSide();
-         std::map<int, StdSize> getConnectedServerDataSize();
+         std::map<int, StdSize> getAttributesBufferSize();
+         std::map<int, StdSize> getDataBufferSize(const std::string& id = "");
          std::vector<StdString> getDomainList();
          std::vector<StdString> getAxisList();