21OS复习

Introduction

monolithic OS：
单内核，所有功能都由kernel实现，没有User space。优点：高效，缺点：不稳定

Micro kernel：
微内核，把kernel部分放入user space，优点: 扩展程度好，可以移植性高，更加可靠安全，缺点: 性能开销比较大

Process和Porgram:
Program: 存储在磁盘中的二进制文件, load入内存后变为process
process: 执行中的Program, 资源分配的单位
不同的进程可以执行同一个program

Process

PCB:
process state, PC, CPU registers,
CPU scheduling info: priority, 等待队列的指针
Mem managment info: 分配的内存
Accountting ifno: 时间片长度
I/O status info: 打开的文件

Process state:
running: 正在执行的进程
ready: 可以执行，在等待被调度
wait: 不可用执行，在等待IO
当进程时间片用完, 从run进入ready等待下一次调度，当wait结束，则进入ready等待下一次调度。

IPC: 进程通信inter-process communication
Message-Passing
优点：适合交换小数据，实现较为简单
缺点：high overhead: 每一次通信需要system call，用户实现麻烦，需要send/recv

Shared Mem:
优点：low-overhead, 只需要开始进行一次systemcall, 对用户更加友好，只需要write,read入RAM
缺点：OS实现困难

fork and exec:
fork: 新建一个process，可能只有当前的thread被复制，也可能复制所有的thread, 但在linux复制一个thread.
fork and exec: 新建进程，并且执行exec指定的内容，原来所有的线程都没了。

内核Thread和用户Thread映射:
用户线程：
有内核支持，由用户级的线程库实现
库支持线程的创建、调度、管理，不需要内核的支持
任何用户级线程都会执行阻塞系统调用，阻塞整个进程
内核线程：
由操作系统直接支持：内核在内核空间中执行线程的创建、调度和管理
创建和管理的速度比用户线程要慢
线程之间的独立块，支持多处理器
Many-to-One Model：
一个内核线程映射多个用户线程，
优点：low-overhead, 高效
缺点：不能利用多核，一次只能执行一个线程，如果一个线程阻塞，不能切换到另一个线程。

One-to-One Model：
优点：一次执行多个线程，一个线程阻塞，切换到其他线程
缺点：不够高效
examples：Windows 95/98/NT/2000，OS/2

Many-to-Many Model:
一个线程阻塞，内核创建新的线程，避免阻塞其他用户线程
新的用户进程不一定创建新的内核线程。
Examples：Solaris 2，Windows NT/2000 with the ThreadFiber package

Schedule

FCFS: 先来先服务，优点：永远不会饥饿，缺点：Convoy effect，长进程后面跟短进程，导致短进程等待很久, 一定是非抢占的

SJF: 优点：最优解，平均等待时间最短，缺点: 不能估计执行时间，分为抢占和非抢占的

RR: 抢占式，如果时间片用完，则切换下一个进程
Priority RR按照优先级，否则按照时间顺序
短时间片short quantum: 响应速度高，但是调度开销大
长时间片：响应速度慢，但是切换的开销小，可能退化为FCFS
time quantum/slice用完后，被抢占并插入就绪队列末尾，如果这个进程结束的时候有新进程产生，则挂在该进程的前面。假定就绪队列中有n个进程、时间量为q, 则每个进程每次得到1/n的、不超过q单位的成块CPU时间，没有任何一个进程的等待时间会超过(n-1)*q单位。RR的平均周转时间比SJF长，但响应时间要短一些

Priority Scheduling：
优先级可能是内部的：剩余执行时间，可能是用户指定的。可能会导致饥饿，即优先级低的进程总是无法运行。使用aging 解决

Multilevel Queue Scheduling
对进程分组，如果执行N个时间片后还没有执行完，进入下一级。直到上一级队列执行完成，开始执行下一级队列。

Multilevel Feedback Queues
和多级队列相似，每级队列用RR调度，RR的时间片逐渐增加，如果执行了若干次后没有执行完，进入下一级队列，增加时间片。这是最灵活高效的。

进程调度计算题注意：
1.十分是抢占式
2.优先级数字越小优先级越高还是越低

CPU调度的评判标准：
1.CPU utilization – CPU使用率
2.Throughput – 单位时间完成的进程数量
3.Turnaround time: 从job到达到执行完成的总时间
4.Waiting time：总job到达到开始执行的时间
5.Burst time：job需要执行的时间
6.Response time – amount of time it takes from when a request was submitted until the first response

Deadlock

dead lock:
条件：mutual exclusion，Hold and wait，non preemption, and circular wait

Deadlock Prevention：根据四个条件分别prevent.

Deadlock Avoidance Algorithms：

resource-allocation graph: 每个资源只有一个instance，
如果线段指向资源，则说明进程request 资源
如果线段指向进程，说明资源分配给了进程
如果是虚线表示可能进行请求，虚线转为实现将调转方向
如果有实线的环则一定有死锁，要求虚线转为实线时必须保证无实线的环。

banker’s algorithm：每个资源有多个instance,
allocation: 初始状态下给定的资源
max: 最大需要的资源
available: 还剩下多少资源
work: 当前可用的资源
need: 目前该进程还需要多少资源

第一步，根据max-allocation得到need
第二步，如果work>need, 则finish，work更新为work+allocation
第三步，继续找work>need的进程

如果问request arrive for (x,x,x,x)，是否可用满足，应该理解为立即从可用的里面分配这么多给它，然后把这些加入到该进程的allocation里面，最后再执行其他调度。特别的，allocation和arrive之和不能超过max
一个简单的方法是让那个进程首先执行。

同步

Critical Section:
一段代码，
同一时间最多一个进程可以访问，之前问entry section，之后为exit section，再之后为remander section.

Race Condition：进程同时访问一个共享数据，执行的结果依赖于程序访问共享数据的顺序。

concurrently: 程序同时执行，可能导致数据不一致。

关键区域算法Three Requirements:
Mutual Exclusion （互斥访问）
Progress （空闲让进）
Bounded waiting (有限等待)

Semaphore: 初值表示资源的数量，可以安全访问，
访问时通过wait(S)表示可用, 此时S<=0时等待，S>0时S–，
通过signal(S)表示释放，此时S++
由于通过信号量进行保护导致一个进程busy waiting，此时可以通过队列方式，wait时加入队列并block，signal时从队列中取出一个并wakeup。

信号量可以为负值，此时需要维护一个等待队列，绝对值是等待的进程数。正常的信号量是一个正值。

Mutex Locks: 表示一个锁，在同一时刻只能有一个进程拥有。
acqurie表示请求锁，release()表示释放锁。

test_and_set(bool* v), 把v设置为True，同时返回v本来的值。

do {
	while (test_set(&lock)); // busy wait
	critical section
	lock = FALSE;
	remainder section 
} while (TRUE);

compare_and_swap(int*value, int expected, int new): 如果value和expected相同，则修改为new，返回原来的value

while(true)
{
	while(compare_and_swap(&lock, 0, 1) != 0);
	critical section
	lock = 0;
	remainder section	
}

mem

Protection:
base and limit: base和Limit是一个进程的空间，当前进程只能访问base和limit之间的部分

MMU: 虚拟地址和物理地址转换
relocation register： 使用虚拟地址+relocation register得到物理地址
缺点：利用率低，需要连续内存

Dynamic Loading：程序在被调用时才加载入内存，可以更好利用内存，不需要OS额外操作，可以由程序执行解决。

Static linking：
将全部程序加载入内存，需要OS帮助：在进程之间共享库

内存分配方法：
Contiguous Allocation：连续分配，
Multiple-partition allocation：从当前的洞中找到一个足够的内存给新的进程，可以有：FF,BF,WF方法，
问题：External fragmentation：一个进程结束，内存被回收，但是却不够分给下一个进程。
解决方法：compaction, 在runtime时执行压缩

paging：总是按照固定的大小分给进程
Internal fragmentation：分配的大小大于所需要的
page有内部碎片，没有外部碎片

用Page table记录page的逻辑地址和物理地址
page number: page table 的index,

page table 查表过程：
1.VPN=va>>offset
2.找到VPN对应的PPN
3.PPN<offset+offset
注意不要忘记页号计算地址时左移

如果页太大，内部碎片比较严重，如果页太小，页表会比较大

TLB:
每个进程有自己的TLB，通过ASID号进行查找，如果用同一个TLB, 每次进程切换都会导致cold start

Effective Access Time：ETA
如果mem access需要xms，如果TLB命中，则只需要访问一次mem，如果TLBmiss，需要访问TLB和Page table2次mem，所以ETA=hit ratio*mem access time+(1-hit ratio)*2*mem access

通过页表项的R, X, W位进行保护，看是否允许读写和执行

计算TLB大小：
2^逻辑地址位数/2^page offset

Page Sharing：
通过页表中某两个索引指向同一个物理地址实现

hierarchical page table: 多级页表
va中分为VPN1, VPN2, page offset
VPN表示了页表的位置，页表中记录了下一级页表的位置，然后用VPN2进行查找

hashed page table：
VPN通过hash函数计算出一个hash值，然后在hash表中找到对应的项，后面连着一个链表，在链表中查找PPN

inverted page table
索引是物理页号，每项记录了虚拟页号，查找时需要遍历整个表，找到虚拟页号的值，然后索引就是物理页号，一般会增加一个pid项，表示不同的进程

Swapping
交换分区，作为物理内存的backing store，如果进程在执行中则swap in，如果内存满了，则会将一个进程的页swap到swap分区中。
移动设备不支持swap，只是把一些进程kill

10 virtual mem

Lazy Allocation(demand paging):
操作系统只有在真正访问时才分配页
如果页面是无效的=>中止操作，
如果页面是有效的，但不是在内存=>使它通过交换进入内存。

lazy swapper: 纯lazy，pre-paging：有时候预先分配页
valid bit: 表示该页是否在内存中
访问一个invalid页：
invalid reference => deliver an exception to the process
valid but not in memory => swap in

demand paging硬件支持:
page table entries with valid / invalid bit
backing storage (usually disks)
instruction restart

zero-fill-on-demand: 希望新的页都是0

Effective Access Time (EAT)=(1 – p) x memory access + p x (page fault overhead + swap page out + swap page in + instruction restart overhead)

demand paging优化：使用swap分区

COW(copy-on-write)
一个拷贝的内容只有在修改时才分配空间，尤其是fork的时候

To evaluate a page replacement algorithm：
生成一个页号的序列，并访问页号，计算缺页次数，次数越少的算法越好。
如果TLB大小为3
FIFO: 每隔三个相同的页号则是需要替换的
LRU: 把最不长访问的替换出去，向前看若干位，如果有，则不替换该页。替换最远的那个。
可以用计数器或者stack实现
Clock实现：
1.replace reference=0的页
2.对于ref=1的页，set ref=0

OPT: 把最长时间不使用的替换出去，向后看若干位，如果有，则不替换该页，替换最远的那个
LFU: 替换计数器值最小的那个页
MFU: 替换计数器值最大的那个页

Belady’s Anomaly：
FIFO page越多，page fault的不一定越少，LRU和OPT没有这种情况

Fixed Allocation：
进程均分page

Major: page被访问，但是不在mem中
Minor： page在内存中，但是没有建立映射，比如共享内存

Thrashing抖动：
操作系统一直换页，原因是进程没有足够的page，需要不断replace
此时CPU利用率比较低，因为OS认为进程使用的cpu时间比较小，此时os会增加进程
解决方法：1.局部页替换，这样一个进程抖动不影响其他进程,2.提供足够的page

Buddy System：
把物理存储器等分为多个2的幂次大小的部分
可以快速找到连续的内存

SLAB Allocators：把一块连续的内存分为多个相等的块

page size
为了避免碎片化，希望page size比较小一点
为了减小page table size，则增大Page size
为了减少缺页，则希望增加页大小
从空间局部性来说,希望页小一点，如果页太大，则很多内容会不相干

11 物理存储

Disk Scheduling
FCFS
First-come first-served, simplest scheduling algorithm
SSTF
选择距离当前位置最近的需求，可能会导致饥饿
优势：平均响应时间减少,吞吐量增加
缺点：需要提前计算寻道时间,可能导致饥饿，响应时间差异很大
SCAN
从一个位置开始到0，依次服务，然后从0到199，服务沿途的任务
优势：高吞吐量, 响应时间差异小,平均响应时间
缺点：磁盘臂刚访问过的位置请求的等待时间长
C-SCAN
从一个位置开始到199，依次服务，然后从199到0，此时的距离需要计算，但是不服务沿途，必须还是从0开始服务
优点：等待时间更加均衡
C-LOOK
与C-SCAN比，不需要走到头，只需要走到最边缘的即可(其他一模一样)
优点：减少不必要的开销

RAID – redundant array of inexpensive disks

RAID	解释	read	write
RAID0	没有冗余	N	N
RAID1	完全复制	N	最慢的那一个
RAID2	hamming code校验码	<N	需要额外写一个partiy磁盘
RAID4	使用奇偶检验码	N-1	小于RAID0
RAID5	校验码分到各个磁盘中	N	小于RAID0
RAID6	比RAID5增加了一个parity磁盘，具有两个奇偶校验块

12 IO

bus: 不同部件的通信网络
port: 不同设备的连接点
controller：设备控制器

polling轮询：
设备是否busy,如果可用则发送数据或者处理数据, busy waiting
Interrupts:
如果完成，则发起中断。轮询效率更高，因为interrupt需要上下文切换

SMP IRQ Affinity： 中断亲和性：某些中断倾向于在一个core上完成

DMA(Direct Memory Access)
使得IO设备和内存可以直接传输数据，否则需要CPU使用load和stroe进行传输，效率很低

IO设备：
block I/O: read, write, seek(比如DMA)
character I/O (Stream)(Clocks and Timers)
memory-mapped file access
network sockets

IO保护：使用系统调用处理IO

IO的限制因素：
内核态的代码，系统调用和进程切换(因为IO设备需要中断和处理器交流)
数据拷贝，需要从用户态拷贝数据到内核态

IO需要的物理支持:
Kernel IO subsystem(Caching, Spooling, Device reservasion), device driver, interrupt handler, device controller

Pagecache:一次IO请求会多读一些数据，这样可以利用相关性减小下一次IO请求,对大文件不适合，因为大文件不会被多次命中，但是却会占据pagecashe的缓存