Nachos系统的上下文切换

Fork调用创建进程

在实验1中通过gdb调试初步熟悉了Nahcos上下文切换的基本流程，但这个过程还不够清晰，通过源码阅读进一步了解这个过程。
在实验1中通过执行Threadtest，Fork创建子进程，并传入SimpleThread执行currentThread->Yield()进行进程切换：

//----------------------------------------------------------------------
// SimpleThread
// 	Loop 5 times, yielding the CPU to another ready thread 
//	each iteration.
//
//	"which" is simply a number identifying the thread, for debugging
//	purposes.
//----------------------------------------------------------------------

void
SimpleThread(_int which)
{
    int num;
    
    for (num = 0; num < 5; num++) {
	printf("*** thread %d looped %d times\n", (int) which, num);
        currentThread->Yield(); // 模拟时间片用完，Yield进入就绪队列
    }
}

//----------------------------------------------------------------------
// ThreadTest
// 	Set up a ping-pong between two threads, by forking a thread 
//	to call SimpleThread, and then calling SimpleThread ourselves.
//----------------------------------------------------------------------

void
ThreadTest()
{
    DEBUG('t', "Entering SimpleTest");

    Thread *t = new Thread("forked thread");

    t->Fork(SimpleThread, 1);   // fork之后父子进程轮转协作，运行SimpleThread
    SimpleThread(0);
}

在实验8中通过系统调用Exec执行Fork进行子进程的创建，传入StartProcess，与实验1不同，这个Fork是为用户程序创建进程，需要进行地址空间的拷贝，调用InitRegisters初始化CPU寄存器，调用RestoreState加载页表（在处理SC_Exec时已经分配好了用户程序的地址空间），并调用machine::run()执行。

case SC_Exec:
{
    printf("Execute system call of Exec()\n");
    // read argument
    char filename[50];
    int addr = machine->ReadRegister(4);
    int i = 0;
    do
    {
        // read filname from mainMemory
        machine->ReadMem(addr + i, 1, (int *)&filename[i]);
    } while (filename[i++] != '\0');
    printf("Exec(%s)\n", filename);

    // 为halt.noff创建相应的进程以及相应的核心线程
    // 将该进程映射至新建的核心线程上执行begin
    DEBUG('x', "thread:%s\tExec(%s):\n", currentThread->getName(), filename);

    // if (filename[0] == 'l' && filename[1] == 's') // ls
    // {
    //     DEBUG('x', "thread:%s\tFile(s) on Nachos DISK:\n", currentThread->getName());
    //     fileSystem->List();
    //     machine->WriteRegister(2, 127); //
    //     AdvancePC();
    //     return;
    // }

    // OpenFile *executable = fileSystem->OpenTest(filename);
    OpenFile *executable = fileSystem->Open(filename);
    AddrSpace *space;

    if (executable == NULL)
    {
        printf("Unable to open file %s\n", filename);
        // return;

        ASSERT(false);
    }
    space = new AddrSpace(executable);
    // printf("u:Fork\n");
    Thread *thread = new Thread(filename);
    thread->Fork(StartProcess, space->getSpaceId());
    // end

    // return spaceID
    machine->WriteRegister(2, space->getSpaceId());
    AdvancePC();

    currentThread->Yield();

    delete executable;
    break;
}

Yield调度线程执行

但是Fork出的子程序并不是立即执行的！进程的调度由Scheduler负责，Fork前会将该进程加入到就绪队列中。如果我们不用任何进程调度命令，bar程序在执行完系统调用之后，会继续执行该程序剩下的指令，并不会跳转到halt程序执行，因此需要在系统调用返回前调用currentThread->Yield，切换执行halt进程，这样才是完整的Exec系统调用。

  nextThread = scheduler->FindNextToRun();
    if (nextThread != NULL) {
        scheduler->ReadyToRun(this);
        scheduler->Run(nextThread);
    }

scheduler::run

Yield调用scheduler::run执行：

void
Scheduler::Run (Thread *nextThread)
{   // 运行一个新线程

    Thread *oldThread = currentThread;
    
#ifdef USER_PROGRAM			// ignore until running user programs 
    // 1. 将当前CPU寄存器的内容保存到旧进程的用户寄存器中
    // 2. 保存用户页表
    if (currentThread->pcb->space != NULL) {	// if this thread is a user program,
        currentThread->SaveUserState(); // save the user's CPU registers
	    currentThread->pcb->space->SaveState();
    }
#endif
    
    oldThread->CheckOverflow();		    // check if the old thread
					    // had an undetected stack overflow

    currentThread = nextThread;		    // switch to the next thread
    currentThread->setStatus(RUNNING);      // nextThread is now running
    // 将线程指针指向新线程
    DEBUG('t', "Switching from thread \"%s\" to thread \"%s\"\n",
	  oldThread->getName(), nextThread->getName());
    
    // This is a machine-dependent assembly language routine defined 
    // in switch.s.  You may have to think
    // a bit to figure out what happens after this, both from the point
    // of view of the thread and from the perspective of the "outside world".
    
    // 从线程和外部世界的视角
    SWITCH(oldThread, nextThread);  
    // 此时寄存器（非通用数据寄存器，可能是PC，SP等状态寄存器）的状态还未保存和更新
    
    DEBUG('t', "Now in thread \"%s\"\n", currentThread->getName());

    // If the old thread gave up the processor because it was finishing,
    // we need to delete its carcass.  Note we cannot delete the thread
    // before now (for example, in Thread::Finish()), because up to this
    // point, we were still running on the old thread's stack!
    if (threadToBeDestroyed != NULL) {
        delete threadToBeDestroyed;     // 回收旧线程的堆栈
	    threadToBeDestroyed = NULL;
    }
    
#ifdef USER_PROGRAM
    // 1. 如果运行用户进程，需要将当前进程的用户寄存器内存加载到CPU寄存器中
    // 2. 并且加载用户页表
    if (currentThread->pcb->space != NULL) {		// if there is an address space
        currentThread->RestoreUserState();     // to restore, do it.
	    currentThread->pcb->space->RestoreState();
    }
#endif
}

①首尾两部分是用户寄存器和CPU寄存器之间的操作，将40个CPU寄存器的状态保存至用户寄存器，将新进程的用户寄存器加载至CPU寄存器，并加载用户程序页表。
②检查栈溢出。
③将currentThread指向新进程，将其状态设置为RUNNING。
④调用汇编程序SWITCH，实验1中此处的注释是该程序保存并更新寄存器的状态，可是这不是在①部分code做的事情？
⑤回收进程堆栈。

SWITCH初步探索

结合源码进行分析：

#ifdef HOST_i386
/* void SWITCH( thread *t1, thread *t2 )
**
** on entry, stack looks like this:
**      8(esp)  ->              thread *t2
**      4(esp)  ->              thread *t1
**       (esp)  ->              return address
**
** we push the current eax on the stack so that we can use it as
** a pointer to t1, this decrements esp by 4, so when we use it
** to reference stuff on the stack, we add 4 to the offset.
*/
        .comm   _eax_save,4

        .globl  _SWITCH
_SWITCH:
        movl    %eax,_eax_save          # save the value of eax
        movl    4(%esp),%eax            # move pointer to t1 into eax
        movl    %ebx,_EBX(%eax)         # save registers
        movl    %ecx,_ECX(%eax)
        movl    %edx,_EDX(%eax)
        movl    %esi,_ESI(%eax)
        movl    %edi,_EDI(%eax)
        movl    %ebp,_EBP(%eax)
        movl    %esp,_ESP(%eax)         # save stack pointer
        movl    _eax_save,%ebx          # get the saved value of eax
        movl    %ebx,_EAX(%eax)         # store it
        movl    0(%esp),%ebx            # get return address from stack into ebx
        movl    %ebx,_PC(%eax)          # save it into the pc storage

        movl    8(%esp),%eax            # move pointer to t2 into eax

        ......
        movl    _eax_save,%eax

        ret

#endif // HOST_i386

的确是寄存器的保存与加载，但这个寄存器和前面的CPU、用户寄存器有什么不同？实际上它们对应0-32（Step=4）之间数字。

#define _ESP     0
#define _EAX     4
#define _EBX     8
#define _ECX     12
#define _EDX     16
#define _EBP     20
#define _ESI     24
#define _EDI     28
#define _PC      32

StackAllocate开辟堆栈存储进程信息

关注Thread::StackAllocate，将无关部分删除。可看到该函数在StartProcess中也被调用，用于为进程创建堆栈，是的，Nachos的堆栈并不是在内存中进行创建，内存中仅仅存放了noff文件加载进来的内容。
调用AllocBoundedArray分配了StackSize 的堆栈空间，之后将stack+StackSize-4的位置设置为栈顶stackTop，之后在stack位置处设置了一个标志STACK_FENCEPOST，用于检查堆栈溢出（②），当该标志被修改，代表堆栈溢出了。也就是stack维护栈底，stackTop维护栈顶。

ASSERT((unsigned int)*stack == STACK_FENCEPOST);

void
Thread::StackAllocate (VoidFunctionPtr func, _int arg)
{   // 栈分配
    stack = (int *) AllocBoundedArray(StackSize * sizeof(_int));

    // i386 & MIPS & SPARC & ALPHA stack works from high addresses to low addresses
    stackTop = stack + StackSize - 4;	// -4 to be on the safe side!
    *stack = STACK_FENCEPOST;    
    machineState[PCState] = (_int) ThreadRoot;
    machineState[StartupPCState] = (_int) InterruptEnable;
    machineState[InitialPCState] = (_int) func;
    machineState[InitialArgState] = arg;
    machineState[WhenDonePCState] = (_int) ThreadFinish;
}

注意到Thread类将stackTop和machineState的定义提前了，而SWITCH的参数为Thread*，其操作的也是0偏移量为32以内的内存单元，因此SWITCH操作的“寄存器”就是stackTop和machineState，以及Linux系统的寄存器%ebx,%eax,%esp等等。

class Thread {
  private:  // 特意提前，保证SWITCH例程正常
    // NOTE: DO NOT CHANGE the order of these first two members.
    // THEY MUST be in this position for SWITCH to work.
    int* stackTop;			 // the current stack pointer
    _int machineState[MachineStateSize];  // all registers except for stackTop

  public:

结合下面宏定义，了解machineState中各个寄存器存储内容的含义。

#define PCState         (_PC/4-1)
#define FPState         (_EBP/4-1)
#define InitialPCState  (_ESI/4-1)
#define InitialArgState (_EDX/4-1)
#define WhenDonePCState (_EDI/4-1)
#define StartupPCState  (_ECX/4-1)

ThreadRoot维护进程的生命周期

那么machineState的“寄存器”存储了哪些信息？有什么作用？SWITCH之后Linux系统PC保存的应该是ThreadRoot的起始地址，因为4(%esp)是SWITCH的返回地址，它被设置为ThreadRoot的起始地址。这个函数模拟了一个进程的“一生”，初始化，执行，到终结。下面这几个调用函数的地址在StackAllocate最末尾被存储在machineState中，并在SWITCH中装载到Linux系统的寄存器中。

#define InitialPC       %esi
#define InitialArg      %edx
#define WhenDonePC      %edi
#define StartupPC       %ecx

        .text
        .align  2

        .globl  _ThreadRoot

/* void ThreadRoot( void )
**
** expects the following registers to be initialized:
**      eax     points to startup function (interrupt enable)
**      edx     contains inital argument to thread function
**      esi     points to thread function
**      edi     point to Thread::Finish()
*/
_ThreadRoot:
        pushl   %ebp
        movl    %esp,%ebp
        pushl   InitialArg
        call    StartupPC
        call    InitialPC
        call    WhenDonePC

        # NOT REACHED
        movl    %ebp,%esp
        popl    %ebp
        ret

SWITCH更新Linux寄存器状态

现在可以回答最开始的问题了，SWITCH程序保存和更新的是Linux系统寄存器的内容，将其保存到machinState寄存器中。不同于Nachos的用户寄存器和CPU寄存器，这两者是在执行用户程序时才会使用到，用于保存用户指令和机器指令的结果和状态，前者是Nachos得以在Linux机器上运行的基础，这也是为什么它必须要通过汇编代码实现的原因，要操纵Linux系统的寄存器。

回收进程堆栈

scheduler::run最后的语句，回收线程堆栈，这时当前线程仍然在执行，它回收的肯定不是当前线程的堆栈！实际上是已经结束的线程，执行Thread::Finish，会将threadToBeDestroyed指向自己。而Finish是在进程终结之时执行，ThreadRoot中call WhenDonePC就是执行Finish。It all makes sense!

总结

之前在阅读scheduler::run的时候，有一段SWITCH注释让我很迷惑,“You may have to think a bit to figure out what happens after this, both from the point of view of the thread and from the perspective of the “outside world”.”，这个从外部世界去看是什么意思？现在，我也许有了答案。Nachos终归是运行在Linux上的操作系统，用了很多设计Timer，Scheduler，Interrupt模拟了machine，也就是硬件，但是归根结底，它只是运行在Linux系统上的一个进程，Linux系统的PC寄存器保存着Nachos“程序”正在执行的指令地址，为了实现Nachos系统的进程切换，在Linux的一个进程中的一个部分（Nachos进程）跳转到另一个部分，必须修改Linux系统的PC寄存器以及其他寄存器。为了操作Linux系统的寄存器，也就是实际物理硬件的寄存器，必须通过汇编程序进行，因此有了两个SWITCH和ThreadRoot两个汇编方法调用。在Nachos上下文切换中，前者更新Linux寄存器的内容，后者管理进程（除了在Initialize方法中创建的第一个线程main）的生命周期，通过Linux寄存器调用进程初始化StartupPC，运行InitialPC，终结WhenDonePC的3个过程。