模拟线程切换 C++
前言：
本文主要是剖析NachOs的线程切换原理，并通过一个简化的例子（就是将线程部分代码抽取出来再加以修改）
来说明。本文 githbu代码：https://github.com/Ldpe2G/ThreadSwitch--Simulation
正文：
Thread类的声明：
#ifndef THREAD_H
#define THREAD_H
/* the offsets of the registers from the beginning of the thread object */
/* 寄存器存储的位置对应的线程对象内存地址的偏移量 */
#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
/* These definitions are used in Thread::AllocateStack(). */
#define PCState (_PC/4-1)
#define InitialPCState (_ESI/4-1)
#define InitialArgState (_EDX/4-1)
#define MachineStateSize 75
typedef void (*VoidFunctionPtr)(void *arg);
const int StackSize = (8 * 1024); // stack size = 8 * 1024 * 4 bytes
class Thread{
private:
// the current stack pointer
int *stackTop;
// all registers except for stackTop
// 线程切换时存储寄存器的数组
void *machineState[MachineStateSize];
public:
Thread(char* name); // initialize a Thread
~Thread(); // deallocate a Thread
// 分配栈空间和初始化machinState然后
// 将该线程放入就绪队列
void Fork(VoidFunctionPtr func, void *arg);
//从队列中找出下一个要运行的线程，
//然后该线程放入就绪队列
void yield();
// Put the thread to sleep
void Ssleep(bool finishing);
// thread Startup
void Begin();
// The thread is done executing
void Finish();
// Check if thread stack has overflowed
void CheckOverflow();
char* getName(){return name;}
private:
int *stack; // Bottom of the stack
char* name;
void StackAllocate(VoidFunctionPtr func, void *arg);
};
extern "C" {
// First frame on thread execution stack;
// call ThreadBegin
// call "func"
// (when func returns) call ThreadFinish()
void ThreadRoot();
// Stop running oldThread and start running newThread
void SWITCH(Thread *oldThread, Thread *newThread);
}
#endif //THREAD_H
具体的函数定义可以看Github上的代码：Thread.cpp。
代码分析：
现在结合上面的代码来分析。
NachOS的多线程其实就是多个代码段，通过人为调度的方式将它们调度作为线程代码执行。就像单核CPU上的
多线程实现，其实就是线程之间轮换时间片。
我们可以看到在Thread类的开头有两个私有变量：
stackTop （线程运行时的栈指针）和 machineState（线程切换时用于保存当前寄存器的值以便于恢复）。
这两个变量必须是放在开头，接下来解释线程切换的原理的时候读者就会明白为什么要放在开头。
接下来我们看到代码底部的 ThreadRoot 和 SWITCH 函数，这两个函数的内部实现用到了内联汇编。
这两个函数就是重点要解释的部分。
ThreadRoot函数定义：
//Func线程保存函数地址
//IniArg保存函数参数地址
void* IniArg = (void*)0;
void* Func = (void*)0;
void ThreadRoot(){
simulator->currentThread->Begin();
__asm{
push IniArg /* 线程函数func的参数入栈 */
call Func /* call线程函数func */
add esp,4 /* 释放参数传递的栈空间 */
}
simulator->currentThread->Finish();
}
分析：
在NachOS中，除了main线程外，其他线程都是从ThreadRoot入口运行的。
要注意的是ThreadRoot函数并没有被显式的调用，而是在SWITCH函数执行完之后才被调用。
一个线程在初始化的左后准备工作中调用StackAllocate方法，初始化栈空间和设置寄存器的值，
开始的时候保存在machineState中。然后当该线程被切换上CPU的时候，ThreadRoot就被调用。
SWITCH函数定义：
unsigned long _eax_save = 0; //全局中间变量
void SWITCH(Thread *oldThread, Thread *newThread){
__asm{
pop edi /* 恢复edi */
pop esi /* 恢复esi */
pop ebx /* 恢复ebx */
mov esp,ebp /* 释放要函数局部变量空间 */
pop ebp /* 恢复ebp */
mov _eax_save,eax /* 暂存eax, 注意:_eax_save为全局变量 */
mov eax, [esp+4] /* eax 指向oldThread */
mov [_EBX+eax],ebx /* 保存相关寄存器值, 到oldThread的空间中 */
mov [_ECX+eax],ecx
mov [_EDX+eax],edx
mov [_ESI+eax],esi
mov [_EDI+eax],edi
mov [_EBP+eax],ebp
mov [_ESP+eax],esp /* 保存栈指针 */
mov ebx,_eax_save /* 取暂存的eax，从全局变量 _eax_save中 */
mov [_EAX+eax],ebx /* 保存初始eax的值 */
mov ebx,[esp+0] /* 取返回地址 */
mov [_PC +eax],ebx /* 保存返回地址 */
mov eax,[esp+8] /* eax指向newThread */
mov ebx,[_EAX+eax] /* 取newThread保存的eax值*/
mov _eax_save,ebx /* 暂存到 _eax_save */
mov ebx,[_EBX+eax] /* 恢复newThread保存的寄存器值 */
mov ecx,[_ECX+eax]
mov edx,[_EDX+eax]
mov IniArg,edx // 将线程函数参数保存到全局变量
mov esi,[_ESI+eax]
mov Func,esi // 保存线程函数地址
mov edi,[_EDI+eax]
mov ebp,[_EBP+eax]
mov esp,[_ESP+eax] //恢复栈指针
mov eax,[_PC +eax] //保存返回地址到eax
mov [esp+0],eax
mov eax,[_eax_save]
ret /*直接返回，然后继续新线程的执行*/
}
}
分析：
从代码上我们可以看到，NachOS中的线程切换是要借助宿主主机。
其中oldThread是原来正在运行的线程，newThread值需要切换到的线程指针。
线程切换过程是：
1、保存原来正在运行的线程的状态，就是保存寄存器的值；
2、恢复新运行线程的状态；
3、然后最后ret语句执行完就继续新线程的运行。
要理解上述的汇编代码我们首先来看看Thread对象的内存布局：
在StackAllocate初始化然后调用了StackAllocate函数之后的内存布局。
我们可以看到stackTop 和 machinState第一个元素 的地址为线程对象地址分别加0和加4就能找到。
再结合SWITCH汇编代码详细分析：
在代码开头可以看到连续3个pop语句然后恢复ebp，这是因为编译器在帮我们编译的时候做了一些工作。
现在我们来看看SWITCH的反汇编的代码：
unsigned long _eax_save = 0; //全局中间变量
void SWITCH(Thread *oldThread, Thread *newThread){
001748F0 push ebp
001748F1 mov ebp,esp
001748F3 sub esp,0C0h
001748F9 push ebx
001748FA push esi
001748FB push edi
001748FC lea edi,[ebp-0C0h]
00174902 mov ecx,30h
00174907 mov eax,0CCCCCCCCh
0017490C rep stos dword ptr es:[edi]
__asm{
//align 2
pop edi /* 恢复edi */
0017490E pop edi
pop esi /* 恢复esi */
0017490F pop esi
pop ebx /* 恢复ebx */
00174910 pop ebx
mov esp,ebp /* 释放要函数局部变量空间 */
00174911 mov esp,ebp
pop ebp /* 恢复ebp */
00174913 pop ebp
我们可以看到编译器帮我们保存ebp，接着分配函数局部空间然后自动保存了edi，esi，ebx的值。
所以这就是为什么需要先pop的原因，然后释放函数局部空间，恢复ebp的值。
接着才是将寄存器的值保存到oldTHread的machineState变量中，然后还有保存返回地址。
然后将newThread的状态恢复然后继续newThread的执行。
现在来分析具体的切换过程：
首先在进入SWTICH函数时，栈的内容如下：
这也是在刚开始要保存oldThread状态时的栈内容。即是在释放了函数局部空间之后的状态。
所以oldThread 和 newThread 的地址就是 [ esp + 4 ] 和 [ esp + 8 ] ，
然后代码中eax用作线程对象内部变量寻址，[ eax ] 就是stackTop的地址，
而 [ eax + 4 ] 就是machineState第一个元素的地址。
在恢复newThread状态的时候，最后将esp指向了newThread的stackTop所指向的地址，
然后再修改其内容为返回的地址，如果newThread是第一次运行，则返回地址就是ThreadRoot函数的
地址。如果不是就是ThreadRoot函数或者线程函数运行到某一条指令的地址。然后就是继续newThead
的运行。
simulator的声明：
#include<vector>
#include"Thread.h"
using namespace std;
#ifndef SIMULATOR_H
#define SIMULATOR_H
class Simulator{
public:
Simulator();
~Simulator();
//将线程加入就绪队列
void ReadyToRun(Thread* thread);
//随机从就绪队列中返回一个线程来运行
Thread* FindNextToRun();
//切换新旧线程，运行新线程，finishing表示旧线程是否销毁
void Run(Thread* nextThread, bool finishing);
//检测有无线程需要销毁
void CheckToBeDestroyed();
//开始模拟多线程
void Start();
Thread* currentThread; //指向当前正在运行的线程
private:
vector<Thread*> readyList; //保存就绪状态的线程
Thread *toBeDestroyed; //指向将要销毁的线程
};
//声明全局变量，在main.cpp中定义
extern Simulator* simulator;
#endif //SIMULATOR_H
具体的函数定义可以看Github上的代码：Simulator.cpp。
main.cpp的内容：
#include"Simulator.h"
#include"Thread.h"
#include<iostream>
using namespace std;
Simulator* simulator;
//线程要执行的函数
void ThreadTest(int which){
for(int i = 0; i < which; i++) {
std::cout << "*** thread " << simulator->currentThread->getName()
<< " looped " << i << " times\n";
//没一次循环结束，令当前正在运行的线程放弃CPU
//进入就绪队列，然后切换下一个线程，以此来模拟多线程抢占CPU
simulator->currentThread->yield();
}
}
int main(int argc, char* argv[]){
simulator = new Simulator;
Thread* t;
for(int i=0; i<5; i++){
char* threadName = new char[30];
sprintf(threadName, "%s%d", "Test Thread ", i);
t = new Thread(threadName);
t->Fork((VoidFunctionPtr)ThreadTest, (void*)(i + 2));
}
simulator->Start();
return 0;
}
测试结果：
参考资料：
函数调用约定学习
还有以前师兄的论文，这里无法提供链接