17 #include <unordered_map>
23 tmpGridDestination_(destination), originalGridSource_(source),
24 tempGridSrcs_(), tempGridDests_(),
25 dynamicalTransformation_(false), timeStamp_()
42 std::vector<CScalar*> scaListDestP = gridDestination_->getScalars();
43 int scalarDstIndex = elementPositionInGridDst2ScalarPosition_[elementPositionInGrid];
45 CScalar::TransMapTypes::const_iterator it = trans.begin();
47 for (
int i = 0; i < transformationOrder; ++i, ++it) {}
53 elementPositionInGrid,
54 elementPositionInGridSrc2ScalarPosition_,
55 elementPositionInGridSrc2AxisPosition_,
56 elementPositionInGridSrc2DomainPosition_,
57 elementPositionInGridDst2ScalarPosition_,
58 elementPositionInGridDst2AxisPosition_,
59 elementPositionInGridDst2DomainPosition_);
60 algoTransformation_.push_back(algo);
73 std::vector<CAxis*> axisListDestP = gridDestination_->getAxis();
74 int axisDstIndex = elementPositionInGridDst2AxisPosition_[elementPositionInGrid];
76 CAxis::TransMapTypes::const_iterator it = trans.begin();
77 for (
int i = 0; i < transformationOrder; ++i, ++it) {}
84 elementPositionInGrid,
85 elementPositionInGridSrc2ScalarPosition_,
86 elementPositionInGridSrc2AxisPosition_,
87 elementPositionInGridSrc2DomainPosition_,
88 elementPositionInGridDst2ScalarPosition_,
89 elementPositionInGridDst2AxisPosition_,
90 elementPositionInGridDst2DomainPosition_);
91 algoTransformation_.push_back(algo);
104 std::vector<CDomain*> domainListDestP = gridDestination_->getDomains();
105 int domainIndex = elementPositionInGridDst2DomainPosition_[elementPositionInGrid];
107 CDomain::TransMapTypes::const_iterator it = trans.begin();
108 for (
int i = 0; i < transformationOrder; ++i, ++it) {}
115 elementPositionInGrid,
116 elementPositionInGridSrc2ScalarPosition_,
117 elementPositionInGridSrc2AxisPosition_,
118 elementPositionInGridSrc2DomainPosition_,
119 elementPositionInGridDst2ScalarPosition_,
120 elementPositionInGridDst2AxisPosition_,
121 elementPositionInGridDst2DomainPosition_);
122 algoTransformation_.push_back(algo);
133 std::vector<CScalar*> scalarListP = grid->getScalars();
134 std::vector<CAxis*> axisListP = grid->getAxis();
135 std::vector<CDomain*> domListP = grid->getDomains();
137 int scalarIndex = 0, axisIndex = 0, domainIndex = 0;
138 int nbElement = axisDomainOrder.numElements(), elementDim;
139 std::map<int,std::pair<int,int> > elementPosition;
140 for (
int idx = 0; idx < nbElement; ++idx)
142 elementDim = axisDomainOrder(idx);
146 elementPosition[idx] = std::make_pair(elementDim, domainIndex);
150 elementPosition[idx] = std::make_pair(elementDim, axisIndex);
154 elementPosition[idx] = std::make_pair(elementDim, scalarIndex);
162 return elementPosition;
175 if (isSpecialTransformation(transType))
return;
177 if (!tempGridDests_.empty() && (getNbAlgo() == tempGridDests_.size()))
179 tempGridDests_.resize(0);
182 if (1 == getNbAlgo())
184 tmpGridDestination_ = gridDestination_;
188 std::vector<CScalar*> scalarListDestP = gridDestination_->getScalars();
189 std::vector<CScalar*> scalarListSrcP = gridSource_->getScalars(), scalarDst;
191 std::vector<CAxis*> axisListDestP = gridDestination_->getAxis();
192 std::vector<CAxis*> axisListSrcP = gridSource_->getAxis(), axisDst;
194 std::vector<CDomain*> domListDestP = gridDestination_->getDomains();
195 std::vector<CDomain*> domListSrcP = gridSource_->getDomains(), domainDst;
197 CArray<int,1> axisDomainOrderSrc = gridSource_->axis_domain_order;
198 CArray<int,1> axisDomainOrderDst = gridDestination_->axis_domain_order;
200 std::map<int,std::pair<int,int> > elementPositionSrc = getElementPosition(gridSource_);
201 std::map<int,std::pair<int,int> > elementPositionDst = getElementPosition(gridDestination_);
203 CArray<int,1> elementOrder(axisDomainOrderDst.numElements());
204 for (
int idx = 0; idx < axisDomainOrderDst.numElements(); ++idx)
206 if (elementPositionInGrid == idx)
208 int dimElementDst = elementPositionDst[idx].first;
209 int elementIndex = elementPositionDst[idx].second;
210 switch (dimElementDst)
213 domainDst.push_back(domListDestP[elementIndex]);
216 axisDst.push_back(axisListDestP[elementIndex]);
219 scalarDst.push_back(scalarListDestP[elementIndex]);
224 elementOrder(idx) = dimElementDst;
228 int dimElementSrc = elementPositionSrc[idx].first;
229 int elementIndex = elementPositionSrc[idx].second;
230 switch (dimElementSrc)
233 domainDst.push_back(domListSrcP[elementIndex]);
236 axisDst.push_back(axisListSrcP[elementIndex]);
239 scalarDst.push_back(scalarListSrcP[elementIndex]);
244 elementOrder(idx) = dimElementSrc;
248 tmpGridDestination_ =
CGrid::createGrid(domainDst, axisDst, scalarDst, elementOrder);
249 tempGridDests_.push_back(tmpGridDestination_);
263 if (!tempGridSrcs_.empty() && (getNbAlgo()-1) == tempGridSrcs_.size())
265 tempGridSrcs_.resize(0);
268 std::vector<CScalar*> scalarListDestP = tmpGridDestination_->getScalars();
269 std::vector<CScalar*> scalarListSrcP = gridSource_->getScalars(), scalarSrc;
271 std::vector<CAxis*> axisListDestP = tmpGridDestination_->getAxis();
272 std::vector<CAxis*> axisListSrcP = gridSource_->getAxis(), axisSrc;
274 std::vector<CDomain*> domListDestP = tmpGridDestination_->getDomains();
275 std::vector<CDomain*> domListSrcP = gridSource_->getDomains(), domainSrc;
277 CArray<int,1> axisDomainOrderSrc = gridSource_->axis_domain_order;
278 CArray<int,1> axisDomainOrderDst = tmpGridDestination_->axis_domain_order;
280 std::map<int,std::pair<int,int> > elementPositionSrc = getElementPosition(gridSource_);
281 std::map<int,std::pair<int,int> > elementPositionDst = getElementPosition(tmpGridDestination_);
283 for (
int idx = 0; idx < axisDomainOrderDst.numElements(); ++idx)
285 if (elementPositionInGrid == idx)
287 int dimElementDst = elementPositionDst[idx].first;
288 int elementIndex = elementPositionDst[idx].second;
289 if (2 == dimElementDst)
292 domain->domain_ref.setValue(domListDestP[elementIndex]->getId());
293 domain->solveRefInheritance(
true);
295 domainSrc.push_back(domain);
297 else if (1 == dimElementDst)
300 axis->axis_ref.setValue(axisListDestP[elementIndex]->getId());
301 axis->solveRefInheritance(
true);
303 axisSrc.push_back(axis);
308 scalar->scalar_ref.setValue(scalarListDestP[elementIndex]->getId());
309 scalar->solveRefInheritance(
true);
311 scalarSrc.push_back(scalar);
316 int dimElementDst = elementPositionDst[idx].first;
317 int elementIndex = elementPositionDst[idx].second;
318 switch (dimElementDst)
321 domainSrc.push_back(domListDestP[elementIndex]);
324 axisSrc.push_back(axisListDestP[elementIndex]);
327 scalarSrc.push_back(scalarListDestP[elementIndex]);
335 gridSource_ =
CGrid::createGrid(domainSrc, axisSrc, scalarSrc, tmpGridDestination_->axis_domain_order);
337 tempGridSrcs_.push_back(gridSource_);
352 if (nbNormalAlgos_ < 1)
return;
353 if (!auxInputs_.empty() && !dynamicalTransformation_) { dynamicalTransformation_ =
true;
return; }
354 if (dynamicalTransformation_)
356 if (timeStamp_.insert(timeStamp).second)
358 std::list<SendingIndexGridSourceMap>().swap(localIndexToSendFromGridSource_);
359 std::list<RecvIndexGridDestinationMap>().swap(localIndexToReceiveOnGridDest_);
360 std::list<size_t>().swap(nbLocalIndexOnGridDest_);
369 ListAlgoType::const_iterator itb = listAlgos_.begin(),
370 ite = listAlgos_.end(), it;
373 int nbAgloTransformation = 0;
374 for (it = itb; it != ite; ++it)
376 int elementPositionInGrid = it->first;
378 int transformationOrder = (it->second).second.first;
379 int algoType = ((it->second).second.second);
385 setUpGridDestination(elementPositionInGrid, transType);
388 if (!dynamicalTransformation_ || (algoTransformation_.size() < listAlgos_.size()))
390 selectAlgo(elementPositionInGrid, transType, transformationOrder, algoType);
391 algo = algoTransformation_.back();
394 algo = algoTransformation_[std::distance(itb, it)];
405 int elementPosition = it->first;
406 bool nonDistributedActivated = CXios::getin<bool>(
"activate_non_distributed_transformation",
false);
410 vector<int> localSrc ;
411 vector<int> localDst ;
412 vector<double> weight ;
413 int nbLocalIndexOnGridDest;
416 localSrc, localDst, weight, nbLocalIndexOnGridDest) ;
420 nbLocalIndexOnGridDest_.push_back(nbLocalIndexOnGridDest) ;
424 localIndexToSendFromGridSource_.push_back(tmp) ;
429 array.
resize(localSrc.size()) ;
430 for(
int i=0;i< localSrc.size();++i) array(i)=localSrc[i] ;
434 localIndexToReceiveOnGridDest_.push_back(tmp) ;
436 vector<pair<int,double> > vectTmp ;
437 dst.insert( pair<
int,vector<pair<int,double> > >(clientRank,vectTmp)) ;
438 vector<pair<int,double> >& vect=dst[clientRank] ;
439 vect.resize(localDst.size()) ;
440 for(
int i=0;i< localDst.size();++i) vect[i]=pair<int,double>(localDst[i],weight[i]) ;
450 globaIndexWeightFromSrcToDst);
455 computeTransformationMapping(globaIndexWeightFromSrcToDst);
458 if (1 < nbNormalAlgos_)
461 if (nbAgloTransformation != (nbNormalAlgos_-1)) setUpGridSource(elementPositionInGrid);
463 ++nbAgloTransformation;
486 size_t nbLocalIndex = globalLocalIndexGridDestSendToServer.size();
487 nbLocalIndexOnGridDest_.push_back(nbLocalIndex);
493 SourceDestinationIndexMap::const_iterator itbIndex = globaIndexWeightFromSrcToDst.begin(),
494 iteIndex = globaIndexWeightFromSrcToDst.end(), itIndex;
495 typedef std::unordered_map<size_t, std::vector<std::pair<size_t,double> > > SendIndexMap;
496 std::map<int,int> sendRankSizeMap,recvRankSizeMap;
497 int connectedClient = globaIndexWeightFromSrcToDst.size();
498 int* recvCount=
new int[nbClient];
499 int* displ=
new int[nbClient];
500 int* sendRankBuff=
new int[connectedClient];
501 int* sendSizeBuff=
new int[connectedClient];
503 for (itIndex = itbIndex; itIndex != iteIndex; ++itIndex, ++n)
505 sendRankBuff[n] = itIndex->first;
506 const SendIndexMap& sendIndexMap = itIndex->second;
507 SendIndexMap::const_iterator itbSend = sendIndexMap.begin(), iteSend = sendIndexMap.end(), itSend;
509 for (itSend = itbSend; itSend != iteSend; ++itSend)
511 sendSize += itSend->second.size();
513 sendSizeBuff[n] = sendSize;
514 sendRankSizeMap[itIndex->first] = sendSize;
516 MPI_Allgather(&connectedClient,1,MPI_INT,recvCount,1,MPI_INT,client->
intraComm);
519 for(
int n=1;n<nbClient;n++) displ[n]=displ[n-1]+recvCount[n-1];
520 int recvSize=displ[nbClient-1]+recvCount[nbClient-1];
521 int* recvRankBuff=
new int[recvSize];
522 int* recvSizeBuff=
new int[recvSize];
523 MPI_Allgatherv(sendRankBuff,connectedClient,MPI_INT,recvRankBuff,recvCount,displ,MPI_INT,client->
intraComm);
524 MPI_Allgatherv(sendSizeBuff,connectedClient,MPI_INT,recvSizeBuff,recvCount,displ,MPI_INT,client->
intraComm);
525 for (
int i = 0; i < nbClient; ++i)
527 int currentPos = displ[i];
528 for (
int j = 0; j < recvCount[i]; ++j)
529 if (recvRankBuff[currentPos+j] == clientRank)
531 recvRankSizeMap[i] = recvSizeBuff[currentPos+j];
536 std::vector<MPI_Request> requests;
537 std::vector<MPI_Status> status;
538 std::unordered_map<int, unsigned char* > recvMaskDst;
539 std::unordered_map<int, unsigned long* > recvGlobalIndexSrc;
540 for (std::map<int,int>::const_iterator itRecv = recvRankSizeMap.begin(); itRecv != recvRankSizeMap.end(); ++itRecv)
542 int recvRank = itRecv->first;
543 int recvSize = itRecv->second;
544 recvMaskDst[recvRank] =
new unsigned char [recvSize];
545 recvGlobalIndexSrc[recvRank] =
new unsigned long [recvSize];
547 requests.push_back(MPI_Request());
548 MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, MPI_UNSIGNED_LONG, recvRank, 46, client->
intraComm, &requests.back());
549 requests.push_back(MPI_Request());
550 MPI_Irecv(recvMaskDst[recvRank], recvSize, MPI_UNSIGNED_CHAR, recvRank, 47, client->
intraComm, &requests.back());
553 std::unordered_map<int, CArray<size_t,1> > globalIndexDst;
554 std::unordered_map<int, CArray<double,1> > weightDst;
555 std::unordered_map<int, unsigned char* > sendMaskDst;
556 std::unordered_map<int, unsigned long* > sendGlobalIndexSrc;
557 for (itIndex = itbIndex; itIndex != iteIndex; ++itIndex)
559 int sendRank = itIndex->first;
560 int sendSize = sendRankSizeMap[sendRank];
561 const SendIndexMap& sendIndexMap = itIndex->second;
562 SendIndexMap::const_iterator itbSend = sendIndexMap.begin(), iteSend = sendIndexMap.end(), itSend;
563 globalIndexDst[sendRank].resize(sendSize);
564 weightDst[sendRank].resize(sendSize);
565 sendMaskDst[sendRank] =
new unsigned char [sendSize];
566 sendGlobalIndexSrc[sendRank] =
new unsigned long [sendSize];
568 for (itSend = itbSend; itSend != iteSend; ++itSend)
570 const std::vector<std::pair<size_t,double> >& dstWeight = itSend->second;
571 for (
int idx = 0; idx < dstWeight.size(); ++idx)
573 globalIndexDst[sendRank](countIndex) = dstWeight[idx].first;
574 weightDst[sendRank](countIndex) = dstWeight[idx].second;
575 if (0 < globalLocalIndexGridDestSendToServer.count(dstWeight[idx].first))
576 sendMaskDst[sendRank][countIndex] = 1;
578 sendMaskDst[sendRank][countIndex] = 0;
579 sendGlobalIndexSrc[sendRank][countIndex] = itSend->first;
585 requests.push_back(MPI_Request());
586 MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, MPI_UNSIGNED_LONG, sendRank, 46, client->
intraComm, &requests.back());
587 requests.push_back(MPI_Request());
588 MPI_Isend(sendMaskDst[sendRank], sendSize, MPI_UNSIGNED_CHAR, sendRank, 47, client->
intraComm, &requests.back());
591 status.resize(requests.size());
592 MPI_Waitall(requests.size(), &requests[0], &status[0]);
595 std::vector<MPI_Request>().swap(requests);
596 std::vector<MPI_Status>().swap(status);
598 for (std::map<int,int>::const_iterator itSend = sendRankSizeMap.begin(); itSend != sendRankSizeMap.end(); ++itSend)
600 int recvRank = itSend->first;
601 int recvSize = itSend->second;
603 requests.push_back(MPI_Request());
604 MPI_Irecv(sendMaskDst[recvRank], recvSize, MPI_UNSIGNED_CHAR, recvRank, 48, client->
intraComm, &requests.back());
612 for (std::map<int,int>::const_iterator itRecv = recvRankSizeMap.begin(); itRecv != recvRankSizeMap.end(); ++itRecv)
614 int recvRank = itRecv->first;
615 int recvSize = itRecv->second;
616 unsigned char* recvMask = recvMaskDst[recvRank];
617 unsigned long* recvIndexSrc = recvGlobalIndexSrc[recvRank];
618 int realSendSize = 0;
619 for (
int idx = 0; idx < recvSize; ++idx)
621 if (0 != (*(recvMask+idx)))
622 if (0 < globalLocalIndexGridSrcSendToServer.count(*(recvIndexSrc+idx)))
628 tmpSend[recvRank].resize(realSendSize);
630 for (
int idx = 0; idx < recvSize; ++idx)
632 if (0 != (*(recvMask+idx)))
634 tmpSend[recvRank](realSendSize) = globalLocalIndexGridSrcSendToServer[*(recvIndexSrc+idx)];
640 requests.push_back(MPI_Request());
641 MPI_Isend(recvMaskDst[recvRank], recvSize, MPI_UNSIGNED_CHAR, recvRank, 48, client->
intraComm, &requests.back());
643 status.resize(requests.size());
644 MPI_Waitall(requests.size(), &requests[0], &status[0]);
649 for (std::map<int,int>::const_iterator itSend = sendRankSizeMap.begin(); itSend != sendRankSizeMap.end(); ++itSend)
651 int recvRank = itSend->first;
652 int recvSize = itSend->second;
653 unsigned char* recvMask = sendMaskDst[recvRank];
657 int realRecvSize = 0;
658 for (
int idx = 0; idx < recvSize; ++idx)
660 if (0 != *(recvMask+idx))
665 recvTmp[recvRank].resize(realRecvSize);
667 for (
int idx = 0; idx < recvSize; ++idx)
669 if (0 != *(recvMask+idx))
671 recvTmp[recvRank][realRecvSize].first = globalLocalIndexGridDestSendToServer[recvIndexDst(idx)];
672 recvTmp[recvRank][realRecvSize].second = recvWeightDst(idx);
680 delete [] sendRankBuff;
681 delete [] recvRankBuff;
682 delete [] sendSizeBuff;
683 delete [] recvSizeBuff;
685 std::unordered_map<int, unsigned char* >::const_iterator itChar;
686 for (itChar = sendMaskDst.begin(); itChar != sendMaskDst.end(); ++itChar)
687 delete [] itChar->second;
688 for (itChar = recvMaskDst.begin(); itChar != recvMaskDst.end(); ++itChar)
689 delete [] itChar->second;
690 std::unordered_map<int, unsigned long* >::const_iterator itLong;
691 for (itLong = sendGlobalIndexSrc.begin(); itLong != sendGlobalIndexSrc.end(); ++itLong)
692 delete [] itLong->second;
693 for (itLong = recvGlobalIndexSrc.begin(); itLong != recvGlobalIndexSrc.end(); ++itLong)
694 delete [] itLong->second;
void checkAttributesOnClient()
MPI_Comm intraComm
Communicator of client group.
void checkAttributesOnClient()
Check attributes on client side (This name is still adequate???)
enum xios::transformation_type ETranformationType
////////////////////// Définitions ////////////////////// ///
for(int iDest=0;iDest< nDest;iDest++)
int clientSize
Size of client group.
static CAxis * createAxis()
GlobalLocalDataMap & getGlobalLocalDataSendToServer()
Return global local data mapping of client.
CTransformation< CAxis >::TransformationMapTypes TransMapTypes
void checkAttributesOnClient()
long long int Time
////////////////////// Déclarations ////////////////////// ///
CTransformation< CScalar >::TransformationMapTypes TransMapTypes
CTransformation< CDomain >::TransformationMapTypes TransMapTypes
A context can be both on client and on server side.
int clientRank
Rank of current client.
static CGrid * createGrid(CDomain *domain)
Instanciateurs Statiques ///.
Index distribution on client side.
static CTimer & get(std::string name)
This class bases on the knowledge of distribution on client side (decided by users) to calculate the ...
CDistribution::GlobalLocalMap GlobalLocalDataMap
static CScalar * createScalar()
static CContext * getCurrent(void)
Get current context.
CContextClient * client
Concrete contex client.
static CDomain * createDomain()