ModuleWorks
diff --git a/‎taskflow/core/async.hpp‎
Lines changed: 7 additions & 1 deletion b/‎taskflow/core/async.hpp‎
Lines changed: 7 additions & 1 deletion
diff --git a/‎taskflow/core/executor.hpp‎
Lines changed: 31 additions & 9 deletions b/‎taskflow/core/executor.hpp‎
Lines changed: 31 additions & 9 deletions
diff --git a/‎taskflow/core/worker.hpp‎
Lines changed: 0 additions & 14 deletions b/‎taskflow/core/worker.hpp‎
Lines changed: 0 additions & 14 deletions
@@ -13,7 +13,13 @@ namespace tf {
 
 // Procedure: _schedule_async_task
 TF_FORCE_INLINE void Executor::_schedule_async_task(Node* node) {  
-  (pt::this_worker) ? _schedule(*pt::this_worker, node) : _schedule(node);
+  auto w = this_worker();
+  if(w) {
+    _schedule(*w, node);
+  }
+  else{
+    _schedule(node);
+  }
 }
 
 // Procedure: _tear_down_async
 
@@ -542,6 +542,16 @@ class Executor {
   @endcode
   */
   size_t num_taskflows() const;
+
+  /**
+  @brief queries pointer to the current worker if it belongs to this executor, otherwise returns nullptr
+
+  @code{.cpp}
+  auto w = executor.this_worker();
+  assert(w == nullptr || w->executor() == &executor);
+  @endcode
+  */
+  Worker* this_worker();
 
   /**
   @brief queries the id of the caller thread within this executor
@@ -1063,6 +1073,8 @@ class Executor {
 
   std::shared_ptr<WorkerInterface> _worker_interface;
   std::unordered_set<std::shared_ptr<ObserverInterface>> _observers;
+  std::unordered_map<std::thread::id, size_t> _wids;
+
 
   void _shutdown();
   void _observer_prologue(Worker&, Node*);
@@ -1224,23 +1236,31 @@ inline size_t Executor::num_taskflows() const {
   return _taskflows.size();
 }
 
+inline Worker* Executor::this_worker() {
+  auto itr = _wids.find(std::this_thread::get_id());
+  return itr == _wids.end() ? nullptr : &_workers[itr->second];
+}
+
 // Function: this_worker_id
 inline int Executor::this_worker_id() const {
-  auto w = pt::this_worker;
-  return (w && w->_executor == this) ? static_cast<int>(w->_id) : -1;
+  auto i = _wids.find(std::this_thread::get_id());
+  return i == _wids.end() ? -1 : static_cast<int>(_workers[i->second]._id);
 }
 
 // Procedure: _spawn
 inline void Executor::_spawn(size_t N) {
-
+  std::mutex mutex;
   for(size_t id=0; id<N; ++id) {
     _workers[id]._id = id;
     _workers[id]._vtm = id;
     _workers[id]._executor = this;
     _workers[id]._waiter = &_notifier._waiters[id];
     _workers[id]._thread = std::thread([&, &w=_workers[id]] () {
 
-      pt::this_worker = &w;
+      {
+        std::scoped_lock lock(mutex);
+        _wids[std::this_thread::get_id()] = w._id;
+      }
 
       // initialize the random engine and seed for work-stealing loop
       w._rdgen.seed(static_cast<std::default_random_engine::result_type>(
@@ -2080,7 +2100,7 @@ tf::Future<void> Executor::run_until(Taskflow& f, P&& p, C&& c) {
     std::lock_guard<std::mutex> lock(f._mutex);
     f._topologies.push(t);
     if(f._topologies.size() == 1) {
-      _set_up_topology(pt::this_worker, t.get());
+      _set_up_topology(this_worker(), t.get());
     }
   }
 
@@ -2108,23 +2128,25 @@ void Executor::corun(T& target) {
 
   static_assert(has_graph_v<T>, "target must define a member function 'Graph& graph()'");
 
-  if(pt::this_worker == nullptr || pt::this_worker->_executor != this) {
+  Worker* w = this_worker();
+  if(w == nullptr || w->_executor != this) {
     TF_THROW("corun must be called by a worker of the executor");
   }
 
   Node anchor;
-  _corun_graph(*pt::this_worker, &anchor, target.graph().begin(), target.graph().end());
+  _corun_graph(*w, &anchor, target.graph().begin(), target.graph().end());
 }
 
 // Function: corun_until
 template <typename P>
 void Executor::corun_until(P&& predicate) {
 
-  if(pt::this_worker == nullptr || pt::this_worker->_executor != this) {
+  Worker* w = this_worker();
+  if(w == nullptr || w->_executor != this) {
     TF_THROW("corun_until must be called by a worker of the executor");
   }
 
-  _corun_until(*pt::this_worker, std::forward<P>(predicate));
+  _corun_until(*w, std::forward<P>(predicate));
 }
 
 // Procedure: _corun_graph
 
@@ -106,20 +106,6 @@ class Worker {
     BoundedTaskQueue<Node*> _wsq;
 };
 
-
-// ----------------------------------------------------------------------------
-// Per-thread
-// ----------------------------------------------------------------------------
-
-namespace pt {
-
-/**
-@private
-*/
-inline thread_local Worker* this_worker {nullptr};
-
-}
-
 // ----------------------------------------------------------------------------
 // Class Definition: WorkerView
 // ----------------------------------------------------------------------------