distribution_client.cpp

Aller à la documentation de ce fichier.

#include "distribution_client.hpp"

namespace xios {

CDistributionClient::CDistributionClient(int rank, CGrid* grid)
   : CDistribution(rank, 0)
   , axisDomainOrder_()
   , nLocal_(), nGlob_(), nBeginLocal_(), nBeginGlobal_()
   , dataNIndex_(), dataDims_(), dataBegin_(), dataIndex_()
   , gridMask_(), indexMap_()
   , isDataDistributed_(true), axisNum_(0), domainNum_(0)
   , localDataIndex_(), localMaskIndex_()
   , globalLocalDataSendToServerMap_()
   , infoIndex_(), isComputed_(false)
   , elementLocalIndex_(), elementGlobalIndex_(), elementIndexData_()
   , elementNLocal_(), elementNGlobal_()
{
  readDistributionInfo(grid);
  createGlobalIndex();
}

CDistributionClient::~CDistributionClient()
{ /* Nothing to do */ }

void CDistributionClient::partialClear()
{
  GlobalLocalMap void1 ;
  GlobalLocalMap void2 ;
  std::vector<int> void3 ;
  std::vector<bool> void4 ;

  globalLocalDataSendToServerMap_.swap(void1) ;
  globalDataIndex_.swap(void2) ;
  localDataIndex_.swap(void3);
  localMaskIndex_.swap(void4) ;
}

void CDistributionClient::readDistributionInfo(CGrid* grid)
{
  std::vector<CDomain*> domList = grid->getDomains();
  std::vector<CAxis*> axisList = grid->getAxis();
  std::vector<CScalar*> scalarList = grid->getScalars();
  CArray<int,1> axisDomainOrder = grid->axis_domain_order;

  readDistributionInfo(domList, axisList, scalarList, axisDomainOrder);

  // Then check mask of grid
  int gridDim = domList.size() * 2 + axisList.size();
  switch (gridDim) {
    case 0:
      gridMask_.resize(1);
      gridMask_(0) = true;
      break;
    case 1:
      if (!grid->mask_1d.isEmpty()) readGridMaskInfo(grid->mask_1d);
      break;
    case 2:
      if (!grid->mask_2d.isEmpty()) readGridMaskInfo(grid->mask_2d);
      break;
    case 3:
      if (!grid->mask_3d.isEmpty()) readGridMaskInfo(grid->mask_3d);
      break;
    case 4:
      if (!grid->mask_4d.isEmpty()) readGridMaskInfo(grid->mask_4d);
      break;
    case 5:
      if (!grid->mask_5d.isEmpty()) readGridMaskInfo(grid->mask_5d);
      break;
    case 6:
      if (!grid->mask_6d.isEmpty()) readGridMaskInfo(grid->mask_6d);
      break;
    case 7:
      if (!grid->mask_7d.isEmpty()) readGridMaskInfo(grid->mask_7d);
      break;
    default:
      break;
  }
}

void CDistributionClient::readDistributionInfo(const std::vector<CDomain*>& domList,
                                               const std::vector<CAxis*>& axisList,
                                               const std::vector<CScalar*>& scalarList,
                                               const CArray<int,1>& axisDomainOrder)
{
  domainNum_ = domList.size();
  axisNum_   = axisList.size();
  numElement_ = axisDomainOrder.numElements(); // Number of element, e.x: Axis, Domain

  axisDomainOrder_.resize(numElement_);
  axisDomainOrder_ = axisDomainOrder;

  // Because domain and axis can be in any order (axis1, domain1, axis2, axis3, )
  // their position should be specified. In axisDomainOrder, domain == true, axis == false
  int idx = 0;
  indexMap_.resize(numElement_);
  this->dims_ = numElement_;
  for (int i = 0; i < numElement_; ++i)
  {
    indexMap_[i] = idx;
    if (2 == axisDomainOrder(i))
    {
      ++(this->dims_);
      idx += 2;
    }
    else ++idx;
  }

  // Size of each dimension (local and global)
  nLocal_.resize(this->dims_);
  nGlob_.resize(this->dims_);
  nBeginLocal_.resize(this->dims_,0);
  nBeginGlobal_.resize(this->dims_,0);

  // Data_n_index of domain or axis (For now, axis uses its size as data_n_index
  dataNIndex_.resize(numElement_);
  dataDims_.resize(numElement_);
  dataBegin_.resize(this->dims_);

  // Data_*_index of each dimension
  dataIndex_.resize(this->dims_);
  infoIndex_.resize(this->dims_);

  // A trick to determine position of each domain in domainList
  int domIndex = 0, axisIndex = 0, scalarIndex = 0;
  idx = 0;

  elementLocalIndex_.resize(numElement_);
  elementGlobalIndex_.resize(numElement_);
  elementIndexData_.resize(numElement_);
  elementNLocal_.resize(numElement_);
  elementNGlobal_.resize(numElement_);
  elementNLocal_[0] = 1;
  elementNGlobal_[0] = 1;
  size_t localSize = 1, globalSize = 1;

  isDataDistributed_ = false;
  // Update all the vectors above
  for (idx = 0; idx < numElement_; ++idx)
  {
    int eleDim = axisDomainOrder(idx);
    elementNLocal_[idx] = localSize;
    elementNGlobal_[idx] = globalSize;

    // If this is a domain
    if (2 == eleDim)
    {
      // On the j axis
      nLocal_.at(indexMap_[idx]+1) = domList[domIndex]->nj.getValue();
      nGlob_.at(indexMap_[idx]+1)  = domList[domIndex]->nj_glo.getValue();
      nBeginLocal_.at(indexMap_[idx]+1) = 0;
      nBeginGlobal_.at(indexMap_[idx]+1) = domList[domIndex]->jbegin;

      dataBegin_.at(indexMap_[idx]+1) = domList[domIndex]->data_jbegin.getValue();
      dataIndex_.at(indexMap_[idx]+1).reference(domList[domIndex]->data_j_index);
      infoIndex_.at(indexMap_[idx]+1).reference(domList[domIndex]->j_index);

      // On the i axis
      nLocal_.at(indexMap_[idx]) = domList[domIndex]->ni.getValue();
      nGlob_.at(indexMap_[idx]) = domList[domIndex]->ni_glo.getValue();
      nBeginLocal_.at(indexMap_[idx]) = 0;
      nBeginGlobal_.at(indexMap_[idx]) = domList[domIndex]->ibegin;

      dataBegin_.at(indexMap_[idx]) = domList[domIndex]->data_ibegin.getValue();
      dataIndex_.at(indexMap_[idx]).reference(domList[domIndex]->data_i_index);
      infoIndex_.at(indexMap_[idx]).reference(domList[domIndex]->i_index);

      dataNIndex_.at(idx) = domList[domIndex]->data_i_index.numElements();
      dataDims_.at(idx) = domList[domIndex]->data_dim.getValue();

      isDataDistributed_ |= domList[domIndex]->isDistributed();

      localSize *= nLocal_.at(indexMap_[idx]+1)* nLocal_.at(indexMap_[idx]);
      globalSize *= nGlob_.at(indexMap_[idx]+1)* nGlob_.at(indexMap_[idx]);
      ++domIndex;
    }
    else if (1 == eleDim)// So it's an axis
    {
      nLocal_.at(indexMap_[idx]) = axisList[axisIndex]->n.getValue();
      nGlob_.at(indexMap_[idx]) = axisList[axisIndex]->n_glo.getValue();
      nBeginLocal_.at(indexMap_[idx]) = 0;
      nBeginGlobal_.at(indexMap_[idx]) = axisList[axisIndex]->begin.getValue();

      dataBegin_.at(indexMap_[idx]) = axisList[axisIndex]->data_begin.getValue();
      dataIndex_.at(indexMap_[idx]).reference(axisList[axisIndex]->data_index);
      infoIndex_.at(indexMap_[idx]).reference(axisList[axisIndex]->index);
      dataNIndex_.at(idx) = axisList[axisIndex]->data_index.numElements();
      dataDims_.at(idx) = 1;

      isDataDistributed_ |= axisList[axisIndex]->isDistributed();

      localSize *= nLocal_.at(indexMap_[idx]);
      globalSize *= nGlob_.at(indexMap_[idx]);

      ++axisIndex;
    }
    else // scalar
    {
      nLocal_.at(indexMap_[idx]) = 1;
      nGlob_.at(indexMap_[idx]) = 1;
      nBeginLocal_.at(indexMap_[idx]) = 0;
      nBeginGlobal_.at(indexMap_[idx]) = 1;

      dataBegin_.at(indexMap_[idx]) = 0;
      dataIndex_.at(indexMap_[idx]).resize(1); dataIndex_.at(indexMap_[idx])(0) = 0;
      infoIndex_.at(indexMap_[idx]).resize(1); infoIndex_.at(indexMap_[idx])(0) = 0;
      dataNIndex_.at(idx) = 1;
      dataDims_.at(idx) = 1;

      isDataDistributed_ |= false;

      localSize *= nLocal_.at(indexMap_[idx]);
      globalSize *= nGlob_.at(indexMap_[idx]);

      ++scalarIndex;
    }
  }
}

void CDistributionClient::createLocalDomainDataIndex()
{
  int idxDomain = 0;
  for (int i = 0; i < axisDomainOrder_.numElements(); ++i)
  {
    if (2 == axisDomainOrder_(i))
    {
      elementIndexData_[i].resize(dataNIndex_[i]);
      elementIndexData_[i] = false;
      int iIdx, jIdx = 0, count = 0, localIndex;
      for (int j = 0; j < dataNIndex_[i]; ++j)
      {
        iIdx = getDomainIndex((dataIndex_[indexMap_[i]])(j), (dataIndex_[indexMap_[i]+1])(j),
                              dataBegin_[indexMap_[i]], dataBegin_[indexMap_[i]+1],
                              dataDims_[i], nLocal_[indexMap_[i]], jIdx);

        if ((iIdx >= nBeginLocal_[indexMap_[i]]) && (iIdx < nLocal_[indexMap_[i]]) &&
           (jIdx >= nBeginLocal_[indexMap_[i]+1]) && (jIdx < nLocal_[indexMap_[i]+1]))
        {
          ++count;
          elementIndexData_[i](j) = true;
        }
      }

      elementLocalIndex_[i].resize(count);
      elementGlobalIndex_[i].resize(count);
      count = 0;
      CArray<bool,1>& tmpIndexElementData = elementIndexData_[i];
      CArray<int,1>& tmpLocalElementIndex = elementLocalIndex_[i];
      CArray<size_t,1>& tmpGlobalElementIndex = elementGlobalIndex_[i];
      for (int j = 0; j < dataNIndex_[i]; ++j)
      {
        if (tmpIndexElementData(j))
        {
          iIdx = getDomainIndex((dataIndex_[indexMap_[i]])(j), (dataIndex_[indexMap_[i]+1])(j),
                                dataBegin_[indexMap_[i]], dataBegin_[indexMap_[i]+1],
                                dataDims_[i], nLocal_[indexMap_[i]], jIdx);
          localIndex = tmpLocalElementIndex(count) = iIdx + jIdx * nLocal_[indexMap_[i]];
          tmpGlobalElementIndex(count) = (infoIndex_[indexMap_[i]])(localIndex) + ((infoIndex_[indexMap_[i]+1])(localIndex))*nGlob_[indexMap_[i]];
          ++count;
        }
      }
      ++idxDomain;
    }
  }
}

void CDistributionClient::createLocalAxisDataIndex()
{
  int idxAxis = 0;
  for (int i = 0; i < axisDomainOrder_.numElements(); ++i)
  {
    if (1 == axisDomainOrder_(i))
    {
      elementIndexData_[i].resize(dataNIndex_[i]);
      elementIndexData_[i] = false;
      int iIdx = 0, count = 0;
      for (int j = 0; j < dataNIndex_[i]; ++j)
      {
        iIdx = getAxisIndex((dataIndex_[indexMap_[i]])(j), dataBegin_[indexMap_[i]], nLocal_[indexMap_[i]]);
        if ((iIdx >= nBeginLocal_[indexMap_[i]]) &&
           (iIdx < nLocal_[indexMap_[i]]) )//&& (axisMasks_[idxAxis](iIdx)))
        {
          ++count;
          elementIndexData_[i](j) = true;
        }
      }

      elementLocalIndex_[i].resize(count);
      elementGlobalIndex_[i].resize(count);
      count = 0;
      CArray<bool,1>& tmpIndexElementData = elementIndexData_[i];
      CArray<int,1>& tmpLocalElementIndex = elementLocalIndex_[i];
      CArray<size_t,1>& tmpGlobalElementIndex = elementGlobalIndex_[i];
      for (int j = 0; j < dataNIndex_[i]; ++j)
      {
        if (tmpIndexElementData(j))
        {
          iIdx = tmpLocalElementIndex(count) = getAxisIndex((dataIndex_[indexMap_[i]])(j), dataBegin_[indexMap_[i]], nLocal_[indexMap_[i]]);
          tmpGlobalElementIndex(count) = (infoIndex_[indexMap_[i]])(iIdx);
          ++count;
        }
      }
      ++idxAxis;
    }
  }
}

void CDistributionClient::createLocalScalarDataIndex()
{
  int idxAxis = 0;
  for (int i = 0; i < axisDomainOrder_.numElements(); ++i)
  {
    if (0 == axisDomainOrder_(i))
    {
      elementIndexData_[i].resize(dataNIndex_[i]);
      elementIndexData_[i] = true;
      int count = 1;

      elementLocalIndex_[i].resize(count);
      elementLocalIndex_[i] = 0;
      elementGlobalIndex_[i].resize(count);
      elementGlobalIndex_[i] = 0;
    }
  }
}

void CDistributionClient::createGlobalIndexSendToServer()
{
  if (isComputed_) return;
  isComputed_ = true;
  createLocalDomainDataIndex();
  createLocalAxisDataIndex();
  createLocalScalarDataIndex();

  int idxDomain = 0, idxAxis = 0;
  std::vector<int> eachElementSize(numElement_);

  // Precompute size of the loop
  for (int i = 0; i < numElement_; ++i)
  {
    eachElementSize[i] = elementLocalIndex_[i].numElements();
  }

  //   Compute size of the global index on client
  std::vector<StdSize> idxLoop(numElement_,0);
  std::vector<StdSize> currentIndex(numElement_,0);
  std::vector<StdSize> currentGlobalIndex(numElement_,0);
  int innerLoopSize = eachElementSize[0];
  size_t idx = 0, indexLocalDataOnClientCount = 0;
  size_t ssize = 1;

  for (int i = 0; i < numElement_; ++i) ssize *= eachElementSize[i];

  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
  idxLoop.assign(numElement_,0);
  idx = indexLocalDataOnClientCount = 0;
  ssize = 1; for (int i = 0; i < numElement_; ++i) ssize *= dataNIndex_[i];
  innerLoopSize = dataNIndex_[0];
  int countLocalData = 0;
  std::vector<int> correctIndexOfElement(numElement_,0);
  bool isOuterIndexCorrect = true;
  while (idx < ssize)
  {
    for (int i = 0; i < numElement_-1; ++i)
    {
      if (idxLoop[i] == dataNIndex_[i])
      {
        idxLoop[i] = 0;
        correctIndexOfElement[i] = 0;
        ++idxLoop[i+1];
        if (isOuterIndexCorrect) ++correctIndexOfElement[i+1];
      }
    }

    // Depending the inner-most element axis or domain,
    // The outer loop index begins correspondingly at one (1) or zero (0)
    bool isIndexElementDataCorrect = true;
    for (int i = 1; i < numElement_; ++i)
    {
      if (elementIndexData_[i](idxLoop[i]))
      {
        currentIndex[i] = elementLocalIndex_[i](correctIndexOfElement[i]);
        currentGlobalIndex[i] = elementGlobalIndex_[i](correctIndexOfElement[i]);
        isIndexElementDataCorrect &= true;
      }
      else isIndexElementDataCorrect = false;
    }

    isOuterIndexCorrect = isIndexElementDataCorrect;

    if (isOuterIndexCorrect)
    {
      // Inner most index
      int correctIndexInnerElement = 0;
      for (int i = 0; i < innerLoopSize; ++i)
      {
        bool isCurrentIndexDataCorrect = isOuterIndexCorrect;
        if (elementIndexData_[0](i))
        {
          currentIndex[0] = elementLocalIndex_[0](correctIndexInnerElement);
          currentGlobalIndex[0] = elementGlobalIndex_[0](correctIndexInnerElement);
          isCurrentIndexDataCorrect &= true;
          ++correctIndexInnerElement;
        }
        else isCurrentIndexDataCorrect = false;

        if (isCurrentIndexDataCorrect)
        {
          bool maskTmp = true;
          bool maskGridTmp = true;
          size_t globalIndex = 0;
          for (int k = 0; k < numElement_; ++k)
          {
            globalIndex += (currentGlobalIndex[k])*elementNGlobal_[k];
          }
          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
          if (!gridMask_.isEmpty())
          {
            int gridMaskIndex = 0;
            for (int k = 0; k < this->numElement_; ++k)
            {
              gridMaskIndex += (currentIndex[k])*elementNLocal_[k];
            }
            maskGridTmp =  gridMask_(gridMaskIndex);
            if (maskGridTmp)
              localMaskIndex_[indexLocalDataOnClientCount] = true;
            else
              localMaskIndex_[indexLocalDataOnClientCount] = false;
          }

          ++indexLocalDataOnClientCount;

        }
        ++countLocalData;
        correctIndexOfElement[0] = correctIndexInnerElement;;
      }
    }
    else countLocalData+=innerLoopSize ;

    idxLoop[0] += innerLoopSize;
    idx += innerLoopSize;
  }
}

void CDistributionClient::createGlobalIndex()
{
}

int CDistributionClient::getDomainIndex(const int& dataIIndex, const int& dataJIndex,
                                        const int& dataIBegin, const int& dataJBegin,
                                        const int& dataDim, const int& ni, int& j)
{
  int i;
  int tempI = dataIIndex + dataIBegin,
      tempJ = (dataJIndex + dataJBegin);
  if (ni == 0)
  {
    i = -1;
    j = -1;
    return i;
  }
  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;
}

int CDistributionClient::getAxisIndex(const int& dataIndex, const int& dataBegin, const int& ni)
{
  if (ni == 0)
  {
    return -1;
  }
  int tempI = dataIndex;
  if ((tempI < 0) || (tempI > ni))
    return -1;
  else
    return tempI;
}

CDistributionClient::GlobalLocalDataMap& CDistributionClient::getGlobalLocalDataSendToServer()
{
  if (!isComputed_) createGlobalIndexSendToServer();
  return globalLocalDataSendToServerMap_;
}

CDistributionClient::GlobalLocalDataMap& CDistributionClient::getGlobalDataIndexOnClient()
{
  if (!isComputed_) createGlobalIndexSendToServer();
  return globalDataIndex_;
}

const std::vector<int>& CDistributionClient::getLocalDataIndexOnClient()
{
  if (!isComputed_) createGlobalIndexSendToServer();
  return localDataIndex_;
}

const std::vector<bool>& CDistributionClient::getLocalMaskIndexOnClient()
{
  if (!isComputed_) createGlobalIndexSendToServer();
  return localMaskIndex_;
}

const std::vector<int>& CDistributionClient::getLocalMaskedDataIndexOnClient()
{
  if (!isComputed_) createGlobalIndexSendToServer();
  return localMaskedDataIndex_;
}

} // namespace xios