线程和上下文切换 C++

Question

我需要帮助来理解以下代码。是用C++（BC31编译器）写的线程工作和上下文切换的例子。

我明白为什么 PCB 存在是为了切换上下文（特别是为了保留 SS 和 SP 寄存器），我也明白通过使用这个程序可以 return 到像什么都没发生一样被打断的地步。关于代码，我了解宏 DISABLE_INTERRUPT 和 ENABLE_INTERRUPT 的用途（忽略代码某些敏感部分的中断）。我还了解函数 createProcess，其中为每个线程创建了本地堆栈，并且线程的标志、段和偏移量被写入其中。在函数 timerISR 中，我了解完成上下文切换的部分（SS 和 SP 的写入和读取）。

对于其余的代码，我不能说我看懂了。 returnNextThread()、initNewRoutine()、returnOldRoutine()、finishThread() 函数有什么意义？

不过，我最感兴趣的是这个程序是如何运行同时发生的，那里实际发生了什么，所以这三个函数在运行宁...

这一切是如何运作的？我真的很感激一个简单的解释。

#include<stdio.h>
#include<stdlib.h>
#include<iostream.h>
#include<dos.h>

typedef struct PCB_struct {
    unsigned ss;
    unsigned sp;
    unsigned finished;
    unsigned quant;
} PCB;

#define DISABLE_INTERRUPT  asm cli
#define ENABLE_INTERRUPT  asm sti
PCB *threads[4];
volatile unsigned addressOfInterruptVector = 0x08;
volatile unsigned adressOfFreePlaceForInterrupt = 0x60;
volatile unsigned numberOfInterrupts=0;
volatile PCB *activeThread;
volatile unsigned activeThreadNumber=0;
volatile unsigned numberOfFinishedThreads=0;
volatile int necessarilyContextSwitch=0;

PCB* returnNextThread() {
    if(activeThreadNumber==0) {
        if(threads[1]->finished==0) {
            activeThreadNumber=1;
            return threads[1];
        }
        else if(threads[2]->finished==0) {
            activeThreadNumber=2;
            return threads[2];
        }
        else if(threads[3]->finished==0) {
            activeThreadNumber=3;
            return threads[3];
        }
        else {
            activeThreadNumber=0;
            return threads[0];
        }
    }
    else if(activeThreadNumber==1) {
        if(threads[2]->finished==0) {
            activeThreadNumber=2;
            return threads[2];
        }
        else if(threads[3]->finished==0) {
            activeThreadNumber=3;
            return threads[3];
        }
        else {
            activeThreadNumber=0;
            return threads[0];
        }
    }
    else if(activeThreadNumber==2) {
        if(threads[1]->finished==0) {
            activeThreadNumber=1;
            return threads[1];
        }
        else if(threads[3]->finished==0) {
            activeThreadNumber=3;
            return threads[3];
        }
        else {
            activeThreadNumber=0;
            return threads[0];
        }
    }
    else if(activeThreadNumber==3) {
        if(threads[2]->finished==0) {
            activeThreadNumber=2;
            return threads[2];
        }
        else if(threads[1]->finished==0) {
            activeThreadNumber=1;
            return threads[1];
        }
        else {
            activeThreadNumber=0;
            return threads[0];
        }
    }
    activeThreadNumber=0;
    return threads[0];
}

unsigned tmpSs=0;
unsigned tmpSp=0;
void interrupt timerISR() {
    if(!necessarilyContextSwitch) numberOfInterrupts--;
    if(numberOfFinishedThreads<3 && (numberOfInterrupts==0 || necessarilyContextSwitch==1)) {
        asm {
            mov tmpSs,ss
            mov tmpSp,sp
        }
        activeThread->ss=tmpSs;
        activeThread->sp=tmpSp;
        activeThread=returnNextThread();
        tmpSs=activeThread->ss;
        tmpSp=activeThread->sp;
        numberOfInterrupts=activeThread->quant;
        asm {
            mov ss,tmpSs
            mov sp,tmpSp
        }
    }
    if(!necessarilyContextSwitch) asm int 60h;
    necessarilyContextSwitch=0;
}

unsigned oldRoutineOffset, oldRoutineSegment;

void initNewRoutine() {
    unsigned offsetAddress=addressOfInterruptVector*4;
    unsigned segmentAddress=addressOfInterruptVector*4+2;
    unsigned emptyOffset=adressOfFreePlaceForInterrupt*4;
    unsigned emptySegment=adressOfFreePlaceForInterrupt*4+2;
    DISABLE_INTERRUPT 
    asm {
        push es
        push ax
        push di
        mov ax,0
        mov es,ax

        mov di, word ptr segmentAddress
        mov ax, word ptr es:di
        mov word ptr oldRoutineSegment, ax
        mov word ptr es:di, seg timerISR

        mov di, word ptr offsetAddress
        mov ax, word ptr es:di
        mov word ptr oldRoutineOffset, ax
        mov word ptr es:di, offset timerISR

        mov di, word ptr emptyOffset
        mov ax, word ptr oldRoutineOffset
        mov word ptr es:di, ax
        mov di, word ptr emptySegment
        mov ax, word ptr oldRoutineSegment
        mov word ptr es:di, ax

        pop di
        pop ax
        pop es
    }
    ENABLE_INTERRUPT 
}

void returnOldRoutine() {
    unsigned offsetAddress=addressOfInterruptVector*4;
    unsigned segmentAddress=addressOfInterruptVector*4+2;
    DISABLE_INTERRUPT 
    asm {
        push es
        push ax
        push di

        mov ax,0
        mov es,ax

        mov di, word ptr segmentAddress
        mov ax, word ptr oldRoutineSegment
        mov word ptr es:di, ax

        mov di, word ptr offsetAddress
        mov ax, word ptr oldRoutineOffset
        mov word ptr es:di, ax

        pop di
        pop ax
        pop es
    }
    ENABLE_INTERRUPT 
}

int finishThread() {
    necessarilyContextSwitch=1;
    DISABLE_INTERRUPT 
    activeThread->finished=1;
    cout << "Thread " << activeThreadNumber << " finished." << endl;
    ENABLE_INTERRUPT 
    timerISR();
    return 0;
}

void function1() {
    for(int i=0;i<30;i++) {
        cout << "Execution: function 1: " << i << endl;
        for(int j=0;j<10000;j++) {
            for(int k=0;k<30000;k++);
        }
    }
    finishThread();
}

void function2() {
    for(int i=0;i<30;i++) {
        cout << "Execution: function 2: " << i << endl;
        for(int j=0;j<10000;j++) {
            for(int k=0;k<30000;k++);
        }
    }
    finishThread();
}

void function3() {
    for(int i=0;i<30;i++) {
        cout << "Execution: function 3: " << i << endl;
        for(int j=0;j<10000;j++) {
            for(int k=0;k<30000;k++);
        }
    }
    finishThread();
}

void createProcess(PCB *block, void (*method)()) {
    unsigned* st1 = new unsigned[1024];

    st1[1023] = 0x200;          
    st1[1022] = FP_SEG(method);
    st1[1021] = FP_OFF(method);

    block->sp = FP_OFF(st1+1012);
    block->ss = FP_SEG(st1+1012);
    block->finished=0;
}

void mainThread() {

    for(int i=0;i<30;i++) {
        DISABLE_INTERRUPT 
        cout << "Main Thread: " << i << endl;
        ENABLE_INTERRUPT 
        for(int j=0;j<30000;j++) {
            for(int k=0;k<30000;k++);
        }
    }
}

int main() {
    DISABLE_INTERRUPT 
    threads[1]=new PCB();
    createProcess(threads[1], function1);
    threads[1]->quant=20;

    threads[2]=new PCB();
    createProcess(threads[2], function2);
    threads[2]->quant=40;

    threads[3]=new PCB();
    createProcess(threads[3], function3);
    threads[3]->quant=20;

    threads[0]=new PCB();
    activeThread=threads[0];
    activeThreadNumber=0;
    activeThread->quant=20;
    numberOfInterrupts=activeThread->quant;
    ENABLE_INTERRUPT 
    initNewRoutine();
    mainThread();
    returnOldRoutine();
    cout << "Main program finished." << endl;
    return 0;
}

Answer 1

那是可怕的代码（老不是借口）。无论如何，timerISR 每隔一段时间就会触发并切换到由 returnNextThread（基本上是调度程序）确定的适当线程。

finishThread 显然通过将线程标记为已完成并强制进行上下文切换来结束线程。哪一部分不清楚？

initNewRoutine 和 returnOldRoutine 只是安装和卸载定时器 ISR（不幸的命名）。

Answer 2

这看起来像是在非常古老的 CPU 上实现的自制任务调度程序。您可能需要一个非常旧的系统才能拥有它运行.

在高层，代码功能如下：

PCB块只是每个线程的属性。他们维护 2 个寄存器的值，slice（线程在 CPU 上花费了多长时间）和是否完成的标志
当你创建一个新线程（进程）时，这个结构被初始化，但没有其他事情发生
timerInterrupt 由 CPU 在超过时间阈值时自动触发。看到中断后，中断处理程序分析结构并通过调用 CPU 中断切换到适当的线程。

线程和上下文切换 C++

Threads and context switch C++

c++

x86

assembly

multithreading

interrupt