实验4 进程运行轨迹跟踪与统计
pid X time
其中：- pid是进程的ID
- X可以是N，J，R，W和E中的任意一个
- N 进程新建 ,new
- J 进入就绪态 , J
- R 进入运行态 , run
- W 进入阻塞态, wait
- E 退出 ,exit
- time表示X发生的时间。这个时间不是物理时间，而是系统的滴答时间(tick)
仔细阅读sched.c文件
本实验主要分析整个的调度流程，主要方法是，当发生状态转换时，进程的state变化时，我们把这个记录记下来。
打印函数
先看看打印函数：
static char logbuf[1024];
int fprintk(int fd, const char *fmt, ...)
{
va_list args;
int count;
struct file *file;
struct m_inode *inode;
va_start(args, fmt);
count = vsprintf(logbuf, fmt, args);
va_end(args);
if (fd < 3) /* 如果输出到stdout或stderr，直接调用sys_write即可 */
{
__asm__("push %%fs\n\t"
"push %%ds\n\t"
"pop %%fs\n\t"
"pushl %0\n\t"
"pushl $logbuf\n\t"
"pushl %1\n\t"
"call sys_write\n\t"
"addl $8, %%esp\n\t"
"popl %0\n\t"
"pop %%fs"
::"r" (count), "r" (fd)
:"ax", "cx", "dx");
}
else /* 假定>=3的描述符都与文件关联。事实上，还存在很多其他情况，这里并没有考虑 */
{
if (!(file=task[0]->filp[fd])) /* 从进程0的文件描述符表中得到文件句柄 */
return 0;
inode = file->f_inode;
__asm__("push %%fs\n\t"
"push %%ds\n\t"
"pop %%fs\n\t"
"pushl %0\n\t"
"pushl $logbuf\n\t"
"pushl %1\n\t"
"pushl %2\n\t"
"call file_write\n\t" //使用file_write,往文件/var/process.log中写入。
"addl $12, %%esp\n\t"
"popl %0\n\t"
"pop %%fs"
::"r" (count), "r" (file), "r" (inode)
:"ax", "cx", "dx");
}
return count;
}
linux源码中，只有这几种状态：
#define TASK_RUNNING 0 //正在运行或者已就绪
#define TASK_INTERRUPTIBLE 1 //进程处于可中断等待状态
#define TASK_UNINTERRUPTIBLE 2 //程序处于不可中断等待状态，主要用于I/O操作等待。
#define TASK_ZOMBIE 3 //程序处于僵死状态，已经停止运行，但父进程还没发信号。
#define TASK_STOPPED 4 //程序已停止。
N 进程新建 ,new
新进程在fork的时候产生，fork的关键是copy_process
int copy_process(int nr,long ebp,long edi,long esi,long gs,long none,
long ebx,long ecx,long edx,
long fs,long es,long ds,
long eip,long cs,long eflags,long esp,long ss)
{
...
p->start_time = jiffies;
fprintk(3, "%ld\t%c\t%ld\n", last_pid, 'N', jiffies); //新建
...
p->state = TASK_RUNNING; /* do this last, just in case */
fprintk(3, "%ld\t%c\t%ld\n", last_pid, 'J', jiffies); //完成后，立马进入就绪态。
return last_pid;
}
W 进入阻塞态, wait
//系统调用waitpid(),挂起当前进程，直到pid指定的子进程退出。
int sys_waitpid(pid_t pid,unsigned long * stat_addr, int options)
{
...
if (flag) {
if (options & WNOHANG)
return 0;
current->state=TASK_INTERRUPTIBLE;
fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'W', jiffies);//系统调用，等待。
schedule();
if (!(current->signal &= ~(1<<(SIGCHLD-1))))
goto repeat;
else
return -EINTR;
}
return -ECHILD;
}
E 退出 ,exit
int do_exit(long code)
{
...
current->state = TASK_ZOMBIE;
fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'E', jiffies);
/* print message end in 3-processTack */
current->exit_code = code;
tell_father(current->father);
schedule();
return (-1); /* just to suppress warnings */
}
就绪与运行
void schedule(void)
void schedule(void)
{
int i,next,c;
struct task_struct ** p;
/* check alarm, wake up any interruptible tasks that have got a signal */
for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
if (*p) {
if ((*p)->alarm && (*p)->alarm < jiffies) {
(*p)->signal |= (1<<(SIGALRM-1));//到点，给信号alarm
(*p)->alarm = 0;
}
if (((*p)->signal & ~(_BLOCKABLE & (*p)->blocked)) && //除去被block掉的信号，还有其他信号，
(*p)->state==TASK_INTERRUPTIBLE) //且进程是可中断的
{
(*p)->state=TASK_RUNNING;
fprintk(3, "%ld\t%c\t%ld\n", (*p)->pid, 'J', jiffies);//进程进入就绪。
}
}
/* this is the scheduler proper: */
while (1) {
c = -1;
next = 0;
i = NR_TASKS;
p = &task[NR_TASKS];
while (--i) {
if (!*--p)
continue;
if ((*p)->state == TASK_RUNNING && (*p)->counter > c)
c = (*p)->counter, next = i;//检查所有任务中，最需要被调度的进程，将这个号码放入next，这个就是下次要调度的进程。
}
if (c) break; /* 找到一个counter不等于0 且是TASK_RUNNING状态中的counter最大的进程；或者当前系统没有一个可以运行的进程，此时c=-1, next=0，进程0得到调度，所以调度算法是不在意进程0的状态是不是TASK_RUNNING，这就意味这进程0可以直接从睡眠切换到运行！ */
for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
if (*p)
(*p)->counter = ((*p)->counter >> 1) +
(*p)->priority;
}
if (task[next]->pid != current->pid) {
//打印就绪，运行，就切到那个进程。
if (current->state == TASK_RUNNING) {
fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'J', jiffies);
}
fprintk(3, "%ld\t%c\t%ld\n", task[next]->pid, 'R', jiffies);
}
switch_to(next);
}
int sys_pause(void)
/*
* 系统无事可做的时候，进程0会不停地调用sys_pause()，以激活调度算法。此时它的状态可以是等待态，
* 等待有其他可运行的进程；也可以是运行态，因为它是唯一一个在CPU上运行的进程，只不过运行的效果是等待。
*/
int sys_pause(void)
{
current->state = TASK_INTERRUPTIBLE;
if (current->pid != 0) //进程0死循环，一直调用这个函数。防止一直打印。
{
fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'W', jiffies);
}
schedule();
return 0;
}
void sleep_on(struct task_struct **p)
void sleep_on(struct task_struct **p)
{
struct task_struct *tmp;
if (!p)
return;
if (current == &(init_task.task))
panic("task[0] trying to sleep");
tmp = *p;
*p = current; /* 仔细阅读，实际上是将current插入“等待队列”头部，tmp是原来的头部 */
current->state = TASK_UNINTERRUPTIBLE;
fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'W', jiffies);
schedule();
if (tmp) {
fprintk(3, "%ld\t%c\t%ld\n", tmp->pid, 'J', jiffies);
/* print message end in 3-processTack */
tmp->state=TASK_RUNNING; /* 唤醒队列中的上一个(tmp)睡眠进程。0换作TASK_RUNNING更好。在记录进程被唤醒时一定要考虑到这种情况，实验者一定要注意！！！ */
}
}
void interruptible_sleep_on(struct task_struct **p)
/*
* TASK_UNINTERRUPTIBLE和TASK_INTERRUPTIBLE的区别在于不可中断的睡眠只能由wake_up()显示唤醒，
* 再由上面的 schedule()语句后面的
*
* if (tmp) tmp->state=0;
*
* 依次唤醒，所以不可中断的睡眠一定是严格按照从“队列”(一个依靠放在进程内核栈中的指针变量tmp
* 维护的队列)的首部进行唤醒。而对于可中断的进程，除了用wake_up唤醒以外，也可以用信号(给进程
* 发送一个信号，实际上就是将进程PCB中维护的一个向量的某一位置位，进程需要在合适的时候处理
* 这一位。感兴趣的实验者可以阅读有关代码)来唤醒，如在 schedule()中：
*
* for(p = &LAST_TASK; p > &FRIST_TASK; --p)
* if (((*p)->signal & ~(_BLOCKABLE & (*p)->blocked)) &&
* (*p)->state==TASK_INTERRUPTIBLE)
* (*p)->state=TASK_RUNNING;//唤醒
*
* 就是当进程是可中断睡眠时，如果遇到一些信号就将其唤醒。这样的唤醒会出现一个问题，那就是可能会
* 唤醒等待队列中间的某个进程，此时这个链就需要进行适当调整。interruptible_sleep_on和sleep_on
* 函数的主要区别就在这里。
*/
void interruptible_sleep_on(struct task_struct **p) //将当前任务置为可中断的等待状态，并放入*p指定的等待队列中。
{
struct task_struct *tmp;
if (!p)
return;
if (current == &(init_task.task))
panic("task[0] trying to sleep");
tmp=*p;
*p=current;
repeat: current->state = TASK_INTERRUPTIBLE; //等待的任务可中断。
schedule();//只有当进程被唤醒才会回到这里。
if (*p && *p != current) {
//此current不等于当时的current，说明队列中间有任务被唤醒了。
(**p).state=TASK_RUNNING;//将队头唤醒。
fprintk(3, "%ld\t%c\t%ld\n", (*p)->pid, 'J', jiffies);
goto repeat;//重新调度。
}
*p=NULL;
if (tmp)//从队头开始，逐个释放。
tmp->state=0;
fprintk(3, "%ld\t%c\t%ld\n", (*p)->pid, 'J', jiffies);
}
void wake_up(struct task_struct **p)
void wake_up(struct task_struct **p)
{
if (p && *p) {
(**p).state=0;
fprintk(3, "%ld\t%c\t%ld\n", (*p)->pid, 'J', jiffies);
*p=NULL;
}
}
进程运行log分析
1 N 48 copy_process //进程1新建(init())。此前是进程0建立和运行,我们是在move_to_user_mode后才新建/var/process.log文件进行进程运行轨迹记录的,所以进程0的新建和运行没有出现在log文件里
1 J 48 copy_process //新建后进入就绪队列
0 J 48 schedule /* --- 进程0从运行->就绪,让出CPU。(执行的是pause,调用)
1 R 48 schedule 进程1运行 --- */
2 N 49 copy_process /* --- 进程1建立进程2。
2 J 49 copy_process 进程2会运行/etc/rc脚本,然后退出 --- */
1 W 49 sys_waitpid //进程1开始等待(等待进程2退出)
2 R 49 schedule //进程2运行
3 N 64 copy_process /* --- 进程2建立进程3
3 J 64 copy_process 进程3是/bin/sh建立的运行脚本的子进程 --- */
2 E 68 do_exit //进程2不等进程3退出,就先走一步了
1 J 68 schedule /* --- 进程1此前在等待进程2退出,被阻塞。进程2退出后,重新进入就绪队列
1 R 68 schedule 进程1运行 --- */
4 N 69 copy_process /* --- 进程1建立进程4,即shell
4 J 69 copy_process 进程4进入就绪队列 --- */
1 W 69 sys_waitpid //进程1等待shell退出(除非执行exit命令,否则shell不会退出)
3 R 69 schedule //进程3开始运行
3 W 75 sys_pause //进程3主动睡觉,让出CPU
4 R 75 schedule //进程4开始运行
5 N 107 copy_process /* --- 进程5是shell建立的不知道做什么的进程(可能是ls命令?)
5 J 107 copy_process 进程5新建后进入就绪队列 --- */
4 W 108 sleep_on //进程4进入不可中断睡眠状态
5 R 108 schedule //进程5开始运行
4 J 110 wake_up //进程5唤醒睡觉的进程4,进程4进入就绪队列
5 E 110 do_exit //进程5很快退出
4 R 110 schedule //进程4执行
4 W 115 interruptible_sleep_on //shell等待用户输入命令
0 R 115 schedule //因为无事可做,所以进程0重出江湖
4 J 902 wake_up //用户开始输入命令了,唤醒了shell(从等待用户输入到用户开始输入命令总共经历了将近8s)
4 R 902 schedule //进程4执行
4 W 903 interruptible_sleep_on //shell等待用户输入命令
0 R 903 schedule //因为无事可做,进程0再次执行
4 J 953 wake_up //用户接着输入命令,唤醒shell(shell等待了0.5s)
4 R 953 schedule //进程4执行
4 W 953 interruptible_sleep_on //shell等待用户输入命令
0 R 953 schedule //因为无事可做,进程0再次执行
4 J 1003 wake_up //用户接着输入命令,唤醒shell(shell等待了0.5s)
4 R 1003 schedule //shell执行
4 W 1003 interruptible_sleep_on //shell等待用户输入
0 R 1003 schedule //因为无事可做,进程0再次执行
4 J 1056 wake_up //用户接着输入命令,唤醒shell(shell等待了0.53s)
4 R 1056 schedule //shell执行
4 W 1056 interruptible_sleep_on //shell等待用户输入
0 R 1056 schedule //因为无事可做,进程0再次执行
4 J 1182 wake_up //用户接着输入命令,唤醒shell(shell等待了1.26s),该命令输入完毕(用户输入该命令总共经历了将近1.8s)
4 R 1182 schedule //shell执行
6 N 1184 copy_process /* --- 进程6是shell建立的不知道做什么的进程
6 J 1185 copy_process 进程6进入就绪队列 --- */
4 W 1185 sys_waitpid //shell开始等待(等待进程6退出)
6 R 1185 schedule //进程6开始执行
6 E 1191 do_exit //进程6很快退出
4 J 1191 schedule //shell此前在等待进程6退出,被阻塞。进程6退出后,重新进入就绪队列
4 R 1191 schedule //shell执行
7 N 1192 copy_process /* --- 进程7是shell建立的不知道做什么的进程
7 J 1192 copy_process 进程7进入就绪队列 --- */
4 J 1193 schedule /* --- shell从运行->就绪,让出CPU。
7 R 1193 schedule 进程7开始运行 --- */
7 E 1195 do_exit //进程7很快退出
4 R 1195 schedule //shell执行
4 W 1196 interruptible_sleep_on //shell等待用户输入命令
0 R 1196 schedule //因为无事可做,进程0再次执行
4 J 1251 wake_up //用户开始输入命令,唤醒了shell(从等待用户输入命令到用户开始输入命令,总共经历了0.55s)
4 R 1251 schedule //shell执行
4 W 1251 interruptible_sleep_on //shell等待用户继续输入命令
0 R 1252 schedule //因为无事可做,进程0再次执行
4 J 2345 wake_up //用户接着输入命令,唤醒shell(shell等待了0.93s)
4 R 2345 schedule //shell执行
4 W 2345 interruptible_sleep_on //shell等待用户输入
0 R 2345 schedule //因为无事可做,进程0再次执行
4 J 2386 wake_up //用户接着输入命令,唤醒shell(shell等待了0.41s)
4 R 2386 schedule //shell执行
4 W 2386 interruptible_sleep_on //shell等待用户输入
0 R 2386 schedule //因为无事可做,进程0再次执行
4 J 2823 wake_up //用户接着输入命令,唤醒shell(shell等待了4.37s)
4 R 2823 schedule //shell执行
4 W 2823 interruptible_sleep_on //shell等待用户输入
0 R 2823 schedule //因为无事可做,进程0再次执行
4 J 2864 wake_up //用户接着输入命令,唤醒shell(shell等待了0.41s)
4 R 2864 schedule //shell执行
4 W 2864 interruptible_sleep_on //shell等待用户输入
0 R 2864 schedule //因为无事可做,进程0再次执行
4 J 2898 wake_up //用户接着输入命令,唤醒shell(shell等待了0.34s)
4 R 2898 schedule //shell执行
4 W 2898 interruptible_sleep_on //shell等待用户继续输入
0 R 2898 schedule //因为无事可做,进程0再次执行
4 J 2936 wake_up //用户接着输入命令,唤醒shell(shell等待了0.38s)
4 R 2936 schedule //shell执行
4 W 2936 interruptible_sleep_on //shell等待用户输入
0 R 2936 schedule //因为无事可做,进程0再次执行
4 J 3046 wake_up //用户接着输入命令,唤醒shell(shell等待了1.1s)
4 R 3046 schedule //shell执行
4 W 3046 interruptible_sleep_on //shell等待用户输入
0 R 3046 schedule //因为无事可做,进程0再次执行
3 J 3074 schedule /* --- 进程3从睡眠->就绪。
3 R 3074 schedule 进程3运行(进程3由于长时间睡觉,其优先级变高,进入就绪队列后立即得到调度执行) --- */
3 W 3074 sys_pause //进程3主动睡觉,让出CPU
0 R 3074 schedule //因为无事可做,进程0再次执行
4 J 3099 wake_up //用户接着输入命令,唤醒shell(shell等待了0.53s)
4 R 3100 schedule //shell执行
4 W 3100 interruptible_sleep_on //shell等待用户输入
0 R 3100 schedule //因为无事可做,进程0再次执行
4 J 3416 wake_up //用户接着输入命令,唤醒shell(shell等待了3.16s)
4 R 3417 schedule //shell执行
4 W 3417 interruptible_sleep_on //shell等待用户输入
0 R 3417 schedule //因为无事可做,进程0再次执行
4 J 3457 wake_up //用户接着输入命令,唤醒shell(shell等待了0.4s)
4 R 3457 schedule //shell执行
4 W 3457 interruptible_sleep_on //shell等待用户输入
0 R 3457 schedule //因为无事可做,进程0再次执行
4 J 3623 wake_up //用户接着输入命令,唤醒shell(shell等待了1.66s)
4 R 3623 schedule //shell执行
4 W 3623 interruptible_sleep_on //shell等待用户输入
0 R 3623 schedule //因为无事可做,进程0再次执行
4 J 3687 wake_up //用户接着输入命令,唤醒shell(shell等待了0.64s)
4 R 3687 schedule //shell执行
4 W 3687 interruptible_sleep_on //shell等待用户输入
0 R 3687 schedule
....
0 R 7494 schedule //因为无事可做,进程0再次运行
4 J 7560 wake_up //用户继续输入命令,唤醒shell(shell等待了0.66s)
4 R 7560 schedule //shell执行
4 W 7560 interruptible_sleep_on //shell等待用户输入
0 R 7561 schedule //因为无事可做,进程0再次执行
4 J 7617 wake_up //用户继续输入命令,唤醒shell(shell等待了0.56s)
4 R 7617 schedule //shell执行
4 W 7617 interruptible_sleep_on //shell等待用户输入
0 R 7617 schedule //因为无事可做,进程0再次执行
4 J 8090 wake_up //用户继续输入命令,唤醒shell(shell等待了3.73s),该命令输入完毕(用户输入该命令总共经历了67.39s,一分钟的时间,用户输入不可能这么长！那么这个命令是什么?全部是由用户输入?)
4 R 8090 schedule //shell执行该命令
8 N 8092 copy_process /* --- shell新建进程8(估计是gcc编译process.c生成可执行文件process的命令)。
8 J 8093 copy_process 进程8新建后进入就绪队列 --- */
4 W 8093 sys_waitpid //shell开始等待进程8退出
8 R 8093 schedule //进程8开始运行
9 N 8098 copy_process /* --- 进程8新建进程9(估计是gcc用于编译process.c的预处理子进程?)。
9 J 8098 copy_process 进程9新建后进入就绪队列 --- */
8 W 8099 sys_waitpid //进程8开始等待进程9退出
9 R 8099 schedule //进程9开始运行
9 E 8159 do_exit //进程9退出(运行了0.6s)
8 J 8159 schedule /* --- 进程8此前在等待进程9退出,被阻塞。进程9退出后,重新进入就绪队列。
8 R 8159 schedule 进程8运行 --- */
10 N 8160 copy_process /* --- 进程8新建进程10(估计是gcc用于编译process.c的编译子进程,生成汇编代码?)。
10 J 8161 copy_process 进程10新建后进入就绪队列 --- */
8 W 8161 sys_waitpid //进程8开始等待进程10退出
10 R 8161 schedule //进程10开始运行
10 E 8295 do_exit //进程10退出(运行了1.34s)
8 J 8295 schedule /* --- 进程8此前在等待进程10退出,被阻塞。进程10退出后,重新进入就绪队列。
8 R 8295 schedule 进程8继续运行 --- */
11 N 8295 copy_process /* --- 进程8新建进程11(估计是gcc用于编译process.c的汇编子进程,生成二进制目标文件?)。
11 J 8296 copy_process 进程11新建后进入就绪队列 --- */
8 W 8296 sys_waitpid //进程8开始等待进程11退出
11 R 8296 schedule //进程11开始运行
11 E 8341 do_exit //进程11退出(运行了0.45s)
8 J 8341 schedule /* --- 进程8此前在等待进程11退出,被阻塞。进程11退出后,重新进入就绪队列。
8 R 8341 schedule 进程8继续运行 --- */
12 N 8343 copy_process /* --- 进程8新建进程12(估计是gcc用于编译process.c的链接子进程,生成可执行文件process?)。
12 J 8344 copy_process 进程12新建后进入就绪队列 --- */
8 W 8344 sys_waitpid //进程8开始等待进程12退出
12 R 8344 schedule //进程12开始运行
12 E 8425 do_exit //进程12退出(运行了0.81s)
8 J 8425 schedule /* --- 进程8此前在等待进程12退出,被阻塞。进程12退出后,重新进入就绪队列。
8 R 8425 schedule 进程8继续运行 --- */
8 E 8427 do_exit //进程8退出(gcc编译process.c生成process可执行文件经历了3.34s)
4 J 8427 schedule /* --- shell此前在等待进程8退出,被阻塞。进程8退出后,重新进入就绪队列
4 R 8427 schedule shell运行 --- */
13 N 8427 copy_process /* --- shell新建进程13(不知道是做什么的进程)。
13 J 8428 copy_process 进程13新建后进入就绪队列 --- */
4 W 8428 sleep_on //进程4进入不可中断睡眠状态
13 R 8428 schedule //进程13开始运行
4 J 8430 wake_up //进程13唤醒睡觉的进程4,进程4进入就绪队列
13 E 8431 do_exit //进程13很快退出(运行了0.03s)
4 R 8431 schedule //shell运行
4 W 8432 interruptible_sleep_on //shell等待用户输入命令
0 R 8432 schedule //因为无事可做,进程0再次执行
4 J 9737 wake_up //用户开始输入命令,唤醒了shell(从等待用户输入命令到用户开始输入命令,总共经历了13s！为什么会这么长时间?)
4 R 9737 schedule //shell运行
4 W 9737 interruptible_sleep_on //shell等待用户输入命令
0 R 9737 schedule //因为无事可做,进程0再次执行
4 J 9790 wake_up //用户接着输入命令,唤醒了shell(shell等待了0.53s)
4 R 9790 schedule //shell运行
4 W 9790 interruptible_sleep_on //shell等待用户输入命令
......
0 R 11136 schedule //因为无事可做,进程0再次执行
4 J 11195 wake_up //用户接着输入命令,唤醒了shell(shell等待了0.59s)
4 R 11195 schedule //shell运行
4 W 11195 interruptible_sleep_on //shell等待用户输入命令
0 R 11196 schedule //因为无事可做,进程0再次执行
4 J 12048 wake_up //用户接着输入命令,唤醒了shell(shell等待了8.52s),该命令输入完毕(用户输入该命令总共经历了231s！输入不可能需要这么长时间！说明计时单位并不是10ms???)
4 R 12048 schedule //shell执行该命令(即我们自己编写的样本程序process可执行文件)
14 N 12049 copy_process /* --- shell新建进程14(即process.c的main()函数)。
14 J 12049 copy_process 进程14新建后进入就绪队列 --- */
4 W 12049 sys_waitpid //shell开始等待进程14(process.c的main()函数)退出
14 R 12050 schedule //进程14(process.c的main()函数)开始运行
15 N 12051 copy_process /* --- main()函数新建进程15(N1 node)。
15 J 12051 copy_process 进程15(N1 node)新建后进入就绪队列 --- */
16 N 12052 copy_process /* --- main()函数新建进程16(N2 node)。
16 J 12052 copy_process 进程16(N2 node)新建后进入就绪队列 --- */
14 W 12053 sys_waitpid //进程14(现在为process.c的main()函数中的Root)开始等待进程15(N1 node)和进程16(N2 node)退出
16 R 12053 schedule //进程16(N2 node)开始运行
17 N 12053 copy_process /* --- 进程16新建进程17(N5 node)。
17 J 12053 copy_process 进程17(N5 node)新建后进入就绪队列 --- */
16 W 12054 sys_pause //进程16(N2 node)主动睡觉
17 R 12054 schedule //进程17(N5 node)开始运行
17 J 12069 schedule /* --- 进程17(n5 node)时间片(15个滴答)耗完,从运行->就绪(运行了0.15s),让出CPU。
15 R 12069 schedule 进程15(N1 node)开始运行 --- */
18 N 12069 copy_process /* --- 进程15(N1 node)新建进程18(N3 node)。
18 J 12069 copy_process 进程18(N3 node)新建后进入就绪队列 --- */
19 N 12070 copy_process /* --- 进程15(N1 node)新建进程19(N4 node)。
19 J 12070 copy_process 进程19(N4 node)新建后进入就绪队列 --- */
15 J 12084 schedule /* --- 进程15(N1 node)时间片耗完,从运行->就绪(运行了0.15s),让出CPU。
19 R 12084 schedule 进程19(N4 node)开始运行 --- */
19 J 12099 schedule /* --- 进程19(N4 node)时间片耗完,从运行->就绪(运行了0.15s),让出CPU。
18 R 12099 schedule 进程18(N3 node)开始运行 --- */
18 J 12114 schedule /* --- 进程18(N3 node)时间片耗完,从运行->就绪(运行了0.15s),让出CPU。
19 R 12114 schedule 进程19(N4 node)运行 --- */
19 J 12129 schedule /* --- 进程19(N4 node)时间片耗完,从运行->就绪(运行了0.15s),让出CPU。
18 R 12129 schedule 进程18(N3 node)开始运行 --- */
18 J 12144 schedule /* --- 进程18(N3 node)时间片耗完,从运行->就绪(运行了0.15s),让出CPU。
17 R 12144 schedule 进程17(N5 node)运行 --- */
16 J 12159 schedule /* --- 进程16(N2 node)被唤醒。
17 J 12159 schedule 进程17(N5 node)时间片耗完,从运行->就绪(运行了0.15s),让出CPU。
16 R 12159 schedule 进程16(N2 node)运行 --- */