操作系统课程设计范文样本.doc

学 号：
2

课 程 设 计

课 程
计算机操作系统
题 目
模仿设计存储管理分派与回收
学 院
计算机科学与技术学院
专 业
计算机科学与技术
班 级
计算机1404
姓 名
王承禹
指引教师
王红霞

年
12
月
27
日

目录

1需求分析 2
1.1 任务描述 2
1.2系统功能需求 2
2 功能设计 3
2.1 算法分析 3
2.2 数据构造 4
2.2.1 页表构造 4
2.3模块阐明 4
2.3.1 内存模块 4
2.3.2 进程模块 5
2.3.3 主控模块 5
2.3.4 错误解决模块 6
3 开发平台 7
3.1开发平台 7
4 运营成果与运营状况分析 7
4.1初始界面以及功能选项 7
4.2内存状况 7
4.3进程页表信息 8
5 自我评价与总结 9
6 核心代码 9
4.1内存模块代码 10
4.2进程模块代码 13
4.3主控模块代码 14
6 成绩评估表 16

模仿设计页式存储管理分派与回收

1需求分析

1.1 任务描述
页式管理页式管理是一种内存空间存储管理技术，分为静态页式管理和动态页式管理。模仿动态页式管理，祈求调页技术，将各进程虚拟空间划提成若干个长度相等页，将内存划提成若干长度相等页框。并且能完毕逻辑地址到物理地址转换。模仿虚拟存储器工作。

1.2系统功能需求
（1）可以输入给定内存页面数，页面大小，进程个数及每个进程页数。
（2）当某进程提出申请空间大小后，显示能否满足申请，以及为该进程分派资源后 内存空间使用状况（被进程占用页面，空闲页面）。
（3）当某进程撤除时，显示内存回收后内存空间使用状况。
（4）实现缺页中断解决。

2 功能设计

2.1 算法分析
一方面，祈求表给出进程或作业规定页面数。然后，由存储页面表检查与否有足够空闲页面，如果没有，则本次无法分派。如果有则一方面分派设立页表，并祈求表中相应表项后，按一定查找算法搜索出所规定空闲页面，并将相应页好填入页表中。
页面分派算法如图2.1所示。

剩余页面数>=N？
祈求n个页面

设立页表，将页面始址，页表长度置入祈求表，状态置为已分派

无法分派

搜索空闲页面表，分派N个页面，并将页面号填入页表

返回

图2.1 页面分派算法流程图

2.2 数据构造
页式管理把内存空间按页大小划提成片或者页面,再按照一定规律建立起页表

2.2.1 页表构造
struct Page {
Process* processPtr； //进程指针
int* memoryPage； //内存页号
bool* valid； //页与否有效
int size； //有用页个数
int pageSize;
};
2.3模块阐明
采用了面向对象设计办法，将模块分为内存模块、进程模块与主控模块。下面简要
阐明各个模块接口与数据定义。

2.3.1 内存模块

class Memory {
private:
double allNum=1;//访问总次数
double missNum = 0;//不命中次数
Process** processPtr;//进程指针数组
int* allocateTime； //页被分派时系统时间
bool* valid； //内存页数组，标志页与否可用
int freeSize； //空闲页数量
int pageSize = 2;
static Memory* instance;
Memory()；
public:
static Memory* getInstance();
int getPageNum();
void setPageNum(int Num);
int getPageSize();
void setPageSize(int Size);
Process* getProcess(int index)const； //获取进程指针
int getTime(int index)const； //获取系统时间
bool getValid(int index)const； //获取页与否可用
int getFreeSizse()const { return freeSize；} //获取内存空闲页数量
bool validIndex(int index)const； //index与否有效
int getEarliestPage()const； //获取最早进入内存页
void allocate(Process* ptr，int index)； //分派一种内存页给进程index
void allocateAll(Process* pr)； //为所有进程页分派内存页
void revoke()； //释放一页
void revoke(int mem)； //释放一页
void revokeProcess(Process* ptr)； //释放进程所有页
void printInfo()const； //内存页信息
};

2.3.2 进程模块

class Process {
private:
string name； //进程名
double size； //进程大小，单位为MB
int pageCount； //页数
Page* page； //进程页表
public:
Process(string nm，double sz)； //默认构造函数

string getName()const { return name；}//获取进程名
double getSize()const { return size；}
int getPageCount()const { return pageCount；}
Page* getPage()const { return page；}
void printInfo()const;//输出进程信息
};

2.3.3 主控模块

int main() {
Memory* memory = Memory::getInstance()； //内存指针
Process** process = new Process*[MAX_PROCESS_SIZE]； //进程指针数组
//初始化进程指针数组
for (int i = 0；i < MAX_PROCESS_SIZE；i++)
process[i] = NULL_PTR;
init();
int select = -1； //操作编号
do {
cout << "\n==================== 菜单 ====================" << endl;
cout << "1.创立进程\n2.分派进程所有页\n3.分派进程一页\n4.释放进程" << endl;
cout << "5.释放进程一页\n6.内存状态\n7.进程状态\n8.页表信息\n9.退出" << endl;
cout << "\n操作编号：";

//对的地输入编号
do {
cin >> select;
if (cin.fail()) badInput()； //输入流错误
else if (select < 1 || select > 9) cout << "\n操作编号错误!" << endl;
else break;
} while (true);
switch (select) {
case 1:op1(memory，process)；break;
case 2:op2(memory，process)；break;
case 3:op3(memory，process)；break;
case 4:op4(memory，process)；break;
case 5:op5(memory，process)；break;
case 6:op6(memory，process)；break;
case 7:op7(memory，process)；break;
case 8:op8(memory，process)；break;
case 9:break;
default:cout << "\n怎么会运营到这里?" << endl；break;
}
} while (select != 9);
return 0;
}

2.3.4 错误解决模块

class Error {
private:
string info； //异常信息
public:
Error() :info("Error：exception occured!") {}
Error(string i) :info(i) {}
string getInfo()const { return info；}
};

3 开发平台

3.1开发平台
（1） 操作系统：Windows10
（2） 开发语言：C++
（3） 开发环境：Visual Studio Community
本程序采用C++作为编程语言，用visual studio 进行开发。C++是C语言继承，它既可以进行C语言过程化程序设计，又可以进行以抽象数据类型为特点基于对象程序设计，还可以进行以继承和多态为特点面向对象程序设计。C++擅长面向对象程序设计同步，还可以进行基于过程程序设计。
4 运营成果与运营状况分析
4.1初始界面以及功能选项

4.2内存状况

4.3进程页表信息

5 自我评价与总结
（1） 本次实验中我以为完毕比较好工作有模块设计和编码以及分派算法实现。其中模块分为了内存、进程以及主控模块三某些。可以以便完毕内存分派算法转换，具备较高独立性，同步也可以以便完毕分页到分段转换，采用调度算法也有较高独立性。可见，一种模块独立性高系统，其变更与扩展都会变得十分容易。
另一方面，在页面置换算法选取上，我选取了先进先出算法，该算法易于实现，并且不命中率与随机置换算法不命中率都比较低，是比较抱负页面置换算法。
（2） 需求分析时对题目理解不完全对的，导致了实现系统功能不符合规定，例如，在内存中应当给每个进程分派一定数量块，而我实现中并没有这样做，而是一种进程最极端状况下可以占用所有内存，并且一种进程可以替代其她进程页面。这一点是由于没有完全理解实验规定和对页式虚拟存储器理解有误导致。同步这样也给系统带来了很大影响。我吸取到教训是，需求分析阶段就要弄清晰问题所在，在问题不明确状况下，不能贸然着手实现系统，否则实现系统讲没故意义。
（3） 本次设计中，在编写、调试、执行过程中，我熟悉了页式存储管理各个置换算法与分派办法，以及回收办法。同步，在实现系统过程中，我在需求分析阶段没有弄清晰问题，以至于系统功能有误，这都是较好经验和教训。

6核心代码

6.1内存模块代码
class Memory {
private:
double allNum=1;
double missNum = 0;
Process** processPtr;//进程指针数组
int* allocateTime； //页被分派时系统时间
bool* valid； //内存页数组，标志页与否可用
int freeSize； //空闲页数量
int pageSize = 2;
static Memory* instance;
Memory()；
public:
static Memory* getInstance();

int getPageNum();
void setPageNum(int Num);
int getPageSize();
void setPageSize(int Size);
Process* getProcess(int index)const； //获取进程指针
int getTime(int index)const； //获取系统时间
bool getValid(int index)const； //获取页与否可用
int getFreeSizse()const { return freeSize；} //获取内存空闲页数量
bool validIndex(int index)const； //index与否有效
int getEarliestPage()const； //获取最早进入内存页

void allocate(Process* ptr，int index)； //分派一种内存页给进程index
void allocateAll(Process* pr)； //为所有进程页分派内存页

void revoke()； //释放一页
void revoke(int mem)； //释放一页
void revokeProcess(Process* ptr)； //释放进程所有页

void printInfo()const； //内存页信息
};

//默认构造函数，私有
Memory::Memory() {
valid = new bool[pageNum];
processPtr = new Process*[pageNum];
allocateTime = new int[pageNum];
freeSize = pageNum;

//初始化：页标志、进程指针、分派时间
for (int i = 0；i < pageNum；i++) {
valid[i] = true;
processPtr[i] = NULL_PTR;
allocateTime[i] = -1;
}
}

int Memory::getPageNum()
{
return pageNum;
}
int Memory::getPageSize()
{
return pageSize;
}

void Memory::setPageNum(int Num)
{
pageNum = Num;
}

void Memory::setPageSize(int Size)
{
pageSize = Size;
}

Memory* Memory::instance = new Memory();
//获取单例
Memory* Memory::getInstance() {

return instance;
}

//获取进程指针
Process* Memory::getProcess(int index)const {
if (validIndex(index)) return processPtr[index];
else throw Error("Error：in Memory::getProcess()，错误下标!");
}

//获取系统时间
int Memory::getTime(int index)const {
if (validIndex(index)) return allocateTime[index];
else throw Error("Error：in Memory::getTime()，错误下标!");
}

//获取页与否可用
bool Memory::getValid(int index)const {
if (validIndex(index)) return valid[index];
else throw Error("Error：in Memory.getValid()，错误下标!");
}

//index与否有效
bool Memory::validIndex(int index)const {
if (index < 0 || index >= pageNum) return false;
else return true;
}

//获取最早进入内存页
int Memory::getEarliestPage()const {
int min = MAX_TIME； //最小分派时间
int pos = -1； //最早进入页
for (int i = 0；i < pageNum；i++) {
if (allocateTime[i] != -1 && allocateTime[i] < min) {
pos = i;
min = allocateTime[i];
}
}
return pos;
}

//分派内存页给进程页index
void Memory::allocate(Process* ptr，int index) {
Page* page = ptr->getPage();
if (page->getValid(index)) throw Error("Error：页已在内存中!");

if (freeSize <= 0) revoke()； //释放一页

//开始分派
for (int i = 0；i < pageNum；i++) {
if (valid[i]) { //找到空闲页
try {
//更新进程信息，也许抛出异常
page->allocate(index，i);

//更新内存信息
processPtr[i] = ptr;
allocateTime[i] = time++;
valid[i] = false;
freeSize--;

cout << "分派内存页 " << i << " 给进程 " << ptr->getName() << " 第 " << index << " 页." << endl;
break;
}
catch (Error e) {
cout << e.getInfo() << endl;
}
}
}
}

6.1进程模块代码
class Process {
private:
string name； //进程名
double size； //进程大小，单位为MB
int pageCount； //页数
Page* page； //进程页表
public:
Process(string nm，double sz)； //默认构造函数

//获取进程信息
string getName()const { return name；}
double getSize()const { return size；}
int getPageCount()const { return pageCount；}
Page* getPage()const { return page；}
//输出进程信息
void printInfo()const;
};

//默认构造函数
Process::Process(string nm，double sz) {
//if (sz <= 0 || sz >= pageNum) throw Error("Error：进程大小参数错误，构造失败!");
int nameSize = nm.size();
if (nameSize <= 0 || nameSize > MAX_NAME_SIZE) throw Error("Error：进程名长度错误，容许长度为 1~10 !");

name = nm;
size = sz;//进程大小
double temp = size - (int)size;
if (temp == 0) pageCount = size;
else pageCount = size + 1;
//新建页表
page = new Page(this，pageCount);
}

//输出进程信息
void Process::printInfo()const {
cout << "进程名：" << name << endl;
cout << "大小：" << size << endl;
cout << "页数：" << pageCount << endl;
}
#endif

6.2主控模块代码

int main() {
Memory* memory = Memory::getInstance()； //内存指针
Process** process = new Process*[MAX_PROCESS_SIZE]； //进程指针数组

//初始化进程指针数组
for (int i = 0；i < MAX_PROCESS_SIZE；i++)
process[i] = NULL_PTR;

init();
int select = -1； //操作编号
do {
cout << "\n==================== 菜单 ====================" << endl;
cout << "1.创立进程\n2.分派进程所有页\n3.分派进程一页\n4.释放进程" << endl;
cout << "5.释放进程一页\n6.内存状态\n7.进程状态\n8.页表信息\n9.退出" << endl;
cout << "\n操作编号：";

//对的地输入编号
do {
cin >> select;
if (cin.fail()) badInput()； //输入流错误
else if (select < 1 || select > 9) cout << "\n操作编号错误!" << endl;
else break;
} while (true);

switch (select) {
case 1:op1(memory，process)；break;
case 2:op2(memory，process)；break;
case 3:op3(memory，process)；break;
case 4:op4(memory，process)；break;
case 5:op5(memory，process)；break;
case 6:op6(memory，process)；break;
case 7:op7(memory，process)；break;
case 8:op8(memory，process)；break;
case 9:break;
default:cout << "\n怎么会运营到这里?" << endl；break;
}
getchar();
getchar();
} while (select != 9);
return 0;
}

成绩评估表
序号
评分项目
满分
实得分
1
学习态度认真、出勤状况
10

2
设计分析合理性
10

3
设计方案对的性、可行性、创造性、设计成果对的性
30

4
系统测试、运营状况
40

5
设计报告规范性
10

总得分