Changeset 1570 for XIOS/dev/dev_olga/src/distribution_client.cpp

Timestamp:

08/31/18 14:15:54 (6 years ago)

Author:

oabramkina

Message:

Further simplifications on sending data/grid indexes.

(1) Domain/axis mask is not sent anymore. It has been incorporated into data index.

(2) Creating a map that holds grid mask only in case if grid mask is defined.

Still to fix: a hole in a domain or axis.

File:

• XIOS/dev/dev_olga/src/distribution_client.cpp (modified) (9 diffs)

XIOS/dev/dev_olga/src/distribution_client.cpp

@@ -15 +15 @@
    , axisDomainOrder_()
    , nLocal_(), nGlob_(), nBeginLocal_(), nBeginGlobal_()
-   , dataNIndex_(), dataDims_(), dataBegin_(), dataIndex_(), domainMasks_(), axisMasks_()
+   , dataNIndex_(), dataDims_(), dataBegin_(), dataIndex_()//, domainMasks_()//, axisMasks_()
    , gridMask_(), indexMap_()
    , isDataDistributed_(true), axisNum_(0), domainNum_(0)
@@ -117 +117 @@
   axisDomainOrder_ = axisDomainOrder;
 
-  // Each domain or axis has its mask, of course
-  domainMasks_.resize(domainNum_);
-  for (int i = 0; i < domainNum_;++i)
-  {
-    domainMasks_[i].resize(domList[i]->domainMask.numElements());
-    domainMasks_[i] = domList[i]->domainMask;
-  }
-
-  axisMasks_.resize(axisNum_);
-  for (int i = 0; i < axisNum_; ++i)
-  {
-    axisMasks_[i].resize(axisList[i]->mask.numElements());
-    axisMasks_[i] = axisList[i]->mask;
-  }
+//  // Each domain or axis has its mask, of course
+//  domainMasks_.resize(domainNum_);
+//  for (int i = 0; i < domainNum_;++i)
+//  {
+//    domainMasks_[i].resize(domList[i]->domainMask.numElements());
+//    domainMasks_[i] = domList[i]->domainMask;
+//  }
+
+//  axisMasks_.resize(axisNum_);
+//  for (int i = 0; i < axisNum_; ++i)
+//  {
+//    axisMasks_[i].resize(axisList[i]->mask.numElements());
+//    axisMasks_[i] = axisList[i]->mask;
+//  }
 
   // Because domain and axis can be in any order (axis1, domain1, axis2, axis3, )
@@ -282 +282 @@
 
         if ((iIdx >= nBeginLocal_[indexMap_[i]]) && (iIdx < nLocal_[indexMap_[i]]) &&
-           (jIdx >= nBeginLocal_[indexMap_[i]+1]) && (jIdx < nLocal_[indexMap_[i]+1])
-           && (domainMasks_[idxDomain](iIdx + jIdx*nLocal_[indexMap_[i]])))
+           (jIdx >= nBeginLocal_[indexMap_[i]+1]) && (jIdx < nLocal_[indexMap_[i]+1]))
+//           && (domainMasks_[idxDomain](iIdx + jIdx*nLocal_[indexMap_[i]])))
         {
           ++count;
@@ -330 +330 @@
         iIdx = getAxisIndex((dataIndex_[indexMap_[i]])(j), dataBegin_[indexMap_[i]], nLocal_[indexMap_[i]]);
         if ((iIdx >= nBeginLocal_[indexMap_[i]]) &&
-           (iIdx < nLocal_[indexMap_[i]]) && (axisMasks_[idxAxis](iIdx)))
+           (iIdx < nLocal_[indexMap_[i]]) )//&& (axisMasks_[idxAxis](iIdx)))
         {
           ++count;
@@ -413 +413 @@
 
   for (int i = 0; i < numElement_; ++i) ssize *= eachElementSize[i];
-  while (idx < ssize)
-  {
-    for (int i = 0; i < numElement_-1; ++i)
-    {
-      if (idxLoop[i] == eachElementSize[i])
-      {
-        idxLoop[i] = 0;
-        ++idxLoop[i+1];
-      }
-    }
-
-    // Find out outer index
-    // Depending the inner-most element is axis or domain,
-    // The outer loop index begins correspondingly at one (1) or zero (0)
-    for (int i = 1; i < numElement_; ++i)
-    {
-      currentIndex[i] = elementLocalIndex_[i](idxLoop[i]);
-    }
-
-    // Inner most index
-    for (int i = 0; i < innerLoopSize; ++i)
-    {
-      int gridMaskIndex = 0;
-      currentIndex[0] = elementLocalIndex_[0](i);
-
-      bool maskTmp = true;
-      int idxDomain = 0, idxAxis = 0;
-      for (int elem = 0; elem < numElement_; ++elem)
-      {
-        if (2 == axisDomainOrder_(elem))
-        {
-          maskTmp = maskTmp && domainMasks_[idxDomain](currentIndex[elem]);
-          ++idxDomain;
-        }
-        else if (1 == axisDomainOrder_(elem))
-        {
-          maskTmp = maskTmp && axisMasks_[idxAxis](currentIndex[elem]);
-          ++idxAxis;
-        }
-      }
-      if (maskTmp) ++indexLocalDataOnClientCount;
-    }
-    idxLoop[0] += innerLoopSize;
-    idx += innerLoopSize;
-  }
+//  while (idx < ssize)
+//  {
+//    for (int i = 0; i < numElement_-1; ++i)
+//    {
+//      if (idxLoop[i] == eachElementSize[i])
+//      {
+//        idxLoop[i] = 0;
+//        ++idxLoop[i+1];
+//      }
+//    }
+//
+//    // Find out outer index
+//    // Depending the inner-most element is axis or domain,
+//    // The outer loop index begins correspondingly at one (1) or zero (0)
+//    for (int i = 1; i < numElement_; ++i)
+//    {
+//      currentIndex[i] = elementLocalIndex_[i](idxLoop[i]);
+//    }
+//
+//    // Inner most index
+//    for (int i = 0; i < innerLoopSize; ++i)
+//    {
+//      int gridMaskIndex = 0;
+//      currentIndex[0] = elementLocalIndex_[0](i);
+//
+//      bool maskTmp = true;
+//      int idxDomain = 0, idxAxis = 0;
+//      for (int elem = 0; elem < numElement_; ++elem)
+//      {
+//        if (2 == axisDomainOrder_(elem))
+//        {
+//          maskTmp = maskTmp && domainMasks_[idxDomain](currentIndex[elem]);
+//          ++idxDomain;
+//        }
+//        else if (1 == axisDomainOrder_(elem))
+//        {
+//          maskTmp = maskTmp && axisMasks_[idxAxis](currentIndex[elem]);
+//          ++idxAxis;
+//        }
+//      }
+//      if (maskTmp) ++indexLocalDataOnClientCount;
+//    }
+//    idxLoop[0] += innerLoopSize;
+//    idx += innerLoopSize;
+//  }
 
   // Now allocate these arrays
-  localDataIndex_.resize(indexLocalDataOnClientCount);
-  localMaskIndex_.resize(indexLocalDataOnClientCount);
-  localMaskedDataIndex_.resize(indexLocalDataOnClientCount);
-  globalDataIndex_.rehash(std::ceil(indexLocalDataOnClientCount/globalDataIndex_.max_load_factor()));
-  globalLocalDataSendToServerMap_.rehash(std::ceil(indexLocalDataOnClientCount/globalLocalDataSendToServerMap_.max_load_factor()));
+//  localDataIndex_.resize(indexLocalDataOnClientCount);
+//  localMaskIndex_.resize(indexLocalDataOnClientCount);
+//  localMaskedDataIndex_.resize(indexLocalDataOnClientCount);
+//  globalDataIndex_.rehash(std::ceil(indexLocalDataOnClientCount/globalDataIndex_.max_load_factor()));
+//  globalLocalDataSendToServerMap_.rehash(std::ceil(indexLocalDataOnClientCount/globalLocalDataSendToServerMap_.max_load_factor()));
+
+  localDataIndex_.resize(ssize);
+  if (!gridMask_.isEmpty()) localMaskIndex_.resize(ssize);
+  localMaskedDataIndex_.resize(ssize);
+  globalDataIndex_.rehash(std::ceil(ssize/globalDataIndex_.max_load_factor()));
+  globalLocalDataSendToServerMap_.rehash(std::ceil(ssize/globalLocalDataSendToServerMap_.max_load_factor()));
+
 
   // We need to loop with data index
@@ -524 +531 @@
           bool maskGridTmp = true;
 
-          // Domain or axis mask: only unmasked values will be sent
-          int idxDomain = 0, idxAxis = 0;
-          for (int elem = 0; elem < numElement_; ++elem)
-          {
-            if (2 == axisDomainOrder_(elem))
+//          // Domain or axis mask: only unmasked values will be sent
+//          int idxDomain = 0, idxAxis = 0;
+//          for (int elem = 0; elem < numElement_; ++elem)
+//          {
+//            if (2 == axisDomainOrder_(elem))
+//            {
+//              maskTmp = maskTmp && domainMasks_[idxDomain](currentIndex[elem]);
+//              ++idxDomain;
+//            }
+//            else if (1 == axisDomainOrder_(elem))
+//            {
+//              maskTmp = maskTmp && axisMasks_[idxAxis](currentIndex[elem]);
+//              ++idxAxis;
+//            }
+//          }
+
+//          if (maskTmp)
+//          {
+            size_t globalIndex = 0;
+            for (int k = 0; k < numElement_; ++k)
             {
-              maskTmp = maskTmp && domainMasks_[idxDomain](currentIndex[elem]);
-              ++idxDomain;
+              globalIndex += (currentGlobalIndex[k])*elementNGlobal_[k];
             }
-            else if (1 == axisDomainOrder_(elem))
-            {
-              maskTmp = maskTmp && axisMasks_[idxAxis](currentIndex[elem]);
-              ++idxAxis;
-            }
-          }
+            globalDataIndex_[globalIndex] = indexLocalDataOnClientCount;
+            localDataIndex_[indexLocalDataOnClientCount] = countLocalData;
+            globalLocalDataSendToServerMap_[globalIndex] = indexLocalDataOnClientCount;
+            localMaskedDataIndex_[indexLocalDataOnClientCount] = indexLocalDataOnClientCount;
+//          }
 
           // Grid mask: unmasked values will be replaces by NaN and then all values will be sent
@@ -549 +569 @@
             }
             maskGridTmp =  gridMask_(gridMaskIndex);
-          }
-
-          if (maskTmp)
-          {
-            size_t globalIndex = 0;
-            for (int k = 0; k < numElement_; ++k)
-            {
-              globalIndex += (currentGlobalIndex[k])*elementNGlobal_[k];
-            }
-            globalDataIndex_[globalIndex] = indexLocalDataOnClientCount;
-            localDataIndex_[indexLocalDataOnClientCount] = countLocalData;
             if (maskGridTmp)
               localMaskIndex_[indexLocalDataOnClientCount] = true;
             else
               localMaskIndex_[indexLocalDataOnClientCount] = false;
-            globalLocalDataSendToServerMap_[globalIndex] = indexLocalDataOnClientCount;
-            localMaskedDataIndex_[indexLocalDataOnClientCount] = indexLocalDataOnClientCount;
-            ++indexLocalDataOnClientCount;
           }
+
+          ++indexLocalDataOnClientCount;
+
         }
         ++countLocalData;
@@ -600 +609 @@
                                         const int& dataDim, const int& ni, int& j)
 {
+  int i;
   int tempI = dataIIndex + dataIBegin,
       tempJ = (dataJIndex + dataJBegin);
   if (ni == 0)
   {
-    int i = 0;
-    j = 0;
+    i = -1;
+    j = -1;
     return i;
   }
-  int i = (dataDim == 1) ? (tempI) % ni
-                         : (tempI) ;
-  j = (dataDim == 1) ? (tempI) / ni
-                     : (tempJ) ;
-
+  if ((tempI < 0) || (tempJ < 0))
+  {
+    i = -1;
+    j = -1;
+    return i;
+  }
+  else
+  {
+    i = (dataDim == 1) ? (tempI) % ni : (tempI) ;
+    j = (dataDim == 1) ? (tempI) / ni : (tempJ) ;
+  }
   return i;
 }
@@ -629 +645 @@
     return -1;
   }
-  int tempI = dataIndex; //+ dataBegin;
+  int tempI = dataIndex;
   if ((tempI < 0) || (tempI > ni))
     return -1;