山东大学操作系统实验七实验报告

操作系统实验实验报告一、实验目的操作系统是计算机系统中最为关键的核心软件，它管理着计算机的硬件资源和软件资源，为用户提供了一个方便、高效、稳定的工作环境。

本次操作系统实验的目的在于通过实际操作和实践，深入理解操作系统的基本原理和核心概念，掌握操作系统的基本功能和操作方法，提高对操作系统的认识和应用能力。

二、实验环境本次实验使用的操作系统为 Windows 10 专业版，开发工具为Visual Studio 2019，编程语言为 C 和 C+＋。

实验硬件环境为一台配备Intel Core i7 处理器、16GB 内存、512GB SSD 硬盘的个人计算机。

三、实验内容（一）进程管理实验1、进程创建与终止通过编程实现创建新的进程，并在完成任务后终止进程。

在实验中，我们使用了 Windows API 函数 CreateProcess 和 TerminateProcess 来完成进程的创建和终止操作。

通过观察进程的创建和终止过程，深入理解了进程的生命周期和状态转换。

2、进程同步与互斥为了实现进程之间的同步与互斥，我们使用了信号量、互斥量等同步对象。

通过编写多线程程序，模拟了多个进程对共享资源的访问，实现了对共享资源的互斥访问和同步操作。

在实验中，我们深刻体会到了进程同步与互斥的重要性，以及不正确的同步操作可能导致的死锁等问题。

（二）内存管理实验1、内存分配与释放使用 Windows API 函数 VirtualAlloc 和 VirtualFree 进行内存的分配和释放操作。

通过实验，了解了内存分配的不同方式（如堆分配、栈分配等）以及内存释放的时机和方法，掌握了内存管理的基本原理和操作技巧。

2、内存分页与分段通过编程模拟内存的分页和分段管理机制，了解了内存分页和分段的基本原理和实现方法。

在实验中，我们实现了简单的内存分页和分段算法，对内存的地址转换和页面置换等过程有了更深入的理解。

（三）文件系统实验1、文件操作使用 Windows API 函数 CreateFile、ReadFile、WriteFile 等进行文件的创建、读取和写入操作。

《操作系统》实验报告一、实验目的操作系统是计算机系统中最为关键的组成部分之一，本次实验的主要目的是深入理解操作系统的基本原理和功能，通过实际操作和观察，熟悉操作系统的核心概念，包括进程管理、内存管理、文件系统和设备管理等，提高对操作系统的实际应用能力和问题解决能力。

二、实验环境本次实验在以下环境中进行：操作系统：Windows 10开发工具：Visual Studio 2019编程语言：C+＋三、实验内容1、进程管理实验进程是操作系统中最基本的执行单元。

在这个实验中，我们使用C+＋编写程序来创建和管理进程。

通过观察进程的创建、执行和结束过程，理解进程的状态转换和资源分配。

首先，我们编写了一个简单的程序，创建了多个子进程，并通过进程标识符（PID）来跟踪它们的运行状态。

然后，使用等待函数来等待子进程的结束，并获取其返回值。

在实验过程中，我们发现进程的创建和销毁需要消耗一定的系统资源，而且进程之间的同步和通信需要谨慎处理，以避免出现死锁和竞争条件等问题。

2、内存管理实验内存管理是操作系统的核心功能之一，它直接影响系统的性能和稳定性。

在这个实验中，我们研究了动态内存分配和释放的机制。

使用 C+＋中的 new 和 delete 操作符来分配和释放内存。

通过观察内存使用情况和内存泄漏检测工具，了解了内存分配的效率和可能出现的内存泄漏问题。

同时，我们还探讨了内存分页和分段的概念，以及虚拟内存的工作原理。

通过模拟内存访问过程，理解了页表的作用和地址转换的过程。

3、文件系统实验文件系统是操作系统用于管理文件和目录的机制。

在这个实验中，我们对文件的创建、读写和删除进行了操作。

使用 C+＋的文件流操作来实现对文件的读写。

通过创建不同类型的文件（文本文件和二进制文件），并对其进行读写操作，熟悉了文件的打开模式和读写方式。

此外，还研究了文件的权限设置和目录的管理，了解了如何保护文件的安全性和组织文件的结构。

4、设备管理实验设备管理是操作系统与外部设备进行交互的桥梁。

操作系统实验报告操作系统实验报告引言：操作系统是计算机系统中最重要的软件之一，它负责管理计算机硬件资源，并提供程序运行环境。

操作系统的设计和实现是计算机科学领域的重要研究方向之一。

本篇实验报告将介绍我们在操作系统实验中所进行的实践和实验结果。

一、实验目的我们的实验目的是通过实践操作系统的基本功能，深入理解操作系统的原理和实现方式。

具体来说，我们的实验目标包括：1. 学习并掌握操作系统的基本概念和原理；2. 理解操作系统与硬件之间的交互过程；3. 实践操作系统的进程管理、内存管理和文件系统等功能；4. 分析操作系统的性能和优化策略。

二、实验环境我们使用了一台配置较高的计算机作为实验环境，该计算机配备了一块主频为2.5GHz的多核处理器、8GB内存和500GB硬盘。

我们选择了一款常见的操作系统作为实验平台，以便于进行实验和调试。

三、实验过程1. 进程管理在进程管理实验中，我们实现了进程的创建、调度和终止等功能。

首先，我们编写了一个简单的程序，用于创建多个进程并进行调度。

然后，我们通过观察进程的执行顺序和时间片分配情况，分析操作系统的调度算法对系统性能的影响。

2. 内存管理在内存管理实验中，我们实现了内存的分配和回收等功能。

我们编写了一个模拟程序，用于模拟内存的分配和释放过程。

通过观察内存分配的效率和内存碎片的情况，我们评估了不同的内存管理算法的性能。

3. 文件系统在文件系统实验中，我们实现了文件的创建、读写和删除等功能。

我们编写了一个简单的文件操作程序，用于测试文件系统的性能和可靠性。

通过观察文件系统的读写速度和文件恢复的效果，我们评估了不同的文件系统实现方式的优劣。

四、实验结果通过实验，我们获得了以下结果：1. 进程管理实验中，我们发现不同的调度算法对系统性能的影响差异较大。

短作业优先算法在短时间内能够提高系统的响应速度，而时间片轮转算法则能够保证公平性。

2. 内存管理实验中，我们发现不同的内存管理算法对内存利用率和碎片情况有很大的影响。

《操作系统》课内实验报告一、实验目的本次《操作系统》课内实验的主要目的是通过实际操作和观察，深入理解操作系统的基本原理和功能，掌握常见操作系统命令的使用，提高对操作系统的实际应用能力和问题解决能力。

二、实验环境本次实验在计算机实验室进行，使用的操作系统为 Windows 10 和Linux（Ubuntu 发行版）。

实验所使用的计算机配置为：Intel Core i5 处理器，8GB 内存，500GB 硬盘。

三、实验内容1、进程管理在 Windows 系统中，通过任务管理器观察进程的状态、优先级、CPU 使用率等信息，并进行进程的结束和优先级调整操作。

在 Linux 系统中，使用命令行工具（如 ps、kill 等）实现相同的功能。

2、内存管理使用 Windows 系统的性能监视器和资源监视器，查看内存的使用情况，包括物理内存、虚拟内存的占用和分配情况。

在 Linux 系统中，通过命令（如 free、vmstat 等）获取类似的内存信息，并分析内存的使用效率。

3、文件系统管理在 Windows 系统中，对文件和文件夹进行创建、复制、移动、删除等操作，了解文件的属性设置和权限管理。

在 Linux 系统中，使用命令（如 mkdir、cp、mv、rm 等）完成相同的任务，并熟悉文件的所有者、所属组和权限设置。

4、设备管理在 Windows 系统中，查看设备管理器中的硬件设备信息，安装和卸载设备驱动程序。

在 Linux 系统中，使用命令（如 lspci、lsusb 等）查看硬件设备，并通过安装内核模块来支持特定设备。

四、实验步骤1、进程管理实验（1）打开 Windows 系统的任务管理器，切换到“进程”选项卡，可以看到当前系统中正在运行的进程列表。

（2）选择一个进程，右键点击可以查看其属性，包括进程 ID、CPU 使用率、内存使用情况等。

（3）通过“结束任务”按钮可以结束指定的进程，但要注意不要随意结束系统关键进程，以免导致系统不稳定。

操作系统实验报告七一、实验目的1、死锁如何发生，如何在我们的内核中引发死锁。

2、针对情况解决我们程序的死锁，以及了解更科学的死锁解决方式。

二、实验过程（一）死锁的出现首先编辑src/main.rs，在not_main()函数的空循环中调用print!宏：1、loop{}中print!宏与handle_uart0_rx_irq()中print!宏竞争检查src/interrupts.rs中的handle_uart0_rx_irq()函数，可以看到我们之前写了一个输入中断回调函数，在函数中调用了print!宏输出信息。

直接编译并运行，预期在输入时触发死锁。

不停地乱序敲击键盘，此时有概率出现卡死，按键无法再次输入内容，即触发死锁现象。

2、loop{}中print!宏与handle_timer_irq()中print!宏竞争检查src/interrupts.rs中的handle_timer_irq()函数，可以看到我们之前写了一个时间中断回调函数，在函数中调用了print!宏打点。

但它之前被我们注释掉了，因此我们取消注释：然后我们编译并运行，预期在打第一个点时会触发死锁。

（二）死锁的简单处理为了防止出现死锁，一个简单的办法是在使用锁时禁止中断。

但需要注意的是禁用中断会增加中断响应延迟，而中断响应延迟一个非常重要的性能指标。

所以只能在短时间内禁用中断。

1、编辑src/uart_console/mod.rs，引入asm!宏。

2、编辑src/uart_console/mod.rs中的_print()函数，在处理输入时先关闭中断，再打开。

三、测试及分析两种情况下，死锁均已消失四、心得体会在单进程系统中，死锁更多的发生于进程对某一资源的竞争现象。

例如我们在实验中中断等输出函数对uart硬件资源争夺。

而多进程中的死锁更多的发生于两个不同进程发生了相互调用或资源竞争，互相等待对方结束进程的情况。

这时候我们称系统产生了死锁或系统处于死锁状态。

操作系统实验报告1. 实验目的本次实验的目的是通过设计一个简单的操作系统，深入理解操作系统的基本原理、结构和功能，并通过实践掌握操作系统的核心概念和实现方式。

2. 实验环境本次实验使用的实验环境如下：- 操作系统：Linux Ubuntu 18.04- 开发语言：C/C++- 开发工具：GCC编译器，GNU Make3. 实验内容及步骤本次实验包括以下几个主要内容和步骤：3.1 系统引导- 在操作系统启动时，首先执行系统引导程序，加载操作系统内核到内存中。

- 系统引导程序负责初始化硬件设备，建立起基本的运行环境，然后将控制权转交给操作系统内核。

3.2 内核初始化- 内核初始化过程包括初始化各种数据结构，建立进程控制块（PCB），初始化设备驱动程序等。

- 内核初始化完成后，操作系统进入空闲状态，等待用户的操作请求。

3.3 进程管理- 操作系统需要支持进程管理功能，包括进程的创建、销毁、调度和切换等。

- 进程管理模块负责分配和回收进程资源，根据调度算法决定进程的执行顺序，实现进程的并发执行。

3.4 内存管理- 操作系统需要支持内存管理功能，包括内存的分配和释放、内存的保护和共享等。

- 内存管理模块负责维护内存的使用情况，并根据进程的需求进行内存的分配和回收。

3.5 文件系统- 操作系统需要支持文件系统，提供对文件的创建、打开、读写和关闭等操作。

- 文件系统模块负责管理文件和目录的结构，以及实现对文件的存储和访问策略。

4. 实验结果与分析我们根据上述步骤，设计并实现了一个简单的操作系统。

通过测试和分析，得出以下实验结果和结论：4.1 系统启动与内核初始化- 当系统启动时，我们能够成功加载操作系统的内核，并初始化各种硬件设备。

- 内核初始化过程能够正确建立进程控制块（PCB），并初始化各个设备驱动程序。

4.2 进程管理- 我们能够成功创建和销毁进程，并按照设定的调度算法进行进程的切换。

- 进程间能够实现正确的互斥和同步操作，避免资源竞争和死锁等问题。

《操作系统》课内实验报告一、实验目的操作系统是计算机系统的核心组成部分，本次《操作系统》课内实验旨在通过实际操作和观察，深入理解操作系统的基本原理、功能和运行机制。

具体目的包括：1、熟悉操作系统的常用命令和操作，如文件管理、进程管理、内存管理等。

2、掌握操作系统的资源分配和调度策略，观察其对系统性能的影响。

3、培养解决操作系统相关问题的能力，提高动手实践和分析问题的能力。

二、实验环境本次实验在以下环境中进行：1、操作系统：Windows 10 专业版2、开发工具：Visual Studio Code三、实验内容及步骤（一）文件管理实验1、创建、删除和重命名文件及文件夹打开文件资源管理器，在指定目录下创建新的文件夹和文本文件。

对创建的文件和文件夹进行重命名操作，观察文件名的变化。

选择部分文件和文件夹进行删除操作，验证是否成功删除。

2、文件复制、移动和属性设置选取一些文件，将其复制到其他目录，并观察复制过程和结果。

把特定文件移动到不同的位置，检查文件是否正确迁移。

设置文件的属性，如只读、隐藏等，查看属性设置后的效果。

（二）进程管理实验1、查看系统进程打开任务管理器，观察当前正在运行的进程列表。

了解进程的名称、PID（进程标识符）、CPU 使用率、内存占用等信息。

2、进程的终止和优先级设置选择一个非关键进程，尝试终止其运行，观察系统的反应。

调整某些进程的优先级，观察其对系统资源分配和运行效率的影响。

（三）内存管理实验1、查看内存使用情况通过系统性能监视器，查看物理内存和虚拟内存的使用情况。

观察内存使用量随时间的变化趋势。

2、内存优化操作关闭一些不必要的后台程序，释放占用的内存资源。

调整虚拟内存的大小，观察对系统性能的改善效果。

四、实验结果与分析（一）文件管理实验结果1、成功创建、删除和重命名文件及文件夹，系统能够准确响应操作，文件名和文件夹名的修改即时生效。

2、文件的复制和移动操作顺利完成，数据无丢失和损坏。

《操作系统》课程实验报告一、实验目的本次《操作系统》课程实验的主要目的是通过实际操作和观察，深入理解操作系统的工作原理、进程管理、内存管理、文件系统等核心概念，并掌握相关的操作技能和分析方法。

二、实验环境1、操作系统：Windows 10 专业版2、开发工具：Visual Studio Code3、编程语言：C/C+＋三、实验内容（一）进程管理实验1、进程创建与终止通过编程实现创建新进程，并观察进程的创建过程和资源分配情况。

同时，实现进程的正常终止和异常终止，并分析其对系统的影响。

2、进程同步与互斥使用信号量、互斥锁等机制实现进程之间的同步与互斥。

通过模拟多个进程对共享资源的访问，观察并解决可能出现的竞争条件和死锁问题。

（二）内存管理实验1、内存分配与回收实现不同的内存分配算法，如首次适应算法、最佳适应算法和最坏适应算法。

观察在不同的内存请求序列下，内存的分配和回收情况，并分析算法的性能和优缺点。

2、虚拟内存管理研究虚拟内存的工作原理，通过设置页面大小、页表结构等参数，观察页面的换入换出过程，以及对系统性能的影响。

（三）文件系统实验1、文件操作实现文件的创建、打开、读取、写入、关闭等基本操作。

观察文件在磁盘上的存储方式和文件系统的目录结构。

2、文件系统性能优化研究文件系统的缓存机制、磁盘调度算法等，通过对大量文件的读写操作，评估不同优化策略对文件系统性能的提升效果。

四、实验步骤（一）进程管理实验步骤1、进程创建与终止（1）使用 C/C+＋语言编写程序，调用系统函数创建新进程。

（2）在子进程中执行特定的任务，父进程等待子进程结束，并获取子进程的返回值。

（3）通过设置异常情况，模拟子进程的异常终止，观察父进程的处理方式。

2、进程同步与互斥（1）定义共享资源和相关的信号量或互斥锁。

（2）创建多个进程，模拟对共享资源的并发访问。

（3）在访问共享资源的关键代码段使用同步机制，确保进程之间的正确协作。

（4）观察并分析在不同的并发情况下，系统的运行结果和资源竞争情况。

实验（一） Windows 7基本操作一、实验目的1．掌握文件和文件夹基本操作。

2．掌握“资源管理器”和“计算机”基本操作。

二、实验要求1.请将操作结果用Alt+Print Screen组合键截图粘贴在题目之后。

2．实验完成后，请将实验报告保存并提交。

三、实验内容1．文件或文件夹的管理（提示：此题自行操作一遍即可，无需抓图）★期末机试必考题★(1)在D：盘根目录上创建一个名为“上机实验”的文件夹，在“上机实验”文件夹中创建1个名为“操作系统上机实验”的空白文件夹和2个分别名为“2.xlsx”和“3.pptx”的空白文件，在“操作系统上机实验”文件夹中创建一个名为“1.docx”的空白文件。

(2)将“1.docx”改名为“介绍信.docx”；将“上机实验”改名为“作业”。

(3)在“作业”文件夹中分别尝试选择一个文件、同时选择两个文件、一次同时选择所有文件和文件夹。

(4)将“介绍信.docx”复制到C：盘根目录。

(5)将D：盘根目录中的“作业”文件夹移动到C：盘根目录。

(6)将“作业”文件夹中的“2.xlsx”文件删除放入“回收站”。

(7)还原被删除的“2.xlsx”文件到原位置。

2．搜索文件或文件夹，要求如下：查找C盘上所有以大写字母“A”开头，文件大小在10KB以上的文本文件。

（提示：搜索时，可以使用“?”和“*”。

“？”表示任意一个字符，“*”表示任意多个字符。

）3. 在桌面上为C：盘根目录下的“作业”文件夹创建一个桌面快捷方式。

★期末机试必考题★3．“计算机”或“资源管理器”的使用(1)在“资源管理器”窗口，设置以详细信息方式显示C:\WINDOWS中所有文件和文件夹，使所有图标按类型排列显示，并不显示文件扩展名。

（提示：三步操作全部做完后，将窗口中显示的最终设置结果抓一张图片即可）(2)将C：盘根目录中“介绍信.docx”的文件属性设置为“只读”和“隐藏”，并设置在窗口中显示“隐藏属性”的文件或文件夹。

计算机操作系统实验课实验报告一、实验目的本次计算机操作系统实验课的主要目的是通过实际操作和观察，深入理解计算机操作系统的基本原理和功能，提高对操作系统的实际运用能力和问题解决能力。

二、实验环境本次实验使用的计算机配置为：处理器_____，内存_____，操作系统为_____。

实验所使用的软件工具包括_____。

三、实验内容及步骤（一）进程管理实验1、编写程序创建多个进程，并观察进程的执行顺序和资源分配情况。

首先，使用编程语言（如 C 或 Java）编写代码，创建多个进程。

然后，通过操作系统提供的工具（如任务管理器）观察进程的创建、执行和结束过程。

记录不同进程的执行时间、CPU 使用率和内存占用情况。

2、实现进程间的通信机制，如管道、消息队列等。

分别编写使用管道和消息队列进行进程间通信的程序。

在程序中发送和接收数据，并观察通信的效果和数据的完整性。

（二）内存管理实验1、模拟内存分配算法，如首次适应算法、最佳适应算法和最坏适应算法。

编写程序实现上述三种内存分配算法。

输入不同的内存请求序列，观察每种算法下内存的分配情况和碎片产生情况。

2、研究虚拟内存的工作原理，并进行相关实验。

通过操作系统的设置，调整虚拟内存的大小。

运行大型程序，观察虚拟内存的使用情况和系统性能的变化。

（三）文件系统实验1、实现文件的创建、读写和删除操作。

使用编程语言创建文件，并向文件中写入数据。

读取文件中的内容，并进行验证。

删除文件，观察文件系统的变化。

2、研究文件系统的目录结构和文件权限管理。

观察文件系统的目录层次结构，了解目录的组织方式。

设置文件的权限，如只读、读写、执行等，观察不同权限对文件操作的影响。

四、实验结果与分析（一）进程管理实验结果与分析1、在创建多个进程的实验中，发现进程的执行顺序并非完全按照创建的顺序，而是由操作系统的调度算法决定。

某些进程可能会因为等待资源而暂时被挂起，而其他进程则会得到执行机会。

2、通过进程间通信实验，发现管道通信方式简单直接，但只能用于具有亲缘关系的进程之间；消息队列则更加灵活，可以在不同的进程之间传递消息，但需要更多的编程和管理工作。

操作系统实验报告一、实验目的本次操作系统实验的主要目的是通过实际操作和观察，深入理解操作系统的工作原理和关键机制，包括进程管理、内存管理、文件系统以及设备管理等方面。

同时，培养我们解决实际问题的能力，提高对操作系统相关知识的综合运用水平。

二、实验环境本次实验使用的操作系统为 Windows 10 和 Linux（Ubuntu 2004 LTS），实验所使用的编程工具包括 Visual Studio Code、gcc 编译器等。

三、实验内容及步骤（一）进程管理实验1、进程创建与终止在 Windows 系统中，使用 C+＋语言编写程序，通过调用系统 API函数创建新的进程，并观察进程的创建和终止过程。

在 Linux 系统中，使用 C 语言编写程序，通过 fork(）系统调用创建子进程，并通过 wait(）函数等待子进程的终止。

2、进程调度观察Windows 和Linux 系统中进程的调度策略，包括时间片轮转、优先级调度等。

通过编写程序模拟进程的执行，设置不同的优先级和执行时间，观察系统的调度效果。

（二）内存管理实验1、内存分配与释放在 Windows 系统中，使用 C+＋语言的 new 和 delete 操作符进行内存的动态分配和释放，并观察内存使用情况。

在 Linux 系统中，使用 C 语言的 malloc(）和 free(）函数进行内存的分配和释放，通过查看系统的内存使用信息来验证内存管理的效果。

2、虚拟内存管理研究 Windows 和 Linux 系统中的虚拟内存机制，包括页表、地址转换等。

通过编写程序访问虚拟内存地址，观察系统的处理方式和内存映射情况。

（三）文件系统实验1、文件操作在 Windows 和 Linux 系统中，使用编程语言对文件进行创建、读取、写入、删除等操作。

观察文件的属性、权限设置以及文件在磁盘上的存储方式。

2、目录操作实现对目录的创建、删除、遍历等操作。

研究目录结构和文件路径的表示方法。

计算机科学与技术学院操作系统实验报告学院：专业：班级：姓名：学号：日期：Email：目录实验一进程控制实验 (4)1.1实验目的 (4)1.2实验题目 (4)1.3实验步骤 (4)1.4结论分析与体会 (5)1.5附录：本实验全部程序源代码及注释 (5)1.5.1Pctl.c (5)1.5.2pctl.h (9)1.5.3makefile (10)实验三进程调度算法实验 (10)3.1实验目的 (10)3.2实验题目 (11)3.3实验步骤 (11)3.4结论分析与体会 (12)3.5附录：本实验全部程序源代码及注释 (12)3.5.1Psched.c (12)3.5.2Psched.h (14)3.5.3Makefile (16)实验四进程同步实验 (16)4.1实验目的 (16)4.2实验题目 (16)4.3实验步骤 (17)4.4结论分析与体会 (24)4.5附录：本实验全部程序源代码及注释 (24)4.5.1Ipc.c (24)4.5.2Ipc.h (32)4.5.3Consumer (35)4.5.4Producer (41)4.5.5makefile (50)实验七内存页面置换算法实验 (51)7.1实验目的 (51)7.2实验题目 (51)7.3实验步骤 (52)7.4附录：本实验全部程序源代码及注释 (55)7.4.1Vmrp.h (55) (57)7.5.3makefile (73)实验八磁盘移臂调度算法实验 (74)7.2实验目的 (74)8.2实验题目 (74)8.3实验步骤 (75)8.4附录：本实验全部程序源代码及注释 (76)8.4.1Dask.h (76) (78)8.4.3Makefile (94)实验一进程控制实验1.1 实验目的加深对于进程并发执行概念的理解。

实践并发进程的创建和控制方法。

观察和体验进程的动态特性。

进一步理解进程生命期期间创建、变换、撤销状态变换的过程。

操作系统实验报告操作系统是计算机科学中十分重要的一门课程，本次实验是关于操作系统的，通过实验，我们可以更深入地了解操作系统的相关知识和操作。

本篇文章将着重介绍本次操作系统实验的内容和实验过程中的收获。

一、实验内容本次实验内容主要涉及操作系统的进程、线程和进程同步三部分。

具体内容包括：1. 进程的创建和管理2. 线程的创建和管理3. 进程同步的实现在实验过程中，我们将分别使用C语言和Linux操作系统实现上述功能。

二、实验过程1. 进程的创建和管理在这一部分实验中，我们要创建多个进程，实现进程的调度和管理功能。

我们采用了Linux系统下的fork()函数，用于创建子进程。

在程序运行时，首先创建一个父进程，然后使用fork()函数创建四个子进程，每个子进程都有自己的进程号(pid)，并在屏幕上输出该进程号以示区分。

为了实现进程的调度功能，我们在代码中加入了sleep()函数，用于将进程挂起一段时间，然后再轮流执行其他进程。

2. 线程的创建和管理在这一部分实验中，我们使用了C语言的POSIX线程库pthread.h，实现多线程的功能。

同样地，我们采用了Linux系统下的fork()函数来创建线程。

在代码运行时，我们创建了两个线程，并在屏幕上输出线程号(tid)以示区分。

为了实现线程的调度和管理功能，我们在代码中加入了pthread_join()函数，用于等待线程的执行完成。

3. 进程同步的实现在这一部分实验中，我们使用了Linux系统下的进程同步工具——信号量(semaphore)。

在代码中，我们使用sem_init()函数创建信号量，使用sem_wait()函数阻塞进程或线程，使用sem_post()函数释放进程或线程。

为了更好地理解信号量的工作原理，我们将代码分为生产者和消费者两部分，其中生产者用于向缓冲区添加数据，消费者则用于删除数据。

在这个过程中，我们需要使用信号量控制生产者和消费者的数量，避免出现生产过多或消费过多的情况。

操作系统实验报告通用引言：操作系统是计算机系统中的一个重要组成部分，它主要负责管理计算机硬件和软件资源，并为用户提供一个友好的界面。

操作系统实验是计算机科学与技术专业的一门重要实践课程，通过实际操作和实验验证，可以深入理解操作系统的工作原理和实现方法。

本文将以《操作系统实验报告通用》为题，从引言概述、正文内容、总结等方面详细阐述操作系统实验的一般结构和内容。

概述：操作系统实验是计算机科学与技术专业的一门实践课程，通过实际操作和实验验证来了解操作系统的工作原理和实现方法。

在操作系统实验中，学生将学习操作系统的基本概念、运行机制和实现技术，并通过实验验证来加深对操作系统的理解。

操作系统实验通常涉及到操作系统的各个模块，如进程管理、文件系统、内存管理等，并通过实际操作来了解操作系统的具体实现。

操作系统实验通常包括实验报告、实验代码以及实验总结等部分。

正文内容：1. 实验背景和目的1.1 实验背景在操作系统实验中，学生将学习操作系统的基本概念、运行机制和实现技术，通过实验来了解操作系统的具体实现和应用。

1.2 实验目的操作系统实验的主要目的是通过实际操作和实验验证来加深对操作系统的理解，并培养学生的动手能力和解决问题的能力。

2. 实验内容2.1 实验一：进程管理进程管理是操作系统中的核心模块之一，它负责管理和调度系统中的进程。

在这个实验中，学生需实现一个简单的进程管理器，并能够模拟多个进程的并发执行和互斥访问。

2.2 实验二：文件系统文件系统是操作系统中的另一个重要模块，它负责管理和组织计算机中的文件和目录。

在这个实验中，学生需实现一个简单的文件系统，并能够进行文件的创建、打开、读写和关闭操作。

2.3 实验三：内存管理内存管理是操作系统中的关键模块之一，它负责管理系统中的内存资源。

在这个实验中，学生需实现一个简单的内存管理器，并能够进行内存的分配和释放操作。

2.4 实验四：设备管理设备管理是操作系统中的另一个重要模块，它负责管理和调度计算机中的各种设备。

操作系统课程实验报告一、实验目的操作系统是计算机系统中最为关键的软件之一，它负责管理计算机的硬件资源和软件资源，为用户提供一个良好的工作环境。

通过操作系统课程实验，旨在深入理解操作系统的基本原理和功能，提高对操作系统的实际操作能力和问题解决能力。

二、实验环境本次实验使用的操作系统为Windows 10 和Linux（Ubuntu 1804），开发工具包括 Visual Studio Code、gcc 编译器等。

三、实验内容（一）进程管理1、进程创建与终止在 Windows 系统中，使用 C+＋语言创建多个进程，并通过进程句柄控制进程的终止。

在 Linux 系统中，使用 fork(）系统调用创建子进程，并通过 exit(）函数终止进程。

2、进程同步与互斥使用信号量实现进程之间的同步与互斥。

在 Windows 中，利用CreateSemaphore(）和 WaitForSingleObject(）等函数进行操作；在Linux 中，通过 sem_init(）、sem_wait(）和 sem_post(）等函数实现。

（二）内存管理1、内存分配与释放在 Windows 中，使用 HeapAlloc(）和 HeapFree(）函数进行动态内存的分配与释放。

在 Linux 中，使用 malloc(）和 free(）函数完成相同的操作。

2、内存页面置换算法实现了几种常见的内存页面置换算法，如先进先出（FIFO）算法、最近最少使用（LRU）算法等，并比较它们的性能。

（三）文件系统管理1、文件创建与读写在 Windows 和 Linux 系统中，分别使用相应的 API 和系统调用创建文件，并进行读写操作。

2、目录操作实现了目录的创建、删除、遍历等功能。

四、实验步骤（一）进程管理实验1、进程创建与终止（1）在 Windows 系统中，编写 C+＋程序，使用 CreateProcess(）函数创建新进程，并通过 TerminateProcess(）函数终止指定进程。

实验名称：操作实验系统实验日期：2023年3月15日实验地点：XX大学计算机实验室实验目的：1. 熟悉实验系统的基本操作流程。

2. 掌握实验系统的基本功能使用方法。

3. 培养动手实践能力和团队协作精神。

实验原理：实验系统是一种模拟真实工作环境的软件平台，通过该平台可以完成各种实验任务。

本实验系统基于Windows操作系统，采用C#语言开发，具有图形界面和丰富的功能模块。

实验内容：1. 系统启动与关闭2. 系统界面熟悉3. 功能模块使用4. 实验任务完成实验步骤：一、系统启动与关闭1. 打开实验系统所在的文件夹，找到实验系统可执行文件。

2. 双击可执行文件，系统开始加载，出现启动界面。

3. 系统加载完成后，进入主界面。

4. 完成实验任务后，点击“退出”按钮，系统开始关闭。

二、系统界面熟悉1. 观察主界面，了解系统各个功能模块的布局。

2. 点击各个功能模块，了解其功能及使用方法。

3. 查看系统帮助文档，了解系统功能和使用技巧。

三、功能模块使用1. 数据管理模块：（1）创建数据表：点击“创建数据表”按钮，输入数据表名称，选择数据类型，点击“确定”按钮。

（2）添加数据：选择数据表，点击“添加数据”按钮，输入数据，点击“保存”按钮。

（3）查询数据：选择数据表，点击“查询数据”按钮，输入查询条件，点击“查询”按钮。

2. 图形处理模块：（1）打开图片：点击“打开图片”按钮，选择要处理的图片。

（2）图片编辑：对图片进行缩放、裁剪、旋转等操作。

（3）保存图片：点击“保存图片”按钮，选择保存路径和文件名，点击“保存”按钮。

3. 文本处理模块：（1）打开文本文件：点击“打开文本文件”按钮，选择要处理的文本文件。

（2）文本编辑：对文本进行复制、粘贴、删除等操作。

（3）保存文本：点击“保存文本”按钮，选择保存路径和文件名，点击“保存”按钮。

四、实验任务完成1. 根据实验要求，选择合适的功能模块。

2. 完成实验任务，记录实验数据。

计算机科学与技术学院实验报告
8 }
在文件../test/第5行上的语句Exec是一条Nachos的系统功能调用，它的功能为装入并执行以其参数为名的可执行文件，即创建一个新的用户进程。

假设我们先执行../test/ 程序，则../test/ 会在它还没有执行结束时又装入并执行另外一个程序，并与它同时驻留内存.
pageTable[i].physicalPage=usermap-->Find();避免从头开始物理存储覆盖了前一个用户程序的内存内容
利用Nachos在../userprog/ 中文件定义的Bitmap类。

利用bitmap记录和申请内存物理帧，使不同的程序装入到不同的物理空间中去，下面是对新的内存分配存储算法，改进了对多个用户程序的同时进驻内存的支持
这是对BitMap的代码修改，每次分配的时候要找到bitmap中的空闲页进行分配，而不能从0页开始分配在AddressSpace类中声明bitmap对象
static BitMap *mbitmap=new BitMap(NumPhysPages);
运行./nachos –x ../test/
结论分析与体会：
nachos无法运行多个用户程序的原因在于物理页的分配，那么改变物理页的分配，使多个程序的物理页不会相互覆盖，每个程序都能分配到对应的独立的物理页，那么不就可以同时执行多个用户程序了吗。

物理页的分配算法在BitMap类中有实现，使用一个数组作为物理页的数据结构。

在给用户程序分配物理页时，不再使用与逻辑页相同的数值，而是使用Find()方法查找下一个可用的物理页。

软件学院操作系统实验报告实验题目：实验七、内存页面置换算法实验学号：201100300124日期：2013年05月31日班级：5班姓名：韩俊晓Email：hanjunxiao188@实验目的：加深对于存储管理的了解，掌握虚拟存储器的实现原理；观察和了解重要的页面置换算法和置换过程。

练习模拟算法的编程技巧，锻炼分析试验数据的能力。

实验要求：请在以上示例实验程序中补充“增强二次机会”等置换算法的模拟程序。

输入不同的内存页面引用串和实存帧数，观察并分析其页面置换效果和性能，并将其与LRU和FIFO算法进行比较。

改进以上示例实验程序，使之能够随机的产生内存页面引用串，以便能动态的观测各种置换算法的性能。

硬件环境：实验室计算机软件环境：Ubuntu08.4－Linux操作系统BASH_VERSION='3.2.33(1)-releasegcc version 4.1.2gedit 2.18.2OpenOffice 2.3实验步骤：1.实验说明：1. 示例实验程序中模拟两种置换算法：LRU算法和FIFO算法2. 能对两种算法给定任意序列不同的页面引用串和任意帧实内存块数的组合测试，显示页置换的过程。

3. 能统计和报告不同置换算法情况下依次淘汰的页号、缺页次数（页错误数）和缺页率。

比较两种置换算法在给定条件下的优劣。

4. 为了能方便的扩充页面置换算法，更好的描述置换过程，示例实验程序采用了C++语言用Replace类描述了置换算法及其属性。

2.调试过程：1）建立程序，将代码写到程序中；2）再建立以下名为vmrp.h的C语言头文件：#include <iostream>#include <iomanip>#include <malloc.h>using namespace std;class Replace{public:Replace();~Replace();void InitSpace(char * MethodName); //初始化页号记录void Report(void); // 报告算法执行情况void Fifo(void); //先进先出算法void Lru(void); //最近最旧未用算法void Clock(void); //时钟(二次机会）置换算法void Eclock(void); //增强二次机会置换算法void Lfu(void); //最不经常使用置换算法void Mfu(void); //最经常使用置换算法private:int * ReferencePage ; //存放要访问到的页号int * EliminatePage ; //存放淘汰页号int * PageFrames ; //存放当前正在实存中的页号intPageNumber; //访问页数intFrameNumber; //实存帧数intFaultNumber; //失败页数int * Referencebit;//引用位int * count;int * Modifybit;//修改位};3）建立以下项目管理文件Makefilehead = vmrp.hsrcs = objs = vmrp.oopts = -w -g -call: vmrpvmrp: $(objs)g++ $(objs) -o vmrpvmrp.o: $(srcs) $(head)g++ $(opts) $(srcs)clean:rmvmrp *.o4)输入make命令编译连接生成可执行的vmrp程序$ g makeg++ -g -c vmrp.hg++ vmrp.o -o vmrp5)执行程序实验代码：#include "vmrp.h" Replace::Replace(){//设定总得访问页数,并分配相应的引用页号和淘汰页号记录数组空间cout<< "Please input page numbers :" ;cin>>PageNumber;//存放要访问到的页号ReferencePage = new int[sizeof(int) * PageNumber];//访问页数EliminatePage = new int[sizeof(int) * PageNumber];//存放淘汰页号cout<< "Please input reference page string :";for (i = 0; i <PageNumber; i++)cin>>ReferencePage[i];cout<< "Please input page frames :";cin>>FrameNumber;//实存帧数PageFrames = new int[sizeof(int) * FrameNumber];//存放当前正在实存中的页号Referencebit=new int[sizeof(int) * FrameNumber];//引用位count=new int[sizeof(int)*FrameNumber];Modifybit=new int[sizeof(int)*FrameNumber];//修改位}Replace::~Replace(){}void Replace::InitSpace(char * MethodName){cout<<endl<<MethodName<<endl;FaultNumber=0;//失败页数//引用还未开始,-1表示无引用页for (i = 0; i <PageNumber; i++)EliminatePage[i] = -1;//淘汰页号初始都设为-1for(i = 0; i <FrameNumber; i++){PageFrames[i] = -1;//存放当前正在实存中的页号Referencebit[i]=0;//未被使用引用位设置为0count[i]=0;//计数Modifybit[i]=0;//修改位初始为0}}//分析统计选择的算法对于当前输入的页面走向的性能void Replace::Report(void){//报告淘汰页顺序cout<<endl<< "Eliminate page:";for(int i=0; EliminatePage[i]!=-1; i++) cout<<EliminatePage[i] << " "; //报告缺页数和缺页率cout<<endl<< "Number of page faults = " <<FaultNumber<<endl; cout<<setw(6) <<setprecision(3) ;cout<< "Rate of page faults = " <<100*(float)FaultNumber/(float)PageNumber<< "%"<<endl;}//最近最旧未用置换算法void Replace::Lru(void){inti,j,k,l,next;InitSpace("LRU");//初始化页号记录//循环装入引用页for(k=0,l=0; k <PageNumber; k++){ //l为淘汰页的标记next=ReferencePage[k];//检测引用页当前是否已在实存for (i=0; i<FrameNumber; i++){if(next == PageFrames[i]){//与当前正在实存中的页号比较//引用页已在实存将其调整到页记录栈顶next= PageFrames[i];for(j=i;j>0;j--) PageFrames[j] = PageFrames[j-1];PageFrames[0]=next;break;}}if(PageFrames[0] == next){//如果引用页已放栈顶，则为不缺页，报告当前内存页号for(j=0; j<FrameNumber; j++)if(PageFrames[j]>=0) cout<<PageFrames[j] << " ";cout<<endl;continue; //继续装入下一页}else// 如果引用页还未放栈顶，则为缺页，缺页数加1 FaultNumber++;//栈底页号记入淘汰页数组中EliminatePage[l] = PageFrames[FrameNumber-1];//向下压栈for(j=FrameNumber-1;j>0;j--) PageFrames[j]= PageFrames[j-1]; PageFrames[0]=next; //引用页放栈顶//报告当前实存中页号for(j=0; j<FrameNumber; j++)if(PageFrames[j]>=0) cout<<PageFrames[j] << " ";//报告当前淘汰的页号if(EliminatePage[l]>=0)cout<< "->" <<EliminatePage[l++] <<endl;elsecout<<endl;}//分析统计选择的算法对于当前引用的页面走向的性能Report();}//先进先出置换算法void Replace::Fifo(void){inti,j,k,l,next;InitSpace("FIFO");//循环装入引用页for(k=0,j=l=0; k <PageNumber; k++){next=ReferencePage[k];//如果引用页已在实存中，报告实存页号for (i=0; i<FrameNumber; i++) if(next==PageFrames[i]) break; if (i<FrameNumber){for(i=0; i<FrameNumber; i++) cout<<PageFrames[i] << " "; cout<<endl;continue;// 继续引用下一页}//引用页不在实存中，缺页数加1FaultNumber++;//最先入页号记入淘汰页数组EliminatePage[l]=PageFrames[j];PageFrames[j]=next;//引用页号放最先入页号处j = (j+1)%FrameNumber;//最先入页号循环下移//报告当前实存页号和淘汰页号for(i=0; i<FrameNumber; i++)if(PageFrames[i]>=0) cout<<PageFrames[i] << " ";if(EliminatePage[l]>=0)cout<< "->" <<EliminatePage[l++] <<endl;elsecout<<endl;}Report();}//时钟(二次机会）置换算法void Replace::Clock(void){intj,i,k,l,next;InitSpace("Clock");for(k=0,j=l=0; k <PageNumber; k++){next=ReferencePage[k];for (i=0; i<FrameNumber; i++)//检测引用页当前是否已在实存if(next==PageFrames[i]){Referencebit[i]=1;//引用位设置为1break;}if (i<FrameNumber){for(i=0; i<FrameNumber; i++) cout<<PageFrames[i] << " "; cout<<endl;continue;}if(Referencebit[j]==1){//如果引用位为1 Referencebit[j]==0;//在判断之后，重新设置成0}EliminatePage[l]=PageFrames[j];//最先入页号记入淘汰页数组PageFrames[j]=next; //引用页号放最先入页号处Referencebit[j]=1;//引用位设置为1FaultNumber++;//缺页数加1j=(j+1)%FrameNumber;//最先入页号循环下移for(i=0; i<FrameNumber; i++)if(PageFrames[i]>=0) cout<<PageFrames[i] << " ";if(EliminatePage[l]>=0)cout<< "->" <<EliminatePage[l++] <<endl;elsecout<<endl;}Report();}//增强二次机会置换算法void Replace::Eclock (void){intj,i,k,l,next;InitSpace("EClock");for(k=0,j=l=0; k <PageNumber; k++){next=ReferencePage[k];//循环装入引用页for (i=0; i<FrameNumber; i++)//检测引用页当前是否已在实存if(next==PageFrames[i]){Referencebit[i]=1;//引用位设置为1count[i]++;//如果被引用了两次，就把修改位设置成1 if(count[i]%2==0)Modifybit[i]=0;//修改位设置为0elseModifybit[i]=1;break;}if (i<FrameNumber){for(i=0; i<FrameNumber; i++) cout<<PageFrames[i] << " "; cout<<endl;continue;}if(Referencebit[j]==1){Referencebit[j]==0;}if(Modifybit[j]==1){Modifybit[j]=0;}int min=10*Referencebit[j]+Modifybit[j];int index=j;for(i=0;i<FrameNumber;i++){if(10*Referencebit[i]+Modifybit[i]<min){min=10*Referencebit[i]+Modifybit[i];index=i;}}EliminatePage[l]=PageFrames[index];PageFrames[index]=next;Referencebit[index]=0;Modifybit[index]=1;count[index]=0;FaultNumber++;//引用页不在实存中，缺页数加1j=(j+1)%FrameNumber;//最先入页号循环下移for(i=0; i<FrameNumber; i++)if(PageFrames[i]>=0) cout<<PageFrames[i] << " ";if(EliminatePage[l]>=0)cout<< "->" <<EliminatePage[l++] <<endl;elsecout<<endl;}Report();}//最不经常使用置换算法void Replace::Lfu(void){intj,i,k,l,next;InitSpace("Lfu");for(k=0,j=l=0; k <PageNumber; k++){next=ReferencePage[k];for (i=0; i<FrameNumber; i++)if(next==PageFrames[i]){count[i]++;//记录使用次数break;}if (i<FrameNumber){for(i=0; i<FrameNumber; i++) cout<<PageFrames[i] << " ";cout<<endl;continue;}FaultNumber++;int min=count[0];int index=0;for(i=0;i<FrameNumber;i++){if(count[i]<min){min=count[i];index=i;}}EliminatePage[l]= PageFrames[index];//最不经常使用的页号记入淘汰页数组PageFrames[index]=next;count[index]=1;for(i=0; i<FrameNumber; i++)if(PageFrames[i]>=0) cout<<PageFrames[i] << " "; if(EliminatePage[l]>=0)cout<< "->" <<EliminatePage[l++] <<endl;elsecout<<endl;}Report();}//最经常使用置换算法void Replace::Mfu(void){intj,i,k,l,next;InitSpace("Mfu");for(i=0;i<FrameNumber;i++)count[i]=1;for(k=0,j=l=0; k <PageNumber; k++){next=ReferencePage[k];for (i=0; i<FrameNumber; i++)if(next==PageFrames[i]){count[i]++;break;}if (i<FrameNumber){for(i=0; i<FrameNumber; i++) cout<<PageFrames[i] << " "; cout<<endl;continue;}FaultNumber++;int max=count[0];int index=0;for(i=0;i<FrameNumber;i++){if(count[i]>max){max=count[i];index=i;}}EliminatePage[l]=PageFrames[index];PageFrames[index]=next;count[index]=0;for(i=0; i<FrameNumber; i++)if(PageFrames[i]>=0) cout<<PageFrames[i] << " "; if(EliminatePage[l]>=0)cout<< "->" <<EliminatePage[l++] <<endl;elsecout<<endl;}Report();}int main(intargc,char *argv[]){Replace * vmpr = new Replace();vmpr->Lru();vmpr->Fifo();vmpr->Clock();vmpr->Eclock();vmpr->Lfu();vmpr->Mfu();return 0;}。