Restoring orignal compute + cleanup

diff --git a/src/SMESH/SMESH_Algo.cxx b/src/SMESH/SMESH_Algo.cxx
index ed102fae474483d22f0c98591d57483da77ef7b3..4b5aa6f37868c75b72aaa82c77b5ea2c29a0c60b 100644 (file)
--- a/src/SMESH/SMESH_Algo.cxx
+++ b/src/SMESH/SMESH_Algo.cxx
@@ -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;
 }
 

diff --git a/src/SMESH/SMESH_Gen.cxx b/src/SMESH/SMESH_Gen.cxx
index 2d77c9966e7ec9f28313dc8fb12cba64ddcfe328..c48e8d8414ad1ab77a540fbfe427e798a7fd648b 100644 (file)
--- a/src/SMESH/SMESH_Gen.cxx
+++ b/src/SMESH/SMESH_Gen.cxx
@@ -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

diff --git a/src/SMESH/SMESH_Gen.hxx b/src/SMESH/SMESH_Gen.hxx
index 0ce6755462e867d32f904487df1c438ab96d7133..02f70250d9a59112fb4e23409b0918e72e4fabf5 100644 (file)
--- a/src/SMESH/SMESH_Gen.hxx
+++ b/src/SMESH/SMESH_Gen.hxx
@@ -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

diff --git a/src/SMESH/SMESH_Mesh.hxx b/src/SMESH/SMESH_Mesh.hxx
index 2c14bbbc5756c7322f1f43ab8b2a609161ccf655..b3823828d19e52ab0d195b9ffcb5bd2a7d587a81 100644 (file)
--- a/src/SMESH/SMESH_Mesh.hxx
+++ b/src/SMESH/SMESH_Mesh.hxx
@@ -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:
 

diff --git a/src/SMESH/SMESH_subMesh.cxx b/src/SMESH/SMESH_subMesh.cxx
index a9ea0adeb31a82ac1722eaa8062daabc421c7338..3790ffdde1ef499dd2062f4e697aca279ee97333 100644 (file)
--- a/src/SMESH/SMESH_subMesh.cxx
+++ b/src/SMESH/SMESH_subMesh.cxx
@@ -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();
     }
   }
 

diff --git a/src/SMESHDS/SMESHDS_Mesh.cxx b/src/SMESHDS/SMESHDS_Mesh.cxx
index 7bd48aa11a47bf426ae892366ab4dec4edd1940f..a49408461b40716b73ac87de5cfd0d57b3ff6218 100644 (file)
--- a/src/SMESHDS/SMESHDS_Mesh.cxx
+++ b/src/SMESHDS/SMESHDS_Mesh.cxx
@@ -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;