中南大学
《操作系统》实验报告
姓名：
专业班级：
学号：
指导教师：
完成日期：
实验
1、实验目的
(1)多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些
进程优先占用处理机。本实验模拟实现处理机调度，以加深了解处理机调度的工作。
(2)从不同的侧面了解Windows 2000/XP 的虚拟内存机制。
2、实验内容
(1)选择一个调度算法，实现处理机调度。编写一段程序，实现快速排序。
(2)使用Win32 APIAPI 函数，编写一个包含两个线程的进程，一个线程用
于模拟内存分配活动，一个线程用于跟踪第一个线程的内存行为。模拟
内存活动的线程可以从一个文件中读出要进行的内存操作。每个内存操
作包含如下内容：
(3)时间：开始执行的时间；
(4)块数：分配内存的粒度；
(5)操作：包括保留一个区域、提交一个区域、释放一个区域、回收一个区
域以及锁与解锁一个区域；可以将这些操作编号，存放于文件中。
(6)大小：指块的大小；
(7)访问权限：共五种PAGE_READONLY 、PAGE_READWRITE、PAGE_EXCUTE、
PAGE_EXECUTE_READ 和PAGE_ EXECUTE_READWRITE。可以将这些权限编号，存放于文件中。跟踪线程将页面大小、已使用的地址范围、物理内
存总量以及虚拟内存总量等信息显示出来。
3、实验要求
（1）写出源程序，并编译运行
（2）详细记录程序调试及运行结果
源程序代码：
package OperatingSystem;
public class PCB {
private String name;
private int ID;
private int ra;
private int ntime;
private int ctime;
private String status;
private int priority;
private int raLimit;
public PCB( int id, int ntime, int priority, String status,int ra,int raLimit) {
this.ID = id;
this.ra = ra;
this.ntime = ntime;
this.status = status;
this.priority = priority;
this.raLimit=raLimit;
}
public void setID(int ID) {
this.ID = ID;
public int getID() {
return this.ID;
}
public void setRa(int ra) {
this.ra = ra;
}
public int getRa() {
return this.ra;
}
public void setRaLimit(int ralimit) { this.raLimit = raLimit;
}
public int getRaLimit() {
return this.raLimit;
public void setPriority(int priority) { this.priority = priority;
}
public int getPriority() {
return this.priority;
}
public void setNtime(int ntime) { this.ntime = ntime;
}
public int getNtime() {
return this.ntime;
}
public void setCtime(int ctime) { this.ctime = ctime;
public int getCtime() {
return this.ctime;
}
public void setName(String name) { https://www.doczj.com/doc/db14056993.html, = name;
}
public String getName() {
return https://www.doczj.com/doc/db14056993.html,;
}
public void setStates(String status) { this.status = status;
}
public String getStatus() {
return this.status;
public boolean equals(int id) {
if (this.ID == id)
return true;
else
return false;
}
public String toString() {
return this.ID + "_" + https://www.doczj.com/doc/db14056993.html, + "_" + this.priority + "_" + this.ra + "_" + this.ntime + "_" + this.status + "\n";
}
public void run() {
this.ntime = this.ntime - 1;
this.ctime = this.ctime + 1;
if (this.ctime % 2 == 0)
this.priority = this.priority - 1;
}
}
package OperatingSystem;
import java.util.ArrayList;
import java.util.Iterator;
public class PCBlist implements Iterable
public PCBlist() {
this.PCBItems = new ArrayList
}
public ArrayList
return this.PCBItems;
}
public Iterator
return this.PCBItems.iterator();
}
public void addItem(PCB pcb) {
this.PCBItems.add(pcb);
}
public void removeItem(PCB pcb) {
this.PCBItems.remove(pcb);
}
public PCB getItem(PCB pcb) {
for (PCB a : this.PCBItems) {
if (a.equals(pcb.getID()))
return a;
}
return null;
}
public PCB getItem(int id) {
for (PCB a : this.PCBItems) {
if (a.equals(id))
return a;
}
return null;
}
public int getNumberOfItems() {
return this.PCBItems.size();
}
public String[] getItemsState() {
String itemsStates[] = new String[this.getNumberOfItems()];
int i = 0;
for (Iterator iterator1 = PCBItems.iterator(); iterator1.hasNext();) { PCB Item = (PCB) iterator1.next();
itemsStates[i++] = Item.toString();
}
return itemsStates;
}
}
package OperatingSystem;
public class Resource {
private int ra = 0;
private int raLimit = 0;
private int availableRa;
public Resource(int ra, int raLimit) {
this.ra = ra;
this.raLimit = raLimit;
}
public void setRa(int ra) {
this.ra = ra;
}
public int getRa() {
return this.ra;
}
public void setRaLimit(int raLimit) {
this.raLimit = raLimit;
}
public int getRaLimit() {
return this.raLimit;
}
public void setAvailableRa(int availableRa) { this.availableRa = availableRa;
}
public int getAvailableRa() {
return this.availableRa;
}
public String toString() {
return this.ra + "_" + this.raLimit + "_" + this.availableRa + "\n";
}
}
package OperatingSystem;
import java.util.ArrayList;
import java.util.Iterator;
public class ResourceRecords implements Iterable
public ResourceRecords() {
this.resoureRecods = new ArrayList
}
public Iterator
return this.resoureRecods.iterator();
}
public ArrayList
return this.resoureRecods;
}
public void addItem(Resource re) {
this.resoureRecods.add(re);
}
public void removeItem(Resource re) {
this.resoureRecods.remove(re);
}
public Resource getResource(Resource re) {
for (Resource a : this.resoureRecods) {
if (a.equals(re))
return a;
}
return null;
}
public Resource getResource(int re) {
for (Resource a : this.resoureRecods) {
if (a.getRa() == re)
return a;
}
return null;
}
public int getNumberOfItems(){
return this.resoureRecods.size();
}
public String[] getItemsState() {
String itemsStates[] = new String[this.getNumberOfItems()];
int i = 0;
for (Iterator iterator1 = this.resoureRecods.iterator(); iterator1.hasNext();) {
Resource Item = (Resource) iterator1.next();
itemsStates[i++] = Item.toString();
}
return itemsStates;
}
}
package OperatingSystem;
import java.util.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import OperatingSystem.PCB;
import OperatingSystem.PCBlist;
import OperatingSystem.Resource;
import OperatingSystem.ResourceRecords;
import OperatingSystem.CPUSchedulingGUI.AddToBAKListener; import OperatingSystem.CPUSchedulingGUI.AddToReadyListener; import OperatingSystem.CPUSchedulingGUI.RemoveListener;
import OperatingSystem.CPUSchedulingGUI.ResetListener;
import OperatingSystem.CPUSchedulingGUI.ResetSystemListener; import OperatingSystem.CPUSchedulingGUI.StartSystemListener; import OperatingSystem.CPUSchedulingGUI.SuspendListener;
import OperatingSystem.CPUSchedulingGUI.SystemPauseListener; import OperatingSystem.CPUSchedulingGUI.UmountListener;
import OperatingSystem.CPUSchedulingGUI.priotiryListener;
import OperatingSystem.CPUSchedulingGUI.timeslicListener;
import java.io.*;
import java.text.*;
import java.util.StringTokenizer;
public class CPUSchedulingGUI extends JFrame {
/* Standar error stream */
static private PrintWriter stderr = new PrintWriter(System.err, true);
static private int WIDTH = 1000; // 朱孔面板的大小
static private int HEIGH = 700;
/* Wait:等待Suspend: 挂起；Ready:就绪；Resource:资源*/
static private int Wait_CELL_SIZE = 300, Wait_LIST_ROW = 10;
static private int Back_CELL_SIZE = 300, Back_LIST_ROW = 10;
static private int Ready_CELL_SIZE = 20, Ready_LIST_ROW = 5;
static private int Resource_CELL_SIZE = 200, Resource_LIST_ROW = 10;
static private int CPU_ROWS = 7, CPU_COLS = 28;
static private int STATUS_ROWS = 12, STATUS_COLS = 70;
private int timeSlice = 1;
private int systemStatus = 0;// 设置系统状态0：准备状态1：运行状态2：暂停状态
static private int TOTAL__TEXTFIELD_SIZE = 10; // Size total text field
// 记录各队列元素个数
private JList waitList, backList, readyList, resourceList; // 设置各个队列的链表
private JButton addToReadyButton, addToBackButton, resetButton;// 设置各个按钮
private JButton addToWaitButton, addUnwaitButton, removeButton;
private JButton startButton, pauseButton, resetSystemButton;
private JRadioButton priorityRadioButton, timeSliceRadioButton; // 优先级和时间片单选钮及时间片显示框
private JLabel timesliceSizeLabel;
private JTextField timesliceJTF;
private JPanel backPanel, PCBItemPanel, waitPanel, resourcePanel;
private JLabel backTotalLabel, waitTotalLabel;
private JLabel PIDLabel, requiredTimeLabel, priorityLabel, statuesLabel, baseLabel, limitLabel;
private JTextField backTotalTextField, waitTotalTextField;
private JTextField PIDTextField, requiredTimeTextField, priorityTextField, statusTextField, baseTextField, limitTextField;
private JTextArea CPUTextArea, statuesTextArea;
PCBlist backPCB, readyPCB, waitPCB;
private ResourceRecords resourceItems;
private boolean flag = false;
public void initFrame() {
backList = new JList();
backList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
backList.setVisibleRowCount(Back_LIST_ROW);
backList.setFixedCellWidth(Back_CELL_SIZE);
backList.setBackground(Color.GREEN);
waitList = new JList();
waitList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
waitList.setVisibleRowCount(Wait_LIST_ROW);
waitList.setFixedCellWidth(Wait_CELL_SIZE);
waitList.setBackground(Color.GREEN);
readyList = new JList();
readyList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
readyList.setVisibleRowCount(Ready_LIST_ROW);
readyList.setFixedCellWidth(Ready_CELL_SIZE);
readyList.setBackground(Color.GREEN);
resourceList = new JList();
resourceList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
resourceList.setVisibleRowCount(Resource_LIST_ROW);
resourceList.setFixedCellWidth(Resource_CELL_SIZE);
resourceList.setBackground(Color.GREEN);
addToWaitButton = new JButton("Wait");
addToWaitButton.setBackground(Color.black);
addToBackButton = new JButton("addToBack");
addToBackButton.setBackground(Color.black);
addToReadyButton = new JButton("AddToReady");
addToReadyButton.setBackground(Color.black);
resetButton = new JButton("Reset");
resetButton.setBackground(Color.black);
addUnwaitButton = new JButton("addUnwait");
addUnwaitButton.setBackground(Color.black);
removeButton = new JButton("Remove");
removeButton.setBackground(Color.black);
startButton = new JButton("StartSchuliding");
startButton.setBackground(Color.red);
pauseButton = new JButton("Pause");
pauseButton.setBackground(Color.yellow);
resetSystemButton = new JButton("resetSystem");
resetButton.setBackground(Color.green);
priorityRadioButton = new JRadioButton("Priority", true);
timeSliceRadioButton = new JRadioButton("Timeslice");
backTotalLabel = new JLabel("Total:");
backTotalTextField = new JTextField("0", TOTAL__TEXTFIELD_SIZE);
backTotalTextField.setBackground(Color.gray);
backTotalTextField.setEditable(false);
waitTotalLabel = new JLabel("Total:");
waitTotalTextField = new JTextField("0", TOTAL__TEXTFIELD_SIZE);
waitTotalTextField.setEditable(false);
timesliceSizeLabel = new JLabel("Timeslice");
timesliceJTF = new JTextField("3", 5);
timesliceJTF.setEditable(true);
CPUTextArea = new JTextArea(CPU_ROWS, CPU_COLS);
CPUTextArea.setBackground(Color.orange);
CPUTextArea.setEditable(false);
statuesTextArea = new JTextArea(STATUS_ROWS, STATUS_COLS);
statuesTextArea.setBackground(Color.PINK);
statuesTextArea.setEditable(false);
/* north panel*/
JPanel northPanel = new JPanel(new GridLayout(1, 3));
// ProcessPCB item information Panel
PCBItemPanel = new JPanel(new BorderLayout());
PCBItemPanel.setBorder( BorderFactory.createTitledBorder("PCBIte m Information"));
JPanel PCBItemButtonJPanel = new JPanel(new GridLayout(1, 3));
PCBItemButtonJPanel.add(addToBackButton);
PCBItemButtonJPanel.add(addToReadyButton);
PCBItemButtonJPanel.add(resetButton);
PCBItemPanel.add(this.initPCBItemPanel(), BorderLayout.CENTER);
PCBItemPanel.add(PCBItemButtonJPanel, BorderLayout.SOUTH);
//backupBAKList Panel
backPanel = new JPanel(new BorderLayout());
backPanel.setBorder(BorderFactory.createTitledBorder("BackupList"));
JPanel backupTotalPAnel = new JPanel();
backupTotalPAnel.add(backTotalLabel);
backupTotalPAnel.add(backTotalTextField);
backPanel.add ( new JScrollPane(backList,
JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED), BorderLayout.CENTER);
backPanel.add(backupTotalPAnel, BorderLayout.SOUTH);
// readyList panel
JPanel readyListPanel = new JPanel(new BorderLayout());
readyListPanel.setBorder(BorderFactory.createTitledBorder("ReadyList")) ;
readyListPanel.add ( new JScrollPane(readyList,
JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED));
readyListPanel.add (addToWaitButton, BorderLayout.SOUTH);
northPanel.add(PCBItemPanel);
northPanel.add(backPanel);
northPanel.add(readyListPanel);
/* center Panel*/
JPanel centrelPanel = new JPanel(new GridLayout(1, 0));
// SuspendList Panel
waitPanel = new JPanel(new BorderLayout());
操作系统原理试验报告 班级： 学号： 姓名：
实验一：CPU调度 一、实验内容 选择一个调度算法，实现处理机调度。 二、实验目的 多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机。本实验模拟实现处理机调度，以加深了解处理机调度的工作。 三、实验题目 1、设计一个按优先权调度算法实现处理机调度的程序； 2、设计按时间片轮转实现处理机调度的程序。 四、实验要求 PCB内容： 进程名/PID； 要求运行时间（单位时间）； 优先权； 状态： PCB指针； 1、可随机输入若干进程，并按优先权排序； 2、从就绪队首选进程运行：优先权-1/要求运行时间-1 要求运行时间=0时，撤销该进程 3、重新排序，进行下轮调度 4、最好采用图形界面； 5、可随时增加进程； 6、规定道数，设置后备队列和挂起状态。若内存中进程少于规定道数，可自动从后备 队列调度一作业进入。被挂起进程入挂起队列，设置解挂功能用于将指定挂起进程解挂入就绪队列。 7、每次调度后，显示各进程状态。 实验二：内存管理 一、实验内容 主存储器空间的分配和回收 二、实验目的 帮助了解在不同的存储管理方式下，应怎样实现主存空间的分配和回收。 三、实验题目 在可变分区管理方式下，采用最先适应算法实现主存空间的分配和回收。
四、实验要求 1、自行假设主存空间大小，预设操作系统所占大小并构造未分分区表； 表目内容：起址、长度、状态（未分/空表目） 2、结合实验一，PCB增加为： {PID，要求运行时间，优先权，状态，所需主存大小，主存起始位置，PCB指针} 3、采用最先适应算法分配主存空间； 4、进程完成后，回收主存，并与相邻空闲分区合并 .1、Vo类说明（数据存储结构） 进程控制块PCB的结构： Public class PCB{ //进程控制块PCB，代表一个进程 //进程名，作为进程的标识； private String name; //要求运行时间，假设进程运行的单位时间数； private int time; //赋予进程的优先权，调度时总是选取优先数小的进程先执行； private int priority; //状态，假设有“就绪”状态（ready）、“运行”状态（running）、 //“后备”状态（waiting）、“挂起”状态(handup) private String state; //进程存放在table中的位置 private int start; //进程的大小 private int length; //进程是否进入内存，1为进入，0为未进入 private int isIn; //进程在内存中的起始位置 private int base; //进程的大小 private int limit; //一些get和set方法以及构造器省略… };
重庆大学 学生实验报告 实验课程名称操作系统原理 开课实验室DS1501 学院软件学院年级2013专业班软件工程2 班学生姓名胡其友学号20131802 开课时间2015至2016学年第一学期 总成绩 教师签名洪明坚 软件学院制
《操作系统原理》实验报告 开课实验室：年月日学院软件学院年级、专业、班2013级软件工 程2班 姓名胡其友成绩 课程名称操作系统原理 实验项目 名称 指导教师洪明坚 教师 评语教师签名：洪明坚年月日 1．实验目的： ?进入实验环境 –双击expenv/setvars.bat ?检出（checkout）EPOS的源代码 –svn checkout https://www.doczj.com/doc/db14056993.html,/svn/epos ?编译及运行 –cd epos/app –make run ?清除所有的临时文件 –make clean ?调试 –make debug ?在“Bochs Enhanced Debugger”中，输入“quit”退出调试 –调试指令，请看附录A 2．实验内容： ?编写系统调用“time_t time(time_t *loc)” –功能描述 ?返回从格林尼治时间1970年1月1日午夜起所经过的秒数。如果指针loc 非NULL，则返回值也被填到loc所指向的内存位置 –数据类型time_t其实就是long ?typedef long time_t; 3．实验步骤： ?Kernel space –K1、在machdep.c中，编写系统调用的实现函数“time_t sys_time()”，计算用户秒数。需要用到 ?变量g_startup_time，它记录了EPOS启动时，距离格林尼治时间1970年1午夜的秒数 ?变量g_timer_ticks
“人工智能”实验报告 专业： 班级： 学号： 姓名： 2017年4月日
实验一搜索策略 （一）实验内容 1. 熟悉和掌握启发式搜索的定义、估价函数和算法过程；比较不同算法的性能。 2. 修改八数码问题或路径规划问题的源程序，改变其启发函数定义，观察结果的变化，分析原因。 （二）实验思路 1.利用已有程序“search.jar”，利用已有的“简单搜索树”图或自行构建一个图，选择DFS/BFS/Lowest Cost First/Best-First/Heuristic Depth First/A*等不同的搜索策略，观察程序运行中，OPEN表和CLOSED表的变化，观察搜索过程的变化，理解各个算法的原理。 2.任选八数码问题或路径规划问题的源程序，思考程序如何解决该问题，并对其启发函数进行修改，观察结果的变化，并分析原因 （三）程序清单 此处我选择了路径规划问题：由于篇幅原因，只附上启发函数的定义部分。 原启发函数： floatMapSearchNode::GoalDistanceEstimate( MapSearchNode&nodeGoal ) { floatxd = fabs(float(((float)x - (float)nodeGoal.x))); floatyd = fabs(float(((float)y - (float)nodeGoal.y))); return (xd + yd); } 第一次修改后的启发函数： float MapSearchNode::GoalDistanceEstimate( MapSearchNode&nodeGoal ) { float xd = fabs(float(((float)x - (float)nodeGoal.x))); float yd = fabs(float(((float)y - (float)nodeGoal.y))); float d=sqrt(xd*xd+yd*yd); return d; } 第二次修改后的启发函数： float MapSearchNode::GoalDistanceEstimate( MapSearchNode&nodeGoal ) { float xd = fabs(float(((float)x - (float)nodeGoal.x))); float yd = fabs(float(((float)y - (float)nodeGoal.y))); float d=3*sqrt(xd*xd+yd*yd); return d; } 第三次修改后的启发函数： float MapSearchNode::GoalDistanceEstimate( MapSearchNode&nodeGoal ) { float xd = fabs(float(((float)x - (float)nodeGoal.x)));
操作系统实验报告——实验二：C编程环境 实验目的 1．熟悉Linux下C程序设计的环境； 2．对系统调用有初步了解。 实验内容 1．Linux下C语言程序的开发过程 a、在用户主目录下用vi编辑C语言源程序（源程序已附后），如：$vi hello.c。 b、用gcc编译C语言源程序：$gcc ./hello.c -o example 这里gcc是Linux下的C语言程序编译器（GNU C Compiler），./hello.c表示待编译的源文件是当前工作目录下的hello.c，-o example表示编译后产生的目标代码文件名为example。 c、若编译不正确，则进入vi修改源程序，否则，运行目标代码：$./example 。注意： 这只是gcc最基本的用法，其他常用选项有：-c , -S , -O , -O2, -g 等。 2．编辑、调试下面c语言程序，说明该程序的功能。 #include
HUNAN UNIVERSITY 操作系统实验报告
目录 一、内容 (3) 二、目的 (3) 三、实验设计思想和练习题 (3) 练习0：填写已有实验 (3) 练习1：实现 first-fit 连续物理内存分配算法（需要编程） (3) 练习2：实现寻找虚拟地址对应的页表项（需要编程） (8) 练习3：释放某虚地址所在的页并取消对应二级页表项的映射（需要编程） (11) 运行结果 (13) 四、实验体会 (13)
一、内容 本次实验包含三个部分。首先了解如何发现系统中的物理内存；然后了解如何建立对物理内存的初步管理，即了解连续物理内存管理；最后了解页表相关的操作，即如何建立页表来实现虚拟内存到物理内存之间的映射，对段页式内存管理机制有一个比较全面的了解。 二、目的 1.理解基于段页式内存地址的转换机制； 2.理解页表的建立和使用方法； 3.理解物理内存的管理方法。 三、实验设计思想和练习题 练习0：填写已有实验 使用eclipse中的diff/merge工具将实验1的代码填入本实验中代码中有“LAB1”的注释相应部分。 练习1：实现 first-fit 连续物理内存分配算法（需要编程） 在实现first fit 内存分配算法的回收函数时，要考虑地址连续的空闲块之间的合并操作。提示:在建立空闲页块链表时，需要按照空闲页块起始地址来排序，形成一个有序的链表。可能会修改default_pmm.c 中的default_init，default_init_memmap，default_alloc_pages， default_free_pages等相关函数。请仔细查看和理解default_pmm.c中的注释。 请在实验报告中简要说明你的设计实现过程。请回答如下问题： 你的first fit算法是否有进一步的改进空间。 解答： 分析思路： （1）数据结构： A．每个物理页利用一个Page结构体表示，查看kern/mm/memlayout.h包括：
操作系统实验报告心得体会 每一次课程设计度让我学到了在平时课堂不可能学到的东西。所以我对每一次课程设计的机会都非常珍惜。不一定我的课程设计能够完成得有多么完美,但是我总是很投入的去研究去学习。所以在这两周的课设中,熬了2个通宵,生物钟也严重错乱了。但是每完成一个任务我都兴奋不已。一开始任务是任务,到后面任务就成了自己的作品了。总体而言我的课设算是达到了老师的基本要求。总结一下有以下体会。 1、网络真的很强大,用在学习上将是一个非常高效的助手。几乎所有的资料都能够在网上找到。从linux虚拟机的安装,到linux的各种基本命令操作,再到gtk的图形函数,最后到文件系统的详细解析。这些都能在网上找到。也因为这样,整个课程设计下来,我浏览的相关网页已经超过了100个(不完全统计)。当然网上的东西很乱很杂,自己要能够学会筛选。 不能决定对或错的,有个很简单的方法就是去尝试。就拿第二个实验来说,编译内核有很多项小操作,这些小操作错了一项就可能会导致编译的失败,而这又是非常要花时间的,我用的虚拟机,编译一次接近3小时。所以要非常的谨慎,尽量少出差错,节省时间。多找个几个参照资料,相互比较,
慢慢研究,最后才能事半功倍。 2、同学间的讨论,这是很重要的。老师毕竟比较忙。对于课程设计最大的讨论伴侣应该是同学了。能和学长学姐讨论当然再好不过了,没有这个机会的话,和自己班上同学讨论也是能够受益匪浅的。大家都在研究同样的问题,讨论起来,更能够把思路理清楚,相互帮助,可以大大提高效率。 3、敢于攻坚,越是难的问题,越是要有挑战的心理。这样就能够达到废寝忘食的境界。当然这也是不提倡熬夜的,毕竟有了精力才能够打持久战。但是做课设一定要有状态,能够在吃饭,睡觉,上厕所都想着要解决的问题,这样你不成功都难。 4、最好在做课设的过程中能够有记录的习惯,这样在写实验报告时能够比较完整的回忆起中间遇到的各种问题。比如当时我遇到我以前从未遇到的段错误的问题,让我都不知道从何下手。在经过大量的资料查阅之后,我对段错误有了一定的了解,并且能够用相应的办法来解决。 在编程中以下几类做法容易导致段错误,基本是是错误地使用指针引起的 1)访问系统数据区,尤其是往系统保护的内存地址写数据,最常见就是给一个指针以0地址 2)内存越界(数组越界,变量类型不一致等) 访问到不属于你的内存区域
制造系统自动化技术 实验报告 学院：机电工程学院 班级：机制**** 姓名：张** 学号： *********** 指导教师：李** 时间： 2018-11-12 实验一柔性自动化制造系统运行实验 1.实验目的 （1）通过操作MES终端软件，实现对柔性制造系统的任务下达和控制加工，让学生
了解智能制造的特征及优势。 （2）通过创意性的实验让学生了解自动化系统总体方案的构思。 （3）通过总体方案的构思让学生了解该系统的工作原理，并学会绘制控制系统流程图，掌握物料流、信息流、能量流的流动路径。 （4）通过总体方案的构思让学生掌握各机械零部件、传感器、控制元器件的工作原理及性能。 （5）通过实验系统运行让学生了解运行的可靠性、安全性是采用何种元器件来实现的，促进学生进行深层次的思考和实践。 2.实验内容 （1）仔细观察柔性自动化制造系统的实现，了解柔性自动化制造系统的各个模块，熟悉各个模块的机械结构。 （2）了解各种典型传动机构的组装、工作原理、以及如何实现运动方向和速度的改变； （3）学习多种传感器的工作原理、性能和使用方法； （4）了解典型驱动装置的工作原理、驱动方式和性能； （5）理解柔性制造系统的工作原理，完成柔性制造系统的设计、组装； （6）实现对柔性制造系统的控制与检测，完成工件抓取、传输和加工。
3.实验步骤 （1）柔性制造系统的总体方案设计； （2）进行检测单元的设计； （3）进行控制系统的设计； （4）上下料机构的组装与检测控制； （5）物料传输机构的组装与实现； （6）柔性制造系统各组成模块的连接与控制； （7）柔性制造系统各组成单元的状态与工件状态位置的检测； （8）对机器人手动操作，实现对工件的抓取、传输。 4. 实验报告 ①该柔性自动化制造系统由哪几个主要的部分组成； 主要由：总控室工作站、AGV小车输送物料机构、安川机器人上下料工作站、法那科机器人上下料工作站、ABB机器人组装工作站、视觉检测及传送工作站、激光打标工作站、堆垛机及立体仓储工作站。 ②画出该柔性自动化制造系统的物料传输系统结构简图；
评分： SHANGHAI UNIVERSITY 操作系统实验报告 学院计算机工程与科学 专业计算机科学与技术 学号 学生姓名
《计算机操作系统》实验一报告 实验一题目：操作系统的进程调度 姓名：张佳慧学号 :12122544 实验日期： 2015.1 实验环境： Microsoft Visual Studio 实验目的： 进程是操作系统最重要的概念之一，进程调度又是操作系统核心的主要内容。本实习要求学生独立地用高级语言编写和调试一个简单的进程调度程序。调度算法可任意选择或自行设计。例如，简单轮转法和优先数法等。本实习可加深对于进程调度和各种调度算法的理解。实验内容： 1、设计一个有n个进程工行的进程调度程序。每个进程由一个进程控制块（PCB）表示。进程控制块通常应包含下述信息：进程名、进程优先数、进程需要运行的时间、占用CPU的时间以及进程的状态等，且可按调度算法的不同而增删。 2、调度程序应包含2～3种不同的调度算法，运行时可任意选一种，以利于各种算法的分析比较。 3、系统应能显示或打印各进程状态和参数的变化情况，便于观察诸进程的调度过程。 操作过程： 1、本程序可选用优先数法或简单轮转法对五个进程进行调度。每个进程处于运行R(run)、就绪W(wait)和完成F(finish)三种状态之一，并假设起始状态都是就绪状态W。为了便于处理，程序进程的运行时间以时间片为单位计算。进程控制块结构如下： 进程控制块结构如下： PCB 进程标识数 链指针 优先数/轮转时间片数 占用 CPU 时间片数 进程所需时间片数 进程状态 进程控制块链结构如下：
其中：RUN—当前运行进程指针； HEAD—进程就绪链链首指针； TAID—进程就绪链链尾指针。2、算法与框图 (1) 优先数法。进程就绪链按优先数大小从高到低排列，链首进程首先投入运行。每过一个时间片，运行进程所需运行的时间片数减 1，说明它已运行了一个时间片，优先数也减 3，理由是该进程如果在一个时间片中完成不了，优先级应该降低一级。接着比较现行进程和就绪链链首进程的优先数，如果仍是现行进程高或者相同，就让现行进程继续进行，否则，调度就绪链链首进程投入运行。原运行进程再按其优先数大小插入就绪链，且改变它们对应的进程状态，直至所有进程都运行完各自的时间片数。 (2) 简单轮转法。进程就绪链按各进程进入的先后次序排列，进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项（相当于优先数法的优先数记录项位置）。每过一个时间片，运行进程占用处理机的时间片数加 1，然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等，若相等说明已到达轮转时间，应将现运行进程排到就绪链末尾，调度链首进程占用处理机，且改变它们的进程状态，直至所有进程完成各自的时间片。 (3) 程序框图
操作系统实验报告 实验名称: 系统的引导 所在班级: 指导老师: 老师 实验日期: 2014年3 月29 日
一、实验目的 ◆熟悉hit-oslab实验环境； ◆建立对操作系统引导过程的深入认识； ◆掌握操作系统的基本开发过程； ◆能对操作系统代码进行简单的控制，揭开操作系统的神秘面纱。 二、实验容 1. 阅读《Linux核完全注释》的第6章引导启动程序，对计算机和Linux 0.11的引导过程进行初步的了解。 2. 按照下面的要求改写0.11的引导程序bootsect.s。 3. 有兴趣同学可以做做进入保护模式前的设置程序setup.s。 4. 修改build.c，以便可以使用make BootImage命令 5. 改写bootsect.s主要完成如下功能： bootsect.s能在屏幕上打印一段提示信息XXX is booting...，其中XXX是你给自己的操作系统起的名字，例如LZJos、Sunix等。 6. 改写setup.s主要完成如下功能： bootsect.s能完成setup.s的载入，并跳转到setup.s开始地址执行。而setup.s 向屏幕输出一行"Now we are in SETUP"。setup.s能获取至少一个基本的硬件参数（如存参数、显卡参数、硬盘参数等），将其存放在存的特定地址，并输出到屏幕上。setup.s不再加载Linux核，保持上述信息显示在屏幕上即可。 三、实验环境
本实验使用的系统是windows系统或者是Linux系统，需要的材料是osexp。 四、实验步骤 1. 修改bootsect.s中的提示信息及相关代码; 到osexp\Linux-0.11\boot目录下会看到图1所示的三个文件夹，使用UtraEdit 打开该文件。将文档中的98行的mov cx,#24修改为mov cx,#80。同时修改文档中的第246行为图2所示的情形。 图1图2 图3 2. 在目录linux-0.11\boot下,分别用命令as86 -0 -a -o bootsect.obootsect.s和 ld86 -0 -s -obootsectbootsect.o编译和bootsect.s，生成bootsect文件; 在\osexp目录下点击MinGW32.bat依此输入下面的命令： cd linux-0.11 cd boot as86 -0 -a -o bootsect.obootsect.s ld86 -0 -s -o bootsectbootsect.o
算法分析与设计实验报告 学院：信息科学与工程学院 专业班级： 指导老师： 学号： 姓名：
目录 实验一：递归与分治 (3) 1.实验目的 (3) 2.实验预习内容 (3) 3.实验内容和步骤 (3) 4.实验总结及思考 (5) 实验二：回溯算法 (6) 1.实验目的： (6) 2.实验预习内容： (6) 3. 实验内容和步骤 (6) 4. 实验总结及思考 (9) 实验三：贪心算法和随机算法 (10) 1. 实验目的 (10) 2.实验预习内容 (10) 3.实验内容和步骤 (10) 4. 实验总结及思考 (13)
实验一：递归与分治 1.实验目的 理解递归算法的思想和递归程序的执行过程，并能熟练编写快速排序算法程序。 掌握分治算法的思想，对给定的问题能设计出分治算法予以解决。 2.实验预习内容 递归：递归算法是把问题转化为规模缩小了的同类问题的子问题。然后递归调用函数（或过程）来表示问题的解。 一个过程(或函数)直接或间接调用自己本身,这种过程(或函数)叫递归过程(或函数). 分治：分治算法的基本思想是将一个规模为N的问题分解为K个规模较小的子问题，这些子问题相互独立且与原问题性质相同。求出子问题的解，就可得到原问题的解。 3.实验内容和步骤 快速排序的基本思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 源代码： #include 操作系统教程 实 验 指 导 书 姓名： 学号： 班级：软124班 指导老师：郭玉华 2014年12月10日 实验一WINDOWS进程初识 1、实验目的 （1）学会使用VC编写基本的Win32 Consol Application（控制台应用程序)。 （2）掌握WINDOWS API的使用方法。 （3）编写测试程序，理解用户态运行和核心态运行。 2、实验内容和步骤 （1）编写基本的Win32 Consol Application 步骤1：登录进入Windows，启动VC++ 6.0。 步骤2：在“FILE”菜单中单击“NEW”子菜单，在“projects”选项卡中选择“Win32 Consol Application”,然后在“Project name”处输入工程名，在“Location”处输入工程目录。创建一个新的控制台应用程序工程。 步骤3：在“FILE”菜单中单击“NEW”子菜单，在“Files”选项卡中选择“C++ Source File”, 然后在“File”处输入C/C++源程序的文件名。 步骤4：将清单1-1所示的程序清单复制到新创建的C/C++源程序中。编译成可执行文件。 步骤5：在“开始”菜单中单击“程序”-“附件”-“命令提示符”命令，进入Windows“命令提示符”窗口，然后进入工程目录中的debug子目录，执行编译好的可执行程序： E:\课程\os课\os实验\程序\os11\debug>hello.exe 运行结果 (如果运行不成功，则可能的原因是什么？) ： 有可能是因为DOS下路径的问题 （2）计算进程在核心态运行和用户态运行的时间 步骤1：按照（1）中的步骤创建一个新的“Win32 Consol Application”工程，然后将清单1-2中的程序拷贝过来，编译成可执行文件。 步骤2：在创建一个新的“Win32 Consol Application”工程，程序的参考程序如清单1-3所示，编译成可执行文件并执行。 步骤3：在“命令提示符”窗口中运行步骤1中生成的可执行文件，测试步骤2中可执行文件在核心态运行和用户态运行的时间。 E:\课程\os课\os实验\程序\os12\debug>time TEST.exe 步骤4：运行结果 (如果运行不成功，则可能的原因是什么？) ： 因为程序是个死循环程序 步骤5：分别屏蔽While循环中的两个for循环，或调整两个for循环的次数，写出运行结果。 屏蔽i循环： 屏蔽j循环： _______________________________________________________________________________调整循环变量i的循环次数： 操作系统实验报告 Document number：NOCG-YUNOO-BUYTT-UU986-1986UT 许昌学院 《操作系统》实验报告书学号： 姓名：闫金科 班级：14物联网工程 成绩: 2016年02月 实验一Linux的安装与配置 一、实验目的 1.熟悉Linux系统的基本概念，比如Linux发行版、宏内核、微内核等。 2.掌握Linux系统的安装和配置过程，初步掌握Linux系统的启动和退出方 法。 3.熟悉Linux系统的文件系统结构，了解Linux常用文件夹的作用。 二、实验内容 1.从网络上下载VMware软件和两个不同Linux发行版镜像文件。 2.安装VMware虚拟机软件。 3.在VMware中利用第一个镜像文件完成第一个Linux的安装，期间完成网络 信息、用户信息、文件系统和硬盘分区等配置。 4.在VMware中利用第二个镜像文件完成第二个Linux的安装，并通过LILO或 者GRUB解决两个操作系统选择启动的问题。 5.启动Linux系统，打开文件浏览器查看Linux系统的文件结构，并列举出 Linux常用目录的作用。 三、实验过程及结果 1、启动VMware，点击新建Linux虚拟机，如图所示： 2、点击下一步，选择经典型，点击下一步在选择客户机页面选择 Linux，版本选择RedHatEnterpriseLinux5，如图所示： 3、点击下一步创建虚拟机名称以及所要安装的位置，如图所示： 4、点击下一步，磁盘容量填一个合适大小，此处选择默认值大小 10GB，如图所示： 5、点击完成，点击编辑虚拟机设置，选择硬件选项中的CD-ROM （IDE...）选项，在右侧连接中选择“使用ISO镜像（I）”选项，点 击“浏览”，找到Linux的镜像文件，如图所示： 计算机体系结构课程设计 学院：信息科学与工程学院 专业班级： 指导老师： 学号： 姓名： 目录 实验1 对指令操作码进行霍夫曼编码 (3) 一、实验目的 (3) 二、实验内容 (3) 三、设计思路 (4) 四、关键代码 (4) 五、实验截图 (5) 六、源代码 (5) 实验2 使用LRU 方法更新Cache (8) 一、实验目的 (8) 二、实验内容 (8) 三、设计思路 (9) 四、程序截图 (9) 五、实验代码 (9) 实验总结 (16) 参考文献 (16) 实验1 对指令操作码进行霍夫曼编码一、实验目的 了解和掌握指令编码的基本要求和基本原理 二、实验内容 1. 使用编程工具编写一个程序，对一组指令进行霍夫曼编码，并输出最后的编码结果以及对指令码的长度进行评价。与扩展操作码和等长编码进行比较。 2. 问题描述以及问题分析 举例说明此问题，例如： 下表所示： 对此组指令进行 HUFFMAN 编码正如下图所示： 最后得到的HUFFMAN 编码如下表所示： 最短编码长度为： H=0.45*1+0.30*2+0.15*3+0.05*4+0.03*5+0.01*6+0.01*6=-1.95. 要对指令的操作码进行 HUFFMAN 编码，只要根据指令的各类操作码的出现概率构造HUFFMAN 树再进行 HUFFAM 编码。此过程的难点构造 HUFFMAN 树，进行 HUFFAM 编 码只要对你所生成的 HUFFMAN 树进行中序遍历即可完成编码工作。 三、设计思路 观察上图，不难看出构造 HUFFMAN 树所要做的工作：1、先对各指令操作码的出现概率进行排序，构造一个有序链表。2、再取出两个最小的概率节点相加，生成一个生的节点加入到链表中，同时从两表中删除此两个节点。3、在对链表进行排序，链表是否只有一个节点，是则 HUFFAN 树构造完毕，否则继续做 2 的操作。为此设计一个工作链表（链表的元素时类，此类的功能相当结构。）、HUFFMAN 树节点、HUFFMAN 编码表节点。 四、关键代码 哈夫曼树重点在于如何排列权值大小不同的结点的顺序 private int leafNum; //叶子结点个数 private HaffmanNode[] hnodes; //哈夫曼树的结点数组 public HaffManCode(double[] weight) //构造指定权值集合的哈夫曼树 { int n = weight.length; //n个叶子结点 this.leafNum = n; this.hnodes = new HaffmanNode[2*n-1]; //n个叶子结点的哈夫曼树共有2n-1个结点 for(int i=0; i 操作系统实验报告 学院：计算机与通信工程学院 专业：计算机科学与技术 班级： 学号： 姓名： 指导教师： 成绩： 2014年 1 月 1 日 实验一线程的状态和转换（5分） 1 实验目的和要求 目的：熟悉线程的状态及其转换，理解线程状态转换与线程调度的关系。 要求： （1）跟踪调试EOS线程在各种状态间的转换过程，分析EOS中线程状态及其转换的相关源代码； （2）修改EOS的源代码，为线程增加挂起状态。 2 完成的实验内容 2.1 EOS线程状态转换过程的跟踪与源代码分析 （分析EOS中线程状态及其转换的核心源代码，说明EOS定义的线程状态以及状态转换的实现方法；给出在本部分实验过程中完成的主要工作，包括调试、跟踪与思考等） 1.EOS 准备了一个控制台命令“loop ”，这个命令的命令函数是 ke/sysproc.c 文件中的ConsoleCmdLoop 函数（第797行，在此函数中使用 LoopThreadFunction 函数（第755 行）创建了一个优先级为 8 的线程（后面简称为“loop 线程”），该线程会在控制台中不停的（死循环）输出该线程的ID和执行计数，执行计数会不停的增长以表示该线程在不停的运行。loop命令执行的效果可以参见下图： 2. 线程由阻塞状态进入就绪状态 （1）在虚拟机窗口中按下一次空格键。 （2）此时EOS会在PspUnwaitThread函数中的断点处中断。在“调试”菜单中选择“快速监视”，在快速监视对话框的表达式编辑框中输入表达式“*Thread”，然后点击“重新计算”按钮，即可查看线程控制块（TCB）中的信息。其中State域的值为3（Waiting），双向链表项StateListEntry的Next和Prev指针的值都不为0，说明这个线程还处于阻塞状态，并在某个同步对象的等待队列中；StartAddr域的值为IopConsoleDispatchThread，说明这个线程就是控制台派遣线程。 （3）关闭快速监视对话框，激活“调用堆栈”窗口。根据当前的调用堆栈，可以看到是由键盘中断服务程序（KdbIsr）进入的。当按下空格键后，就会发生键盘中断，从而触发键盘中断服务程序。在该服务程序的最后中会唤醒控制台派遣线程，将键盘事件派遣到活动的控制台。 （4）在“调用堆栈”窗口中双击PspWakeThread函数对应的堆栈项。可以看到在此函数中连续调用了PspUnwaitThread函数和PspReadyThread函数，从而使处于阻塞状态的控制台派遣线程进入就绪状态。 （5）在“调用堆栈”窗口中双击PspUnwaitThread函数对应的堆栈项，先来看看此函数是如何改变线程状态的。按F10单步调试直到此函数的最后，然后再从快速监视对 操作系统实验报告 银行家算法 班级：计算机()班 姓名：李君益 学号：(号) 提交日期： 指导老师: 林穗 一、设计题目 加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。 要求编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用银行家算法，有效的防止和避免死锁的发生。 二、设计要求 内容： 编制银行家算法通用程序，并检测思考题中所给状态的安全性。 要求： (1)下列状态是否安全？(三个进程共享个同类资源) 进程已分配资源数最大需求数 (状态) (状态) (2)考虑下列系统状态 分配矩阵最大需求矩阵可用资源矩阵 问系统是否安全？若安全就给出所有的安全序列。若进程请求()，可否立即分配？ 三、设计分析 一．关于操作系统的死锁 ．死锁的产生 计算机系统中有许多独占资源，他们在任一时刻只能被一个进程使用，如磁带机，绘图仪等独占型外围设备，或进程表，临界区等软件资源。两个进程同时向一台打印机输出将导致一片混乱，两个进程同时进入临界区将导致数据库错误乃至程序崩溃。正因为这些原因，所有操作系统都具有授权一个进程独立访问某一辞源的能力。一个进程需要使用独占型资源必须通过以下的次序： ●申请资源 ●使用资源 ●归还资源 若申请施资源不可用，则申请进程进入等待状态。对于不同的独占资源，进程等待的方式是有差别的，如申请打印机资源、临界区资源时，申请失败将一位这阻塞申请进程；而申请打开文件文件资源时，申请失败将返回一个错误码，由申请进程等待一段时间之后重试。只得指出的是，不同的操作系统对于同一种资源采取的等待方式也是有差异的。 在许多应用中，一个进程需要独占访问多个资源，而操作系统允许多个进程并发执行共享系统资源时，此时可能会出现进程永远被阻塞的现象。这种现象称为“死锁”。 2.死锁的定义 一组进程处于死锁状态是指：如果在一个进程集合中的每个进程都在等待只能由该集合中的其他一个进程才能引发的时间，则称一组进程或系统此时发生了死锁。 ．死锁的防止 .死锁产生的条件： ●互斥条件 “人工智能”实验报告 专业 班级 学号 姓名 目录 一、实验八自动规划实验群 (3) 二、实验一生产式系统实验群 (6) 三、实验二搜索策略实验群 (7) 四、实验七神经网络 (9) 五、实验心得和体会 (10) 实验八自动规划实验群 姓名班级指导老师日期2011.12 实验目 的 熟悉和掌握自动规划的基本原理,方法和主要技术。 实验原理规划是一种问子题求解技术，它从某个特定的问题状态出发，寻求一系列行为动作，并建立一个操作序列，直到求得目标状态为止。简而言之，规划是一个行动过程的描述。一个总规划可以含有若干个子规划。 实验环 境 转载相 关源文 件 实验环境 转载相关源文件 实现过 程 单步观察实验算法 算法结果分析 观测结果通过规定规则，确定initial state和goal state，使得移动臂按照规则进行移动。分别进行clear holding pickup putdown putdowntable等实现对木块的移动。 实现过程先进行逆向推理选择，找出途径后再进行移动。 学生结论对于不同的规则将会出现不同的移动过程。通过规定不同的动作可实现不通过的移动。 实验一生产式系统实验群 姓名指导老师日期2011.12 实验目的熟悉和掌握产生式系统的运行机制，掌握基 于规则推理的基本方法。 推理方 法 逆向推理 建立规则库建立事实库 该动物是哺乳动物<- 该动物有毛发. 该动物是哺乳动物<- 该动物有奶. 该动物是鸟<- 该动物有羽毛. 该动物是鸟<- 该动物会飞&会下蛋. 该动物是食肉动物<- 该动物吃肉. 该动物是食肉动物<- 该动物有犬齿&有爪&眼盯前方. 该动物是有蹄类动物<- 该动物是哺乳动物&有蹄. 该动物是有蹄类动物<- 该动物是哺乳动物& 是嚼反刍动物. 该动物是金钱豹<- 该动物是哺乳动物&是食肉动物&是黄褐色&身上有暗斑点. 该动物是虎<- 该动物是哺乳动物&该动物是食肉动物&是黄褐色&身上有黑色条纹. 该动物是长颈鹿<- 该动物是有蹄类动物&有长脖子&有长腿&身上有暗斑点. 该动物是斑马<- 该动物是有蹄类动物&身上有黑色条纹. 该动物是鸵鸟<- 该动物是鸟&有长脖子&有长腿&不会飞&有黑白二色. 该动物是企鹅<- 该动物是鸟&会游泳&不会飞&有黑白二色. 该动物是信天翁<- 该动物是鸟&善飞. %------动物识别系统事实集： %会游泳. %--该动物是企鹅 %不会飞. %有黑白二色. %该动物是鸟. %-------- %--该动物是鸟 %该动物会飞. %会下蛋. %----该动物是金钱豹<- 该动物是哺乳动物&是食肉动物&是黄褐色&身上有暗斑点. %该动物有毛发. %是食肉动物. %是黄褐色. %身上有暗斑点. %----该动物是虎<- 该动物是哺乳动物&该动物是食肉动物&是黄褐色&身上有黑色条纹. %该动物是哺乳动物. %是食肉动物. %是黄褐色. %身上有暗斑点. %----该动物是长颈鹿<- 该动物是有蹄类动物&有长脖子&有长腿&身上有暗斑点. %该动物是有蹄类动物. %有长脖子. %有长腿. %身上有暗斑点. 预测结果假设目标为该动物是金钱豹，则结果为true. 实验过程及结果(注意观测规则的匹配过程和方法) （1）假设这个动物是金钱豹。为了检验这个假设，根据规则， 要求这个动物是哺乳动物&是食肉动物&是黄褐色&身上有暗 斑点. （2）必须检验这个动物是否为哺乳动物。先由规则库中的： 该动物是哺乳动物<- 该动物有毛发.该动物是哺乳动物<- 备注（原因等） 根据逆向推理可以逐步 确定 操作系统教程实验报告 专业班级 学号 姓名 指导教师 实验一WINDOWS进程初识 1、实验目的 （1）学会使用VC编写基本的Win32 Consol Application（控制台应用程序)。 （2）掌握WINDOWS API的使用方法。 （3）编写测试程序，理解用户态运行和核心态运行。 2、实验内容和步骤 （1）编写基本的Win32 Consol Application 步骤1：登录进入Windows，启动VC++ 6.0。 步骤2：在“FILE”菜单中单击“NEW”子菜单，在“projects”选项卡中选择“Win32 Consol Application”,然后在“Project name”处输入工程名，在“Location”处输入工程目录。创建一个新的控制台应用程序工程。 步骤3：在“FILE”菜单中单击“NEW”子菜单，在“Files”选项卡中选择“C++ Source File”, 然后在“File”处输入C/C++源程序的文件名。 步骤4：将清单1-1所示的程序清单复制到新创建的C/C++源程序中。编译成可执行文件。 步骤5：在“开始”菜单中单击“程序”-“附件”-“命令提示符”命令，进入Windows “命令提示符”窗口，然后进入工程目录中的debug子目录，执行编译好的可执行程序：E:\课程\os课\os实验\程序\os11\debug>hello.exe 运行结果 (如果运行不成功，则可能的原因是什么？) ： （2）计算进程在核心态运行和用户态运行的时间 步骤1：按照（1）中的步骤创建一个新的“Win32 Consol Application”工程，然后将清单1-2中的程序拷贝过来，编译成可执行文件。 步骤2：在创建一个新的“Win32 Consol Application”工程，程序的参考程序如清单1-3所示，编译成可执行文件并执行。 步骤3：在“命令提示符”窗口中运行步骤1中生成的可执行文件，测试步骤2中可执行文件在核心态运行和用户态运行的时间。 E:\课程\os课\os实验\程序\os12\debug>time TEST.exe 步骤4：运行结果 (如果运行不成功，则可能的原因是什么？) ： 步骤5：分别屏蔽While循环中的两个for循环，或调整两个for循环的次数，写出运行结果。 屏蔽i循环：操作系统实验报告
操作系统实验报告
中南大学 计算机体系结构实验报告
计算机操作系统 实验报告
操作系统实验报告
中南大学人工智能实验报告
操作系统实验报告
相关主题
文本预览