GeekOS Project3

1项目3

1.1项目3设计要求

   要求学生改进GeekOS的调度程序，实现基于4级反馈队列的调度算法（初始GeekOS系统仅提供了FIFO进程调度算法），并实现信号量，支持进程间通信。

即完成以下几项：

(1)实现src/geekos/syscall.c文件中的Sys_SetSchedulingPolicy系统调用，它的功能是设置系统采用的何种进程调度策略；

  (2)实现src/geekos/syscall.c文件中的Sys_GetTimeOfDay系统调用，它的功能是获取全局变量g_numTicks的值；

  (3)实现函数Change_Scheduling_Policy()，具体实现不同调度算法的转换。

  (4)实现syscall.c中信号量有关的四个系统调用：sys_createsemaphore( )、sys_P( )、sys_V( )和sys_destroysemaphore( )。

1.2 项目3设计原理和分析

1）Set_Scheduling_Policy(policy,quantum),policy是设置的调度策略，quantum是设置的时间片。例如policy为1说明设置的是多级反馈队列调度算法，g_schedulingPolicy设置为1（g_schedulingPolicy为系统添加的标识算法的变量，初始化为0）。如果policy为0，则说明设置的是轮转调度， g_schedulingPolicy设置为0，把4个队列变成一个队列，即所有的线程都在队列0上了。

 2）在系统调用Sys_GetTimeOfDay（）中，只需要返回g_numTicks就可以了。在Sys_SetSchedulingPolicy（）中，如果state->ebx是1，则设置的是MLF算法，为0则是RR算法。如果state->ebx为其他值，则返回-1。

    3）在Init_Thread（）中都是把队列放在0队列上的，并且blocked变量为false。

    4）在Get_Next_Runnable（）中，从最高级的队列开始，调用Find_Best（）来找线程优先级最大的线程，直到在某级队列中找到符合条件可以运行的线程。

    5）在Wait（）函数中，线程被阻塞，所以blocked变量被设置为true，并且如果是MLF算法，则该进程的currentReadyQueue加一，下次运行的时候进入高一级的线程队列。

6）信号量定义

GveekOS定义了信号量的结构体：

structSemaphore{

     int semaphoreID;                /*信号量的ID*/

     char *semaphoreName;            /*信号量的名字*/

     int value;                      /*信号量的值*/

     int registeredThreadCount;       /*注册该信号量的线程数量*/

     struct Kernel_Thread*registeredThreads[MAX_REGISTERED_THREADS];

/*注册的线程*/

     struct Thread_Queue waitingThreads;    /*等待该信号的线程队列*/

    DEFINE_LINK(Semaphore_List,Semaphore); /*连接信号链表的域*/

     }

7）信号量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了，则把这个信号量从信号量链表中删除，并释放它的内存。

8）多级反馈队列调度队列模型   

9）多级反馈队列与分时调度进程队列的转换

1..3项目3实现

实现信号量需要在synch.h文件中添加信号量结构体的定义和信号量队列的的定义

/*

 *define Semaphore

 */

struct Semaphore;

DEFINE_LIST(Semaphore_List,Semaphore);

 

struct Semaphore{

     intsemaphoreID;                

     char*semaphoreName;          

     intvalue;                    

     intregisteredThreadCount;      

     #defineMAX_REGISTERED_THREADS 60

     structKernel_Thread *registeredThreads[MAX_REGISTERED_THREADS];

     structThread_Queue waitingThreads;   

    DEFINE_LINK(Semaphore_List,Semaphore);

};

IMPLEMENT_LIST(Semaphore_List,Semaphore);

 

static __inline__ void Enqueue_Semaphore(structSemaphore_List *list, struct Semaphore *sem) {

   Add_To_Back_Of_Semaphore_List(list, sem);

}

static __inline__ void Remove_Semaphore(structSemaphore_List *list, struct Semaphore *sem) {

   Remove_From_Semaphore_List(list, sem);

}

在syscall.c文件中添加：

static structSemaphore_List s_sphlist;//如果定义为指针类型易导致13号页保护中断

static intsemnub=1;

并完成如下函数：

/*

 * Create asemaphore.

 * Params:

 *   state->ebx - user address of name ofsemaphore

 *   state->ecx - length of semaphore name

 *   state->edx - initial semaphore count

 * Returns: theglobal semaphore id

 */

static int Sys_CreateSemaphore(struct Interrupt_State*state)

{

//    TODO("CreateSemaphoresystem call");

        int rc;

        char*name = 0;

        //intexit, id_sem;

        structSemaphore *s=s_sphlist.head;

 

        if ((rc =Copy_User_String(state->ebx, state->ecx, VFS_MAX_PATH_LEN, &name)) !=0 )

                goto fail;

        //Print("Copy_User_String_Name=%s\n",name);

        while(s!=0)

        {

        //Print("whiles->semaphoreName=%s\n",s->semaphoreName);        

            if(strcmp(s->semaphoreName,name)==0)

            {

                s->registeredThreads[s->registeredThreadCount]=g_currentThread;

                s->registeredThreadCount+=1;

                returns->semaphoreID;

            }

            s=Get_Next_In_Semaphore_List(s);

        }

        s=(structSemaphore *)Malloc(sizeof(struct Semaphore));

        s->registeredThreads[0]=g_currentThread;

        s->registeredThreadCount=1;

        //strcpy(s->semaphoreName,name);

        s->semaphoreName=name;

        //Print("s->semaphoreName=name===%s\n",s->semaphoreName);

        Clear_Thread_Queue(&s->waitingThreads);

        s->value=state->edx;

        s->semaphoreID=semnub;

        semnub++;

        Add_To_Back_Of_Semaphore_List(&s_sphlist,s);

       

        returns->semaphoreID; 

fail:

    Print("CreateSemaphorefailed!");

    return -1;

}

/*

 * Acquire asemaphore.

 * Assume thatthe process has permission to access the semaphore,

 * the call willblock until the semaphore count is >= 0.

 * Params:

 *   state->ebx - the semaphore id

 *

 * Returns: 0 ifsuccessful, error code (< 0) if unsuccessful

 */

static int Sys_P(struct Interrupt_State* state)

{

//   TODO("P (semaphore acquire) system call");

    structSemaphore *s=s_sphlist.head;    

    while(s!=0)

    {

        if(s->semaphoreID== state->ebx)

            break;                 

        s=Get_Next_In_Semaphore_List(s);               

    }

    if(s==0)

        return-1;

 

    s->value-=1;

 

    if(s->value<0) 

        Wait(&s->waitingThreads);  

     

    return 0;  

}

/*

 * Release asemaphore.

 * Params:

 *   state->ebx - the semaphore id

 *

 * Returns: 0 ifsuccessful, error code (< 0) if unsuccessful

 */

static int Sys_V(struct Interrupt_State* state)

{

//   TODO("V (semaphore release) system call");

 

        structKernel_Thread *kthread;

        structSemaphore *s=s_sphlist.head;

       

        while(s!=0)

        {

            if(s->semaphoreID==state->ebx) 

                 break;        

            s=Get_Next_In_Semaphore_List(s);               

        } 

    if(s==0)

        return-1;

 

    s->value+=1;

 

    if(s->value>=0){

        kthread =s->waitingThreads.head;

        if(kthread !=0){  

            Wake_Up_One(&s->waitingThreads);

        }

    }

     

      return 0;    

}

/*

 * Destroy asemaphore.

 * Params:

 *   state->ebx - the semaphore id

 *

 * Returns: 0 ifsuccessful, error code (< 0) if unsuccessful

 */

static int Sys_DestroySemaphore(structInterrupt_State* state)

{

   //TODO("DestroySemaphore system call");

    structSemaphore *s = s_sphlist.head;

 

    while (s) {

        if(s->semaphoreID == state->ebx)

            break;

        s =Get_Next_In_Semaphore_List(s);

    }

 

    if (s == 0)

        return-1;

 

    s->registeredThreadCount--;

    if(s->registeredThreadCount == 0) {

        Free(s);

        Remove_From_Semaphore_List(&s_sphlist,s);

    }

    return 0;

}

实现多队列的优先级调度要在kthread.h中定义调度方式的宏：

#define ROUND_ROBIN 0

#define MULTILEVEL_FEEDBACK 1 

/*  * Number ofscheduling policy.  * 0 -> RoundRobin  * 1 -> Multilevel feedback  */

int g_schedulingPolicy;

在kthread.c中完成如下函数：

/*

 * Get the nextrunnable thread from the run queue.

 * This is thescheduler.

 */

struct Kernel_Thread* Get_Next_Runnable(void)

{

    structKernel_Thread* best = 0;

    int i,best_index_queue = -1;

 

    if(g_schedulingPolicy == ROUND_ROBIN) {

        structKernel_Thread* best_in_queue = NULL;

 

        for (i =0; i < MAX_QUEUE_LEVEL; i++){

            best_in_queue= Find_Best(&s_runQueue[i]);

            if(best == NULL) {

                best= best_in_queue;

                best_index_queue= i;

            }else if (best_in_queue != NULL){

                    if(best_in_queue->priority > best->priority) {

                        best= best_in_queue;

                        best_index_queue= i;

                    }

            }

        }

    } else if(g_schedulingPolicy == MULTILEVEL_FEEDBACK) {

        if (g_currentThread->priority != PRIORITY_IDLE ){

            if (g_currentThread->blocked && g_currentThread->currentReadyQueue> 0 )

                g_currentThread->currentReadyQueue--;

        }

 

        for (i =0; i < MAX_QUEUE_LEVEL; i++){

            best= Find_Best(&s_runQueue[i]);

            best_index_queue= i;

            if(best != NULL)

                break;

        }

 

        if (best->currentReadyQueue < MAX_QUEUE_LEVEL-1 )

            best->currentReadyQueue++;

 

    }

 

    KASSERT(best!= NULL);

    Remove_Thread(&s_runQueue[best_index_queue],best);

    return best;

}

在syscall.c中完成如下函数：

/*

 * Set the scheduling policy.

 * Params:

 *  state->ebx - policy,

 *  state->ecx - number of ticks in quantum

 * Returns: 0 if successful, -1otherwise

 */

static int Sys_SetSchedulingPolicy(struct Interrupt_State* state)

{

    if (state->ebx != ROUND_ROBIN&& state->ebx != MULTILEVEL_FEEDBACK)

        return -1;

    g_schedulingPolicy =state->ebx;

    g_Quantum = state->ecx;

    return 0;

}

信号量测试结果如下图所示：

                                                                                  图1 项目3信号量测试界面

多队列优先级调度测试结果如下图所示：

                                                                        图2 项目3多队列优先级调度测试界面

1.4项目小结

      从上面的测试结果来看，这两种调度算法都是基于时间片轮转，输出2和输出1的的数量基本一样多（多队列优先级调度算法的时间片都是一样的）。进程的周转时间还包括进程切换的时间。同样的调度算法，同样的时间片，程序执行的周转时间可能不一样（进程切换花费的时间可能不一样）。信号量测试程序测试的是生产者消费者的互斥操作，生产一个消费一个。