<?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>Coroutine on 菜菜博士</title>
    <link>https://microcai.org/tags/coroutine.html</link>
    <description>Recent content in Coroutine on 菜菜博士</description>
    <generator>Hugo</generator>
    <language>zh-cn</language>
    <lastBuildDate>Fri, 03 Jan 2025 00:00:00 +0800</lastBuildDate>
    <atom:link href="https://microcai.org/tags/coroutine/feed.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>调用约定和上下文切换</title>
      <link>https://microcai.org/2025/01/03/calling-convertion-and-context-swap.html</link>
      <pubDate>Fri, 03 Jan 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/01/03/calling-convertion-and-context-swap.html</guid>
      <description>&lt;p&gt;编写协程库的时候，我常常在想，上下文切换的速度，受&lt;strong&gt;调用约定&lt;/strong&gt;的影响非常大。&lt;/p&gt;
&lt;p&gt;因为用户协程的上下文切换，本质上是调用一个 函数。而这个函数需要 “切换” 非易失性寄存器。&lt;/p&gt;
&lt;p&gt;因此，在给定的调用约定下，非易失性寄存器越多，则上下文切换时需要保留和恢复的寄存器数量就越多。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;而由内核进行上下文切换(也就是线程)，所有寄存器都得保留。开销是最大的。何况还有执行特权级切换的巨大开销。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;在知乎上发表的批评 云风的 coroutine 库的文章的评论区里，有个人提到了 &lt;a href=&#34;https://photonlibos.github.io/blog/stackful-coroutine-made-fast&#34;&gt;这篇文章&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;好家伙，他们对内联汇编玩出花来了。使用内联汇编的 clobbered registers 列表来自动生成寄存器的保存和恢复代码。&lt;/p&gt;
&lt;p&gt;然后，他们给 clang 提了一个补丁，增加了一个叫 &lt;code&gt;preserve_none&lt;/code&gt; 的调用约定。&lt;/p&gt;
&lt;p&gt;所谓 &lt;code&gt;preserve_none&lt;/code&gt;，顾名思义，就是这个调用约定下，尽可能啥寄存器都不保留，全是易失性寄存器。&lt;/p&gt;
&lt;p&gt;于是，如果使用 &lt;code&gt;preserve_none&lt;/code&gt; 的调用约定实现 &lt;code&gt;zcontext_swap&lt;/code&gt;, 则代码里并不需要保留上下文。只需要切换 rsp 寄存器，然后调用下 hook 即可返回了。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-asm&#34; data-lang=&#34;asm&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;zcontext_swap_preserve_none:
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// 保存frame寄存器
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;push&lt;/span&gt; %rbp
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// 切换栈指针
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;mov&lt;/span&gt; %rsp, (%r12)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;mov&lt;/span&gt; (%r13), %rsp
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;//  恢复 frame 寄存器
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;pop&lt;/span&gt; %rbp
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// if(hook_function) hook_function(argument);
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;test&lt;/span&gt; %r14, %r14
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;jne&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;f&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// 返回 argument
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;mov&lt;/span&gt; %r15, %rax
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// 返回
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;ret&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;1:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// 如果有 hook ，则调用 hook 后返回
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;mov&lt;/span&gt; %r15, &lt;span style=&#34;color:#66d9ef&#34;&gt;ARG1_REG&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;mov&lt;/span&gt; %r15, %r12 &lt;span style=&#34;color:#75715e&#34;&gt;// 同时兼容 preserve_none 调用约定 的 hook
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;jmp&lt;/span&gt; * %r14 &lt;span style=&#34;color:#75715e&#34;&gt;// 开启尾调用优化.
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;在 无 hook 的情况下，只需 8 条指令即完成上下文切换。&lt;/p&gt;</description>
    </item>
    <item>
      <title>协程切换为什么需要 一个 hook_function 参数.</title>
      <link>https://microcai.org/2024/12/28/context-switch-need-a-hook.html</link>
      <pubDate>Sat, 28 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/28/context-switch-need-a-hook.html</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;刚刚，我将 zcontext 的 API 进行了以下修正。&lt;/p&gt;
&lt;p&gt;从&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;zcontext_swap&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;zcontext_t&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; from, &lt;span style=&#34;color:#66d9ef&#34;&gt;zcontext_t&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; to, &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; argument);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;改成了&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typedef&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;zcontext_swap_hook_function_t&lt;/span&gt;)(&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;zcontext_swap&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;zcontext_t&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; from, &lt;span style=&#34;color:#66d9ef&#34;&gt;zcontext_t&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; to, &lt;span style=&#34;color:#66d9ef&#34;&gt;zcontext_swap_hook_function_t&lt;/span&gt; hook_function, &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; argument);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;增加了一个 hook_function。这是为何呢？这个 hook_function 又是怎么使用的呢？在什么情况下运行呢？&lt;/p&gt;
&lt;p&gt;别着急，我一一道来。&lt;/p&gt;
&lt;h2 id=&#34;需求1自动进行栈回收&#34;&gt;需求1：自动进行栈回收&lt;/h2&gt;
&lt;p&gt;协程需要分配一个新栈。而协程执行完毕的时候，需要对分配的栈内存进行回收。
而协程自身是无法执行这个任务的。协程只有不在运行状态，他的栈才能释放。而他在运行状态下，又如何调用 free 释放自己呢？
free 本身运行也依赖栈。free 不能把自己正在使用的栈给释放了。&lt;/p&gt;
&lt;p&gt;因此，这个需求我用了一些比较绕的方法实现了。其实就是让调度器负责回收。这就限制了调度器只能跑在主线程上。
并且调度器（主事件循环）需要和协程的代码进行一定程度的耦合。&lt;/p&gt;
&lt;p&gt;但是为了解决内存泄漏，这个耦合也是不得不为之。其实应该有更好的解决方法的。&lt;/p&gt;
&lt;h2 id=&#34;需求2线程安全的协程切换&#34;&gt;需求2：线程安全的协程切换&lt;/h2&gt;
&lt;p&gt;在多线程运行调度器的情况下，可能发生协程切换的竞争。具体情况如下：&lt;/p&gt;
&lt;p&gt;假设运行2个线程执行 GetQueuedCompletionStatus。姑且称为 主线程A, 主线程B.
为了更好的性能，通常的做法是让线程A负责 accept, 而线程B负责处理客户端连接。如果处理客户端有瓶颈，还可以创建更多的线程处理。
这里先简化为2个线程。&lt;/p&gt;
&lt;p&gt;系统运行若干个 Accept 协程。并且在接受一个新连接后，创建一个新的处理协程来处理新的连接。
姑且称是协程A吧。某个协程 A 拿到了一个新连接后，创建一个新的处理协程来处理新的连接。
姑且称这个刚刚创建的新协程为 协程C，这个新接受的连接对应 socket C。&lt;/p&gt;
&lt;p&gt;好了，协程A, 接受了一个新连接，然后创建了 协程 C。此时协程 C 和协程 A ，都是在主线程 A 上运行的。&lt;/p&gt;
&lt;p&gt;这时，我们要往socket C 上投递 WSARecv 了。此时投递是在 主线程A上进行的。由于 socket C 绑定了线程B的 IO完成端口，因此稍后
会在主线程 B 上获得完成事件。此时协程 C 是在 线程 A 上运行的。调用 WSARecv 后，紧接着就要进行“协程挂起”操作。
正常来说，线程B获得socket C 的完成事件后，就会恢复协程C。于是，协程 C 后续就在 线程 B 上运行了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>从0开始写上下文切换</title>
      <link>https://microcai.org/2024/12/26/context-switch-explained.html</link>
      <pubDate>Thu, 26 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/26/context-switch-explained.html</guid>
      <description>&lt;h1 id=&#34;有栈协程的核心是执行上下文执行上下文的核心是栈&#34;&gt;有栈协程的核心是执行上下文。执行上下文的核心是栈。&lt;/h1&gt;
&lt;p&gt;因此，切换栈就等于切换了上下文。&lt;/p&gt;
&lt;h1 id=&#34;栈在协程切换上的核心地位&#34;&gt;栈在协程切换上的核心地位&lt;/h1&gt;
&lt;p&gt;栈，存储了一个协程/线程 的“调用链”，以及依附于这条链上的“变量”。&lt;/p&gt;
&lt;p&gt;没有栈，ret 指令将无所适从。&lt;/p&gt;
&lt;p&gt;虽说栈是核心，但是栈本质是堆叠存储“历史 寄存器状态”。而当前没有入栈的寄存器状态，才是真正的当前上下文。&lt;/p&gt;
&lt;p&gt;因此，很多古代协程库的做法，是栈协程“句柄” 上，开辟一个数百字节的空间。用于存放当下的CPU寄存器的数值。
上下文切换的时候，就是把当前 cpu 寄存器拷到句柄空间，然后从新协程的句柄空间里把寄存器的值一个一个读回来。&lt;/p&gt;
&lt;p&gt;这种做法，是认可 “CPU寄存器数值的集合” 是当前上下文。栈不过是其中一个寄存器指向的一块内存区域，没什么特别的。&lt;/p&gt;
&lt;p&gt;但是，boost.fcontext 另辟蹊径。他唯一指定 栈为协程的正统核心。当前的 cpu 寄存器状态，可以通过“调用 上下文切换” 函数，变成 上一层的 “历史状态”。&lt;/p&gt;
&lt;p&gt;于是本层所要做的，就只是切换栈。在切换栈前，也只须将本层寄存器状态入栈。切换后，再将寄存器状态出栈。&lt;/p&gt;
&lt;p&gt;因此，在 boost.fcontext 眼里，代表协程正统的，不是那个存储了几百个字节的寄存器数值的句柄空间，而是 栈顶指针。&lt;/p&gt;
&lt;p&gt;而用于引用协程的那个句柄， fcontext_t 结构，不过就是存储了一个栈顶指针。
而不像 ucontext_t 那样，好家伙洋洋洒洒数百字节体积。&lt;/p&gt;
&lt;p&gt;这就是对“何谓上下文”的理解理念不同带来的设计差异。&lt;/p&gt;
&lt;p&gt;这点设计差异，造成了数据结构的不同。数据结构都不同了，自然上下文切换的代码也不尽相同了。正是所谓的，数据结构决定了算法。&lt;/p&gt;
&lt;p&gt;来个上下文切换代码看看&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/context_switch_code.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;作为对比，看下 ucontext 系是怎么做上下文切换的：&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/ucontext_code_swapcontext.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;这就是不同的设计理念带来的差异。&lt;/p&gt;
&lt;p&gt;ucontext 认为 cpu寄存器是上下文，栈只是其中一个寄存器所引用的附属上下文。
而 boost.fcontext 则认为，栈就是上下文的全部。包括了所有的寄存器历史。&lt;/p&gt;
&lt;p&gt;&lt;em&gt;所谓寄存器的历史，是说进行函数调用的时候，编译器会生成入栈指令保留寄存器的数值，以便函数返回后能恢复这些寄存器的值。于是在调用链上，每一层调用帧上面都保留了一份寄存器的“快照‘&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;既然寄存器的快照就在栈上留着，那只要把当前的状态再“压栈”一次。那么所有的上下文，不就都用一个栈顶表达了吗？&lt;/p&gt;
&lt;p&gt;显然我们会发现，将栈视为协程的核心，能极大的简化代码。&lt;/p&gt;
&lt;p&gt;这点差异，还影响了 make_context 的设计。&lt;/p&gt;
&lt;h1 id=&#34;新建协程&#34;&gt;新建协程&lt;/h1&gt;
&lt;p&gt;一个协程上下文切换库，只需要编写3个函数&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;上下文切换&lt;/li&gt;
&lt;li&gt;新上下文创建&lt;/li&gt;
&lt;li&gt;新上下文的出生点&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;其中，新建上下文的出生点代码，是不需要暴露给用户的内部使用代码。另外两个，是作为库接口的形式存在的。&lt;/p&gt;
&lt;p&gt;上下文的切换，在上节已经赘述过了。就是当前状态 push 入栈。然后切换栈顶，然后 pop 出栈。大功告成。&lt;/p&gt;
&lt;p&gt;傻瓜式的代码。&lt;/p&gt;</description>
    </item>
    <item>
      <title>boost.fcontext 为何快？</title>
      <link>https://microcai.org/2024/12/18/why-boost-fcontext-is-fast.html</link>
      <pubDate>Wed, 18 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/18/why-boost-fcontext-is-fast.html</guid>
      <description>&lt;p&gt;在 &lt;a href=&#34;https://microcai.org/2024/12/17/dig-into-libco.html&#34;&gt;批评 libco&lt;/a&gt; 的 上下文切换代码的时候，我曾经说，协程的上下文切换代码，并不需要恢复所有的寄存器。
只需要恢复调用约定里规定的 “非易失性寄存器”。&lt;/p&gt;
&lt;p&gt;只有操作系统进行抢占式调度的时候，才需要恢复所有的寄存器。因为抢占式调度，可以在任何时间任何地方中断线程。如果不恢复所有寄存器，则在线程的角度看来就是寄存器的值可以任何时间任何地方突然“自主改变”。&lt;/p&gt;
&lt;p&gt;而由用户执行的协程调度则不然。上下文切换，一定是代码里“主动”调用某个控制权转移接口实现的。&lt;/p&gt;
&lt;p&gt;而这个控制权转移接口，在编译器看来，不过是一次再正常不过的外部函数调用。只要按照约定，准备好寄存器。。 并且在它返回的时候，自主恢复易失性寄存器。&lt;/p&gt;
&lt;p&gt;是的没错，调用它的地方，本来就假定易失性寄存器的数值会改变。&lt;/p&gt;
&lt;p&gt;因此，在协程的上下文切换函数里，根本没有任何必要恢复易失性寄存器的内容。只需要恢复非易失性寄存器即可。&lt;/p&gt;
&lt;p&gt;为了验证我的设想，我写了一个 zcontext 进行了验证。
这个 zcontext 已提交进 uasync 代码仓库，详情看 &lt;a href=&#34;https://github.com/microcai/iocp/commit/e2d6da2a7cb208a8ed1fcdda6d835ccef193b3c4&#34;&gt;commit&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;不过我这上下文切换，只恢复了8个非易失性通用寄存器。对16 个 MMX 寄存器，还有 AVX 寄存器，都没有进行恢复。
不知道会不会出问题。于是就仔细的研读了 boost.context 的汇编代码。希望研究下怎么恢复 SSE 和 AVX 寄存器。&lt;/p&gt;
&lt;p&gt;注：boost.context 里负责上下文切换的 汇编写的 api 叫 fcontext 。&lt;/p&gt;
&lt;p&gt;结果发现 fcontext 的做法和我的不能说完全一样，简直是一模一样。&lt;/p&gt;
&lt;p&gt;无非是我用了 一排 push + 一排 pop 做的切换，而它的代码使用了 mov 指令。但都是等价的。&lt;/p&gt;
&lt;p&gt;也只恢复了非易失性通用寄存器和 2个 80387状态寄存器。&lt;/p&gt;
&lt;p&gt;这下总算完全理解为啥 boost.context 称自己的性能天下无敌了。&lt;/p&gt;
&lt;p&gt;因为确实没有比这更快的上下文切换方式了。&lt;/p&gt;
&lt;p&gt;由此可见，libco 的作者还真是水货一个。他引以为傲的那段汇编代码，就是一坨羊粪。&lt;/p&gt;</description>
    </item>
    <item>
      <title>点评 腾讯 的 协程库 libco</title>
      <link>https://microcai.org/2024/12/17/dig-into-libco.html</link>
      <pubDate>Tue, 17 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/17/dig-into-libco.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;libco 是 腾讯开源的一个协程库。噱头很大，动不动就是承载了微信后台亿万并发。
敢说个不马上被喷成狗头。但是我偏就是要对这些光有名头没啥技术的东西祛魅。&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;https://microcai.org/2024/12/16/dig-into-coroutine-lib.html&#34;&gt;上一片文章&lt;/a&gt; 里，点评了云风的 coroutine库，其中提到了 libco 犯了和云风一样的错。&lt;/p&gt;
&lt;p&gt;其实 libco 的错误要比云风还要多的多。&lt;/p&gt;
&lt;p&gt;废话不多说，接下来点评 libco&lt;/p&gt;
&lt;h1 id=&#34;libco-错在哪里&#34;&gt;libco 错在哪里&lt;/h1&gt;
&lt;p&gt;首先错误的，仓库上一篇，他和云风的错误是一样的。表述相同的部分就不特别说明了。&lt;/p&gt;
&lt;h2 id=&#34;1-协程库不应该干涉程序结构&#34;&gt;1 协程库不应该干涉程序结构&lt;/h2&gt;
&lt;p&gt;但是 libco 的此进入非彼侵入。云风的侵入，是需要永久性的携带 &lt;code&gt;struct schedule *S&lt;/code&gt;,
而 libc 的侵入，则是，它根本就不让你正常的用阻塞的思维模式设计你的代码结构。&lt;/p&gt;
&lt;p&gt;我们那它源码里自带的 example_echosrv.cpp 举例&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/libco_code1.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;这是它一个建议的 echo server。前面介绍 iocp4linux 的时候，我就贴过正统代码。
算了，还是直接给个对比吧。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;alt text&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/compare_libco_uasync.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;图片里两端代码，下面的是正统协程库写的 echo server 里的 accept 循环。
而上面那段则是 libco 里的例子。&lt;/p&gt;
&lt;p&gt;正如我图片里的吐槽那样，腾讯的 libco 在编写代码的时候，很容易陷入不知所谓的境地。&lt;/p&gt;
&lt;p&gt;这就是因为它库设计的缺陷，所以必须要用很绕的方式组织代码逻辑。&lt;/p&gt;
&lt;h2 id=&#34;2-协程库不应该强依赖一个调度器&#34;&gt;2 协程库不应该强依赖一个调度器&lt;/h2&gt;
&lt;p&gt;还是刚刚腾讯自己写的 example_echosrv.cpp 例子。
这次是 main 函数。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/libco_code2.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;这不仅仅是依赖调度器了，这是必须，也只能使用 libco 的事件循环。&lt;/p&gt;
&lt;p&gt;如果云风的库只能算对你壁咚，那腾讯的库就是把你裤子都扒光了后入。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;当然，不可否认一些人有网红膜拜症，非要被玩一把才开心。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;当然，如果他的库已经实现的比较完善，那么使用他的事件循环，调用他封装好的 IO api，也未尝不可以接受。神神曾经说过，被强奸的时候，反抗不了，就要学会享受。&lt;/p&gt;</description>
    </item>
    <item>
      <title>点评 云风 的 C库 coroutine</title>
      <link>https://microcai.org/2024/12/16/dig-into-coroutine-lib.html</link>
      <pubDate>Mon, 16 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/16/dig-into-coroutine-lib.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;在知乎上看到两篇 吹嘘 云风的 coroutine 库的文章。&lt;/p&gt;
&lt;p&gt;人啊就是这样的，出名了以后，就是垃圾也有人吹捧。&lt;/p&gt;
&lt;p&gt;今天来点评下，云风的 coroutine 到底垃圾在哪里。又或者说，一个优秀的协程，应该优秀在哪里。&lt;/p&gt;
&lt;h1 id=&#34;云风错在哪里&#34;&gt;云风错在哪里&lt;/h1&gt;
&lt;p&gt;首先一个优秀的协程库，要做到“自然”。&lt;/p&gt;
&lt;p&gt;什么是“自然”呢？就是要做到尽量不改变原来写同步阻塞IO逻辑的时候的代码。&lt;/p&gt;
&lt;p&gt;因此引出第一错：&lt;/p&gt;
&lt;h2 id=&#34;1-协程库不应该侵入-api-设计&#34;&gt;1 协程库不应该侵入 API 设计&lt;/h2&gt;
&lt;p&gt;要使用云风的协程，被调度的协程必须有如下的函数签名&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;coroutine_function&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;struct&lt;/span&gt; schedule &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;S, &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; arg);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;注意到那个 &lt;code&gt;struct schedule *S&lt;/code&gt; 参数了吗？要使用协程，必须带上这个参数。&lt;/p&gt;
&lt;p&gt;哪怕本层级的函数并不直接调用 IO, 也就是不会直接用到 &lt;code&gt;struct schedule *S&lt;/code&gt; 参数，他也得带上，并将 &lt;code&gt;struct schedule *S&lt;/code&gt; 传给所有他要调用的函数。&lt;/p&gt;
&lt;p&gt;也就是整个程序所有的函数都得带上 &lt;code&gt;struct schedule *S&lt;/code&gt; 参数。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;这也是 asio 的有栈协程设计失败的地方。一旦使用了有栈协程，所有的函数都得加上 &lt;code&gt;asio::yield_context&lt;/code&gt; 参数。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;如果只是某个会调用 IO 的函数需要带上这个 休眠器 还好。但是假设这样的调用链条&lt;/p&gt;
&lt;p&gt;A -&amp;gt; B -&amp;gt; C -&amp;gt; D, 最终在 D函数里调用了  async_read();&lt;/p&gt;
&lt;p&gt;那显然，为了让整条路径能实现逐级传递 &lt;code&gt;struct schedule *S&lt;/code&gt;, 必然会让这条调用链上的所有函数都带上 &lt;code&gt;struct schedule *S&lt;/code&gt; 参数。&lt;/p&gt;</description>
    </item>
    <item>
      <title>微软不会起名</title>
      <link>https://microcai.org/2024/10/30/ms-went-wrong-on-coroutine-naming.html</link>
      <pubDate>Wed, 30 Oct 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/10/30/ms-went-wrong-on-coroutine-naming.html</guid>
      <description>&lt;p&gt;微软不会起名，而且名字还具有极大的误导性。&lt;/p&gt;
&lt;p&gt;先说类名：&lt;/p&gt;
&lt;p&gt;首先，微软的协程原作者，他总是用 &lt;code&gt;Task&amp;lt;&amp;gt;&lt;/code&gt; 来命名一个协程函数。但是这就是他犯的第一个错误。
因为只有 await 构成的一系列调用，那条调用链才是一个 “任务”。 也就是 asio 作者所说的 co_spawn. 只有被 spawn 出来的协程，才叫一个任务。而被 await 的函数，不能叫任务，而是”可异步等待返回的函数“。 因此 asio 作者使用 &lt;code&gt;asio::awaitable&amp;lt;&amp;gt;&lt;/code&gt; 来命名，而不是 &lt;code&gt;task&amp;lt;&amp;gt;&lt;/code&gt; 是十分妥帖的。&lt;/p&gt;
&lt;p&gt;接着是 promise_type ，这个微软就是纯粹的瞎搞了。不同于 Task&amp;lt;&amp;gt; 只是出现在微软的示例代码里，promise_type 可是直接进了标准。这瞎命名带来的恶劣影响要大的多。为啥说这个不能是 promise_type 呢？ 因为这个对象存储的是 协程状态。因此 asio 使用 coro_frame 来命名，显然要更正确的。它存储的就是当前协程帧的状态数据。&lt;/p&gt;
&lt;p&gt;最后是 final_suspend ，这个类名简直就是严重误导性的集大成者。他干的活和 suspend 毫无关系。实际上他干的恰恰不是 suspend 的活，而是 “恢复调用者” 。协程作为可等待函数，他的调用者调用了一个协程后，调用者才是真正的被 suspend 了。被调用者是执行中。处于 running 状态。当被调用者完成工作，他要 恢复 调用者，让调用者醒来继续干活。&lt;/p&gt;
&lt;p&gt;因此， final_suspend 其实应该叫 resume_caller .&lt;/p&gt;
&lt;p&gt;接着说 三件套函数名：&lt;/p&gt;
&lt;p&gt;await_suspend 其实不是 挂起。协程 A 调用 协程 B, 实际上是 A 被挂起。可是代码上却是 调用 B 的 await_suspend 。这简直就是极大的误导性。当 B 对象的 await_suspend 被调用的时候，实际上恰恰是 B 被 “恢复”， B 进入了 running 状态。这个地方准确的命名，应该叫 await_setup.&lt;/p&gt;</description>
    </item>
    <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>
  </channel>
</rss>
