C++ error handling, let’s abuse the co_await operator

Introduction

Sometimes (very rarely :-p), errors may happen. It can be due to misuse from the user, it can be due to a system error, a corrupted, or a missing file. Errors can pop from everywhere. There are several ways to handle errors. In this article, we are going to see how coroutine may be used for error handling, so let’s abuse the co_await operator

Old ways to handle errors

One of the first ways to handle errors used (AFAIK) was the error code return. The idea is simple, you return OK when the function executes properly, else you return an error code, like OUT_OF_RANGE, FILE_NOT_EXIST

You ended with code like:

As expected, the code will write error! and 10.

The advantage of this way is that it is really explicit, you know which function can fail. A disadvantage is that there is no propagation of errors. You must treat error in the same place that you treat the correct path. Another problem is it can lead to severe problems if the client of your function does not check if it fails or not. Believe me, programmers are somewhat lazy, and they may forget to check the return value and they will process the result like if it was correct. For example, let’s imagine you developed an initialize() function, it returns fails, but you use the object not initialized. it will, sooner or later, lead to a severe failure.

Another way to process errors is the exception. When you detect an error, you throw the error, and when you want to process the error, you catch it. It solves the problems both of error propagation and the use of non initialized objects we saw prior. The code will look like that:

The code is shorter, and the error handling is done when you need it. However, it is difficult to know if the function f can fail if we don’t have the code of g(). We can doubt because f is not noexcept, but that’s all, and it does not give us so much information about the possible error.

A modern way for error-handling thanks to ADT

There is a proposal for an expected object for C++23. Basically, std::excpected is a template object which takes 2 arguments.

  1. The result type
  2. The error type

It is a sum-type, so it can contain either the result or the error. However, the std::expected way to handle errors will be a bit like the error code, you don’t get automatic propagation. However, you may use the functional approaches that simulate the error propagation:

The map function will be executed only if g(success) is not an error, if it is an error, the error will be propagated to the caller.

All the lambda thing is very good, works perfectly, is pretty_fast and readable. However, in some cases, it can become cumbersome.

In the rust language programming, we would write something like:

Note the presence of the operator ?. It means, if g(success) succeed, so continue the execution, else, stops the execution and propagates the error to the caller.

Did this story of stopping and continue the execution reminds you something?

Let’s abuse the co_await operator !

The objective will be to be able to write something like:

You can even imagine a macro try or TRY to make things even better :p. But be careful if you are using exceptions :).

Let’s design a simple Expected class.

I didn’t use reference qualified member for the sake of simplicity. However, in a production code, to have the best performance, you must use them to avoid useless copy etc.

I use a std::variant with std::monostate because we are going to need it later. So, basically, we have a class that represents either a result or an error. You have a function to ask which value is carried by the Expected and you have a function to retrieve the result or the error.

As we said before, Expected is meant to be used with coroutines. It must have a nested promise_type

The promise_type

We remind that the promise_type must have 5 member functions.

  1. get_return_object() which will return an expected
  2. return_value() / return_void() which will handle the co_return operator.
  3. initial_suspend and final_suspend that handle the beginning and the end of the coroutine
  4. unhandled_exception that handles unhandled exceptions.

In our example, unhandled_exception will do nothing for the sake of simplicity. initial_suspend and final_suspend will be of std::suspend_never because when we launch the function, we want it to not be paused, and when we exit the function, we expect everything to be cleared properly.

Let’s talk about the get_return_object() and return_value(). We are going to begin with return_value(). Its prototype will be something like void return_value(Expected result). We can write different overloads for Result and Error and their reference qualified friends, but for the sake of simplicity, again, I chose to have only the Expected overload :-).

We must do something with this result, we must set the current expected with this value. To do that, I decided to use a pointer on the current Expected instance.

For the get_return_object function, things are not that easy. You must be able to construct an expected without an error or a result. Moreover, you must initialize the pointer to the expected in the promise_type.

Then, I added a private constructor to the Expected object.

The promise_type is as we described prior.

However, be careful with your get_return_object function. Here it works because of guaranteed copy elision. If there was no elision, you will get a segmentation fault(in the best case) because the Expected address will not be the same 🙂

Our Expected object can be co_returned from a coroutine, but it can not be co_awaited . So, let’s abuse the co_await operator !

Awaiter

To make our Expected class awaitable, we must define an Awaiter class.

As a reminder, an awaiter must have three functions.

  1. await_ready: which returns a bool to know if we can continue the execution, or suspend it.
  2. await_resume: which returns the type wanted from co_await x.
  3. await_suspend: which is called when a coroutine is suspended.

The await_ready is really simple. If the expected is an error, we suspend, else, we continue. The await_resume function just returns the result. The await_suspend function is the most complicated! It is called when we have an error, it must give the error to the expected returned by get_current_object. Moreover, it must destroys the current coroutine.

Hence, here is the code for Awaiter class and the operator co_await:

Again, I do not manage reference qualified methods. You must do it in production code. Here is the full code if you want it.

Performance ?

It is purely one hypothesis, but I do believe that in the future, the compiler could be optimized out of this kind of code. Indeed, from cpp-reference, we can read :

  • The lifetime of the coroutine state is strictly nested within the lifetime of the caller, and
  • the size of coroutine frame is known at the call site

The first is obvious, the second I think yes, but I am not sure, that is why it is one hypothesis.

Thanks for reading :).

Thread pool with coroutines: Threads (1/3)

Introduction

In this little series of articles, we are going to see how to implement a thread pool usable with coroutines. This series will contain these articles :

  1. Creating a Thread
  2. Creating the pool
  3. Using future with the pool

The final objective will be to be able to write something like that:

Choice of implementation for the thread pool

We will use the well-known work-stealing algorithm inside our thread pool. It implies that each thread has its own task queue and threads can steal tasks from each other. It will lead to concurrency with shared variables between threads, hence, we must be careful with data races.

To deal with data races, I decided to make some homemade helpers inspired by the Rust programming language.

Mutex

Here is the first helper I have made. A mutex protects a resource from data race. So we can make a template class to protect the template argument. We use a callback to operate on a protected variable.

Why do I use a shared mutex? I use a shared mutex because multiple readers are not an issue.

Condition variable

What are the events that can occured within a thread?

  1. The thread can be requested to stop
  2. The thread can have a new task to perform

To not use CPU resources when the thread is not fed (i.e, there is no task to run), I decided to use a condition variable. The idea is simple, on the waiting thread, you wait for an event, and you go out of the wait function when the predicate is satisfied, and in another thread, you notify the condition variable to wake up.

Since a condition variable is generally used with a Mutex, I decided to join them together through inheritance. Hence, a condition variable behaves like a mutex but can be waited on also.

You may wonder what is std::stop_token, it is simply a C++20 feature provided by std::jthread that avoid user to wait on an atomic boolean. Put it simply, a std::jthread, when it is destroyed, do two things:

  1. It calls request_stop to a std::stop_source that will notify the std::stop_token
  2. It joins the thread

An Awaiter

With coroutines, the task will not be a function, but a coroutine_handle which will be resumed. Hence, we need to have an object that manages this handle.

One will observe that we destroy the coroutine only if it was not resumed. It is a movable only type.

A thread safe queue

Now that we have our Awaiter object, we must push them into a thread-safe queue. The new tasks will be pushed into the queue, and the thread pool will pop them one by one.

Since the queue may be empty, the pop operation can return nothing, represented by a std::nullopt.

We have 3 operations possible.

  1. Push: this operation enqueue a new task and notify the condition variable
  2. Pop: This operation deque a task to be executed in the current thread.
  3. Wait for an element: This operation will make the current thread idle until we got a new task (notified by the push function)

The thread

It is time to design our thread class.

The thread class will be designed over the std::jthread class. It will also embed a thread-safe queue of Awaiters.

Thus, we can lay:

First, we can imagine what operation our thread must do:

  1. Adding tasks
  2. Schedule operation (thanks to the co_await operator)
  3. A background infinite loop that will pop tasks and execute them.

There is nothing complicated, the run methods just wait for an element, pop awaiters, execute them if they are valid and that’s all.

The co_await operator will just push the coroutine_handle to the thread thanks to the Awaitable object.

Using this thread

We schedule the operations thanks to the co_await operator.
Here is an example, the task is a basic promise that never suspends. It means that the coroutine frame is destroyed at the end of the function.

The operation behind the first co_await runs on the first thread, the operation behind the second co_await runs on the second thread. Really simple.

Conclusion

We finished the first article about creating a thread pool using coroutines. We introduced some utility classes and designed a concurrent queue. If you want to try, you can find a full code here.

Thanks to  Nir Friedman to help me design mutex and condition variable in a better way :).

Blog talking about 3D rendering, Qt and C++