异步电机控制何以复杂

一言以蔽之:因为有两个控制维度。 控制维度 在自动控制系统里,系统通过传感器观察被控对象,然后通过执行器施加控制。 传感器的输入,被称为 被控量,而传递给执行器的命令,叫控制量。 当一个被控量可以用多个控制量影响的时候,这个控制量的数量,就是控制维度。 绝大多数时候,我们都喜欢一维控制。 为何呢? 一维控制 还是拿电机举例。先举例直流有刷电机。 被控量是电机转速,控制量是 电压,或者占空比。 控制器要影响电机的转速,唯一能控制的量,就是自己输出给电机的电压。 有的人说是电流?但是电流也是电压的结果。控制电流大小归根结底也是通过控制输出电压实现的。 如果把有刷电机,换成无刷电机。 看似执行机构变了, MOS 管数量从4个变成了 6个。 但是,实际上控制器最终能控制的量,也只有唯一的一个:电压。 因为对于无刷电机来说,控制器输出的是三相平衡交流电。 三相平衡的交流电,实际上有2个自由度:电压和频率。 因为是三相平衡的,因此3条线的电压,实际上只有一个自由度,而不是3个。 看似控制器可以控制电压和频率2个量,实际上控制器只能控制电压。 因为对于永磁同步电机来说,输入的交流电的频率和相位,必须和转子同步。 意味着,频率或者相位,并不是一个可选的自由度,必须跟随转子同步。 控制器唯一能控制的量,就剩下了一个:电压。 这也是为何永磁同步电机,或者说无刷电机,大受欢迎。因为控制起来和直流有刷电机是一模一样的,都是唯一一个电压这个控制量。 二维控制 但是,如果电机换成了异步电机,情况就发生了翻天覆地的变化。 因为,异步电机是“异步”的。控制器输出的三相电,频率,还真就有了自由度。他不必跟随转子同步。甚至绝对不能和转子同步。还必须有个差。 更要命的是,增加电压和提高频率,二者都可以提高电机转速: 也就是说,如果电机转速(被控制量)和实际目标有偏差,控制器有2个自由度实施校正:它可以改变电压,也可以改变频率。 2个控制自由度,看似 “灵活” 实则给控制算法摆出了一个天大的难题。 异步电机的矢量控制 电机控制,控制的是磁场。异步电机的运行原理和同步电机并没有本质区别:定子磁场带着转子磁场运动。 无非是,同步电机的转子磁场被转子物理锁定,转子磁场和转子本身没有相对运动。 而异步电机的转子磁场和转子本身有一个漂移运动。 如果先无视这个漂移运动呢?那么就可以使用和无刷电机一模一样的算法来控制定子磁场了。 于是这个2个控制自由度,就下降为一个了。 真的吗? 异步电机的矢量控制,本质上是把异步电机这一个整体,看成了 一个同步电机+液力变矩器。液力变矩器的输入和输出之间,有一个转速差,所传递的扭矩大小,正比于这个转速差。 但是,困难的地方在于,这个同步电机无法安装传感器,传感器只能安装在液力变矩器的输出端。 于是这个(虚拟的)同步电机的转子,其磁场的真正朝向,就只能靠“猜”了。 而要猜,就必须依靠电机的电动力学方程。要求解,就必须带入电机参数。 恰恰这个“电机参数”,是非常难以精确获得的。他随着工况会随时变化。 哪怕我们忽略这部分的困难,还有另一个问题: 这个液力变矩器对扭矩的传递,也有控制量! 因此,实际上还是有2个控制自由度。完全没有下降。 对于一个控制偏差,算法既可以调整(虚拟的)同步电机的转速来修正,也可以通过调节液力变矩器的传递效率(扭矩增益)进行修正。 因此, 异步电机的矢量控制,实际上它的控制量也是两个, 不是 电压+频率, 而是 电压+液力变矩器的扭矩增益。 自由度实际上完全没有下降。 还带来了这个 (虚拟的)同步电机 转子位子本身的猜测困难问题。 哪怕加了传感器,还是需要电机参数,还需要“猜”转子磁场位置。 传感器加了一个寂寞。 要知道,在永磁同步电机控制里,物理上的传感器可以让控制器完全抛弃电机参数。只有无传感器控制才依赖电机参数去猜转子的位置。 因此,矢量控制放到异步电机上,其实就是死路一条。 转差频率控制 在 转差频率控制 里,我们认为,异步电机的扭矩 = 转差频率*励磁电流。 ...

May 25, 2026

异步电机控制

超越开环 要不怎么说, AI 极大的促进了知识的传播。 我很多年前,就做了一个变频器。 但是,一直都是使用 V/F 开环控制。 使用开环控制,简单,好用,便宜。 但是,如何进行闭环控制呢? 滑差频率控制 我第一时间就想到了控制滑差率。 一开始,我的想法是这样的: 假设控制目标是一个转速。转速 S 是控制目标。 直接输出 S+转差 是不行的。 所以,需要几个 PID 控制环。 我最初的设想是这样的,如果是一台直流电机,做闭环转速控制是怎么做的? 答案是 转速环-》扭矩环(电流环)-》PWM 占空比。 或者,可以一步到位,转速环-》PWM 占空比。 转速高了,就降低 pwm 占空比,低了,就提高占空比。占空比本质上是控制电压。 于是,我在异步电机这里,这么设计: 转速环-》电压。 然后根据转差率,直接确定输出频率。频率不用一个闭环进行控制,而是通过测量转速,直接乘上一个转差率,得到输出频率。 这个转差率,由当前的负载情况,可以直接计算出一个最优转差率。所谓最优转差率,就是效率最高的转差率。低了,铁损增加,高了,铜损增加。 然后,我遇到了一个很现实的问题:就是转速环一开始就会输出一个很高的电压! 但是,我认为,可以加入一个恒流恒压控制。只要设定了最大电流,电压就自动被控制住了。 然而,现实的情况是,这种限制最大电流的模式,其实并不适用。这意味着启动的时候电机会一直处于磁通饱和状态。而且这种饱和状态,还使用个屁的最佳转差率,根本就破坏了最佳转差率的存在前提嘛。 经过和 AI 的反复沟通,推翻了各种方案,最终我确定了以下方案: 转速环(输出扭矩参考)-》扭矩环(输出频率) 电流环(维持励磁电流)-》输出电压 电流环是独立运行的一个控制环,他控制输出电压,以维持在当前频率下的励磁电流为一个定值。 扭矩环接受转速环(或者位置环)的输出,根据转子转速直接确定输出频率。 这个频率的确定方式是:输出频率 = 转子频率 + 扭矩参考*最大转差频率。 扭矩参考是一个 [-1,1] 的数值。最大转差频率是和电机有关的一个参数,计算方式是:最大转差频率 = 转子的电阻 ÷ (2π × 转子的电感) 滑差频率控制的底层物理原理 为啥是这个频率呢?因为异步电机的扭矩,说到底是定子磁场*转子磁场*攻角。 而转子磁场,就是由 转差频率 供电的。 当转子的电阻和电抗相等的时候,转子电流出现最大值。继续提高转差频率,转子电抗会增加导致电流下降。因此,使转子的电阻和电抗相等的频率,就是最大转差频率。 更进一步的来说,电机扭矩 = 定子磁场矢量 叉乘 转子磁场矢量。 这对任何电机都是成立的。 ...

May 10, 2026

编译期构造只读容器

我在设计变频器的红外遥控处理的时候,定义了一个 map 容器。 这个容器很简单,就是一个 int 对 int 的映射。 把 红外遥控器的按键ID, 映射到我内部定义的一个 枚举命令id 上。 这样只要修改这个 map 容器,就可以适配多种红外遥控。 但是,我发现,这个 map 容器哪怕定义为 const 变量也没用,他依旧是分配在内存里的。而且是分配在宝贵的堆内存里。 不仅仅如此,这个 map 容器的构造还会在运行时分配大量的细碎内存块。 除了占用运行时内存,他对单片机flash的占用并不消失。因为构造这个map所需的原始数据还是需要躺在 .rodata 段里。 既然这个 map 容器是只读的,那么为啥我需要在运行时分配这么多的内存? 直接在编译期就构造好一个map,然后在运行时直接使用,岂不更好? 我试着给 std::map 前面添加一个 constexpr 修饰符,结果编译失败。 看来 std.map 并不能简单的通过 constexpr 变成编译期构造。 由于 单片机的内存有 8KB 之巨,很长一段时间里我都没有遇到内存不足问题。直到最近为了缩减代码体积,把一些本该无栈协程实现的代码替换成了有栈协程。编译后能缩减数个KB的体积。 结果遇到莫名其妙的硬件错误。调试了许久才发现原来是内存分配失败导致的。 于是想在其他地方扣点内存出来,于是重新盯上了这个 map 容器。 我最初的做法本来是想自己手搓一个。 但是,如此需求,难道真只有我有吗? 如果并不是我独有的需求,应该已经有前人已经实现过了。不能动不动就重复发明轮子呀! 于是我找啊找,找到了这个 frozen 库。 #include <map> static const std::map<ir_command, UserCommand> ir_command_map = { {0x0002000D, UserCommand::speed_0}, ... 这样的代码,被替换成了 #include <frozen/map.hpp> static constexpr frozen::map<ir_command, UserCommand, 41> ir_command_map = { {0x0002000D, UserCommand::speed_0}, ... 然后重新编译,代码体积略微膨胀。但是运行时的堆内存占用一下减小千余字节。 代码膨胀,是因为原来编译器会把这 41 个 KV 对,一共 82 个数字存在 .rodata 段里, 然后在 启动的时候调用构造函数构造 map。如今编译器直接在 .rodata 段里构造出一个 map 容器的二叉树。在运行时直接在这个只读的,放在 FLASH 而不是 RAM 里的 二叉树进行查找。不需要构造了。因此减少了 RAM 的使用。但是存在 .rodata 段的二叉树,比原始的82个整数要多占一些空间。

April 22, 2026

调用约定和上下文切换

编写协程库的时候,我常常在想,上下文切换的速度,受调用约定的影响非常大。 因为用户协程的上下文切换,本质上是调用一个 函数。而这个函数需要 “切换” 非易失性寄存器。 因此,在给定的调用约定下,非易失性寄存器越多,则上下文切换时需要保留和恢复的寄存器数量就越多。 而由内核进行上下文切换(也就是线程),所有寄存器都得保留。开销是最大的。何况还有执行特权级切换的巨大开销。 在知乎上发表的批评 云风的 coroutine 库的文章的评论区里,有个人提到了 这篇文章。 好家伙,他们对内联汇编玩出花来了。使用内联汇编的 clobbered registers 列表来自动生成寄存器的保存和恢复代码。 然后,他们给 clang 提了一个补丁,增加了一个叫 preserve_none 的调用约定。 所谓 preserve_none,顾名思义,就是这个调用约定下,尽可能啥寄存器都不保留,全是易失性寄存器。 于是,如果使用 preserve_none 的调用约定实现 zcontext_swap, 则代码里并不需要保留上下文。只需要切换 rsp 寄存器,然后调用下 hook 即可返回了。 zcontext_swap_preserve_none: // 保存frame寄存器 push %rbp // 切换栈指针 mov %rsp, (%r12) mov (%r13), %rsp // 恢复 frame 寄存器 pop %rbp // if(hook_function) hook_function(argument); test %r14, %r14 jne 1f // 返回 argument mov %r15, %rax // 返回 ret 1: // 如果有 hook ,则调用 hook 后返回 mov %r15, ARG1_REG mov %r15, %r12 // 同时兼容 preserve_none 调用约定 的 hook jmp * %r14 // 开启尾调用优化. 在 无 hook 的情况下,只需 8 条指令即完成上下文切换。 ...

January 3, 2025

协程切换为什么需要 一个 hook_function 参数.

前言 刚刚,我将 zcontext 的 API 进行了以下修正。 从 void* zcontext_swap(zcontext_t* from, zcontext_t* to, void* argument); 改成了 typedef void* (*zcontext_swap_hook_function_t)(void*); void* zcontext_swap(zcontext_t* from, zcontext_t* to, zcontext_swap_hook_function_t hook_function, void* argument); 增加了一个 hook_function。这是为何呢?这个 hook_function 又是怎么使用的呢?在什么情况下运行呢? 别着急,我一一道来。 需求1:自动进行栈回收 协程需要分配一个新栈。而协程执行完毕的时候,需要对分配的栈内存进行回收。 而协程自身是无法执行这个任务的。协程只有不在运行状态,他的栈才能释放。而他在运行状态下,又如何调用 free 释放自己呢? free 本身运行也依赖栈。free 不能把自己正在使用的栈给释放了。 因此,这个需求我用了一些比较绕的方法实现了。其实就是让调度器负责回收。这就限制了调度器只能跑在主线程上。 并且调度器(主事件循环)需要和协程的代码进行一定程度的耦合。 但是为了解决内存泄漏,这个耦合也是不得不为之。其实应该有更好的解决方法的。 需求2:线程安全的协程切换 在多线程运行调度器的情况下,可能发生协程切换的竞争。具体情况如下: 假设运行2个线程执行 GetQueuedCompletionStatus。姑且称为 主线程A, 主线程B. 为了更好的性能,通常的做法是让线程A负责 accept, 而线程B负责处理客户端连接。如果处理客户端有瓶颈,还可以创建更多的线程处理。 这里先简化为2个线程。 系统运行若干个 Accept 协程。并且在接受一个新连接后,创建一个新的处理协程来处理新的连接。 姑且称是协程A吧。某个协程 A 拿到了一个新连接后,创建一个新的处理协程来处理新的连接。 姑且称这个刚刚创建的新协程为 协程C,这个新接受的连接对应 socket C。 好了,协程A, 接受了一个新连接,然后创建了 协程 C。此时协程 C 和协程 A ,都是在主线程 A 上运行的。 这时,我们要往socket C 上投递 WSARecv 了。此时投递是在 主线程A上进行的。由于 socket C 绑定了线程B的 IO完成端口,因此稍后 会在主线程 B 上获得完成事件。此时协程 C 是在 线程 A 上运行的。调用 WSARecv 后,紧接着就要进行“协程挂起”操作。 正常来说,线程B获得socket C 的完成事件后,就会恢复协程C。于是,协程 C 后续就在 线程 B 上运行了。 ...

December 28, 2024

从0开始写上下文切换

有栈协程的核心是执行上下文。执行上下文的核心是栈。 因此,切换栈就等于切换了上下文。 栈在协程切换上的核心地位 栈,存储了一个协程/线程 的“调用链”,以及依附于这条链上的“变量”。 没有栈,ret 指令将无所适从。 虽说栈是核心,但是栈本质是堆叠存储“历史 寄存器状态”。而当前没有入栈的寄存器状态,才是真正的当前上下文。 因此,很多古代协程库的做法,是栈协程“句柄” 上,开辟一个数百字节的空间。用于存放当下的CPU寄存器的数值。 上下文切换的时候,就是把当前 cpu 寄存器拷到句柄空间,然后从新协程的句柄空间里把寄存器的值一个一个读回来。 这种做法,是认可 “CPU寄存器数值的集合” 是当前上下文。栈不过是其中一个寄存器指向的一块内存区域,没什么特别的。 但是,boost.fcontext 另辟蹊径。他唯一指定 栈为协程的正统核心。当前的 cpu 寄存器状态,可以通过“调用 上下文切换” 函数,变成 上一层的 “历史状态”。 于是本层所要做的,就只是切换栈。在切换栈前,也只须将本层寄存器状态入栈。切换后,再将寄存器状态出栈。 因此,在 boost.fcontext 眼里,代表协程正统的,不是那个存储了几百个字节的寄存器数值的句柄空间,而是 栈顶指针。 而用于引用协程的那个句柄, fcontext_t 结构,不过就是存储了一个栈顶指针。 而不像 ucontext_t 那样,好家伙洋洋洒洒数百字节体积。 这就是对“何谓上下文”的理解理念不同带来的设计差异。 这点设计差异,造成了数据结构的不同。数据结构都不同了,自然上下文切换的代码也不尽相同了。正是所谓的,数据结构决定了算法。 来个上下文切换代码看看 作为对比,看下 ucontext 系是怎么做上下文切换的: 这就是不同的设计理念带来的差异。 ucontext 认为 cpu寄存器是上下文,栈只是其中一个寄存器所引用的附属上下文。 而 boost.fcontext 则认为,栈就是上下文的全部。包括了所有的寄存器历史。 所谓寄存器的历史,是说进行函数调用的时候,编译器会生成入栈指令保留寄存器的数值,以便函数返回后能恢复这些寄存器的值。于是在调用链上,每一层调用帧上面都保留了一份寄存器的“快照‘ 既然寄存器的快照就在栈上留着,那只要把当前的状态再“压栈”一次。那么所有的上下文,不就都用一个栈顶表达了吗? 显然我们会发现,将栈视为协程的核心,能极大的简化代码。 这点差异,还影响了 make_context 的设计。 新建协程 一个协程上下文切换库,只需要编写3个函数 上下文切换 新上下文创建 新上下文的出生点 其中,新建上下文的出生点代码,是不需要暴露给用户的内部使用代码。另外两个,是作为库接口的形式存在的。 上下文的切换,在上节已经赘述过了。就是当前状态 push 入栈。然后切换栈顶,然后 pop 出栈。大功告成。 傻瓜式的代码。 ...

December 26, 2024

链接到 ucrtbase.dll

使用 vc6.0 以后的 VS 编译器,最恼火的一点就是生成的 exe 依赖 msvcrXXX.dll。 其中 XXX 是个版本号。而且 msvcrXXX.dll 系统是不自带的。 于是每个 exe 都得带上 vcredist.exe 安装程序。 过于蛋疼。 正统的解决方法是改使用静态C库。 但是会带来二进制体积暴涨的问题。 十分的怀念 VC6.0 可以生成exe 依赖 msvcrt.dll, 不带版本号那种。而不带版本号的那个,每个 windows 都会自带。 有比较多的偏门方式,可以在 vc6 以后的版本继续链接到 msvcrt.dll 。但是一来是偏方,而来在 vs2017 以后这些偏方也没用了。 后来对此也不甚钻研了,直接无脑静态链接了。 最近,突然又关心起 msvcrt 问题,因为用了下 LLVM MinGW。然后在 readme 里看到了 UCRT 介绍。 UCRT? UCRT 是啥? 原来微软也发现大家不爽带版本号的 msvcrXXX.dll。于是用 C++ 以 extern “C” 的方式重写了它的 C 运行时。 这个重写的新C运行时就是 UCRT。每个 win 都会带上。名为 ucrtbase.dll 和 Debug 版的 ucrtbased.dll。 连这个UCRT的,还有新的 vcruntimeXXX.dll。而过去 C++ 运行时是 msvcpXXX.dll 。 ...

December 23, 2024

boost.fcontext 为何快?

在 批评 libco 的 上下文切换代码的时候,我曾经说,协程的上下文切换代码,并不需要恢复所有的寄存器。 只需要恢复调用约定里规定的 “非易失性寄存器”。 只有操作系统进行抢占式调度的时候,才需要恢复所有的寄存器。因为抢占式调度,可以在任何时间任何地方中断线程。如果不恢复所有寄存器,则在线程的角度看来就是寄存器的值可以任何时间任何地方突然“自主改变”。 而由用户执行的协程调度则不然。上下文切换,一定是代码里“主动”调用某个控制权转移接口实现的。 而这个控制权转移接口,在编译器看来,不过是一次再正常不过的外部函数调用。只要按照约定,准备好寄存器。。 并且在它返回的时候,自主恢复易失性寄存器。 是的没错,调用它的地方,本来就假定易失性寄存器的数值会改变。 因此,在协程的上下文切换函数里,根本没有任何必要恢复易失性寄存器的内容。只需要恢复非易失性寄存器即可。 为了验证我的设想,我写了一个 zcontext 进行了验证。 这个 zcontext 已提交进 uasync 代码仓库,详情看 commit 不过我这上下文切换,只恢复了8个非易失性通用寄存器。对16 个 MMX 寄存器,还有 AVX 寄存器,都没有进行恢复。 不知道会不会出问题。于是就仔细的研读了 boost.context 的汇编代码。希望研究下怎么恢复 SSE 和 AVX 寄存器。 注:boost.context 里负责上下文切换的 汇编写的 api 叫 fcontext 。 结果发现 fcontext 的做法和我的不能说完全一样,简直是一模一样。 无非是我用了 一排 push + 一排 pop 做的切换,而它的代码使用了 mov 指令。但都是等价的。 也只恢复了非易失性通用寄存器和 2个 80387状态寄存器。 这下总算完全理解为啥 boost.context 称自己的性能天下无敌了。 因为确实没有比这更快的上下文切换方式了。 由此可见,libco 的作者还真是水货一个。他引以为傲的那段汇编代码,就是一坨羊粪。

December 18, 2024

点评 腾讯 的 协程库 libco

序 libco 是 腾讯开源的一个协程库。噱头很大,动不动就是承载了微信后台亿万并发。 敢说个不马上被喷成狗头。但是我偏就是要对这些光有名头没啥技术的东西祛魅。 上一片文章 里,点评了云风的 coroutine库,其中提到了 libco 犯了和云风一样的错。 其实 libco 的错误要比云风还要多的多。 废话不多说,接下来点评 libco libco 错在哪里 首先错误的,仓库上一篇,他和云风的错误是一样的。表述相同的部分就不特别说明了。 1 协程库不应该干涉程序结构 但是 libco 的此进入非彼侵入。云风的侵入,是需要永久性的携带 struct schedule *S, 而 libc 的侵入,则是,它根本就不让你正常的用阻塞的思维模式设计你的代码结构。 我们那它源码里自带的 example_echosrv.cpp 举例 这是它一个建议的 echo server。前面介绍 iocp4linux 的时候,我就贴过正统代码。 算了,还是直接给个对比吧。 图片里两端代码,下面的是正统协程库写的 echo server 里的 accept 循环。 而上面那段则是 libco 里的例子。 正如我图片里的吐槽那样,腾讯的 libco 在编写代码的时候,很容易陷入不知所谓的境地。 这就是因为它库设计的缺陷,所以必须要用很绕的方式组织代码逻辑。 2 协程库不应该强依赖一个调度器 还是刚刚腾讯自己写的 example_echosrv.cpp 例子。 这次是 main 函数。 这不仅仅是依赖调度器了,这是必须,也只能使用 libco 的事件循环。 如果云风的库只能算对你壁咚,那腾讯的库就是把你裤子都扒光了后入。 当然,不可否认一些人有网红膜拜症,非要被玩一把才开心。 当然,如果他的库已经实现的比较完善,那么使用他的事件循环,调用他封装好的 IO api,也未尝不可以接受。神神曾经说过,被强奸的时候,反抗不了,就要学会享受。 ...

December 17, 2024

点评 云风 的 C库 coroutine

序 在知乎上看到两篇 吹嘘 云风的 coroutine 库的文章。 人啊就是这样的,出名了以后,就是垃圾也有人吹捧。 今天来点评下,云风的 coroutine 到底垃圾在哪里。又或者说,一个优秀的协程,应该优秀在哪里。 云风错在哪里 首先一个优秀的协程库,要做到“自然”。 什么是“自然”呢?就是要做到尽量不改变原来写同步阻塞IO逻辑的时候的代码。 因此引出第一错: 1 协程库不应该侵入 API 设计 要使用云风的协程,被调度的协程必须有如下的函数签名 void coroutine_function(struct schedule *S, void* arg); 注意到那个 struct schedule *S 参数了吗?要使用协程,必须带上这个参数。 哪怕本层级的函数并不直接调用 IO, 也就是不会直接用到 struct schedule *S 参数,他也得带上,并将 struct schedule *S 传给所有他要调用的函数。 也就是整个程序所有的函数都得带上 struct schedule *S 参数。 这也是 asio 的有栈协程设计失败的地方。一旦使用了有栈协程,所有的函数都得加上 asio::yield_context 参数。 如果只是某个会调用 IO 的函数需要带上这个 休眠器 还好。但是假设这样的调用链条 A -> B -> C -> D, 最终在 D函数里调用了 async_read(); 那显然,为了让整条路径能实现逐级传递 struct schedule *S, 必然会让这条调用链上的所有函数都带上 struct schedule *S 参数。 ...

December 16, 2024

基于 ucontext + iocp4linux 的超简协程库

虽然说,使用 异步最佳的实践是使用协程。 然而 c++20 的协程并不总是可用的。总不能说,不能更新编译器的地方就不配写代码吧。 因此,我在上一篇文章里说道,可以继续忍受回调地狱。或者使用有栈协程。 当然,如果使用 asio , 那么一切问题都不存在。asio 支持 有栈协程,无栈协程,daff‘s device 协程,还有最基础的,回调模式。 asio 简直就是个“宇宙级” 的异步库。 然而,asio 也并不总是可用。 于是,基于 ucontext 的一个超简协程库就应运而生。 首先,这个不是一个独立的库,他其实顺手带在 uasync 里。作为 universal_fiber.h 头文件提供。 就隐藏在 iocp4linux 的 example 代码里。 见 echo_server_stackfull.c 没错,这次是个 C 代码。尽管我非常讨厌 C。 这个库,只是为了演示如何将 proactor 和有栈协程给结合起来。虽然我本人建议最好使用 c++20 的协程。但是总有人是升级不了编译器的。 因此我再三思考后,决定还是写一个小 demo 来演示 proactor 和有栈协程 如何极便捷的结合。 对于这么一个简单的 echo server 例子,作为对比,同文件夹下的 echo_server_callback.cpp 就是基于回调的。可以直观感受下,基于回调和基于协程的代码可读性。 先看有栈和无栈例子对比 这个是 echo server 左边有栈协程和右边无栈协程的 accept 循环的代码对比 不能说毫无差别,简直可以说是一模一样 也就是说有栈和无栈,是只存在底层工作机制的差异 没有使用上的差异。 这就是 universal_fiber.h 和 universal_async.hpp 的威力。 关于那个无栈协程 universal_async.hpp 的分析,参考 这篇文章 ...

December 15, 2024

深入异步IO 第二篇: 正确使用 IOCP,正确设计 proactor

前言 干了那么多年码农,遇到 IO 从来都是写异步代码。从最初直面裸 epoll 写,到后来基本上依赖 asio 写。 最近研究 io_uring 后,试着用 io_uring 把 IOCP 那套 API 实现了。 以前呆在 asio 的舒适区,根本没关注过其他程序员对异步的理解。但是 windows 程序员是最多的,当我研究IOCP的时候, 以前被我忽略掉的那群写 IOCP 的程序员,突然进入了我的视线。 当我研究了他们对异步的一些吐槽后,才发现了一个真相:大部程序员并不懂异步。 尤其是,我由于不熟悉 IOCP,故而为了给 iocp4linux 找测试用例,而翻遍网络,寻找使用 IOCP 写成的一些网络代码示例。 能跑通它们,才算 iocp4linux 功能完成了。对吧。 结果,大部分 IOCP 的例子,虽然能跑。但是我研究了他们的代码后发现,统统都是错误的。完全没有领会到异步IO的精髓。根本就 没有真正的理解异步IO。 所以,我打算写数篇最深入剖析异步IO的引导文章,足够教会大家 真正的异步思维。 Reactor 和 Proactor ACE 作者当年提出了数个高性能网络IO的模型,其中将这些模型总结为 Reacto 和 Proactor。如果按字母意思翻译, 则称为 反应器 和前摄器。 但是,我更愿意使用更精准的汉语表达:多路复用模式 和 重叠IO模式。 多路复用模式 前一篇文章说道,要想实现单线程并发IO, 内核必须要提供的2个机制。在 多路复用模式下,要求的机制就是 可读写状态通知 和 无阻塞IO操作。 无阻塞IO操作 要求内核在IO不能立即完成的情况下,不能挂起调用线程,而是返回错误。但是此时代码不应该进入无限重试,而是等待内核的通知。 可读写状态通知 如果一个 IO 操作接下来可以无阻塞立即执行,则通知程序,现在可以干活而不会失败了。 比如我写一个 server,调用 read() 读取客户端发送的数据。如果客户端还未发送数据。则内核会挂起线程直到对方发送数据。然后 read 就执行成功并返回了。 ...

December 14, 2024

深入理解异步IO

前言 干了那么多年码农,遇到 IO 从来都是写异步代码。从最初直面裸 epoll 写,到后来基本上依赖 asio 写。 最近研究 io_uring 后,试着用 io_uring 把 IOCP 那套 API 实现了。 以前呆在 asio 的舒适区,根本没关注过其他程序员对异步的理解。但是 windows 程序员是最多的,当我研究IOCP的时候, 以前被我忽略掉的那群写 IOCP 的程序员,突然进入了我的视线。 当我研究了他们对异步的一些吐槽后,才发现了一个真相:大部程序员并不懂异步。 尤其是,我由于不熟悉 IOCP,故而为了给 iocp4linux 找测试用例,而翻遍网络,寻找使用 IOCP 写成的一些网络代码示例。 能跑通它们,才算 iocp4linux 功能完成了。对吧。 结果,大部分 IOCP 的例子,虽然能跑。但是我研究了他们的代码后发现,统统都是错误的。完全没有领会到异步IO的精髓。根本就 没有真正的理解异步IO。 所以,我打算写数篇最深入剖析异步IO的引导文章,足够教会大家 真正的异步思维。 线程的由来 现在的程序员大部分都是新世纪后出生的。所以早就忘记了线程的设计初衷了。我看到大部分新世纪程序员都说线程是为了并发,为了压榨cpu的性能。 其实多线程压榨 cpu 的性能,是最近十几年才有的。而线程的历史,和操作系统一样古老。 计算机诞生的前半个世纪,CPU都是单核的。那时候就已经有了多线程。 所以,线程的最初真正作用,实际上出乎现在的程序员的意料:是为了实现异步IO。 DOS 下的 IO 在个人电脑的上古时代,一个打字员的日常工作,是打字,然后 按下键盘上的 Ctrl-S。接着去泡杯茶去喝。 当 wps 要将文档存入软盘,意味着这段时间,整台电脑都处于“不可操作”的状态。 直到软驱磁头吭呲吭呲的干完活,当前的应用才会复活,能继续执行其他任务了。 为啥会这样呢?因为 DOS 是一个单任务的操作系统,不支持多线程。这就意味着,DOS 不支持异步 IO。WPS要写磁盘,就只能等待 DOS 完成文件写入。 期间整个电脑都无法干其他工作。 这个问题,直到“多任务系统”的出现才解决。当然,多任务系统,出现的比 DOS 早多了,只不过,引入 PC 领域要晚的多。一直到 windows 出现。 ...

December 13, 2024

批量提交IO提升性能

在基本完成 iocp4linux 后,我抽空在 rockpi 上测了下性能。 使用仓库里自带的例子 test/web_server/server.cpp,我测得了大约 6000req/s 的性能。 还不错。但是和 PC 上超过十万的性能相比,有那么点。。。弱鸡。 但是我通过 htop 注意到了一点。wrk 压测的时候, cpu1 是 cpu 100%。而且都是 红色的。说明cpu 都花在内核时间上了。 这也是 io_uring 很牛逼的原因:活都让内核干了。 ==。 rockpi 是个6核的soc, 其中 cpu1-cpu4 (我设定 htop 的 cpu 从 1 开始数。)是个 1.4Ghz 的小核。cpu5,cpu6 才是 1.8Ghz 的大核。 这 不仅仅一核有难,5核围观。这特么干活的还是个小核。 于是果断找原因,发现是中断亲和性的设定问题。将中断迁移到 cpu5 后,测试发现干活的就是 1.8Ghz 的大核啦。 然后性能飙到超过 9000req/s。 之前测试的性能忘记记录了,这次随手截图留存了。 嘿嘿,果然给力。这优化。还是免费的。 就在我沾沾自喜的时候,我又随手测试了以下 老中医写的 proxy_server。它里面带了一个简单的 http server。 wrk 压测以下,我了个去的。轻轻松松 1.6万req/s。 asio 你大爷还是你大爷! 于是我琢磨着进行优化。 我想到了 io_uring 提交 IO 的两步曲: ...

December 10, 2024

超轻量级 IOCP 协程库

在 上一篇 文章里,我提出了 iocp4linux 。 在编写 iocp4linux 的过程中,我需要写一些测试代码。 一开始,我随便的找了一个基于 IOCP 的 echo test 和一个简单的 web server。 首先确保这弄来的例子能在 windows 上编译通过。 然后修改 ifdef _WIN32守卫,在 linux 平台上改为使用 iocp.h 头文件。 然后很轻松的就移植到 linux 上了。 但是,我对于这些 C 风格的 demo 并不满意。因为我完全改不动他们的代码。 于是,我想着,何不写一个超级轻量级的一个封装库? 这个库,应该做到跨平台 —— 指能同时兼容原版 windows.h和 iocp.h。然后代码尽量短小,同时又足够易用。 最后。我折腾出了一个超轻量级的协程库。 废话不说,先看一段 异步 accept 的代码: 在红框处,使用的是 windows 上的异步 accept 。 在 AcceptEx 调用的时候,传入了一个 ov 对象。 这个 ov 对象,类型是 awaitable_overlapped 。 awaitable_overlapped 可以隐式转换为 WSAOVERLAPPED* 从而被 AcceptEx 所接受。 由于是异步 IO , 这时代码会继续向下运行。一般如果是在非协程的代码里。此时就应该返回函数。 然后把 accpet 的后续逻辑,放到 调用 GetQueuedCompletionStatus 的事件循环里了。 ...

December 8, 2024

IOCP 移植到Linux上

序 windows 高性能IO使用的是 proactor 模型,而古代 Linux 上则是 reactor 模型。 因此跨平台的网络库,通常会选择实现为其中一种模型,然后在另一个平台上使用模拟。 比如 asio 使用 proactor 模型。Linux 上使用 epoll 模拟。 又比如 libevent 使用 reactor 模型, windows 上使用 iocp 模拟。 而将 iocp 模拟为 epoll 的库,就是 wepoll 了。 但是,reactor 比较是一种比较落后的模型。因此,进行跨平台封装为 proactor 实际上是更先进的做法。 虽然已经有 asio 这种 proactor 库了,但是毕竟 asio 是一个比较重量级的库。一种轻量级的 proactor 库 也是非常有市场的。 更何况,既然有 wepoll 这种把 Linux api 弄到 windows 上的库,那没有 Linux IOCP 就说不过去了。 于是我决定,开发一个 Linux 版的 IOCP 库。这样方便使用 IOCP 开发的各种软件可以方便的迁移到 Linux 平台。而无需重写。 如何实现呢? 如果是在很久以前,这件事其实还是比较复杂的。然而,嘿嘿。从 linux 5.1 开始,一个崭新的名为 io_uring 的系统接口诞生了。 ...

December 4, 2024

用iouring扩展asio

序 什么叫扩展asio? Beast给Asio增加了 HTTP 协议,不叫扩展asio。那什么叫扩展asio? 举个例子,给 asio 的 socket 对象,基于io_uring提供的 IORING_OP_SHUTDOWN 增加 async_shutdown() 接口,就算扩展asio。因为原本asio并没有异步shutdown功能。而且这个功能并不能靠组合原有的asio接口实现。这就叫扩展asio。 扩展asio, 又不能修改asio的代码。看起来有点难办。 好在,asio的设计也是有一定的扩展性的,并非完全依赖修改源码实现扩展。 但是不可避免的,需要使用 asio::detail:: 名字空间下的非公开接口。 那么,就从 async_shutdown 开始,讲解如何扩展asio吧! 接口形式 不修改asio代码的大前提下,要给一个对象增加一个 async_shutdown() 的成员函数那是痴人说梦。语言上就禁了此路。 不过,有两种绕过的做法 其一。写一个新的socket对象,自 asio::ip::tcp::socket 继承。然后增加一个成员函数。缺点是所有使用 socket 的地方都得修改一下类型。有了IDE的重构大法,实际上为了能异步关闭而进行的迁移并不算特别大的工作量。但是如果有不需要牵一发而动全身的修改,会更好。 其二。写一个全局函数,接受一个 asio::ip::tcp::socket 并将他异步关闭。 第二个方法,不需要对整个项目进行大手术。只需要在需要异步关闭的地方,将原来的同步关闭 ( socket.shutdown();),替换为 co_await async_shutdown(socket, defered); 从设计美学上来说,第二个方法更好。 操作系统接口 扩展asio, 并不是使用asio现有接口去实现一个功能。比如beast利用 asio现有的socket接口就能实现在其基础上增加 HTTP 协议支持。 我们要给 asio 的 socket 增加异步关闭功能,是实打实的让asio多了原本不存在的功能。那么显然,这样的功能,首先我们得问一问,操作系统支持吗? 如果操作系统不支持一个功能,我们想破天也没法给asio扩展出这个功能。 答案是,异步关闭socket只有io_uring支持了。windows 上虽然也支持异步关闭,但是需要使用 WSAEventSelect + WSAWaitForMultipleEvents + shutdown 组合使用。IOCP不支持异步关闭。没有能传 overlaped* 的 WSAShutdown 版本。 asio 的接口组织结构 asio 暴露给用户的接口为2种对象,其一为 executor ,其二为 io_object. executor 一般而言就是 asio::io_context。而 io_object 则通常就是 socket 咯。 ...

November 21, 2024

重叠IO(proactor)是最理想的IO模型

reactor 和 proactor , 这种毫无联系的英文专用名词,很容易把人弄晕。 回归正途,使用精确的汉语描述,而非翻译,则正确的说法是: 多路复用IO 和 重叠 IO 模式。 所谓多路复用,顾名思义,就是好几个IO复用。。。 复用了谁?复用了线程。 它对比的是最传统的UNIX网络编程: 一个连接一个线程。并发就要开多线程。连接多了,线程就多,系统压力非常大。 而多路复用,则可以让一个线程处理多个连接。这就是复用的含义。为了实现复用,首先IO是非阻塞的。因为如果阻塞了线程,其他连接上的数据不就没法处理了么。既然非阻塞,那就会出现网络数据没准备好,就一直返回 EAGAIN 错误。一直返回难道一直重试吗?显然不现实。所以就有了一个 多路复用器。这个多路复用器最早是 select() 调用。后来是 poll() 最后是 epoll(). 而重叠IO,顾名思义,就是 IO 操作是重叠的。和什么重叠?当然是和你当前的线程是重叠的。 也就是,向系统提交一个 IO 操作, 系统就会在“后台”默默的干苦力,当前线程可以立即执行其他任务。不会被阻塞。他和多路复用模式的区别是,多路复用模式,如果会阻塞,内核就返回会阻塞,而不是在后台默默干活。而 重叠IO 则即不会阻塞,也不会返回“请重试”。而是在后台开始默默的进行处理。这个IO的处理,和你程序本身的逻辑,是重叠进行的。所以叫重叠IO。 话又说回来了,系统是在后台干活了,你得知道他啥时候干好了吧?总不能两眼一摸黑,不知道了吧。 因此,系统需要一个通知机制。Linux 这边,曾经有一种叫 AIO 的东西,它用 “信号” 来通知 IO 完成了。而如今 Linux 使用 io_uring 的 无锁列队 来完成通知。而 windows 则使用 一个叫“完成队列”的东西来通知,当然也可以使用 窗口消息来通知结果。 不管是 win 的窗口消息,还是linux的 AIO ,在实践中都被人抛弃不用了。因此不讨论这些。 我们讨论 IO完成端口,和 io_uring, 他们本质上是一样的,就是提供一个异步队列,然后应用层可以使用 一个或多个线程,去读取这个队列获得完成通知。每一个IO操作,都对应一个完成通知。 因此,重叠IO模式,其实和传统的编程思路是一致的:每调用一个函数,就获得一个返回值。 无非是,这个返回不是通过 ret 指令返回,返回结果也不是通过 EAX 寄存器返回。 而是存放到了一个消息队列里。 但是,操作请求和结果返回,是一一对应的。这是一种非常自然的概念。 自然而然的,在编程上,就可以设计为 IO发起 + 完成回调。 库的作用,就是封装 系统的 IO api ,然后将 IO完成消息转化为 完成回调。 有了 IO发起+完成回调。很自然的,程序就可以组织为一种 协程结构。 发起IO操作,返回一个 promise . IO完成就是让 promise 完成状态。 想同步IO结果,只要 await 这个 promise 就可以了。 非常的容易理解,而且封装起来也非常的轻松。用起来简直就是爽到high起。 ...

November 19, 2024

真正的重叠IO

不知有没有人想过,为何微软将windows 的异步API称为“重叠IO”而不是异步IO。 在我看来,重叠IO和异步IO的区别,主要在于发起IO后的动作。 重叠IO, 发起 IO 后,继续执行应用层的逻辑。应用可以选择在任何何时的地点再选择同步(阻塞等待 or 异步等待)IO的结果。 异步IO, 发起 IO 后,立即挂起当前业务逻辑(也就是立即非阻塞等待 IO 结果),回到事件循环,以便执行其他业务逻辑。 放到协程的设计角度,重叠 IO 相当于这样使用 async function do_read() { let read_promise = file.read(...); ... 干点不依赖 IO 结果的事情 let read_result = await read_promise; ... 干需要 IO 操作结果的事情 } 而异步 IO, 则是这样使用 awaitable<void> function do_read() { auto read_result = co_await file.async_read(...); // do other logic. } 可以看出来,重叠 IO 在发出 IO 操作后,可以继续执行其他逻辑。只有当确实需要数据的时候,再进行等待。 而异步IO模式下,发出IO后,必须立即挂起当前协程等待IO完成。 那么,这两种差异,对现实中的程序有什么影响呢? 我们先考虑一个最简单的应用: 静态 web 服务器。 在静态web服务器里,最核心的处理逻辑,就是找到用户要下载的文件,然后将文件发送给客户端。伪代码如下 awaitable<int> handle_send_file(auto target, auto socket) { char buffer[65536]; fs::file f(target, flags::binary|flags::open); long total = 0; for(;;) { auto read_size = co_await f.async_read_some(buffer); if (read_size == 0) break; total += co_await socket.async_write_some(buffer, read_size); } co_return total; } 在这个代码里,主要的逻辑就是 循环读取文件,然后发送。 ...

November 18, 2024

不要 new 一个 char 数组当缓冲区

性能调优是一个有魔力的工作。最近研究到了 std::pmr::, 就想着看能否有些老代码能改进改进,提高下性能。 但是,测试的时候,发现还是有一些路径的效率不理想。 经过好久的排查,最终定位代码到这么一行 auto buffer_size = 5*1024*1024; auto buffer = std::make_unique<char[]>(buffer_size); 好家伙,原来 make_unique<char[]> 这么慢的吗? 原来 make_unique 不单单是 分配了 buffer_size 个字节的内存,同时还 构造了如此数量的 char 对象。 问题是我这只是个 buffer, 不需要初始化啊! 继续查看生成的汇编代码,发现 make_unique 还是很聪明的,并没有在一个 for 循环里调用5百万次 char 的构造函数。 看来第一种 for 循环五百万次赋值 0 的担忧是没了。 结果看到了汇编代码里的 call memset@plt 所以说,哪怕编译器自动的把初始化代码优化为了一个 memset 调用,它还是调用了 memset , memset 对一个 5MB 的内存,还是要花点时间的。 于是我随手把代码改成了 auto buffer_size = 5*1024*1024; std::unique_ptr<void, decltype(&std::free)> buffer(std::malloc(buffer_size), &std::free); 测试发现性能飙升了十几倍。 总结 在不需要初始化的 buffer 分配领域,使用 malloc 是比 new 更好的选择。

November 16, 2024