MT's blog

我的 RSS 与书签工作流

Tue, 26 May 2026 00:00:00 +0000

我的 RSS 工作流

我使用 RSS 订阅我喜欢的源，并依赖 Karakeep 来管理书签。为了简化这个流程，我将 Miniflux 与 Karakeep 进行了同步集成，这样我在 RSS 阅读器中保存的任何文章都会自动保存为书签。此外，我还将 Miniflux 与 Telegram 进行了集成，以便轻松地与朋友分享文章。

  graph TD
    A[RSS 订阅源] -->|1. 定期自动获取| B(Miniflux 阅读器)

    B -->|2. 新文章到达| H[触发 Telegram 机器人]
    H -->|3. 自动发布| G[(Telegram 频道)]
    
    B -->|4. 用户阅读并加星| C[文章加星]
    C -->|5. 同步集成| E[(Karakeep 书签)]

古诗词日常收藏 - 2

Mon, 08 Dec 2025 00:00:00 +0000

破窑赋

[作者] 吕蒙正 [朝代] 宋代

天有不测风云，人有旦夕祸福。蜈蚣百足，行不及蛇；雄鸡两翼，飞不过鸦。马有千里之程，无骑不能自往；人有冲天之志，非运不能自通。

盖闻：人生在世，富贵不能淫，贫贱不能移。文章盖世，孔子厄于陈邦；武略超群，太公钓于渭水。颜渊命短，殊非凶恶之徒；盗跖年长，岂是善良之辈。尧帝明圣，却生不肖之儿；瞽叟愚顽，反生大孝之子。张良原是布衣，萧何称谓县吏。晏子身无五尺，封作齐国宰相；孔明卧居草庐，能作蜀汉军师。楚霸虽雄，败于乌江自刎；汉王虽弱，竟有万里江山。李广有射虎之威，到老无封；冯唐有乘龙之才，一生不遇。韩信未遇之时，无一日三餐，及至遇行，腰悬三尺玉印，一旦时衰，死于阴人之手。

有先贫而后富，有老壮而少衰。满腹文章，白发竟然不中；才疏学浅，少年及第登科。深院宫娥，运退反为妓妾；风流妓女，时来配作夫人。

青春美女，却招愚蠢之夫；俊秀郎君，反配粗丑之妇。蛟龙未遇，潜水于鱼鳖之间；君子失时，拱手于小人之下。衣服虽破，常存仪礼之容；面带忧愁，每抱怀安之量。时遭不遇，只宜安贫守份；心若不欺，必然扬眉吐气。初贫君子，天然骨骼生成；乍富小人，不脱贫寒肌体。

天不得时，日月无光；地不得时，草木不生；水不得时，风浪不平；人不得时，利运不通。注福注禄，命里已安排定，富贵谁不欲？人若不依根基八字，岂能为卿为相？

吾昔寓居洛阳，朝求僧餐，暮宿破窑，思衣不可遮其体，思食不可济其饥，上人憎，下人厌，人道我贱，非我不弃也。今居朝堂，官至极品，位置三公，身虽鞠躬于一人之下，而列职于千万人之上，有挞百僚之杖，有斩鄙吝之剑，思衣而有罗锦千箱，思食而有珍馐百味，出则壮士执鞭，入则佳人捧觞，上人宠，下人拥。人道我贵，非我之能也，此乃时也、运也、命也。

嗟呼！人生在世，富贵不可尽用，贫贱不可自欺，听由天地循环，周而复始焉。

无题

[作者] 无名

陈事万千似寒霜, 傲雪梅来如故乡.

终南别业

[作者] 王维 [朝代] 唐代

中岁颇好道，晚家南山陲。兴来每独往，胜事空自知。 行到水穷处，坐看云起时。偶然值林叟，谈笑无还期。

MIT 6.s081(Operating System)

Wed, 09 Mar 2022 00:00:00 +0000

MIT OS

课程地址: https://pdos.csail.mit.edu/6.S081/2020/schedule.html

在拖沓了许久之后, 终于OS给看完了. 总体来说质量很不错, 设计的lab都很好, 理清了不少底层的概念.

体验

个人觉得OS课程的lab至关重要, 这也是MIT 6.s081做得非常好的点之一, 他们的lab确实做到了由浅入深.
理论知识是围绕xv6来讲解, 同时后期开始讲解OS的一些经典paper, 这些可以让自己对OS的学术领域有一个基本的了解.
然后lab大部分都是修改xv6, 因为xv6的代码非常简洁, 所以修改一般都比较轻松. 难的是OS里面一个很小的细节可能要debug很久.
加深了对所谓并发的理解, 多线程的lab是设计一个用户空间的"线程调度器", 写完之后感觉对多线程/多进程的概念更清晰了, 虽然我觉得这里的多线程更像是协程.
学习了一些经典的技术: copy-on-write, mmap, Read-Copy-Update
看到meltdown的时候有点激动, 原作者是怎么想到这个做法的 (
看了MIT 6.004之后惊叹数字电路上那么多精妙的设计, 现在看来OS里面也有很多精妙设计, 或者说是体系架构里面. 虽然MIT 6.004学习了页表, 但在OS里面可以看到页表的各种用法, 不得不佩服页表这个发明.
知道了微内核和宏内核的区别

总结

之前觉得一个CPU就是一个通用图灵机, 它的输入也是各种图灵机, 而其中之一就是OS, 而OS本身应该也是一个通用图灵机, 所以本质上OS是通过套娃提高了抽象层次, 简化了操作.
现代OS的几个关键点应该是并发和安全. 对于并发, 常见的说法是多进程和多线程, 但实际上都是一回事, 只不过多线程是共享一个address space. 对于安全, 用页表来实现address space的隔离是个绝妙的idea, 虽然meltdown的出现吓到了不少人, 但这实际上也跟intel自己的micro-architecture实现有关, 好在现在已经可以在硬件层面修复了(不然还是得把用户空间和内核空间分开, 会拉低大概5%的性能).
锁可以解决数据冲突, 但会降低并行性, 过度的使用等于没有并行.

Parallel Processing

Thu, 16 Dec 2021 00:00:00 +0000

Parallel Processing

课程地址: https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-004-computation-structures-spring-2017/c21/c21s1/

本章讲的是各种并行方案.

并行

并行大体上有如下3种:

指令级并行(ILP)
数据级并行(DLP)
线程级并行(TLP)

指令级并行

指令级并行是让流行线的每个阶段尽可能同时执行多条指令.

数据级并行

数据级并行主要是指像向量加法这种计算, 天生就能拆开运算的! 只需要提供多个ALU就行了, 目前主要是由GPU来做.

线程级并行

首先介绍一下阿姆达尔定律:

一个线程就是在一个core上执行的计算任务.

Using multiple independent cores to execute a parallel task is called thread-level parallelism (TLP), where each core executes a separate computation “thread”.

不同的Core之间是通过同一个main memory来交换数据(还有更高效的MPI), 而且每个core都有自己的cache.

为了保证数据的一致性, 在cache和内存之间也有一条bus来监测cache的变化和同步.

例如MESI protocal: https://en.wikipedia.org/wiki/MESI_protocol

System-level Communication

Thu, 16 Dec 2021 00:00:00 +0000

System-level Communication

课程地址: https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-004-computation-structures-spring-2017/c20/c20s1/

本章主要讲的是系统间通信, 按现在来讲就是总线(BUS).

前面讲了很多硬核的物理知识, 证明了单一总线因为传输线反射的问题, 无法做到高频.

后面介绍了PCIe, 原来PCIe是受Network的启发, 也搞了一套点对点的通信协议, 跟网络一样分了几层, 数据也是包装成packet发出去.

跟网络一样, PCIe也可以有多种top, 比如环形, 树形等等.

Concurrency and Synchronization

Wed, 15 Dec 2021 00:00:00 +0000

Concurrency and Synchronization

课程地址: https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-004-computation-structures-spring-2017/c19/c19s1/

本章主要是讲进程间通信(IPC), 不过是从硬件的角度来看.

IPC里面常用的信号量, 其实也只是在共享内存中存入了一个数字, 而所谓的lock, 也只是数量为1的semaphore.

但是如果不同core上的进程同时对同一个内存地址进行写操作的话, 会产生冲突吗? 这个貌似是内存或者总线去解决的, 目前还没找到具体实现, 先mark一下.

IPC的一个重要问题是deadlock, 比如进程A和进程B:

# 进程A
wait(x)
wait(y)

# 进程B
wait(y)
wait(x)

当进程A执行完wait(x)后, 进程B被调度, 而且执行了wait(y), 显然这两个进程永远都无法结束.

一个比较直观而且简单的方案是对IPC中需要用到的信号量进行排序, 在进程wait时, 总是先wait顺序在前的信号量.

Devices and Interrupts

Tue, 14 Dec 2021 00:00:00 +0000

Devices and Interrupts

课程地址: https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-004-computation-structures-spring-2017/c18/c18s1/

本章引入外设, 讲解了round-robin调度算法的优缺点.

首先, “IO阻塞"的本质是什么?

当IO请求没有收到回复时, OS在调度到该进程时还是会继续执行等待IO的指令.

虽然每次调度到正在等待IO的进程也花不了多少条指令, 但还是要切换上下文啥的, 为了提高轮询的效率, 我们可以想办法让这些等待IO的进程不会被调度.

我们可以将进程分为不同的状态, 只有状态为0的进程可以被正常调度.

当进程开始等待IO时, 便用 sleep(id) 来改变进程的状态, 其中 id 相当于这个IO资源的标识符, 比如可以有多个进程都在等待键盘的输入. 当相应的IO时间响应后, 再根据这个id去恢复进程的状态.

加了状态的轮询调度感觉也挺合理的!

那么, 轮询能满足所有的任务吗? 当然是不能!

某些特殊的系统, 例如车载系统, 会有一些特别紧急的中断必须要优先执行, 比如紧急制动啥的. 按我们之前的设计, 中断都是在内核态中执行, 而内核态会禁用中断, 所以当需要紧急制动时, 巧好有一个耗时较长的中断在执行, 可能就会引发悲剧!

像这种每个中断都要及时响应或者在一定时间内执行完成的, 一般称为实时调度.

本章介绍了弱优先级抢占和强优先级抢占两种调度算法. 区别就是当前的中断是否能被高优先级的中断中断 (

Virtualizing the Processor

Mon, 13 Dec 2021 00:00:00 +0000

Virtualizing the Processor

课程地址: https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-004-computation-structures-spring-2017/c17/c17s1/

本章讲了CPU的"虚拟化", 不过这里的"虚拟化"是指在同一个CPU上执行多个程序, 并且互不干扰, 重点当然就是虚拟内存和MMU啦.

现代CPU都在硬件上实现了内核态和用户态, 所以无法单纯靠软件来实现内核态和用户态的切换, 而是要靠CPU的中断来实现.

当Timer发起一个中断时, 我们调用OS的schedule程序来切换用户程序的上下文, 那么具体需要切换哪些内容呢? 常见的就是所有寄存器的内容, MMU的Context和Page Directory/Page Map的base pointer, 还有其他各种外设的状态等等, 比如该用户程序的输入应该在哪个tty.

这种代码+上下文+所有相关资源的集合便是一个进程(Process).

众所周知, OS提供的底层接口都是在内核态运行, 因为内核态不会受中断的干扰, 所以能够保持调度器一直能正常运行. 但是CPU是禁止程序从用户态直接转移到内核态的, 唯一的办法便是通过中断或者异常.

现代的CPU都运行设置部分中断和异常的Handler, 当用户态程序有中断或异常产生时, 便会跳转到相应的Handler去执行, 而且会无视用户态/内核态的区别. 所以, OS可以指定自己的异常处理Handler, 对于每一个系统调用, 都分配一个illegal-opcode就可以啦!

Virtual Memory

Sun, 12 Dec 2021 00:00:00 +0000

Virtual Memory

课程地址: https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-004-computation-structures-spring-2017/c16/c16s1/

本章主要讲了从硬盘加载数据到主存的策略, 从而引出了虚拟内存和页表.

Extending the memory hierarchy

Virtual Memory

Page Map

Translation look-aside buffer (TLB)

Context

Summary

Pipelining the Beta

Fri, 10 Dec 2021 00:00:00 +0000

Pipelining the Beta

课程地址: https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-004-computation-structures-spring-2017/c15/c15s1/

本章主要是讲如何讲前面做的Beta cpu流水线化, 以及如何解决流水线中会遇到的数据冲突/控制逻辑冲突等等.

PS: 这章内容是真多 (

流水线化

冲突

常见的冲突有两种,即数据冲突和控制逻辑冲突. 数据冲突是指当前指令需要的数据暂时还没有写回寄存器或者内存, 控制逻辑冲突是指当要跳转的指令的地址还没计算出来时, 下一个指令的地址应该是多少.

数据冲突

Strategy 1 - Stall

Stall就是当指令运行到流水线的某一个阶段时, 如果检测到需要的数据还没有写回寄存器或者内存, 就在这个阶段阻塞住, 而且前面阶段的指令也要同时阻塞住, 阻塞的同时给下一阶段的IR寄存器输出NOP.

Strategy 2 - Bypass

虽然每个指令只有在最后的Write Back阶段才会把数据写回寄存器或者内存, 但相关的值在前面的阶段就已经计算出来了, 所以可以直接把这些值bypass到可能需要的地方.

控制逻辑冲突

Stratege 1和2跟前面数据冲突的处理一样, 这里只记录一下第三个做法, 也就是分支预测.

分支预测

Exception and Interruption

Caches and the Memory Hierarchy

Tue, 07 Dec 2021 00:00:00 +0000

Caches and the Memory Hierarchy

课程地址：https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-004-computation-structures-spring-2017/c14/c14s1/

本章主要讲了SRAM、DRAM、Flash、HDD的原理和现代CPU的缓存架构。

存储设备

PS: 片上的存储设备一般都有bitline和wordline, wordline用来激活指定的存储单元，bitline用来读/写数据。

SRAM

SRAM跟寄存器比较像，都是用正反馈是保持电压。

DRAM

DRAM是使用电容来保持电压，体积更小，所以容量更大，但访问速度比SRAM慢，而且需要定时刷新存储的数据。

Flash

Flash是使用MOSFET来存储数据，在栅极下加了一层绝缘体，讲电子导入绝缘体，然后根据绝缘体的带电大小来决定数据。

Hard Disk

硬盘（这里指机械硬盘）是用磁化来存储数据。

内存系统

在现代CPU的架构中，主存一般是速度相对较慢但是体积更小的DRAM组成。不过CPU不会直接跟主存交换数据，在中间可能会有其他几层SRAM来充当缓存，以降低内存的平均访问时间。

但从编程的角度看，有这样两种选择。一是完全隐藏缓存的细节，这样写程序时便可以把内存当成一个单独的设备使用；二是公开缓存细节，由programmer去决定哪些数据放在缓存，哪些放在主存。

现在除了超算，基本都是选择隐藏缓存的细节。

Cache策略

既然要隐藏缓存的细节，那么需要用硬件或者软件来自动控制哪些数据应该放在缓存，当缓存命中时，直接返回给CPU，未命中时，缓存应当自主去主存读数据然后缓存起来并返回给CPU. 下面来讨论一下具体的缓存策略.

前提

在模拟测试中, 可以发现这样一个事实:

Direct-Mapped

Full-Associative

Set-Associative

Policies

Replacement Policies

Write Policy

Summary

Building the Beta

Sat, 04 Dec 2021 00:00:00 +0000

Building the Beta

课程地址：https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-004-computation-structures-spring-2017/c13/c13s1/

本章主要是介绍如何实现一个beta处理器，应该是一个实验课，所以没啥要记录的（

PS: 对着一堆逻辑门Debug了一整天终于把所有测试都通过了！累死人（

Lab地址：https://computationstructures.org/exercises/beta/lab.html

Compilers

Wed, 01 Dec 2021 00:00:00 +0000

Compilers

课程地址：https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-004-computation-structures-spring-2017/c11/

本章就是讲了一些简单的编译原理的内容，内容比较简单，就不多记录了。

控制流图(CFG)是常用的IR

Procedures and Stacks

Wed, 01 Dec 2021 00:00:00 +0000

Procedures and Stacks

课程地址：https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-004-computation-structures-spring-2017/c12/c12s1/

本章的主要内容是讲解了为什么需要Procedures和Stacks, 应该是第一次这么清晰的理解栈（

Procedures

Procedures就是一组指令的集合，目的是为了重用指令，节约空间。当然，在高级变成语言里面都叫函数或者方法。

这里从汇编的角度来考虑如何实现Procedure, 一个最简单的办法是将Procedure在编译的时候展开，这样虽然重用了指令，但是并没有节省空间，而且无法递归调用！

另一个比较好的做法是记录Procedure的开始位置，在需要调用的时候只需要把PC设置成Procedure的地址就可以了，这样即能重用指令，也能节省空间，还能递归调用！不过问题也随之而来，当Procedure运行完后，如何知道应该返回到哪里继续执行呢？Procedure所需要的参数该如何传递呢？

首先，在执行分支指令的时候，会自动计算$PC + 4$并存在指定的寄存器，所以我们可以在Procedure里面拿到要返回的地址。其次，我们可以固定几个寄存器来传递参数，比如R3 ~ R6。这样做的话，似乎可以正确执行procedure, 但是，一旦有递归调用，那这些指定的寄存器都会被覆盖，当递归最后一层结束后返回上一层时，整个调用链就“断掉”了！

而且，当procedure的参数变多时，寄存器根本不够用！

Stacks

有了上述的问题之后，让我们再来思考一下procedure的调用需要那些工作来完成。

首先我们需要知道Procedure的参数、返回值以及结束后PC的值，其次是procedure里面的局部变量应该存在哪里，因为在procedure执行完后，这些局部变量应该要被完全清除。我们的目标是在procedure执行过程中不会影响caller的数据，在执行完成后回到caller的时候，各个寄存器除了存放返回值的那个外，都应该是调用procedure前的状态！我们把这些在每次procedure调用时都需要记录的东西称为Activation Record。

下图演示了在递归调用时，Activation Record应该是如何变化的。

这不就是先进后出的Stack嘛！然后就是一系列的有关于Stack的定义了。

Stack frame

现在我们用Stack来解决之前的问题了！

我们可以把procedure的参数，局部变量，以及procedure要使用的寄存器的内容都存到stack了！除此之外，我们还需要一些特殊的记录，比如procedure执行完后该返回的地址以及一个可以随时在栈中寻址的指针。然后，约定一个顺序来存这些数据就可以了！

栈中一个procedure的相关数据都在连续的区块中，我们称这个区块为stack frame.

然后约定好caller和callee的职责，就可以开心地使用procedure啦！

Compile procedure

如下是将C的一个递归调用编译成汇编的例子。

Summary

Assembly Language

Mon, 29 Nov 2021 00:00:00 +0000

Assembly Language

课程地址: https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-004-computation-structures-spring-2017/c10/c10s1/

汇编语言是对指令集的抽象，用一些单词的缩写来替代指令集的opcode, 从而更容易记忆和理解。

本课程中使用的汇编语言叫USAM，课程Lab里面有详细的cookbook, 就不再记录了，下面主要记录图灵机相关的内容。

FSM的局限

FSM是一个很强大的计算模型，前面章节中我们已经用电路实现了通用FSM, 那么FSM是否可以计算所有能用数字设备计算的功能或者说函数呢？

答案是不能，比如简单的括号匹配。因为FSM要靠状态来记住(和)的个数，当有一个长度无穷大的序列时，FSM便无法构造。

为了解决这个问题，Alan turing提出了图灵机的模型。

图灵机

图灵机的核心还是FSM, 不过现在多了一条无限长的纸带，FSM可以通过存储在纸带上的符号来记录额外的信息，从而避免了状态数过多而无法构造FSM的问题。

因为一段纸带上的符号可以被编码为一个整数，所以图灵机就是一个整数函数$y = TM_I(x)$。

其中$I$是用来标识特定功能即有特定FSM的图灵机，我们可以将FSM的真值表编码成数字来表示$I$。

Church’s Thesis

$f(x) computable <=> for some k, all x f(x) = T_k[x]$

该定理由图灵的老师Church提出，但目前并没有证明，不过已经被普遍接受（可能是还没找到反例吧）。

通用图灵机

对于不同的计算任务，其构造的FSM不同，所构造的图灵机便也不同，那么为了各种计算任务，就需要构造各种各样的图灵机（实际上只有FSM不同）。那么存在一种或者一个图灵机，能够计算所有图灵机能计算的函数吗？

从21世纪的结果来看，当然是存在的！

如上图所示，$U(k, j) = T_k[j]$是一个Universal Function, 实现这个函数的图灵机便是通用图灵机。

实际上，这里的关键在于$k$。

$k$在这里是表示program，理论上讲就是对FSM的编码，比如用FSM的真值表来编码，而从上层计算机的角度来讲的话，$k$就是可执行的二进制程序，而PC本身就是一个通用图灵机！通用图灵机的计算便是对$k$的interpret，实际上就是把$k$本身的计算步骤走一遍。

现在的各种编码算法，实际上就是把一个FSM编码成整数从而输入给通用图灵机。

不过由于内存的空间是有限的，所以实际中的计算机还是只能计算数据量不超过内存大小的任务。

Uncomputability

如下是一个不可计算函数的例子，也就是所谓的图灵停机问题。

Designing an instruction set

Wed, 24 Nov 2021 00:00:00 +0000

Designing an instruction set

课程地址: https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-004-computation-structures-spring-2017/c9/c9s1/

本章用前8章所学的知识设计了一个简单的通用计算机，采用冯诺伊曼结构，即main memory + CPU，而CPU则主要由datapath(即以ALU为主的计算电路)和control logic(即用ROM和Register实现的FSM控制电路)。整体内容很简单，但是很好玩！

Datapaths and FSMs

Let’s start by designing the logic that implements the desired computations — we call this part of the logic the “datapath”.

上图虽然实现了a和b的计算，但还不能控制其状态，即不能在b为0时结束循环，所以需要一个FSM来控制整个计算电路即datapath的状态。

Programmable Datapath

第一节中设计了一个可以计算介乘的datapath, 然后配上一个简单的FSM, 就可以完成计算任务。但实际中的计算任务有成千上万种，我们不能为每种任务都设计一个单独的datapath。

首先每种计算都可以分解为ALU的几个基本计算类型(Arithmetic, Bool, Comparable, Shift)，所以就计算来说，一个ALU就差不多够用了。但有的任务可能需要更多的寄存器来保存中间结果，所以增加寄存器数量是必须的。如下是一个简单的可以进行通用计算的datapath.

The von Neumann Model

在上一节的模型的基础上，冯诺伊曼引入了主存和输入/输出设备，从而执行数据量更大的计算任务，而且也可以有各种各样的输入输出设备，如下图所示。

Storage

冯诺伊曼模型的要点是用主存来存储指令和数据，主存相对于寄存器来说，最主要的优点就是容量大，所以能存储很多条指令。假如一条指令是32位也就是4bytes的话，那么1KB就能存256条指令，1M就能存256000条！

在冯诺伊曼结构中，有一个专门的PC寄存器，用来存储下一条指令在主存中的地址。

指令和指令集

指令就是用来告诉control logic该干什么，指令集就是按同一标准设计的一大堆指令，可以控制control logic干各种各样的事。指令集相关内容感觉没有太多需要记录的，所以就不记录啦。

Summary

Design Tradeoffs

Thu, 18 Nov 2021 00:00:00 +0000

Design Tradeoffs

课程地址

本章从CMOS的电能消耗出发，讲如何减少不必要的能量损失，同时也讲了很多时间和空间的tradeoff.

Power dissipation

电路优化的几个metrics

CMOS能耗

一个减小能耗的简单例子

Carry-select Adder

设计一个N位的加法器，最直观的设计就是把N个全加器串联。

但是这样的$t_{PD}$是$\theta(N)$级别的。

现在将一个32位的加法器分成两个16位的部分分别计算再组合，$t_{PD}$就差不多减小了一半。

按这个思路一直二分下去，$t_{PD}$便能达到$O(\log n)$。

Carry lookahead Adder(CLA)

从$C_{out}$的计算公式中可以看出，一个FA的输入可以转换成3个变量$P$,$G$和$C_{in}$ ，其中只有$C_{in}$需要该位的前一位的$C_{out}$。

如果知道了两个相邻位置的$P$和$G$，那么可以把这两位当作一个整体，计算出这个整体的$P$和$G$，这时$P$和$G$任然还保留着原来的性质，所以，我们可以用倍增来计算整个电路的$P$和$G$。

下图是一个8-bits的CLA的G&P generate的部分：

然后是计算Carry的方法：

完整版：

Multiplier

binary multiplication

就是普通的竖式乘法，但是要注意如果值是补码，那最高位的全值为$-2^{N-1}$而不是$2^{N-1}$。

如下是值为补码的情况：

pipelined multiplier

虽然pipeline化了，但每个stage的$t_{PD}$还是$O(N)$的，主要问题在于要按行传递carry。

Carry-save multiplier

讲每行需要传递的carry降到下一行（反正都是加在同一列，所以对结果没影响），这样可以将每个stage的$t_{PD}$优化到$O(1)$，但是需要更多的行，也就是面积增加了。

用时序电路减少面积

求和->移位->求和。

Summary

Performance Measures

Thu, 11 Nov 2021 00:00:00 +0000

Performance Measures

本章主要是讲pipeline的原理以及如何将一般的逻辑电路转换为pipeline，最后简单提到了一下异步电路和同步电路的区别。

Latency and Throughput

Latency: the delay from when an input is established until the output associated with that input becomes valid.

Throughput: The rate at which inputs or outputs are processed.

Pipelined Circuites

如上图所示，在计算$P(X)$时，F和G一直处于空闲状态，那么有没有办法把这段时间利用起来呢？

我们可以用寄存器来保持F和G的输出，从而在$P(X)$的工作时间内，可以让F和G去进行其他计算。

Pipelining Methodology

如上是将一般逻辑电路pipeline化的一般步骤

Circuit Interleaving

Pipeline的瓶颈在于$t_{PD}$最大的那个module, 我们可以用如下的方式将两个相同的module组合在一起，提高throughput.

异步及同步

同一个module对于不同的输入，所需要的时间可能也不一样。按之前的CLK驱动来设计电路的话，计算CLK的时候需要用module的最长计算时间，才能保证正确性。但对于一些计算较快的输入，这样做肯定是浪费了时间的。

上图展示了用同步和异步两种方式来实现一个简单的握手协议，对于异步电路来说，不再需要全局的CLK，所以效率非常高，但实际设计非常困难；对于同步电路来说，不再需要靠CLK来在module之间传输数据，效率也提高了，虽然还是在CLK上升沿才会有数据输入输出，但CLK不需要用最长计算时间的输入来计算了。

这个简单的握手协议如下：

In phase 1, when the upstream stage has a new output and GOT-X is deasserted, it asserts its HERE-IS-X signal and then waits to see the downstream stage’s reply on the GOT-X signal.
In phase 2, the downstream stage, seeing that HERE-IS-X is asserted, asserts GOT-X when it has consumed the available input.
In phase 3, the downstream stage waits to see the HERE-IS-X go low, indicating that the upstream stage has successfully received the GOT-X signal.
In phase 4, once HERE-IS-X is deasserted, the downstream stage deasserts GOT-X and the transfer handshake is ready to begin again. Note that the upstream stage waits until it sees the GOT-X deasserted before starting the next handshake.

Finite State Machine

Sun, 07 Nov 2021 00:00:00 +0000

Finite State Machine

有穷自动机本身是一个比较简单的概念，不过这里的主要难点是考虑将异步信号转换为同步

课程地址: Finate State Machine

本课程中自动机的表示图

异步时钟

当电路中的时钟信号和输入变量的时钟信号不一样时，需要将输入的时钟信号转换为与电路时钟同步的信号，从而使得电路能正常工作。

The bounded-time Synchronizer

当IN和CLK的上升沿到来时间$t_{IN}$和$t_{CLK}$相差大于$t_{E}$时，Synchronizer将输出至少持续$t_{D}$时长的0或1。但如果IN和CLK的上升时间沿到来时间之差小于$t_E$时，就无法确定Synchronizer的输出。为什么无法确定？个人理解是因为上升沿实际是要一段时间才能完成的，如果两者上升沿到来时间相差太短，当CLK达到1时，IN可能还在中间。

那么该如何用逻辑电路来实现这个Synchronizer，当然要靠D-Register啦！

上图是用D-Register实现的Synchronizer, 用$t_{setup}$和$t_{hold}$来充当$t_{E}$，看起来很美好，但还没有解决IN和CLK的上升沿同时到来的问题！

当IN和CLK的上升沿同时到来时，可能会让D-latch进入metastable状态：

解决办法：加D-Register!

Sequential Logic

Fri, 05 Nov 2021 00:00:00 +0000

Sequential Logic

课程地址：https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-004-computation-structures-spring-2017/c5/c5s1/

Background

用简单的逻辑门与/或/非可以实现很多逻辑函数，但有一种很简单的电路，却没办法用与/或/非直接实现，如下图所示的开关电路。

普通的组合逻辑电路和开关电路最大的区别在于开关电路的输出还于当前的输出(状态)有关。

为了用逻辑电路来实现相同的功能，首先得让电路能记住上一次的状态。

Memory

Using Capacitors

如上图所示，电容是可以存储 ”电压“ 的装置，所以很容易想到用电容来实现存储电路。不过在现实环境中，电容没办法做到完全不漏电，所以用电容实现的存储电路每隔一段时间要充一次电。

DRAM便是类似的原理，需要定时刷新电容上的电压，特点是体积小，便宜。

Using Feedback

另一个实现存储电路的思路便是正反馈，如下图所示。

上图中用两个invertor实现的正反馈电路可以使输出稳定保持，但除了高低两个状态，还有一个中间的状态，而且该电路也可能会永远保持在中间的状态，所以我们需要避免这种情况。

Settable Memory

我们可以用一个两位的MUX来实现一个可设定的Memory.

这样的元件叫做D-latch, 即D锁存器。

要理解D-latch输入输出和时间的关系，如下图。

Try it out

虽然D-锁存器能够存储状态，但当有一连串的状态输入时，如果要保证每次只有一个状态能通过，然后被其余逻辑电路读取，然后下一个状态才能通过的话，需要对时间做非常严格的限制，但在实际环境中，各种干扰和噪声让这种限制变得几乎不太可能。

Move to Register

Flaky Control System

为了解决上面Try it out中提到的问题，这里先用一个现实中的例子来解释一下：

D-Register

我们可以按如上的例子用D-latch来实现一个这样的系统。

各种时序图

理解D-Register的时序很重要！！！

Summary

Combinational Logic

Sun, 31 Oct 2021 00:00:00 +0000

Combinational Logic

如何描述电子元件的功能

真值表
逻辑表达式

在输入变量比较多的时候，真值表就很难读/写了，所以逻辑表达式更加通用。

设计数字电路的步骤

写出真值表
写出逻辑表达式
用AND/OR/NOT三种基本逻辑门实现，或者用NAND/NOR/NOT三种逻辑门实现

因为CMOS本身就是Inverting的，所以实际中NAND/NOR更加通用。

Sum of products

将真值表中为1的项用OR连接起来就得到了相应的逻辑表达式。

在功能不变的情况下，为了减少逻辑门的数量，也就是减小$t_{pd}$和$t_{cd}$，就需要将逻辑表达式中的项数最小化。

卡诺图

卡诺图化简步骤

找出Implicants
合并
处理lenient

Mux

Decoder

ROM

Summary

CMOS

Mon, 25 Oct 2021 00:00:00 +0000

CMOS

MOSFET

Overview

Characters

Two Flavors

CMOS

CMOS is Complementary Metal Oxide Semiconductor

Two switches

Inverter

Basic usage of CMOS

Timing specifications

Propagation Delay

Contamination Delay

Summary

唐宋诗词1-上官体

Sat, 09 Oct 2021 00:00:00 +0000

上官体

上官仪

背景

上官仪是初唐文学的重要人物，开创了上官体，特点是绮错婉媚，上承虞世南，下启沈佺期和宋之问。不过后来被杨炯批评为有风韵，但无风骨。

代表作

咏画障

芳晨丽日桃花浦，珠帘翠帐凤凰楼。

蔡女菱歌移锦缆，燕姬春望上琼钩。

新妆漏影浮轻扇，冶袖飘香入浅流。

未减行雨荆台下，自比凌波洛浦游。

新装漏影浮新扇，冶袖飘香入浅流。

未减行云荆台下，自比凌波洛浦游。

The Digital Abstraction

Thu, 30 Sep 2021 00:00:00 +0000

The Digital Abstraction

信息编码

信息的种类有各种各样，我们需要找到一种方式来表示这些信息。比如，生物的基因信息是通过DNA来记录和表达，在计算机中，所有的数据都是二进制，我们也需要一个物理介质来表达和存储这些二进制信息。

电压

目前用来存储和表达二进制信息的物理介质绝大部分都是使用电压，高电平表示1, 低电平表示0。

VTC和容错

VTC(voltage transfer characteristics)是用来表示一个电子原件的输入和输出电压关系的图，如下是一个Buffer的VTC：

其中$V_{IL},V_{IH},V_{OL},V_{OH}$是一个电子元件最重要的参数，解释如下（这里假设最高电压为1）：

$V_{IL}$是低电平的输入有效范围，即如果输入电压为$[0,V_{IL}]$，就会被元件当成0处理。
$V_{IH}$是高电平的输入有效范围，即如果输入电压为$[V_{IH}, 1]$，就会被元件当成1处理。
$V_{OL}$是低电平的输出电压，即如果元件想输出0，则其输出电压应该为$[0, V_{OL}]$。
$V_{OH}$是高电平的输出电压，即如果元件想输出1，则其输出电压应该为$[V_{OH},1]$。

其中, $min(|V_{OL} - V_{IL}|, |V_{OH} - V_{IH}|)$即为该元件能容忍的噪声范围。

Summary

Basic of information

Sun, 19 Sep 2021 00:00:00 +0000

Basic of Information

信息是什么

信息是我们接收到的关于确实某个特定事件或者情况的数据。

量化信息

对于随机变量$X_i$，其发生的概率为$p_i$，则其传达的信息量为:

$$I(x_i) = \log_2(\frac{1}{p_i})$$

数据中的信息

假设收到data的概率$p_{data}$，则

$$I(data) = \log_2(\frac{1}{p_{data}})$$

Entropy

信息论中的entropy：

$$H(X) = \sum_{i=1}^{N}p_i\log_2(\frac{1}{p_i})$$

其中$X$为随机变量。

物理中的entropy：

$$ S = k\ln\Omega $$

其中，$k$为玻尔兹曼常数

Meaning of Entropy

为了描述某一个随机变量$X$，需要传输一系列的数据，Entropy就是确定$X_i$发生与否的平均位数，即传输量。

编码

编码就是把一个数据集合映射为一系列二进制字符串。常见的编码是把英文字母用二进制来表示，比如如下表格：

A	B	C	D	ABBC的编码
00	01	10	11	00 01 01 00
01	1	000	001	01 1 1 01
0	1	10	11	0 1 1 0（无法确定）

编码不能有二义性

二叉树编码

用二叉树的边当作0和1,叶子节点当作编码的值，可以去除二义性。

定长编码

所有值的编码长度都相等。

2的补码

即将二进制最高位的全值定为$-2^{N-1}$

负数的补码，按位取反再加1,因为$-A = -1 - A + 1$

Chapter01-Introduction to Calculus and Analysis Volume I

Tue, 14 Sep 2021 00:00:00 +0000

Overview of <Introduction to Calculus and Analysis Volume I> chapter 1

算法导论 Chapter1&2

Sun, 27 Jun 2021 00:00:00 +0000

算法

什么是算法

形式上的定义

Informally, an algorithm is any well-defined computational procedure that takes some value, or set of values, as input and produces some value, or set of values, as output.

个人理解

算法是CS中很多技术的基础，也应该是CS的核心所在。

排序问题

插入排序

插入排序的过程跟打扑克时起牌的过程差不多，对于位置i的元素，在其前面找到应该插入的位置插入即可，复杂度是$\theta(n^2)$。

归并排序

归并排序就是将原序列递归分成多个小序列，然后合并的时候发现每个元素只需要$O(1)$的时间就可以确定其位置，比较次数较插入排序少了很多，所以复杂度比插入排序小，为$\theta(nlogn)$。

归并+插入

考虑到算法复杂度的常数，在数据规模较小时，插入排序可能会比归并更优，所以在归并排序中，当子序列规模小于k时，可采用插入排序来完成。

延伸问题

逆序对

序列中，数值和位置的大小关系不匹配便可以称为一个逆序。思考一下，可以发现插入排序中，元素的比较次数就是序列中逆序对的个数，而归并排序中同样也能推算出所有的比较次数，故可以在$\theta(nlogn)$的复杂度下解决该问题。

MIT 6.824 Lec1 分布式：MapReduce

Sat, 19 Jun 2021 00:00:00 +0000

Introduction

paper url: http://nil.csail.mit.edu/6.824/2020/papers/mapreduce.pdf

Why need distributed

parallelism
fault tolerance
physical
security or isolated

Basic challenges

concurrency
partial failture
performence

Map Reduce

个人理解

MapReduce是一个比较直观而且可以分布式的编程框架，主要过程就是将数据（输入）分发到不同的task（map过程），然后将所有task的输出收集起来shuffle一下，然后分发给另外的task（reduce过程）。从目前（2021年）来看，这个编程模型的瓶颈应该是中间的shuffle过程，因为数据量非常大的时候，shuffle过程的网络IO量也非常大。

关键点

MapReduce的编程模型很简单，但Google的论文中最有价值的部分是应该是关于容错和任务备份。

容错

Worker容错

每个Task可以分为三个状态，idle/in-progress/completed，当task被分配给worker后，会由idle变为in-progress状态，当worker正常完成task时，会由in-progress变为completed。当worker因意外或其他原因变得inavaible时，Task将会变成idle状态，然后master就可以将其重新分配给其他worker去完成。

Master容错

Master的错误比较暴力，直接做几个mirror就行了，如果没有mirror，那么当master出错时，整个系统就会宕机。

任务备份

个人觉得是论文里一个不错的点，任务备份是当一个MapReduce操作（个人理解就是map和reduce)完成时，将当前in-progress的Task备份，然后当有空闲的worker时再将备份中的task分配过去执行。这样的好处是可以明显减少因为straggler的存在而导致的性能下降。

straggler指因为磁盘、网络等原因而造成性能下降的Worker

personal idea

因为在实际情况中，每个Worker都会因为各种因素而产生性能上的差距。同时，Master中也记录了每个task的完成时间，感觉可以用完成时间的平均值（或者之类的）来将worker放到一颗平衡树里面，然后优先用效率高的worker去完成task。

Arch Linux 桌面配置

Sun, 30 May 2021 00:00:00 +0000

My Archlinux desktop configuratoins

Basic setup

Desktop Environment

KDE
Bismuth

Fonts

Apple Developer fonts
Wenquanyi
Sarasa
FiraCode Nerd mono

App icons

Tela

Dotfiles

Apply dotfiles from my own repo

Softwares for daily use

qView: image viewer
thunar: graphical file manager
ranger: console file manager
Typora: writing articles
Thunderbird: mail and rss client
Yesplaymusic: music player
Zotero: PDF/paper read and management

数电设计和计算机结构：从0到1

Wed, 27 Jan 2021 00:00:00 +0000

数电设计和计算机结构：从0到1（第一章）

计算机的抽象结构

Application Software: Programs
Operating Systems: Device Drivers
Architecture: Instructions Registers
Microarchitecture: Datapaths Controllers
Logic: Adders Memories
Digital Circuits: AND Gates/NOT Gates
Analog Circuits: Amplifiers Filters
Devices: Transistors Diodes
Physics: Electrons

二进制

信息量

N种状态需要$ log_2{N} $个Bit

补码

我们一般学习补码都是分正数和负数，正数不变，负数将对应的绝对值按位取反再加1。不过在这本书中学到了一个新的角度：将MSB(二进制最高位)的全值当成$ -2^{N-1}$即可，这样看补码的话也更直观一些。

逻辑门

基本的一些门电路

AND
OR
NOT
NAND
XOR
NOR
Buffer

Logical level

数字电路处理的是离散量，比如电压只有高电平和低电平（一般用1和0表示），但实际上电路中的电压是连续变化的，那么怎么把连续的量转化为离散的量呢？

逻辑门的输入输出电压

逻辑门的输入输出中，所用的高电平和低电平的范围可能会不相同。对于输出，高电平一般是在$V_{OH} - V_{DD}$之间，而低电平是在$GND - V_{OL}$之间。而当门电路读取输入时，低电平一般是在$GND-V_{IL}$之间，高电平是在$V_{IH} - V_{DD}$之间，这样的话，在一套逻辑电路内，必须要有:

$$ V_{OL} \leq V_{IL} $$$$ V_{OH} \leq V_{IH} $$

而他们的差值就是能容忍的噪声。

Linux日常使用应用推荐

Tue, 19 Jan 2021 00:00:00 +0000

Recommand applications for cross platform or linux

JavaScript学习总结

Mon, 11 Jan 2021 00:00:00 +0000

JS study conclude

红黑树(C++)

Sun, 08 Nov 2020 00:00:00 +0000

红黑树(C++)

红黑树性质

每个节点只能是红色或者黑色
根节点是黑色
叶子节点是黑色
红色节点的子节点必须是黑色
任一节点到其子树叶子节点的所有简单路径具有相同数量的黑色节点

插入

共6种情况，其中33对称，实际上就3种

删除

共8种情况，其中44对称，实际上就4种

代码实现

#include <algorithm>
#include <iostream>

using namespace std;
enum Color {
    RED, BLACK
};

template<typename T>
class Node {
public:
    Node *parent, *left, *right;
    T key;
    Color color;

    Node(T key, Color color = RED) : key(key), color(color) {
        parent = nullptr;
        left = nullptr;
        right = nullptr;
    }

    Node() : Node(0) {

    }
};

template<typename T>
class RBT {
private:
    Node<T> *nil;
    Node<T> *root;
public:
    RBT() {
        nil = new Node<T>(0, BLACK);
        root = nil;
    }

    void leftRotate(Node<T> *x) {
        Node<T> *y = x->right;
        x->right = y->left;

        if (y->left != nil) {
            y->left->parent = x;
        }

        y->parent = x->parent;

        if (x->parent == nil) {
            root = y;
        } else if (x == x->parent->left) {
            x->parent->left = y;
        } else {
            x->parent->right = y;
        }

        y->left = x;
        x->parent = y;
    }

    void rightRotate(Node<T> *y) {
        Node<T> *x = y->left;
        y->left = x->right;

        if (y->left != nil) {
            y->left->parent = x;
        }

        x->parent = y->parent;

        if (y->parent == nil) {
            root = x;
        } else if (y->parent->left == y) {
            y->parent->left = x;
        } else {
            y->parent->right = x;
        }

        x->right = y;
        y->parent = x;
    }

    void insert(Node<T> *z) {
        Node<T> *y = nil;
        Node<T> *x = root;

        while (x != nil) {
            y = x;
            if (z->key < x->key)
                x = x->left;
            else
                x = x->right;
        }

        z->parent = y;
        if (y == nil) {
            root = z;
        } else if (z->key < y->key) {
            y->left = z;
        } else {
            y->right = z;
        }

        z->left = nil;
        z->right = nil;
        z->color = RED;
        insert_fixup(z);
    }

    void insert_fixup(Node<T> *z) {
        while (z->parent->color == RED) {
            if (z->parent == z->parent->parent->left) {
                Node<T> *y = z->parent->parent->right;
                if (y->color == RED) {
                    z->parent->color = BLACK;
                    y->color = BLACK;
                    z->parent->parent->color = RED;
                    z = z->parent->parent;
                } else {
                    if (z == z->parent->right) {
                        z = z->parent;
                        leftRotate(z);
                    }
                    z->parent->color = BLACK;
                    z->parent->parent->color = RED;
                    rightRotate(z->parent->parent);
                }

            } else {
                Node<T> *y = z->parent->parent->left;
                if (y->color == RED) {
                    z->parent->color = BLACK;
                    y->color = BLACK;
                    z->parent->parent->color = RED;
                    z = z->parent->parent;
                } else {
                    if (z == z->parent->left) {
                        z = z->parent;
                        rightRotate(z);
                    }
                    z->parent->color = BLACK;
                    z->parent->parent->color = RED;
                    leftRotate(z->parent->parent);
                }
            }
        }
        root->color = BLACK;
    }

    void transplant(Node<T> *u, Node<T> *v) {
        if (u->parent == nil)
            root = v;
        else if (u->parent->left == u)
            u->parent->left = v;
        else
            u->parent->right = v;
        v->parent = u->parent;
    }

    Node<T> *minimum(Node<T> *u) {
        while (u != nil && u->left != nil)
            u = u->left;
        return u;
    }

    void remove(Node<T> *z) {
        Node<T> *y = z, *x;
        Color origin_y = y->color;

        if (z->left == nil) {
            x = z->right;
            transplant(z, z->right);
        } else if (z->right == nil) {
            x = z->left;
            transplant(z, z->left);
        } else {
            y = minimum(z->right);
            origin_y = y->color;
            x = y->right;
            if (y->parent == z)
                x->parent = z;
            else {
                transplant(y, y->right);
                y->left = z->left;
                y->left->parent = y;
                y->color = z->color;
            }
            transplant(z, y);
            y->left = z->left;
            y->left->parent = y;
            y->color = z->color;
        }

        if (origin_y == BLACK) {
            remove_fixup(x);
        }
    }

    void remove_fixup(Node<T> *x) {
        while (x != root && x->color == BLACK) {
            if (x == x->parent->left) {
                Node<T> *w = x->parent->right;

                if (w->color == RED) {
                    w->color = BLACK;
                    x->parent->color = RED;
                    leftRotate(x->parent);
                    w = x->parent->right;
                }

                if (w->left->color == BLACK && w->right->color == BLACK) {
                    w->color = RED;
                    x = x->parent;
                } else {
                    if (w->right->color == BLACK) {
                        w->left->color = BLACK;
                        w->color = RED;
                        rightRotate(w);
                        w = x->parent->right;
                    }
                    w->color = x->parent->color;
                    x->parent->color = BLACK;
                    w->right->color = BLACK;
                    leftRotate(x->parent);
                    x = root;
                }
            } else {
                Node<T> *w = x->parent->left;

                if (w->color == RED) {
                    w->color = BLACK;
                    x->parent->color = RED;
                    rightRotate(x->parent);
                    w = x->parent->left;
                }

                if (w->left->color == BLACK && w->right->color == BLACK) {
                    w->color = RED;
                    x = x->parent;
                } else {
                    if (w->left->color == BLACK) {
                        w->right->color = BLACK;
                        w->color = RED;
                        leftRotate(w);
                        w = x->parent->left;
                    }
                    w->color = x->parent->color;
                    x->parent->color = BLACK;
                    w->left->color = BLACK;
                    rightRotate(x->parent);
                    x = root;
                }

            }
        }
        x->color = BLACK;
    }
};

// test for number 1-100
int main() {
    auto *nodes = new Node<int>[100];
    for (int i = 0; i < 100; ++i)
        (nodes + i)->key = i + 1;
    RBT<int> T;
    for (int i = 0; i < 100; ++i) {
        T.insert(nodes + i);
    }

    for (int i = 0; i < 95; ++i)
        T.remove(nodes + i);

    return 0;
}

古诗词日常收藏

Sat, 23 May 2020 11:45:34 +0800

题龙阳县青草湖

[作者] 唐温如 [朝代] 元

西风吹老洞庭波，一夜湘君白发多。

醉后不知天在水，满船清梦压星河。

无题

[出自] 风云

倚楼听风雨,淡看江湖路.

但见泪痕湿,不知心恨谁!

春夜喜雨

[作者] 杜甫 [朝代] 唐

好雨知时节，当春乃发生。

随风潜入夜，润物细无声。

野径云俱黑，江船火独明。

晓看红湿处，花重锦官城。

和董传留别

[作者] 苏轼 [朝代] 宋

粗缯大布裹生涯，腹有诗书气自华。

厌伴老儒烹瓠叶，强随举子踏槐花。

囊空不办寻春马，眼乱行看择婿车。

得意犹堪夸世俗，诏黄新湿字如鸦。

大德歌·冬景

[作者] 关汉卿 [朝代] 元

雪粉华，舞梨花，再不见烟村四五家。

密洒堪图画，看疏林噪晚鸦。

黄芦掩映清江下，斜缆着钓鱼艖。

清平乐·春归何处

[作者] 黄庭坚 [朝代] 宋

春归何处？寂寞无行路。

若有人知春去处，唤取归来同住。

春无踪迹谁知？除非问取黄鹂。

百啭无人能解，因风飞过蔷薇。

送别长亭外

[作者] 李叔同

长亭外古道边芳草碧连天，

晚风拂柳笛声残夕阳山外山，

长亭外古道边芳草碧连天，

晚风拂柳笛声残夕阳山外山，

天之涯地之角知交半零落，

一壶浊酒尽余欢今宵别梦寒，

长亭外古道边芳草碧连天，

问君此去几时来来时莫徘徊，

天之涯地之角知交半零落，

人生难得是欢聚惟有别离多，

天之涯地之角知交半零落，

Windows10 + Linux开发环境探索

Sat, 07 Mar 2020 01:39:24 +0800

为什么要Windows + Linux

其实主要是因为N卡和CUDA，不然直接macOS就行了 (x)

探索经历

Arch + i3wm + kvm

众所周知，Arch是最好的发行版(x)，配上i3wm的便捷操作，效率确实能提高不少，但是最终还是放弃了这个方案。放弃的原因并不是因为软件的问题，主要还是因为硬件的问题，一是主板不支持vt-d，不能直通显卡给KVM，而windows和macOS都是比较吃显卡的，二是新换的Intel AX200在Linux固件上还有点问题，不过这个问题是personally。

Windows10 + Hyper-v

最终还是选择了这个方案，主要是因为Linux可以不吃显卡，有图形化的需求可以直接在Windows上跑一个X Server。

Hyper-v安装Arch

安装过程都是傻瓜式的，因为我笔记本上刚好有两块SSD，索性就直接把Arch装在256G的PM961上了，然后Switch用的就是默认的Switch。

Arch安装Hyper-v Integration Service

微软提供了一套服务来让宿主机和Hyper-v VM交互，包括文件传输、状态监控、获取IP等等，只需要安装hyperv这个包就行了，然后开启如下三个daemon:

hv_kvp_daemon
hv_vss_daemon
hv_fcopy_daemon

不过启动这3个service后再重启VM，马上就会发现问题：这3个Service启动时有很大的可能会失败。然后看了一下Service的内容:

[Unit]
xxx
ConditionPathExists=/dev/vmbus/hv_xxx

失败的原因是ConditionPathExists不满足，但是奇怪的是重启登录后这个设备是存在的，手动启动是可以成功的，于是开始Google(期间因为网络问题错过了标准答案，还好后来archlinuxcn群里有人帮忙找到了答案)。在Redhat的论坛里有一篇15年的帖子讨论了这个问题，然后我看了一下日志发现现在2020年了，hyper-v的这个设计还是一样毫无变化。主要的原因就是hyper-v的这个vmbus是通过netlink挂载上去的，而网络传输是存在延迟的，所以就会导致在Integration Service启动的时候vmbus还没有挂载上，不过解决的办法也很简单，就是自己添加一个udev的rule，在vmbus成功挂载时再次启动相应的service：

SUBSYSTEM=="misc",KERNEL=="vmbus/hv_kvp",TAG+="systemd",ENV{SYSTEMD_WANTS}+="hv_kvp_daemon.service"

那么Integration Service启动失败的问题就差不多解决了(期间因为把==写成了=，找了好几个小时 TwT)。

Windows Terminal的配置

Windows Terminal是微软官方发布的一款terminator，目前还在preview，不过已经0.9了，估计可能20H1就要发布正式版了。

第一步当然是要先换字体和配色，字体很简单，用fontFace配置就行了，然后配色，刚好自带了Solarized(目前最喜欢的配色)，不过如果是Powershell最好换用其他颜色，因为PS的语法亮尚会和Solarized冲突。(感谢这些愿意无私奉献的艺术家们)

接下来就是配置ssh登录Arch，因为Default Switch的IP range是dynamic的(为什么不用Static IP?因为之前试过几次都不稳定，不是突然变了就是突然连不了Internet了)，所以需要动态获取Arch的IP，好在Powershell提供了很多操作命令，实现起来很简单：

function arch_addr {
    $addr = (Get-VMNetworkAdapter Arch).ipaddresses[0]
    return $addr
}

同时为了支持转发X，需要配置端口转发，因为Windows Terminal中直连貌似不行，完整的代码如下：

$arch_switch="Default Switch"

function arch_addr {
    $addr = (Get-VMNetworkAdapter Arch).ipaddresses[0]
    return $addr
}

function arch_switch_addr {
    return (Get-NetIPAddress | Where-Object {$_.InterfaceAlias -like "*($arch_switch)*" -and $_.AddressFamily -eq "IPv4"}).ipaddress    
}
function    arch {
    $addr = arch_addr
    $switch_addr = arch_switch_addr
    $x_port = 6000
    ssh -R $switch_addr`:$x_port`:localhost`:$x_port  mt@$addr -i C:\Users\RMT\.ssh\arch
}

同时需要手动在Arch中设置DISPLAY，然后就可以转发X了，Windows10用的是VCXSRV。

有理数的可数性

Sat, 29 Feb 2020 21:12:19 +0800

虽然知道了有理数集是可数的，但一直都不知道该如何定义一个有理数序列，使得每个有理数都在其中出现至少一次。今天看书的时候了解到了一种构造方法，所以记录一下。

有理数的可数性证明

众所周知，有理数都可以写成$ \frac{p}{q} $的形式，其中p和q都是自然数。对于一个大于1的正整数x，将x表示为$x=p + q$共有$x-1$种表示方式。对于所有的$x=2,3,4,\dots$，我们将p和q构造成分数$\frac{p}{q}$，并按照p从小到大排列，则可以得到如下序列(忽略p和q有大于1的公因数的情况)：

$$\frac{1}{1},\frac{1}{2},\frac{2}{1},\frac{3}{1},\frac{1}{3},\frac{1}{4},\frac{2}{3},\frac{3}{2},\frac{4}{1},\frac{1}{5},\frac{5}{1},\frac{1}{6},\frac{2}{5}\dots$$

或许从这里还看不出这个序列已经包含了所有大于0的有理数，那么可以看如下的规律：

对于$p=1,2,3,4,\dots$，其分母都包括了所有的自然数。对于负有理数，vice versa.

GPU 基础知识

Tue, 11 Feb 2020 22:19:39 +0800

因为最近要写一篇GPU方面的论文，所以找了一些资料慢慢看

参考：GPU Technology Trends and Future Requirements

虽然是多年前的文章，不过讲得很细～

GPU的发展

GPU的基本功能是处理图形，从最初单一的pipeline发展到现在，已经能够完成很多通用的计算任务，而且拥有远超CPU的并行计算能力。

GPU基本知识

GPU接受的数据应该是一系列的Vertex(保存坐标信息)和Attributes(保存颜色、亮度等信息)，Vertex由专门的vertex shader处理，Attribute由pixel shader处理，shader就是GPU中的一个子程序。经过一系列的shaer处理后，最初的几何数据便会成功最终的像素合并到Frame Buffer中。

GPU基础架构

从架构图可以比较容易看出，基本的工作方式就是通过BUS传输数据，然后GPU中一些shader讲计算任务分发给各个TPC。至于其中各个组件的作用，见下面的MindMap。