introduction

Cet article est une traduction d'un chapitre du livre de Rainer Grimm, Concurrency with Modern C ++ , qui est une version plus raffinée et plus complète de l' article sur son site Web . Puisque toute la traduction ne rentre pas dans le cadre de cet article, en fonction de la réaction à la publication, je posterai le reste.

Coroutines

Les coroutines sont des fonctions qui peuvent suspendre ou reprendre leur exécution tout en conservant leur état. L'évolution des fonctions en C ++ a fait un pas en avant. Coroutinesle plus susceptible d'inclure est entré en C ++ 20.

L'idée des coroutines, introduite comme nouvelle dans C ++ 20, est assez ancienne. Le concept de coroutine a été proposé par Melvin Conway . Il a utilisé ce concept dans sa publication de conception de compilateur de 1963. Donald Knuth a qualifié les procédures de cas particulier de coroutines. Parfois, il faut du temps pour que telle ou telle idée soit acceptée.

Avec de nouveaux mots clés co_awaitet co_yieldC ++ 20, il élargit le concept d'exécution de fonction en C ++ avec deux nouveaux concepts.

Grâce à lui co_await expression, il devient possible de suspendre et de reprendre l'exécution expression. Lorsqu'il est utilisé co_await expressiondans une fonction, l' funcappel n'est auto getResult = func()pas bloquant si le résultat de cette fonction n'est pas disponible. Au lieu d'un blocage gourmand en ressources, une attente respectueuse des ressources est effectuée.

co_yield expressionvous permet d'implémenter des fonctions de générateur. Les générateurs sont des fonctions qui renvoient une nouvelle valeur à chaque appel suivant. La fonction de générateur est similaire aux flux de données à partir desquels des valeurs peuvent être extraites. Les flux de données peuvent être infinis. Ainsi, ces concepts sont fondamentaux pour l'évaluation paresseuse en C ++.

Fonctions du générateur

. getNumbers begin end inc. begin end, inc .

// greedyGenerator.cpp
#include <iostream>
#include <vector>

std::vector<int> getNumbers(int begin, int end, int inc = 1) {
    std::vector<int> numbers; // (1)
    for (int i = begin; i < end; i += inc) {
        numbers.push_back(i);
    }
    return numbers;
}

int main() {
    const auto numbers = getNumbers(-10, 11);
    for (auto n : numbers) {
        std::cout << n << " ";
    }
    std::cout << "\n";

    for (auto n : getNumbers(0, 101, 5)) {
        std::cout << n << " ";
    }
    std::cout << "\n";
}

, getNumbers , std::iota C++11.

, :

$ ./greedyGenerator
-10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 
0 5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 

. -, numbers (. (1) ) . 5 1000 . -, getNumbers .

// lazyGenerator.cpp
#include <iostream>
#include <vector>

generator<int> generatorForNumbers(int begin, int inc = 1) {
    for (int i = begin; ; i += inc) { // (4)
        co_yield i; // (3)
    }
}

int main() {
    const auto numbers = generatorForNumbers(-10); // (1)
    for (int i = 1; i <= 20; ++i) { // (5)
        std::cout << numbers << " ";
    }
    std::cout << "\n";

    for (auto n : generatorForNumbers(0, 5)) { // (2)
        std::cout << n << " ";
    }
    std::cout << "\n";
}

: , .. . .

, getNumbers greedyGenerator.cpp std::vector<int>, generatorForNumbers lazyGenerator.cpp generator. numbers (1) generatorForNumbers(0, 5) (2) . Range-based for . , i co_yield i (. (3)) . , .

generatorForNumbers(0, 5) (. (2)) (just-in-place usage).

. generatorForNumbers , for (4) . , .., , (5) . , , (2) .

- . - , , , . , , . , .

C++20 , (first-class) (stackless).

. , .

. , .

. . (resumable functions).

.

:

• ( ).
• , .
• .
• c , , , , .
• .

, . , - 1MB Windows 2MB Linux.

• co_return
• co_await
• co_yield
• co_await expression range-based for

return . (auto), ().

, constexpr , , main .

proposal N4628.

co_return, co_yield co_await

co_return .

co_yield . generator<int> generatorForNumbers(int begin, int inc = 1) generator<int> promise p , co_yield i co_await p.yield_value(i).co_yield i . .

co_await , . exp co_await exp , , ( awaitables). exp , : await_ready, await_suspend await_resume.

C++20 2 awaitables: std::suspend_always std::suspend_never.

std::suspend_always

struct suspend_always {
    constexpr bool await_ready() const noexcept { return false; }
    constexpr void await_suspend(coroutine_handle<>) const noexcept {}
    constexpr void await_resume() const noexcept {}
};

, awaitable std::suspend_always , await_ready false. std::suspend_never.

std::suspend_never

struct suspend_never {
    constexpr bool await_ready() const noexcept { return true; }
    constexpr void await_suspend(coroutine_handle<>) const noexcept {}
    constexpr void await_resume() const noexcept {}
};

co_await .

Acceptor acceptor{443};
while (true) {
    Socket socket = acceptor.accept();          // blocking
    auto request = socket.read();               // blocking
    auto response = handleRequest(request);
    socket.write(response);                     // blocking
}

. 443 , , . .

co_await .

Acceptor acceptor{443};
while (true) {
    Socket socket = co_await acceptor.accept();
    auto request = co_await socket.read();
    auto response = handleRequest(request);
    co_await socket.write(response);
}

20 , . .

: promise , handle frame .

Promise .

Handle handle frame .

Frame , . promise , , (suspention point), , , .

:

1. .
2. frame .

workflow

co_return co_yield co_await .

{
    Promise promise;
    co_await promise.initial_suspend();
    try {
        < >
    } catch (...) {
        promise.unhandled_exception();
    }
FinalSuspend:
    co_await promise.final_suspend();
}

Workflow :

• 
  
  
  • frame .
  • frame .
  • promise promise.
  • promise.get_return_object() handle . .
  • promise.initial_suspend() co_await . promise suspend_never suspend_always .
  • co_await promise.initial_suspend()
• 
  
  
  • promise.get_return_object()
• co_return
  
  
  • promise.return_void() co_return co_return expression, expression void
  • appelé promise.return_value(expression)à co_return expression, où expressionest de type autre quevoid
  • supprime toute la pile de variables créées
  • résultats appelés promise.final_suspend()et attendusco_await
• La coroutine est détruite (via la complétion via co_return, une exception non gérée, ou via le handle de coroutine)
  
  
  • le destructeur de l'objet de promesse est appelé
  • le destructeur des paramètres de la fonction est appelé
  • libère la mémoire utilisée par la trame coroutine
  • passer l'exécution à l'appelant

Lorsque la coroutine se termine par une exception non gérée, ce qui suit se produit:

• l'exception est interceptée et appelée promise.unhandled_exception()depuis le bloc catch
• appelé promise.final_suspend()et attendu co_awaitrésultat

Partie 2