Terminate TBB deterministically before MATLAB unloads the MEX file

gtwrap/matlab_wrapper/templates.py

@@ -26,6 +26,16 @@ class WrapperTemplate:
             '''),
                                  prefix='  ')
 
+    tbb_headers = textwrap.dedent("""
+            #ifdef GTSAM_USE_TBB
+            #include <tbb/version.h>
+            #if TBB_INTERFACE_VERSION >= 12060
+            #include <tbb/global_control.h>
+            #define GTSAM_WRAP_TBB_FINALIZE 1
+            #endif
+            #endif
+        """)
+
     delete_all_objects = textwrap.dedent('''
             void _deleteAllObjects()
             {{
@@ -39,6 +49,16 @@ class WrapperTemplate:
                   "calling destructors, call \'clear all\' again if you plan to now recompile a wrap\\n"
                   "module, so that your recompiled module is used instead of the old one." << endl;
               std::cout.rdbuf(outbuf);
+            #ifdef GTSAM_WRAP_TBB_FINALIZE
+              // Terminate TBB worker threads deterministically before MATLAB unloads
+              // this MEX file. Otherwise the workers may still be winding down when
+              // the image is unmapped and touch freed code, which crashes on exit.
+              // See oneTBB issue #977. finalize() is idempotent, returns false rather
+              // than throwing if the scheduler is still referenced elsewhere, and TBB
+              // re-initializes transparently if the module is used again.
+              static tbb::task_scheduler_handle tbbHandle{{tbb::attach{{}}}};
+              tbb::finalize(tbbHandle, std::nothrow);
+            #endif
             }}
         ''')
 

gtwrap/matlab_wrapper/wrapper.py

@@ -1952,9 +1952,11 @@ def generate_wrapper(self, namespace):
         includes = textwrap.dedent("""\
             {wrapper_file_headers}
             {boost_headers}
+            {tbb_headers}
             {includes_list}
         """).format(wrapper_file_headers=self.wrapper_file_headers.strip(),
                     boost_headers=boost_headers,
+                    tbb_headers=WrapperTemplate.tbb_headers,
                     includes_list='\n'.join(map(str, includes_list)))
 
         preamble = self.generate_preamble()

tests/expected/matlab/class_wrapper.cpp

@@ -1,6 +1,15 @@
 #include <gtwrap/matlab.h>
 #include <map>
 
+
+#ifdef GTSAM_USE_TBB
+#include <tbb/version.h>
+#if TBB_INTERFACE_VERSION >= 12060
+#include <tbb/global_control.h>
+#define GTSAM_WRAP_TBB_FINALIZE 1
+#endif
+#endif
+
 #include <folder/path/to/Test.h>
 
 typedef Fun<double> FunDouble;
@@ -139,6 +148,16 @@ void _deleteAllObjects()
       "calling destructors, call 'clear all' again if you plan to now recompile a wrap\n"
       "module, so that your recompiled module is used instead of the old one." << endl;
   std::cout.rdbuf(outbuf);
+#ifdef GTSAM_WRAP_TBB_FINALIZE
+  // Terminate TBB worker threads deterministically before MATLAB unloads
+  // this MEX file. Otherwise the workers may still be winding down when
+  // the image is unmapped and touch freed code, which crashes on exit.
+  // See oneTBB issue #977. finalize() is idempotent, returns false rather
+  // than throwing if the scheduler is still referenced elsewhere, and TBB
+  // re-initializes transparently if the module is used again.
+  static tbb::task_scheduler_handle tbbHandle{tbb::attach{}};
+  tbb::finalize(tbbHandle, std::nothrow);
+#endif
 }
 
 void _class_RTTIRegister() {

tests/expected/matlab/enum_wrapper.cpp

@@ -2,6 +2,15 @@
 #include <map>
 
 
+#ifdef GTSAM_USE_TBB
+#include <tbb/version.h>
+#if TBB_INTERFACE_VERSION >= 12060
+#include <tbb/global_control.h>
+#define GTSAM_WRAP_TBB_FINALIZE 1
+#endif
+#endif
+
+
 
 typedef gtsam::Optimizer<gtsam::GaussNewtonParams> OptimizerGaussNewtonParams;
 
@@ -44,6 +53,16 @@ void _deleteAllObjects()
       "calling destructors, call 'clear all' again if you plan to now recompile a wrap\n"
       "module, so that your recompiled module is used instead of the old one." << endl;
   std::cout.rdbuf(outbuf);
+#ifdef GTSAM_WRAP_TBB_FINALIZE
+  // Terminate TBB worker threads deterministically before MATLAB unloads
+  // this MEX file. Otherwise the workers may still be winding down when
+  // the image is unmapped and touch freed code, which crashes on exit.
+  // See oneTBB issue #977. finalize() is idempotent, returns false rather
+  // than throwing if the scheduler is still referenced elsewhere, and TBB
+  // re-initializes transparently if the module is used again.
+  static tbb::task_scheduler_handle tbbHandle{tbb::attach{}};
+  tbb::finalize(tbbHandle, std::nothrow);
+#endif
 }
 
 void _enum_RTTIRegister() {

tests/expected/matlab/functions_wrapper.cpp

@@ -2,6 +2,15 @@
 #include <map>
 
 
+#ifdef GTSAM_USE_TBB
+#include <tbb/version.h>
+#if TBB_INTERFACE_VERSION >= 12060
+#include <tbb/global_control.h>
+#define GTSAM_WRAP_TBB_FINALIZE 1
+#endif
+#endif
+
+
 
 
 
@@ -20,6 +29,16 @@ void _deleteAllObjects()
       "calling destructors, call 'clear all' again if you plan to now recompile a wrap\n"
       "module, so that your recompiled module is used instead of the old one." << endl;
   std::cout.rdbuf(outbuf);
+#ifdef GTSAM_WRAP_TBB_FINALIZE
+  // Terminate TBB worker threads deterministically before MATLAB unloads
+  // this MEX file. Otherwise the workers may still be winding down when
+  // the image is unmapped and touch freed code, which crashes on exit.
+  // See oneTBB issue #977. finalize() is idempotent, returns false rather
+  // than throwing if the scheduler is still referenced elsewhere, and TBB
+  // re-initializes transparently if the module is used again.
+  static tbb::task_scheduler_handle tbbHandle{tbb::attach{}};
+  tbb::finalize(tbbHandle, std::nothrow);
+#endif
 }
 
 void _functions_RTTIRegister() {

tests/expected/matlab/geometry_wrapper.cpp

@@ -5,6 +5,15 @@
 #include <boost/archive/text_oarchive.hpp>
 #include <boost/serialization/export.hpp>
 
+
+#ifdef GTSAM_USE_TBB
+#include <tbb/version.h>
+#if TBB_INTERFACE_VERSION >= 12060
+#include <tbb/global_control.h>
+#define GTSAM_WRAP_TBB_FINALIZE 1
+#endif
+#endif
+
 #include <gtsam/geometry/Point2.h>
 #include <gtsam/geometry/Point3.h>
 
@@ -43,6 +52,16 @@ void _deleteAllObjects()
       "calling destructors, call 'clear all' again if you plan to now recompile a wrap\n"
       "module, so that your recompiled module is used instead of the old one." << endl;
   std::cout.rdbuf(outbuf);
+#ifdef GTSAM_WRAP_TBB_FINALIZE
+  // Terminate TBB worker threads deterministically before MATLAB unloads
+  // this MEX file. Otherwise the workers may still be winding down when
+  // the image is unmapped and touch freed code, which crashes on exit.
+  // See oneTBB issue #977. finalize() is idempotent, returns false rather
+  // than throwing if the scheduler is still referenced elsewhere, and TBB
+  // re-initializes transparently if the module is used again.
+  static tbb::task_scheduler_handle tbbHandle{tbb::attach{}};
+  tbb::finalize(tbbHandle, std::nothrow);
+#endif
 }
 
 void _geometry_RTTIRegister() {

tests/expected/matlab/inheritance_wrapper.cpp

@@ -2,6 +2,15 @@
 #include <map>
 
 
+#ifdef GTSAM_USE_TBB
+#include <tbb/version.h>
+#if TBB_INTERFACE_VERSION >= 12060
+#include <tbb/global_control.h>
+#define GTSAM_WRAP_TBB_FINALIZE 1
+#endif
+#endif
+
+
 
 typedef MyTemplate<gtsam::Point2> MyTemplatePoint2;
 typedef MyTemplate<gtsam::Matrix> MyTemplateMatrix;
@@ -87,6 +96,16 @@ void _deleteAllObjects()
       "calling destructors, call 'clear all' again if you plan to now recompile a wrap\n"
       "module, so that your recompiled module is used instead of the old one." << endl;
   std::cout.rdbuf(outbuf);
+#ifdef GTSAM_WRAP_TBB_FINALIZE
+  // Terminate TBB worker threads deterministically before MATLAB unloads
+  // this MEX file. Otherwise the workers may still be winding down when
+  // the image is unmapped and touch freed code, which crashes on exit.
+  // See oneTBB issue #977. finalize() is idempotent, returns false rather
+  // than throwing if the scheduler is still referenced elsewhere, and TBB
+  // re-initializes transparently if the module is used again.
+  static tbb::task_scheduler_handle tbbHandle{tbb::attach{}};
+  tbb::finalize(tbbHandle, std::nothrow);
+#endif
 }
 
 void _inheritance_RTTIRegister() {

tests/expected/matlab/multiple_files_wrapper.cpp

@@ -2,6 +2,15 @@
 #include <map>
 
 
+#ifdef GTSAM_USE_TBB
+#include <tbb/version.h>
+#if TBB_INTERFACE_VERSION >= 12060
+#include <tbb/global_control.h>
+#define GTSAM_WRAP_TBB_FINALIZE 1
+#endif
+#endif
+
+
 
 
 
@@ -44,6 +53,16 @@ void _deleteAllObjects()
       "calling destructors, call 'clear all' again if you plan to now recompile a wrap\n"
       "module, so that your recompiled module is used instead of the old one." << endl;
   std::cout.rdbuf(outbuf);
+#ifdef GTSAM_WRAP_TBB_FINALIZE
+  // Terminate TBB worker threads deterministically before MATLAB unloads
+  // this MEX file. Otherwise the workers may still be winding down when
+  // the image is unmapped and touch freed code, which crashes on exit.
+  // See oneTBB issue #977. finalize() is idempotent, returns false rather
+  // than throwing if the scheduler is still referenced elsewhere, and TBB
+  // re-initializes transparently if the module is used again.
+  static tbb::task_scheduler_handle tbbHandle{tbb::attach{}};
+  tbb::finalize(tbbHandle, std::nothrow);
+#endif
 }
 
 void _multiple_files_RTTIRegister() {

tests/expected/matlab/namespaces_wrapper.cpp

@@ -1,6 +1,15 @@
 #include <gtwrap/matlab.h>
 #include <map>
 
+
+#ifdef GTSAM_USE_TBB
+#include <tbb/version.h>
+#if TBB_INTERFACE_VERSION >= 12060
+#include <tbb/global_control.h>
+#define GTSAM_WRAP_TBB_FINALIZE 1
+#endif
+#endif
+
 #include <gtsam/nonlinear/Values.h>
 #include <path/to/ns1.h>
 #include <path/to/ns1/ClassB.h>
@@ -81,6 +90,16 @@ void _deleteAllObjects()
       "calling destructors, call 'clear all' again if you plan to now recompile a wrap\n"
       "module, so that your recompiled module is used instead of the old one." << endl;
   std::cout.rdbuf(outbuf);
+#ifdef GTSAM_WRAP_TBB_FINALIZE
+  // Terminate TBB worker threads deterministically before MATLAB unloads
+  // this MEX file. Otherwise the workers may still be winding down when
+  // the image is unmapped and touch freed code, which crashes on exit.
+  // See oneTBB issue #977. finalize() is idempotent, returns false rather
+  // than throwing if the scheduler is still referenced elsewhere, and TBB
+  // re-initializes transparently if the module is used again.
+  static tbb::task_scheduler_handle tbbHandle{tbb::attach{}};
+  tbb::finalize(tbbHandle, std::nothrow);
+#endif
 }
 
 void _namespaces_RTTIRegister() {

tests/expected/matlab/special_cases_wrapper.cpp

@@ -1,6 +1,15 @@
 #include <gtwrap/matlab.h>
 #include <map>
 
+
+#ifdef GTSAM_USE_TBB
+#include <tbb/version.h>
+#if TBB_INTERFACE_VERSION >= 12060
+#include <tbb/global_control.h>
+#define GTSAM_WRAP_TBB_FINALIZE 1
+#endif
+#endif
+
 #include <gtsam/geometry/Cal3Bundler.h>
 
 typedef gtsam::PinholeCamera<gtsam::Cal3Bundler> PinholeCameraCal3Bundler;
@@ -53,6 +62,16 @@ void _deleteAllObjects()
       "calling destructors, call 'clear all' again if you plan to now recompile a wrap\n"
       "module, so that your recompiled module is used instead of the old one." << endl;
   std::cout.rdbuf(outbuf);
+#ifdef GTSAM_WRAP_TBB_FINALIZE
+  // Terminate TBB worker threads deterministically before MATLAB unloads
+  // this MEX file. Otherwise the workers may still be winding down when
+  // the image is unmapped and touch freed code, which crashes on exit.
+  // See oneTBB issue #977. finalize() is idempotent, returns false rather
+  // than throwing if the scheduler is still referenced elsewhere, and TBB
+  // re-initializes transparently if the module is used again.
+  static tbb::task_scheduler_handle tbbHandle{tbb::attach{}};
+  tbb::finalize(tbbHandle, std::nothrow);
+#endif
 }
 
 void _special_cases_RTTIRegister() {

tests/expected/matlab/template_wrapper.cpp

@@ -2,6 +2,15 @@
 #include <map>
 
 
+#ifdef GTSAM_USE_TBB
+#include <tbb/version.h>
+#if TBB_INTERFACE_VERSION >= 12060
+#include <tbb/global_control.h>
+#define GTSAM_WRAP_TBB_FINALIZE 1
+#endif
+#endif
+
+
 
 typedef ScopedTemplate<Result> ScopedTemplateResult;
 
@@ -36,6 +45,16 @@ void _deleteAllObjects()
       "calling destructors, call 'clear all' again if you plan to now recompile a wrap\n"
       "module, so that your recompiled module is used instead of the old one." << endl;
   std::cout.rdbuf(outbuf);
+#ifdef GTSAM_WRAP_TBB_FINALIZE
+  // Terminate TBB worker threads deterministically before MATLAB unloads
+  // this MEX file. Otherwise the workers may still be winding down when
+  // the image is unmapped and touch freed code, which crashes on exit.
+  // See oneTBB issue #977. finalize() is idempotent, returns false rather
+  // than throwing if the scheduler is still referenced elsewhere, and TBB
+  // re-initializes transparently if the module is used again.
+  static tbb::task_scheduler_handle tbbHandle{tbb::attach{}};
+  tbb::finalize(tbbHandle, std::nothrow);
+#endif
 }
 
 void _template_RTTIRegister() {