From 62161e9201293a0ba766c6cfa84202330460764a Mon Sep 17 00:00:00 2001 From: Roman Beranek Date: Thu, 3 Jun 2021 22:04:34 +0200 Subject: [PATCH] drop deprecated TBB components Quite some time ago, many of the TBB components were deprecated in favor of their near-equivalents in the STL or, in the case of task_scheduler_init, were broken up and reconstituted under a less ad-hoc logic. Every time a header file marked deprecated gets included, a rather loud warning is emitted, which leads to a complete TBB's domination over the stderr stream during build time, making it harder to notice _legitimate_ warnings. Instead of merely muting the output with TBB_SUPPRESS_DEPRECATED_MESSAGES, perform a genuine migration away from the deprecated components with the added benefit of achieving a source compatibility with oneTBB, the successor to TBB which has dropped the deprecated API for good. What got replaced for what? | Deprecated | Replacement | | ------------------------------------- | --------------------------------------------- | | `tbb::atomic` | `std::atomic` | | `tbb::mutex` | `std::mutex` | | `tbb::mutex::scoped_lock` | `std::scoped_lock` | | `tbb::mutex::scoped_lock` (empty) | `std::unique_lock` (deferred) | | `tbb::task_scheduler_init` | `tbb::global_control` | | `tbb::this_thread` | `std::this_thread` | Signed-off-by: Roman Beranek --- src/libslic3r/Execution/ExecutionTBB.hpp | 5 +-- src/libslic3r/Print.cpp | 4 +-- src/libslic3r/PrintApply.cpp | 2 +- src/libslic3r/PrintBase.cpp | 2 +- src/libslic3r/PrintBase.hpp | 40 ++++++++++----------- src/libslic3r/PrintObject.cpp | 1 - src/libslic3r/SLA/SupportTree.cpp | 3 -- src/libslic3r/SLAPrint.cpp | 10 +++--- src/libslic3r/SupportMaterial.cpp | 1 - src/libslic3r/Thread.cpp | 12 +++---- src/libslic3r/pchheader.hpp | 3 -- src/libslic3r/utils.cpp | 6 ++-- src/slic3r/GUI/BackgroundSlicingProcess.cpp | 6 ++-- src/slic3r/GUI/InstanceCheck.hpp | 2 +- src/slic3r/GUI/Mouse3DController.cpp | 38 ++++++++++---------- src/slic3r/GUI/Mouse3DController.hpp | 10 +++--- src/slic3r/GUI/RemovableDriveManager.cpp | 24 ++++++------- src/slic3r/GUI/RemovableDriveManager.hpp | 6 ++-- 18 files changed, 80 insertions(+), 95 deletions(-) Index: PrusaSlicer-version_2.3.3/src/libslic3r/Print.cpp =================================================================== --- PrusaSlicer-version_2.3.3.orig/src/libslic3r/Print.cpp +++ PrusaSlicer-version_2.3.3/src/libslic3r/Print.cpp @@ -36,7 +36,7 @@ template class PrintStatestate_mutex()); + std::scoped_lock lock(this->state_mutex()); // The following call should stop background processing if it is running. this->invalidate_all_steps(); for (PrintObject *object : m_objects) @@ -262,7 +262,7 @@ bool Print::is_step_done(PrintObjectStep { if (m_objects.empty()) return false; - tbb::mutex::scoped_lock lock(this->state_mutex()); + std::scoped_lock lock(this->state_mutex()); for (const PrintObject *object : m_objects) if (! object->is_step_done_unguarded(step)) return false; @@ -617,7 +617,7 @@ Print::ApplyStatus Print::apply(const Mo update_apply_status(false); // Grab the lock for the Print / PrintObject milestones. - tbb::mutex::scoped_lock lock(this->state_mutex()); + std::scoped_lock lock(this->state_mutex()); // The following call may stop the background processing. if (! print_diff.empty()) Index: PrusaSlicer-version_2.3.3/src/libslic3r/PrintBase.cpp =================================================================== --- PrusaSlicer-version_2.3.3.orig/src/libslic3r/PrintBase.cpp +++ PrusaSlicer-version_2.3.3/src/libslic3r/PrintBase.cpp @@ -97,7 +97,7 @@ void PrintBase::status_update_warnings(O printf("%s warning: %s\n", (object_id == this->id()) ? "print" : "print object", message.c_str()); } -tbb::mutex& PrintObjectBase::state_mutex(PrintBase *print) +std::mutex& PrintObjectBase::state_mutex(PrintBase *print) { return print->state_mutex(); } Index: PrusaSlicer-version_2.3.3/src/libslic3r/PrintBase.hpp =================================================================== --- PrusaSlicer-version_2.3.3.orig/src/libslic3r/PrintBase.hpp +++ PrusaSlicer-version_2.3.3/src/libslic3r/PrintBase.hpp @@ -6,12 +6,8 @@ #include #include #include - -// tbb/mutex.h includes Windows, which in turn defines min/max macros. Convince Windows.h to not define these min/max macros. -#ifndef NOMINMAX - #define NOMINMAX -#endif -#include "tbb/mutex.h" +#include +#include #include "ObjectID.hpp" #include "Model.hpp" @@ -84,23 +80,23 @@ class PrintState : public PrintStateBase public: PrintState() {} - StateWithTimeStamp state_with_timestamp(StepType step, tbb::mutex &mtx) const { - tbb::mutex::scoped_lock lock(mtx); + StateWithTimeStamp state_with_timestamp(StepType step, std::mutex &mtx) const { + std::scoped_lock lock(mtx); StateWithTimeStamp state = m_state[step]; return state; } - StateWithWarnings state_with_warnings(StepType step, tbb::mutex &mtx) const { - tbb::mutex::scoped_lock lock(mtx); + StateWithWarnings state_with_warnings(StepType step, std::mutex &mtx) const { + std::scoped_lock lock(mtx); StateWithWarnings state = m_state[step]; return state; } - bool is_started(StepType step, tbb::mutex &mtx) const { + bool is_started(StepType step, std::mutex &mtx) const { return this->state_with_timestamp(step, mtx).state == STARTED; } - bool is_done(StepType step, tbb::mutex &mtx) const { + bool is_done(StepType step, std::mutex &mtx) const { return this->state_with_timestamp(step, mtx).state == DONE; } @@ -121,8 +117,8 @@ public: // This is necessary to block until the Print::apply() updates its state, which may // influence the processing step being entered. template - bool set_started(StepType step, tbb::mutex &mtx, ThrowIfCanceled throw_if_canceled) { - tbb::mutex::scoped_lock lock(mtx); + bool set_started(StepType step, std::mutex &mtx, ThrowIfCanceled throw_if_canceled) { + std::scoped_lock lock(mtx); // If canceled, throw before changing the step state. throw_if_canceled(); #ifndef NDEBUG @@ -154,8 +150,8 @@ public: // Timestamp when this stepentered the DONE state. // bool indicates whether the UI has to update the slicing warnings of this step or not. template - std::pair set_done(StepType step, tbb::mutex &mtx, ThrowIfCanceled throw_if_canceled) { - tbb::mutex::scoped_lock lock(mtx); + std::pair set_done(StepType step, std::mutex &mtx, ThrowIfCanceled throw_if_canceled) { + std::scoped_lock lock(mtx); // If canceled, throw before changing the step state. throw_if_canceled(); assert(m_state[step].state == STARTED); @@ -266,9 +262,9 @@ public: // Return value: // Current milestone (StepType). // bool indicates whether the UI has to be updated or not. - std::pair active_step_add_warning(PrintStateBase::WarningLevel warning_level, const std::string &message, int message_id, tbb::mutex &mtx) + std::pair active_step_add_warning(PrintStateBase::WarningLevel warning_level, const std::string &message, int message_id, std::mutex &mtx) { - tbb::mutex::scoped_lock lock(mtx); + std::scoped_lock lock(mtx); assert(m_step_active != -1); StateWithWarnings &state = m_state[m_step_active]; assert(state.state == STARTED); @@ -314,7 +310,7 @@ protected: PrintObjectBase(ModelObject *model_object) : m_model_object(model_object) {} virtual ~PrintObjectBase() {} // Declared here to allow access from PrintBase through friendship. - static tbb::mutex& state_mutex(PrintBase *print); + static std::mutex& state_mutex(PrintBase *print); static std::function cancel_callback(PrintBase *print); // Notify UI about a new warning of a milestone "step" on this PrintObjectBase. // The UI will be notified by calling a status callback registered on print. @@ -461,7 +457,7 @@ protected: friend class PrintObjectBase; friend class BackgroundSlicingProcess; - tbb::mutex& state_mutex() const { return m_state_mutex; } + std::mutex& state_mutex() const { return m_state_mutex; } std::function cancel_callback() { return m_cancel_callback; } void call_cancel_callback() { m_cancel_callback(); } // Notify UI about a new warning of a milestone "step" on this PrintBase. @@ -486,7 +482,7 @@ protected: status_callback_type m_status_callback; private: - tbb::atomic m_cancel_status; + std::atomic m_cancel_status; // Callback to be evoked to stop the background processing before a state is updated. cancel_callback_type m_cancel_callback = [](){}; @@ -494,7 +490,7 @@ private: // Mutex used for synchronization of the worker thread with the UI thread: // The mutex will be used to guard the worker thread against entering a stage // while the data influencing the stage is modified. - mutable tbb::mutex m_state_mutex; + mutable std::mutex m_state_mutex; }; template Index: PrusaSlicer-version_2.3.3/src/libslic3r/PrintObject.cpp =================================================================== --- PrusaSlicer-version_2.3.3.orig/src/libslic3r/PrintObject.cpp +++ PrusaSlicer-version_2.3.3/src/libslic3r/PrintObject.cpp @@ -19,7 +19,6 @@ #include #include -#include #include Index: PrusaSlicer-version_2.3.3/src/libslic3r/SLA/SupportTree.cpp =================================================================== --- PrusaSlicer-version_2.3.3.orig/src/libslic3r/SLA/SupportTree.cpp +++ PrusaSlicer-version_2.3.3/src/libslic3r/SLA/SupportTree.cpp @@ -16,9 +16,6 @@ #include #include #include -#include -#include -#include #include //! macro used to mark string used at localization, Index: PrusaSlicer-version_2.3.3/src/libslic3r/SLAPrint.cpp =================================================================== --- PrusaSlicer-version_2.3.3.orig/src/libslic3r/SLAPrint.cpp +++ PrusaSlicer-version_2.3.3/src/libslic3r/SLAPrint.cpp @@ -19,8 +19,6 @@ #include #endif -//#include //#include "tbb/mutex.h" - #include "I18N.hpp" //! macro used to mark string used at localization, @@ -118,7 +116,7 @@ bool validate_pad(const TriangleMesh &pa void SLAPrint::clear() { - tbb::mutex::scoped_lock lock(this->state_mutex()); + std::scoped_lock lock(this->state_mutex()); // The following call should stop background processing if it is running. this->invalidate_all_steps(); for (SLAPrintObject *object : m_objects) @@ -212,7 +210,7 @@ SLAPrint::ApplyStatus SLAPrint::apply(co update_apply_status(false); // Grab the lock for the Print / PrintObject milestones. - tbb::mutex::scoped_lock lock(this->state_mutex()); + std::scoped_lock lock(this->state_mutex()); // The following call may stop the background processing. bool invalidate_all_model_objects = false; @@ -514,7 +512,7 @@ SLAPrint::ApplyStatus SLAPrint::apply(co void SLAPrint::set_task(const TaskParams ¶ms) { // Grab the lock for the Print / PrintObject milestones. - tbb::mutex::scoped_lock lock(this->state_mutex()); + std::scoped_lock lock(this->state_mutex()); int n_object_steps = int(params.to_object_step) + 1; if (n_object_steps == 0) @@ -884,7 +882,7 @@ bool SLAPrint::is_step_done(SLAPrintObje { if (m_objects.empty()) return false; - tbb::mutex::scoped_lock lock(this->state_mutex()); + std::scoped_lock lock(this->state_mutex()); for (const SLAPrintObject *object : m_objects) if (! object->is_step_done_unguarded(step)) return false; Index: PrusaSlicer-version_2.3.3/src/libslic3r/SupportMaterial.cpp =================================================================== --- PrusaSlicer-version_2.3.3.orig/src/libslic3r/SupportMaterial.cpp +++ PrusaSlicer-version_2.3.3/src/libslic3r/SupportMaterial.cpp @@ -12,7 +12,6 @@ #include #include -#include #include #include Index: PrusaSlicer-version_2.3.3/src/libslic3r/Thread.cpp =================================================================== --- PrusaSlicer-version_2.3.3.orig/src/libslic3r/Thread.cpp +++ PrusaSlicer-version_2.3.3/src/libslic3r/Thread.cpp @@ -9,10 +9,10 @@ #include #include #include +#include +#include #include -#include #include -#include #include "Thread.hpp" @@ -206,13 +206,13 @@ void name_tbb_thread_pool_threads() nthreads = 1; #endif - if (nthreads != nthreads_hw) - new tbb::task_scheduler_init(int(nthreads)); + if (nthreads != nthreads_hw) + tbb::global_control(tbb::global_control::max_allowed_parallelism, nthreads); std::atomic nthreads_running(0); std::condition_variable cv; std::mutex cv_m; - auto master_thread_id = tbb::this_tbb_thread::get_id(); + auto master_thread_id = std::this_thread::get_id(); tbb::parallel_for( tbb::blocked_range(0, nthreads, 1), [&nthreads_running, nthreads, &master_thread_id, &cv, &cv_m](const tbb::blocked_range &range) { @@ -226,7 +226,7 @@ void name_tbb_thread_pool_threads() std::unique_lock lk(cv_m); cv.wait(lk, [&nthreads_running, nthreads]{return nthreads_running == nthreads;}); } - auto thread_id = tbb::this_tbb_thread::get_id(); + auto thread_id = std::this_thread::get_id(); if (thread_id == master_thread_id) { // The calling thread runs the 0'th task. assert(range.begin() == 0); Index: PrusaSlicer-version_2.3.3/src/libslic3r/pchheader.hpp =================================================================== --- PrusaSlicer-version_2.3.3.orig/src/libslic3r/pchheader.hpp +++ PrusaSlicer-version_2.3.3/src/libslic3r/pchheader.hpp @@ -93,12 +93,9 @@ #include #include -#include #include #include -#include #include -#include #include #include Index: PrusaSlicer-version_2.3.3/src/libslic3r/utils.cpp =================================================================== --- PrusaSlicer-version_2.3.3.orig/src/libslic3r/utils.cpp +++ PrusaSlicer-version_2.3.3/src/libslic3r/utils.cpp @@ -43,7 +43,7 @@ #include #include -#include +#include #if defined(__linux__) || defined(__GNUC__ ) #include @@ -118,9 +118,7 @@ void trace(unsigned int level, const cha void disable_multi_threading() { // Disable parallelization so the Shiny profiler works - static tbb::task_scheduler_init *tbb_init = nullptr; - if (tbb_init == nullptr) - tbb_init = new tbb::task_scheduler_init(1); + tbb::global_control(tbb::global_control::max_allowed_parallelism, 1); } static std::string g_var_dir; Index: PrusaSlicer-version_2.3.3/src/slic3r/GUI/BackgroundSlicingProcess.cpp =================================================================== --- PrusaSlicer-version_2.3.3.orig/src/slic3r/GUI/BackgroundSlicingProcess.cpp +++ PrusaSlicer-version_2.3.3/src/slic3r/GUI/BackgroundSlicingProcess.cpp @@ -465,7 +465,7 @@ void BackgroundSlicingProcess::schedule_ return; // Guard against entering the export step before changing the export path. - tbb::mutex::scoped_lock lock(m_print->state_mutex()); + std::scoped_lock lock(m_print->state_mutex()); this->invalidate_step(bspsGCodeFinalize); m_export_path = path; m_export_path_on_removable_media = export_path_on_removable_media; @@ -478,7 +478,7 @@ void BackgroundSlicingProcess::schedule_ return; // Guard against entering the export step before changing the export path. - tbb::mutex::scoped_lock lock(m_print->state_mutex()); + std::scoped_lock lock(m_print->state_mutex()); this->invalidate_step(bspsGCodeFinalize); m_export_path.clear(); m_upload_job = std::move(upload_job); @@ -491,7 +491,7 @@ void BackgroundSlicingProcess::reset_exp m_export_path.clear(); m_export_path_on_removable_media = false; // invalidate_step expects the mutex to be locked. - tbb::mutex::scoped_lock lock(m_print->state_mutex()); + std::scoped_lock lock(m_print->state_mutex()); this->invalidate_step(bspsGCodeFinalize); } } Index: PrusaSlicer-version_2.3.3/src/slic3r/GUI/InstanceCheck.hpp =================================================================== --- PrusaSlicer-version_2.3.3.orig/src/slic3r/GUI/InstanceCheck.hpp +++ PrusaSlicer-version_2.3.3/src/slic3r/GUI/InstanceCheck.hpp @@ -13,7 +13,7 @@ #if __linux__ #include -#include +#include #include #endif // __linux__ Index: PrusaSlicer-version_2.3.3/src/slic3r/GUI/Mouse3DController.cpp =================================================================== --- PrusaSlicer-version_2.3.3.orig/src/slic3r/GUI/Mouse3DController.cpp +++ PrusaSlicer-version_2.3.3/src/slic3r/GUI/Mouse3DController.cpp @@ -66,7 +66,7 @@ void update_maximum(std::atomic& maxi void Mouse3DController::State::append_translation(const Vec3d& translation, size_t input_queue_max_size) { - tbb::mutex::scoped_lock lock(m_input_queue_mutex); + std::scoped_lock lock(m_input_queue_mutex); while (m_input_queue.size() >= input_queue_max_size) m_input_queue.pop_front(); m_input_queue.emplace_back(QueueItem::translation(translation)); @@ -77,7 +77,7 @@ void Mouse3DController::State::append_tr void Mouse3DController::State::append_rotation(const Vec3f& rotation, size_t input_queue_max_size) { - tbb::mutex::scoped_lock lock(m_input_queue_mutex); + std::scoped_lock lock(m_input_queue_mutex); while (m_input_queue.size() >= input_queue_max_size) m_input_queue.pop_front(); m_input_queue.emplace_back(QueueItem::rotation(rotation.cast())); @@ -92,7 +92,7 @@ void Mouse3DController::State::append_ro void Mouse3DController::State::append_button(unsigned int id, size_t /* input_queue_max_size */) { - tbb::mutex::scoped_lock lock(m_input_queue_mutex); + std::scoped_lock lock(m_input_queue_mutex); m_input_queue.emplace_back(QueueItem::buttons(id)); #if ENABLE_3DCONNEXION_DEVICES_DEBUG_OUTPUT update_maximum(input_queue_max_size_achieved, m_input_queue.size()); @@ -277,7 +277,7 @@ void Mouse3DController::device_attached( #if ENABLE_CTRL_M_ON_WINDOWS m_device_str = format_device_string(vid, pid); if (auto it_params = m_params_by_device.find(m_device_str); it_params != m_params_by_device.end()) { - tbb::mutex::scoped_lock lock(m_params_ui_mutex); + std::scoped_lock lock(m_params_ui_mutex); m_params = m_params_ui = it_params->second; } else @@ -295,7 +295,7 @@ void Mouse3DController::device_detached( int pid = 0; if (sscanf(device.c_str(), "\\\\?\\HID#VID_%x&PID_%x&", &vid, &pid) == 2) { if (std::find(_3DCONNEXION_VENDORS.begin(), _3DCONNEXION_VENDORS.end(), vid) != _3DCONNEXION_VENDORS.end()) { - tbb::mutex::scoped_lock lock(m_params_ui_mutex); + std::scoped_lock lock(m_params_ui_mutex); m_params_by_device[format_device_string(vid, pid)] = m_params_ui; } } @@ -307,12 +307,12 @@ void Mouse3DController::device_detached( // Filter out mouse scroll events produced by the 3DConnexion driver. bool Mouse3DController::State::process_mouse_wheel() { - tbb::mutex::scoped_lock lock(m_input_queue_mutex); - if (m_mouse_wheel_counter == 0) - // No 3DConnexion rotation has been captured since the last mouse scroll event. + std::scoped_lock lock(m_input_queue_mutex); + if (m_mouse_wheel_counter == 0) + // No 3DConnexion rotation has been captured since the last mouse scroll event. return false; if (std::find_if(m_input_queue.begin(), m_input_queue.end(), [](const QueueItem &item){ return item.is_rotation(); }) != m_input_queue.end()) { - // There is a rotation stored in the queue. Suppress one mouse scroll event. + // There is a rotation stored in the queue. Suppress one mouse scroll event. -- m_mouse_wheel_counter; return true; } @@ -329,7 +329,7 @@ bool Mouse3DController::State::apply(con std::deque input_queue; { // Atomically move m_input_queue to input_queue. - tbb::mutex::scoped_lock lock(m_input_queue_mutex); + std::scoped_lock lock(m_input_queue_mutex); input_queue = std::move(m_input_queue); m_input_queue.clear(); } @@ -418,7 +418,7 @@ bool Mouse3DController::apply(Camera& ca #if ENABLE_CTRL_M_ON_WINDOWS #ifdef _WIN32 { - tbb::mutex::scoped_lock lock(m_params_ui_mutex); + std::scoped_lock lock(m_params_ui_mutex); if (m_params_ui_changed) { m_params = m_params_ui; m_params_ui_changed = false; @@ -447,7 +447,7 @@ void Mouse3DController::render_settings_ Params params_copy; bool params_changed = false; { - tbb::mutex::scoped_lock lock(m_params_ui_mutex); + std::scoped_lock lock(m_params_ui_mutex); params_copy = m_params_ui; } @@ -565,7 +565,7 @@ void Mouse3DController::render_settings_ if (params_changed) { // Synchronize front end parameters to back end. - tbb::mutex::scoped_lock lock(m_params_ui_mutex); + std::scoped_lock lock(m_params_ui_mutex); auto pthis = const_cast(this); #if ENABLE_3DCONNEXION_DEVICES_DEBUG_OUTPUT if (params_copy.input_queue_max_size != params_copy.input_queue_max_size) @@ -586,7 +586,7 @@ void Mouse3DController::connected(std::s m_device_str = device_name; // Copy the parameters for m_device_str into the current parameters. if (auto it_params = m_params_by_device.find(m_device_str); it_params != m_params_by_device.end()) { - tbb::mutex::scoped_lock lock(m_params_ui_mutex); + std::scoped_lock lock(m_params_ui_mutex); m_params = m_params_ui = it_params->second; } m_connected = true; @@ -597,7 +597,7 @@ void Mouse3DController::disconnected() // Copy the current parameters for m_device_str into the parameter database. assert(m_connected == ! m_device_str.empty()); if (m_connected) { - tbb::mutex::scoped_lock lock(m_params_ui_mutex); + std::scoped_lock lock(m_params_ui_mutex); m_params_by_device[m_device_str] = m_params_ui; m_device_str.clear(); m_connected = false; @@ -621,7 +621,7 @@ bool Mouse3DController::handle_input(con { // Synchronize parameters between the UI thread and the background thread. //FIXME is this necessary on OSX? Are these notifications triggered from the main thread or from a worker thread? - tbb::mutex::scoped_lock lock(m_params_ui_mutex); + std::scoped_lock lock(m_params_ui_mutex); if (m_params_ui_changed) { m_params = m_params_ui; m_params_ui_changed = false; @@ -733,7 +733,7 @@ void Mouse3DController::run() for (;;) { { - tbb::mutex::scoped_lock lock(m_params_ui_mutex); + std::scoped_lock lock(m_params_ui_mutex); if (m_stop) break; if (m_params_ui_changed) { @@ -998,7 +998,7 @@ bool Mouse3DController::connect_device() #endif // ENABLE_3DCONNEXION_DEVICES_DEBUG_OUTPUT // Copy the parameters for m_device_str into the current parameters. if (auto it_params = m_params_by_device.find(m_device_str); it_params != m_params_by_device.end()) { - tbb::mutex::scoped_lock lock(m_params_ui_mutex); + std::scoped_lock lock(m_params_ui_mutex); m_params = m_params_ui = it_params->second; } } @@ -1023,7 +1023,7 @@ void Mouse3DController::disconnect_devic BOOST_LOG_TRIVIAL(info) << "Disconnected device: " << m_device_str; // Copy the current parameters for m_device_str into the parameter database. { - tbb::mutex::scoped_lock lock(m_params_ui_mutex); + std::scoped_lock lock(m_params_ui_mutex); m_params_by_device[m_device_str] = m_params_ui; } m_device_str.clear(); Index: PrusaSlicer-version_2.3.3/src/slic3r/GUI/Mouse3DController.hpp =================================================================== --- PrusaSlicer-version_2.3.3.orig/src/slic3r/GUI/Mouse3DController.hpp +++ PrusaSlicer-version_2.3.3/src/slic3r/GUI/Mouse3DController.hpp @@ -10,12 +10,12 @@ #include #include +#include #include #include #include #include -#include namespace Slic3r { @@ -85,7 +85,7 @@ class Mouse3DController // m_input_queue is accessed by the background thread and by the UI thread. Access to m_input_queue // is guarded with m_input_queue_mutex. std::deque m_input_queue; - mutable tbb::mutex m_input_queue_mutex; + mutable std::mutex m_input_queue_mutex; #ifdef WIN32 // When the 3Dconnexion driver is running the system gets, by default, mouse wheel events when rotations around the X axis are detected. @@ -112,12 +112,12 @@ class Mouse3DController #if ENABLE_3DCONNEXION_DEVICES_DEBUG_OUTPUT Vec3d get_first_vector_of_type(unsigned int type) const { - tbb::mutex::scoped_lock lock(m_input_queue_mutex); + std::scoped_lock lock(m_input_queue_mutex); auto it = std::find_if(m_input_queue.begin(), m_input_queue.end(), [type](const QueueItem& item) { return item.type_or_buttons == type; }); return (it == m_input_queue.end()) ? Vec3d::Zero() : it->vector; } size_t input_queue_size_current() const { - tbb::mutex::scoped_lock lock(m_input_queue_mutex); + std::scoped_lock lock(m_input_queue_mutex); return m_input_queue.size(); } std::atomic input_queue_max_size_achieved; @@ -133,7 +133,7 @@ class Mouse3DController // UI thread will read / write this copy. Params m_params_ui; bool m_params_ui_changed { false }; - mutable tbb::mutex m_params_ui_mutex; + mutable std::mutex m_params_ui_mutex; // This is a database of parametes of all 3DConnexion devices ever connected. // This database is loaded from AppConfig on application start and it is stored to AppConfig on application exit. Index: PrusaSlicer-version_2.3.3/src/slic3r/GUI/RemovableDriveManager.cpp =================================================================== --- PrusaSlicer-version_2.3.3.orig/src/slic3r/GUI/RemovableDriveManager.cpp +++ PrusaSlicer-version_2.3.3/src/slic3r/GUI/RemovableDriveManager.cpp @@ -84,7 +84,7 @@ void RemovableDriveManager::eject_drive( this->update(); #endif // REMOVABLE_DRIVE_MANAGER_OS_CALLBACKS BOOST_LOG_TRIVIAL(info) << "Ejecting started"; - tbb::mutex::scoped_lock lock(m_drives_mutex); + std::scoped_lock lock(m_drives_mutex); auto it_drive_data = this->find_last_save_path_drive_data(); if (it_drive_data != m_current_drives.end()) { // get handle to device @@ -130,7 +130,7 @@ std::string RemovableDriveManager::get_r this->update(); #endif // REMOVABLE_DRIVE_MANAGER_OS_CALLBACKS - tbb::mutex::scoped_lock lock(m_drives_mutex); + std::scoped_lock lock(m_drives_mutex); if (m_current_drives.empty()) return std::string(); std::size_t found = path.find_last_of("\\"); @@ -146,7 +146,7 @@ std::string RemovableDriveManager::get_r std::string RemovableDriveManager::get_removable_drive_from_path(const std::string& path) { - tbb::mutex::scoped_lock lock(m_drives_mutex); + std::scoped_lock lock(m_drives_mutex); std::size_t found = path.find_last_of("\\"); std::string new_path = path.substr(0, found); int letter = PathGetDriveNumberW(boost::nowide::widen(new_path).c_str()); @@ -285,7 +285,7 @@ void RemovableDriveManager::eject_drive( DriveData drive_data; { - tbb::mutex::scoped_lock lock(m_drives_mutex); + std::scoped_lock lock(m_drives_mutex); auto it_drive_data = this->find_last_save_path_drive_data(); if (it_drive_data == m_current_drives.end()) return; @@ -341,7 +341,7 @@ void RemovableDriveManager::eject_drive( if (success) { // Remove the drive_data from m_current drives, searching by value, not by pointer, as m_current_drives may get modified during // asynchronous execution on m_eject_thread. - tbb::mutex::scoped_lock lock(m_drives_mutex); + std::scoped_lock lock(m_drives_mutex); auto it = std::find(m_current_drives.begin(), m_current_drives.end(), drive_data); if (it != m_current_drives.end()) m_current_drives.erase(it); @@ -361,7 +361,7 @@ std::string RemovableDriveManager::get_r std::size_t found = path.find_last_of("/"); std::string new_path = found == path.size() - 1 ? path.substr(0, found) : path; - tbb::mutex::scoped_lock lock(m_drives_mutex); + std::scoped_lock lock(m_drives_mutex); for (const DriveData &data : m_current_drives) if (search_for_drives_internal::compare_filesystem_id(new_path, data.path)) return path; @@ -377,7 +377,7 @@ std::string RemovableDriveManager::get_r new_path = new_path.substr(0, found); // check if same filesystem - tbb::mutex::scoped_lock lock(m_drives_mutex); + std::scoped_lock lock(m_drives_mutex); for (const DriveData &drive_data : m_current_drives) if (search_for_drives_internal::compare_filesystem_id(new_path, drive_data.path)) return drive_data.path; @@ -452,7 +452,7 @@ RemovableDriveManager::RemovableDrivesSt RemovableDriveManager::RemovableDrivesStatus out; { - tbb::mutex::scoped_lock lock(m_drives_mutex); + std::scoped_lock lock(m_drives_mutex); out.has_eject = // Cannot control eject on Chromium. platform_flavor() != PlatformFlavor::LinuxOnChromium && @@ -468,17 +468,17 @@ RemovableDriveManager::RemovableDrivesSt // Update is called from thread_proc() and from most of the public methods on demand. void RemovableDriveManager::update() { - tbb::mutex::scoped_lock inside_update_lock; + std::unique_lock inside_update_lock(m_inside_update_mutex, std::defer_lock); #ifdef _WIN32 // All wake up calls up to now are now consumed when the drive enumeration starts. m_wakeup = false; #endif // _WIN32 - if (inside_update_lock.try_acquire(m_inside_update_mutex)) { + if (inside_update_lock.try_lock()) { // Got the lock without waiting. That means, the update was not running. // Run the update. std::vector current_drives = this->search_for_removable_drives(); // Post update events. - tbb::mutex::scoped_lock lock(m_drives_mutex); + std::scoped_lock lock(m_drives_mutex); std::sort(current_drives.begin(), current_drives.end()); if (current_drives != m_current_drives) { assert(m_callback_evt_handler); @@ -489,7 +489,7 @@ void RemovableDriveManager::update() } else { // Acquiring the m_iniside_update lock failed, therefore another update is running. // Just block until the other instance of update() finishes. - inside_update_lock.acquire(m_inside_update_mutex); + inside_update_lock.lock(); } } Index: PrusaSlicer-version_2.3.3/src/slic3r/GUI/RemovableDriveManager.hpp =================================================================== --- PrusaSlicer-version_2.3.3.orig/src/slic3r/GUI/RemovableDriveManager.hpp +++ PrusaSlicer-version_2.3.3/src/slic3r/GUI/RemovableDriveManager.hpp @@ -5,7 +5,7 @@ #include #include -#include +#include #include // Custom wxWidget events @@ -111,9 +111,9 @@ private: // m_current_drives is guarded by m_drives_mutex // sorted ascending by path std::vector m_current_drives; - mutable tbb::mutex m_drives_mutex; + mutable std::mutex m_drives_mutex; // Locking the update() function to avoid that the function is executed multiple times. - mutable tbb::mutex m_inside_update_mutex; + mutable std::mutex m_inside_update_mutex; // Returns drive path (same as path in DriveData) if exists otherwise empty string. std::string get_removable_drive_from_path(const std::string& path); Index: PrusaSlicer-version_2.3.3/src/libslic3r/SLA/Concurrency.hpp =================================================================== --- PrusaSlicer-version_2.3.3.orig/src/libslic3r/SLA/Concurrency.hpp +++ PrusaSlicer-version_2.3.3/src/libslic3r/SLA/Concurrency.hpp @@ -1,8 +1,9 @@ #ifndef SLA_CONCURRENCY_H #define SLA_CONCURRENCY_H +#include + #include -#include #include #include @@ -23,7 +24,7 @@ template struct _ccr {}; template<> struct _ccr { using SpinningMutex = tbb::spin_mutex; - using BlockingMutex = tbb::mutex; + using BlockingMutex = std::mutex; template static IteratorOnly loop_(const tbb::blocked_range &range, Fn &&fn) Index: PrusaSlicer-version_2.3.3/src/slic3r/GUI/BackgroundSlicingProcess.hpp =================================================================== --- PrusaSlicer-version_2.3.3.orig/src/slic3r/GUI/BackgroundSlicingProcess.hpp +++ PrusaSlicer-version_2.3.3/src/slic3r/GUI/BackgroundSlicingProcess.hpp @@ -213,7 +213,7 @@ private: State m_state = STATE_INITIAL; PrintState m_step_state; - mutable tbb::mutex m_step_state_mutex; + mutable std::mutex m_step_state_mutex; bool set_step_started(BackgroundSlicingProcessStep step); void set_step_done(BackgroundSlicingProcessStep step); bool is_step_done(BackgroundSlicingProcessStep step) const;