c++20 协程本质_资讯

c++20 协程本质

创始人

2024-05-30 06:10:26

0次

c++20 协程本质

背景：

最近因项目关系，web端，js异步调用，发现跟本门的C++20 还是有些不一样的，本文主要从另外一个角度来看

什么是协程

协程是能暂停执行以在之后恢复的函数。协程是无栈的：它们通过返回到调用方暂停执行，并且恢复执行所需的数据与栈分离存储。这样就可以编写异步执行的顺序代码（例如不使用显式的回调来处理非阻塞输入/输出），还支持作用于惰性计算的无限序列上的算法及其他用途。

腾讯用c语言实现了一个有栈携程，libco，有兴趣的同学可以看下，跟本文讲的协程不太一样。

当一个函数中出现 co_yeild, co_wait, co_return，它就是一个协程

了解一些概念

承诺（promise）对象，从协程内部操纵。协程通过此对象提交其结果或异常。

协程句柄 (coroutine handle)，从协程外部操纵。这是用于恢复协程执行或销毁协程帧的非拥有柄

co_yeild, co_wait, co_return ,可以参照https://zh.cppreference.com/w/cpp/language/coroutines里边自行看下，

我们主要分析协程在编译后会变成什么样子

示例代码

C++
#include
#include
#include
#include

struct Generator {

  class ExhaustedException : std::exception {};

  struct promise_type {
    int value;
    bool is_ready = false;

    std::suspend_always initial_suspend() { return {}; };

    std::suspend_always final_suspend() noexcept { return {}; }

    std::suspend_always yield_value(int value) {
      this->value = value;
      is_ready = true;
      return {};
    }

    void unhandled_exception() {

    }

    Generator get_return_object() {
      return Generator{std::coroutine_handle::from_promise(*this)};
    }

    void return_void() {}
  };

  std::coroutine_handle handle;

  bool has_next() {
    if (handle.done()) {
      return false;
    }

    if (!handle.promise().is_ready) {
      handle.resume();
    }

    if (handle.done()) {
      return false;
    } else {
      return true;
    }
  }

  int next() {
    if (has_next()) {
      handle.promise().is_ready = false;
      return handle.promise().value;
    }

  }

  explicit Generator(std::coroutine_handle handle) noexcept
      : handle(handle) {}

  ~Generator() {
    if (handle) handle.destroy();
  }
};

Generator fibonacci() {
  co_yield 0;
  co_yield 1;

  int a = 0;
  int b = 1;
  while (true) {
    co_yield a + b;
    b = a + b;
    a = b - a;
  }
}

int main() {
  auto generator = fibonacci();
  for (int i = 0; i < 10; ++i) {
    if (generator.has_next()) {
      std::cout << generator.next() << " " << std::endl;
    } else {
      break;
    }
  }
  return 0;
}

原示例很简单，斐波那契数列，考虑以下问题：

上文中的fibonacci方法中，int a; int b 存在哪里，是栈空间还是堆空间

为什么fibonacci方法返回的Generator里边会定义struct promise_type 内部结构体

协程的帧到底长什么样子的

协程挂起与恢复的本质是什么

带着上边疑问，接下来就开始分析下，编译器把这块代码转成什么样子的

C++

struct __fibonacciFrame
{
  void (*resume_fn)(__fibonacciFrame *);
  void (*destroy_fn)(__fibonacciFrame *);
  std::__coroutine_traits_impl::promise_type __promise;
  int __suspend_index;
  bool __initial_await_suspend_called;
  int a;
  int b;
  std::suspend_always __suspend_71_11;
  std::suspend_always __suspend_72_3;
  std::suspend_always __suspend_73_3;
  std::suspend_always __suspend_78_5;
  std::suspend_always __suspend_71_11_1;
};

Generator fibonacci()
{
  /* Allocate the frame including the promise */
  __fibonacciFrame * __f = reinterpret_cast<__fibonacciFrame *>(operator new(__builtin_coro_size()));
  __f->__suspend_index = 0;
  __f->__initial_await_suspend_called = false;

  /* Construct the promise. */
  new (&__f->__promise)std::__coroutine_traits_impl::promise_type{};

  /* Forward declare the resume and destroy function. */
  void __fibonacciResume(__fibonacciFrame * __f);
  void __fibonacciDestroy(__fibonacciFrame * __f);

  /* Assign the resume and destroy function pointers. */
  __f->resume_fn = &__fibonacciResume;
  __f->destroy_fn = &__fibonacciDestroy;

  /* Call the made up function with the coroutine body for initial suspend.
     This function will be called subsequently by coroutine_handle<>::resume()
     which calls __builtin_coro_resume(__handle_) */
  __fibonacciResume(__f);


  return __promise.get_return_object();
}

/* This function invoked by coroutine_handle<>::destroy() */
void __fibonacciDestroy(__fibonacciFrame * __f)
{
  /* destroy all variables with dtors */
  __f->~__fibonacciFrame();
  /* Deallocating the coroutine frame */
  operator delete(__builtin_coro_free(static_cast(__f)));
}

方便分析，上边代码已经删除了一部分，首先我们先回答第一个问题，这两个变量存放位置，

struct __fibonacciFrame 里边有int a; int b;两个成员，在fibonacci()，可以看到使用了new 关键字分配对象，也就是说int a；int b；被编译器放到堆里边了，

第二个问题：

为什么要定义struct promise_type，通过上边的代码也可以看出来， new (&__f->__promise) std::__coroutine_traits_impl::promise_type{}; 萃取机已经明确要求，里边要含有promise_type, 并且这个里边要有明确的几个协程必备的方法定义。另外通过__promise.get_return_object()可以构建Generator 对象，

第三个问题：

协程帧的样子就是struct __fibonacciFrame这个里边定义的，包含协程恢复与销毁的方法

第四个问题：

协程挂起与恢复，本质上讲就是函数调用，可以看下下边代码，协程恢复本质上就是标记一个值，每次调用的时候根据这个值，goto 到指定的代码位置，协程里边局部成员都保存在堆里边了，可以直接使用，

C++
/* This function invoked by coroutine_handle<>::resume() */
void __fibonacciResume(__fibonacciFrame * __f)
{
  try
  {
    /* Create a switch to get to the correct resume point */
    switch(__f->__suspend_index) {
      case 0: break;
      case 1: goto __resume_fibonacci_1;
      case 2: goto __resume_fibonacci_2;
      case 3: goto __resume_fibonacci_3;
      case 4: goto __resume_fibonacci_4;
    }

    /* co_await insights.cpp:71 */
    __f->__suspend_71_11 = __f->__promise.initial_suspend();
    if(!__f->__suspend_71_11.await_ready()) {
      __f->__suspend_71_11.await_suspend(std::coroutine_handle::from_address(static_cast(__f)).operator coroutine_handle());
      __f->__suspend_index = 1;
      __f->__initial_await_suspend_called = true;
      return;
    }

    __resume_fibonacci_1:
    __f->__suspend_71_11.await_resume();

    /* co_yield insights.cpp:72 */
    __f->__suspend_72_3 = __f->__promise.yield_value(0);
    if(!__f->__suspend_72_3.await_ready()) {
      __f->__suspend_72_3.await_suspend(std::coroutine_handle::from_address(static_cast(__f)).operator coroutine_handle());
      __f->__suspend_index = 2;
      return;
    }

    __resume_fibonacci_2:
    __f->__suspend_72_3.await_resume();

    /* co_yield insights.cpp:73 */
    __f->__suspend_73_3 = __f->__promise.yield_value(1);
    if(!__f->__suspend_73_3.await_ready()) {
      __f->__suspend_73_3.await_suspend(std::coroutine_handle::from_address(static_cast(__f)).operator coroutine_handle());
      __f->__suspend_index = 3;
      return;
    }

    __resume_fibonacci_3:
    __f->__suspend_73_3.await_resume();
    __f->a = 0;
    __f->b = 1;
    while(true) {

      /* co_yield insights.cpp:78 */
      __f->__suspend_78_5 = __f->__promise.yield_value(__f->a + __f->b);
      if(!__f->__suspend_78_5.await_ready()) {
        __f->__suspend_78_5.await_suspend(std::coroutine_handle::from_address(static_cast(__f)).operator coroutine_handle());
        __f->__suspend_index = 4;
        return;
      }

      __resume_fibonacci_4:
      __f->__suspend_78_5.await_resume();
      __f->b = (__f->a + __f->b);
      __f->a = (__f->b - __f->a);
    }

    goto __final_suspend;
  } catch(...) {
    if(!__f->__initial_await_suspend_called) {
      throw ;
    }

    __f->__promise.unhandled_exception();
  }

  __final_suspend:

  /* co_await insights.cpp:71 */
  __f->__suspend_71_11_1 = __f->__promise.final_suspend();
  if(!__f->__suspend_71_11_1.await_ready()) {
    __f->__suspend_71_11_1.await_suspend(std::coroutine_handle::from_address(static_cast(__f)).operator coroutine_handle());
  }

  ;
}

协程恢复就更好理解了，

C++
if(!__f->__suspend_73_3.await_ready()) {
      __f->__suspend_73_3.await_suspend(std::coroutine_handle::from_address(static_cast(__f)).operator coroutine_handle());
      __f->__suspend_index = 3;
      return;
    }

await_ready return false，就直接进入里边，然后就return了，很好理解

总结：

通过上边的理解，我们可以看到协程本质上还是函数调用，利用goto语句来实现协程挂起与恢复

词库加载错误:未能找到文件“E:\highferrum_mysql\Configuration\Dict_Stopwords.txt”。

上一篇：2023年品牌惊蛰节气海报赏析

下一篇：2020最火爆小本创业摆摊项目儿童摆摊小本创业项目最火摆摊创业小项目

c++20 协程本质

相关内容

热门资讯