操作系统实验报告-中南大学

操作系统原理试验报告

班级：

学号：

姓名：

实验一：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方法以及构造器省略…

};

2流程图

3.源程序核心代码

public void display()

{

if(runningList.size()>0)

{

jt1.setValueAt(runningList.get(0).getName().trim(),0,0);

jt1.setValueAt(runningList.get(0).getIsIn(),0,1);

jt1.setValueAt(runningList.get(0).getTime(),0,2);

jt1.setValueAt(runningList.get(0).getPriority(),0,3);

jt1.setValueAt(runningList.get(0).getStart(),0,4);

jt1.setValueAt(runningList.get(0).getLength(),0,5);

}

else

{

jt1.setValueAt("无进程",0,0);

jt1.setValueAt("进行",0,1);

jt1.setValueAt(null,0,2);

jt1.setValueAt(null,0,3);

jt1.setValueAt(null,0,4);

jt1.setValueAt(null,0,5);

}

///////////////////////////////////////////////////

for(int i =0; i < readyList.size(); i++)

{

jt2.setValueAt(readyList.get(i).getName().trim(),i,0);

jt2.setValueAt(readyList.get(i).getIsIn(),i,1);

jt2.setValueAt(readyList.get(i).getTime(),i,2);

jt2.setValueAt(readyList.get(i).getPriority(),i,3);

jt2.setValueAt(readyList.get(i).getStart(),i,4);

jt2.setValueAt(readyList.get(i).getLength(),i,5);

}

for(int j = readyList.size(); j < 6; j++)

{

jt2.setValueAt(null,j,0);

jt2.setValueAt(null,j,1);

jt2.setValueAt(null,j,2);

jt2.setValueAt(null,j,3);

jt2.setValueAt(null,j,4);

jt2.setValueAt(null,j,5);

}

//////////////////////////////////////////////

for(int i =0; i < waitingList.size(); i++)

{

jt3.setValueAt(waitingList.get(i).getName().trim(),i,0);

jt3.setValueAt(waitingList.get(i).getIsIn(),i,1);

jt3.setValueAt(waitingList.get(i).getTime(),i,2);

jt3.setValueAt(waitingList.get(i).getPriority(),i,3);

jt3.setValueAt(waitingList.get(i).getStart(),i,4);

jt3.setValueAt(waitingList.get(i).getLength(),i,5);

}

for(int j = waitingList.size(); j < 15; j++)

{

jt3.setValueAt(null,j,0);

jt3.setValueAt(null,j,1);

jt3.setValueAt(null,j,2);

jt3.setValueAt(null,j,3);

jt3.setValueAt(null,j,4);

jt3.setValueAt(null,j,5);

}

//////////////////////////////////////////////////////////////

for(int i =0; i < handupList.size(); i++)

{

jt4.setValueAt(handupList.get(i).getName().trim(),i,0);

jt4.setValueAt(handupList.get(i).getIsIn(),i,1);

jt4.setValueAt(handupList.get(i).getTime(),i,2);

jt4.setValueAt(handupList.get(i).getPriority(),i,3);

jt4.setValueAt(handupList.get(i).getStart(),i,4);

jt4.setValueAt(handupList.get(i).getLength(),i,5);

}

for(int j = handupList.size(); j < 15; j++)

{

jt4.setValueAt(null,j,0);

jt4.setValueAt(null,j,1);

jt4.setValueAt(null,j,2);

jt4.setValueAt(null,j,3);

jt4.setValueAt(null,j,4);

jt4.setValueAt(null,j,5);

}

jl1.setCellRenderer(new MyRenderer());

for(int i = 0; i < unAssignList.size(); i++)

{

System.out.print(unAssignList.get(i).getBase()+" ");

System.out.println(unAssignList.get(i).getLimit());

}

System.out.println("one");System.out.println();

}

////////////////////////////////////////////////////////时间和优先级减一

public void sub()

{

if(runningList.size()>0&&runningList.get(0).getIsIn()==1)

{

runningList.get(0).setTime(runningList.get(0).getTime()-1);

if(runningList.get(0).getPriority()>=1)

runningList.get(0).setPriority(runningList.get(0).getPriority()-1);

if(runningList.get(0).getTime()<0)

{

runningList.get(0).setTime(0);

}

if(runningList.get(0).getTime()==0)

{

putOutMemory(runningList,0);

}

}

}

public void sub1()

{

if(runningList.size()>0&&runningList.get(0).getIsIn()==1)

{

runningList.get(0).setTime(runningList.get(0).getTime()-1);

if(runningList.get(0).getTime()==0)

{

putOutMemory(runningList,0);

}

if(runningList.get(0).getPriority()<15)

if(runningList.get(0).getPriority()>=1)

runningList.get(0).setPriority(runningList.get(0).getPriority()-1);

}

}

////////////////////////////////////////////////////////////////////

public class MyRunnable implements Runnable

{

public void run()

{

while(true)

timeManager();

try

{

Thread.sleep(1000);

}

catch(InterruptedException ex)

{}

}

}

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////自动调度///////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////// public class MyRunnable1 implements Runnable

{

public void run()

{

while(true)

{

PManager();

try

{

Thread.sleep(1000);

}

catch(InterruptedException ex)

{}

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////得到list中优先权最高的//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

}

}

public int getFirstW(ArrayList list)

{

if(list.size()>0)

{

int min = 0;

for(int i = 1;i

{

if(list.get(min).getPriority() > list.get(i).getPriority())

{

min = i;

}

}

min++;

return min;

}

else

{

return 0;

}

}

/////////////////////////////////////////////////////////////////////////

///////////////////////////删除列表中第几个数据/////////////////////////////////////////////////// ///////////////////////////////////////////////////////////

public void update(ArrayList list, int num)

{

sList.clear();

for(int i = 0; i < list.size(); i++)

{

if(i != num)

{

sList.add(list.get(i));

}

}

list.clear();

for(int i = 0; i < sList.size();i++)

{

list.add(sList.get(i));

}

}

public void update1(ArrayList list, int num)

{

sList1.clear();

for(int i = 0; i < list.size(); i++)

{

if(i != num)

{

sList1.add(list.get(i));

}

}

list.clear();

for(int i = 0; i < sList1.size();i++)

{

list.add(sList1.get(i));

}

}

////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////放入内存//////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////

public void putInMemory()

{

if(runningList.size()>0)

{

if(runningList.get(0).getIsIn()==0)

{

for(int i = 0; i < unAssignList.size(); i++)

{

if(unAssignList.get(i).getLimit() >= runningList.get(0).getLength())

{

runningList.get(0).setStart(unAssignList.get(i).getBase());

runningList.get(0).setIsIn(1);

if(unAssignList.get(i).getLimit() == runningList.get(0).getLength())

{

update1(unAssignList,i);

}

else

{

unAssignList.get(i).setBase(unAssignList.get(i).getBase()+runningList.get(0).getLength());

unAssignList.get(i).setLimit(unAssignList.get(i).getLimit()-runningList.get(0).getLength());

}

break;

}

}

}

}

if(readyList.size()>0)

{

for(int j = 0; j < readyList.size(); j++)

{

if(readyList.get(j).getIsIn()==0)

{

for(int i = 0; i < unAssignList.size(); i++)

{

if(unAssignList.get(i).getLimit() >= readyList.get(j).getLength())

{

readyList.get(j).setStart(unAssignList.get(i).getBase());

readyList.get(j).setIsIn(1);

if(unAssignList.get(i).getLimit() == readyList.get(j).getLength())

{

update1(unAssignList,i);

}

else

{

unAssignList.get(i).setBase(unAssignList.get(i).getBase()+readyList.get(j).getLength());

unAssignList.get(i).setLimit(unAssignList.get(i).getLimit()-readyList.get(j).getLength());

}

break;

}

}

}

}

}

}

////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////移除内存//////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////

public void putOutMemory(ArrayList list, int num)

{

list.get(num).setIsIn(0);

boolean flag1 = false;

boolean flag2 = false;

for(int i = 0; i < unAssignList.size(); i++)

{

if(unAssignList.get(i).getBase() == (list.get(num).getLength()+list.get(num).getStart()))

{

unAssignList.get(i).setBase(list.get(num).getStart());

unAssignList.get(i).setLimit(list.get(num).getLength()+unAssignList.get(i).getLimit());

flag1 = true;

break;

}

}

for(int i = 0; i < unAssignList.size(); i++)

{

if((unAssignList.get(i).getBase()+unAssignList.get(i).getLimit()) == list.get(num).getStart())

if(!flag1)

{

unAssignList.get(i).setLimit(list.get(num).getLength()+unAssignList.get(i).getLimit());

flag2 = true;

break;

}

else

{

unAssignList.get(i).setLimit(unAssignList.get(i).getLimit()+unAssignList.get(i+1).getLimit() );

update1(unAssignList,i+1);

}

}

}

if(flag1 || flag2)

{}

else

{

int i = 0;

while(unAssignList.get(i).getBase()

{

i++;

}

Data_Memory data = new Data_Memory();

data.setBase(list.get(num).getStart());

data.setLimit(list.get(num).getLength());

sList1.clear();

for(int j = 0; j < i; j++)

{

sList1.add(unAssignList.get(j));

}

sList1.add(data);

for(int j = i; j < unAssignList.size(); j++)

{

sList1.add(unAssignList.get(j));

}

unAssignList.clear();

for(int j = 0; j < sList1.size(); j++)

{

unAssignList.add(sList1.get(j));

}

}

}

////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////JLIST

private class MyRenderer extends DefaultListCellRenderer

{

public Component getListCellRendererComponent(JList list, Object value,int index, boolean isSelected, boolean cellHasFocus)

{

super.getListCellRendererComponent(list, value, index, isSelected,cellHasFocus);

setBackground(Color.gray);

for(int i = 0; i < unAssignList.size(); i++)

{

for(int j = unAssignList.get(i).getBase() ; j < unAssignList.get(i).getLimit()+unAssignList.get(i).getBase(); j++)

{

if(index == j)

{

setBackground(Color.white);//当没有内容变为白色

}

}

}

return this;

}

}

////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////

public void timeManager()

{

////////////去掉time==0的，从waiting队列加入新的进程，排序,调整waitingList加入runningLIst

/////////////去掉time==0的

if(runningList.size()>0)

if(runningList.get(0).getTime()==0)

runningList.clear();

sList.clear();

for(int i = 0; i < readyList.size(); i++)

{

if(readyList.get(i).getTime()>0)

{

sList.add(readyList.get(i));

}

}

readyList.clear();

for(int i =0; i < sList.size();i++)

{

readyList.add(sList.get(i));

readyList.get(i).setState("ready");

}

/////////////////从waiting队列加入新的进程

int j = 0;

int m = readyList.size();

for(; m < 6 && j < waitingList.size(); m++,j++) {

readyList.add(waitingList.get(j));

readyList.get(m).setState("ready");

}

// sort(readyList);

/////////////////////////调整waitingList

sList.clear();

for(int i = j; i < waitingList.size(); i++)

{

sList.add(waitingList.get(i));

}

waitingList.clear();

for(int i =0; i < sList.size();i++)

{

waitingList.add(sList.get(i));

}

////////////////////////////////////加入runningLIst

if(runningList.size()==0)

{

if(readyList.size()>0)

{

runningList.add(readyList.get(0));

runningList.get(0).setState("running");

update(readyList,0);

if(waitingList.size()>0)

{

readyList.add(waitingList.get(0));

readyList.get(5).setState("ready");

}

update(waitingList,0);

}

}

else /////////////////if(runningList.size()>0)

{

if(readyList.size()>0)

{

readyList.add(runningList.get(0));

runningList.clear();

readyList.get(0).setState("running");

readyList.get(readyList.size()-1).setState("ready");

runningList.add(readyList.get(0));

update(readyList,0);

}

}

putInMemory();

sub();

display();

jtf1.grabFocus();

}

public void PManager()

{

if(runningList.size()>0)

if(runningList.get(0).getTime()==0)

runningList.clear();

sList.clear();

for(int i = 0; i < readyList.size(); i++)

{

if(readyList.get(i).getTime()>0)

{

sList.add(readyList.get(i));

}

}

readyList.clear();

for(int i =0; i < sList.size();i++)

{

readyList.add(sList.get(i));

readyList.get(i).setState("ready");

}

/////////////////从waiting队列加入新的进程

int j = 0;

int m = readyList.size();

for(; m < 6 && j < waitingList.size(); m++,j++)

{

readyList.add(waitingList.get(getFirstW(waitingList)-1));

readyList.get(m).setState("ready");

update(waitingList,getFirstW(waitingList)-1);

}

/////////////////////////调整waitingList

////////////////////////////////////加入runningLIst

if(runningList.size()==0)

{

if(readyList.size()>0)

{

runningList.add(readyList.get(getFirstW(readyList)-1));

runningList.get(0).setState("running");

update(readyList,getFirstW(readyList)-1);

if(waitingList.size()>0)

{

readyList.add(waitingList.get(getFirstW(waitingList)-1));

readyList.get(readyList.size()-1).setState("ready");

}

update(waitingList,getFirstW(waitingList)-1);

}

}

else

{

if(readyList.size()>0)

{

boolean flag = false;

int a = runningList.get(0).getPriority();

int b = readyList.get(getFirstW(readyList)-1).getPriority();

if(a > b)

{

sList.clear();

sList.add(readyList.get(getFirstW(readyList)-1));

flag = true;

}

if(flag)

{

runningList.get(0).setState("ready");

readyList.add(runningList.get(0));

runningList.clear();

runningList.add(sList.get(0));

runningList.get(0).setState("running");

update(readyList,getFirstW(readyList)-1);

}

}

}

putInMemory();

sub1();

display();

jtf1.grabFocus();

}

}

操作系统实验报告-中南大学

操作系统原理试验报告 班级： 学号： 姓名：

实验一：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方法以及构造器省略… };

操作系统实验报告--实验一--进程管理

实验一进程管理 一、目的 进程调度是处理机管理的核心内容。本实验要求编写和调试一个简单的进程调度程序。通过本实验加深理解有关进程控制块、进程队列的概念，并体会和了解进程调度算法的具体实施办法。 二、实验内容及要求 1、设计进程控制块PCB的结构（PCB结构通常包括以下信息：进程名（进程ID）、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等。可根据实验的不同，PCB结构的内容可以作适当的增删）。为了便于处理，程序中的某进程运行时间以时间片为单位计算。各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定。 2、系统资源(r1…r w),共有w类，每类数目为r1…r w。随机产生n进程P i(id,s(j,k)，t),0<=i<=n,0<=j<=m,0<=k<=dt为总运行时间，在运行过程中，会随机申请新的资源。 3、每个进程可有三个状态（即就绪状态W、运行状态R、等待或阻塞状态B），并假设初始状态为就绪状态。建立进程就绪队列。 4、编制进程调度算法：时间片轮转调度算法 本程序用该算法对n个进程进行调度，进程每执行一次，CPU时间片数加1，进程还需要的时间片数减1。在调度算法中，采用固定时间片（即：每执行一次进程，该进程的执行时间片数为已执行了1个单位），这时，CPU时间片数加1，进程还需要的时间片数减1，并排列到就绪队列的尾上。 三、实验环境 操作系统环境：Windows系统。 编程语言：C#。 四、实验思路和设计 1、程序流程图

2、主要程序代码 //PCB结构体 struct pcb { public int id; //进程ID public int ra; //所需资源A的数量 public int rb; //所需资源B的数量 public int rc; //所需资源C的数量 public int ntime; //所需的时间片个数 public int rtime; //已经运行的时间片个数 public char state; //进程状态，W（等待）、R（运行）、B（阻塞） //public int next; } ArrayList hready = new ArrayList(); ArrayList hblock = new ArrayList(); Random random = new Random(); //ArrayList p = new ArrayList(); int m, n, r, a,a1, b,b1, c,c1, h = 0, i = 1, time1Inteval;//m为要模拟的进程个数，n为初始化进程个数 //r为可随机产生的进程数（r=m-n） //a，b，c分别为A，B，C三类资源的总量 //i为进城计数，i=1…n //h为运行的时间片次数，time1Inteval为时间片大小（毫秒） //对进程进行初始化，建立就绪数组、阻塞数组。 public void input()//对进程进行初始化，建立就绪队列、阻塞队列 { m = int.Parse(textBox4.Text); n = int.Parse(textBox5.Text); a = int.Parse(textBox6.Text); b = int.Parse(textBox7.Text); c = int.Parse(textBox8.Text); a1 = a; b1 = b; c1 = c; r = m - n; time1Inteval = int.Parse(textBox9.Text); timer1.Interval = time1Inteval; for (i = 1; i <= n; i++) { pcb jincheng = new pcb(); jincheng.id = i; jincheng.ra = (random.Next(a) + 1); jincheng.rb = (random.Next(b) + 1); jincheng.rc = (random.Next(c) + 1); jincheng.ntime = (random.Next(1, 5)); jincheng.rtime = 0;

中南大学通信电子线路实验报告

中南大学 《通信电子线路》实验报告 学院信息科学与工程学院 题目调制与解调实验 学号 专业班级 姓名 指导教师

实验一振幅调制器 一、实验目的： 1．掌握用集成模拟乘法器实现全载波调幅和抑止载波双边带调幅的方法。 2．研究已调波与调制信号及载波信号的关系。 3．掌握调幅系数测量与计算的方法。 4．通过实验对比全载波调幅和抑止载波双边带调幅的波形。 二、实验内容： 1．调测模拟乘法器MC1496正常工作时的静态值。 2．实现全载波调幅，改变调幅度，观察波形变化并计算调幅度。 3．实现抑止载波的双边带调幅波。 三、基本原理 幅度调制就是载波的振幅（包络）受调制信号的控制作周期性的变化。变化的周期与调制信号周期相同。即振幅变化与调制信号的振幅成正比。通常称高频信号为载波信号。本实验中载波是由晶体振荡产生的10MHZ高频信号。1KHZ的低频信号为调制信号。振幅调制器即为产生调幅信号的装置。 在本实验中采用集成模拟乘法器MC1496来完成调幅作用，图2-1为1496芯片内部电路图，它是一个四象限模拟乘法器的基本电路，电路采用了两组差动对由V1－V4组成，以反极性方式相连接，而且两组差分对的恒流源又组成一对差分电路，即V5与V6，因此恒流源的控制电压可正可负，以此实现了四象限工作。D、V7、V8为差动放大器V5与V6的恒流源。进行调幅时，载波信号加在V1－V4的输入端，即引脚的⑧、⑩之间；调制信号加在差动放大器V5、V6的输入端，即引脚的①、④之间，②、③脚外接1KΩ电位器，以扩大调制信号动态范围，已调制信号取自双差动放大器的两集电极（即引出脚⑹、⑿之间）输出。

图2-1 MC1496内部电路图 用1496集成电路构成的调幅器电路图如图2－2所示，图中VR8用来调节引出脚①、④之间的平衡，VR7用来调节⑤脚的偏置。器件采用双电源供电方式（＋12V，－9V），电阻R29、R30、R31、R32、R52为器件提供静态偏置电压，保证器件内部的各个晶体管工作在放大状态。 四、实验结果 1. ZD.OUT波形： 2. TZXH波形：

嵌入式操作系统实验报告

中南大学信息科学与工程学院实验报告 姓名：安磊 班级：计科0901 学号： 0909090310

指导老师：宋虹

目录 课程设计内容 ----------------------------------- 3 uC/OS操作系统简介 ------------------------------------ 3 uC/OS操作系统的组成 ------------------------------ 3 uC/OS操作系统功能作用 ---------------------------- 4 uC/OS文件系统的建立 ---------------------------- 6 文件系统设计的原则 ------------------------------6 文件系统的层次结构和功能模块 ---------------------6 文件系统的详细设计 -------------------------------- 8 文件系统核心代码 --------------------------------- 9 课程设计感想 ------------------------------------- 11 附录-------------------------------------------------- 12

课程设计内容 在uC/OS操作系统中增加一个简单的文件系统。 要求如下： (1)熟悉并分析uc/os操作系统 (2)设计并实现一个简单的文件系统 (3)可以是存放在内存的虚拟文件系统，也可以是存放在磁盘的实际文件系统 (4)编写测试代码，测试对文件的相关操作：建立，读写等 课程设计目的 操作系统课程主要讲述的内容是多道操作系统的原理与技术，与其它计算机原理、编译原理、汇编语言、计算机网络、程序设计等专业课程关系十分密切。 本课程设计的目的综合应用学生所学知识，建立系统和完整的计算机系统概念，理解和巩固操作系统基本理论、原理和方法，掌握操作系统开发的基本技能。 I．uC/OS操作系统简介 μC/OS-II是一种可移植的，可植入ROM的，可裁剪的，抢占式的，实时多任务操作系统内核。它被广泛应用于微处理器、微控制器和数字信号处理器。 μC/OS 和μC/OS-II 是专门为计算机的嵌入式应用设计的，绝大部分代码是用C语言编写的。CPU 硬件相关部分是用汇编语言编写的、总量约200行的汇编语言部分被压缩到最低限度，为的是便于移植到任何一种其它的CPU 上。用户只要有标准的ANSI 的C交叉编译器，有汇编器、连接器等软件工具，就可以将μC/OS-II嵌入到开发的产品中。μC/OS-II 具有执行效率高、占用空间小、实时性能优良和可扩展性强等特点，最小内核可编译至2KB 。μC/OS-II 已经移植到了几乎所有知名的CPU 上。 严格地说uC/OS-II只是一个实时操作系统内核，它仅仅包含了任务调度，任务管理，时间管理，内存管理和任务间的通信和同步等基本功能。没有提供输入输出管理，文件系统，网络等额外的服务。但由于uC/OS-II良好的可扩展性和源码开放，这些非必须的功能完全 可以由用户自己根据需要分别实现。 uC/OS-II目标是实现一个基于优先级调度的抢占式的实时内核，并在这个内核之上提供最基本的系统服务，如信号量，邮箱，消息队列，内存管理，中断管理等。 uC/OS操作系统的组成 μC/OS-II可以大致分成核心、任务处理、时间处理、任务同步与通信，CPU的移植等5个部分。如下图：

2017中南大学人工智能实验报告

“人工智能”实验报告 专业： 班级： 学号： 姓名： 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)));

嵌入式操作系统实验报告

中南大学信息科学与工程学院实验报告 ：安磊 班级：计科0901 学号： 0909090310 指导老师：宋虹

目录 课程设计容 ----------------------------------- 3 uC/OS操作系统简介 ------------------------------------ 3 uC/OS操作系统的组成 ------------------------------ 3 uC/OS操作系统功能作用 ---------------------------- 4 uC/OS文件系统的建立 ---------------------------- 6 文件系统设计的原则 ------------------------------ 6 文件系统的层次结构和功能模块 --------------------- 6 文件系统的详细设计 -------------------------------- 8 文件系统核心代码 --------------------------------- 9 课程设计感想 ------------------------------------- 11 附录 -------------------------------------------------- 12

课程设计容 在uC/OS操作系统中增加一个简单的文件系统。 要求如下： (1)熟悉并分析uc/os操作系统 (2)设计并实现一个简单的文件系统 (3)可以是存放在存的虚拟文件系统，也可以是存放在磁盘的实际文件系统 (4)编写测试代码，测试对文件的相关操作：建立，读写等 课程设计目的 操作系统课程主要讲述的容是多道操作系统的原理与技术，与其它计算机原理、编译原理、汇编语言、计算机网络、程序设计等专业课程关系十分密切。 本课程设计的目的综合应用学生所学知识，建立系统和完整的计算机系统概念，理解和巩固操作系统基本理论、原理和方法，掌握操作系统开发的基本技能。 I．uC/OS操作系统简介 μC/OS-II是一种可移植的，可植入ROM的，可裁剪的，抢占式的，实时多任务操作系统核。它被广泛应用于微处理器、微控制器和数字信号处理器。 μC/OS 和μC/OS-II 是专门为计算机的嵌入式应用设计的，绝大部分代码是用C语言编写的。CPU 硬件相关部分是用汇编语言编写的、总量约200行的汇编语言部分被压缩到最低限度，为的是便于移植到任何一种其它的CPU 上。用户只要有标准的ANSI 的C交叉编译器，有汇编器、连接器等软件工具，就可以将μC/OS-II嵌入到开发的产品中。μC/OS-II 具有执行效率高、占用空间小、实时性能优良和可扩展性强等特点，最小核可编译至 2KB 。μC/OS-II 已经移植到了几乎所有知名的CPU 上。 严格地说uC/OS-II只是一个实时操作系统核，它仅仅包含了任务调度，任务管理，时间管理，存管理和任务间的通信和同步等基本功能。没有提供输入输出管理，文件系统，网络等额外的服务。但由于uC/OS-II良好的可扩展性和源码开放，这些非必须的功能完全可以由用户自己根据需要分别实现。 uC/OS-II目标是实现一个基于优先级调度的抢占式的实时核，并在这个核之上提供最基本的系统服务，如信号量，，消息队列，存管理，中断管理等。 uC/OS操作系统的组成 μC/OS-II可以大致分成核心、任务处理、时间处理、任务同步与通信，CPU的移植等5个部分。如下图：

实时操作系统报告

实时操作系统课程实验报告 专业：通信1001 学号：3100601025 姓名：陈治州 完成时间：2013年6月11日

实验简易电饭煲的模拟 一．实验目的： 掌握在基于嵌入式实时操作系统μC/OS-II的应用中，基于多任务的模式的编程方法。锻炼综合应用多任务机制，任务间的通信机制，内存管理等的能力。 二．实验要求： 1.按“S”开机，系统进入待机状态，时间区域显示当前北京时间，默认模式“煮饭”; 2.按“C”选择模式，即在“煮饭”、“煮粥”和“煮面”模式中循环选择； 3.按“B”开始执行模式命令，“开始”状态选中，时间区域开始倒计时，倒计时完成后进入“保温”状态，同时该状态显示选中，时间区域显示保温时间； 4.按“Q”取消当前工作状态，系统进入待机状态，时间区域显示北京时间，模式为当前模式； 5.按“X”退出系统，时间区域不显示。 6.煮饭时长为30，煮粥时长为50，煮面时长为40. 三．实验设计： 1.设计思路： 以老师所给的五个程序为基础，看懂每个实验之后，对borlandc的操作有了大概的认识，重点以第五个实验Task_EX为框架，利用其中界面显示与按键扫描以及做出相应的响应，对应实现此次实验所需要的功能。 本次实验分为界面显示、按键查询与响应、切换功能、时钟显示与倒计时模块，综合在一起实验所需功能。 2.模块划分图： （1）界面显示： Main（） Taskstart（） Taskstartdispinit（） 在TaskStartDispInit()函数中，使用PC_DispStr()函数画出界面。

（2）按键查询与响应： Main（） Taskstart（） 在TaskStart()函数中，用if (PC_GetKey(&key) == TRUE)判断是否有按键输入。然后根据key 的值，判断输入的按键是哪一个；在响应中用switch语句来执行对应按键的响应。 （3）切换功能： l计数“C”按 键的次数 M=l%3 Switch(m) M=0，1，2对应于煮饭，煮粥，煮面，然后使用PC_DispStr()函数在选择的选项前画上“@”指示，同时，在其余两项钱画上“”以“擦出”之前画下的“@”，注意l自增。 四.主要代码： #include "stdio.h" #include "includes.h" #include "time.h" #include "dos.h" #include "sys/types.h" #include "stdlib.h" #define TASK_STK_SIZE 512 #define N_TASKS 2 OS_STK TaskStk[N_TASKS][TASK_STK_SIZE]; OS_STK TaskStartStk[TASK_STK_SIZE]; INT8U TaskData[N_TASKS];

中南大学系统仿真实验报告

实验一MATLAB 中矩阵与多项式的基本运算 实验任务 1. 了解MATLAB命令窗口和程序文件的调用。 2 ?熟悉如下MATLAB的基本运算： ①矩阵的产生、数据的输入、相关元素的显示； ②矩阵的加法、乘法、左除、右除； ③特殊矩阵：单位矩阵、“ 1 ”矩阵、“0”矩阵、对角阵、随机矩阵的产生和运算； ④多项式的运算：多项式求根、多项式之间的乘除。 基本命令训练 1、>> eye(2) ans = 1 0 0 1 >> eye(4) ans = 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 2、>> ones(2) 1 1 ans =

1 1 >> ones(4) ans = 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 >> ones(2,2) ans = 1 1 1 1 >> ones(2,3) ans = 1 1 1 1 1 1 >> ones(4,3) ans = 1 1 1 1 1 1 1 1 1 1 1 1 3、>> zeros(2) ans =

0 0 0 0 >> zeros(4) ans = 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 >> zeros(2,2) ans = 0 0 0 0 >> zeros(2,3) ans = 0 0 0 0 0 0 >> zeros(3,2) ans = 0 0 0 0 00 4、随机阵>> rand(2,3) ans = 0.2785 0.9575 0.1576 0.5469 0.9649 0.9706 >> rand(2,3)

中南大学制造系统自动化技术实验报告整理

制造系统自动化技术 实验报告 学院：机电工程学院 班级：机制**** 姓名：张** 学号： *********** 指导教师：李** 时间： 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机器人组装工作站、视觉检测及传送工作站、激光打标工作站、堆垛机及立体仓储工作站。 ②画出该柔性自动化制造系统的物料传输系统结构简图；

中南大学 计算机体系结构实验报告

计算机体系结构课程设计 学院：信息科学与工程学院 专业班级： 指导老师： 学号： 姓名：

目录 实验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

中南大学操作系统年试卷

中南大学考试试卷 2010-2011学年一学期时间100分钟 专业年级信息安全1001级总分100分，占总评成绩70% 注：此页不做答题纸，请将答案写在答题纸上 一、单项选择题（本题24分，每小题2分） 1. 在设计分时操作系统，首先考虑的是（）；在设计实时操作系统，首先考虑的是（）； 在设计批处理系统，首先考虑的是（） A．灵活性和适应性； B.交互性和相应时间； C.周转时间和系统吞吐量； D.实时性和可靠性. 2. 特权指令是操作系统中只能在管态下执行的指令，而下列那一条指令不是特权指令 （） A．输入输出；B.置中断屏蔽；C.wait、signal操作；D.置程序状态字. 3. 在多道处理系统中，为充分利用各种资源，运行的程序应该具备的条件是（） A．适应于内存分配的；B.计算量大的；C.I/O量大的；D.计算型和I/O型均衡的. 4. 在单处理系统中实现并发技术后，（） A．各进程在某一时刻并行运行，CPU与外设并行工作； B. 各进程在一个时间段内并行运行，CPU与外设串行工作； C. 各进程在一个时间段内并行运行，CPU与外设并行工作； D. 各进程在某一时刻并行运行，CPU与外设串行工作. 5. 下面有关可交变分区管理中采取主存分配算法说法错误的是（） A．可变分区管理常采用的主存分配算法包括首次适应、最佳适应和最差适应等算法； B. 首次适应算法实现简单，但碎片过多使主存利用率降低； C. 最佳适应算法是很好的算法，但后到的较大作业很难得到满足； D. 最差适应算法会导致系统存在较多碎片. 6. 下列有关系统安全状态的叙述中，正确的是（） A 系统处于不安全状态一定会发生死锁； B. 系统处于不安全状态可能会发生死锁； C. 系统处于安全状态也可能会发生死锁； D. 不安全状态是死锁的一个特例. 7. 进程在其生命周期期间在三种基本状态中转换，下列哪一种状态是不会发生的？（） A．从执行态到等待态； B.从等待态到执行态； C.从就绪态到执行态； D.从执行到就绪态. 8. 下列叙述中正确的是（） A．在设备I/O中引用缓冲技术的目的是为了节省内存； B. 指令的地址结构和外存容量是决定续存作业地址空间的两个因素； C. 处于阻塞状态的进程被唤醒后，可直接进入运行状态； D. 在虚拟页式管理中，FIFO置换算法的内存利用率是较高的. 9. 下面不属于操作系统提供虚拟设备技术原因的是（） A．独占设备可作为共享设备来使用； B. 独占设备的静态分配技术既不能充分利用设备，又不利于提高系统效率； C. 在一定的硬件和软件条件的基础上共享设备可以部分或全部地模拟独占设备的 工作，提高独占设备的利用率和系统效率；

算法实验报告

算法分析与设计实验报告 学院：信息科学与工程学院 专业班级： 指导老师： 学号： 姓名：

目录 实验一：递归与分治 (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 using namespace std; int num; void swap(int &a,int &b) { int temp=a; a=b; b=temp; } void printarray(int *arr) { for (int i=1;i<=num;++i) cout<

嵌入式实时操作系统实验报告

嵌入式实时操作系统实验报告 任务间通信机制的建立 系别计算机与电子系 专业班级***** 学生姓名****** 指导教师 ****** 提交日期 2012 年 4 月 1 日

一、实验目的 掌握在基于嵌入式实时操作系统μC/OS-II的应用中，任务使用信号量的一般原理。掌握在基于优先级的可抢占嵌入式实时操作系统的应用中，出现优先级反转现象的原理及解决优先级反转的策略——优先级继承的原理。 二、实验内容 1.建立并熟悉Borland C 编译及调试环境。 2.使用课本配套光盘中第五章的例程运行（例5-4,例5-5，例5-6），观察运行结果，掌握信号量的基本原理及使用方法，理解出现优先级反转现象的根本原因并提出解决方案。 3.试编写一个应用程序，采用计数器型信号量（初值为2），有3个用户任务需要此信号量，它们轮流使用此信号量，在同一时刻只有两个任务能使用信号量，当其中一个任务获得信号量时向屏幕打印“TASK N get the signal”。观察程序运行结果并记录。 4. 试编写一个应用程序实现例5-7的内容，即用优先级继承的方法解决优先级反转的问题，观察程序运行结果并记录。 5.在例5-8基础上修改程序增加一个任务HerTask,它和YouTask一样从邮箱Str_Box里取消息并打印出来，打印信息中增加任务标识，即由哪个任务打印的；MyTask发送消息改为当Times为5的倍数时才发送，HerTask接收消息采用无等待方式，如果邮箱为空，则输出“The mailbox is empty”, 观察程序运行结果并记录。 三、实验原理 1. 信号量 μC/OS-II中的信号量由两部分组成：一个是信号量的计数值，它是一个16位的无符号整数（0 到65,535之间）；另一个是由等待该信号量的任务组成的等待任务表。用户要在OS_CFG.H中将OS_SEM_EN开关量常数置成1，这样μC/OS-II 才能支持信号量。

中南大学软件体系结构实验报告-实验1

实验1 UML实验 实验学时： 4 每组人数： 1 实验类型： 3 （1：基础性2：综合性3：设计性4：研究性） 实验要求： 1 （1：必修2：选修3：其它） 实验类别： 3 （1：基础2：专业基础3：专业4：其它） 一、实验目的 1. 学会安装和使用建模工具PowerDesigner，熟练使用PowerDesigner绘制常用的UML 图形，熟悉常用的UML建模符号； 2. 构建用例模型来描述软件需求，包括绘制用例图，撰写用例文档并制作用例检查矩阵； 3. 学习使用状态图描述对象的状态及转换； 4. 学习使用活动图为业务流程建模； 5. 学习使用顺序图描述对象之间的交互； 6. 学习类图的绘制； 7. 学习从系统需求中识别类，并构建相应的面向对象模型； 8. 学习使用PowerDesigner实现正向工程和逆向工程； 9. 学习使用组件图描述每个功能所在的组件位置以及它们之间的关系； 10. 学习使用部署图描述软件中各个组件驻留的硬件位置以及这些硬件之间的交互关系。 二、实验内容 1. 某酒店订房系统描述如下： (1) 顾客可以选择在线预订，也可以直接去酒店通过前台服务员预订； (2) 前台服务员可以利用系统直接在前台预订房间； (3) 不管采用哪种预订方式，都需要在预订时支付相应订金； (4) 前台预订可以通过现金或信用卡的形式进行订金支付，但是网上预订只能通过信用卡进行支付； (5) 利用信用卡进行支付时需要和信用卡系统进行通信； (6) 客房部经理可以随时查看客房预订情况和每日收款情况。 绘制该酒店订房系统的用例图。 2. 根据以下场景绘制用例图： 某企业为了方便员工用餐，为企业餐厅开发了一个订餐系统（COS：Cafeteria Ordering System），企业员工可通过企业内联网使用该系统。该系统功能描述如下：

操作系统-课程设计

课程设计说明书（操作系统） 题目：进程调度 院系：计算机科学与工程学院 专业班级：信息安全13-2 学号：20133029xx 学生姓名：xx 指导教师：xx 2015年12月15日

安徽理工大学课程设计（论文）任务书计算机科学与工程学院

安徽理工大学课程设计（论文）成绩评定表

摘要 现代计算机系统中，进程是资源分配和独立运行的基本单位，是操作系统的核心概念。因而，进程就成为理解操作系统如何实现系统管理的最基本，也是最重要的概念。进程调度是进程管理过程的主要组成部分，是必然要发生的事件。 在现代操作系统中，进程的并发机制在绝大多数时候，会产生不断变化的进程就绪队列和阻塞队列。处于执行态的进程无论是正常或非正常终止、或转换为阻塞状态，都会引发从就绪队列中，由进程调度选择一个进程进占CPU。 进程调度的核心是进程调度的算法．在本课程设计中，用良好清晰的界面向用户展示了进程调度中的时间片轮转调度算法。在最终实现的成果中，用户可指定需要模拟的进程数，CPU时间片和进程的最大执行时间，并且选择需要演示的算法，界面将会动态的显示进程调度过程及各个队列的变化。通过此进程调度模拟系统，用户可以对时间片轮转调度算法有进一步以及直观的了解。 关键词:进程，调度，PCB，时间片轮转

目录 1.设计目的 (6) 2.设计思路 (6) 3.设计过程 (8) 3.1流程图 (8) 3.2算法 (8) 3.3数据结构 (10) 3.4源代码 (10) 4.实验结果及分析 (20) 4.1 使用说明 (20) 4.2程序演示 (20) 5.实验总结 (24) 6.参考文献 (24)

操作系统实验报告

实验报告 实验课程名称：操作系统 实验地点：南主楼七楼机房 2018—2019学年（一）学期 2018年 9月至 2019 年 1 月 专业： 班级： 学号： 姓名： 指导老师：刘一男

实验一 实验项目：分时系统模拟 实验学时：2实验日期： 2018-10-25 成绩： 实验目的利用程序设计语言模拟分时系统中多个进程按时间片轮转调度算法进行进程调度的过程； 假设有五个进程A，B，C，D，E，它们的到达时间及要求服务的时间分别为：进程名 A B C D E 到达时间0 1 2 3 4 服务时间 4 3 4 2 4 时间片大小为1，利用程序模拟A，B，C，D，E五个进程按时间片轮转的调度及执行过程并计算各进程的周转时间及带权周转时间。 执行过程并计算各进程的周转时间及带权周转时间。 轮转调度：BDACE

（1）修改时间片大小为2，利用程序模拟A，B，C，D，E五个进程按时间片轮转的调度及执行过程并计算各进程的周转时间及带权周转时间。 轮转调度：ADBCE （2）修改时间片大小为4，利用程序模拟A，B，C，D，E五个进程按时间片轮转的调度及执行过程并计算各进程的周转时间及带权周转时间.

顺序：ABCDE 1、思考 时间片的大小对调度算法产生什么影响？对计算机的性能产生什么影响？答：通过对时间片轮转调度算法中进程最后一次执行时间片分配的优化,提出了一种改进的时间片轮转调度算法,该算法具有更好的实时性,同时减少了任务调度次数和进程切换次数,降低了系统开销,提升了CPU的运行效率,使操作系统的性能得到了一定的提高。 A B C D E 时间片为1 周转时间12 9 14 8 13 3 3 3.5 4 3.25 带权周转 时间 时间片为2 周转时间8 12 13 7 13 2 4 3.25 3.5 3.25 带权周转 时间 时间片为4 周转时间 4 6 9 10 13 1 2 2.25 5 3.25 带权周转 时间

中南大学操作系统课程设计

操作系统课程设计题目名称：银行家算法 姓名 学号 专业 班级 指导教师 编写日期

目录 第一章问题描述 (3) 1.1 课设题目重述 (3) 1.2 问题分析 (3) 1.3 实验环境 (3) 第二章系统设计 (4) 3.1 主要数据结构 (4) 3.2 银行家算法 (4) 3.3 安全性检查算法 (6) 3.4 银行家算法安全性序列分析之例 (7) 第三章源代码清单 (10) 3.1 函数清单 (10) 3.2 各函数的调用关系图 (12) 第四章运行结果测试与分析 (13) 4.1 程序的正常输出结果 (13) 4.2 程序的差错控制 (15) 第五章结论与心得 (18) [参考文献] (18)

第一章问题描述 1.1课设题目重述 设计目的：了解多道程序系统中，多个进程并发执行的资源分配。 设计要求：管理员可以把一定数量的作业供多个用户周转使用，为保证作业的安全，管理员规定：当一个用户对作业的最大需求量不超过管理员现有的资金就要接纳该用户；用户可以分期贷款，但贷款的总数不能超过最大需求量；当管理员现有的作业不能满足用户的所需数时，对用户的请求可以推迟支付，但总能使用户在有限的时间里得到请求。当用户得到所需的全部作业后，一定能在有限的时间里归还所有的作业。 1.2问题分析 银行家算法是最具有代表性的避免死锁的算法。我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。在死锁的避免中，银行家算法把系统状态分为安全状态和不安全状态，只要能使系统始终处于安全状态，便可以避免发生死锁。所谓安全状态，是指系统能按某种顺序为每个进程分配所需资源，直到最大需求，使每一个进程都可以顺利完成，即可找到一个安全资源分配序列。 所以我们需要解决问题有： 1)熟悉银行家算法的工作原理，明白如何判断系统处于安全状态，避 免死锁。 2)在Windows操作系统上，如何利用Win32 API编写多线程应用程序 实现银行家算法。 3)创建n个线程来申请或释放资源，如何保证系统安全，批准资源申 请。 4)通过Win32 API提供的信号量机制，实现共享数据的并发访问。1.3实验环境 操作系统：windows 8.1 实验语言：c++