<?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>Cpp on 菜菜博士</title>
    <link>https://microcai.org/tags/cpp.html</link>
    <description>Recent content in Cpp 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/cpp/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>链接到 ucrtbase.dll</title>
      <link>https://microcai.org/2024/12/23/link-to-ucrtbase-dll.html</link>
      <pubDate>Mon, 23 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/23/link-to-ucrtbase-dll.html</guid>
      <description>&lt;p&gt;使用 vc6.0 以后的 VS 编译器，最恼火的一点就是生成的 exe 依赖 msvcrXXX.dll。
其中 XXX 是个版本号。而且 msvcrXXX.dll 系统是不自带的。&lt;/p&gt;
&lt;p&gt;于是每个 exe 都得带上 vcredist.exe 安装程序。&lt;/p&gt;
&lt;p&gt;过于蛋疼。&lt;/p&gt;
&lt;p&gt;正统的解决方法是改使用静态C库。&lt;/p&gt;
&lt;p&gt;但是会带来二进制体积暴涨的问题。&lt;/p&gt;
&lt;p&gt;十分的怀念 VC6.0 可以生成exe 依赖 msvcrt.dll， 不带版本号那种。而不带版本号的那个，每个 windows 都会自带。&lt;/p&gt;
&lt;p&gt;有比较多的偏门方式，可以在 vc6 以后的版本继续链接到 msvcrt.dll 。但是一来是偏方，而来在 vs2017 以后这些偏方也没用了。&lt;/p&gt;
&lt;p&gt;后来对此也不甚钻研了，直接无脑静态链接了。&lt;/p&gt;
&lt;p&gt;最近，突然又关心起 msvcrt 问题，因为用了下 LLVM MinGW。然后在 readme 里看到了 UCRT 介绍。&lt;/p&gt;
&lt;p&gt;UCRT？ UCRT 是啥？&lt;/p&gt;
&lt;p&gt;原来微软也发现大家不爽带版本号的 msvcrXXX.dll。于是用 C++ 以 extern &amp;ldquo;C&amp;rdquo; 的方式重写了它的 C 运行时。
这个重写的新C运行时就是 UCRT。每个 win 都会带上。名为 ucrtbase.dll 和 Debug 版的 ucrtbased.dll。&lt;/p&gt;
&lt;p&gt;连这个UCRT的，还有新的 vcruntimeXXX.dll。而过去 C++ 运行时是 msvcpXXX.dll 。&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>基于 ucontext &#43; iocp4linux 的超简协程库</title>
      <link>https://microcai.org/2024/12/15/ucontext-based-uasync.html</link>
      <pubDate>Sun, 15 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/15/ucontext-based-uasync.html</guid>
      <description>&lt;p&gt;虽然说，使用 异步最佳的实践是使用协程。&lt;/p&gt;
&lt;p&gt;然而 c++20 的协程并不总是可用的。总不能说，不能更新编译器的地方就不配写代码吧。&lt;/p&gt;
&lt;p&gt;因此，我在上一篇文章里说道，可以继续忍受回调地狱。或者使用有栈协程。&lt;/p&gt;
&lt;p&gt;当然，如果使用 asio ， 那么一切问题都不存在。asio 支持 有栈协程，无栈协程，daff‘s device 协程，还有最基础的，回调模式。
asio 简直就是个“宇宙级” 的异步库。&lt;/p&gt;
&lt;p&gt;然而，asio 也并不总是可用。&lt;/p&gt;
&lt;p&gt;于是，基于 ucontext 的一个超简协程库就应运而生。&lt;/p&gt;
&lt;p&gt;首先，这个不是一个独立的库，他其实顺手带在 uasync 里。作为  universal_fiber.h 头文件提供。&lt;/p&gt;
&lt;p&gt;就隐藏在 iocp4linux 的 example 代码里。
见 &lt;a href=&#34;https://github.com/microcai/iocp/blob/master/example/echo_server/echo_server_stackfull.c&#34;&gt;echo_server_stackfull.c&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;没错，这次是个 C 代码。尽管我非常讨厌 C。&lt;/p&gt;
&lt;p&gt;这个库，只是为了演示如何将 proactor 和有栈协程给结合起来。虽然我本人建议最好使用 c++20 的协程。但是总有人是升级不了编译器的。
因此我再三思考后，决定还是写一个小 demo 来演示 proactor 和有栈协程 如何极便捷的结合。&lt;/p&gt;
&lt;p&gt;对于这么一个简单的 echo server 例子，作为对比，同文件夹下的 echo_server_callback.cpp 就是基于回调的。可以直观感受下，基于回调和基于协程的代码可读性。&lt;/p&gt;
&lt;h1 id=&#34;先看有栈和无栈例子对比&#34;&gt;先看有栈和无栈例子对比&lt;/h1&gt;
&lt;p&gt;这个是 echo server 左边有栈协程和右边无栈协程的 accept 循环的代码对比
&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/ucontext_code4.png&#34;&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;这就是 universal_fiber.h 和 universal_async.hpp 的威力。&lt;/p&gt;
&lt;p&gt;关于那个无栈协程 universal_async.hpp 的分析，参考 &lt;a href=&#34;https://microcai.org/2024/12/08/super-lightweight-iocp-coroutine.html&#34;&gt;这篇文章&lt;/a&gt;&lt;/p&gt;</description>
    </item>
    <item>
      <title>深入异步IO 第二篇： 正确使用 IOCP，正确设计 proactor</title>
      <link>https://microcai.org/2024/12/14/use-iocp-in-the-right-way.html</link>
      <pubDate>Sat, 14 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/14/use-iocp-in-the-right-way.html</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;干了那么多年码农，遇到 IO 从来都是写异步代码。从最初直面裸 epoll 写，到后来基本上依赖 asio 写。
最近研究 io_uring 后，试着用 io_uring 把 IOCP 那套 API 实现了。&lt;/p&gt;
&lt;p&gt;以前呆在 asio 的舒适区，根本没关注过其他程序员对异步的理解。但是 windows 程序员是最多的，当我研究IOCP的时候，
以前被我忽略掉的那群写 IOCP 的程序员，突然进入了我的视线。&lt;/p&gt;
&lt;p&gt;当我研究了他们对异步的一些吐槽后，才发现了一个真相：大部程序员并不懂异步。&lt;/p&gt;
&lt;p&gt;尤其是，我由于不熟悉 IOCP，故而为了给 iocp4linux 找测试用例，而翻遍网络，寻找使用 IOCP 写成的一些网络代码示例。
能跑通它们，才算 iocp4linux 功能完成了。对吧。&lt;/p&gt;
&lt;p&gt;结果，大部分 IOCP 的例子，虽然能跑。但是我研究了他们的代码后发现，统统都是错误的。完全没有领会到异步IO的精髓。根本就
没有真正的理解异步IO。&lt;/p&gt;
&lt;p&gt;所以，我打算写数篇最深入剖析异步IO的引导文章，足够教会大家 真正的异步思维。&lt;/p&gt;
&lt;h1 id=&#34;reactor-和-proactor&#34;&gt;Reactor 和 Proactor&lt;/h1&gt;
&lt;p&gt;ACE 作者当年提出了数个高性能网络IO的模型，其中将这些模型总结为 Reacto 和 Proactor。如果按字母意思翻译，
则称为 反应器 和前摄器。&lt;/p&gt;
&lt;p&gt;但是，我更愿意使用更精准的汉语表达：多路复用模式 和 重叠IO模式。&lt;/p&gt;
&lt;h2 id=&#34;多路复用模式&#34;&gt;多路复用模式&lt;/h2&gt;
&lt;p&gt;前一篇文章说道，要想实现单线程并发IO, 内核必须要提供的2个机制。在 多路复用模式下，要求的机制就是&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;可读写状态通知&lt;/strong&gt; 和 &lt;strong&gt;无阻塞IO操作&lt;/strong&gt;。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;无阻塞IO操作&lt;/strong&gt; 要求内核在IO不能立即完成的情况下，不能挂起调用线程，而是返回错误。但是此时代码不应该进入无限重试，而是等待内核的通知。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;可读写状态通知&lt;/strong&gt; 如果一个 IO 操作接下来可以无阻塞立即执行，则通知程序，现在可以干活而不会失败了。&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;比如我写一个 server，调用 read() 读取客户端发送的数据。如果客户端还未发送数据。则内核会挂起线程直到对方发送数据。然后 read 就执行成功并返回了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>深入理解异步IO</title>
      <link>https://microcai.org/2024/12/13/in-deepth-async.html</link>
      <pubDate>Fri, 13 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/13/in-deepth-async.html</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;干了那么多年码农，遇到 IO 从来都是写异步代码。从最初直面裸 epoll 写，到后来基本上依赖 asio 写。
最近研究 io_uring 后，试着用 io_uring 把 IOCP 那套 API 实现了。&lt;/p&gt;
&lt;p&gt;以前呆在 asio 的舒适区，根本没关注过其他程序员对异步的理解。但是 windows 程序员是最多的，当我研究IOCP的时候，
以前被我忽略掉的那群写 IOCP 的程序员，突然进入了我的视线。&lt;/p&gt;
&lt;p&gt;当我研究了他们对异步的一些吐槽后，才发现了一个真相：大部程序员并不懂异步。&lt;/p&gt;
&lt;p&gt;尤其是，我由于不熟悉 IOCP，故而为了给 iocp4linux 找测试用例，而翻遍网络，寻找使用 IOCP 写成的一些网络代码示例。
能跑通它们，才算 iocp4linux 功能完成了。对吧。&lt;/p&gt;
&lt;p&gt;结果，大部分 IOCP 的例子，虽然能跑。但是我研究了他们的代码后发现，统统都是错误的。完全没有领会到异步IO的精髓。根本就
没有真正的理解异步IO。&lt;/p&gt;
&lt;p&gt;所以，我打算写数篇最深入剖析异步IO的引导文章，足够教会大家 真正的异步思维。&lt;/p&gt;
&lt;h1 id=&#34;线程的由来&#34;&gt;线程的由来&lt;/h1&gt;
&lt;p&gt;现在的程序员大部分都是新世纪后出生的。所以早就忘记了线程的设计初衷了。我看到大部分新世纪程序员都说线程是为了并发，为了压榨cpu的性能。&lt;/p&gt;
&lt;p&gt;其实多线程压榨 cpu 的性能，是最近十几年才有的。而线程的历史，和操作系统一样古老。
计算机诞生的前半个世纪，CPU都是单核的。那时候就已经有了多线程。&lt;/p&gt;
&lt;p&gt;所以，线程的最初真正作用，实际上出乎现在的程序员的意料：是为了实现异步IO。&lt;/p&gt;
&lt;h2 id=&#34;dos-下的-io&#34;&gt;DOS 下的 IO&lt;/h2&gt;
&lt;p&gt;在个人电脑的上古时代，一个打字员的日常工作，是打字，然后 按下键盘上的 Ctrl-S。接着去泡杯茶去喝。&lt;/p&gt;
&lt;p&gt;当 wps 要将文档存入软盘，意味着这段时间，整台电脑都处于“不可操作”的状态。
直到软驱磁头吭呲吭呲的干完活，当前的应用才会复活，能继续执行其他任务了。&lt;/p&gt;
&lt;p&gt;为啥会这样呢？因为 DOS 是一个单任务的操作系统，不支持多线程。这就意味着，DOS 不支持异步 IO。WPS要写磁盘，就只能等待 DOS 完成文件写入。
期间整个电脑都无法干其他工作。&lt;/p&gt;
&lt;p&gt;这个问题，直到“多任务系统”的出现才解决。当然，多任务系统，出现的比 DOS 早多了，只不过，引入 PC 领域要晚的多。一直到 windows 出现。&lt;/p&gt;</description>
    </item>
    <item>
      <title>批量提交IO提升性能</title>
      <link>https://microcai.org/2024/12/10/io_batching-boost-performance.html</link>
      <pubDate>Tue, 10 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/10/io_batching-boost-performance.html</guid>
      <description>&lt;p&gt;在基本完成 iocp4linux 后，我抽空在 &lt;a href=&#34;https://wiki.radxa.com/Rockpi4&#34;&gt;rockpi&lt;/a&gt; 上测了下性能。&lt;/p&gt;
&lt;p&gt;使用仓库里自带的例子  test/web_server/server.cpp，我测得了大约 6000req/s 的性能。&lt;/p&gt;
&lt;p&gt;还不错。但是和 PC 上超过十万的性能相比，有那么点。。。弱鸡。&lt;/p&gt;
&lt;p&gt;但是我通过 htop 注意到了一点。wrk 压测的时候， cpu1 是 cpu 100%。而且都是 红色的。说明cpu 都花在内核时间上了。
这也是 io_uring 很牛逼的原因：活都让内核干了。&lt;/p&gt;
&lt;p&gt;==。&lt;/p&gt;
&lt;p&gt;rockpi 是个6核的soc, 其中 cpu1-cpu4 （我设定 htop 的 cpu 从 1 开始数。）是个 1.4Ghz 的小核。cpu5，cpu6 才是 1.8Ghz 的大核。&lt;/p&gt;
&lt;p&gt;这 不仅仅一核有难，5核围观。这特么干活的还是个小核。&lt;/p&gt;
&lt;p&gt;于是果断找原因，发现是中断亲和性的设定问题。将中断迁移到 cpu5 后，测试发现干活的就是 1.8Ghz 的大核啦。&lt;/p&gt;
&lt;p&gt;然后性能飙到超过 9000req/s。&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/iocp4linux_perf_1.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;嘿嘿，果然给力。这优化。还是免费的。&lt;/p&gt;
&lt;p&gt;就在我沾沾自喜的时候，我又随手测试了以下 老中医写的 proxy_server。它里面带了一个简单的 http server。
wrk 压测以下，我了个去的。轻轻松松 1.6万req/s。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/asio_test1_perf.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;asio 你大爷还是你大爷！&lt;/p&gt;
&lt;p&gt;于是我琢磨着进行优化。&lt;/p&gt;
&lt;p&gt;我想到了 io_uring 提交 IO 的两步曲：&lt;/p&gt;</description>
    </item>
    <item>
      <title>超轻量级 IOCP 协程库</title>
      <link>https://microcai.org/2024/12/08/super-lightweight-iocp-coroutine.html</link>
      <pubDate>Sun, 08 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/08/super-lightweight-iocp-coroutine.html</guid>
      <description>&lt;p&gt;在 &lt;a href=&#34;https://microcai.org/2024/12/04/iocp-on-linux.html&#34;&gt;上一篇&lt;/a&gt; 文章里，我提出了 &lt;a href=&#34;https://github.com/microcai/iocp&#34;&gt;iocp4linux&lt;/a&gt; 。&lt;/p&gt;
&lt;p&gt;在编写 iocp4linux 的过程中，我需要写一些测试代码。&lt;/p&gt;
&lt;p&gt;一开始，我随便的找了一个基于 IOCP 的 echo test 和一个简单的 web server。
首先确保这弄来的例子能在 windows 上编译通过。&lt;/p&gt;
&lt;p&gt;然后修改 ifdef _WIN32守卫，在 linux 平台上改为使用 iocp.h 头文件。&lt;/p&gt;
&lt;p&gt;然后很轻松的就移植到 linux 上了。&lt;/p&gt;
&lt;p&gt;但是，我对于这些 C 风格的 demo 并不满意。因为我完全改不动他们的代码。&lt;/p&gt;
&lt;p&gt;于是，我想着，何不写一个超级轻量级的一个封装库？
这个库，应该做到跨平台 —— 指能同时兼容原版 windows.h和 iocp.h。然后代码尽量短小，同时又足够易用。&lt;/p&gt;
&lt;p&gt;最后。我折腾出了一个超轻量级的协程库。&lt;/p&gt;
&lt;p&gt;废话不说，先看一段 异步 accept 的代码：&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/awaitable_overlapped.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;在红框处，使用的是 windows 上的异步 accept 。
在 AcceptEx 调用的时候，传入了一个 ov 对象。
这个 ov 对象，类型是 awaitable_overlapped 。
awaitable_overlapped 可以隐式转换为 &lt;code&gt;WSAOVERLAPPED*&lt;/code&gt; 从而被 AcceptEx 所接受。&lt;/p&gt;
&lt;p&gt;由于是异步 IO ， 这时代码会继续向下运行。一般如果是在非协程的代码里。此时就应该返回函数。&lt;/p&gt;
&lt;p&gt;然后把 accpet 的后续逻辑，放到 调用 &lt;code&gt;GetQueuedCompletionStatus&lt;/code&gt; 的事件循环里了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>IOCP 移植到Linux上</title>
      <link>https://microcai.org/2024/12/04/iocp-on-linux.html</link>
      <pubDate>Wed, 04 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/04/iocp-on-linux.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;windows 高性能IO使用的是 proactor 模型，而古代 Linux 上则是 reactor 模型。&lt;/p&gt;
&lt;p&gt;因此跨平台的网络库，通常会选择实现为其中一种模型，然后在另一个平台上使用模拟。
比如 asio 使用 proactor 模型。Linux 上使用 epoll 模拟。
又比如 libevent 使用 reactor 模型， windows 上使用 iocp 模拟。&lt;/p&gt;
&lt;p&gt;而将 iocp 模拟为 epoll 的库，就是 &lt;a href=&#34;https://github.com/piscisaureus/wepoll&#34;&gt;wepoll&lt;/a&gt; 了。&lt;/p&gt;
&lt;p&gt;但是，reactor 比较是一种比较落后的模型。因此，进行跨平台封装为 proactor 实际上是更先进的做法。&lt;/p&gt;
&lt;p&gt;虽然已经有 asio 这种 proactor 库了，但是毕竟 asio 是一个比较重量级的库。一种轻量级的 proactor 库
也是非常有市场的。&lt;/p&gt;
&lt;p&gt;更何况，既然有 wepoll 这种把 Linux api 弄到 windows 上的库，那没有 Linux IOCP 就说不过去了。&lt;/p&gt;
&lt;p&gt;于是我决定，开发一个 Linux 版的 IOCP 库。这样方便使用 IOCP 开发的各种软件可以方便的迁移到 Linux 平台。而无需重写。&lt;/p&gt;
&lt;h1 id=&#34;如何实现呢&#34;&gt;如何实现呢？&lt;/h1&gt;
&lt;p&gt;如果是在很久以前，这件事其实还是比较复杂的。然而，嘿嘿。从 linux 5.1 开始，一个崭新的名为 io_uring 的系统接口诞生了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>用iouring扩展asio</title>
      <link>https://microcai.org/2024/11/21/extending-asio.html</link>
      <pubDate>Thu, 21 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/21/extending-asio.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;什么叫扩展asio？
Beast给Asio增加了 HTTP 协议，不叫扩展asio。那什么叫扩展asio？
举个例子，给 asio 的 socket 对象，基于io_uring提供的 IORING_OP_SHUTDOWN 增加 async_shutdown() 接口，就算扩展asio。因为原本asio并没有异步shutdown功能。而且这个功能并不能靠组合原有的asio接口实现。这就叫扩展asio。&lt;/p&gt;
&lt;p&gt;扩展asio, 又不能修改asio的代码。看起来有点难办。
好在，asio的设计也是有一定的扩展性的，并非完全依赖修改源码实现扩展。
但是不可避免的，需要使用 asio::detail:: 名字空间下的非公开接口。&lt;/p&gt;
&lt;p&gt;那么，就从 async_shutdown 开始，讲解如何扩展asio吧！&lt;/p&gt;
&lt;h1 id=&#34;接口形式&#34;&gt;接口形式&lt;/h1&gt;
&lt;p&gt;不修改asio代码的大前提下，要给一个对象增加一个 async_shutdown() 的成员函数那是痴人说梦。语言上就禁了此路。&lt;/p&gt;
&lt;p&gt;不过，有两种绕过的做法&lt;/p&gt;
&lt;p&gt;其一。写一个新的socket对象，自 asio::ip::tcp::socket 继承。然后增加一个成员函数。缺点是所有使用 socket 的地方都得修改一下类型。有了IDE的重构大法，实际上为了能异步关闭而进行的迁移并不算特别大的工作量。但是如果有不需要牵一发而动全身的修改，会更好。
其二。写一个全局函数，接受一个 asio::ip::tcp::socket 并将他异步关闭。&lt;/p&gt;
&lt;p&gt;第二个方法，不需要对整个项目进行大手术。只需要在需要异步关闭的地方，将原来的同步关闭 ( &lt;code&gt;socket.shutdown();&lt;/code&gt;)，替换为  &lt;code&gt;co_await async_shutdown(socket, defered);&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;从设计美学上来说，第二个方法更好。&lt;/p&gt;
&lt;h1 id=&#34;操作系统接口&#34;&gt;操作系统接口&lt;/h1&gt;
&lt;p&gt;扩展asio, 并不是使用asio现有接口去实现一个功能。比如beast利用 asio现有的socket接口就能实现在其基础上增加 HTTP 协议支持。
我们要给 asio 的 socket 增加异步关闭功能，是实打实的让asio多了原本不存在的功能。那么显然，这样的功能，首先我们得问一问，操作系统支持吗？
如果操作系统不支持一个功能，我们想破天也没法给asio扩展出这个功能。&lt;/p&gt;
&lt;p&gt;答案是，异步关闭socket只有io_uring支持了。windows 上虽然也支持异步关闭，但是需要使用 WSAEventSelect + WSAWaitForMultipleEvents + shutdown 组合使用。IOCP不支持异步关闭。没有能传 overlaped* 的 WSAShutdown 版本。&lt;/p&gt;
&lt;h1 id=&#34;asio-的接口组织结构&#34;&gt;asio 的接口组织结构&lt;/h1&gt;
&lt;p&gt;asio 暴露给用户的接口为2种对象，其一为 executor ，其二为 io_object. executor 一般而言就是 asio::io_context。而 io_object 则通常就是 socket 咯。&lt;/p&gt;</description>
    </item>
    <item>
      <title>重叠IO（proactor）是最理想的IO模型</title>
      <link>https://microcai.org/2024/11/19/proactor-is-better-than-reactor.html</link>
      <pubDate>Tue, 19 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/19/proactor-is-better-than-reactor.html</guid>
      <description>&lt;p&gt;reactor 和 proactor ， 这种毫无联系的英文专用名词，很容易把人弄晕。&lt;/p&gt;
&lt;p&gt;回归正途，使用精确的汉语描述，而非翻译，则正确的说法是：&lt;/p&gt;
&lt;p&gt;多路复用IO 和 重叠 IO 模式。&lt;/p&gt;
&lt;p&gt;所谓多路复用，顾名思义，就是好几个IO复用。。。 复用了谁？复用了线程。
它对比的是最传统的UNIX网络编程： 一个连接一个线程。并发就要开多线程。连接多了，线程就多，系统压力非常大。
而多路复用，则可以让一个线程处理多个连接。这就是复用的含义。为了实现复用，首先IO是非阻塞的。因为如果阻塞了线程，其他连接上的数据不就没法处理了么。既然非阻塞，那就会出现网络数据没准备好，就一直返回 EAGAIN 错误。一直返回难道一直重试吗？显然不现实。所以就有了一个 多路复用器。这个多路复用器最早是 select() 调用。后来是 poll() 最后是 epoll().
而重叠IO,顾名思义，就是 IO 操作是重叠的。和什么重叠？当然是和你当前的线程是重叠的。
也就是，向系统提交一个 IO 操作， 系统就会在“后台”默默的干苦力，当前线程可以立即执行其他任务。不会被阻塞。他和多路复用模式的区别是，多路复用模式，如果会阻塞，内核就返回会阻塞，而不是在后台默默干活。而 重叠IO 则即不会阻塞，也不会返回“请重试”。而是在后台开始默默的进行处理。这个IO的处理，和你程序本身的逻辑，是重叠进行的。所以叫重叠IO。&lt;/p&gt;
&lt;p&gt;话又说回来了，系统是在后台干活了，你得知道他啥时候干好了吧？总不能两眼一摸黑，不知道了吧。
因此，系统需要一个通知机制。Linux 这边，曾经有一种叫 AIO 的东西，它用 “信号” 来通知 IO 完成了。而如今 Linux 使用 io_uring 的 无锁列队 来完成通知。而 windows 则使用 一个叫“完成队列”的东西来通知，当然也可以使用 窗口消息来通知结果。&lt;/p&gt;
&lt;p&gt;不管是 win 的窗口消息，还是linux的 AIO ，在实践中都被人抛弃不用了。因此不讨论这些。&lt;/p&gt;
&lt;p&gt;我们讨论 IO完成端口，和 io_uring, 他们本质上是一样的，就是提供一个异步队列，然后应用层可以使用 一个或多个线程，去读取这个队列获得完成通知。每一个IO操作，都对应一个完成通知。
因此，重叠IO模式，其实和传统的编程思路是一致的：每调用一个函数，就获得一个返回值。
无非是，这个返回不是通过 ret 指令返回，返回结果也不是通过 EAX 寄存器返回。
而是存放到了一个消息队列里。&lt;/p&gt;
&lt;p&gt;但是，操作请求和结果返回，是一一对应的。这是一种非常自然的概念。
自然而然的，在编程上，就可以设计为 IO发起 + 完成回调。
库的作用，就是封装 系统的 IO api ，然后将 IO完成消息转化为 完成回调。
有了 IO发起+完成回调。很自然的，程序就可以组织为一种 协程结构。 发起IO操作，返回一个 promise . IO完成就是让 promise 完成状态。
想同步IO结果，只要 await 这个 promise 就可以了。
非常的容易理解，而且封装起来也非常的轻松。用起来简直就是爽到high起。&lt;/p&gt;</description>
    </item>
    <item>
      <title>真正的重叠IO</title>
      <link>https://microcai.org/2024/11/18/real-overlaped-io.html</link>
      <pubDate>Mon, 18 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/18/real-overlaped-io.html</guid>
      <description>&lt;p&gt;不知有没有人想过，为何微软将windows 的异步API称为“重叠IO”而不是异步IO。&lt;/p&gt;
&lt;p&gt;在我看来，重叠IO和异步IO的区别，主要在于发起IO后的动作。&lt;/p&gt;
&lt;p&gt;重叠IO, 发起 IO 后，继续执行应用层的逻辑。应用可以选择在任何何时的地点再选择同步（阻塞等待 or 异步等待）IO的结果。
异步IO, 发起 IO 后，立即挂起当前业务逻辑（也就是立即非阻塞等待 IO 结果），回到事件循环，以便执行其他业务逻辑。&lt;/p&gt;
&lt;p&gt;放到协程的设计角度，重叠 IO 相当于这样使用&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-js&#34; data-lang=&#34;js&#34;&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;async&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;function&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;do_read&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;let&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;read_promise&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;file&lt;/span&gt;.&lt;span style=&#34;color:#a6e22e&#34;&gt;read&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:#a6e22e&#34;&gt;干点不依赖&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;IO&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#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;let&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;read_result&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;await&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;read_promise&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;干需要&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;IO&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#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;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;而异步 IO, 则是这样使用&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&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;awaitable&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; function &lt;span style=&#34;color:#a6e22e&#34;&gt;do_read&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;auto&lt;/span&gt; read_result &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; co_await file.&lt;span style=&#34;color:#a6e22e&#34;&gt;async_read&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:#75715e&#34;&gt;// do other logic.
&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;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;可以看出来，重叠 IO 在发出 IO 操作后，可以继续执行其他逻辑。只有当确实需要数据的时候，再进行等待。
而异步IO模式下，发出IO后，必须立即挂起当前协程等待IO完成。&lt;/p&gt;
&lt;p&gt;那么，这两种差异，对现实中的程序有什么影响呢？&lt;/p&gt;
&lt;p&gt;我们先考虑一个最简单的应用： 静态 web 服务器。&lt;/p&gt;
&lt;p&gt;在静态web服务器里，最核心的处理逻辑，就是找到用户要下载的文件，然后将文件发送给客户端。伪代码如下&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&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;awaitable&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; handle_send_file(&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; target, &lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; socket)
&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;char&lt;/span&gt; buffer[&lt;span style=&#34;color:#ae81ff&#34;&gt;65536&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;    fs&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;file f(target, flags&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;binary&lt;span style=&#34;color:#f92672&#34;&gt;|&lt;/span&gt;flags&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;open);
&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;long&lt;/span&gt; total &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&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;for&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;auto&lt;/span&gt; read_size &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;co_await&lt;/span&gt; f.async_read_some(buffer);
&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;if&lt;/span&gt; (read_size &lt;span style=&#34;color:#f92672&#34;&gt;==&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&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;break&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        total &lt;span style=&#34;color:#f92672&#34;&gt;+=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;co_await&lt;/span&gt; socket.async_write_some(buffer, read_size);
&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&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;co_return&lt;/span&gt; total;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;在这个代码里，主要的逻辑就是 循环读取文件，然后发送。&lt;/p&gt;</description>
    </item>
    <item>
      <title>不要 new 一个 char 数组当缓冲区</title>
      <link>https://microcai.org/2024/11/16/do-not-new-a-buffer.html</link>
      <pubDate>Sat, 16 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/16/do-not-new-a-buffer.html</guid>
      <description>&lt;p&gt;性能调优是一个有魔力的工作。最近研究到了 &lt;code&gt;std::pmr::&lt;/code&gt;, 就想着看能否有些老代码能改进改进，提高下性能。&lt;/p&gt;
&lt;p&gt;但是，测试的时候，发现还是有一些路径的效率不理想。&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;auto&lt;/span&gt; buffer_size &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;5&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1024&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1024&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;auto&lt;/span&gt; buffer &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;make_unique&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;char&lt;/span&gt;[]&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;(buffer_size);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;好家伙，原来 &lt;code&gt;make_unique&amp;lt;char[]&amp;gt;&lt;/code&gt; 这么慢的吗？&lt;/p&gt;
&lt;p&gt;原来 make_unique 不单单是 分配了 buffer_size 个字节的内存，同时还 构造了如此数量的 char 对象。
问题是我这只是个 buffer, 不需要初始化啊！&lt;/p&gt;
&lt;p&gt;继续查看生成的汇编代码，发现 make_unique 还是很聪明的，并没有在一个 for 循环里调用5百万次 char 的构造函数。
看来第一种 for 循环五百万次赋值 0 的担忧是没了。
结果看到了汇编代码里的 &lt;code&gt;call memset@plt&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;所以说，哪怕编译器自动的把初始化代码优化为了一个  memset 调用，它还是调用了 memset ， memset 对一个 5MB 的内存，还是要花点时间的。&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;auto&lt;/span&gt; buffer_size &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;5&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1024&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1024&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;unique_ptr&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;, &lt;span style=&#34;color:#66d9ef&#34;&gt;decltype&lt;/span&gt;(&lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt;std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;free)&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; buffer(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;malloc(buffer_size), &lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt;std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;free);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;测试发现性能飙升了十几倍。&lt;/p&gt;
&lt;h1 id=&#34;总结&#34;&gt;总结&lt;/h1&gt;
&lt;p&gt;在不需要初始化的 buffer 分配领域，使用 malloc 是比 new 更好的选择。&lt;/p&gt;</description>
    </item>
    <item>
      <title>可变模板参数包迭代</title>
      <link>https://microcai.org/2024/11/13/range-for-on-parameter-pack.html</link>
      <pubDate>Wed, 13 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/13/range-for-on-parameter-pack.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&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;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt;... Args&lt;span style=&#34;color:#f92672&#34;&gt;&amp;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;int&lt;/span&gt; print(Args... args);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;那么，要如何去访问这些可变的参数呢？&lt;/p&gt;
&lt;h3 id=&#34;方法-1&#34;&gt;方法 1&lt;/h3&gt;
&lt;p&gt;使用递归法。比如定义2个 print, 一个是单参数的，另一个是 2个模板参数的。&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;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; Arg&lt;span style=&#34;color:#f92672&#34;&gt;&amp;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;int&lt;/span&gt; print(Arg arg);
&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;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; Arg1, &lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt;... Args&lt;span style=&#34;color:#f92672&#34;&gt;&amp;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;int&lt;/span&gt; print(Arg1 arg1, Args... args)
&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;	print(arg1);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	print(args...);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;在可变参的 print 里， 它首先将第一个参数调用了单参数版的 print. 接着把剩下的参数调用自身。&lt;/p&gt;
&lt;p&gt;如果剩下的参数就一个了，那么编译器也是匹配到单参数版的 print 从而结束递归。&lt;/p&gt;
&lt;h3 id=&#34;方法-2&#34;&gt;方法 2&lt;/h3&gt;
&lt;p&gt;使用 &lt;strong&gt;折叠表达式&lt;/strong&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;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt;... Args&lt;span style=&#34;color:#f92672&#34;&gt;&amp;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;int&lt;/span&gt; print(Args... args)
&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;	(print_one(args), ...);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;在这个方法里，&lt;code&gt;(print_one(args), ...);&lt;/code&gt;就是所谓的 &lt;strong&gt;折叠表达式&lt;/strong&gt;。 它的意思就是把 前面的 重复一下。每次重复的时候，各使用参数包里的一个参数。&lt;/p&gt;
&lt;h3 id=&#34;方法-3&#34;&gt;方法 3&lt;/h3&gt;
&lt;p&gt;打包进 std::tuple 后使用。比如&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;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt;... Args&lt;span style=&#34;color:#f92672&#34;&gt;&amp;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;int&lt;/span&gt; print_tuple(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;tuple&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;Args...&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; tuple_arg)
&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&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;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt;... Args&lt;span style=&#34;color:#f92672&#34;&gt;&amp;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;int&lt;/span&gt; print(Args... args)
&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;	print_tuple(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;forward_as_tuple(args...));
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;吼吼，那么问题来了， tuple 版本要怎么实现？&lt;/p&gt;</description>
    </item>
    <item>
      <title>把闭包变成函数指针—— trampoline 原理解析</title>
      <link>https://microcai.org/2024/11/02/lambda-to-function-pointer.html</link>
      <pubDate>Sat, 02 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/02/lambda-to-function-pointer.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;十年前，我曾经写过一个让 C 形式的回调函数支持 闭包的小转换工具, &lt;a href=&#34;https://github.com/avplayer/avboost/blob/master/include/boost/cfunction.hpp&#34;&gt;见这&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;那时候，我说过，要想把 boost.function 传给 C 接口，那这个 C 接口，必须得带一个 &lt;code&gt;void* user_data&lt;/code&gt; 的参数。&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;typedef&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;int&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;callback_t&lt;/span&gt;)(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg1, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg2, &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; user_data);
&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;bool&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;register_callback&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;callback_t&lt;/span&gt; cb, &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; user_data);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;可以利用这个 cfuntion，把 &lt;code&gt;boost::function&amp;lt;int(int, int)&amp;gt;&lt;/code&gt; 给当成 callback_t 使用。
而 boost::function 本身又可以接受 lambda, boost::bind ， 从而组合出非常易用的使用方式。&lt;/p&gt;
&lt;p&gt;但是，这十年来，我也偶尔会遇到一些 C 库的 api ， 他就只能接受裸指针，不能接受 &lt;code&gt;void* user_data&lt;/code&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:#a6e22e&#34;&gt;int&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;callback_t&lt;/span&gt;)(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg1, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg2);
&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;bool&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;register_callback&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;callback_t&lt;/span&gt; cb);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这就很难受了。因为没有办法传递 void*, 也就无法给回调函数设置“上下文”。也就彻底失去了上下文关联能力了。不得不将所需的
数据通过“全局变量”传递给回调函数。十分丑陋不说，还导致回调函数变成了无法重入的。&lt;/p&gt;
&lt;h1 id=&#34;转机&#34;&gt;转机&lt;/h1&gt;
&lt;p&gt;其实，如果使用 GCC 编译器，GCC 也提供一个叫 “nested function” 的功能，比如&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:#a6e22e&#34;&gt;int&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;callback_t&lt;/span&gt;)(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg1, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg2);
&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;bool&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;register_callback&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;callback_t&lt;/span&gt; cb);
&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;int&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;main&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;int&lt;/span&gt; hello &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#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&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;nested_function&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg1, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg2)
&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:#a6e22e&#34;&gt;printf&lt;/span&gt;(&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;hello = %d&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;\n&lt;/span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;&lt;/span&gt;, hello);
&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&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#a6e22e&#34;&gt;register_callback&lt;/span&gt;(nested_function);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这个 nested_function 能访问 main 里定义的对象，算的上一种“闭包”了，但是，它仍然可以转换为不需要 void* 的裸函数指针。&lt;/p&gt;</description>
    </item>
    <item>
      <title>类型萃取技术：函数签名当模板参数</title>
      <link>https://microcai.org/2024/11/01/function-signature-as-template-parameter.html</link>
      <pubDate>Fri, 01 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/01/function-signature-as-template-parameter.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;在 &lt;a href=&#34;https://microcai.org/2024/11/01/type-erasuer.html&#34;&gt;上一篇&lt;/a&gt; 文章里，我提到了 std::function 的模板参数，是一个叫&lt;strong&gt;函数签名&lt;/strong&gt; 的东西。&lt;/p&gt;
&lt;p&gt;什么是函数签名？&lt;/p&gt;
&lt;p&gt;比如 main 函数，他的签名是 &lt;code&gt;int(int, char**)&lt;/code&gt;。所谓函数签名，是指函数声明去掉 函数名和变量名 后得到的一个精简描述。 这个精简描述，指导编译器如何按”调用约定“产生具体的汇编指令以调用一个函数。&lt;/p&gt;
&lt;p&gt;函数名，不过是在最后的 call 指令里，提供了具体的目标地址。&lt;/p&gt;
&lt;p&gt;但是，如果你问 decltype(&amp;amp;main) 的类型是啥，其实他的类型是&lt;code&gt;int (*)(int, char**)&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;因为 &amp;amp;main 是 main 函数的函数指针。 函数签名是形如 R(args&amp;hellip;) 的东西，而函数指针的类型，就是 R (*)(args&amp;hellip;)&lt;/p&gt;
&lt;p&gt;函数签名甚至不是一个合法的类型，你不能定义  &lt;code&gt;int(int,int) p;&lt;/code&gt; 这样的一个变量。
但是你可以用 &lt;code&gt;int (*p)(int, int)&lt;/code&gt; 定一个 函数指针 p, 其指向的函数，具有 &lt;code&gt;int(int, int)&lt;/code&gt; 这样的签名。&lt;/p&gt;
&lt;p&gt;那么，对于  std::function 来说，他的模板参数要怎么写，才能接受一个签名呢？&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;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; Signature&lt;span style=&#34;color:#f92672&#34;&gt;&amp;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;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;function&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;那么有人问了，这 Signature 就一个类型啊，那 function 的 括号操作符 要怎么写？&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Signature operator()(Signature)&lt;/code&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;</description>
    </item>
    <item>
      <title>重提类型擦除器</title>
      <link>https://microcai.org/2024/11/01/type-erasuer.html</link>
      <pubDate>Fri, 01 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/01/type-erasuer.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;十年前，我曾经写过一篇有关类型擦除器的文章, &lt;a href=&#34;https://microcai.org/2014/04/21/type-erasure.html&#34;&gt;见这&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;十年后，我打算再探讨下类型擦除器。&lt;/p&gt;
&lt;p&gt;C++ 对 多态 的支持，在核心层面，就两条： 虚继承 和 模板。&lt;/p&gt;
&lt;p&gt;假设你要设计一个 线程池。这个池你可以“投递”各种任务进去。&lt;/p&gt;
&lt;p&gt;什么叫”任务“呢？ 就是一段代码。于是，早期你想到，可以使用 函数指针。&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;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;threadpool&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;typedef&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;void&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;task_function_t)();
&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;	std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;list&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;task_function_t&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; tasks;
&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;public&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 style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; post(task_function_t job);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;};
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这样的代码，有个问题，那就是你“投递” 的任务，他干活得有数据。如果投递的任务，只能是一个函数指针。
那么这个函数，就得使用“全局变量“来传递工作内容了。&lt;/p&gt;
&lt;p&gt;所以说，这个 task ，不能是个函数指针。它得携带对象。&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&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;task&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;public&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 style=&#34;color:#66d9ef&#34;&gt;virtual&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; run() &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&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;virtual&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;~&lt;/span&gt;task(){}
&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&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;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;threadpool&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;	std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;list&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;task&lt;span style=&#34;color:#f92672&#34;&gt;*&amp;gt;&lt;/span&gt; tasks;
&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;public&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 style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; post(task&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; job);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;};
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;显然，如果要给任务携带点状态，就可以写一个 task 对象，比如&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-cpp&#34; data-lang=&#34;cpp&#34;&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;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;some_task&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt; task
&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;int&lt;/span&gt; work_arg1;
&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;int&lt;/span&gt; work_arg2;
&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;public&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;	some_task(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg1, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg2);
&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:#a6e22e&#34;&gt;run&lt;/span&gt;() &lt;span style=&#34;color:#66d9ef&#34;&gt;override&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:#75715e&#34;&gt;// do some work with args.
&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&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;};
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;想要带上啥状态，一股脑的给添加到自己写的派生类里就行了。&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>高并发服务器的静态内存分配策略</title>
      <link>https://microcai.org/2018/10/25/static-memory-allocation-made-server-fast.html</link>
      <pubDate>Thu, 25 Oct 2018 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2018/10/25/static-memory-allocation-made-server-fast.html</guid>
      <description>&lt;p&gt;asio 的 async_accept 函数在高并发的时候，会发生遗漏 accept 的情况。根本原因在于，async_accept 回调的时候，已经 监听的socket已经没有执行 accept 操作了。
解决的办法就是投递多个 async_accept. asio 的 async_* 系列 函数通常只能投递一次，多次投递会发生未定义行为。async_accept 是为数不多的例外。&lt;/p&gt;
&lt;p&gt;通常在写一个 server 的时候，client 是采取 accept 一个就 make_shared 一个的做法。对于大量频繁的连接请求，make_shared 很快就会成为新的瓶颈。
在读 beast 的 example/http/fast_server 的时候，发现了 beast 对这个问题的解决方案，非常的聪明。&lt;/p&gt;
&lt;p&gt;beast 的做法就是，固定的 client 对象。每个 client 自己投递 async_accept 请求，把自己的 socket_ 投递给 async_accept。
async_accept 返回后， client 就对自己的 socket_ 执行处理， 该 read read，该 write 就 write。
直到这个 client 的请求全部处理完毕，连接也 shutdown 后， 它就再次投递 async_accept 进入下一个循环。&lt;/p&gt;
&lt;p&gt;在这个模式下，client 对象并没有被不断的 new 出来。 client 对象的数目是固定的。他利用了 async_accept 可以多次投递的 feature。
在超大量的请求下，该模式始终不会产生频繁的内存分配和释放请求，不仅仅加快了速度，而且也极大的避免了内存碎片。&lt;/p&gt;</description>
    </item>
  </channel>
</rss>
