drop dead code

Author: Conor

src/core/promise.cxx

@@ -138,83 +138,6 @@ struct final_awaitable : std::suspend_always {
   }
 };
 
-/**
- * @brief Part that deals only with parent.
- */
-template <worker_context Context>
-[[nodiscard]]
-constexpr auto final_suspend_continue(Context *context, frame_t<Context> *parent) noexcept -> coro<> {
-
-  // An owner is a worker who:
-  //
-  // - Created the task.
-  // - OR had the task submitted to them.
-  // - OR won the task at a join.
-  //
-  // An owner of a task owns the stack the task is on.
-  //
-  // As the worker who completed the child task this thread owns the stack the child task was on.
-  //
-  // Either:
-  //
-  // 1. The parent is on the same stack as the child.
-  // 2. OR the parent is on a different stack to the child.
-  //
-  // Case (1) implies: we owned the parent; forked the child task; then the parent was then stolen.
-  // Case (2) implies: we stole the parent task; then forked the child; then the parent was stolen.
-  //
-  // Case (2) implies that our stack is empty.
-
-  // As soon as we do the `fetch_sub` below the parent task is no longer safe
-  // to access as it may be resumed and then destroyed by another thread. Hence
-  // we must make copies on-the-stack of any data we may need if we lose the
-  // join race.
-  bool const owner = parent->stack_ckpt == context->stack().checkpoint();
-
-  // TODO: we could reduce branching if we unconditionally release and also
-  // drop pre-release function altogether... Need to benchmark with code that
-  // triggers a lot of stealing.
-
-  // As soon as we do the fetch_sub (if we loose) someone may acquire
-  // the stack so we must prepare it for release now.
-  auto release_key = context->stack().prepare_release();
-
-  // TODO: we could add an `if (owner)` around acquire below, then we could
-  // define that acquire is always called with null or not-self.
-
-  // Register with parent we have completed this child task.
-  if (parent->atomic_joins().fetch_sub(1, std::memory_order_release) == 1) {
-    // Parent has reached join and we are the last child task to complete. We
-    // are the exclusive owner of the parent and therefore, we must continue
-    // parent. As we won the race, acquire all writes before resuming.
-    std::atomic_thread_fence(std::memory_order_acquire);
-
-    if (!owner) {
-      // In case of scenario (2) we must acquire the parent's stack.
-      context->stack().acquire(std::as_const(parent->stack_ckpt));
-    }
-
-    // Must reset parent's control block before resuming parent.
-    parent->reset_counters();
-
-    return parent->handle();
-  }
-
-  // We did not win the join-race, we cannot dereference the parent pointer now
-  // as the frame may now be freed by the winner. Parent has not reached join
-  // or we are not the last child to complete. We are now out of jobs, we must
-  // yield to the executor.
-
-  if (owner) {
-    // We were unable to resume the parent and we were its owner, as the
-    // resuming thread will take ownership of the parent's we must give it up.
-    context->stack().release(std::move(release_key));
-  }
-
-  // Else, case (2), our stack has no allocations on it, it may be used later.
-  return std::noop_coroutine();
-}
-
 // =============== Fork/Call =============== //
 
 // TODO: make sure exceptions are cancel-safe (I think now cancellation can leak)