练习0：填写已有实验
对kern/trap/trap.c中的lab6 code中的sched_class_proc_tick(current)改成run_timer_list()
case IRQ_OFFSET + IRQ_TIMER:
ticks ++;
assert(current != NULL);
run_timer_list(); //这里
break;
练习1: 理解内核级信号量的实现和基于内核级信号量的哲学家就餐问题（不需要编码）
请在实验报告中给出内核级信号量的设计描述，并说明其大致执行流程。
可以看出内核信号量结构体中就是个值，和队列而已
typedef struct {
int value;
wait_queue_t wait_queue;
} semaphore_t;
void sem_init(semaphore_t *sem, int value);
void up(semaphore_t *sem);
void down(semaphore_t *sem);
bool try_down(semaphore_t *sem);
首先分析 up函数（完成V操作），发现只是调用了_up把sem传入了
void
up(semaphore_t *sem) {
__up(sem, WT_KSEM);//WT_KSEM： 0x00000100 //等待内核信号量
}
然后来看一下_up
大致手段就是禁用中断的方式来处理（在单核有效，多核无效）
禁用中断后，首先判断是否有等待的，没有就把值++
有的话直接唤醒他就行（就是简化了一下++之后在–，所以就直接唤醒就行，方便写）
static __noinline void __up(semaphore_t *sem, uint32_t wait_state) {
bool intr_flag;
local_intr_save(intr_flag);
{
wait_t *wait;
if ((wait = wait_queue_first(&(sem->wait_queue))) == NULL) {
sem->value ++;
}
else {
assert(wait->proc->wait_state == wait_state);
wakeup_wait(&(sem->wait_queue), wait, wait_state, 1);
}
}
local_intr_restore(intr_flag)
}
然后看一下down操作（P操作）类似调用了_down
void
down(semaphore_t *sem) {
uint32_t flags = __down(sem, WT_KSEM);
assert(flags == 0);
}
首先关中断
然后查看value，如果有的话就–然后恢复中断了
没有value的话，把当前放到等待队列里，然后执行调度（让别人去占用cpu）
然后等别人有value了把自己叫醒
关中断，把等待链表上的自己删掉，恢复中断
static __noinline uint32_t __down(semaphore_t *sem, uint32_t wait_state) {
bool intr_flag;
local_intr_save(intr_flag);
if (sem->value > 0) {
sem->value --;
local_intr_restore(intr_flag);
return 0;
}
wait_t __wait, *wait = &__wait;
wait_current_set(&(sem->wait_queue), wait, wait_state);
local_intr_restore(intr_flag);
schedule();
local_intr_save(intr_flag);
wait_current_del(&(sem->wait_queue), wait);
local_intr_restore(intr_flag);
if (wait->wakeup_flags != wait_state) {
return wait->wakeup_flags;
}
return 0;
}
value>0，表示共享资源的空闲数
vlaue<0，表示该信号量的等待队列里的进程数
value=0，表示等待队列为空
哲学家就餐问题
//---------- philosophers problem using semaphore ----------------------
int state_sema[N]; /* 记录每个人状态的数组 */
/* 信号量是一个特殊的整型变量 */
semaphore_t mutex; /* 临界区互斥 */
semaphore_t s[N]; /* 每个哲学家一个信号量 */
说白了就是 先弄个互斥锁，然后看看自己能抢不，不能让别人到时候调用我的phi_test_sema去抢
void phi_take_forks_sema(int i) /* i：哲学家号码从0到N-1 */
{
down(&mutex); /* 进入临界区 */
state_sema[i] = HUNGRY; /* 记录下哲学家i饥饿的事实 */
phi_test_sema(i); /* 试图得到两只叉子 */
up(&mutex); /* 离开临界区 */
down(&s[i]); /* 如果得不到叉子就阻塞 */
}
这个就是 吃饭的人不吃了，然后看看左边的人想吃不，和右边的人想吃不
void phi_put_forks_sema(int i) /* i：哲学家号码从0到N-1 */
{
down(&mutex); /* 进入临界区 */
state_sema[i] = THINKING; /* 哲学家进餐结束 */
phi_test_sema(LEFT); /* 看一下左邻居现在是否能进餐 */
phi_test_sema(RIGHT); /* 看一下右邻居现在是否能进餐 */
up(&mutex); /* 离开临界区 */
}
整体就是，一个信号量表示公共的互斥操作，五个信号量（也算是条件变量了）表示状态（阻塞，非阻塞）
自己阻塞的时候，通过别人调用下面的函数来唤醒
void phi_test_sema(i) /* i：哲学家号码从0到N-1 */
{
if (state_sema[i] == HUNGRY && state_sema[LEFT] != EATING && state_sema[RIGHT] != EATING)
{
state_sema[i] = EATING;
up(&s[i]);
}
}
每个线程的操作函数
int philosopher_using_semaphore(void *arg) /* i：哲学家号码，从0到N-1 */
{
int i, iter = 0;
i = (int)arg;
cprintf("I am No.%d philosopher_sema\n", i);
while (iter++ < TIMES)
{ /* 无限循环 */
cprintf("Iter %d, No.%d philosopher_sema is thinking\n", iter, i); /* 哲学家正在思考 */
do_sleep(SLEEP_TIME);
phi_take_forks_sema(i);
/* 需要两只叉子，或者阻塞 */
cprintf("Iter %d, No.%d philosopher_sema is eating\n", iter, i); /* 进餐 */
do_sleep(SLEEP_TIME);
phi_put_forks_sema(i);
/* 把两把叉子同时放回桌子 */
}
cprintf("No.%d philosopher_sema quit\n", i);
return 0;
}
练习2: 完成内核级条件变量和基于内核级条件变量的哲学家就餐问题（需要编码）
内核级条件变量的哲学家就餐问题在check_sync处实现。同信号量的测试相似，这里也是创建了5个内核进程表示5个哲学家的行为。
void check_sync(void){
int i;
//check condition variable
monitor_init(&mt, N);
for(i=0;i<N;i++){
state_condvar[i]=THINKING;
int pid = kernel_thread(philosopher_using_condvar, (void *)i, 0);
if (pid <= 0) {
panic("create No.%d philosopher_using_condvar failed.\n");
}
philosopher_proc_condvar[i] = find_proc(pid);
set_proc_name(philosopher_proc_condvar[i], "philosopher_condvar_proc");
}
每个线程也是调用phi_test_condvar(i)尝试自己获取到叉子，自己获取不到，那就让别人帮自己调用phi_test_condvar这个函数来获取
同时在尝试获取不到叉子时候调用 cond_wait(&mtp->cv[i]);阻塞自己，等待别人唤醒，因为有可能唤醒之后，自己还是没有EATING所以要用循环判断，直到自己获取到了
void phi_take_forks_condvar(int i)
{
down(&(mtp->mutex));
//--------into routine in monitor--------------
// LAB7 EXERCISE1: YOUR CODE
// I am hungry
state_condvar[i] = HUNGRY; /* 记录下哲学家i饥饿的事实 */
// try to get fork
phi_test_condvar(i);
while (state_condvar[i] != EATING)
{
cprintf("phi_take_forks_condvar: %d didn't get fork and will wait\n", i);
cond_wait(&mtp->cv[i]);
}
//--------leave routine in monitor--------------
if (mtp->next_count > 0)
up(&(mtp->next));
else
up(&(mtp->mutex));
}
其中下面是管程的操作
down(&(mtp->mutex));
。。。。
//--------leave routine in monitor--------------
if (mtp->next_count > 0)
up(&(mtp->next));
else
up(&(mtp->mutex));
}
一个管程定义了一个数据结构和能为并发进程所执行（在该数据结构上）的一组操作，这组操作能同步进程和改变管程中的数据。管程由以下四部分组成：
①管程内部的共享变量；
②管程内部的条件变量；
③管程内部并发执行的进程；
④对局部于管程内部的共享数据设置初始值的语句。
即一个管程由一个锁和多个条件变量组成。由此可见，管程相当于一个隔离区，它把共享变量和对它进行操作的若干个过程围了起来，所有进程要访问临界资源时，都必须经过管程才能进入，而管程每次只允许一个进程进入管程，从而需要确保进程之间互斥。
typedef struct monitor monitor_t;
typedef struct condvar{
semaphore_t sem; // the sem semaphore is used to down the waiting proc, and the signaling proc should up the waiting proc
int count; // the number of waiters on condvar
monitor_t * owner; // the owner(monitor) of this condvar
} condvar_t;
typedef struct monitor{
semaphore_t mutex; // the mutex lock for going into the routines in monitor, should be initialized to 1
semaphore_t next; // the next semaphore is used to down the signaling proc itself, and the other OR wakeuped waiting proc should wake up the sleeped signaling proc.
int next_count; // the number of of sleeped signaling proc
condvar_t *cv; // the condvars in monitor
} monitor_t;
管程中的成员变量mutex是一个二值信号量，是实现每次只允许一个进程进入管程的关键元素，确保了互斥访问性质。管程中的条件变量cv通过执行wait_cv，会使得等待某个条件C为真的进程能够离开管程并睡眠，且让其他进程进入管程继续执行；而进入管程的某进程设置条件C为真并执行signal_cv时，能够让等待某个条件C为真的睡眠进程被唤醒，从而继续进入管程中执行。管程中的成员变量信号量next和整形变量next_count是配合进程对条件变量cv的操作而设置的，这是由于发出signal_cv的进程A会唤醒睡眠进程B，进程B执行会导致进程A睡眠，直到进程B离开管程，进程A才能继续执行，这个同步过程是通过信号量next完成的；而next_count表示了由于发出singal_cv而睡眠的进程个数。
然后下面就是实现管程中条件变量（信号量模拟）的函数
void cond_signal(condvar_t *cvp)
{
if (cvp->count > 0) //确保有人在阻塞
{
cvp->owner->next_count++;//管程只能同时有一个线程在运行，所以要把自己挂起来
up(&cvp->sem);//唤醒别人
down(&cvp->owner->next);//阻塞自己
cvp->owner->next_count--;//自己阻塞没了就--
}
}
void cond_wait(condvar_t *cvp)
{
cvp->count++;//等待数++
if(cvp->owner->next_count > 0){ // 如果说别人是因为条件变量阻塞的
up(&cvp->owner->next);
}else{//是不是条件变量阻塞的就是互斥锁阻塞
up(&cvp->owner->mutex);
}
down(&cvp->sem);//阻塞自己
cvp->count--;//接触阻塞
}
下面是哲学家操作
void phi_take_forks_condvar(int i)
{
down(&(mtp->mutex));
//--------into routine in monitor--------------
// LAB7 EXERCISE1: YOUR CODE
// I am hungry
state_condvar[i] = HUNGRY; /* 记录下哲学家i饥饿的事实 */
phi_test_condvar(i); // try to get fork
while (state_condvar[i] != EATING)
{
cprintf("phi_take_forks_condvar: %d didn't get fork and will wait\n", i);
cond_wait(&mtp->cv[i]);
}
//--------leave routine in monitor--------------
if (mtp->next_count > 0)
up(&(mtp->next));
else
up(&(mtp->mutex));
}
void phi_put_forks_condvar(int i)
{
down(&(mtp->mutex));
//--------into routine in monitor--------------
// LAB7 EXERCISE1: YOUR CODE
// I ate over
state_condvar[i] = THINKING;
// test left and right neighbors
phi_test_condvar(LEFT);
phi_test_condvar(RIGHT);
//--------leave routine in monitor--------------
if (mtp->next_count > 0)
up(&(mtp->next));
else
up(&(mtp->mutex));
}
以上就是代码操作
总体来说，我有点菜，这节的管程还是没太理解，没办法用简单的话语描述，下去在仔细了解一下把
121
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
