Понимание примера возобновляемых функций в предложении N3650 для C++1y

Ключевое слово await не эквивалентно вызову get для будущего. Вы можете посмотреть на это примерно так, предположим, вы начинаете с этого:

future<T> complex_function()
{
     do_some_stuff();
     future<Result> x = await some_async_operation();
     return do_some_other_stuff(x);
}

Это функционально более или менее похоже на

future<T> complex_function()
{
     do_some_stuff();
     return some_async_operation().then([=](future<Result> x) {
         return do_some_other_stuff(x);
     });
}

Обратите внимание, более или менее, поскольку есть некоторые последствия для управления ресурсами, переменные, созданные в do_some_stuff, не должны быть скопированы для выполнения do_some_other_stuff, как это будет делать лямбда-версия.

Второй вариант делает более понятным, что произойдет при вызове.

1. do_some_stuff() будет вызываться синхронно при вызове complex_function.
2. some_async_operation вызывается асинхронно и приводит к будущему. Точный момент выполнения этой операции зависит от вашей фактической реализации асинхронного вызова, это может быть немедленно, когда вы используете потоки, это может быть всякий раз, когда вызывается .get(), когда вы используете отложенное выполнение.
3. Мы не выполняем do_some_other_stuff сразу, а привязываем его к будущему, полученному на шаге 2. Это означает, что его можно выполнить, как только будет готов результат из some_async_operation, но не раньше. Кроме того, его момент выполнения определяется временем выполнения. Если реализация будет просто обертывать предложение then, это означает, что она унаследует политику исполнителя/запуска родительского будущего (согласно N3558).
4. Функция возвращает последнее будущее, которое представляет конечный результат. Обратите внимание, что это НЕОБХОДИМО в будущем, так как часть тела функции выполняется асинхронно.

Более полный пример (надеюсь, правильный):

future<void> forwardMsgs(istream& streamR, ostream& streamW) async
{
    char buf[512];
    int cnt = 0;
    do {
       cnt = await streamR.read(512, buf);
       if (cnt == 0)
          break;
       cnt = await streamW.write(cnt, buf);
    } while (cnt > 0);
}

future<void> fut = forwardMsgs(myStreamR, myStreamW);

/* do something */

fut.get();

Важный момент (цитата из проекта):

После приостановки возобновляемая функция может быть возобновлена ​​логикой планирования среды выполнения и в конечном итоге завершит свою логику, после чего она выполнит оператор возврата (явный или неявный) и установит значение результата функции в заполнителе.

и:

Возобновляемая функция может продолжать выполнение в другом потоке после возобновления после приостановки ее выполнения.

То есть поток, который первоначально вызвал forwardMsgs, может вернуться в любой из точек приостановки. Если да, то во время строки /* do something */ код внутри строки forwardMsgs может выполняться другим потоком, даже если функция была вызвана "синхронно".

Этот пример очень похож на

future<void> fut = std::async(forwardMsgs, myStreamR, myStreamW);

/* do something */

fut.get();

Разница в том, что возобновляемая функция может выполняться разными потоками: другой поток может возобновить выполнение (возобновляемой функции) после каждой точки возобновления/приостановки.

Я думаю, что идея в том, что вызовы streamR.read() и streamW.write() являются асинхронными операциями ввода-вывода и возвращают фьючерсы, которые автоматически ожидаются выражениями await.

Таким образом, эквивалентная синхронная версия должна была бы вызвать future::get() для получения результатов, например.

int cnt = 0;
do {
   cnt = streamR.read(512, buf).get();
   if (cnt == 0)
      break;
   cnt = streamW.write(cnt, buf).get();
} while (cnt > 0);

Вы правильно заметили, что здесь нет параллелизма. Однако в контексте возобновляемой функции await делает поведение отличным от приведенного выше фрагмента. При достижении await функция вернет future, поэтому вызывающая функция может продолжать работу без блокировки, даже если возобновляемая функция заблокирована на await в ожидании какого-либо другого результата (например, в этом случае вызовы read() или write() для завершения .) Возобновляемая функция может возобновить работу в асинхронном режиме, поэтому результат становится доступным в фоновом режиме, пока вызывающий объект делает что-то еще.

Вот правильный перевод примера функции, чтобы не использовать ожидание:

struct Copy$StackFrame {
  promise<void> $result;
  input_stream& streamR;
  output_stream& streamW;
  int cnt;
  char buf[512];
};
using Copy$StackPtr = std::shared_ptr<Copy$StackFrame>;

future<void> Copy(input_stream& streamR, output_stream& streamW) {
  Copy$StackPtr $stack{ new Copy$StackFrame{ {}, streamR, streamW, 0 } };
  future<int> f$1 = $stack->streamR.read(512, stack->buf);
  f$1.then([$stack](future<int> f) { Copy$Cont1($stack, std::move(f)); });
  return $stack->$result.get_future();
}

void Copy$Cont1(Copy$StackPtr $stack, future<int> f$1) {
  try {
    $stack->cnt = f$1.get();
    if ($stack->cnt == 0) {
      // break;
      $stack->$result.set_value();
      return;
    }
    future<int> f$2 = $stack->streamW.write($stack->cnt, $stack->buf);
    f$2.then([$stack](future<int> f) { Copy$Cont2($stack, std::move(f)); });
  } catch (...) {
    $stack->$result.set_exception(std::current_exception());
  }
}

void Copy$Cont2(Copy$StackPtr $stack, future<int> f$2) {
  try {
    $stack->cnt = f$2.get();
    // while (cnt > 0)
    if (cnt <= 0) {
      $stack->$result.set_value();
      return;
    }
    future<int> f$1 = $stack->streamR.read(512, stack->buf);
    f$1.then([$stack](future<int> f) { Copy$Cont1($stack, std::move(f)); });
  } catch (...) {
    $stack->$result.set_exception(std::current_exception());
  }
}

Как видите, преобразование компилятора здесь довольно сложное. Ключевым моментом здесь является то, что, в отличие от версии get(), исходная версия Copy возвращает свое будущее, как только был сделан первый асинхронный вызов.

У меня та же проблема со значением разницы между этими двумя примерами кода. Давайте перепишем их немного, чтобы быть более полными.

    // Having two functions
    future<void> f (istream&streamR, ostream&streamW) async
    {  int cnt = 0;
       do {
          cnt = await streamR.read(512, buf);
          if (cnt == 0)
             break;
          cnt = await streamW.write(cnt, buf);
       } while (cnt > 0);
    }
    void g(istream&streamR, ostream&streamW)
    {  int cnt = 0;
       do {
          cnt = streamR.read(512, buf).get();
          if (cnt == 0)
             break;
          cnt = streamW.write(cnt, buf).get();
       } while (cnt > 0);
    }
    // what is the difference between
    auto a = f(streamR, streamW);
    // and 
    auto b = async(g, streamR, streamW);

Вам все еще нужно по крайней мере три стопки. В обоих случаях основной поток не блокируется. Является ли это предположением, что await будет реализовано компилятором более эффективно, чем future‹>:get()?. Теперь можно использовать тот, что без await.

Спасибо, Адам Зелински.