In modern C++, coroutines have become an important feature that helps in writing more efficient and readable asynchronous code. Coroutines provide a way to suspend and resume the execution of a function, allowing for better handling of tasks that involve waiting for I/O or other time-consuming operations.

What is a Coroutine?

A coroutine is a function that can be suspended and resumed at specific points during its execution. Unlike regular functions, coroutines can yield their execution, allowing other code to run in the meantime. This makes them well-suited for handling asynchronous tasks without blocking the main thread.

The Coroutine State Machine

Under the hood, coroutines in C++ are implemented using a technique called the coroutine state machine. The state machine is responsible for keeping track of the coroutine’s current state, and when to suspend and resume its execution.

At a high level, the coroutine state machine is a compiler-generated construct that transforms a coroutine function into a stateful object. This object maintains the state of the coroutine and handles the suspending and resuming mechanisms.

How Coroutines Work

When a coroutine function is invoked, it returns a special object called a coroutine handle. This handle can be used to control the execution of the coroutine. By calling the resume() function on the handle, the coroutine starts executing. When the coroutine reaches a point where it can suspend its execution, it yields control back to the caller and returns a special value called a promise. The promise contains information about the coroutine’s state at the point of suspension.

When the coroutine is resumed again using the resume() function, it picks up from the point where it left off and continues execution until it reaches the next suspension point. This back-and-forth communication between the coroutine and the caller enables efficient asynchronous programming.

Example: Coroutine State Machine in C++

#include <iostream>
#include <experimental/coroutine>

class CoroutineState {
  bool isCompleted = false;

public:
  bool IsCompleted() const {
    return isCompleted;
  }

  std::experimental::suspend_never initial_suspend() {
    return {};
  }

  std::experimental::suspend_always final_suspend() noexcept {
    isCompleted = true;
    return {};
  }
};

class MyCoroutine {
public:
  struct promise_type {
    MyCoroutine get_return_object() {
      return MyCoroutine{CoroutineState{}};
    }

    std::experimental::suspend_always initial_suspend() const noexcept {
      return {};
    }

    std::experimental::suspend_never final_suspend() const noexcept {
      return {};
    }

    void return_void() {}

    void unhandled_exception() {}
  };

  MyCoroutine(CoroutineState state) : state(state) {}

  bool resume() {
    return !state.IsCompleted();
  }

  void operator()() {
    while (resume()) {
      std::cout << "Coroutine is running..." << std::endl;
    }
    std::cout << "Coroutine finished." << std::endl;
  }

private:
  CoroutineState state;
};

int main() {
  MyCoroutine coroutine{};
  coroutine();
  return 0;
}

In this example, we define a simple coroutine using the new C++20 coroutine syntax. The MyCoroutine class represents our coroutine, and the CoroutineState class handles the suspension and resumption of the coroutine.

When the main() function is executed, a new instance of MyCoroutine is created, and the operator() function is called. This starts the execution of the coroutine, and it enters the loop, printing the message “Coroutine is running…” repeatedly. The coroutine will continue running until it completes, which is determined by the isCompleted variable.

The CoroutineState class provides the necessary suspend and resume mechanisms. It returns the appropriate suspend types and handles the completion state of the coroutine.

Conclusion

Understanding the coroutine state machine is crucial in harnessing the power of coroutines for writing efficient and readable asynchronous code in C++. By leveraging the suspend and resume mechanisms provided by the state machine, developers can write more concise and manageable code. With the addition of coroutines in C++20, handling asynchronous tasks has become more intuitive and less error-prone.

#cpp #coroutines