Callback

Mircea Baja - 31 May 2025

# Callback

<div align="center">
<svg xmlns="http://www.w3.org/2000/svg" id="svg20250530-0-box" width="100%" viewBox="0 0 800 300">
  <style>
    #svg20250530-0-box {
      border: 1px solid #e8e8e8;
      background-color: #f5f5f5;
    }
    .svg20250530-0-t1 {
      font-family: sans-serif;
      font-size: 16px;
      dominant-baseline: middle;
    }
    .svg20250530-0-l1 {
      stroke: #000000;
      stroke-width: 2;
      fill: none;
    }
    .svg20250530-0-task_white {
      stroke: #000000;
      stroke-width: 4;
      fill: #ffffff;
    }
    .svg20250530-0-task_orange {
      stroke: #000000;
      stroke-width: 4;
      fill: #f5bb00;
    }
    .svg20250530-0-task_pink {
      stroke: #000000;
      stroke-width: 4;
      fill: #ff36ab;
    }
    .svg20250530-0-task_pink1 {
      stroke: #000000;
      stroke-width: 4;
      fill: #ffcdea;
    }
    .svg20250530-0-task_pink2 {
      stroke: #000000;
      stroke-width: 4;
      fill: #ff9bd5;
    }
    .svg20250530-0-task_pink3 {
      stroke: #000000;
      stroke-width: 4;
      fill: #ff69c0;
    }
  </style>
  <defs>
    <marker id="svg20250530-0-arrow" viewBox="0, 0, 10, 10" refX="5" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse">
      <path d="M 0 0 L 10 5 L 0 10 L 2.5 5 Z"/>
    </marker>
  </defs>
  <rect x="30" y="10" width="100" height="120" class="svg20250530-0-task_white"/>
  <path class="svg20250530-0-l1" d="M 80 30 v 85 h -60" marker-end="url(#svg20250530-0-arrow)"/>
  <rect x="180" y="40" width="100" height="30" class="svg20250530-0-task_orange"/>
  <rect x="180" y="70" width="100" height="30" class="svg20250530-0-task_orange"/>
  <text class="svg20250530-0-t1" x="190" y="55">x</text>
  <text class="svg20250530-0-t1" x="190" y="85">fn</text>
  <line class="svg20250530-0-l1" x1="80" y1="40" x2="172" y2="40" marker-end="url(#svg20250530-0-arrow)"/>
  <line class="svg20250530-0-l1" x1="280" y1="50" x2="372" y2="50" marker-end="url(#svg20250530-0-arrow)"/>
  <rect x="380" y="50" width="100" height="100" class="svg20250530-0-task_white"/>
  <rect x="380" y="150" width="100" height="80" class="svg20250530-0-task_orange"/>
  <rect x="380" y="230" width="100" height="30" class="svg20250530-0-task_white"/>
  <line class="svg20250530-0-l1" x1="430" y1="55" x2="430" y2="250" marker-end="url(#svg20250530-0-arrow)"/>
  <rect x="30" y="200" width="100" height="80" class="svg20250530-0-task_white"/>
  <path class="svg20250530-0-l1" d="M 430 215 h -350 v 45" marker-end="url(#svg20250530-0-arrow)"/>
</svg>
</div>

---

# Capture

```cpp
class callback
{
  void* x_{ nullptr };
  void (*fn_)(void* x) noexcept { nullptr };

public:
  callback() noexcept = default;
  callback(void* x, void (*fn)(void* x) noexcept) noexcept :
    x_{ x },
    fn_{ fn }
  {
    assert(nullptr != fn_);
  }

callback(const callback&) noexcept = default;
  callback& operator=(const callback&) noexcept = default;
```

- pure callback (`void`, `noexcept`, no arguments other than `x`)
- some unusual copy: `default` and  `noexcept`, but makes sense here

---

# Invoke

```cpp
  void invoke() noexcept
  {
    assert(nullptr != fn_);
    fn_(x_);
  }

void operator()() noexcept
  {
    invoke();
  }

bool is_callable() noexcept
  {
    return nullptr != fn_;
  }
}; // callback
```

---

# Convenience, not `void`

```cpp
template<typename T, void (*fn)(T&) noexcept>
struct make_function_callback_impl
{
  static void invoke(void* x_void) noexcept
  {
    assert(x_void != nullptr);
    T* x = reinterpret_cast<T*>(x_void);
    return std::invoke(fn, *x);
  }
};

template<auto FnPtr, typename T>
callback make_function_callback(T& x)
{
  return callback{ &x, &make_function_callback_impl<T, FnPtr>::invoke };
}
```

- unusual order of templates in `make_function_callback` but makes sense here
- unusual static in template

---

# Convenience, not `void`

```cpp
TEST(callback_trivial_function)
{
  callback cb;

bool called{ false };

cb = make_function_callback<+[](bool & x) noexcept {
    x = true;
  }>(called);

ASSERT_FALSE(called);

cb.invoke();

ASSERT_TRUE(called);
}
```

- unusual lambda, uses plus, no capture => it's a function

---

# Convenience, member

```cpp
template<typename T, void (T::*member_fn)() noexcept>
struct make_member_callback_impl
{
  static void invoke(void* x_void) noexcept
  {
    assert(x_void != nullptr);
    T* x = reinterpret_cast<T*>(x_void);
    return std::invoke(member_fn, x);
  }
};

template<auto MemberFnPtr, typename T>
callback make_member_callback(T* x)
{
  return callback{ x, &make_member_callback_impl<T, MemberFnPtr>::invoke };
}
```

---

# Convenience, member

```cpp
TEST(callback_trivial_member)
{
  callback cb;

// assuming X is a class that has a member function
  X x;

cb = make_member_callback<&X::member_function>(&x);

cb.invoke();

// x.member_function was called
}
```

---

# Convenience, resume

```cpp
inline callback make_resume_coroutine_callback(std::coroutine_handle<> handle)
{
  return callback{ handle.address(), +[](void* x) noexcept {
    std::coroutine_handle<> original_handle = std::coroutine_handle<>::from_address(x);
    original_handle.resume();
  }};
}
```

---

# Convenience, resume

```cpp
TEST(callback_resume)
{
  // coroutine
  dummy_co co = async_foo();

callback cb =
    make_resume_coroutine_callback(co.unique_child_coro.get());

cb.invoke();

// coroutine is resumed
}
```

---

# resume

- discuss resume throwing

```cpp
  promise_type promise(<<promise constructor args>>);
  try {
    co_await promise.initial_suspend();
    // ... body here
  }
  catch (...) {
    if (!made enough progress through initial_suspend) {
      throw;
    }
    promise.unhandled_exception();
  }
  co_await promise.final_suspend();
```

---

# Alternatives

- std::function
  - D: allocation, indirect call
- virtual function
  - D: indirect call, worse for coroutine resume or multiple member functions
- resume style ABI
  - D: indirect call
- receiver (as in senders/receivers) is a generalized callback
  - multiple entry points:
  - set_value(...), set_error(...), set_stopped()

Trade offs are:
- allocation
- memory/space
- level of call indirection

---

# Applications

- ready queue
- timer heap
- stop callback
- continuations (what do do when things complete)

---

# Ready queue: intrusive queue

```cpp
template<typename Node, Node* Node::*next>
class intrusive_queue {
  Node* head_{ nullptr };
  Node* tail_{ nullptr };
public:
  // constructor, move etc ...

bool empty() const noexcept {
    return head_ == nullptr;
  }

void push(Node* what) noexcept {
    // add to back
  }

Node* pop() noexcept {
    // return front or nullptr
  }
};
```

---

# Ready queue

```cpp
struct ready_node {
  ready_node() noexcept = default;

ready_node(const ready_node&) = delete;
  ready_node& operator=(const ready_node&) = delete;

ready_node* next{};
  callback cb{};
};

using ready_queue = cpp_util::intrusive_queue<ready_node, &ready_node::next>;
```

---

# Ready queue: usage

```cpp
// consume existing entries
ready_queue local_ready = std::move(ready_queue_);
while (!local_ready.empty()) {
  auto* ready_node = local_ready.pop();

callback cb = ready_node->cb;
  assert(cb.is_callable());
  cb.invoke();
}
// then check timer heap
```

---

# Disadvantages

- not the perfect solution (we'll see other options at sender/receiver)
- but will do

---

# Questions?