Coroutine task

Mircea Baja - 6 Aug 2023

# Coroutines problem domain

<div align="center">
<svg xmlns="http://www.w3.org/2000/svg" id="svg20230623-1-1" width="100%" viewBox="0 0 250 100">
  <style>
    #svg20230623-1-1 {
      border: 1px solid #e8e8e8;
      background-color: #f5f5f5;
    }
    .svg20230623-1-t1 {
      font-family: sans-serif;
      font-size: 16px;
      font-weight: bold;
      dominant-baseline: middle;
    }
    .svg20230623-1-task_blue {
      stroke: #000000;
      stroke-width: 4;
      fill: #2d93ad;
    }
    .svg20230623-1-task_purple {
      stroke: #000000;
      stroke-width: 4;
      fill: #9665ac;
    }
    .svg20230623-1-task_orange {
      stroke: #000000;
      stroke-width: 4;
      fill: #f5bb00;
    }
  </style>
  <rect x="-10" y="-10" width="80" height="80" class="svg20230623-1-task_purple"/>
  <rect x="70" y="-10" width="60" height="80" class="svg20230623-1-task_blue"/>
  <rect x="130" y="-10" width="30" height="80" class="svg20230623-1-task_orange"/>
  <rect x="160" y="-10" width="40" height="80" class="svg20230623-1-task_blue"/>
  <rect x="200" y="-10" width="60" height="80" class="svg20230623-1-task_purple"/>
  <rect x="-10" y="80" width="100" height="80" class="svg20230623-1-task_orange"/>
  <rect x="90" y="80" width="80" height="80" class="svg20230623-1-task_purple"/>
  <rect x="170" y="80" width="90" height="80" class="svg20230623-1-task_orange"/>
</svg>
</div>

---

# Concurrent vs. parallel

- intuitively illustrated using abstract pictures
- for intro into C++ standardese doublespeak see ["Forward Progress Guarantees in
  C++ - Olivier Giroux - CppNow 2023"](https://www.youtube.com/watch?v=g9Rgu6YEuqY&t=978s)

---

# Sequential

<div align="center">
<svg xmlns="http://www.w3.org/2000/svg" id="svg20230623-2-1" width="100%" viewBox="0 0 800 70">
  <style>
    #svg20230623-2-1 {
      border: 1px solid #e8e8e8;
      background-color: #f5f5f5;
    }
    .svg20230623-2-task_blue {
      stroke: #000000;
      stroke-width: 4;
      fill: #2d93ad;
    }
    .svg20230623-2-task_purple {
      stroke: #000000;
      stroke-width: 4;
      fill: #9665ac;
    }
    .svg20230623-2-task_orange {
      stroke: #000000;
      stroke-width: 4;
      fill: #f5bb00;
    }
  </style>
  <rect x="10" y="10" width="220" height="50" class="svg20230623-2-task_purple"/>
  <rect x="230" y="10" width="220" height="50" class="svg20230623-2-task_orange"/>
  <rect x="450" y="10" width="110" height="50" class="svg20230623-2-task_blue"/>
</svg>
</div>

# Concurrent

<div align="center">
<svg xmlns="http://www.w3.org/2000/svg" id="svg20230623-3-1" width="100%" viewBox="0 0 800 70">
  <style>
    #svg20230623-3-1 {
      border: 1px solid #e8e8e8;
      background-color: #f5f5f5;
    }
    .svg20230623-3-task_blue {
      stroke: #000000;
      stroke-width: 4;
      fill: #2d93ad;
    }
    .svg20230623-3-task_purple {
      stroke: #000000;
      stroke-width: 4;
      fill: #9665ac;
    }
    .svg20230623-3-task_orange {
      stroke: #000000;
      stroke-width: 4;
      fill: #f5bb00;
    }
  </style>
  <rect x="10" y="10" width="80" height="50" class="svg20230623-3-task_purple"/>
  <rect x="90" y="10" width="100" height="50" class="svg20230623-3-task_orange"/>
  <rect x="190" y="10" width="60" height="50" class="svg20230623-3-task_blue"/>
  <rect x="250" y="10" width="30" height="50" class="svg20230623-3-task_orange"/>
  <rect x="280" y="10" width="80" height="50" class="svg20230623-3-task_purple"/>
  <rect x="360" y="10" width="50" height="50" class="svg20230623-3-task_blue"/>
  <rect x="410" y="10" width="60" height="50" class="svg20230623-3-task_purple"/>
  <rect x="470" y="10" width="90" height="50" class="svg20230623-3-task_orange"/>
</svg>
</div>

- purple and yellow end later
- there is additional overhead (not illustrated)

---

# Sequential

# Parallel

<div align="center">
<svg xmlns="http://www.w3.org/2000/svg" id="svg20230623-2-1" width="100%" viewBox="0 0 800 130">
  <style>
    #svg20230623-2-1 {
      border: 1px solid #e8e8e8;
      background-color: #f5f5f5;
    }
    .svg20230623-2-task_blue {
      stroke: #000000;
      stroke-width: 4;
      fill: #2d93ad;
    }
    .svg20230623-2-task_purple {
      stroke: #000000;
      stroke-width: 4;
      fill: #9665ac;
    }
    .svg20230623-2-task_orange {
      stroke: #000000;
      stroke-width: 4;
      fill: #f5bb00;
    }
  </style>
  <rect x="10" y="10" width="220" height="50" class="svg20230623-2-task_purple"/>
  <rect x="10" y="70" width="220" height="50" class="svg20230623-2-task_orange"/>
  <rect x="230" y="10" width="110" height="50" class="svg20230623-2-task_blue"/>
</svg>
</div>

- there is additional overhead (not illustrated)

---

# Sequential

# Concurrent and parallel

<div align="center">
<svg xmlns="http://www.w3.org/2000/svg" id="svg20230623-4-1" width="100%" viewBox="0 0 800 130">
  <style>
    #svg20230623-4-1 {
      border: 1px solid #e8e8e8;
      background-color: #f5f5f5;
    }
    .svg20230623-4-task_blue {
      stroke: #000000;
      stroke-width: 4;
      fill: #2d93ad;
    }
    .svg20230623-4-task_purple {
      stroke: #000000;
      stroke-width: 4;
      fill: #9665ac;
    }
    .svg20230623-4-task_orange {
      stroke: #000000;
      stroke-width: 4;
      fill: #f5bb00;
    }
  </style>
  <rect x="10" y="10" width="80" height="50" class="svg20230623-4-task_purple"/>
  <rect x="90" y="10" width="60" height="50" class="svg20230623-4-task_blue"/>
  <rect x="150" y="10" width="30" height="50" class="svg20230623-4-task_orange"/>
  <rect x="180" y="10" width="50" height="50" class="svg20230623-4-task_blue"/>
  <rect x="230" y="10" width="60" height="50" class="svg20230623-4-task_purple"/>
  <rect x="10" y="70" width="100" height="50" class="svg20230623-4-task_orange"/>
  <rect x="110" y="70" width="80" height="50" class="svg20230623-4-task_purple"/>
  <rect x="190" y="70" width="90" height="50" class="svg20230623-4-task_orange"/>
</svg>
</div>

- purple ends later
- there is additional overhead (not illustrated)

---

# Use cases for concurrency

---

# Compilers (maybe)

<div align="center">
<svg xmlns="http://www.w3.org/2000/svg" id="svg20230623-11-1" width="100%" viewBox="0 0 800 220">
  <style>
    #svg20230623-11-1 {
      border: 1px solid #e8e8e8;
      background-color: #f5f5f5;
    }
    .svg20230623-11-t1 {
      font-family: sans-serif;
      font-size: 16px;
      text-anchor: middle;
      dominant-baseline: middle;
    }
    .svg20230623-11-l1 {
      stroke: #000000;
      stroke-width: 2;
      fill: none;
    }
    .svg20230623-11-l2 {
      stroke: #000000;
      stroke-width: 4;
      fill: #ffffff;
    }
    .svg20230623-11-task_neutral2 {
      stroke: #000000;
      stroke-width: 4;
      fill: #6ac3d9;
    }
  </style>
  <path class="svg20230623-11-l2" d="M 10 80 h 60 l 20 20 v 100 h -80 z"/>
  <line class="svg20230623-11-l1" x1="90" y1="140" x2="150" y2="140"/>
  <text class="svg20230623-11-t1" x="50" y="35">source</text>
  <rect x="150" y="80" width="80" height="120" class="svg20230623-11-task_neutral2"/>
  <line class="svg20230623-11-l1" x1="230" y1="140" x2="290" y2="140"/>
  <text class="svg20230623-11-t1" x="190" y="20">lexical</text>
  <text class="svg20230623-11-t1" x="190" y="50">analysis</text>
  <rect x="290" y="80" width="80" height="120" class="svg20230623-11-task_neutral2"/>
  <line class="svg20230623-11-l1" x1="370" y1="140" x2="430" y2="140"/>
  <text class="svg20230623-11-t1" x="330" y="20">syntactical</text>
  <text class="svg20230623-11-t1" x="330" y="50">analysis</text>
  <rect x="430" y="80" width="80" height="120" class="svg20230623-11-task_neutral2"/>
  <line class="svg20230623-11-l1" x1="510" y1="140" x2="570" y2="140"/>
  <text class="svg20230623-11-t1" x="470" y="20">data</text>
  <text class="svg20230623-11-t1" x="470" y="50">analysis</text>
  <rect x="570" y="80" width="80" height="120" class="svg20230623-11-task_neutral2"/>
  <line class="svg20230623-11-l1" x1="650" y1="140" x2="710" y2="140"/>
  <text class="svg20230623-11-t1" x="610" y="20">instruction</text>
  <text class="svg20230623-11-t1" x="610" y="50">generator</text>
  <path class="svg20230623-11-l2" d="M 710 80 h 60 l 20 20 v 100 h -80 z"/>
  <text class="svg20230623-11-t1" x="750" y="35">code</text>
</svg>
</div>

- Melvin Conway: Design of a separable transition-diagram compiler
- of Conway law fame: product design mirrors organisation structure
- motivation: single pass compiler in memory constraints environments, each
  "coroutine" can output zero or more than one results each time it's invoked
- in the meantime: better ways of designing a compiler

---

# Simulations

- Bjarne Stroustrup: [A Set of C++ Classes for Co−routine Style
  Programming.](https://www.softwarepreservation.org/projects/c_plus_plus/cfront/release_e/doc/ClassesForCoroutines.pdf)
  Bell Laboratories Computer Science Technical Report CSTR−90. November 1980.
- motivation: event driven simulations
- `task` base class used to represent a independent activity which:
  - suspends voluntarily
  - can be resumed, canceled
  - can wait, sleep
  - provides an `int` result and communicates with other `task`s (e.g. producer
    and consumer, server reading from a queue)
  - work is done in the derived class constructor
- one of the earliest libraries in C++ (think `complex` and `string` without
  templates), yet did not make it to the standard
- some of the problems it tries to solve turn out to be recurring:
  cancellation, time management, forking and joining, queues, etc.

---

# GUI

```cpp
BOOL bRet;

while( (bRet = GetMessage( &msg, hWnd, 0, 0 )) != 0)
{
  if (bRet == -1)
  {
    // handle the error and possibly exit
  }
  else
  {
    TranslateMessage(&msg); 
    DispatchMessage(&msg); 
  }
}
```

---

# GUI

- usually single threaded: a single dedicated UI thread
- the thread has a queue
- the thread is blocked waiting for a message from the queue
- when a message is returned, the thread processes it via a `switch` statements
- messages are added to the queue via `PostMessage` (from the same thread) or
  `PostThreadMessage` (from a different thread)
- there is also a special "quit" message

- GUIs show the usage of queue of work to manage concurrency, of a blocking
  function to get next piece of work, not necessarily in need of coroutines
  (often long background activities are scheduled on additional threads)

---

# Async IO

- motivation: C10K (1999)
- networking is often IO bound (wait for data to be sent or received)
- what's wrong with `WaitForMultipleObjects` (more later)
  - `O(N)` time complexity with the number of handles provided
  - similar `select` for Linux
- IO completion ports: it's a queue again (more later)
  - similar `kevent` for Linux
- (boost) ASIO
- file IO
- timers/events/registry monitoring
- one problem: thread(s) blocked using API to get data from the queue, can't
  have a thread check for work in multiple incompatible queue types
- Windows thread pools to unify work covered by IO completion ports e.g.
  networking, with work not covered via IO completion ports
- similar evolution on other OSes

---

# WaitForMultipleObjects

- when a thread calls `WaitForMultipleObjects`, the caller provides a set of
  objects it waits for
- for each object in the set, the OS has to atomically (thread safe) add this
  thread ID to a list associated to the object
- the thread is suspended

- when an object in the set is signaled, the OS finds the thread ID in the
  object's list
- the thread is scheduled to resume

- when the thread resumes
- for each object in the set, the OS has to atomically remove this thread ID
  from the list associated to the object
- `WaitForMultipleObjects` returns

- The steps above lead to `O(N)` time complexity with the number of objects
  provided, which is why `WaitForMultipleObjects` limits it to 64

---

# Completion port

- when a thread calls `GetQueuedCompletionStatus`
- it checks if work is queued (requires a lock)
- if not, it suspends, a single object needs to have this thread ID stored

- when an object associated with the completion port is signaled
- it's added to the queue
- the thread is scheduled to resume (if needed)

- when the thread resumes
- it picks work from the queue
- `GetQueuedCompletionStatus` return

- it solves the `O(N)` problem, work to queue/dequeue one item does not depend
  on the number of items in the queue
- the disadvantage is that most such queueing systems are incompatible, a
  thread is blocked on reading from a particular queue system

---

# Async IO

- network echo work with coroutine support

```cpp
task echo(socket s) {
  buffer buff;
  while (true) {
    std::size_t length = co_await read_some(s, buff);
    co_await write(s, buff, length);
  }
}
```

---

# Async IO

- without coroutines it's a lot of callbacks and manual memory management

```cpp
class session : public std::enable_shared_from_this<session>
{
  // ...
  void do_read()
  {
    auto self(shared_from_this());
    socket_.async_read_some(buff_/*...*/,
      [this, self](boost::system::error_code ec, std::size_t length) {
        do_write(length);
      });
  }

void do_write(std::size_t length)
  {
    auto self(shared_from_this());
    boost::asio::async_write(buff_/*...*/,
      [this, self](boost::system::error_code ec, std::size_t /*length*/) {
        do_read();
      });
  }
```

---

# Nanocoroutines

- motivation: is handle memory latencies for database JOINs
- CppCon 2018: G. Nishanov [“Nano-coroutines to the Rescue! (Using Coroutines
  TS, of Course)”](https://www.youtube.com/watch?v=j9tlJAqMV7U)

---

# Generator

```cpp
struct fib_state {
  int x_1 = 1;
  int x_2 = 0;
};

int next_fib(fib_state & state) {
  int val = state.x_1 + state.x_2;
  state.x_2 = state.x_1;
  state.x_1 = val;
  return val;
}

void foo() {
  fib_state state;
  while (true) {
    int x = next_fib(state);
    // use x
  }
}
```
---

# Generator

```cpp
generator fib() {
  int x_1 = 1;
  int x_2 = 0;
  while (true) {
    int val = x_1 + x_2;
    yield val;
    x_2 = x_1;
    x_1 = val;
  }
}

void foo() {
  for (int x: fib()) {
    // use x
  }
}
```

- `val` is `yield`ed before `x_2` and `x_1` are updated

---

# Generator

```cpp
std::generator<int> fib() {
  int x_1 = 1;
  int x_2 = 0;
  while (true) {
    int val = x_1 + x_2;
    co_yield val;
    x_2 = x_1;
    x_1 = val;
  }
}

void foo() {
  for (int x: fib()) {
    // use x
  }
}
```

---

# Exception-less mode

- e.g. for using in kernel code without using C++ exceptions
- this was important for Microsoft (that significantly drove towards C++
  coroutine adoptions)

---

# GPU work

- there is a lot of effort (e.g. by Nvidia) to make calculations work from C++
  (algorithms, coroutines, sender/receives etc.) compatible with "normal" CPU
  usage

- beware that choices made for a use case (e.g. GPU) might be not the right
  ones for another use case (e.g. async networking IO)

---

# Interaction with threads

- single thread simplifies a lot of things, but has limits of how much
  computation is available
- explicit multithreading
  - can a coroutine resume in a different thread?
  - `scoped_lock|lock_guard<std::mutex>` potential for misuse

---

# Timing matters/choices

- read operations might get more than what was requested (e.g. when request is
  less than data in the IP package). Subsequent reads:
  - could always queue the continuation (to allow fairness, at cost of
    additional work)
  - avoid queueing if data already available (maximise speed by avoiding work
    in this case)

- wait when_all(op1, op2, op3) can mean different things for different
  environments:
 - initiate all operations, the progress in parallel, return when the last one
   (by time) completes (e.g. op2)
 - initiate sequentially, progress is not parallel, return when the last one
   (in sequence) completes (i.e. op3)

---

# What are coroutines then?

---

# Function vs. coroutine

<div align="center">
<svg xmlns="http://www.w3.org/2000/svg" id="svg20230623-5-1" width="100%" viewBox="0 0 800 320">
  <style>
    #svg20230623-5-1 {
      border: 1px solid #e8e8e8;
      background-color: #f5f5f5;
    }
    .svg20230623-5-l1 {
      stroke: #000000;
      stroke-width: 2;
      fill: none;
    }
    .svg20230623-5-l2 {
      stroke: #000000;
      stroke-width: 2;
      fill: none;
      stroke-dasharray: 5;
    }
    .svg20230623-5-task_white {
      stroke: #000000;
      stroke-width: 4;
      fill: #ffffff;
    }
    .svg20230623-5-task_green {
      stroke: #000000;
      stroke-width: 4;
      fill: #c2b102;
    }
    .svg20230623-5-task_neutral2 {
      stroke: #000000;
      stroke-width: 4;
      fill: #6ac3d9;
    }
  </style>
  <rect x="10" y="10" width="80" height="300" class="svg20230623-5-task_white"/>
  <rect x="130" y="85" width="80" height="160" class="svg20230623-5-task_green"/>
  <path class="svg20230623-5-l1" d="M 50 30 v 70 h 120 v 65"/>
  <path class="svg20230623-5-l2" d="M 170 165 v 70 l -120 -125 v 180"/>
  <rect x="290" y="10" width="80" height="300" class="svg20230623-5-task_white"/>
  <rect x="410" y="85" width="80" height="160" class="svg20230623-5-task_neutral2"/>
  <path class="svg20230623-5-l1" d="M 330 30 v 70 h 120 v 20"/>
  <path class="svg20230623-5-l2" d="M 450 120 v 20 l -120 -30 v 55 l 120 -15 v 40 l -120 -15 v 35
    l 120 -10 v 35 l -120 -15 v 70"/>
</svg>
</div>

---

# Coroutines

<div align="center">
<svg xmlns="http://www.w3.org/2000/svg" id="svg20230623-6-1" width="100%" viewBox="0 0 800 320">
  <style>
    #svg20230623-6-1 {
      border: 1px solid #e8e8e8;
      background-color: #f5f5f5;
    }
    .svg20230623-6-l1 {
      stroke: #000000;
      stroke-width: 2;
      fill: none;
    }
    .svg20230623-6-l2 {
      stroke: #000000;
      stroke-width: 2;
      fill: none;
      stroke-dasharray: 5;
    }
    .svg20230623-6-task_white {
      stroke: #000000;
      stroke-width: 4;
      fill: #ffffff;
    }
    .svg20230623-6-task_green {
      stroke: #000000;
      stroke-width: 4;
      fill: #c2b102;
    }
    .svg20230623-6-task_neutral2 {
      stroke: #000000;
      stroke-width: 4;
      fill: #6ac3d9;
    }
  </style>
  <rect x="10" y="10" width="80" height="300" class="svg20230623-6-task_white"/>
  <rect x="130" y="85" width="80" height="160" class="svg20230623-6-task_green"/>
  <path class="svg20230623-6-l1" d="M 50 30 v 70 h 120 v 65"/>
  <path class="svg20230623-6-l2" d="M 170 165 v 70 l -120 -125 v 180"/>
  <rect x="290" y="10" width="80" height="300" class="svg20230623-6-task_white"/>
  <rect x="410" y="85" width="80" height="160" class="svg20230623-6-task_neutral2"/>
  <path class="svg20230623-6-l1" d="M 330 30 v 70 h 120 v 20"/>
  <path class="svg20230623-6-l2" d="M 450 120 v 20 l -120 -30 v 55 l 120 -15 v 40 l -120 -15 v 35
    l 120 -10 v 35 l -120 -15 v 70"/>
  <rect x="570" y="10" width="80" height="300" class="svg20230623-6-task_white"/>
  <rect x="690" y="85" width="80" height="160" class="svg20230623-6-task_neutral2"/>
  <path class="svg20230623-6-l1" d="M 610 30 v 70 h 120 v 5"/>
  <path class="svg20230623-6-l2" d="M 730 110 v 5 l 60 -10 v 30 l -60 -10 v 15 l -120 -30 v 55 h 60 l 60 -15 v 40
    l 60 -20 v 40 l -60 -20 l -60 -15 h -60 v 35
    l 120 -10 v 35 l -120 -15 v 70"/>
</svg>
</div>

---

# Stack

<div align="center">
<svg xmlns="http://www.w3.org/2000/svg" id="svg20230623-7-1" width="100%" viewBox="0 0 800 320">
  <style>
    #svg20230623-7-1 {
      border: 1px solid #e8e8e8;
      background-color: #f5f5f5;
    }
    .svg20230623-7-l1 {
      stroke: #000000;
      stroke-width: 2;
      fill: none;
    }
    .svg20230623-7-l2 {
      stroke: #000000;
      stroke-width: 2;
      fill: none;
      stroke-dasharray: 5;
    }
    .svg20230623-7-task_white {
      stroke: #000000;
      stroke-width: 4;
      fill: #ffffff;
    }
    .svg20230623-7-task_grey {
      stroke: #000000;
      stroke-width: 4;
      fill: #cccccc;
    }
    .svg20230623-7-task_green {
      stroke: #000000;
      stroke-width: 4;
      fill: #c2b102;
    }
    .svg20230623-7-task_neutral2 {
      stroke: #000000;
      stroke-width: 4;
      fill: #6ac3d9;
    }
  </style>
  <rect x="10" y="10" width="100" height="160" class="svg20230623-7-task_grey"/>
  <rect x="10" y="170" width="100" height="50" class="svg20230623-7-task_green"/>
  <rect x="10" y="220" width="100" height="80" class="svg20230623-7-task_white"/>
</svg>
</div>

---

# Stackful

<div align="center">
<svg xmlns="http://www.w3.org/2000/svg" id="svg20230623-8-1" width="100%" viewBox="0 0 800 320">
  <style>
    #svg20230623-8-1 {
      border: 1px solid #e8e8e8;
      background-color: #f5f5f5;
    }
    .svg20230623-8-l1 {
      stroke: #000000;
      stroke-width: 2;
      fill: none;
    }
    .svg20230623-8-l2 {
      stroke: #000000;
      stroke-width: 2;
      fill: none;
      stroke-dasharray: 5;
    }
    .svg20230623-8-task_white {
      stroke: #000000;
      stroke-width: 4;
      fill: #ffffff;
    }
    .svg20230623-8-task_grey {
      stroke: #000000;
      stroke-width: 4;
      fill: #cccccc;
    }
    .svg20230623-8-task_green {
      stroke: #000000;
      stroke-width: 4;
      fill: #c2b102;
    }
    .svg20230623-8-task_neutral2 {
      stroke: #000000;
      stroke-width: 4;
      fill: #6ac3d9;
    }
  </style>
  <rect x="10" y="10" width="100" height="210" class="svg20230623-8-task_grey"/>
  <rect x="10" y="220" width="100" height="80" class="svg20230623-8-task_white"/>
  <rect x="290" y="10" width="100" height="240" class="svg20230623-8-task_grey"/>
  <rect x="290" y="250" width="100" height="50" class="svg20230623-8-task_neutral2"/>
  <rect x="570" y="10" width="100" height="220" class="svg20230623-8-task_grey"/>
  <rect x="570" y="230" width="100" height="70" class="svg20230623-8-task_neutral2"/>
</svg>
</div>

---

# Stackless

<div align="center">
<svg xmlns="http://www.w3.org/2000/svg" id="svg20230623-9-1" width="100%" viewBox="0 0 800 320">
  <style>
    #svg20230623-9-1 {
      border: 1px solid #e8e8e8;
      background-color: #f5f5f5;
    }
    .svg20230623-9-l1 {
      stroke: #000000;
      stroke-width: 2;
      fill: none;
    }
    .svg20230623-9-l2 {
      stroke: #000000;
      stroke-width: 2;
      fill: none;
      stroke-dasharray: 5;
    }
    .svg20230623-9-task_white {
      stroke: #000000;
      stroke-width: 4;
      fill: #ffffff;
    }
    .svg20230623-9-task_grey {
      stroke: #000000;
      stroke-width: 4;
      fill: #cccccc;
    }
    .svg20230623-9-task_green {
      stroke: #000000;
      stroke-width: 4;
      fill: #c2b102;
    }
    .svg20230623-9-task_neutral2 {
      stroke: #000000;
      stroke-width: 4;
      fill: #6ac3d9;
    }
  </style>
  <rect x="10" y="10" width="100" height="210" class="svg20230623-9-task_grey"/>
  <rect x="10" y="220" width="100" height="80" class="svg20230623-9-task_white"/>
  <rect x="290" y="250" width="100" height="50" class="svg20230623-9-task_neutral2"/>
  <rect x="570" y="230" width="100" height="70" class="svg20230623-9-task_neutral2"/>
</svg>
</div>

---

# Duality

<div align="center">
<svg xmlns="http://www.w3.org/2000/svg" id="svg20230623-10-1" width="100%" viewBox="0 0 800 320">
  <style>
    #svg20230623-10-1 {
      border: 1px solid #e8e8e8;
      background-color: #f5f5f5;
    }
    .svg20230623-10-l1 {
      stroke: #000000;
      stroke-width: 2;
      fill: none;
    }
    .svg20230623-10-c1 {
      stroke: #000000;
      stroke-width: 2;
      fill: #ff36ab;
    }
    .svg20230623-10-c2 {
      stroke: #000000;
      stroke-width: 2;
      fill: #ff9bd5;
    }
    .svg20230623-10-c3 {
      stroke: #000000;
      stroke-width: 2;
      fill: #ffcdea;
    }
    .svg20230623-10-l2 {
      stroke: #000000;
      stroke-width: 2;
      fill: none;
      stroke-dasharray: 5;
    }
    .svg20230623-10-task_white {
      stroke: #000000;
      stroke-width: 4;
      fill: #ffffff;
    }
    .svg20230623-10-task_green {
      stroke: #000000;
      stroke-width: 4;
      fill: #c2b102;
    }
    .svg20230623-10-task_neutral2 {
      stroke: #000000;
      stroke-width: 4;
      fill: #6ac3d9;
    }
  </style>
  <rect x="10" y="10" width="80" height="300" class="svg20230623-10-task_white"/>
  <rect x="130" y="85" width="80" height="160" class="svg20230623-10-task_green"/>
  <path class="svg20230623-10-l1" d="M 50 30 v 70 h 120 v 65"/>
  <path class="svg20230623-10-l2" d="M 170 165 v 70 l -120 -125 v 180"/>
  <circle cx="50" cy="110" r="7" class="svg20230623-10-c1"/>
  <rect x="290" y="10" width="80" height="300" class="svg20230623-10-task_white"/>
  <rect x="410" y="85" width="80" height="160" class="svg20230623-10-task_neutral2"/>
  <path class="svg20230623-10-l1" d="M 330 30 v 70 h 120 v 20"/>
  <path class="svg20230623-10-l2" d="M 450 120 v 20 l -120 -30 v 55 l 120 -15 v 40 l -120 -15 v 35
    l 120 -10 v 35 l -120 -15 v 70"/>
  <circle cx="330" cy="110" r="7" class="svg20230623-10-c1"/>
  <circle cx="330" cy="175" r="7" class="svg20230623-10-c2"/>
  <circle cx="330" cy="220" r="7" class="svg20230623-10-c3"/>
  <rect x="570" y="250" width="100" height="50" class="svg20230623-10-task_neutral2"/>
</svg>
</div>

---

# Questions?