<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>C&#43;&#43;20 on 菜菜博士</title>
    <link>https://microcai.org/tags/c&#43;&#43;20.html</link>
    <description>Recent content in C&#43;&#43;20 on 菜菜博士</description>
    <generator>Hugo</generator>
    <language>zh-cn</language>
    <lastBuildDate>Fri, 04 Oct 2024 00:00:00 +0800</lastBuildDate>
    <atom:link href="https://microcai.org/tags/c++20/feed.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>µcoro 介绍</title>
      <link>https://microcai.org/2024/10/04/deep-into-cpp20-coroutine.html</link>
      <pubDate>Fri, 04 Oct 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/10/04/deep-into-cpp20-coroutine.html</guid>
      <description>&lt;h1 id=&#34;什么是-µcoro-ucoro-actions-workflow&#34;&gt;什么是 µcoro (ucoro) &lt;a href=&#34;https://github.com/avplayer/ucoro/actions&#34;&gt;&lt;img alt=&#34;actions workflow&#34; loading=&#34;lazy&#34; src=&#34;https://github.com/avplayer/ucoro/actions/workflows/ci.yml/badge.svg&#34;&gt;&lt;/a&gt;&lt;/h1&gt;
&lt;p&gt;µcoro 是一个最小化的c++20协程库。精简到不能再删一行代码。&lt;/p&gt;
&lt;h2 id=&#34;什么是-c20协程&#34;&gt;什么是 c++20协程&lt;/h2&gt;
&lt;p&gt;要理解 c++20 协程，首先要理解 无栈协程。 要理解无栈协程，首先要理解“调用链”。&lt;/p&gt;
&lt;h3 id=&#34;调用链&#34;&gt;调用链&lt;/h3&gt;
&lt;p&gt;函数，是被“调用”的。函数 A 调用 函数 B, 函数 B 再调用 函数 C。意思就是当 C 执行完工作，它返回就会回到 B 函数里调用C的那个地方。然后继续执行。
B 函数返回的时候， 它会返回 A 函数里调用B的那个地方。&lt;/p&gt;
&lt;p&gt;这种链试的返回控制流，就是调用链。&lt;/p&gt;
&lt;p&gt;在线程里，调用链是存储在栈上的。在函数返回的地方，编译器生成 ret 指令。而 ret 指令的执行步骤，就是从栈指针获取返回的目标地址。然后将栈指针退行并跳转到目标地址。
现代的调试器，都能在暂停代码执行的时候，检查栈内存，从而获取调用链。&lt;/p&gt;
&lt;p&gt;而有栈协程，就是指多个 “栈” 共享一个内核调度单元——线程。多个协程之间进行切换，实质上就是直接切换了 栈。而切换栈，是一个主动操作，而不是像线程那样由内核抢占式调度。
所以协程又被成为协作式多任务。&lt;/p&gt;
&lt;p&gt;在无栈协程里， 调用链并不存储于栈上。当 协程函数C 完成任务要返回 B, 控制流程会在另外的地方找到它的调用者B,然后跳转到B继续执行。
如果使用调试器，那么调试器按传统的方式找调用栈，在函数C里下断点，也看不到B和A的调用帧。 函数C，函数B，函数A在调试器里看，永远都是由一种复杂的“协程调度器”代码调用的。
如果非要调试 C 返回B 的过程，会发现 C 的代码会先返回到内部的某种“协程调度器“然后紧接着进入 函数B. 而且 B 函数明明是被框架调用的，但是并不会从头执行，而是在上次挂起的地方继续。所谓上次刮起的地方，实际上这个地方就是安排了对C的调用。&lt;/p&gt;
&lt;p&gt;最简单的实现一个 无栈协程 的方式，就是写闭包。在闭包里存储上次挂起的位置。下次执行函数的时候，就从挂起位置继续。可以使用状态机很容易就实现。&lt;/p&gt;
&lt;p&gt;只不过，用手写状态机实现的闭包模拟的无栈协程，任务代码本身就会被为了实现状态机而添加的代码打乱。因此微软为编译器添加了自动化实现可重入状态机的功能，这个机制，就是 c++20协程啦。&lt;/p&gt;
&lt;p&gt;so, c++20协程，是无栈协程的一种。&lt;/p&gt;</description>
    </item>
    <item>
      <title>c&#43;&#43;20 协程</title>
      <link>https://microcai.org/2022/02/20/co_await.html</link>
      <pubDate>Sun, 20 Feb 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/02/20/co_await.html</guid>
      <description>&lt;p&gt;表面上我是想说 c++20 的协程, 其实我是想说, asio 封装后的 asio::awaitable&amp;lt;&amp;gt; , 这个威力巨大的武器将是未来异步的基石.&lt;/p&gt;
&lt;p&gt;asio::awaitable&amp;lt;&amp;gt; 的概念, 是万物皆可 await. 万物皆可 await 的概念实际上来自 nodejs.&lt;/p&gt;
&lt;p&gt;当初, nodejs 用回调地狱带火了异步. 既然回调地狱为何又火? 因为 nodejs 万物只能异步. nodejs 没有除了异步以外的 IO.
于是 nodejs 逼迫大家在异步的道路上进行探索, 终于诞生了 Promsie/await 对. Promise 是库, await 是语言关键字.
Promise 先出, await 后出. 没有 await 的 Promise 是不完整的 Promsie , 没有 Promise 的 await 是无法使用的废物.
两个天造地设的一对, 居然并不是同时出生.&lt;/p&gt;
&lt;p&gt;Promise 的概念就是, 所有的函数, 都不直接返回数据, 而是返回 Promise , 要取得真正的返回值, 就要 await 这个 Promise.
那么, 调用返回 Promise 函数的地方, 就变成了 initiator , 而 await promsie 的地方, 就是 completion handler.
也就是, Promsie/await 的概念, 正好契合了 Proactor 的异步并发模型. 自从有了 promise/await , 原先为了避免回调地狱而
设计为 on(&amp;lsquo;data&amp;rsquo;, lisener) 的 reactor 模式的库纷纷被抛弃, 大家都要选择 Promise 版的替代品.&lt;/p&gt;</description>
    </item>
    <item>
      <title>asio::promise yyds</title>
      <link>https://microcai.org/2022/02/04/asio-promise-yyds.html</link>
      <pubDate>Fri, 04 Feb 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/02/04/asio-promise-yyds.html</guid>
      <description>&lt;p&gt;最近在写以太坊的巧克力浏览器（区块链浏览器）。因为区块链浏览器需要访问历史的块，因此需要节点以 archive 模式同步。&lt;/p&gt;
&lt;p&gt;遂运行了一个 geth。 然而半个月过去了，才同步了四百万高度，而且这四百万高度的最后一百万花了80%的时间。
同步速度以肉眼可见的速度下降，ETA 变的越来越长。 从一个月慢慢的增长到6个月。&lt;/p&gt;
&lt;p&gt;于是寻找更快的客户端。找到了 erigon。erigon 号称2天完成 archive 节点同步。
结果牛逼是吹大了啊。最后耗费了10天完成了同步。&lt;/p&gt;
&lt;p&gt;geth 在同步的时候， rpc 是可用的，geth 同步到哪里， eth_getBlockNumber 返回的高度就是哪里。
因此在同步的时候，我也开始同步巧克力浏览器的数据了。&lt;/p&gt;
&lt;p&gt;巧克力浏览器是通过 eth_getblockbynumber 和 eth_gettransactionreceipt 把所有的交易数据都存入自己的数据库实现的。虽然其实可以等用户浏览到那个块再通过 rpc 获取数据，但是这样轻模式就没有检索功能了。所以还是需要解析所有的交易存入自己的数据库。&lt;/p&gt;
&lt;p&gt;最终放弃 geth 二改用 erigon 的时候，巧克力浏览器才同步到一百多万的高度，就被迫停止了。&lt;/p&gt;
&lt;p&gt;因为 erigon 只有完成同步，才会更新 eth_getBlockNumber 返回的高度。他同步的方式是先下载所有的块，然后执行，让后更新state数据，然后更新 rpc 接口的数据，然后获取最新高度，然后把落下的全下载回来，然后执行，让后更新state数据，然后更新 rpc 接口的数据，然后获取最新高度，然后把落下的全下载回来，然后执行，让后更新state数据，然后更新 rpc 接口的数据，然后获取最新高度&amp;hellip;&amp;hellip; 直到最后每次批处理的块只有1个，就算同步彻底完成。
如果 eth_getBlockNumber 一直返回 0 高度，我的浏览器就没法同步了，于是只能等。&lt;/p&gt;
&lt;p&gt;问题是，他第一次的批量的时候，就试图从 0 一直批量执行到 1401万高度。结果，执行了10天才批量执行完。这一等就是十天, 等到了除夕前一天啊。执行完毕后，就再次落后十万高度了，于是进入第二次批处理。&lt;em&gt;因为我在机械盘上运行 erigon，因此 erigon 最后会永远落后几百到几千个高度，不过这个是后话，第一次批处理完成后，我的浏览器又可以开起来同步了&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;结果，我对巧克力浏览器的同步速度非常的不满了。&lt;/p&gt;
&lt;p&gt;因为，按同步速度估算，可没法10天完成巧克力浏览器的同步。大约需要20天，而且 ETA 在增加！最后可能达到了三年之久。为啥我能提前知道eta在增加呢？因为我观察到，同步空快很快，同步内部有交易的块就慢下来了。早期空块多，但是后期基本都是满块。满块的同步速度低到令人发指的超过数秒！&lt;/p&gt;
&lt;p&gt;经过研究发现，速度是慢在了 get_transactionreceipt 上。这个接口对未缓存的交易返回速度需要数百毫秒。&lt;em&gt;第二次调用其实几个毫秒就返回了.&lt;/em&gt;
而巧克力浏览器访问的都是数年前的交易，都是属于 old data。因此每次调用它都要等待几百毫秒。
如果一个块里有个一百个交易，同步速度就惊人的 slow down 了。&lt;/p&gt;</description>
    </item>
  </channel>
</rss>
