天津理工大学 操作系统 存储器的分配与回收算法实现 实验报告

实验报告学院（系）名称：计算机与通信工程学院

【实验过程记录（源程序、测试用例、测试结果及心得体会等）】源程序:

MemoryBlock.java:

//内存块类，包含各种操作

public class MemoryBlock {

static final int BLOCK_SIZE = 4096;

private int baseBlock; //内存块基地址

private int blockNum; //大小

private boolean inUse; //是否已分配

private MemoryBlock prev, next;

public MemoryBlock(int blockNum) {

this.baseBlock = 0;

this.blockNum = blockNum;

inUse = false;

prev = null;

next = null;

}

public MemoryBlock(int base, int blockNum) {

this.baseBlock = base;

this.blockNum = blockNum;

inUse = false;

prev = null;

next = null;

}

public int getBlockNum() {

return blockNum;

}

public void setBlockNum(int blockNum) {

this.blockNum = blockNum;

}

public MemoryBlock getPrev() {

return prev;

}

public void setPrev(MemoryBlock prev) {

this.prev = prev;

public MemoryBlock getNext() {

return next;

}

public void setNext(MemoryBlock next) {

this.next = next;

}

public boolean inUse() {

return inUse;

}

public void setUse() {

inUse = true;

}

public void free() {

inUse = false;

}

public int getBaseBlock() {

return baseBlock;

}

public void setBaseBlock(int baseBlock) { this.baseBlock = baseBlock;

}

//分配内存块，如果可分配，则返回剩余内存块

public MemoryBlock allocate(int blockNum) { if(this.blockNum - blockNum>0) {

int newBase = baseBlock + blockNum;

int newBlock = this.blockNum-blockNum;

this.blockNum = blockNum;

setUse();

return new MemoryBlock(newBase, newBlock);

}

else if(this.blockNum - blockNum ==0) {

this.blockNum = 0;

}

return null;

}

//判断内存块是否能合并

public boolean merge(MemoryBlock memBlock) {

if(baseBlock+blockNum==memBlock.getBaseBlock()) {

setBlockNum(blockNum+memBlock.blockNum);

memBlock.setBaseBlock(0);

memBlock.setBlockNum(0);

return true;

}

else

return false;

}

@Override

public String toString() {

String inUse = null;

if(inUse())inUse = "已分配";

else inUse = "未分配";

return"内存块 [基地址=" + baseBlock + ", 大小=" + blockNum +

", " + inUse + "]";

}

}

MemoryTable.java:

//虚类MemTable，提供内存链表的各种基本方法

public abstract class MemoryTable {

//MemoryBlock链表表头

protected MemoryBlock memList;

public MemoryTable(int blockNum) {

memList = new MemoryBlock(0, blockNum);

}

//把newBlock插入到memBlock前面

public void insertBefore(MemoryBlock memBlock, MemoryBlock newBlock){

if(memBlock.getPrev() != null)

memBlock.getPrev().setNext(newBlock);

if(memList == memBlock)

memList = newBlock;

newBlock.setPrev(memBlock.getPrev());

newBlock.setNext(memBlock);

memBlock.setPrev(newBlock);

}

//在memBlock后插入newBlock

public void insert(MemoryBlock memBlock, MemoryBlock newBlock) { if(memBlock.getNext() != null)

memBlock.getNext().setPrev(newBlock);

newBlock.setNext(memBlock.getNext());

memBlock.setNext(newBlock);

newBlock.setPrev(memBlock);

}

//删除块的连接关系，但不释放块

public void remove(MemoryBlock memBlock) {

if(memBlock == memList)

memList = memBlock.getNext();

if(memBlock.getNext()!=null)

memBlock.getNext().setPrev(memBlock.getPrev());

if(memBlock.getPrev()!=null)

memBlock.getPrev().setNext(memBlock.getNext());

}

public void print() {

MemoryBlock memBlock = memList;

int i=0;

while(memBlock != null) {

System.out.print(i+" ");

System.out.println(memBlock);

i++;

memBlock = memBlock.getNext();

}

}

//合并邻接的空闲内存

public void merge(MemoryBlock newBlock) {

MemoryBlock memBlock = memList;

while(memBlock != null) {

if(!memBlock.inUse()) {

if(memBlock.merge(newBlock)) {

memBlock.setBlockNum( memBlock.getBlockNum() +

newBlock.getBlockNum());

remove(newBlock);

break;

}

if(newBlock.merge(memBlock)) {

newBlock.setBlockNum( newBlock.getBlockNum() + memBlock.getBlockNum());

break;

}

}

memBlock = memBlock.getNext();

}

}

//分配内存（抽象函数）

public abstract boolean allocate(int blockNum);

//释放内存（抽象函数）

public abstract boolean free(int baseBlock);

}

FirstFit.java:

public class FirstFit extends MemoryTable{

public FirstFit(int blockNum) {

super(blockNum);

}

@Override

public boolean allocate(int blockNum) {

MemoryBlock memBlock = memList;

while(memBlock!=null) {

if(!memBlock.inUse()) {

if(memBlock.getBlockNum()>blockNum) {

MemoryBlock newBlock = memBlock.allocate(blockNum);

insert(memBlock, newBlock);

return true;

}

else if(memBlock.getBlockNum()==blockNum) {

memBlock.setUse();

}

}

memBlock = memBlock.getNext();

}

return false;

}

//分配内存（类内使用）

void freeMemory(MemoryBlock freeBlock) {

MemoryBlock prev = freeBlock.getPrev();

MemoryBlock next = freeBlock.getNext();

freeBlock.free();

while(!prev.inUse() && (prev.merge(freeBlock))) {

prev.setBlockNum( prev.getBlockNum() +

freeBlock.getBlockNum());

remove(freeBlock);

freeBlock = prev;

if(freeBlock.getPrev()!=null)

prev = freeBlock.getPrev();

else return;

}

}

if(freeBlock.getNext()!=null) {

while(!next.inUse() && (freeBlock.merge(next))) {

freeBlock.setBlockNum ( next.getBlockNum() +

freeBlock.getBlockNum());

remove(next);

freeBlock = next;

if(freeBlock.getNext()!=null)

next = freeBlock.getNext();

else return;

}

}

}

@Override

public boolean free(int baseBlock) {

MemoryBlock memBlock = memList;

while(memBlock != null) {

if(memBlock.getBaseBlock() == baseBlock) {

freeMemory(memBlock);

return true;

}

memBlock = memBlock.getNext();

}

return false;

}

}

BestFit.java:

public class BestFit extends MemoryTable {

private MemoryBlock usedMemory;

public BestFit(int blockNum) {

super(blockNum);

usedMemory = null;

}

@Override

public boolean allocate(int blockNum) {

MemoryBlock memBlock = memList;

MemoryBlock minBlock = null;

for(;memBlock!=null; memBlock = memBlock.getNext()) { if(!memBlock.inUse()&&(memBlock.getBlockNum()>=blockNum)) { minBlock = memBlock;

break;

}

}

if(minBlock != null) {

remove(minBlock);

if(minBlock.getBlockNum()!=blockNum) {

MemoryBlock newBlock = minBlock.allocate(blockNum);

insertUnused(newBlock);

}

insertUsed(minBlock);

return true;

}

else

return false;

}

boolean freeMemory(MemoryBlock freeBlock) {

if(freeBlock != null) {

freeBlock.free();

removeUsed(freeBlock);

insertUnused(freeBlock);

return true;

}

return false;

}

@Override

public boolean free(int baseBlock) {

MemoryBlock memBlock = usedMemory;

while(memBlock != null) {

if(memBlock.getBaseBlock() == baseBlock) {

freeMemory(memBlock);

merge(memBlock);

return true;

}

memBlock = memBlock.getNext();

return false;

}

//在已分配链表删除

public void removeUsed(MemoryBlock memBlock) {

if(memBlock == usedMemory)

usedMemory = memBlock.getNext();

if(memBlock.getNext()!=null)

memBlock.getNext().setPrev(memBlock.getPrev());

if(memBlock.getPrev()!=null)

memBlock.getPrev().setNext(memBlock.getNext());

}

//插入未分配链表

void insertUnused(MemoryBlock newBlock) {

if(memList == null)

memList = newBlock;

else {

MemoryBlock memBlock = memList;

MemoryBlock preBlock = null;

while(memBlock!=null) {

if(newBlock.getBlockNum()<=memBlock.getBlockNum()) { insertBefore(memBlock, newBlock);

return;

}

preBlock = memBlock;

memBlock = memBlock.getNext();

}

insert(preBlock, newBlock);

}

}

//插入已分配链表

void insertUsed(MemoryBlock newBlock) {

if(usedMemory == null)

usedMemory = newBlock;

else {

MemoryBlock memBlock = usedMemory;

while(memBlock.getNext() != null)

memBlock = memBlock.getNext();

memBlock.setNext(newBlock);

newBlock.setPrev(memBlock);

}

}

public void print() {

super.print();

MemoryBlock memBlock = usedMemory;

int i=0;

while(memBlock != null) {

System.out.print(i+" ");

System.out.println(memBlock);

i++;

memBlock = memBlock.getNext();

}

}

}

WorstFit.java:

public class WorstFit extends MemoryTable {

//已分配链表

private MemoryBlock usedMemory;

public WorstFit(int blockNum) {

super(blockNum);

usedMemory = null;

}

@Override

public boolean allocate(int blockNum) {

MemoryBlock maxBlock = memList;

if(maxBlock.getBlockNum()

return false;

remove(maxBlock);

if(maxBlock.getBlockNum()!=blockNum) {

MemoryBlock newBlock = maxBlock.allocate(blockNum);

insertUnused(newBlock);

}

insertUsed(maxBlock);

return true;

}

boolean freeMemory(MemoryBlock freeBlock) {

if(freeBlock != null) {

freeBlock.free();

removeUsed(freeBlock);

insertUnused(freeBlock);

}

return false;

}

@Override

public boolean free(int baseBlock) {

//已分配链表

MemoryBlock memBlock = usedMemory;

while(memBlock != null) {

if(memBlock.getBaseBlock() == baseBlock) {

freeMemory(memBlock);

merge(memBlock);

return true;

}

memBlock = memBlock.getNext();

}

return false;

}

public void removeUsed(MemoryBlock memBlock) {

if(memBlock == usedMemory)

usedMemory = memBlock.getNext();

if(memBlock.getNext()!=null)

memBlock.getNext().setPrev(memBlock.getPrev());

if(memBlock.getPrev()!=null)

memBlock.getPrev().setNext(memBlock.getNext());

}

void insertUnused(MemoryBlock newBlock) {

if(memList == null)

memList = newBlock;

else {

MemoryBlock memBlock = memList;

MemoryBlock preBlock = null;

while(memBlock!=null) {

if(newBlock.getBlockNum()>=memBlock.getBlockNum()) { insertBefore(memBlock, newBlock);

return;

}

preBlock = memBlock;

memBlock = memBlock.getNext();

}

insert(preBlock, newBlock);

}

void insertUsed(MemoryBlock newBlock) {

if(usedMemory == null)

usedMemory = newBlock;

else {

MemoryBlock memBlock = usedMemory;

while(memBlock.getNext() != null)

memBlock = memBlock.getNext();

memBlock.setNext(newBlock);

newBlock.setPrev(memBlock);

}

}

public void print() {

super.print();

MemoryBlock memBlock = usedMemory;

int i=0;

while(memBlock != null) {

System.out.print(i+" ");

System.out.println(memBlock);

i++;

memBlock = memBlock.getNext();

}

}

}

测试用例:

Main.java:

public class Main {

public static void main(String[] args) {

testFirstFit();

System.out.println();

testBestFit();

System.out.println();

testWorstFit();

}

public static void testFirstFit() {

MemoryTable mem = new FirstFit(1024);

System.out.println("测试首次适应法:");

mem.allocate(512);

mem.allocate(256);

mem.allocate(128);

mem.print();

mem.free(768);

mem.print();

}

public static void testBestFit() {

MemoryTable mem = new BestFit(1024);

System.out.println("测试最佳适应法:");

mem.allocate(1);

mem.allocate(2);

mem.allocate(3);

mem.print();

mem.free(0);

mem.free(1);

mem.print();

}

public static void testWorstFit() {

MemoryTable mem = new WorstFit(1024);

System.out.println("测试最坏适应法:");

mem.allocate(1);

mem.allocate(2);

mem.allocate(3);

mem.print();

mem.free(0);

mem.free(3);

mem.print();

}

}

测试结果:

测试首次适应法:

分配 512 内存

分配 256 内存

分配 128 内存

内存单元:

0 内存块 [基地址=0, 大小=512, 已分配]

1 内存块 [基地址=512, 大小=256, 已分配]

2 内存块 [基地址=768, 大小=128, 已分配]

3 内存块 [基地址=896, 大小=128, 未分配]

释放 512 处内存

释放 768 处内存

内存单元:

0 内存块 [基地址=0, 大小=512, 已分配]

1 内存块 [基地址=512, 大小=512, 未分配]

测试最佳适应法:

分配 1 内存

分配 2 内存

分配 3 内存

内存单元:

0 内存块 [基地址=6, 大小=1018, 未分配]

0 内存块 [基地址=0, 大小=1, 已分配]

1 内存块 [基地址=1, 大小=2, 已分配]

2 内存块 [基地址=3, 大小=3, 已分配]

释放 0 处内存

释放 1 处内存

内存单元:

0 内存块 [基地址=0, 大小=3, 未分配]

1 内存块 [基地址=6, 大小=1018, 未分配]

0 内存块 [基地址=3, 大小=3, 已分配]

测试最坏适应法:

分配 1 内存

分配 2 内存

分配 3 内存

内存单元:

0 内存块 [基地址=6, 大小=1018, 未分配]

0 内存块 [基地址=0, 大小=1, 已分配]

1 内存块 [基地址=1, 大小=2, 已分配]

2 内存块 [基地址=3, 大小=3, 已分配]

释放 0 处内存

释放 3 处内存

内存单元:

0 内存块 [基地址=3, 大小=1021, 未分配]

1 内存块 [基地址=0, 大小=1, 未分配]

0 内存块 [基地址=1, 大小=2, 已分配]

心得体会:

1.使用类来进行一些方法的重用

2.释放内存时，根据不同的分配方法进行相邻的内存合并

3.链表应根据具体情况优化从而简化代码

操作系统-Linux课程实验报告

实验、 Linux Ubuntu的安装、创建新的虚拟机VMWare 实验 Shell编程 1.实验目的与内容 通过本实验，了解Linux系统的shell机制，掌握简单的shell编程技巧。 编制简单的Shell程序，该程序在用户登录时自动执行，显示某些提示信息,如“Welcome to Linux”, 并在命令提示符中包含当前时间、当前目录和当前用户名等基本信息。 2.程序源代码清单 #include<> #include int main(){ printf("Hello Linux\n"); int pid; int state; int pfd[2]; pipe(pfd); if (fork()==0){ printf("In the grep progress\n"); dup2(pfd[0],0); close(pfd[0]); close(pfd[1]); execlp("grep","grep","sh",0); perror("exelp grep error"); } esle if(fork()==0){ printf("In the ps progress\n"); dup2(pfd[1],1); close(pfd[0]); close(pfd[1]); execlp("ps","ps","-ef",0); perror("execlp ps -ef"); }

close(pfd[1]); close(pfd[0]); wait(&state); wait(&state); } 实验内核模块 实验步骤: (1).编写内核模块 文件中主要包含init_clock()，exit_clock()，read_clock()三个函数。其中init_clock()，exit_clock()负责将模块从系统中加载或卸载，以及增加或删除模块在/proc中的入口。read_clock()负责产生/proc/clock被读时的动作。 (2).编译内核模块Makefile文件 # Makefile under ifneq ($(KERNELRELEASE),) #kbuild syntax. dependency relationshsip of files and target modules are listed here. obj-m := else PWD := $(shell pwd) KVER ?= $(shell uname -r) KDIR := /lib/modules/$(KVER)/build all: $(MAKE) -C $(KDIR) M=$(PWD) modules clean: rm -rf .*.cmd *.o *. *.ko .tmp_versions *.symvers *.order endif 编译完成之后生成模块文件。 (3).内核模块源代码 #include #include #include #include #include #include #define MODULE #define MODULE_VERSION "" #define MODULE_NAME "clock" struct proc_dir_entry* my_clock; int read_clock(char* page, char** start, off_t off, int count, int* eof, void* data) { int len; struct timeval xtime;

天津理工大学编译原理期末考试试卷

天津理工大学考试试卷 ～2010学年度第二学期 《编译原理》期末考试试卷 课程代码： 0660116 试卷编号： 1-A 命题日期： 2010 年 6 月 15 日 答题时限： 120 分钟考试形式：闭卷笔试 大题号 一二三四 总分 一、单项选择题（请从4个备选答案中选择最适合的一项，每小题2分， 得 分 1 2 3 4 5 6 7 8 9 10 D C B D D B C B D C 1. 编译程序是对（） A. 汇编程序的翻译 B. 高级语言程序的解释执行 C. 机器语言的执行 D. 高级语言的翻译 2. 词法分析器的输出结果是（） A．单词的种别编码B．单词在符号表中的位置 C．单词的种别编码和自身值D．单词自身值 3. 在规范规约中，用（）来刻画可规约串。 A．直接短语 B．句柄 C．最左素短语 D．素短语 4. 与正规式(a* | b) * (c | d)等价的正规式是（） A．a* (c | d) | b(c | d) B．a* (c | d) * | b(c | d) * C．a* (c | d)| b* (c | d) D．(a | b) * c| (a | b) * d 含有Aα·，则在状态K时，仅当面临输入符号a∈FOLLOW(A)时，才采 5. 若项目集I K 取Aα·动作的一定是（） A．LALR文法 B．LR(0) 文法C．LR(1)文法 D．SLR(1)文法 6. 四元式之间的联系是通过（）实现的。

A. 指示器 B. 临时变量 C. 符号表 D. 程序变量 7．文法G ：S x Sx | y 所识别的语言是（ ） A ．xyx B ．(xyx) * C ．x n yx n (n ≥0) D ．x * yx * 8. 有一语法制导翻译如下所示： S b Ab {print “1”} A (B {print “2”} A a {print “3”} B Aa) {print “4”} 若输入序列为b(((aa)a)a)b ，且采用自下而上的分析方法，则输出序列为（ ） A ．32224441 B. 34242421 C ．12424243 D. 34442212 9．关于必经结点的二元关系，下列叙述不正确的是（ ） A ．满足自反性 B ．满足传递性 C ．满足反对称型 D ．满足对称性 10．错误的局部化是指（ ）。 A ．把错误理解成局部的错误 B ．对错误在局部范围内进行纠正 C ．当发现错误时，跳过错误所在的语法单位继续分析下去 D ．当发现错误时立即停止编译，待用户改正错误后再继续编译 二、判断题（每小题1分，共5分） 得 分 1. 文法G 的一个句子对应于多个推导，则G 是二义性的。（× ） 2. 动态的存储分配是指在运行阶段为源程序中的数据对象分配存储单元。（√ ） 3. 算符优先文法采用“移进－规约”技术，其规约过程是规范的。（ × ） 4. 删除归纳变量是在强度削弱以后进行。（ √ ） 5. 在目标代码生成阶段，符号表用于目标代码生成。（ × ） 5分，共15分） 得 分 1. 构造正规式(0∣1)* 00相应的正规式并化简。（共5分） （1）根据正规式，画出相应的NFA M （2分） I I 0 I 1 {x,1,2} {1,2,3} {1,2} {1,2,3} {1,2,3,4} {1,2} {1,2} {1,2,3} {1,2 } {1,2,3, {1,2,3,4} {1,2 } X 12 3 4 01

计算机操作系统实验课实验报告

实验报告 实验课程: 计算机操作系统学生姓名：XXX 学号：XXXX 专业班级：软件 2014年12月25日

目录 实验一熟悉Windows XP中的进程和线程.. 3实验二进程调度 (7) 实验三死锁避免—银行家算法的实现 (18) 实验四存储管理 (24)

实验一熟悉Windows XP中的进程和线程 一、实验名称 熟悉Windows XP中的进程和线程 二、实验目的 1、熟悉Windows中任务管理器的使用。 2、通过任务管理器识别操作系统中的进程和线程的相关信息。 3、掌握利用spy++.exe来察看Windows中各个任务的更详细信息。 三、实验结果分析 1、启动操作系统自带的任务管理器： 方法：直接按组合键Ctrl+Alt+Del，或者是在点击任务条上的“开始”“运行”，并输入“taskmgr.exe”。

2、调整任务管理器的“查看”中的相关设置，显示关于进程的以下各项信息，并 完成下表： 表一：统计进程的各项主要信息 3、启动办公软件“Word”，在任务管理器中找到该软件的登记，并将其结束掉。再

从任务管理器中分别找到下列程序：winlogon.exe、lsass.exe、csrss.exe、smss.exe，试着结束它们，观察到的反应是任务管理器无法结束进程， 原因是该系统是系统进程。 4、在任务管理器中找到进程“explorer.exe”，将之结束掉，并将桌面上你打开的所 有窗口最小化，看看你的计算机系统起来什么样的变化桌面上图标菜单都消失了、得到的结论explorer.exe是管理桌面图标的文件（说出explorer.exe进程的作用）。 5、运行“spy++.exe”应用软件，点击按钮“”，切换到进程显示栏上，查看进 程“explorer.exe”的各项信息，并填写下表： 进程：explorer.exe 中的各个线程

静态存储器扩展实验报告

静态存储器扩展实验报告告圳大学实验报深

微机原理与接口技术 课程名称： 静态存储器扩展实验实验项目名称： 信息工程学院学院： 专业：电子信息工程

指导教师：周建华 32012130334 学号：班级：电子洪燕报告人：班 2014/5/21 实验时间： 实验报告提交时间：2014/5/26 教务部制． 一．实验目的与要求： 1. 了解存储器扩展的方法和存储器的读/写。 2. 掌握CPU对16位存储器的访问方法。

二．实验设备 PC机一台，TD-PITE实验装置或TD-PITC实验装置一套，示波器一台。 三．实验原理VCC28A141WE27A122A1326A73A8254A6存储器是用来存储信息的A924A55A1123A46OE22A3762256A10218A2CS209A1部件，是计算机的重要组成部D719A010D618D011D517D112D416D213D315GND14管组成的是由MOS分，静态RAM触发器电路，每个触发器可以存放1位

信息。只要不掉电，所储存的信息就不会丢失。因此，静态RAM工作稳定，不要外加刷新电路，使用方便。 但一般SRAM 的每一个触发器是由6个晶体管组成，SRAM 芯片的集成度不会太高，目前较常用的有6116（2K×8位），图4.1 62256引脚图6268位）622532位。本验平台上选． 用的是62256，两片组成32K×16位的形式，共64K字节。 62256的外部引脚图如图4.1所示。 本系统采用准32位CPU，具有16位外部

数据总线，即D0、D1、…、D15，地址总线为BHE＃（＃表示该信号低电平有效）、BLE ＃、A1、A2、…、A20。存储器分为奇体和偶体，分别由字节允许线BHE＃和BLE＃选通。 存储器中，从偶地址开始存放的字称为规则字，从奇地址开始存放的字称为非规则字。处理器访问规则字只需要一个时钟周期，BHE＃和BLE＃同时有效，从而同时选通存储器奇体和偶体。处理器访问非规则字却需要

天津理工大学高等数学下册试题

天津理工高等数学试题 一、填空题 1.设sin z xyz 1,-=则 z yz x cos z xy ?=?-. 2.设L 为圆周22x y 4+= ，则对弧长曲线积分=12π? . 3.交换积分次序( )22 2y 410y 0x 2dy f x,y dx =dx y)dy ????. 4.方程2x y"4y'4y e -++=的一个特解是2x x e -212 . 二、选择题 1.函数( )2222x y 0f x,y 0x y 0 +≠=+=?在点（0，0）处A . A.连续 B.两个偏导数都存在，且为0 C.两个偏导数都存在，但不为0 D.全微分存在 2.设有空间区域2221:x y z 1,z 0Ω++≤≥； 2222:x y z 1,x 0,y 0,z 0Ω++≤≥≥≥,则C . A.12xdv 4xdv ΩΩ=?????? B.12 ydv 4ydv ΩΩ=?????? C.12zdv 4zdv ΩΩ=?????? D.12 xyzdv xyzdv ΩΩ=?????? 3.设∑为球面222x y z 1++=的外侧，则222 x dydz x y z ∑++?? 等于C . A.0 B. 22y z 1+≤?? C.43π D.22x z 1 +≤-?? 4.下列微分方程中，通解为()2x 12y e c cos x c sin x =+的方程是B .

A.y"4y'5y 0--= B.y"4y'5y 0-+= C.y"2y'5y 0-+= D.2x y"4y'5y e -+= 三、计算二重积分2y 2D e dxdy y ??.其中D 为3x y =与5x y =所围区域. 1e 12- 五、设y u y f 2x,x ??=? ??，f 具有二阶连续偏导数，求 22 11222223u 2y 2y y 2f f f f x y x x x ?''''''=+--??. 六、设()f x 是一个连续函数，证明： （1）()()22f x y xdx ydy ++是一个全微分；（2）()()()u 2201d f u du f x y xdx ydy 2??=++ ??? ?，其中22u x y =+. 证明：（1） ()()()( ) 222222222222222222f x y xdx ydy xf (x y )dx yf (x y )dy (xf (x y ))2xyf (x y )y (yf (x y ))(xf (x y ))2xyf (x y )x y f x y xdx ydy ++=+++?+'=+??+?+'=+=??∴++ （2） ()()22 u x y 2222002222111d f u du f u du f (x y )d(x y )2221f (x y )(2xdx 2ydy)f (x y )(xdx ydy).2 +??==++ ???=++=++?? 七、求：由曲面2222z 0,z y 1,x y 4== +=+=所围空间立体Ω的体积. 解： 22010V dxdydz d d dz 14d d dz 3πρρρθθρρπΩΩ ====????????? 是一个全微分。

静态存储器-实验报告

计算机科学与技术系 实验报告 专业名称计算机科学与技术 课程名称计算机组成与结构 项目名称静态随机存储器实验 班级 学号 姓名 同组人员无 实验日期 2015-10-24

一、实验目的与要求 掌握静态随机存储器RAM 工作特性及数据的读写方法 二、实验逻辑原理图与分析 2.1 实验逻辑原理图及分析 实验所用的静态存储器由一片6116(2K ×8bit)构成(位于MEM 单元)，如下 图所示。6116有三个控制线：CS(片选线)、OE(读线)、WE(写线)，当片选有效(CS=0)时，OE=0时进行读操作，WE=0时进行写操作，本实验将CS 常接地线。 由于存储器(MEM)最终是要挂接到CPU 上，所以其还需要一个读写控制逻辑，使得CPU 能控制MEM 的读写，实验中的读写控制逻辑如下图所示，由于T3的参与，可以保证MEM 的写脉宽与T3一致，T3由时序单元的TS3给出。IOM 用来选择是对I/O 还是对MEM 进行读写操作，RD=1时为读，WR=1时为写。 XMRD XIOR XIOW XMWR RD IOM WE T3 读写控制逻辑 实验原理图如下如所示，存储器数据线接至数据总线，数据总线上接有8 个LED 灯显示D7…D0的内容。地址线接至地址总线，地址总线上接有8个LED 灯显示A7…A0的内容，地址由地址锁存器(74LS273,位于PC&AR 单元)给出。数据开关(位于IN 单元)经一个三态门(74LS245)连至数据总线，分时给出地址和数据。地址寄存器为8位，接入6116的地址A7…A0，6116的高三位地址A10…A8接地，所以其实际容量为256字节。

天津理工大学编译原理期末考试试卷

1. 编译程序是对（ ） A. 汇编程序的翻译 B. 高级语言程序的解释执行 D.高级语言的翻译 2?词法分析器的输出结果是（ ） A .单词的种别编码 C ?单词的种别编码和自身值 B .单词在符号表中的位置 D .单词自身值 3.在规范规约中，用（ A .直接短语 ）来刻画可规约串。 B .句柄 C .最左素短语 D .素短语 4. 与正规式(a | b) (c | d)等价的正规式是( ) * * * * A . a (c | d) | b(c | d) B . a (c | d) | b(c | d) C. a (c | d) | b (c | d) D. (a | b) c| (a | b) d 5.若项目集I K 含有A 2009?2010学年度第二学期 《编译原理》 期末考试试卷 课程代码： 0660116试卷编号：1-A 命题日期： 2010年 6月 15日 答题时限： 120分钟 考试形式：闭卷笔试 得分统计表： 大题号 总分f -一一 -二二 -三 四 一、单项选择题（请从4个备选答案中选择最适合的一项，每小题 2分，共20 分） ?，则在状态K 时，仅当面临输入符号a FOLLOW （A ）时，才采取 A ?动作的一定是（ ） A. LALR 文法 B. LR （0）文法 C. LR （1）文法 D. SLR （1）文法 天津理工大学考试试卷

S b Ab {pri nt 1” A (B {pri nt 2” A a {pri nt 3” B Aa) {pri nt 4” A.指示器 B.临时变量 C.符号表 D.程序变量 7. 文法G: S x Sx | y 所识别的语言是（ ） * * * A. xyx B. （xyx ） C. x n yx n （n 》0） D. x yx 若输入序列为b （（（aa ）a ）a ）b,且采用自下而上的分析方法，则输出序列为（ ） A. B. 34242421 C. D. 9. 关于必经结点的二元关系，下列叙述不正确的是（ ） A .满足自反性 B .满足传递性 C.满足反对称型 D .满足对称性 10. 错误的局部化是指（ ）。 A .把错误理解成局部的错误 B.对错误在局部范围内进行纠正 C.当发现错误时，跳过错误所在的语法单位继续分析下去 D .当发现错误时立即停止编译，待用户改正错误后再继续编译 二、判断题（每小题1分，共5分） 得分 1. 文法G 的一个句子对应于多个推导，则 G 是二义性的。（X ） 2. 动态的存储分配是指在运行阶段为源程序中的数据对象分配存储单元。 （V ） 3. 算符优先文法采用“移进-规约”技术，其规约过程是规范的。 （X ） 4. 删除归纳变量是在强度削弱以后进行。（V ） 5. 在目标代码生成阶段，符号表用于目标代码生成。 （X ） 三、简答题（每小题5分，共15分） 得分 1. 构造正规式（0 I 1） 00相应的正规式并化简。（共5分） （1）根据正规式，画出相应的 NFA M （2分） （2）用子集法将NFA 确定化（2分） I I 0 I 1 1 8. 有一语法制导翻译如下所示：

存储器管理实验报告.docx

操作系统实验报告 存储器管理 学院电信学院 专业计算机科学与技术 班级 14级计科一班 实验题目动态分区分配 实验组别第三组 指导老师曹华

一、实验目的 了解动态分区分配方式中使用的数据结构和分配算法，并进一步加深对动态分区存储管理方式及其实现过程的理解。 二、实验内容 用Ｃ语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc()和回收过程free()。其中，空闲分区通过分区链来管理，在进行内存分配时，系统优先使用空闲区低端的空间。 请分别用首次适应算法和最佳适应算法进行内存块的分配和回收，要求每次分配和回收后显示出空闲内存分区链的情况。 三、实验主要仪器设备 软件环境：ＶＣ＋＋６编程环境 四、实验原理及设计方案 1.实验原理： 可变分区调度算法有：最先适应分配算法，循环首次适应算法，最佳适应算法，最坏适应算法。 首次适应算法（First-fit）：当要分配内存空间时，就查表，在各空闲区中查找满足大小要求的可用块。只要找到第一个足以满足要求的空闲块就停止查找，并把它分配出去； 如果该空闲空间与所需空间大小一样，则从空闲表中取消该项；如果还有剩余，则余下的部分仍留在空闲表中，但应修改区分大小和分区始址。 用户提出内存空间的申请：系统根据申请者的要求，按照一定的分配策略分析内存空间的使用情况，找出能满足请求的空闲区，分给申请者；当程序执行完毕或主动归还内存资源时，系统要收回它所占用的内存空间或它归还的部分内存空间。 最佳适应算法（Best-fit）：当要分配内存空间时，就查找空闲表中满足要求的空闲块，并使得剩余块是最小的。然后把它分配出去，若大小恰好合适，则直按分配；若有剩余块，则仍保留该余下的空闲分区，并修改分区大小的起始地址。 内存回收：将释放作业所在内存块的状态改为空闲状态，删除其作业名，设置为空，并判断该空闲块是否与其他空闲块相连，若释放的内存空间与空闲块相连时，则合并为同一个空闲块，同时修改分区大小及起始地址。 每当一个进程被创建时，内存分配程序首先要查找空闲内存分区链，从中寻找一个合适的空闲块进行划分，并修改空闲内存分区链，系统根据回收区的首址，从空闲区链中找到相应的插入点，此时出现如下四种情况： (１)回收区与插入点的前一个空闲区Ｆ１相邻接，此时可将回收区直接与Ｆ１合并，并修改Ｆ１的大小； (２)回收区与插入点的后一个空闲分区Ｆ２相邻接，此时可将回收区直接与Ｆ２合并，并用回收区的首址作为新空闲区的首址，大小为二者之和； (３)回收区同时与插入点的前后两个空闲分区邻接，此时需将三者合并； (４)回收区不与任何一个空闲区邻接，此时应建一新的表项 2.主要数据结构的说明 定义一个空闲区说明表结构

天津理工大学-数据库2014-2015期末考试试卷

2014 ～2015 学年度第二学期 《数据库系统概论》期末考试试卷 课程代码：0660096 试卷编号：命题日期：2015 年11 月22 日答题时限：120 分钟考试形式：闭卷笔试 一、单项选择题（请从4个备选答案中选择最适合的一项，每小题2分，共40分） 注意：须将本题答案写在下面的表格中，写在其它地方无效 1. 数据库系统与文件系统的根本区别在于（） A. 提高了系统效率 B. 方便了用户使用 C. 数据的结构化 D. 节省了存储空间 2. 数据库系统的核心是（） A．数据库B．数据库管理系统 C．数据模型D．软件工具 3.用二维表结构表示实体以及实体间联系的数据模型称为（） A．网状模型B．层次模型 C．关系模型D．面向对象模型 4. 数据库的概念模型独立于（） A．具体的机器和DBMS B．E-R图

C．信息世界D．现实世界 5. 层次型、网状型和关系型数据库划分原则是（） A．记录长度B．文件的大小 C．联系的复杂程度D．数据之间的联系 6.设在某个公司环境中，一个部门有多名职工，一名职工只能属于一个部门，则部门与职工之间的联系是（） A. 一对一 B. 一对多 C. 多对多 D. 不确定 7．在数据库的三级模式结构中，描述数据库中全体数据的全局逻辑结构和特征的是（）A．外模式B．内模式C．存储模式D．模式 8.在数据库结构中，保证数据库独立性的关键因素是（） A．数据库的逻辑结构B.数据库的逻辑结构、物理结构 C．数据库的三级结构D.数据库的三级模式和两级映像。 9．关系模型中，一个关键字是（） A．可由多个任意属性组成B．至多由一个属性组成 C．可由一个或多个其值能惟一标识该关系模式中任何元组的属性组成 D．以上都不是 10．同一个关系模型的任两个元组值（） A．不能全同B．可全同C．必须全同D．以上都不是 11. 有关系：R(A, B, C)，主码＝A；S(D, A)，主码＝D，外码＝A（参照于R）。关系R和S 的元组如表1、表2所示，指出关系S中违反关系完整性规则的元组是（）表1 R 表2 S A．A（1，2）B．（2，Null）C．（3，3）D．（4，1） 12．有一个关系：学生（学号，姓名，系别），规定学号的值域是8个数字组成的字符串，这一规则属于（） A. 实体完整性约束 B. 参照完整性约束 C.用户自定义完整性约束 D. 关键字完整性约束 13. 现有如下关系：患者（患者编号，患者姓名，性别，出生日期，所在单位）医疗（患者编号，医生编号，医生姓名，诊断日期，诊断结果）其中，医疗关系中的外码是（） A. 患者编号 B. 患者姓名

操作系统课程设计实验报告

河北大学工商学院 课程设计 题目：操作系统课程设计 学部信息学部 学科门类电气信息 专业计算机 学号2011482370 姓名耿雪涛 指导教师朱亮 2013 年6月19日

主要内容 一、设计目的 通过模拟操作系统的实现，加深对操作系统工作原理理解，进一步了解操作系统的实现方法，并可练习合作完成系统的团队精神和提高程序设计能力。 二、设计思想 实现一个模拟操作系统，使用VB、VC、CB等windows环境下的程序设计语言，以借助这些语言环境来模拟硬件的一些并行工作。模拟采用多道程序设计方法的单用户操作系统，该操作系统包括进程管理、存储管理、设备管理、文件管理和用户接口四部分。 设计模板如下图： 注：本人主要涉及设备管理模块

三、设计要求 设备管理主要包括设备的分配和回收。 ⑴模拟系统中有A、B、C三种独占型设备，A设备1个，B设备2个，C设备2个。 ⑵采用死锁的预防方法来处理申请独占设备可能造成的死锁。 ⑶屏幕显示 注：屏幕显示要求包括：每个设备是否被使用，哪个进程在使用该设备，哪些进程在等待使用该设备。 设备管理模块详细设计 一、设备管理的任务 I/O设备是按照用户的请求，控制设备的各种操作，用于完成I/O 设备与内存之间的数据交换（包括设备的分配与回收，设备的驱动管理等），最终完成用户的I/O请求，并且I/O设备为用户提供了使用外部设备的接口，可以满足用户的需求。 二、设备管理函数的详细描述 1、检查设备是否可用（主要代码） public bool JudgeDevice(DeviceType type) { bool str = false; switch (type) { case DeviceType.a: {

计算机组成原理存储器读写和总线控制实验实验报告

信息与管理科学学院计算机科学与技术 实验报告 课程名称：计算机组成原理 实验名称：存储器读写和总线控制实验 姓名：班级：指导教师：学号： 实验室：组成原理实验室 日期： 2013-11-22

一、实验目的 1、掌握半导体静态随机存储器RAM的特性和使用方法。 2、掌握地址和数据在计算机总线的传送关系。 3、了解运算器和存储器如何协同工作。 二、实验环境 EL-JY-II型计算机组成原理实验系统一套，排线若干。 三、实验内容 学习静态RAM的存储方式，往RAM的任意地址里存放数据，然后读出并检查结果是否正确。 四、实验操作过程 开关控制操作方式实验 注：为了避免总线冲突，首先将控制开关电路的所有开关拨到输出高电平“1”状态，所有对应的指示灯亮。 本实验中所有控制开关拨动，相应指示灯亮代表高电平“1”，指示灯灭代表低电平“0”。连线时应注意：对于横排座，应使排线插头上的箭头面向自己插在横排座上；对于竖排座，应使排线插头上的箭头面向左边插在竖排座上。 1、按图3－1接线图接线： 图3－1 实验三开关实验接线 2、拨动清零开关CLR，使其指示灯显示状态为亮—灭—亮。 3、往存储器写数据：

以往存储器的（FF ） 地址单元写入数据“AABB ”为例，操作过程如下： 4、按上述步骤按表3－2所列地址写入相应的数据 表3－2 5、从存储器里读数据： 以从存储器的（FF ） 地址单元读出数据“AABB ”为例，操作过程如下： (操作) (显示) (操作) (显示) (操作) (显6、按上述步骤读出表3－2数据，验证其正确性。 五、实验结果及结论 通过按照实验的要求以及具体步骤，对数据进行了严格的检验，结果是正确的，具体数据如图所示：

天津理工大学_操作系统_存储器的分配与回收算法实现_实验报告

实验报告学院（系）名称：计算机与通信工程学院

【实验过程记录（源程序、测试用例、测试结果及心得体会等）】源程序: MemoryBlock.java: //内存块类，包含各种操作 public class MemoryBlock { static final int BLOCK_SIZE = 4096; private int baseBlock; //内存块基地址 private int blockNum; //大小 private boolean inUse; //是否已分配 private MemoryBlock prev, next; public MemoryBlock(int blockNum) { this.baseBlock = 0; this.blockNum = blockNum; inUse = false; prev = null; next = null; } public MemoryBlock(int base, int blockNum) { this.baseBlock = base; this.blockNum = blockNum; inUse = false; prev = null; next = null; } public int getBlockNum() { return blockNum; } public void setBlockNum(int blockNum) { this.blockNum = blockNum; } public MemoryBlock getPrev() { return prev; } public void setPrev(MemoryBlock prev) { this.prev = prev;

天津理工大学 2007-2008 学年度第1 学期 《电磁场理论》 期末考试试卷

2007 ～ 2008 学年度第 一 学期 《电磁场理论》 期末考试试卷 课程代码： 0562020 试卷编号： 5－A 命题日期： 2007 年 11 月 22 日 答题时限： 120 分钟 考试形式：闭卷笔试 得分统计表： 一、单项选择题（请从4个备选答案中选择最适合的一项，每小题2分，共30分） 1. （ D ）矢量 的单位方向矢量为_______________。 A ．（1，2，2） B ．（ ， ， ） C ．（ ， ， ） D ．（ ， ， ） 2. （ B ）下面关于电介质描述正确的是________。 A ．其分子分为有极分子和无极分子，因此在宏观上显示出电特性 B ．在外电场作用下发生极化，其中的总电偶极矩不为零，产生了一个附加电场 C ．极化后产生的附加电场能够抵消外加电场 D ．极化后产生的极化电荷只能分布于介质表面 3. （ C ）下面关于时变场的正确表述为____________。 A.时变场是无旋场 B.时变场是保守场 C.时变场是有旋场 D.时变场是无源场 4. （ B ）在静电场中，电场强度E 与电位?的关系为________________。 A ．E ?=?? B ．E ?=? C ．E ?=?? D ．2 E ?=? 5. （ A ）关于磁感应强度的正确关系是______________。

A ．0 B ??= B ．0B ??= C ．0=?B D ．02=?B 6. （ C ）磁矢位的方向与磁感应强度的方向__________。 A ．相反 B ．互相平行 C ．互相垂直 D ．共线 7. （ B ）点电荷q 对不接地球面导体(点电荷q 位于球面外)的镜像电荷有__________个。 A ．1 B ．2 C ．3 D ．4 8. （ A ）在真空中，位于'r 处的电流密度() 'J r 在r 处产生的磁矢位() A r 为_________， 其中'R r r =-。 A ．()()0 ' 4V J r A r dV R μπ =? B ．()()0 '14V J r A r dV R πμ=? C ．()()0 '4V J r A r dS R μπ=?? D ．()()0 '4V J r A r dS R μ π=?? 9. ( D )对趋肤深度描述正确的是_______。 A ． 趋肤深度是电磁场进入媒质的最大深度 B ． 趋肤深度越大衰减常数也越大 C ． 电磁场强度越大趋肤深度越大 D ． 通常它与电磁波的频率有关 10. （ D ）已知媒质的介电常数为'''j εεε=-，该媒质的损耗正切为______。 A. '''εε B. ''tan 'εε C. 'tan ''εε D. ''' εε 11. （ B ）密度为s ρ的电荷均匀分布在平面432=+-z y x 上，则含有原点那一侧的电场 。 A ． m V e e e E z y x s /)1432(20 +-=ερ B ．m V e e e E z y x s /)1432(20 -+-=ερ C ．m V e e e E z y x s /)1432(0 +-=ερ D ． m V e e e E z y x s /)1432(0 -+-=ερ 12. （B ）下面关于电磁场边界条件的错误表述为 。 A. 分界面两侧，电场的切向分量连续 B. 分界面两侧，电场的法向分量连续 C. 分界面两侧，磁场的法向分量连续 D. 分界面不存在电流时，磁场的切向分量连续 13. （ D ）一点电荷q +位于（0，δ，0），另一点电荷q -位于（δ，δ，0），这两个点电 荷可以看成为一个偶极子，其偶极矩p =________。 A ．2q δ B ．q δ C ．x q e δ D ．x q e δ- 14. （ D ）对电磁波相速度描述正确的是_______。 A ．相速度总是大于群速度 B ．它是电磁能传播的速度

操作系统实验报告

操作系统教程 实 验 指 导 书 姓名： 学号： 班级：软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的循环次数：

天津理工大学考试试卷 - 天津理工大学教务处

2010～2011学年度第二学期 《大学英语I》期末考试试卷 课程代码：试卷编号：命题日期：年月日答题时限：分钟考试形式：闭（开）卷笔试 Part I Listening Comprehension (20 Points, 1 Points for each) Section A Directions: In this section,…… 1. A) At a supermarket. B) At a department store. C) At an airport. D) At a restaurant. …… Section B Directions: In this section,…… Passage One Questions 11 to 15 are based on the passage you have just heard. 11.A) At a supermarket. B) At a department store. C) At an airport. D) At a restaurant. ……

Part II Reading Comprehension (30 Points, 1 Points for each) …… Passage One Questions 21 to 25 are based on the following passage. 21. A) At a supermarket. B) At a department store. C) At an airport. D) At a restaurant. …… Passage Two Questions 26 to 30 are based on the following passage. …… Passage Three Questions 31 to 35 are based on the following passage. …… Part III Translation (20 Points, 2Points for each) Section A (10 points) Directions: Translate the following phrases into English. 36.前进 …… Section B (10 points) Directions: Translate the following phrases into Chinese. 41.当地政府负责运动会的安全。 …… Part IV Cloze (10 Points, 0.5 Points for each) ……

操作系统实验报告心得体会

操作系统实验报告心得体会 每一次课程设计度让我学到了在平时课堂不可能学到的东西。所以我对每一次课程设计的机会都非常珍惜。不一定我的课程设计能够完成得有多么完美,但是我总是很投入的去研究去学习。所以在这两周的课设中,熬了2个通宵,生物钟也严重错乱了。但是每完成一个任务我都兴奋不已。一开始任务是任务,到后面任务就成了自己的作品了。总体而言我的课设算是达到了老师的基本要求。总结一下有以下体会。 1、网络真的很强大,用在学习上将是一个非常高效的助手。几乎所有的资料都能够在网上找到。从linux虚拟机的安装,到linux的各种基本命令操作,再到gtk的图形函数,最后到文件系统的详细解析。这些都能在网上找到。也因为这样,整个课程设计下来,我浏览的相关网页已经超过了100个(不完全统计)。当然网上的东西很乱很杂,自己要能够学会筛选。 不能决定对或错的,有个很简单的方法就是去尝试。就拿第二个实验来说,编译内核有很多项小操作,这些小操作错了一项就可能会导致编译的失败,而这又是非常要花时间的,我用的虚拟机,编译一次接近3小时。所以要非常的谨慎,尽量少出差错,节省时间。多找个几个参照资料,相互比较,

慢慢研究,最后才能事半功倍。 2、同学间的讨论,这是很重要的。老师毕竟比较忙。对于课程设计最大的讨论伴侣应该是同学了。能和学长学姐讨论当然再好不过了,没有这个机会的话,和自己班上同学讨论也是能够受益匪浅的。大家都在研究同样的问题,讨论起来,更能够把思路理清楚,相互帮助,可以大大提高效率。 3、敢于攻坚,越是难的问题,越是要有挑战的心理。这样就能够达到废寝忘食的境界。当然这也是不提倡熬夜的,毕竟有了精力才能够打持久战。但是做课设一定要有状态,能够在吃饭,睡觉,上厕所都想着要解决的问题,这样你不成功都难。 4、最好在做课设的过程中能够有记录的习惯,这样在写实验报告时能够比较完整的回忆起中间遇到的各种问题。比如当时我遇到我以前从未遇到的段错误的问题,让我都不知道从何下手。在经过大量的资料查阅之后,我对段错误有了一定的了解,并且能够用相应的办法来解决。 在编程中以下几类做法容易导致段错误,基本是是错误地使用指针引起的 1)访问系统数据区,尤其是往系统保护的内存地址写数据,最常见就是给一个指针以0地址 2)内存越界(数组越界,变量类型不一致等) 访问到不属于你的内存区域

虚拟存储器管理实验报告

淮海工学院计算机科学系实验报告书 课程名：《操作系统》 题目：虚拟存储器管理 页面置换算法模拟实验 班级： 学号： 姓名：

一、实验目的与要求 1.目的： 请求页式虚存管理是常用的虚拟存储管理方案之一。通过请求页式虚存管理中对页面置换算法的模拟，有助于理解虚拟存储技术的特点，并加深对请求页式虚存管理的页面调度算法的理解。 2.要求： 本实验要求使用C语言编程模拟一个拥有若干个虚页的进程在给定的若干个实页中运行、并在缺页中断发生时分别使用FIFO和LRU算法进行页面置换的情形。其中虚页的个数可以事先给定（例如10个），对这些虚页访问的页地址流（其长度可以事先给定，例如20次虚页访问）可以由程序随机产生，也可以事先保存在文件中。要求程序运行时屏幕能显示出置换过程中的状态信息并输出访问结束时的页面命中率。程序应允许通过为该进程分配不同的实页数，来比较两种置换算法的稳定性。 二、实验说明 1．设计中虚页和实页的表示 本设计利用C语言的结构体来描述虚页和实页的结构。 在虚页结构中，pn代表虚页号，因为共10个虚页，所以pn的取值范围是0—9。pfn代表实页号，当一虚页未装入实页时，此项值为-1；当该虚页已装入某一实页时，此项值为所装入的实页的实页号pfn。time项在FIFO算法中不使用，在LRU中用来存放对该虚页的最近访问时间。 在实页结构中中，pn代表虚页号，表示pn所代表的虚页目前正放在此实页中。pfn代表实页号，取值范围（0—n-1）由动态指派的实页数n所决定。next是一个指向实页结构体的指针，用于多个实页以链表形式组织起来，关于实页链表的组织详见下面第4点。 2．关于缺页次数的统计 为计算命中率，需要统计在20次的虚页访问中命中的次数。为此，程序应设置一个计数器count，来统计虚页命中发生的次数。每当所访问的虚页的pfn项值不为-1，表示此虚页已被装入某实页内， 此虚页被命中，count加1。最终命中率=count/20*100%。 3．LRU算法中“最近最久未用”页面的确定 为了能找到“最近最久未用”的虚页面，程序中可引入一个时间计数器countime，每当要访问 一个虚页面时，countime的值加1，然后将所要访问的虚页的time项值设置为增值后的当前