ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-11-11 16:19:16 +05:00
Code Issues Packages Projects Releases Wiki Activity

Restoring orignal compute + cleanup

Browse Source
This commit is contained in:
Yoann Audouin 2022-08-30 13:24:07 +02:00
parent 5d3c1425f8
commit 67ee393af6
6 changed files with 54 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/SMESH/SMESH_Algo.cxx
View File

@ -281,9 +281,6 @@ SMESH_Algo::GetUsedHypothesis(SMESH_Mesh & aMesh,
if ( _usedHypList == savedHyps )
savedHyps.swap( me->_usedHypList );
for(auto hyp:_usedHypList){
std::cout << hyp << std::endl;
}
return _usedHypList;
}

60
src/SMESH/SMESH_Gen.cxx
View File

@ -171,7 +171,7 @@ const std::function<void(int,
bool,
TopTools_IndexedMapOfShape *,
TSetOfInt*)>
parallel_compute([&] (int id,
compute_function([&] (int id,
SMESH_subMesh* sm,
SMESH_subMesh::compute_event event,
SMESH_subMesh *shapeSM,
@ -179,7 +179,7 @@ const std::function<void(int,
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 );
@ -188,6 +188,7 @@ const std::function<void(int,
sm->SetAllowedSubShapes( nullptr );
}
// TODO: Check if this is necessary
if ( aShapesId )
aShapesId->insert( sm->GetId() );
@ -221,9 +222,8 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
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;
@ -246,8 +246,9 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
// ===============================================
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();
@ -259,11 +260,10 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
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){
@ -280,7 +280,8 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
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");
@ -299,25 +300,40 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
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

2
src/SMESH/SMESH_Gen.hxx
View File

@ -187,8 +187,6 @@ private:
volatile bool _compute_canceled;
std::list< SMESH_subMesh* > _sm_current;
// TODO: Replace by number of thread
ctpl::thread_pool * _pool = nullptr; //thread pool for computation
};
#endif

7
src/SMESH/SMESH_Mesh.hxx
View File

@ -393,8 +393,15 @@ class SMESH_EXPORT SMESH_Mesh
int GetNbThreads(){return _NbThreads;};
void SetNbThreads(int nbThreads){_NbThreads=nbThreads;};
void InitPoolThreads(){_pool = new ctpl::thread_pool(_NbThreads);};
bool IsParallel(){return _NbThreads > 0;}
// Temporary folder used during parallel Computation
boost::filesystem::path tmp_folder;
// TODO: Replace by number of thread
ctpl::thread_pool * _pool = nullptr; //thread pool for computation
private:

38
src/SMESH/SMESH_subMesh.cxx
View File

@ -207,20 +207,6 @@ SMESH_Algo* SMESH_subMesh::GetAlgo() const
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
@ -1520,12 +1506,11 @@ bool SMESH_subMesh::ComputeStateEngine(compute_event event)
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 *****");
@ -1536,9 +1521,8 @@ bool SMESH_subMesh::ComputeStateEngine(compute_event event)
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;
@ -1594,6 +1578,7 @@ bool SMESH_subMesh::ComputeStateEngine(compute_event event)
}
else
{
// TODO: Do switch of compute here instead of within algo
ret = algo->Compute((*_father), shape);
}
// algo can set _computeError of submesh
@ -1756,9 +1741,8 @@ bool SMESH_subMesh::ComputeStateEngine(compute_event event)
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
@ -2194,10 +2178,8 @@ TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * /*theGen*/,
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
@ -2225,7 +2207,6 @@ TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * /*theGen*/,
}
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
@ -2237,7 +2218,6 @@ TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * /*theGen*/,
theSubComputed = false;
theSubs.push_back( subMesh );
}
_father->Unlock();
}
}

1
src/SMESHDS/SMESHDS_Mesh.cxx
View File

@ -1328,7 +1328,6 @@ SMESHDS_SubMesh * SMESHDS_Mesh::NewSubMesh(int Index)
if ( !SM )
{
SM = new SMESHDS_SubMesh(this, Index);
std::cout << "Adding " << Index << ':' <<SM<<std::endl;
mySubMeshHolder->Add( Index, SM );
}
return SM;