HITOS_LAB5 进程运行轨迹的跟踪与统计

2023-12-05 22:28
文章标签 统计 运行 进程 轨迹 跟踪 lab5 hitos

本文主要是介绍HITOS_LAB5 进程运行轨迹的跟踪与统计，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

5. 进程运行轨迹的跟踪与统计

5.1. 实验目的

  • 掌握 Linux 下的多进程编程技术；
  • 通过对进程运行轨迹的跟踪来形象化进程的概念；
  • 在进程运行轨迹跟踪的基础上进行相应的数据统计，从而能对进程调度算法进行实际的量化评价， 更进一步加深对调度和调度算法的理解，获得能在实际操作系统上对调度算法进行实验数据对比的直接经验。

5.2. 实验内容

编写样本程序

process.c：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <sys/times.h>#define HZ	100void cpuio_bound(int last, int cpu_time, int io_time);int main(int argc, char * argv[])
{pid_t fd_1, fd_2;int fd;printf("The Parent Pid = [%d].\n", getpid());fd_1 = fork();if(fd_1 == 0){printf("[%d] Is Running Now.\n", getpid());cpuio_bound(10, 1, 0);exit(0);}fd_2 = fork();if(fd_2 == 0){printf("[%d] Is Running Now.\n", getpid());cpuio_bound(10, 1, 0);exit(0);}fd = wait(NULL);printf("[%d] Have Exited.\n",fd);fd = wait(NULL);printf("[%d] Have Exited.\n",fd);return 0;
}void cpuio_bound(int last, int cpu_time, int io_time)
{struct tms start_time, current_time;clock_t utime, stime;int sleep_time;while (last > 0){times(&start_time);do{times(&current_time);utime = current_time.tms_utime - start_time.tms_utime;stime = current_time.tms_stime - start_time.tms_stime;} while ( ( (utime + stime) / HZ )  < cpu_time );last -= cpu_time;if (last <= 0 )break;sleep_time=0;while (sleep_time < io_time){sleep(1);sleep_time++;}last -= sleep_time;}
}

跟踪进程运行轨迹

首先修改init文件夹下的main.c中的main()函数，应当在内核启动时就打开log文件。

在这里插入图片描述

打开log文件的参数指定为只写模式，如果文件已经存在，则清空其现有内容。文件权限设置为所有人可读可写。
在kernel/printk.c中添加fprintk函数。

#include <stdarg.h>
#include <stddef.h>
#include <linux/kernel.h>
#include "linux/sched.h"
#include "sys/stat.h"static char logbuf[1024];
static char buf[1024];
extern int vsprintf(char * buf, const char * fmt, va_list args);int printk(const char *fmt, ...)
{va_list args;int i;va_start(args, fmt);i=vsprintf(buf,fmt,args);va_end(args);__asm__("push %%fs\n\t""push %%ds\n\t""pop %%fs\n\t""pushl %0\n\t""pushl $buf\n\t""pushl $0\n\t""call tty_write\n\t""addl $8,%%esp\n\t""popl %0\n\t""pop %%fs"::"r" (i):"ax","cx","dx");return i;
}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){__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{if (!(file=task[0]->filp[fd]))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""addl $12,%%esp\n\t""popl %0\n\t""pop %%fs"::"r" (count),"r" (file),"r" (inode):"ax","cx","dx");}return count;
}

jiffies

jiffies在kernel/sched.c文件中定义为一个全局变量：

long volatile jiffies=0;

其记录了从系统开机到当前时间的时钟中断发生次数，也被称为“滴答数”。

在kernel/sched.c文件中的sched_init()函数中，时钟中断处理函数被设置为：

set_intr_gate(0x20,&timer_interrupt);

这表明jiffies表示了从系统开机时到目前为止的时钟中断次数，即“滴答数”。

此外，在sched_init()函数中，以下代码用于设置每次时钟中断的间隔，即LATCH：

outb_p(0x36, 0x43);
outb_p(LATCH&0xff, 0x40);
outb_p(LATCH>>8, 0x40);

三条语句的目的是配置8253定时芯片的工作模式，并设置时钟中断的触发频率。其中，LATCH是在kernel/sched.c文件中定义的一个宏：

kernel/sched.c

#define LATCH  (1193180/HZ)

include/linux/sched.h

#define HZ 100

寻找状态切换点

需要在所有发生进程状态切换的代码点添加适当的代码，以记录进程状态变化的情况并输出到log文件中。

总体而言，Linux 0.11支持四种主要的进程状态转移：从就绪到运行、从运行到就绪、从运行到睡眠以及从睡眠到就绪。此外，还存在新建和退出两种情况。其中，就绪到运行的状态转移通过schedule()函数实现（该函数同时涵盖调度算法）；运行到睡眠的转移则依赖于sleep_on()和interruptible_sleep_on()，以及进程主动休眠的系统调用如sys_pause()和sys_waitpid()；而从睡眠到就绪的转移则依赖于wake_up()。通过在这些函数的适当位置插入处理语句，可以实现对进程运行轨迹的全面跟踪。

在kernel/fork.c文件中的copy_process()函数中，修改如下，以在新建态N时输出新建进程信息到文件：

	p->start_time = jiffies;fprintk(3, "%ld\t%c\t%ld\n", p->pid, 'N', jiffies);

kernel/sched.c：

schedule()函数：

if (((*p)->signal & ~(_BLOCKABLE & (*p)->blocked)) &&(*p)->state==TASK_INTERRUPTIBLE){(*p)->state=TASK_RUNNING;fprintk(3, "%ld\t%c\t%ld\n", (*p)->pid, 'J', jiffies);	}

由于中断信号影响，由可中断的阻塞态W变为就绪态J

	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);

sys_pause()函数：

int sys_pause(void)
{if(current->state!=TASK_INTERRUPTIBLE )fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'W', jiffies);current->state = TASK_INTERRUPTIBLE;schedule();return 0;
}

sleep_on()函数：

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->state = TASK_UNINTERRUPTIBLE;fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'W', jiffies);		schedule();if (tmp)tmp->state=0;fprintk(3, "%ld\t%c\t%ld\n", tmp->pid, 'J', jiffies);		
}

interruptible_sleep_on()函数：

void interruptible_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;
repeat:	current->state = TASK_INTERRUPTIBLE;fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'W', jiffies);schedule();if (*p && *p != current) {(**p).state=0;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", tmp->pid, 'J', jiffies);
}

wake_up()函数：

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;}
}

修改kernel/exit.c：

do_exit()函数：

fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'E', jiffies);

sys_waitpid()函数：

fprintk(3, "%ld\t%c\t%ld\n", current->pid, 'W', jiffies);
schedule();

在Linux-0.11下

make all
sudo ./mount-hdc
sudo umount hdc
./run

在这里插入图片描述
日志文件process.log中

在这里插入图片描述

统计进程时间

chmod +x stat_log.py
./stat_log.py process.log 12 13 14 15 -g | more

在这里插入图片描述

修改linux-0.11进程调度的时间片

Linux 0.11所采用的调度算法是一种综合考虑进程优先级并具有动态反馈机制，能够调整时间片的轮转调度算法。该算法为每个进程分配一个称为时间片的时间段，即该进程被允许运行的时间。如果在时间片结束时进程仍在运行，CPU将会被剥夺，并分配给另一个进程；而如果进程在时间片结束前阻塞或结束，则CPU会立即进行切换。调度程序的主要任务是维护一个就绪进程列表，当进程用完它的时间片后，它将被移到队列的末尾。那么综合考虑进程优先级又是什么呢？这意味着一个进程在阻塞队列中停留的时间越长，其优先级就越高，因此下次将被分配更大的时间片。

进程之间的切换是需要时间的。如果时间片设定得太小，将导致频繁的进程切换，从而浪费大量时间在进程切换上，影响系统效率；相反，如果时间片设定得足够大，虽然不会浪费时间在进程切换上，但会降低系统的利用率，且可能对用户交互性产生不良影响。因此，时间片的大小需要在保持CPU利用率和用户交互性之间取得平衡。

为了调整每个进程的时间片，可以通过修改INIT_TASK宏中的counter来实现。在这里，counter代表进程的时间片。通过增加它，可以延长进程被分配CPU的时间。下图中，平均等待时间以及平均完成时间随着时间片的切片数增多而减少 。

在这里插入图片描述

5.3. 实验报告

  1. 结合自己的体会，谈谈从程序设计者的角度看，单进程编程和多进程编程最大的区别是什么？

在单进程编程中，程序是按照顺序执行的，一个任务完成后才会执行下一个任务。这种方式不涉及到多个任务之间的切换和数据保存，但是在等待I/O时，CPU可能处于空闲状态，导致CPU利用率相对较低。

相比之下，多进程编程允许多个进程交替执行。当一个进程等待I/O时，系统可以切换到另一个就绪的进程执行，从而提高了CPU的利用率。然而，多进程编程涉及到进程切换时的数据保存和复杂的调度机制，这可能导致一些额外的开销和复杂性。

执行方式

  • 单进程编程： 顺序执行，程序从上到下逐行执行。一个任务的执行完成后，才会执行下一个任务。
  • 多进程编程： 并发执行，多个进程可以同时运行。进程之间可以交替执行，提高系统的响应速度和资源利用率。

数据是否同步

  • 单进程编程： 数据是同步的，因为在单进程中修改数据会直接影响整个进程的状态。
  • 多进程编程： 数据是异步的，因为每个进程有自己的内存空间，进程之间的数据修改不会直接影响其他进程的数据。

CPU利用率

  • 单进程编程： CPU利用率相对较低。当进程在等待I/O操作时，CPU处于空闲状态。
  • 多进程编程： CPU利用率相对较高。当一个进程在等待I/O时，其他进程可以继续执行，充分利用了CPU资源。

适用场景

  • 单进程编程： 适用于简单的、线性的任务，不涉及多任务协同工作的场景。
  • 多进程编程： 适用于需要同时处理多个任务、有并发需求的场景，例如服务器程序、并行计算等。

2.你是如何修改时间片的？仅针对样本程序建立的进程，在修改时间片前后， log 文件的统计结果（不包括Graphic）都是什么样？结合你的修改分析一下为什么会这样变化，或者为什么没变化？

通过在sched.h文件中的INIT_TASK宏进行时间片的修改。观察到在样本程序建立的进程中，随着时间片的较大幅度修改，并没有引起log文件统计结果的显著变化。

  • 系统处理能力不变： 关键在于系统处理的进程数量并没有发生改变。即使时间片较大，系统在单位时间内仍能处理相同数量的进程。这导致了吞吐量在一定范围内没有明显的变化。

  • 平均等待时间和平均完成时间的变化： 在一定范围内，随着时间片的增大，平均等待时间和平均完成时间呈下降趋势。这是因为在较小的时间片情况下，CPU花费更多时间在调度切换上，导致平均等待时间增加。随着时间片的增大，这种等待时间减小。然而，当时间片足够大时，进程调度可能变得类似于先来先服务（FCFS），平均等待时间和平均完成时间趋于稳定。

  • 调度策略影响： 随着时间片的修改，RR轮转调度逐渐转变为FCFS先来先服务。这导致了吞吐量的相对稳定性，因为在单位时间内完成的进程数量受到系统处理能力的限制。

这篇关于HITOS_LAB5 进程运行轨迹的跟踪与统计的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/459381。

相关文章

SQL Server跟踪自动统计信息更新实战指南

SQL Server跟踪自动统计信息更新实战指南

《SQLServer跟踪自动统计信息更新实战指南》本文详解SQLServer自动统计信息更新的跟踪方法,推荐使用扩展事件实时捕获更新操作及详细信息,同时结合系统视图快速检查统计信息状态,重点强调修... 目录SQL Server 如何跟踪自动统计信息更新：深入解析与实战指南 核心跟踪方法1️⃣ 利用系统目录
阅读更多...
MySQL多实例管理如何在一台主机上运行多个mysql

MySQL多实例管理如何在一台主机上运行多个mysql

《MySQL多实例管理如何在一台主机上运行多个mysql》文章详解了在Linux主机上通过二进制方式安装MySQL多实例的步骤,涵盖端口配置、数据目录准备、初始化与启动流程,以及排错方法,适用于构建读... 目录一、什么是mysql多实例二、二进制方式安装MySQL1.获取二进制代码包2.安装基础依赖3.清
阅读更多...
在IntelliJ IDEA中高效运行与调试Spring Boot项目的实战步骤

在IntelliJ IDEA中高效运行与调试Spring Boot项目的实战步骤

《在IntelliJIDEA中高效运行与调试SpringBoot项目的实战步骤》本章详解SpringBoot项目导入IntelliJIDEA的流程,教授运行与调试技巧,包括断点设置与变量查看,奠定... 目录引言：为良驹配上好鞍一、为何选择IntelliJ IDEA？二、实战：导入并运行你的第一个项目步骤1
阅读更多...
一文解密Python进行监控进程的黑科技

一文解密Python进行监控进程的黑科技

《一文解密Python进行监控进程的黑科技》在计算机系统管理和应用性能优化中,监控进程的CPU、内存和IO使用率是非常重要的任务,下面我们就来讲讲如何Python写一个简单使用的监控进程的工具吧... 目录准备工作监控CPU使用率监控内存使用率监控IO使用率小工具代码整合在计算机系统管理和应用性能优化中，监
阅读更多...
Linux进程CPU绑定优化与实践过程

Linux进程CPU绑定优化与实践过程

《Linux进程CPU绑定优化与实践过程》Linux支持进程绑定至特定CPU核心,通过sched_setaffinity系统调用和taskset工具实现,优化缓存效率与上下文切换,提升多核计算性能,适... 目录1. 多核处理器及并行计算概念1.1 多核处理器架构概述1.2 并行计算的含义及重要性1.3 并
阅读更多...
Linux下进程的CPU配置与线程绑定过程

Linux下进程的CPU配置与线程绑定过程

《Linux下进程的CPU配置与线程绑定过程》本文介绍Linux系统中基于进程和线程的CPU配置方法,通过taskset命令和pthread库调整亲和力,将进程/线程绑定到特定CPU核心以优化资源分配... 目录1 基于进程的CPU配置1.1 对CPU亲和力的配置1.2 绑定进程到指定CPU核上运行2 基于
阅读更多...
Javaee多线程之进程和线程之间的区别和联系(最新整理)

Javaee多线程之进程和线程之间的区别和联系(最新整理)

《Javaee多线程之进程和线程之间的区别和联系(最新整理)》进程是资源分配单位,线程是调度执行单位,共享资源更高效,创建线程五种方式:继承Thread、Runnable接口、匿名类、lambda,r... 目录进程和线程进程线程进程和线程的区别创建线程的五种写法继承Thread,重写run实现Runnab
阅读更多...
怎样通过分析GC日志来定位Java进程的内存问题

怎样通过分析GC日志来定位Java进程的内存问题

《怎样通过分析GC日志来定位Java进程的内存问题》：本文主要介绍怎样通过分析GC日志来定位Java进程的内存问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、GC 日志基础配置1. 启用详细 GC 日志2. 不同收集器的日志格式二、关键指标与分析维度1.
阅读更多...
Java进程异常故障定位及排查过程

Java进程异常故障定位及排查过程

《Java进程异常故障定位及排查过程》：本文主要介绍Java进程异常故障定位及排查过程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、故障发现与初步判断1. 监控系统告警2. 日志初步分析二、核心排查工具与步骤1. 进程状态检查2. CPU 飙升问题3. 内存
阅读更多...
在Linux终端中统计非二进制文件行数的实现方法

在Linux终端中统计非二进制文件行数的实现方法

《在Linux终端中统计非二进制文件行数的实现方法》在Linux系统中,有时需要统计非二进制文件（如CSV、TXT文件）的行数,而不希望手动打开文件进行查看,例如,在处理大型日志文件、数据文件时,了解... 目录在linux终端中统计非二进制文件的行数技术背景实现步骤1. 使用wc命令2. 使用grep命令
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2