完成的项目:https://github.com/abc222/project3(想要小星星>_<)
然后,做一下笔记~~~
一、项目设计目的
研究进程调度算法,掌握用信号量实现进程间同步的方法。为GeekOS扩充进程调度算法——基于时间片轮转的进程多级反馈调度算法,并能用信号量实现进程协作。
二、项目设计要求
(1)实现src/geekos/syscall.c文件中的Sys_SetSchedulingPolicy系统调用,它的功能是设置系统采用的何种进程调度策略;
(2)实现geekos/syscall.c文件中的Sys_GetTimeOfDaysrc/系统调用,它的功能是获取全局变量g_numTicks的值;
(3)实现函数Change_Scheduling_Policy(),具体实现不同调度算法的转换。
(4)实现syscall.c中信号量有关的四个系统调用:sys_createsemaphore( )、sys_P( )、sys_V( )和sys_destroysemaphore( )。
PS:前三个要求都是关于多级反馈调度策略的,第一个是设置,第三个是转换,第二个用来评估算法;第四个要求是有关信号量操作。
三、先看一些GeekOS进程管理基础知识
1、内核进程控制块
系统中每个内核进程有且只有一个进程控制块,进程控制块是用于记录进程状态及有关信息的数据结构。GeekOS操作系统中用数据结构Kernel_Thread作为内核进程控制块,对系统中的进程信息、执行情况、控制信息等加以维护,这个结构在include/kthread.h中定义。
struct Kernel_Thread {
ulong_t esp; /* offset 0 */
volatile ulong_t numTicks; /* offset 4 */
int priority;
DEFINE_LINK(Thread_Queue, Kernel_Thread);
void* stackPage;
struct User_Context* userContext;
struct Kernel_Thread* owner;
int refCount;
/* These fields are used to implement the Join() function */
bool alive;
struct Thread_Queue joinQueue;
int exitCode;
/* The kernel thread id; also used as process id */
int pid;
/* Link fields for list of all threads in the system. */
DEFINE_LINK(All_Thread_List, Kernel_Thread);
/* Array of MAX_TLOCAL_KEYS pointers to thread-local data. */
#define MAX_TLOCAL_KEYS 128
const void* tlocalData[MAX_TLOCAL_KEYS];
/*
* The run queue level that the thread should be put on
* when it is restarted.
*/
int currentReadyQueue;
bool blocked;
};
2、GeekOS系统中最早的内核进程
GeekOS系统最早创建的内核进程有Idle、Peaper和Main3个进程。在系统初始化时,Main函数调用了一系列初始化函数,其中Init_Scheduler函数(\src\geekos\kthread.c)的作用:
- 初始化一个内核进程mainThread,并将该进程作为当前运行进程;
- 创建两个系统进程Idle和Reaper;
- Idle进程类似于Windows中的系统闲置进程,什么也不做,创建后就一直存在于系统中,它存在的唯一目的是保证准备运行队列中有可调度的进程。当系统没有可运行的进程时,CPU就运行Idle,一旦有其他准备运行的进程进入,Idle就会立即放弃CPU。
- Reaper负责消亡进程的善后工作,如释放消亡进程占用的资源,内存、堆栈等。
void Init_Scheduler(void)
{
g_preSchedulingPolicy = ROUND_ROBIN;
g_curSchedulingPolicy = MULTILEVEL_FEEDBACK;
struct Kernel_Thread* mainThread = (struct Kernel_Thread *) KERN_THREAD_OBJ;
/*
* Create initial kernel thread context object and stack,
* and make them current.
*/
Init_Thread(mainThread, (void *) KERN_STACK, PRIORITY_NORMAL, true);
g_currentThread = mainThread;
Add_To_Back_Of_All_Thread_List(&s_allThreadList, mainThread);
/*
* Create the idle thread.
*/
/*Print("starting idle thread\n");*/
Start_Kernel_Thread(Idle, 0, PRIORITY_IDLE, true);
/*
* Create the reaper thread.
*/
/*Print("starting reaper thread\n");*/
Start_Kernel_Thread(Reaper, 0, PRIORITY_NORMAL, true);
}
3、内核进程对象
创建一个GeekOS内核进程需要调用Start_Kernel_Thread函数,而Start_Kernel_Thread内部调用Creat_Thread函数 ,该函数主要是创建内核进程对象,并调用Alloc_Page函数为进程对象、进程内核堆栈各分配一页内存(若失败,返回0,同时释放内核控制块空间)。
struct Kernel_Thread* Start_Kernel_Thread(
Thread_Start_Func startFunc,
ulong_t arg,
int priority,
bool detached
)
{
struct Kernel_Thread* kthread = Create_Thread(priority, detached);
if (kthread != 0) {
/*
* Create the initial context for the thread to make
* it schedulable.
*/
Setup_Kernel_Thread(kthread, startFunc, arg);
/* Atomically put the thread on the run queue. */
Make_Runnable_Atomic(kthread);
}
return kthread;
}
4、进程调度
GeekOS在一下几种情况会发生进程切换:
1)时间片用完;
2)执行内核进程Idle;
3)进程退出调用Exit函数;
4)进程进入等待调用Wait函数。
第一种情况下,当时间片用完,进程切换在中断处理函数Handle_Interrupt(在lowlevel.asm中定义)中完成。
align 8
Handle_Interrupt:
; Save registers (general purpose and segment)
Save_Registers
; Ensure that we're using the kernel data segment
mov ax, KERNEL_DS
mov ds, ax
mov es, ax
; Get the address of the C handler function from the
; table of handler functions.
mov eax, g_interruptTable ; get address of handler table
mov esi, [esp+REG_SKIP] ; get interrupt number
mov ebx, [eax+esi*4] ; get address of handler function
; Call the handler.
; The argument passed is a pointer to an Interrupt_State struct,
; which describes the stack layout for all interrupts.
push esp
call ebx
add esp, 4 ; clear 1 argument
; If preemption is disabled, then the current thread
; keeps running.
cmp [g_preemptionDisabled], dword 0
jne .restore
; See if we need to choose a new thread to run.
cmp [g_needReschedule], dword 0
je .restore
; Put current thread back on the run queue
push dword [g_currentThread]
call Make_Runnable
add esp, 4 ; clear 1 argument
; Save stack pointer in current thread context, and
; clear numTicks field.
mov eax, [g_currentThread]
mov [eax+0], esp ; esp field
mov [eax+4], dword 0 ; numTicks field
; Pick a new thread to run, and switch to its stack
call Get_Next_Runnable
mov [g_currentThread], eax
mov esp, [eax+0] ; esp field
; Clear "need reschedule" flag
mov [g_needReschedule], dword 0
.restore:
; Activate the user context, if necessary.
Activate_User_Context
; Restore registers
Restore_Registers
; Return from the interrupt.
iret
后三种情况,函数内部都有调用Schedule()函数,其中又调用Switch_To_Thread函数(在lowlevel.asm中定义)
align 16
Switch_To_Thread:
; Modify the stack to allow a later return via an iret instruction.
; We start with a stack that looks like this:
;
; thread_ptr
; esp --> return addr
;
; We change it to look like this:
;
; thread_ptr
; eflags
; cs
; esp --> return addr
push eax ; save eax
mov eax, [esp+4] ; get return address
mov [esp-4], eax ; move return addr down 8 bytes from orig loc
add esp, 8 ; move stack ptr up
pushfd ; put eflags where return address was
mov eax, [esp-4] ; restore saved value of eax
push dword KERNEL_CS ; push cs selector
sub esp, 4 ; point stack ptr at return address
; Push fake error code and interrupt number
push dword 0
push dword 0
; Save general purpose registers.
Save_Registers
; Save stack pointer in the thread context struct (at offset 0).
mov eax, [g_currentThread]
mov [eax+0], esp
; Clear numTicks field in thread context, since this
; thread is being suspended.
mov [eax+4], dword 0
; Load the pointer to the new thread context into eax.
; We skip over the Interrupt_State struct on the stack to
; get the parameter.
mov eax, [esp+INTERRUPT_STATE_SIZE]
; Make the new thread current, and switch to its stack.
mov [g_currentThread], eax
mov esp, [eax+0]
; Activate the user context, if necessary.
Activate_User_Context
; Restore general purpose and segment registers, and clear interrupt
; number and error code.
Restore_Registers
; We'll return to the place where the thread was
; executing last.
iret
; Return current contents of eflags register.
以上两个关键函数均在汇编文件中实现,最终执行一个iret指令中断返回,跳入目标进程。
5、GeekOS进程调度策略
GeekOS的初始系统提供的进程调度是时间片轮转调度,所有准备运行进程(即Kernel_Thread)都放在一个FIFO队列里面,进程调度时找优先级最高的进程投入运行。
在GeekOS中,Get_Next_Runnable函数就是进程调度算法实现的地方,由\src\geekos\kthread.c文件中的Find_Best函数在准备运行进程的队列(s_runQueue指针指向)中查找,找优先级最高的。
6、GeekOS进程调度处理过程
进程调度是在时钟中断处理函数Time_Interrupt_Handle(/src/geekos/timer.c)内实现的。进程的Kernel_Thread结构中有一个numTicks变量,在进程对象初始化时被初始化为零,之后每次时钟中断处理,进程的该变量都会加1,然后系统会检查进程执行的时间是否超过了系统规定的时间片g_Quantum,如果超过,说明当前进程时间片已用完,系统应调度新的进程运行,于是将变量g_needReschedule置为true,用以标志需要重新调度新进程运行。
在时钟中断处理函数返回到Handle_Interrupt后检查g_needReschedule变量,如果为true,就调用Make_Runnable函数(kthread.c),将当前运行进程放入准备运行进程队列s_runQueue;之后再调用Get_Next_Runnable函数(kthread.c)找到优先级最高的进程;最后返回Handle_Interrupt将g_needReschedule返回为false,并切换到新进程运行。
static void Timer_Interrupt_Handler(struct Interrupt_State* state)
{
int i;
struct Kernel_Thread* current = g_currentThread;
Begin_IRQ(state);
/* Update global and per-thread number of ticks */
++g_numTicks;
++current->numTicks;
/* update timer events */
for (i=0; i < timeEventCount; i++) {
if (pendingTimerEvents[i].ticks == 0) {
if (timerDebug) Print("timer: event %d expired (%d ticks)\n",
pendingTimerEvents[i].id, pendingTimerEvents[i].origTicks);
(pendingTimerEvents[i].callBack)(pendingTimerEvents[i].id);
} else {
pendingTimerEvents[i].ticks--;
}
}
/*
* If thread has been running for an entire quantum,
* inform the interrupt return code that we want
* to choose a new thread.
*/
if (current->numTicks >= g_Quantum) {
g_needReschedule = true;
/*
* The current process is moved to a lower priority queue,
* since it consumed a full quantum.
*/
if (current->currentReadyQueue < (MAX_QUEUE_LEVEL - 1)) {
/*Print("process %d moved to ready queue %d\n", current->pid, current->currentReadyQueue); */
current->currentReadyQueue++;
}
}
End_IRQ(state);
}
四、项目设计原理
设计流程图:
本项目主要实现多级反馈队列(MLF)和轮询(RR)调度算法以及信号量的相关操作, 需要我们填写 syscall.c 和 kthread.c 等不同文件中的多个函数。 在之前的项目中,GeekOS 使用的系统调度算法均为轮询调度算法,因此在此项目 中,我们需要实现 MLF 调度算法的相关操作以及 RR 与 MLF 两种算法之间的队列转换 算法。GeekOS 中,MLF 算法的规则描述为:进程就绪队列共分为 4 级,按照优先级从 高到低排列分别为 Q0、Q1、Q2 和 Q3 队列;新创建的进程会被置入最高优先级的就绪 队列(此处为 Q0);每当一个进程运行完一个时间片长度之后,它就会被置入比之前低 一级的就绪队列,直到到达优先级最低的队列(Q3), 因此,CPU 密集型的进程最终会 被放到最低优先级的队列中;如果一个进程被阻塞(blocked),它的队列优先级就会提 升一个等级,直到被阻塞三次后达到最高优先级队列(Q0)。
在 MLF 策略与 RR 策略的进程队列转换时,GeekOS 给出的规则如下:MLF->RR 时,将 Q1-Q3 队列中所有进程转移至 Q0 队列,然后按照优先级从高到低的顺序重新排 序;RR->MLF 时,只需将原本位于 Q0 队列中的 Idle(空闲)进程转移至 Q3 队列,其 他进程无需再做修改。在实际编写代码的时候,由于 GeekOS 提前实现了从队列中获取 最高优先级进程的函数 Find_Best(),因此在 MLF->RR 时只需要将所有队列中进程移至 Q0 队列中即可。
为实现四级队列,设计中首先要修改s_runQueue(src/geekos/kthreas.c)的定义,从原来一个结构体改为一个4元素的结构体数组,每一个结构体元素用于存放一个优先级队列的队首指针。
GeekOS系统将Idle进程始终放在优先级为3的进程队列末尾,且不允许移动到其它队列,以保证进程调度时一定能找到进程投入运行。
当实现四级反馈队列调度策略后,GeekOS系统就拥有2种进程调度策略,即单队列时间片轮转调度策略和四级反馈队列调度策略。到底采用哪种,是通过系统调用Sys_SetSchedulingPolicy(src/geekos/syscall.c)实现的,函数原型:
static int Sys_SetSchedulingPolicy(struct Interrupt_State* state);
参数state是一个结构体,其中,state->ebx成员用于指定调度策略,值为0代表系统采用时间片轮转调度策略,值为1则代表系统采用四级反馈队列调度策略,若取其他值则出错。state->ecx成员用于记录相应调度策略下的时间片长度。
五、多级反馈策略测试运行流程
schedtest里面参数相关代码:
if (argc == 3) {
if (!strcmp(argv[1], "rr")) {
policy = 0;//选择时间片轮转调度
} else if (!strcmp(argv[1], "mlf")) {
policy = 1;//选择多级反馈调度
} else {
Print("usage: %s [rr|mlf] <quantum>\n", argv[0]);
Exit(1);
}
} else {
Print("usage: %s [rr|mlf] <quantum>\n", argv[0]);
Exit(1);
}
quantum = atoi(argv[2]);//设置时间片长度
Set_Scheduling_Policy(policy, quantum);
接着调用Sys_SetSchedulingPolicy()(\src\geekos\syscall.c)设置调度策略:
static int Sys_SetSchedulingPolicy(struct Interrupt_State* state)
{
/* 如果输入的优先级调度方法参数无效(非 0 或 1)则返回错误 */
if (state->ebx != ROUND_ROBIN && state->ebx != MULTILEVEL_FEEDBACK)
{
Print("Error! Scheduling Policy should be RR or MLF\n");
return -1;
}
/* 如果输入的时间片参数不在[1, 100]之间则返回错误 */
if (state->ecx < 1 || state->ecx > 100)
{
Print("Error! Quantum should be in the range of [1, 100]\n");
return -1;
}
int res = Chang_Scheduling_Policy(state->ebx, state->ecx);
return res;
}
到Chang_Scheduling_Policy()(\src\geekos\kthread.c)修改线程队列及系统相关变量,主要是 g_curSchedulingPolicy 为当前调度策略, g_Quantum 为时间片长度:
int Chang_Scheduling_Policy(int policy, int quantum)
{
/* 如果调度策略不同,则修改线程队列 */
if (policy != g_curSchedulingPolicy)
{
/* MLF -> RR */
if (policy == ROUND_ROBIN)
{
/* 从最后一个线程队列(此处为 Q3)开始将其中的所有线程依次移动到前一个队列,
直到所有线程都移动到 Q0 队列 */
int i;
for (i = MAX_QUEUE_LEVEL - 1; i > 0; i--)
Append_Thread_Queue(&s_runQueue[i - 1], &s_runQueue[i]);
}
/* RR -> MLF */
else
{
/* 判断 Idle(空闲)线程是否在 Q0 队列 */
if (Is_Member_Of_Thread_Queue(&s_runQueue[0], IdleThread))
{
/* 将 Idle 线程从 Q0 队列移出 */
Remove_Thread(&s_runQueue[0], IdleThread);
/* 将 Idle 线程加入到最后一个队列(此处为 Q3) */
Enqueue_Thread(&s_runQueue[MAX_QUEUE_LEVEL - 1], IdleThread);
}
}
/* 保存原来的调度策略 */
g_preSchedulingPolicy = g_curSchedulingPolicy;
/* 将全局变量设置为对应的输入值 */
g_curSchedulingPolicy = policy;
Print("g_schedulingPolicy = %d\n", g_curSchedulingPolicy);
}
g_Quantum = quantum;
Print("g_Quantum = %d\n", g_Quantum);
return 0;
}
系统创建进程并运行后,每次时钟中断,进程的numTicks变量加1,这就用到了上面的Time_Interrupt_Handle(/src/geekos/timer.c),通过进程所用时间片与用户输入时间片长度比较,设置g_needReschedule变量,再调用Handle_Interrupt进行进程调度。倘若超过时间片,g_needReschedule为true,Handle_Interrupt就会调用Get_Next_Runnable(\src\geekos\kthread.c),Get_Next_Runnable函数就是进程调度算法实现的地方:
struct Kernel_Thread* Get_Next_Runnable(void)
{
/* Find the best thread from the highest-priority run queue */
KASSERT(g_curSchedulingPolicy == ROUND_ROBIN ||
g_curSchedulingPolicy == MULTILEVEL_FEEDBACK);
/* 查找下一个被调度的线程 */
struct Kernel_Thread* best = NULL;
if (g_curSchedulingPolicy == ROUND_ROBIN)
{
/* 轮询调度策略:只需要从 Q0 队列找优先级最高的线程取出 */
best = Find_Best(&s_runQueue[0]);
/* 如果找到了符合条件的线程则将其从队列中移出 */
if (best != NULL)
Remove_Thread(&s_runQueue[0], best);
}
else
{
int i;
for (i = 0; i < MAX_QUEUE_LEVEL; i++)
{
/* 从最高层队列依次向下查找本层队列中最靠近队首的线程,
如果找到则不再向下继续查找 */
best = Get_Front_Of_Thread_Queue(&s_runQueue[i]);
if (best != NULL)
{
Remove_Thread(&s_runQueue[i], best);
break;
}
}
}
/* 如果当前没有可执行进程,则至少应该找到 Idle 线程 */
KASSERT(best != NULL);
return best;
/*
* Print("Scheduling %x\n", best);
*/
}
系统调入新的进程运行后,时间片轮转结束,继续调度新的进程。
运行结果:
从上面的测试结果来看,这两种调度算法都是基于时间片轮转,输出2和输出1的的数量基本一样多(多队列优先级调度算法的时间片都是一样的)。进程的周转时间还包括进程切换的时间。同样的调度算法,同样的时间片,程序执行的周转时间可能不一样(进程切换花费的时间可能不一样)。
六、信号量和PV操作
信号量操作:
Semaphore_Create( )
Semaphore_Acquire(P操作)
Semaphore_Release(V操作)
Semaphore_Destroy( )
Create_Semaphore()函数首先检查请求创建的这个信号量的名字是否存在,如果存在,那么就把这个线程加入到这个信号量所注册的线程链表上;如果不存在,则分配内存给新的信号量,清空它的线程队列,把当前的这个线程加入到它的线程队列中,设置注册线程数量为1,初始化信号量的名字,值和信号量的ID,并把这个信号量添加到信号量链表上,最后返回信号量的ID。
P操作Semaphore_Acquire()中,首先检查传入的信号量ID是否存在,如果存在,接着检查当前线程是否注册使用了这个信号量,如果这两项检查任意一项失败了,那么就返回-1。如果成功了,就把信号量的值减去1,如果减去1后信号量的值小于0,那么就把当前线程放入这个信号量的等待队列上。
V操作Semaphore_Release()中,首先也是检查传入的信号量ID是否存在,如果存在,接着检查当前线程是否注册使用了这个信号量,如果这两项检查任意一项失败了,那么就返回-1。如果成功了,那就把信号量的值加上1,如果加上1后信号量的值小于或等于0,则要把该信号量里等待队列上的一个线程唤醒。
Semaphore_Destroy()中,首先也是检查传入的信号量ID是否存在,如果存在,接着检查当前线程是否注册使用了这个信号量,如果这两项检查任意一项失败了,那么就返回-1。如果成功了,就把该线程从这个信号量的注册的线程数组中删除,并把注册的线程数量减去1。如果这个信号量的注册线程为0了,则把这个信号量从信号量链表中删除,并释放它的内存。
运行结果:
semtest:
semtest1:
semtest2:
从结果中我们可以看出,我们实现的信号量相关操作(创建、获取、释放和销毁) 都能够正确的在系统中执行,而且在 semtest2.exe 的测试中对于不正确的信号量操作(线 程对未授权信号量进行操作、无效信号量 ID 和销毁信号量后再对其进行获取操作)系 统也能够进行相应的处理和反馈,从此证明了信号量部分相关代码的正确性。
七、其他
在完成项目 3 代码填写进行测试的时候,可能发现 schedtest.exe 这个文件在 /project3/build/user/文件夹中存在,但是却无法在系统中执行,总是会显示找不到文件, 如图:
分析 GeekOS 系统编译阶段 make 程序的执行结果,会发现 schedtest.exe 文件的名 称并没有显示完全,也就是说在 GeekOS 的挂载磁盘中,这个文件的名称为“schedtest.ex” 而非“schedtest.exe”, 这也就是为什么直接输入程序名或者加上路径都无法执行该文件 的原因。同时还能发现了 Makefile 文件中并没有加入对 semtest.c 和 null.c 的编译处理, make 工具生成结果见下图:
找到原因后,解决方案: exe 文件是通过/tools/builtFat.exe 这 个小程序生成 img 格式磁盘映像文件的,找到这个文件的源代码文件位置 /project3/src/tools/buildFat.c,会发现是其中使用的 directoryEntry 这个结构中 fileName 字段 的长度不足。因此通过 grep 指令找到 directoryEntry 结构体所在文件 /project3/include/geekos/pfat.h,改动如下:
同时,为了解决上面额外发现的有文件未编译的问题,还应修改/build/Makefile文件,在“USER_C_SRCS”后面添加“semtest.c”和“null.c”。
至此,问题解决。
哈哈哈