bool,
TopTools_IndexedMapOfShape *,
TSetOfInt*)>
- parallel_compute([&] (int id,
+ compute_function([&] (int id,
SMESH_subMesh* sm,
SMESH_subMesh::compute_event event,
SMESH_subMesh *shapeSM,
TopTools_IndexedMapOfShape *allowedSubShapes,
TSetOfInt* aShapesId) -> void
{
- if (sm->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE)
+ if (sm->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE)
{
sm->SetAllowedSubShapes( fillAllowed( shapeSM, aShapeOnly, allowedSubShapes ));
//setCurrentSubMesh( sm );
sm->SetAllowedSubShapes( nullptr );
}
+ // TODO: Check if this is necessary
if ( aShapesId )
aShapesId->insert( sm->GetId() );
const int globalAlgoDim = 100;
// Pool of thread for computation
- if (!_pool){
- _pool = new ctpl::thread_pool(2);
- }
+ if(aMesh.IsParallel())
+ aMesh.InitPoolThreads();
SMESH_subMeshIteratorPtr smIt;
// ===============================================
TopAbs_ShapeEnum previousShapeType = TopAbs_VERTEX;
- smIt = shapeSM->getDependsOnIterator(includeSelf, !complexShapeFirst);
std::vector<std::future<void>> pending;
+
+ smIt = shapeSM->getDependsOnIterator(includeSelf, !complexShapeFirst);
while ( smIt->more() )
{
SMESH_subMesh* smToCompute = smIt->next();
continue;
//DEBUG std::cout << "Shape Type" << shapeType << " previous" << previousShapeType << std::endl;
- if (shapeType != previousShapeType) {
- // Waiting for all thread for the previous type to end
- for(auto it =std::begin(pending); it != std::end(pending); ++it){
- std::cout << "Waiting" << std::endl;
- it->wait();
+ if (aMesh.IsParallel() && shapeType != previousShapeType) {
+ // Waiting for all threads for the previous type to end
+ for(auto &it: pending){
+ it.wait();
}
std::string file_name;
switch(previousShapeType){
file_name = "";
break;
}
- if(file_name != ""){
+ if(file_name != "")
+ {
fs::path mesh_file = fs::path(aMesh.tmp_folder) / fs::path(file_name);
// TODO: change mesh name
export_mesh(mesh_file.string(), aMesh, "Maillage_1");
smToCompute->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
continue;
}
- pending.push_back(_pool->push(parallel_compute, smToCompute, computeEvent,
- shapeSM, aShapeOnly, allowedSubShapes,
- aShapesId));
- //DEBUG std::cout << "Launched " << smToCompute << " shape type " << shapeType << std::endl;
-
+ if(aMesh.IsParallel())
+ {
+ pending.push_back(aMesh._pool->push(compute_function, smToCompute, computeEvent,
+ shapeSM, aShapeOnly, allowedSubShapes,
+ aShapesId));
+ } else {
+ compute_function(1 ,smToCompute, computeEvent,
+ shapeSM, aShapeOnly, allowedSubShapes,
+ aShapesId);
+ if (smToCompute->GetComputeState() == SMESH_subMesh::FAILED_TO_COMPUTE &&
+ ( shapeType != TopAbs_EDGE || !SMESH_Algo::isDegenerated( TopoDS::Edge( shape ))))
+ ret = false;
+ else if ( aShapesId )
+ aShapesId->insert( smToCompute->GetId() );
+ }
}
- for(auto it =std::begin(pending); it != std::end(pending); ++it){
- it->wait();
+ // TODO: Check error handling in parallel mode
+ if(aMesh.IsParallel()){
+ // Waiting for the thread for Solids to finish
+ for(auto &it:pending){
+ it.wait();
+ }
+ pending.clear();
}
- pending.clear();
- //aMesh.GetMeshDS()->Modified();
+
+ aMesh.GetMeshDS()->Modified();
return ret;
}
else
{
// ================================================================
- // Apply algos that do NOT require discreteized boundaries
+ // Apply algos that do NOT require discretized boundaries
// ("all-dimensional") and do NOT support sub-meshes, starting from
// the most complex shapes and collect sub-meshes with algos that
// DO support sub-meshes
return _algo;
}
-//================================================================================
-/*!
- * \brief Returns a current algorithm
- */
-//================================================================================
-
-SMESH_Algo* SMESH_subMesh::CopyAlgo() const
-{
- //SMESH_Algo* algo = (SMESH_Algo*) new StdMeshers_Regular_1D(666, _father->GetGent());
- SMESH_Algo* algo;
-
- return algo;
-}
-
//================================================================================
/*!
* \brief Allow algo->Compute() if a sub-shape of lower dim is meshed but
case COMPUTE_SUBMESH:
{
algo = GetAlgo();
- SMESH_Algo* algo2 = CopyAlgo();
- cout << "Algo2" << algo2;
ASSERT(algo);
- //_father->Lock();
- //ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
- //_father->Unlock();
+ if(!_father->IsParallel())
+ ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
+ else
+ ret = true;
if (!ret)
{
MESSAGE("***** verify compute state *****");
TopoDS_Shape shape = _subShape;
algo->SubMeshesToCompute().assign( 1, this );
// check submeshes needed
- // Forcing to false for parallel run
- // TODO: Remove forced false
- if (_father->HasShapeToMesh() && false) {
+ // In parallel there would be no submesh to check
+ if (_father->HasShapeToMesh() && !_father->IsParallel()) {
bool subComputed = false, subFailed = false;
if (!algo->OnlyUnaryInput()) {
// --- commented for bos#22320 to compute all sub-shapes at once if possible;
}
else
{
+ // TODO: Do switch of compute here instead of within algo
ret = algo->Compute((*_father), shape);
}
// algo can set _computeError of submesh
updateDependantsState( SUBMESH_COMPUTED );
}
// let algo clear its data gathered while algo->Compute()
- //_father->Lock();
- //algo->CheckHypothesis((*_father), _subShape, hyp_status);
- //_father->Unlock();
+ if(!_father->IsParallel())
+ algo->CheckHypothesis((*_father), _subShape, hyp_status);
}
break;
case COMPUTE_CANCELED: // nothing to do
return _subShape;
const bool skipAuxHyps = false;
- _father->Lock();
list<const SMESHDS_Hypothesis*> usedHyps =
theAlgo->GetUsedHypothesis( *_father, _subShape, skipAuxHyps ); // copy
- _father->Lock();
std::list < TopoDS_Shape > assiShapes = theAlgo->GetAssignedShapes();
// put in a compound all shapes with the same hypothesis assigned
}
else if ( subMesh->GetComputeState() == READY_TO_COMPUTE )
{
- _father->Lock();
SMESH_Algo* anAlgo = subMesh->GetAlgo();
if (( anAlgo->IsSameName( *theAlgo )) && // same algo
( anAlgo->GetUsedHypothesis( *_father, S, skipAuxHyps ) == usedHyps ) && // same hyps
theSubComputed = false;
theSubs.push_back( subMesh );
}
- _father->Unlock();
}
}
