浅析 NJU-os-JYY 的五十行建模操作系统
前言
其实上课 os 之前，我对操作系统的理解，几乎可以等同于 windows XP、linux kde 之类的桌面环境，或者是提供命令行交互环境，来给我们“操作”。
而实际学习过后，我才意识到 os 的主要职责。
其中极其之多的细节，只有动手编写，才会真正地想明白各个地方。
而之前，我一直觉得实现一个 os 的工程量之大，是一个人需要以月、甚至于年才能做到的。
但 JYY 老师的 50 行代码建模操作系统令我由衷地佩服，想着如果我在上 os 课时候如果能有这样的讲解，我一定会有更深入的理解吧。
注：此代码需要在 Python 3.10 的环境下运行（match 关键字在 3.10 版本才被引入）
测试程序
我们先来看一下给的测试程序
count = 0 # variable in main()
def Tprint(name):
global count # get the variable in main()
for i in range(3):
count += 1
sys_write(f'#{count:02} Hello from {name}{i+1}\n')
sys_sched()
def main():
n = sys_choose([3, 4, 5]) # random choose to assign a value to n
sys_write(f'#Thread = {n}\n')
for name in 'ABCDE'[:n]: # create n threads
sys_spawn(Tprint, name)
sys_sched() # schedules to another thread
假设此时 choose 使得 n = 3, 输出#Thread = 3，则 spawn 了 3 个线程，然后开始调度（如果此时删去 main() 中的 sys_sched() 会怎么样？），接下来，三个线程并发运行（concurrency，在同一时间间隔内运行）每个线程在循环中自增 count 并输出后就准备调度，结果可能是
#Thread = 3
#01 Hello from C1
#02 Hello from A1
#03 Hello from A2
#04 Hello from C2
#05 Hello from C3
#06 Hello from B1
#07 Hello from A3
#08 Hello from B2
#09 Hello from B3
如果删去 sys_sched() 此时输出不会有任何变化，但是 main() 函数所在的线程结束了。
接下来衍生了一个新的问题，main() 结束了，整个进程是否会结束？
理论上来说，正常情况下是不会的，在这个五十行建模操作系统中，必须得等待其他线程返回结果。
也就是说，删去之前，线程列表中有 4 个线程，而删去这句话之后，main() 函数所在线程运行结束，接下来准备调度到其他线程，线程列表仅有 3 个线程。
建模源码分析
首先，进行一个约定，下文所提到的“源代码”不是指建模源码，而是自己编写的测试程序源代码
yield 关键字
建模源码运用到了 Python yield 关键字的特性，这里先对 yield 关键字进行简单的讲解
线程特性
yield 类似 return 会给调用它的函数返回一个东西
但是不同在于，yield 创建了一个无栈协程，在 Python 里叫做生成器的东西
接下来使用 Python 的交互式环境
>>> def A():
... for i in range(0, 3):
... x = yield i
... print(f"received {x}")
...
>>> type(A)
<class 'function'>
>>> a = A()
>>> type(a)
<class 'generator'>
可以看出，A 本身是一个函数，但是调用它返回的 a 是一个生成器
此时 a 所指的生成器的线程，还未开始运行，需要给它一个 None 信号启动
>>> a.send(None)
0
如此，线程已经运行到了 yield 语句，并停止（此时还未到达 print(f"received {x}")）
接下来，继续传入信号，注意此时传入的信号均为 yield i 在函数内的值
>>> a.send(9)
received 9
1
>>> a.send(8)
received 8
2
>>> a.send(7)
received 7
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
可以看出，每当我们传入一个信号，就会将信号作为 yield 向内返回的值，并继续运行，直到下一次 yield 并向外返回 yield 后面跟的参数的值
当线程运行结束，则会让生成器返回一个 StopIteration 类型的 Exception
另一种方式运行生成器
使用 for ... in ... 的格式，这里就不过多赘述，相信有了前面的理解，这里稍微看一眼就能感受到其用途
>>> a = A()
>>> for i in A():
... print(i)
...
0
received None
1
received None
2
received None
yield 小结
如此，相信读者已经对 yield 关键字有了部分的理解，接下来进入整体，更多相关内容请查阅 Python 文档
完整建模源码
这里先给出 JYY 的完整源码
#!/usr/bin/env python3
# ^ python environment
import sys
import random
from pathlib import Path
class OperatingSystem():
"""A minimal executable operating system model."""
SYSCALLS = ['choose', 'write', 'spawn', 'sched']
class Thread:
"""A "freezed" thread state."""
def __init__(self, func, *args):
self._func = func(*args)
self.retval = None
def step(self):
"""Proceed with the thread until its next trap."""
syscall, args, *_ = self._func.send(self.retval)
self.retval = None
return syscall, args
def __init__(self, src):
variables = {}
exec(src, variables)
self._main = variables['main']
def run(self):
threads = [OperatingSystem.Thread(self._main)]
while threads: # Any thread lives
try:
match (t := threads[0]).step():
case 'choose', xs: # Return a random choice
t.retval = random.choice(xs)
case 'write', xs: # Write to debug console
print(xs, end='')
case 'spawn', (fn, args): # Spawn a new thread
threads += [OperatingSystem.Thread(fn, *args)]
case 'sched', _: # Non-deterministic schedule
random.shuffle(threads)
except StopIteration: # A thread terminates
threads.remove(t)
random.shuffle(threads) # sys_sched()
if __name__ == '__main__':
if len(sys.argv) < 2:
print(f'Usage: {sys.argv[0]} file')
exit(1)
src = Path(sys.argv[1]).read_text()
for syscall in OperatingSystem.SYSCALLS:
src = src.replace(f'sys_{syscall}', # sys_write(...)
f'yield "{syscall}", ') # -> yield 'write', (...)
OperatingSystem(src).run()
main()
以参数形式读入源码，并将 sys_{SYSCALL} 的 sys_SYSCALL(args) 调用形式替换为 yield, SYSCALL, (args)
至于改变形式的原因，请看下回分解 下文将围绕此进行解释
class OperatingSystem():
SYSCALLS = ['choose', 'write', 'spawn', 'sched']
if __name__ == '__main__':
if len(sys.argv) < 2: # 检验传入参数
print(f'Usage: {sys.argv[0]} file')
exit(1)
src = Path(sys.argv[1]).read_text() # 读取文件
for syscall in OperatingSystem.SYSCALLS: # 将文件读入，并替换 4 种系统调用为 yield 格式
src = src.replace(f'sys_{syscall}', # 例如替换 sys_write(...)
f'yield "{syscall}", ') # 为 yield 'write', (...)
OperatingSystem(src).run() # 接下来接入 OperatingSystem.__init__()
OperatingSystem.init()
获取运行的源代码的 main() 函数入口
class OperatingSystem():
def __init__(self, src):
variables = {}
exec(src, variables) # 传入源代码，并获得变量表（整个机器的状态）
# 注: exec 与 eval 不同，后者有运行代码结束的返回值，而前者没有
self._main = variables['main'] # 把 main() 函数赋入 self._main，接下来接入 OperatingSystem.run()
OperatingSystem.run() PART.1
过渡段
class OperatingSystem():
def run(self):
threads = [OperatingSystem.Thread(self._main)] # 下接 OperatingSystem.Thread.__init__()
OperatingSystem.Thread.init()
重点部分来了，这里的 self._func = func(*args) 搭配前面关于 yield 关键字的讲解，应该不那么难理解，可以上下结合理解
class OperatingSystem():
class Thread:
"""A "freezed" thread state."""
def __init__(self, func, *args):
self._func = func(*args) # <--- 运行源代码，并等待到 yield 第一个返回
self.retval = None # retval == return value，下接 OperatingSystem.run() 的后续部分
OperatingSystem.run() PART.2
每当程序 yield 回来，去 match 一个系统调用（如果有的话，给出返回值 retval）
class OperatingSystem():
def run(self):
threads = [OperatingSystem.Thread(self._main)] # <--- PART.1 end
while threads: # <--- PART.2 begin 检查是否还有线程存活
try:
match (temp := (t := threads[0]).step()): # 将控制权交给进程
# temp 是 t := threads[0]).step() 的返回值
# 即 temp 是一个元组 (函数名, 参数)，这里的 temp 没有实际用途，只是方便说明
# 下接 OperatingSystem.Thread.step()
OperatingSystem.Thread.step()
将线程进行一步，但这里的一步是指，到下一次系统调用
class OperatingSystem():
class Thread:
def step(self):
"""Proceed with the thread until its next trap."""
syscall, args, *_ = self._func.send(self.retval) # 向对应生成器发送信号，送入 retval
self.retval = None # 清空 retval
return syscall, args # 返回元组 (函数名, 参数)，即返回给上文提到的 temp
OperatingSystem.run() PART.3
接下来是 match 到相应系统调用后，检查线程是否结束，做出相应操作
class OperatingSystem():
def run(self):
threads = [OperatingSystem.Thread(self._main)]
while threads:
try:
match (temp := (t := threads[0]).step()): # <--- PART.2 end temp 是一个元组 (函数名, 参数)
case 'choose', xs: # <--- PART.3 begin 随机选择一个元素
t.retval = random.choice(xs) # 这里将 t.retval 设置为随机选取的值，准备作为信号送回线程
case 'write', xs: # 写入 stdout
print(xs, end='')
case 'spawn', (fn, args): # 产生一个新线程，在这个模型玩具中，只需要将其加入到 Thread 的 list 中即可
threads += [OperatingSystem.Thread(fn, *args)]
case 'sched', _: # 非确定性调度
random.shuffle(threads) # 随机排序一下即可（因为从 match 那句话可以看出，永远是选择 thread[0] 进行一步）
except StopIteration: # 某一个线程结束
threads.remove(t) # 移除结束的线程
random.shuffle(threads) # 等同于 sys_sched()
此后，各线程不断运行，直至所有线程全部结束，threads 内容为空，退出循环，运行结束。
小结
再次佩服一下 JYY 老师的这个 50 行操作系统的巧妙，使用了 yield 的机制完美的描述出了系统调用时管、目态（内核态、用户态）的切换
线程 yield 后将控制权交给操作系统（发送 0x80 中断信号），接下来操作系统查询对应系统调用编号（eax 寄存器上的值），执行系统调用并返回结果（到 eax 上）
顺带提一下，x86 架构寄存器命名方式大致如下
0000000000000000000000000000000000000000000000000000000000000000
| rax |
| eax |
| ax |
| ah |
| al |
至此，相信读者已经对整个操作系统就能够有一个很好的理解了（吴恩达：you're already an expert in machine learning.jpg）
