Visualization - s3loy's blog

graph TD
    Running((运行))
    Ready((就绪))
    Blocked((阻塞))

    Running -->|"取消调度"| Ready
    Ready -->|"调度"| Running
    Running -->|"I/O: 发起"| Blocked
    Blocked -->|"I/O: 完成"| Ready

Interlude: ProcessAPI

The fork() System Call

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char *argv[]) {
  printf("hello (pid:%d)\n", (int) getpid());
  int rc = fork();
  if (rc < 0) {
    // fork failed
    fprintf(stderr, "fork failed\n");
    exit(1);
  } else if (rc == 0) {
    // child (new process)
    printf("child (pid:%d)\n", (int) getpid());
  } else {
    // parent goes down this path (main)
    printf("parent of %d (pid:%d)\n",
    rc, (int) getpid());
  }
  return 0;
}

wsl跑了一下

$ gcc p1.c -o p1
$ ./p1
hello (pid:990)
parent of 991 (pid:990)
child (pid:991)

fork()创建子进程,从创建的位置开始运行,而非main() fork()结束后,父进程和子进程都在内存内,输出结果取决于CPU调度程序(Scheduler) 因为无法预测操作系统的调度策略,所以程序的输出顺序时不确定的(non-deterministic) 在后序多进程程序(multi-threaded program)和并发(concurrency)时会更加明显

The wait() System Call

wait()系统调用会在子进程运行结束后才返回

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main(int argc, char *argv[])
{
    printf("hello world (pid:%d)\n", (int) getpid());
    int rc = fork();
    if (rc < 0) {
        // fork failed; exit
        fprintf(stderr, "fork failed\n");
        exit(1);
    } else if (rc == 0) {
        // child (new process)
        printf("hello, I am child (pid:%d)\n", (int) getpid());
  sleep(1);
    } else {
        // parent goes down this path (original process)
        int wc = wait(NULL);
        printf("hello, I am parent of %d (wc:%d) (pid:%d)\n",
         rc, wc, (int) getpid());
    }
    return 0;
}

$ ./p2
hello world (pid:1350)
hello, I am child (pid:1351)
hello, I am parent of 1351 (wc:1351) (pid:1350)

父进程调用wait(),延迟执行,直到子进程执行完毕。当子进程结束时,wait()才返回父进程,使得程序输出结果变稳定了

Finally, The exec() System Call

它也是创建进程 API 的一个重要部分,可以让子进程执行与父进程不同的程序

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>

int main(int argc, char *argv[])
{
    printf("hello world (pid:%d)\n", (int) getpid());
    int rc = fork();
    if (rc < 0) {
        // fork failed; exit
        fprintf(stderr, "fork failed\n");
        exit(1);
    } else if (rc == 0) {
        // child (new process)
        printf("hello, I am child (pid:%d)\n", (int) getpid());
        char *myargs[3];
        myargs[0] = strdup("wc");   // program: "wc" (word count)
        myargs[1] = strdup("p3.c"); // argument: file to count
        myargs[2] = NULL;           // marks end of array
        execvp(myargs[0], myargs);  // runs word count
        printf("this shouldn't print out");
    } else {
        // parent goes down this path (original process)
        int wc = wait(NULL);
        printf("hello, I am parent of %d (wc:%d) (pid:%d)\n",
         rc, wc, (int) getpid());
    }
    return 0;
}

$ ./p3
hello world (pid:605)
hello, I am child (pid:606)
  35  120 1024 p3.c
hello, I am parent of 606 (wc:606) (pid:605)

Why? Motivating The API

构建shell时好用 fork()和 exec()的分离,让 shell 可以方便地实现很多有用的功能

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <assert.h>
#include <sys/wait.h>

int main(int argc, char *argv[])
{
    int rc = fork();
    if (rc < 0) {
        // fork failed; exit
        fprintf(stderr, "fork failed\n");
        exit(1);
    } else if (rc == 0) {
  // child: redirect standard output to a file
  close(STDOUT_FILENO);
  open("./p4.output", O_CREAT|O_WRONLY|O_TRUNC, S_IRWXU);

  // now exec "wc"...
        char *myargs[3];
        myargs[0] = strdup("wc");   // program: "wc" (word count)
        myargs[1] = strdup("p4.c"); // argument: file to count
        myargs[2] = NULL;           // marks end of array
        execvp(myargs[0], myargs);  // runs word count
    } else {
        // parent goes down this path (original process)
        int wc = wait(NULL);
        assert(wc >= 0);
    }
    return 0;
}

但幸运的是我们的init会一直wait()循环,有时候这个孤儿进程反而是很好被利用的点

Mechanism: Limited Direct Execution

通过时分共享(time sharing)CPU，实现了虚拟化

但构建该虚拟化机制，面临着要保持控制权的同时获得高性能的挑战

Basic Technique: Limited Direct Execution

受限直接执行(limited direct execution)

有受限那当然就有直接运行协议:

sequenceDiagram
    participant OS
    participant Program

    OS->>OS: 创建 PCB
    OS->>OS: 地址空间初始化
    OS->>OS: 加载代码段/数据段
    OS->>OS: 初始化用户栈（argc/argv）
    OS->>OS: 设置 CPU 上下文（PC, SP）

    OS->>Program: 切换到用户态，跳转到 main

    Program->>Program: 运行 main()
    Program->>Program: 执行用户逻辑
    Program-->>OS: return（退出）

    OS->>OS: 回收资源（内存/PCB）

正在缓慢更新中qwq

# Visualization