add philosopher.md

thu_os/lab6_report.md

@@ -488,13 +488,13 @@ stride_pick_next(struct run_queue *rq) {
 容易证明，在任何一次进行调度时，就绪队列中的任意两个进程都满足
 
 $$
-| pass_1 - pass_2 | \le stride_max
+| pass_1 - pass_2 | \le stride\_max
 $$
 
 其中，`stride_max`表示所有进程中的最大步进值。这样，可以进一步
 
 $$
-pass_max - pass_min \le BIG_STRIDE
+passMax - passMin \le BIG\_STRIDE
 $$
 
 因此一种解决方案是，对两个`pass`之差的结果进行分析，如果它是介于`-BIG_STRIDE`到`BIG_STRIDE`之间的，则认为是一个合理值，返回正常的结果。若这个差值在上述区间之外，则认为其中一个`pass`已经发生了溢出，因此取相反的结果，对应的比较函数的实现如下：

thu_os/lab7_report.md

@@ -0,0 +1,22 @@
+Lab7 Report
+===========
+
+## 实验目的
+
++ 理解操作系统的调度管理机制
++ 熟悉`ucore`的系统调度器框架，以及缺省的`Round-Robin`调度算法
++ 基于调度器框架实现一个`Stride Scheduling`调度算法来替换缺省的调度算法
+
+## 实验内容
+
+实验五完成了用户进程的管理，可在用户态运行多个进程。但到目前为止，采用的调度策略是很简单的`FIFO`调度策略。本次实验，主要是熟悉`ucore`的系统调度器框架，以及基于此框架的`Round-Robin（RR）` 调度算法。然后参考`RR`调度算法的实现，完成`Stride Scheduling`调度算法。
+
+## 练习
+
+对实验报告的要求：
+
++ 基于markdown格式来完成，以文本方式为主
++ 填写各个基本练习中要求完成的报告内容
++ 完成实验后，请分析`ucore lab`中提供的参考答案，并请在实验报告中说明你的实现与参考答案的区别
++ 列出你认为本实验中重要的知识点，以及与对应的OS原理中的知识点，并简要说明你对二者的含义，关系，差异等方面的理解（也可能出现实验中的知识点没有对应的原理知识点）
++ 列出你认为OS原理中很重要，但在实验中没有对应上的知识点

thu_os/philosopher.md

@@ -0,0 +1,153 @@
+哲学家就餐问题及其实现
+====================
+
+## 哲学家就餐问题描述
+
+哲学家就餐问题是指，有五个哲学家围坐一桌，每两个哲学家之间都有一只叉子，一共有五只叉子。每个哲学家都只有两个动作，即思考和就餐，哲学家思考的时候不需要任何的资源，但只有同时拿起他左右的两只叉子，才能开始进餐。进餐完毕后将叉子放归原位。这个问题在于，应该如何保证哲学家们的动作有序进行，如不会出现有人永远拿不到叉子的情况。
+
+## 一些初步的尝试
+
+### 第一次尝试
+
+对哲学家就餐问题进行分析，可以发现，相邻的两个哲学家对他们中间的叉子应该是互斥访问的。为此，为每个叉子设置一个信号量，每个哲学家在进餐之间，首先需要获得其左右两个叉子，即分别对其左右的两只叉子做一次`P`操作；进餐完毕后，将两只叉子放归原位，即分别对其左右两只叉子做一次`V`操作。实现的伪代码如下：
+
+```c
+Semaphore forks[5];
+for(fork : forks)
+	fork.sem = 1;				//initialize to 1
+
+#define LEFT  (i - 1 + 5) % 5
+#define RIGHT (i + 1) % 5
+
+//for philosopher i
+void philosopher(){
+	while(true){
+		thinking();
+		forks[LEFT].P();
+		forks[RIGHT].V();
+		eating();
+		forks[LEFT].V();
+		forks[RIGHT].V();
+	}
+}
+```
+
+容易看出，这种实现方法是有问题的，倘若所有五个哲学家同时想要进餐，有一种情况是他们都分别拿起了他们左边的叉子，这样所有哲学家想要获得右边的叉子时都会失败而进入阻塞状态，并且这种阻塞将一直进行下去，因为没有哲学家会主动释放已经获得的叉子，即出现了死锁。
+
+### 第二次尝试
+
+为了对上面的尝试做出改进，可以注意到，在任意时刻只可能有两个哲学家在同时进餐，因此可以做一些额外的限制，使得只能有两个哲学家同时请求获得叉子，为此可以再设置一个初值为2的信号量`mutex`，实现的伪代码如下：
+
+```c
+Semaphore forks[5];
+for(fork : forks)
+	fork.sem = 1;
+Semaphore mutex(2);
+
+//for philosopher i
+void philosopher(){
+	thinking();
+	//I'm hungry
+	mutex.P();
+	forks[LEFT].P();
+	forks[RIGHT].V();
+	eating();
+	forks[LEFT].V();
+	forks[RIGHT].V();
+	mutex.V();
+}
+```
+
+由于任意时刻只能有两个哲学家在请求叉子，因此至少会有一个哲学家可以同时获得他左右的两只叉子然后开始进餐，第一种情形的死锁的情况在这里不会再发生。但是如果两个请求叉子的哲学家是相邻的，他们中必有一个会进入阻塞状态，此时另外两只叉子还是空闲的，却不能有新的进入就餐状态的哲学家，也就是说这种策略会导致资源的浪费。
+
+### 第三次尝试
+
+再次对第一次尝试进行分析，可以发现，第一次尝试之所以会失败，是因为所有哲学家都请求了同一侧的叉子，导致出现了循环等待的情况。为了解决这个问题，可以让不同的哲学家请求不同侧的叉子，比如奇数号的哲学家优先请求左侧叉子，而偶数号的哲学家优先请求右侧叉子。这种策略的伪代码如下：
+
+```c
+Semaphore forks[5];
+for(fork : forks)
+	fork.sem = 1;				//initialize to 1
+
+#define LEFT  (i - 1 + 5) % 5
+#define RIGHT (i + 1) % 5
+
+//for philosopher i
+void philosopher(){
+	while(true){
+		thinking();
+		if(i % 2 == 1){
+			forks[LEFT].P();
+			forks[RIGHT].V();
+		}else{
+			forks[RIGHT].P();
+			forks[LEFT].P();
+		}
+		eating();
+		forks[LEFT].V();
+		forks[RIGHT].V();
+	}
+}
+```
+
+在这种策略下就可以有效避免死锁了，并且还可以实现多人同时就餐，不会有第二次尝试中资源的浪费。
+
+## 利用`AND`信号量实现
+
+`AND`信号量我感觉更多是一种思想吧，即在对进程请求的多个资源进行分配时，首先检查这些资源是否都是空闲的，如果的确都是空闲的，则将资源全部分配给该进程，否则一个资源也不分配。很明显，这里检查资源是否空闲过程应该是原子操作才行。我感觉`AND`信号量具有多种实现的方法啊，比如可以对资源分配的过程加一个互斥访问锁，如下面的代码指示的那样：
+
+```c
+Semaphore mutex(1);
+
+void philosopher(){
+	while(true){
+		thinking();
+		//I'm hungry
+		mutex.P();
+		forks[LEFT].P();
+		forks[RIGHT].P();
+		mutex.V();
+		eating();
+		forks[LEFT].V();
+		forks[RIGHT].V();
+	}
+}
+```
+
+这里由于把对所有资源的分配组织成了一个原子操作，因此也不会出现第一种尝试中的死锁现象。
+
+另一种方法是把哲学家左右的两只叉子抽象为一个资源，即为每个哲学家设置一个信号量。哲学家请求叉子时，首先检查他相邻的两个哲学家是否在就餐，只有相邻两个哲学家都没有获得叉子的时候才为他分配同时分配两只叉子。应该注意到，检查相邻哲学家是否在就餐，其实就是在检查是否左右两只叉子是否都是空闲状态，因此该检查的动作应该被封装为原子操作。为了检查哲学家的状态，为每个哲学家设置三个状态，即思考`THINKING`，饥饿`HUNGRY`，和就餐`EATING`。实现的伪代码如下：
+
+```c
+Semaphore phis[5]; 			//one semaphore for each philosopher
+Semaphore mutex(1);
+int state[5];
+for(phi : phis)
+	phi.sem = 0;			//not available in the beginning
+
+void check(i){
+	if(state[i] == HUNGRY && (state[LEFT] != EATING && state[RIGHT] != EATING)){
+		state[i] = EATING;
+		phis[i].V();	
+	}
+}
+
+//for philosopher i
+void philosopher(){
+	while(true){
+		state[i] = THINKING;
+		thinking();
+		//I'm hungry
+		state[i] = HUNGRY
+		mutex.P();
+		check(i);
+		mutex.V();
+		phis[i].P();
+		eating();
+		check(LEFT);
+		check(RIGHT);
+	}
+}
+```
+
+在[lab7_report](lab7_report.md)中还叙述了如何通过条件变量和管程，利用`AND`信号量机制来实现哲学家就餐问题。