Replacing ctpl by boost::thread_pool

[modules/smesh.git] / src / SMESH / SMESH_Gen.cxx

diff --git a/src/SMESH/SMESH_Gen.cxx b/src/SMESH/SMESH_Gen.cxx
index c27f5ec025fa667cde59716d526947746574438f..45a0049b45c474f3449e37da3c31261c340f93b4 100644 (file)
--- a/src/SMESH/SMESH_Gen.cxx
+++ b/src/SMESH/SMESH_Gen.cxx
@@ -48,6 +48,8 @@
 #include <TopoDS_Iterator.hxx>
 
 #include "memoire.h"
+#include <chrono>
+#include <functional>
 
 #ifdef WIN32
   #include <windows.h>
@@ -57,6 +59,7 @@
 
 using namespace std;
 #include <boost/filesystem.hpp>
+#include <boost/asio.hpp>
 namespace fs = boost::filesystem;
 
 // Environment variable separator
@@ -246,7 +249,9 @@ bool SMESH_Gen::Compute(SMESH_Mesh &                aMesh,
     // ===============================================
 
     TopAbs_ShapeEnum previousShapeType = TopAbs_VERTEX;
-    std::vector<std::future<void>> pending;
+    int nbThreads = aMesh.GetNbThreads();
+    auto begin = std::chrono::high_resolution_clock::now();
+
 
     smIt = shapeSM->getDependsOnIterator(includeSelf, !complexShapeFirst);
     while ( smIt->more() )
@@ -258,13 +263,15 @@ bool SMESH_Gen::Compute(SMESH_Mesh &                aMesh,
       const TopAbs_ShapeEnum shapeType = shape.ShapeType();
       if ( !aMesh.HasShapeToMesh() && shapeType == TopAbs_VERTEX )
         continue;
-
+      if(shapeType==TopAbs_FACE||shapeType==TopAbs_EDGE)
+        aMesh.SetNbThreads(0);
+      else
+        aMesh.SetNbThreads(nbThreads);
       //DEBUG std::cout << "Shape Type" << shapeType << " previous" << previousShapeType << std::endl;
-      if (aMesh.IsParallel() && shapeType != previousShapeType) {
+      if ((aMesh.IsParallel()||nbThreads!=0) && shapeType != previousShapeType) {
         // Waiting for all threads for the previous type to end
-        for(auto &it: pending){
-          it.wait();
-        }
+        aMesh.wait();
+
         std::string file_name;
         switch(previousShapeType){
           case TopAbs_FACE:
@@ -276,6 +283,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh &                aMesh,
           case TopAbs_VERTEX:
             file_name = "Mesh0D.med";
             break;
+          case TopAbs_SOLID:
           default:
             file_name = "";
             break;
@@ -289,7 +297,6 @@ bool SMESH_Gen::Compute(SMESH_Mesh &                aMesh,
         }
         //Resetting threaded pool info
         previousShapeType = shapeType;
-        pending.clear();
       }
 
       // check for preview dimension limitations
@@ -302,14 +309,20 @@ bool SMESH_Gen::Compute(SMESH_Mesh &                aMesh,
       }
       if(aMesh.IsParallel())
       {
-        pending.push_back(aMesh._pool->push(compute_function, smToCompute, computeEvent,
-                             shapeSM, aShapeOnly, allowedSubShapes,
-                             aShapesId));
+        std::cout << "Submitting thread function " << std::endl;
+        boost::asio::post(*(aMesh._pool), [](){std::cerr<< "In Here" << std::endl;});
+        boost::asio::post(*(aMesh._pool), std::bind(compute_function, 1, smToCompute, computeEvent,
+                          shapeSM, aShapeOnly, allowedSubShapes,
+                          aShapesId));
       } else {
+        auto begin2 = std::chrono::high_resolution_clock::now();
+
         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;
@@ -321,13 +334,18 @@ bool SMESH_Gen::Compute(SMESH_Mesh &                aMesh,
     // 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();
+      aMesh.wait();
     }
 
     aMesh.GetMeshDS()->Modified();
+    auto end = std::chrono::high_resolution_clock::now();
+    auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin);
+    std::cout << "Time for All: " << elapsed.count()*1e-9 << std::endl;
+
+    // Pool of thread for computation
+    if(aMesh.IsParallel())
+      aMesh.DeletePoolThreads();
+
     return ret;
   }
   else
@@ -338,7 +356,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh &                aMesh,
     // the most complex shapes and collect sub-meshes with algos that
     // DO support sub-meshes
     // ================================================================
-
+    auto begin = std::chrono::high_resolution_clock::now();
     list< SMESH_subMesh* > smWithAlgoSupportingSubmeshes[4]; // for each dim
 
     // map to sort sm with same dim algos according to dim of
@@ -534,7 +552,12 @@ bool SMESH_Gen::Compute(SMESH_Mesh &                aMesh,
             continue;
           sm->SetAllowedSubShapes( fillAllowed( shapeSM, aShapeOnly, allowedSubShapes ));
           setCurrentSubMesh( sm );
+          auto begin = std::chrono::high_resolution_clock::now();
           sm->ComputeStateEngine( computeEvent );
+          auto end = std::chrono::high_resolution_clock::now();
+          auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin);
+          std::cout << "Time for seq:alldim:compute: " << elapsed.count()*1e-9 << std::endl;
+
           setCurrentSubMesh( NULL );
           sm->SetAllowedSubShapes( nullptr );
           if ( aShapesId )
@@ -547,6 +570,10 @@ bool SMESH_Gen::Compute(SMESH_Mesh &                aMesh,
     // mesh the rest sub-shapes starting from vertices
     // -----------------------------------------------
     ret = Compute( aMesh, aShape, aFlags | UPWARD, aDim, aShapesId, allowedSubShapes );
+    auto end = std::chrono::high_resolution_clock::now();
+    auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin);
+    std::cout << "Time for All: " << elapsed.count()*1e-9 << std::endl;
+
   }
 
   MEMOSTAT;