LINUX编程-实验五 内存管理实验

合集下载

实验五 Linux进程管理

实验五  Linux进程管理

实验五Linux进程管理一.实验目的:进行系统进程管理。

二.实验内容:1.进程状态查看;2.控制系统中运行的进程;3.安排一次性和周期性自动执行的后台进程;三.实验练习:任务一进程管理实验内容:查看系统中的进程;控制系统中的进程;安排计划任务。

实验步骤:1.使用ps命令查看和控制进程●显示本用户的进程:●显示所有用户的进程:。

●在后台运行cat命令:●查看进程cat :●杀死进程cat:。

●再次查看查看进程cat,看看是否被杀死。

2.使用top命令查看和控制进程●用top命令动态显示当前的进程。

●只显示用户user01的进程(利用u键)。

●利用k键,杀死指定进程号的进程。

3.挂起和恢复进程●执行命令cat。

●按Ctrl+z键,挂起进程cat。

●输入jobs命令,查看作业。

●输入bg,把cat切换到后台执行。

●输入fg,把cat切换到前台执行。

●按Ctrl+c键,结束进程cat。

4. 熟悉并使用at命令5.安排计划任务某系统管理员需每天做一定的重复工作,请按照下列要求,编制一个解决方案:(1)在下午4 :50删除/abc目录下的全部子目录和全部文件;(2)从早8:00~下午6:00每小时读取/xyz目录下x1文件中的全部数据加入到/backup目录下的bak01.txt文件内;(3)每逢星期一下午5:50将/data目录下的所有目录和文件归档并压缩为文件:backup.tar.gz;(4)在下午5:55将IDE接口的CD-ROM卸载(假设:CD-ROM的设备名为hdc);(5)在早晨8:00前开机后启动启动www服务器。

●查看crontab命令的帮助信息:●查看用户的计划任务列表:●生成一个crontab的脚本文件:●按照生成的脚本安排计划任务:●查看计划任务表,看看计划任务是否已被安排:●删除计划任务列表,并进行确认。

(4)Linux内存管理实验(2学时)

(4)Linux内存管理实验(2学时)

Linux内存管理实验
实验一打印进程的虚存区
实验内容:编写一个内核模块,打印进程的虚存区,其中通过模块参数把进程的PID传递给模块。

实验步骤:
1、编写模块p96.c。

程序见pptprogram/mm/module_p96/p96.c
2编译模块
3在后台运行某个程序,如p95.c对应的可执行程序,程序见pptprogram/mm/p95.c。

然后把程序的PID号作为参数插入p96模块,使其读出程序的虚存区如蓝色框中的内容。

4 查看/proc文件系统3552进程对应的虚存映射,
#cd /proc
#cd 3552
#cat maps 可以看到模块输出的信息和/proc文件系统中所读取的信息是一致的。

实验二物理内存分配举例编写模块p113.c。

程序见pptprogram/mm/module_adress /p113.c pptprogram/mm/module_adress /Makefile
编译、插入模块后的结果为:
请同学自己范围内各自分配的地址范围。

linux 基本操作 实验报告

linux 基本操作 实验报告

linux 基本操作实验报告《Linux基本操作实验报告》Linux操作系统是一款开源的操作系统,具有稳定性高、安全性强等特点,因此在服务器领域得到了广泛的应用。

对于初学者来说,熟悉Linux的基本操作是非常重要的,下面我将分享一份Linux基本操作的实验报告。

实验一:登录和退出Linux系统首先,我们需要了解如何登录和退出Linux系统。

在登录界面输入用户名和密码后,我们就可以进入系统。

在系统中,我们可以使用命令“exit”来退出系统。

实验二:文件和目录操作在Linux系统中,文件和目录的操作是非常重要的。

我们可以使用命令“ls”来查看当前目录下的文件和目录,使用命令“cd”来切换目录,使用命令“mkdir”来创建新的目录,使用命令“rm”来删除文件或目录。

实验三:文件编辑在Linux系统中,我们可以使用命令行工具来编辑文件。

比较常用的编辑器有vi和nano。

我们可以使用命令“vi”或“nano”来打开文件进行编辑,然后保存并退出。

实验四:用户和权限管理Linux系统中的用户和权限管理也是非常重要的。

我们可以使用命令“useradd”来添加新用户,使用命令“passwd”来修改用户密码,使用命令“chmod”来修改文件或目录的权限。

实验五:系统管理最后,我们还可以使用一些命令来管理系统。

比如使用命令“ps”来查看当前系统进程,使用命令“top”来查看系统资源占用情况,使用命令“shutdown”来关闭系统。

通过以上实验,我们可以初步了解Linux系统的基本操作。

当然,Linux系统还有很多其他的功能和命令,需要我们不断学习和实践。

希望大家能够通过实践不断提升自己的Linux操作技能,为今后的工作和学习打下坚实的基础。

Linux内存管理实验概要

Linux内存管理实验概要

Linux内存管理实验一、实验目的1. 通过在Linux环境下对内存管理的基本操作,感性认识Linux如何对内存进行管理。

2. 利用readelf和objdump观测linux下的内存地址映射过程以及进程的虚拟地址空间。

二、实验内容与要求(1)按照实验内容完成实验操作步骤,学习内存管理中的一些常用命令(2)理解linux中逻辑地址、线性地址的概念。

三、实验步骤与测试实验一free命令显示显示内存的使用情况(使用的和空闲的),包括物理内存、交换区内存、内核缓冲区内存。

不包括共享内存。

free命令默认选项为-k语法:free [-bkmotV] [-s <间隔秒数>]选项介绍:-b: 以Byte为单位显示内存使用情况;-k: 以KB为单位显示内存使用情况;-m: 以MB为单位显示内存使用情况;-o: 不显示缓冲区调节列;-s<间隔秒数>: 每间隔指定时间执行一次free命令;-t: 显示内存总和列;-V: 显示版本信息;(1)free -k: 以KB为单位显示内存使用情况;解释:total: 内存总量: 3355508(k)used: 已经使用的内存量: 490664(k)free: 空闲的内存量: 2864844(k)shared: 当前已经废弃不用,总量是0(k)buffers: 25164(k)Buffer Cache内存量: 263480(k)cached: Page Cache内存量: 21436(k)(2)free –m -s 5:以M为单位,5秒显示以下内存信息解释:以上为每隔5秒显示内存信息,由以上图可知:两次内存使用情况没有变化。

(3)free -o: 不显示缓冲区调节列;解释:由以上可知Buffer Cache这一列没有显示出来。

(4)free -t: 显示内存总和列;解释:如上所示,内存总和是3355508(k),内存已使用为491408(k),内存空闲为2864100(k)。

内存管理实验报告

内存管理实验报告

内存管理实验报告实验名称:内存管理实验目的:掌握内存管理的相关概念和算法加深对内存管理的理解实验原理:内存管理是操作系统中的一个重要模块,负责分配和回收系统的内存资源。

内存管理的目的是高效地利用系统内存,提高系统的性能和稳定性。

实验过程:1.实验环境准备本实验使用C语言编程,要求安装GCC编译器和Linux操作系统。

2.实验内容实验主要包括以下几个部分:a.基本内存管理创建一个进程结构体,并为其分配一定大小的内存空间。

可以通过C语言中的指针操作来模拟内存管理的过程。

b.连续分配内存算法实现两种连续分配内存的算法:首次适应算法和最佳适应算法。

首次适应算法是从低地址开始寻找满足要求的空闲块,最佳适应算法是从所有空闲块中选择最小的满足要求的块。

c.非连续分配内存算法实现分页和分段两种非连续分配内存的算法。

分页是将进程的虚拟地址空间划分为固定大小的页面,然后将页面映射到物理内存中。

分段是将进程的地址空间划分为若干个段,每个段可以是可变大小的。

3.实验结果分析使用实验中的算法和方法,可以实现对系统内存的高效管理。

通过比较不同算法的性能指标,我们可以选择合适的算法来满足系统的需求。

具体而言,连续分配内存算法中,首次适应算法适用于内存中有大量小碎片的情况,可以快速找到满足要求的空闲块。

最佳适应算法适用于内存中碎片较少的情况,可以保证最小的内存浪费。

非连续分配内存算法中,分页算法适用于对内存空间的快速分配和回收,但会带来一定的页表管理开销。

分段算法适用于对进程的地址空间进行分段管理,可以灵活地控制不同段的权限和大小。

实验中还可以通过性能测试和实际应用场景的模拟来评估算法的性能和适用性。

实验总结:本实验主要介绍了内存管理的相关概念和算法,通过编写相应的代码实现了基本内存管理和连续分配、非连续分配内存的算法。

通过实际的实验操作,加深了对内存管理的理解。

在实验过程中,我们发现不同算法适用于不同情况下的内存管理。

连续分配算法可以根据实际情况选择首次适应算法或最佳适应算法。

实验五 存储管理(实验报告格式)

实验五 存储管理(实验报告格式)

实验五:存储管理一、实验目的(1)熟悉内存空闲分区的分配方式;(2)理解动态分区存储管理方式;(3)掌握动态分区的分配与回收的过程。

二、实验环境微型计算机,Ubuntu Linux10.04 ,gedit,gcc三、实验内容根据流程图和参考程序,完成模拟内存分配和回收过程。

内存空间大小为100,进程数为5,每个进程所需空间为随机产生,大小为1~20,编制程序,首先对5个进程进行内存分配,然后回收指定的进程空间,并进行适当的空闲分区合并操作,要求每次操作结束后都能显示当前的内存分配情况。

四、实验结果截图一截图二截图三五、源代码#include<stdio.h>#include<malloc.h>typedef struct MEMORY_BLOCK{int name; //进程名int address; //起始地址int length; //长度int flag; //标志,表示该块是否被分配。

struct MEMORY_BLOCK *next; //指向下一个进程}MEMORY_BLOCK;#define NUM 5#define LEN sizeof(MEMORY_BLOCK)void allocation(MEMORY_BLOCK *Header,int name,int length_p){ MEMORY_BLOCK *temp,*t,*tt;int minsize=2; //不可切割的分区阈值while(t!=0){if(t->length>length_p&&t->flag==0) break;t=t->next;}if(t->length-length_p>minsize){ //分割temp=(MEMORY_BLOCK*)malloc(LEN);temp->name=-1;temp->flag=0;temp->length=t->length-length_p;temp->address=t->address+length_p;t->name=name;t->flag=1;t->length=length_p;temp->next=t->next;t->next=temp;}else{ //直接分配t->name=name;t->flag=1;}}void reclaim(int processname, MEMORY_BLOCK *Header){ MEMORY_BLOCK *temp,*t,*tt;temp=t;while(t->name!=processname){temp=t;t=t->next;}if(t->next!=NULL){ //t非尾结点if(temp->flag==0&&t->next->flag==0){ //左右为空temp->name=-1;temp->length=temp->length+t->length+t->next->length;tt=t->next;temp->next=tt->next;}else if(temp->flag==0){ //左为空temp->name=-1;temp->length=temp->length+t->length;temp->next=t->next;}else if(t->next->flag==0){ //右为空t->name=-1;t->length=t->length+t->next->length;t->flag=0;tt=t->next;t->next=tt->next;}else{ //左右不为空t->name=-1;t->flag=0;}else{ //t是尾结点if(temp->flag==0){ //左为空temp->name=-1;temp->length=temp->length+t->length;temp=t->next;}else{ //左不为空t->name=-1;t->flag=0;}}}void main(){ //主函数int length_p,i,processname;MEMORY_BLOCK *Header,*t;Header=(MEMORY_BLOCK*)malloc(LEN); //初始化存储空间Header->name=-1;Header->address=0;Header->length=100;Header->flag=0;Header->next=NULL;srand((int)time(0));for(i=1;i<=NUM+1;i++){length_p=rand()%20+1; //随机产生进程所需存储空间,至少为1allocation(Header,i,length_p);}printf("当前内存分配情况:\n");t=Header;while(t!=0){printf("process_name:%d,address:%d,length:%d,flag:%d\n",t->name,t->address,t->length,t->flag);t=t->next;}printf("请输入回收的进程号(输入0结束):\n");scanf("%d",&processname);while(processname!=0){printf("回收process name %d\n",processname);reclaim(processname,Header);printf("当前内存分配情况:\n");t=Header;while(t!=0){printf("process_name:%d,address:%d,length=%d,flag=%d\n", t->name, t->address, t->length,t->flag);t=t->next;}。

linux实验五 用户管理

linux实验五 用户管理

集美大学Linux系统管理课程实验报告课程名称:Linux系统管理班级:软件1115实验成绩:指导教师:范明红姓名:许云云实验项目名称:实验五:用户管理学号:2011813035上机实践日期:1.实验目的:1)熟悉Linux操作系统中的用户和组的概念。

2)掌握Linux操作系统中用户管理。

3)理解用户管理涉及的系统配置文件。

2.实验要点:1.认真阅读课本相关的内容,掌握相关指令的使用。

2. 理解系统管理中的用户管理的概念,掌握如何在Linux系统中管理用户和组。

3.实验准备:1 熟悉useradd(adduser)和userdel指令的使用2 熟悉groupadd和groupdel指令的使用3 熟悉passwd指令的使用4了解who、id、,finger,chfn,groups、whoami、newgrp指令的用法5 学习使用用户管理器管理用户4.实验内容:设置系统以字符界面方式启动:4.1用户管理1:使用useradd(adduser)指令添加名称为user1、user2、user3、user4的用户,分别为其设定密码。

2:使用userdel指令删除user4用户3.使用chfn指令添加用户的详细信息,并使用finger指令察看相关信息。

4.锁定user1用户,使其无法登陆。

(有2种方法)5.在其他终端使用用户user1、user2等登陆验证。

6.为user1解锁,使其能正常登陆。

方法一:使用usermod锁定:解锁:方法二:使用passwd锁定:解锁:4.2组管理。

1:使用groupadd指令添加user和group两个组2:使用groupdel指令删除group组3: 将用户user1、user2、user3添加到user组中。

4:指定user1为组管理员。

5.使用user1账户登陆,删除组内成员user3.6.更改user1账户的主组为user并验证。

4.3其他指令使用who、id、whoami、groups等指令1:使用who指令查看当前登陆系统的用户2:使用id指令查看当前用户的UID与GID3:使用whoami指令查看当前使用shell的用户名称4.4 打开用户管理配置文件/etc/passwd,/etc/shadow,/etc/group察看内容:查看/etc/passwd文件部分内容:查看/etc/ shadow文件部分内容:查看/etc/group文件部分内容:4.5 打开图形界面,使用用户管理器管理用户和组。

Linux的内存管理

Linux的内存管理

total Mem: 256024 −/+ buffers/cache: Swap: 522072
used 192284 80604
free 63740 75420
shared 0
buffers 10676
cached 101004
0
522072
表8-1中第二行输出(Mem:)显示物理 中第二行输出(Mem:) 内存:total列显示共有的可用内存 列显示共有的可用内存( 内存:total列显示共有的可用内存(不显示 核心使用的物理内存,通常大约1MB), 核心使用的物理内存,通常大约1MB), used列显示被使用的内存总额 free列显示 used列显示被使用的内存总额,free列显示 列显示被使用的内存总额, 全部空闲的内存,shared列显示多个进程共 全部空闲的内存,shared列显示多个进程共 享的内存总额,buffers列显示磁盘缓存的当 享的内存总额,buffers列显示磁盘缓存的当 前大小。 前大小。 表8-1中第二行输出(Swap)显示交换 中第二行输出(Swap) 空间的信息,与上一行类似。 空间的信息,与上一行类似。如果该行为全 0,则没有使用交换空间。 则没有使用交换空间。
1.实时监控内存使用情况 (1)在命令行用“free”命令监控内存使 在命令行用“ 用情况
在提示符后输入命令free:# 在提示符后输入命令free:#free :#free 表8-1所示为输出情况。 所示为输出情况。
表8-1
一个256MB的RAM和512MB交换空间的系统情况 的 一个 和 交换空间的系统情况
Linux的内存管理 Linux的内存管理
一、实验目的 二、实验工具与设备 三、实验预备知识 四、实验内容和步骤 五、实验总结

实验5_内存管理

实验5_内存管理

• 当程序运行的时候,初始化 数据、BSS和堆栈区域通常 放在一个单独的连续区域: 数据段。堆栈段和代码段与 数据段是分隔开的。
堆 BSS 数据段
代码段
• 示例程序运行结果:
相关调用说明
【 brk/sbrk系统调用】 功能描述: 改变一个进程数据段的大小。当使用者提供合理的参数,系统有足够 的内存,并且进程没有超出允许它的最大数据段,操作会得到实现。 用法: #include <unistd.h> int brk(void *end_data_segment); void *sbrk(intptr_t increment); 参数: end_data_segment:数据段的新终点 increment:当前进程数据段将会被增加的量 返回说明: 成功执行时,brk()返回0,sbrk()返回新区域起点的指针。失败返回1,errno被设为以下值 ENOMEM: 核心内存不足

栈是用户存放程序临时创建的局部变量,也 就是说我们函数括弧“{}”中定义的变量(但不包 括static声明的变量,static意味着在数据段中存 放变量)。除此以外,在函数被调用时,其参数 也会被压入发起调用的进程栈中,并且待到调用 结束后,函数的返回值也会被存放回栈中。由于 栈的先进先出特点,所以栈特别方便用来保存/恢 复调用现场。从这个意义上讲,我们可以把堆栈 看成一个寄存、交换临时数据的内存区。
BSS段
• BSS段包含了程序中未初始化的全局变量, 在内存中 bss段全部置零。

堆是用于存放进程运行中被动态分配 的内存段,它的大小并不固定,可动态扩 张或缩减。当进程调用malloc等函数分配 内存时,新分配的内存就被动态添加到堆 上(堆被扩张);当利用free等函数释放 内存时,被释放的内存从堆中被剔除(堆 被缩减) 。

操作系统实验-内存管理

操作系统实验-内存管理

操作系统实验-内存管理操作系统实验内存管理在计算机系统中,内存管理是操作系统的核心任务之一。

它负责有效地分配和管理计算机内存资源,以满足各种程序和进程的需求。

通过本次操作系统实验,我们对内存管理有了更深入的理解和认识。

内存是计算机用于存储正在运行的程序和数据的地方。

如果没有有效的内存管理机制,计算机系统将无法高效地运行多个程序,甚至可能会出现内存泄漏、内存不足等严重问题。

在实验中,我们首先接触到的是内存分配策略。

常见的内存分配策略包括连续分配和离散分配。

连续分配是将内存空间视为一个连续的地址空间,程序和数据被依次分配到连续的内存区域。

这种方式简单直观,但容易产生内存碎片,降低内存利用率。

离散分配则将内存分成大小相等或不等的块,根据需求进行分配。

其中分页存储管理和分段存储管理是两种常见的离散分配方式。

分页存储管理将内存空间划分为固定大小的页,程序也被分成相同大小的页,通过页表进行映射。

分段存储管理则根据程序的逻辑结构将其分成不同的段,如代码段、数据段等,每个段有不同的访问权限和长度。

接下来,我们研究了内存回收算法。

当程序不再使用分配的内存时,操作系统需要回收这些内存以便再次分配。

常见的内存回收算法有首次适应算法、最佳适应算法和最坏适应算法。

首次适应算法从内存的起始位置开始查找,找到第一个满足需求的空闲区域进行分配;最佳适应算法则选择大小最接近需求的空闲区域进行分配;最坏适应算法选择最大的空闲区域进行分配。

为了更直观地理解内存管理的过程,我们通过编程实现了一些简单的内存管理算法。

在编程过程中,我们深刻体会到了数据结构和算法的重要性。

例如,使用链表或二叉树等数据结构来表示空闲内存区域,可以提高内存分配和回收的效率。

在实验中,我们还遇到了一些实际的问题和挑战。

比如,如何处理内存碎片的问题。

内存碎片是指内存中存在一些无法被有效利用的小空闲区域。

为了解决这个问题,我们采用了内存紧缩技术,将分散的空闲区域合并成较大的连续区域。

操作系统实验之内存管理实验报告

操作系统实验之内存管理实验报告

操作系统实验之内存管理实验报告一、实验目的内存管理是操作系统的核心功能之一,本次实验的主要目的是深入理解操作系统中内存管理的基本原理和机制,通过实际编程和模拟操作,掌握内存分配、回收、地址转换等关键技术,提高对操作系统内存管理的认识和实践能力。

二、实验环境本次实验在 Windows 操作系统下进行,使用 Visual Studio 作为编程环境,编程语言为 C++。

三、实验原理1、内存分配算法常见的内存分配算法有首次适应算法、最佳适应算法和最坏适应算法等。

首次适应算法从内存的起始位置开始查找,找到第一个满足需求的空闲分区进行分配;最佳适应算法则选择大小最接近需求的空闲分区;最坏适应算法选择最大的空闲分区进行分配。

2、内存回收算法当进程结束释放内存时,需要将其占用的内存区域回收至空闲分区链表。

回收过程中需要考虑相邻空闲分区的合并,以减少内存碎片。

3、地址转换在虚拟内存环境下,需要通过页表将逻辑地址转换为物理地址,以实现进程对内存的正确访问。

四、实验内容1、实现简单的内存分配和回收功能设计一个内存管理模块,能够根据指定的分配算法为进程分配内存,并在进程结束时回收内存。

通过模拟多个进程的内存请求和释放,观察内存的使用情况和变化。

2、实现地址转换功能构建一个简单的页式存储管理模型,模拟页表的建立和地址转换过程。

给定逻辑地址,能够正确计算出对应的物理地址。

五、实验步骤1、内存分配和回收功能实现定义内存分区的数据结构,包括起始地址、大小、使用状态等信息。

实现首次适应算法、最佳适应算法和最坏适应算法的函数。

创建空闲分区链表,初始化为整个内存空间。

模拟进程的内存请求,调用相应的分配算法进行内存分配,并更新空闲分区链表。

模拟进程结束,回收内存,处理相邻空闲分区的合并。

2、地址转换功能实现定义页表的数据结构,包括页号、页框号等信息。

给定页面大小和逻辑地址,计算页号和页内偏移。

通过页表查找页框号,结合页内偏移计算出物理地址。

linux内存管理实验报告

linux内存管理实验报告

操作系统实验报告院别:XXXXXX班级:XXXXXX学号:XXXXXX姓名:稻草人一、实验目的1、通过本次试验体会操作系统中内存的分配模式;2、掌握内存分配的方法(FF,BF,WF);3、学会进程的建立,当一个进程被终止时内存是如何处理被释放块,并当内存不满足进程申请时是如何使用内存紧凑;4、掌握内存回收过程及实现方法;5、学会进行内存的申请释放和管理;二、实验内容附源代码:/*宏定义*/#include<stdio.h>#include<stdlib.h>#include<sys/types.h>#define PROCESS_NAME_LEN 32 /*进程名称的最大长度*/#define MIN_SLICE 10 /*最小碎片的大小*/#define DEFAULT_MEM_SIZE 1024 /*默认内存的大小*/#define DEFAULT_MEM_START 0 /*默认内存的起始位置*//* 内存分配算法 */#define MA_FF 1#define MA_BF 2#define MA_WF 3int mem_size=DEFAULT_MEM_SIZE; /*内存大小*/int ma_algorithm = MA_FF; /*当前分配算法*/int flag = 0; /*设置内存大小标志*/static int pid = 0; /*初始pid*/int algorithm;/*描述每一个空闲块的数据结构*/struct free_block_type{int size;int start_addr;struct free_block_type *next;};/*指向内存中空闲块链表的首指针*/struct free_block_type *free_block;/*每个进程分配到的内存块的描述*/struct allocated_block{int pid;int size;int start_addr;char process_name[PROCESS_NAME_LEN];struct allocated_block *next;};/*进程分配内存块链表的首指针*/struct allocated_block *allocated_block_head = NULL;struct allocated_block *find_process(int id){struct allocated_block *p;p=allocated_block_head;while(p!=NULL){if (p->pid==id)return p;}return NULL;}void swap(int *p,int *q){int temp;temp = *p;*p = *q;*q = temp;return;}void do_exit(){exit(0);}/*初始化空闲块,默认为一块,可以指定大小及起始地址*/ struct free_block_type* init_free_block(int mem_size){ struct free_block_type *fb;fb=(struct free_block_type *)malloc(sizeof(struct free_block_type)); if(fb==NULL){printf("No mem\n");return NULL;}fb->size = mem_size;fb->start_addr = DEFAULT_MEM_START;fb->next = NULL;return fb;}/*显示菜单*/display_menu(){printf("\n");printf("1 - Set memory size (default=%d)\n", DEFAULT_MEM_SIZE);printf("2 - Select memory allocation algorithm\n");printf("3 - New process \n");printf("4 - Terminate a process \n");printf("5 - Display memory usage \n");printf("0 - Exit\n");}/*设置内存的大小*/set_mem_size(){int size;if(flag!=0){ //防止重复设置printf("Cannot set memory size again\n");return 0;}printf("Total memory size =");scanf("%d", &size);if(size>0) {mem_size = size;free_block->size = mem_size;}flag=1; return 1;}/*按FF算法重新整理内存空闲块链表*/rearrange_FF(){struct free_block_type *tmp, *work;printf("Rearrange free blocks for FF \n");tmp = free_block;while(tmp!=NULL){ work = tmp->next;while(work!=NULL){{ /*地址递增*/swap(&work->start_addr, &tmp->start_addr); swap(&work->size, &tmp->size);}work=work->next;}tmp = tmp -> next;}}/*按BF最佳适应算法重新整理内存空闲块链表*/rearrange_BF(){struct free_block_type *tmp, *work;printf("Rearrange free blocks for BF \n");tmp = free_block;while(tmp!=NULL){ work = tmp->next;while(work!=NULL){if ( work->size > tmp->size) { /*地址递增*/swap(&work->start_addr, &tmp->start_addr); swap(&work->size, &tmp->size);}work=work->next;}tmp = tmp -> next;}}/*按WF算法重新整理内存空闲块链表*/rearrange_WF(){struct free_block_type *tmp, *work;printf("Rearrange free blocks for WF \n");tmp = free_block;while(tmp!=NULL){ work = tmp->next;while(work!=NULL){if ( work->size < tmp->size) { /*地址递增*/swap(&work->start_addr, &tmp->start_addr); swap(&work->size, &tmp->size);}else}tmp = tmp -> next;}}/*按指定的算法整理内存空闲块链表*/rearrange(int algorithm){switch(algorithm){case MA_FF: rearrange_FF(); break;case MA_BF: rearrange_BF(); break;case MA_WF: rearrange_WF(); break;}}/* 设置当前的分配算法 */set_algorithm(){printf("\t1 - First Fit\n");printf("\t2 - Best Fit \n");printf("\t3 - Worst Fit \n");scanf("%d", &algorithm);if(algorithm>=1 && algorithm <=3) ma_algorithm=algorithm;//按指定算法重新排列空闲区链表rearrange(ma_algorithm); }/*分配内存模块*/int allocate_mem(struct allocated_block *ab){struct free_block_type *fbt, *pre, *temp,*work;int request_size=ab->size;fbt = free_block;while(fbt!=NULL){if(fbt->size>=request_size){if (fbt->size - request_size >= MIN_SLICE) /*分配后空闲空间足够大,则分割*/{mem_size -= request_size;fbt->size -= request_size;ab->start_addr= fbt->start_addr;fbt->start_addr += request_size;}else if (((fbt->size - request_size) < MIN_SLICE)&&((fbt->size - request_size) > 0))/*分割后空闲区成为小碎片,一起分配*/{mem_size -= fbt->size;pre = fbt->next;fbt->start_addr += fbt->size;free(fbt);}else{temp = free_block;while(temp!=NULL){work = temp->next;if(work!=NULL)/*如果当前空闲区与后面的空闲区相连,则合并*/{if (temp->start_addr+temp->size == work->start_addr) {temp->size += work->size;temp->next = work->next;free(work);continue;}}temp = temp->next;}fbt = free_block;break;}rearrange(algorithm); /*重新按当前的算法排列空闲区*/return 1;}pre = fbt;fbt = fbt->next;}return -1;}/*创建新的进程,主要是获取内存的申请数量*/new_process(){struct allocated_block *ab;int size;int ret;ab=(struct allocated_block *)malloc(sizeof(struct allocated_block));if(!ab) exit(-5);ab->next = NULL;sprintf(ab->process_name, "PROCESS-%02d", pid);ab->pid = pid;printf("Memory for %s:", ab->process_name);scanf("%d", &size);if(size>0) ab->size=size;ret = allocate_mem(ab); /* 从空闲区分配内存,ret==1表示分配ok*//*如果此时allocated_block_head尚未赋值,则赋值*/if((ret==1) &&(allocated_block_head == NULL)){allocated_block_head=ab;return 1;}/*分配成功,将该已分配块的描述插入已分配链表*/else if (ret==1) {ab->next=allocated_block_head;allocated_block_head=ab;return 2;}else if(ret==-1){ /*分配不成功*/printf("Allocation fail\n");free(ab);return -1;}return 3;}/*将ab所表示的已分配区归还,并进行可能的合并*/int free_mem(struct allocated_block *ab){int algorithm = ma_algorithm;struct free_block_type *fbt, *work;fbt=(struct free_block_type*) malloc(sizeof(struct free_block_type)); if(!fbt) return -1;fbt->size = ab->size;fbt->start_addr = ab->start_addr;/*插入到空闲区链表的头部并将空闲区按地址递增的次序排列*/fbt->next = free_block;free_block=fbt;rearrange(MA_FF);fbt=free_block;while(fbt!=NULL){work = fbt->next;if(work!=NULL){/*如果当前空闲区与后面的空闲区相连,则合并*/{fbt->size += work->size;fbt->next = work->next;free(work);continue;}}fbt = fbt->next;}rearrange(algorithm); /*重新按当前的算法排列空闲区*/return 1;}/*释放ab数据结构节点*/int dispose(struct allocated_block *free_ab){struct allocated_block *pre, *ab;if(free_ab == allocated_block_head) { /*如果要释放第一个节点*/allocated_block_head = allocated_block_head->next;free(free_ab);return 1;}pre = allocated_block_head;ab = allocated_block_head->next;while(ab!=free_ab){ pre = ab; ab = ab->next; }pre->next = ab->next;free(ab);return 2;}/* 显示当前内存的使用情况,包括空闲区的情况和已经分配的情况 */display_mem_usage(){struct free_block_type *fbt=free_block;struct allocated_block *ab=allocated_block_head;if(fbt==NULL) return(-1);printf("----------------------------------------------------------\n");/* 显示空闲区 */printf("Free Memory:\n");printf("%20s %20s\n", " start_addr", " size");while(fbt!=NULL){printf("%20d %20d\n", fbt->start_addr, fbt->size);fbt=fbt->next;/* 显示已分配区 */printf("\nUsed Memory:\n");printf("%10s %20s %10s %10s\n", "PID", "ProcessName", "start_addr", " size");while(ab!=NULL){printf("%10d %20s %10d %10d\n", ab->pid, ab->process_name, ab->start_addr, ab->size); ab=ab->next;}printf("----------------------------------------------------------\n");return 0;}/*删除进程,归还分配的存储空间,并删除描述该进程内存分配的节点*/kill_process(){struct allocated_block *ab;int pid;printf("Kill Process, pid=");scanf("%d", &pid);ab=find_process(pid);if(ab!=NULL){free_mem(ab); /*释放ab所表示的分配区*/dispose(ab); /*释放ab数据结构节点*/}}main(){char choice;pid=0;free_block = init_free_block(mem_size); //初始化空闲区for(;;){display_menu(); //显示菜单fflush(stdin);choice=getchar(); //获取用户输入switch(choice){case '1': set_mem_size(); break; //设置内存大小case '2': set_algorithm(); flag=1; break; //设置分配算法case '3': new_process(); flag=1; break; //创建新进程case '4': kill_process(); flag=1; break; //删除进程case '5': display_mem_usage(); flag=1; break //显示内存使用case '0': do_exit(); exit(0); break; //释放链表并退出default: break;}}三、实验结果实验界面:提示输入以后,输入 1,显示如下:紧接着输入: 3,设置内存空间为 256,显示如下:重复一次上一操作。

Linu实验五

Linu实验五

Linu实验五实验五五进程管理命令一、实验目的( 1)了解如何监视系统运行状态( 2)掌握查看、删除进程的正确方法( 3)掌握命令在后台运行的用法( 4)掌握进程手工、调度启动的方法二、常用命令an 手册三、实验内容1、用 top 命令察看当前系统的状态,并识别各进程的有关栏目。

2、用 ps 命令察看系统当前的进程,并把系统当前的进程保存到文件 process 中。

3、用 ps 命令察看系统当前有没有 init 进程。

4、输入 cat 回车按 Ctrl-z 键,出现什么情况?输入fg 命令出现什么情况?答:将 cat 进程挂起, fg 将挂起进程调到前台运行按Ctrl-c 键,出现什么情况?答;强制中断5、输入 find / -name ls_temp ,该命令的功能是什么?查看该进程;答:在根目录下按名字查找以 ls 开头的文件,并把查询结果保存到temp 文件,并且把进程置为后台运行输入 killall find 命令后 ,再查看该进程。

答:输入该命令后回车后,和 fand 相关的进程全部被杀死6、输入 find / -name ls_temp 输入 jobs 命令,出现什么情况?答 ;查看后台进程的信息输入 fg 命令出现什么情况?答:将后台进程调到前台运行7、指定上午 __(小时):__(分钟)执行某命令8、查阅资料,了解 batch 命令与 at 命令的关系答: at 是在指定时间执行某命令, batch 是党系统负载低于 0.8 的时候在某一时间执行某命令9、每逢星期一下午 5:50 将 /data 目录下的所有目录和文件归档并压缩为 :backup.tar.gz,放在 /home/backup 目录下 .(先新建 /data 目录,并在目录中随意生成几个文件)四、实验报告以书写形式记录下每一个( 1-8)实验内容,包括遇到的问题和解决方法;并回答以下思考题。

五、思考题1、输入 cat 回车, Ctrl-z 键。

Linux实验五 Linux进程管理

Linux实验五  Linux进程管理

实验五Linux进程管理一、实验目的1.掌握Linux进程管理。

2.学习并掌握进程查看命令、进程终止命令。

3.使用at和cron服务实现Linux进程调度。

二、实验环境安装了Red Hat Linux9.0系统的计算机一台三、实验过程(实验步骤、记录、数据、分析、结果)(一)进程查看、终止、挂起及暂停等操作1、使用ps命令查看和控制进程1)显示本用户进程#ps分析:显示进程:shell和ps2)显示所有用户的进程#ps –au分析:显示共有8个进程3)在后台运行cat命令#cat&分析:PID为27244)查看进程cat#ps aux |grep cat5)杀死进程cat#kill -9 cat6)再次查看进程cat,看看是否被杀死。

分析:结果显示已经杀死cat2、使用top命令查看和控制进程1)用top命令动态显示当前的进程。

分析:显示当前的进程2)只显示某一用户的进程(u)分析:pm进程的PID为123)杀死指定进程号的进程(k)3、挂起和恢复进程1)执行命令cat分析:重新执行cat命令,PID号变成28852)按【ctrl+z】挂起进程3)输入jobs命令,查看作业分析:按【ctrl+z】挂起进程后,用jobs命令查看作业,cat被挂起。

4)输入bg,把cat切换到后台执行5)输入fg,把cat切换到前台执行6)按【ctrl+c】结束进程(二)通过at命令实现计划任务1、5分钟后执行/bin/date#at now+5minutesat>/bin/dateat><EOT>(提示:输入【ctrl+d】job任务号at 年-月-日小时:分钟如何查看结果?2、查找系统中任何以c为后缀名的文档,将结果保存到$HOME/findc文件中,指定时间为2016年12月01日早上8点#at 8am 12/01/16at>find / -name ‘*.c’ >$HOME/findcat><EOT>job任务号at 年-月-日小时:分钟如何查看结果?分析:指定时间必须要在当前时间之后,将12月1日16点改为12月28日16点3、2题的命令写到$HOME/findjob中,使用at命令执行,并将结果保存到$HOME/findfc文件中,指定时间为当前时间后5分钟#vi $HOME/findjob内容如下:find / -name ‘*.c’ >$HOME/findfc存盘退出#at –f $HOME/findjob now+5minutes4、at命令实现在30天后统计/etc/inittab文件的行数,将统计结果发送至$HOME/initline文件中#at now+3daysat>wc –l /etc/inittab>>$HOME/initlineat><EOT>5、列出现有的所有at任务,并记下相关信息分析:5分钟已过去,第一个at计划已经执行,上面3个计划等待执行。

计算机操作系统实验指导linux版王红玲源码

计算机操作系统实验指导linux版王红玲源码

计算机操作系统实验指导linux版王红玲源码计算机操作系统实验指导(Linux版)导言:计算机操作系统是计算机系统中最重要的软件之一,负责管理计算机系统的硬件和软件资源,并为用户提供良好的使用环境。

为了帮助学生更好地理解操作系统的原理和实现,我们开设计算机操作系统实验课程,并提供一份针对Linux操作系统的实验指导。

本实验指导旨在帮助学生通过实际编程来探索和理解操作系统的原理和实现方式。

通过完成本实验,学生将能够熟悉Linux操作系统的基本功能和原理,并学会使用Linux的命令行界面和Shell编程。

同时,本实验还将引导学生通过源代码的阅读和分析,深入理解操作系统内部的工作原理。

实验一:Linux环境搭建在开始实验之前,我们首先需要搭建一个适合的Linux开发环境。

学生可以选择在个人电脑上安装Linux发行版,如Ubuntu或Fedora,也可以使用虚拟机软件,如VirtualBox或VMware,在Windows或Mac OS上安装Linux虚拟机。

实验二:Linux基本操作和Shell编程在本实验中,学生将通过完成一系列实际任务来熟悉Linux的基本操作和Shell编程。

任务包括使用命令行界面进行文件和目录操作、执行Shell脚本、配置系统环境等。

学生需要按照指导完成每个任务,并理解每个任务的目的和原理。

实验三:Linux系统调用和进程管理在本实验中,学生将学习和实现Linux系统调用和进程管理的功能。

学生需要阅读和分析Linux内核源代码中与系统调用和进程管理相关的部分,并完成一系列与之相关的实验任务。

任务包括编写和调试系统调用、创建和管理进程、实现进程间通信等。

实验四:Linux内存管理和文件系统在本实验中,学生将学习和实现Linux内存管理和文件系统的功能。

学生需要阅读和分析Linux内核源代码中与内存管理和文件系统相关的部分,并完成一系列与之相关的实验任务。

任务包括实现内存分配算法、设计和实现文件系统、调试和优化内存和文件系统的性能等。

操作系统实验5文件系统:Linux文件管理

操作系统实验5文件系统:Linux文件管理

实验5 文件系统: Linux文件管理1. 实验目的〔1〕掌握Linux提供的文件系统调用的使用方法;〔2〕熟悉文件和目录操作的系统调用用户接口;〔3〕了解操作系统文件系统的工作原理和工作方式。

2. 实验内容〔1〕利用Linux有关系统调用函数编写一个文件工具filetools, 要求具有下列功能:***********0.退出1.创建新文件2.写文件3.读文件4.复制文件5.修改文件权限6.查看文件权限7.创建子目录8.删除子目录9.改变当前目录到指定目录10.操作***********代码:#include<stdio.h>#include<sys/types.h>#include<unistd.h>#include<fcntl.h>#include<sys/stat.h>#include<syslog.h>#include<string.h>#include<stdlib.h>void menu(void);void openfile(void);void writefile(void);void readfile(void);void copyfile(void);void chmd(void);void ckqx(void);void cjml(void);void scml(void);void ggml(void);void ylj(void);int main(){int choose;int suliangjin=1;menu();scanf("%d",&choose);while(choose!=0){switch(choose){case 1:openfile();break;case 2:writefile();break;case 3:readfile();break;case 4:copyfile();break;case 5:chmd();break;case 6:ckqx();break;case 7:cjml();break;case 8:scml();break;case 9:ggml();break;case 10:ylj();break;}menu();scanf("%d",&choose);}return 0;}void menu(void){printf("文件系统\n");printf("1.创建新文件\n");printf("2.写文件\n");printf("3.读文件\n");printf("4.复制文件\n");printf("5.修改文件权限\n");printf("6.查看文件权限\n");printf("7.创建子目录\n");printf("8.删除子目录\n");printf("9.改变目前目录到指定目录\n");printf("10.操作\n");printf("0.退出\n");printf("请输入您的选择...\n");}void openfile(void){int fd;if((fd=open("/tmp/hello.c",O_CREAT|O_TRUNC|O_RDWR,0666))<0) perror("open");elseprintf("open file:hileo.c %d\n",fd);if(close(fd)<0)perror("close");elseprintf("Close hello.c\n");}void writefile(void){int fd,size,len;char *buf="Hello!I'm writing to this file!";len=strlen(buf);if((fd=open("/tmp/hello.c",O_CREAT|O_TRUNC|O_RDWR,0666))<0) perror("open");elseprintf("open file:hileo.c %d\n",fd);if((size=write(fd,buf,len))<0)perror("write");elseprintf("Write:%s\n",buf);if(close(fd)<0)perror("close");elseprintf("Close hello.c \n");}void readfile(void){int fd,size;char b[10];if((fd=open("/tmp/hello.c",O_CREAT|O_TRUNC|O_RDWR,0666))<0) perror("open");elseprintf("open file:hileo.c %d\n",fd);lseek(fd,0,SEEK_SET);if((size=read(fd,b,10))<0)perror("read");elseprintf("read from file:%s\n",b);if(close(fd)<0)perror("close");elseprintf("Close hello.c\n");}void copyfile(void){if(fork()==0)execlp("/bin/cp","cp","/tmp/hello.c","/tmp/he.c",NULL);elsewait(0);printf("将hello.c复制he.c");}void chmd(void){int a;printf("1.文件主可读可写可执行\n");printf("2.文件主可读\n");printf("3.文件主可写\n");printf("4.文件主可执行\n");printf("请输入您的选项\n");scanf("%d",&a);switch(a){case 1:chmod("/tmp/hello.c",S_IRWXU);printf("ok!\n");break;case 2:chmod("/tmp/hello.c",S_IRUSR);printf("ok!\n");break;case 3:chmod("/tmp/hello.c",S_IWUSR);printf("ok!\n");break;case 4:chmod("/tmp/hello.c",S_IXUSR);printf("ok!\n");break;default:printf("您选择有误\n");}}void ckqx(void){char *path="/bin/ls";char *argv[4]={"ls","-l",NULL};if(fork()==0)execv(path,argv);elsewait(0);}void cjml(void){if(mkdir("/tmp/a",S_IRWXU)<0)perror("Mkdir");elseprintf("创建成功\n");}void scml(void){if(rmdir("/tmp/a")<0)perror("Rmdir");elseprintf("删除成功\n");}void ggml(void){if(chdir("/tmp/bc")<0)perror("chdir");elseprintf("更改目录成功\n"); }void ylj(void){if(link("hello.c","h.c")<0)perror("Link");elseprintf("建立硬连接\n"); }打开文件:写文件:读文件:复制文件: 修改权限: 查看权限:创建目录:删除目录:更改目录:硬连接:1.问题解决方案:在复制文件时用execlp函数, 虽然有复制成功但是他就跳出整个程序, 这就是一个缺陷。

LINUX编程-实验五 内存管理实验

LINUX编程-实验五 内存管理实验

LINUX编程-实验五内存管理实验实验五内存管理实验1. 目的要求(1)学习使用内存管理库函数。

(2)学习分析、改正内存错误。

2. 实验内容(1)内存库函数实验 ?malloc函数原型:extern void *malloc(unsigned int num_bytes); 头文件:#include功能:分配长度为num_bytes字节的内存块。

说明:如果分配成功则返回指向被分配内存的指针,否则返回空指针NULL。

当内存不再使用时,应使用free()函数将内存块释放。

举例:运行程序清单5-1,写明运行结果:_?______________________________________________________________________________________________________________________________________________________________ calloc函数原型:extern void *calloc(int num_elems, int elem_size); 头文件:#include功能:为具有num_elems个长度为elem_size元素的数组分配内存。

说明:如果分配成功则返回指向被分配内存的指针,否则返回空指针NULL。

当内存不再使用时,应使用free()函数将内存块释放。

举例:运行程序清单5-2,写明运行结果:______________________________________________________________________________________________________________________________________________?_________________ realloc函数原型:extern void *realloc(void *mem_address, unsigned int newsize); 头文件:#include功能:改变mem_address所指内存区域的大小为newsize长度。

管理linux系统实验报告

管理linux系统实验报告

管理linux系统实验报告实验背景Linux 是一种以Unix 为基础设计的开源操作系统,广泛应用于服务器领域和嵌入式系统中。

作为一个管理员,熟悉并掌握Linux 系统的管理能力是十分重要的。

本次实验旨在加深理解Linux 的基本管理技能,并通过实践加以应用。

实验内容本次实验包括以下几个部分:1. 用户管理2. 文件权限管理3. 进程管理4. 磁盘管理5. 系统日志管理实验步骤1. 用户管理通过命令行创建一个新用户,并设置密码。

其中,新用户需要有管理员权限(sudo)。

bashsudo adduser <用户名>sudo passwd <用户名>sudo usermod -aG sudo <用户名>2. 文件权限管理创建一个新的文件夹,并设置不同的权限给不同的用户组:bashmkdir test_directorychown <用户名>:<用户组> test_directorychmod 750 test_directory3. 进程管理查看当前正在运行的进程列表,并进行进程的查找、结束操作:bashps auxkill <PID>4. 磁盘管理查看系统的磁盘使用情况,并对硬盘进行挂载和卸载操作:bashdf -hsudo mount /dev/<设备名> /mntsudo umount /mnt5. 系统日志管理查看系统日志,并分析其中的信息:bashtail /var/log/syslog实验总结通过本次实验,我学习到了Linux 系统的基本管理技能。

用户管理、文件权限管理、进程管理、磁盘管理和系统日志管理是运维人员必须掌握的基本技能。

合理设置用户权限、熟练运用命令行工具、了解硬盘的使用情况以及分析系统日志,都有助于提高系统的安全性和稳定性。

在实验过程中,我发现通过多次实践才能真正熟练掌握这些技能。

同时,还需要时常查阅相关的文档和资料,以便了解更多命令和技巧。

linux实验5_文件管理

linux实验5_文件管理

实验二Linux指令入门-文件管理目录实验二Linux指令入门-文件管理 (1)1实验环境 (2)2实验内容 (2)2.1磁盘管理命令 (2)2.1.1 cat (2)2.1.2 cmp (3)2.1.3 diff (4)2.1.4 file (6)2.1.5 find (7)3实验小节 (8)1实验环境本实验根据移动云平台的《Linux指令入门-系统管理》进行,为了直观展示linux命令对文件的操作,部分实验使用个人电脑双系统的linux环境,这样可以直接打开文件观察。

由于没有使用docker或虚拟机来备份恢复系统,所以分盘等操作会影响linux系统的使用,因此部分实验直接使用移动云的ECS实例。

2实验内容2.1磁盘管理命令2.1.1 catcat命令描述:该命令用于连接文件并打印到标准输出设备上。

cat命令语法:cat [参数] [文件名]参数说明:cat命令使用示例:a.执行如下命令,将一个自增序列写入test1.txt文件中。

b.执行如下命令,查看文件test1.txt内容。

c.执行如下命令,将test1.txt的文件内容加上行号后输入到test2.txt文件。

d.执行如下命令,查看文件test2.txt内容e.执行如下命令,将test1.txt文件内容清空。

f.执行如下命令,查看文件test1.txt内容。

2.1.2 cmpcmp命令描述:该命令用于比较两个文件是否有差异。

当相互比较的两个文件完全一样时,该指令不会显示任何信息。

否则会标示出第一个不同之处的字符和列数编号。

当不指定任何文件名称,或文件名为"-",则cmp指令会从标准输入设备读取数据。

cmp命令语法:cmp [-clsv][-i <字符数目>][--help][第一个文件][第二个文件]参数说明:cmp命令使用示例:a.执行如下命令,将一个自增序列1-5写入test1.txt文件中。

b.执行如下命令,比较test1.txt文件和test2.txt文件是否相同。

(完整word版)Linux操作系统实验报告 存储管理试验

(完整word版)Linux操作系统实验报告 存储管理试验
(2)利用随机函数动态生成进程访问页面的序列号。
(3)实现FIFO页面淘汰算法。
(4)实现页故障率反馈模型。
2、实验目的与要求
①(1)用C语言是实现模拟Linux系统中连续内存分配用到的伙伴对算法。
(2)通过链表的形式输出在内存申请和释放过程中内存状态的对比图。
②(1)了解工作集模型的原理及其特点。
printmem();
}
int power(int x,int y){
int k=0,tmp=1;
for(;k<y;k++){
tmp=tmp*x;
}
return tmp;
}
int root(int x,int y){
int result=y,count=0;
while(result!=1){
result=result/x;
merge(tempId,merger);
}else {
return 0;
}
return 1;
}else {
second=second->next;
isFirst++;
}
}
return 1;
}
int freeb(int size){
block * first=(struct block *)malloc(sizeof(struct block));
if((second->start==nextStart || second->start==preStart) && second->loc==0){
merger->size=(first->size)+(second->size);
相关主题
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验五内存管理实验1.目的要求(1)学习使用内存管理库函数。

(2)学习分析、改正内存错误。

2.实验内容(1)内存库函数实验●malloc函数原型:extern void *malloc(unsigned int num_bytes);头文件:#include <alloc.h>功能:分配长度为num_bytes字节的内存块。

说明:如果分配成功则返回指向被分配内存的指针,否则返回空指针NULL。

当内存不再使用时,应使用free()函数将内存块释放。

举例:运行程序清单5-1,写明运行结果:_______________________________________________________________________________________________________________________________________________________________●calloc函数原型:extern void *calloc(int num_elems, int elem_size);头文件:#include <alloc.h>功能:为具有num_elems个长度为elem_size元素的数组分配内存。

说明:如果分配成功则返回指向被分配内存的指针,否则返回空指针NULL。

当内存不再使用时,应使用free()函数将内存块释放。

举例:运行程序清单5-2,写明运行结果:_______________________________________________________________________________________________________________________________________________________________●realloc函数原型:extern void *realloc(void *mem_address, unsigned int newsize);头文件:#include <alloc.h>功能:改变mem_address所指内存区域的大小为newsize长度。

说明:如果分配成功则返回指向被分配内存的指针,否则返回空指针NULL。

当内存不再使用时,应使用free()函数将内存块释放。

举例:运行程序清单5-3,写明运行结果:______________________________________________________________________ ___________________________________________________________________ ______________________(2)内存错误分析实验●分析1:指出程序清单5-4的内存错误原因。

错误原因:___ApplyForMem(char *p,int num)是不能传递动态内存的,这样main函数当中Str始终都是NULL_________________________________________________________________ ______________________________________________________________________ _____________________●分析2:指出程序清单5-5的内存错误原因。

错误原因:____(const char *)没有具体指明内存地址,这个写法表示从地址0处取一个字符,而地址0是没有东西的____________________________________________________________________ ____________________________________________________________________ ___________________●分析3:通过比较程序清单5-6、5-7输出结果,分析程序5-3内存错误原因程序5-6运行结果___________________________________________________________________ ___________________________________________________________________ _________________________程序5-7运行结果_______________________________________________________________________________________________________________________________________________________________错误原因__程序5-6释放内存的顺序和分配内存的顺序不对应。

_____________________________________________________________________________________________________________________________________________________________经验总结______堆分配内存后,释放内存的顺序应该和分配内存的逆序,这样才能保证释放内存的顺序的正确性。

________________________________________________________________________________________________________________________________________________________3.主要仪器设备及软件(1)硬件:计算机、网络(2)软件:VMWare workstation、RedHat 9.04.附录:程序清单if()(1)5-1#include <syslib.h>#include <alloc.h>main(){char *p;clrscr(); // clear screenp=(char *)malloc(100);if(p)printf("Memory Allocated at: %x",p);elseprintf("Not Enough Memory!\n");free(p);return 0;}(2)5-2#include <syslib.h>#include <alloc.h>main(){char *p;clrscr(); // clear screenp=(char *)calloc(100,sizeof(char));if(p)printf("Memory Allocated at: %x",p);elseprintf("Not Enough Memory!\n");free(p);return 0;}(3)5-3#include <syslib.h>#include <alloc.h>main(){char *p;clrscr(); // clear screenp=(char *)malloc(100);if(p)printf("Memory Allocated at: %x",p);elseprintf("Not Enough Memory!\n");p=(char *)realloc(p,256);if(p)printf("Memory Reallocated at: %x",p);elseprintf("Not Enough Memory!\n");free(p);return 0; }(4)5-4……Void ApplyForMem(char *p,int num){p=(char*)malloc(sizeof(char)*num);return;}int main(){char *str=NULL;………….ApplyForMem(str,300);free(str);infile.close();return 0;}(5)5-5#include <unistd.h>#include <stdlib.h>#include <stdio.h>int main() {char z = *(const char *)0;exit(EXIT_SUCCESS);}(6)5-6#include “stdlib.h”#define HEAP_BLOCK_SIZE 32int main(){// 分配申明heap 内存块1char *pbuf1 = (char *) malloc(HEAP_BLOCK_SIZE);printf("HeapTest block 1 (%d bytes) at %08Xh", sizeof(pbuf1), pbuf1);*pbuf1 = '1';//分配申明heap 内存块2char *pbuf2 = (char *) malloc(HEAP_BLOCK_SIZE);printf("HeapTest block 2 (%d bytes) at %08Xh", sizeof(pbuf2), pbuf2);*pbuf2 = '2';//分配申明heap 内存块 3char *pbuf3 = (char *) malloc(HEAP_BLOCK_SIZE);printf("HeapTest block 3 (%d bytes) at %08Xh", sizeof(pbuf3), pbuf3);*pbuf3 = '3';// 释放heap 内存块1printf("HeapTest block 1 (%d bytes) at %08Xh freed",sizeof(pbuf1), pbuf1);free(pbuf1);printf("HeapTest block 2 (%d bytes) at %08Xh freed",sizeof(pbuf2), pbuf2);free(pbuf2);//释放heap内存块 3printf("HeapTest block 3 (%d bytes) at %08Xh freed",sizeof(pbuf3), pbuf3);free(pbuf3);//分配申明heap 内存块4char *pbuf4 = (char *) malloc( HEAP_BLOCK_SIZE);printf("HeapTest block 4 (%d bytes) at %08Xh", sizeof(pbuf4), pbuf4);*pbuf4 = '4';//分配申明heap 内存块5char *pbuf5 = (char *) malloc( HEAP_BLOCK_SIZE);printf("HeapTest block 5 (%d bytes) at %08Xh", sizeof(pbuf5), pbuf5);*pbuf5 = '5';//分配申明heap 内存块6char *pbuf6 = (char *) malloc( HEAP_BLOCK_SIZE);printf("HeapTest block 6 (%d bytes) at %08Xh", sizeof(pbuf6), pbuf6);*pbuf6= '6';for(;;) {Sleep(1000);}return 0;}(7)5-7#include “stdlib.h”#define HEAP_BLOCK_SIZE 32int main(){// 分配申明heap 内存块1char *pbuf1 = (char *) malloc(HEAP_BLOCK_SIZE);printf("HeapTest block 1 (%d bytes) at %08Xh", sizeof(pbuf1), pbuf1);*pbuf1 = '1';//分配申明heap 内存块2char *pbuf2 = (char *) malloc(HEAP_BLOCK_SIZE);printf("HeapTest block 2 (%d bytes) at %08Xh", sizeof(pbuf2), pbuf2);*pbuf2 = '2';//分配申明heap 内存块 3char *pbuf3 = (char *) malloc(HEAP_BLOCK_SIZE);printf("HeapTest block 3 (%d bytes) at %08Xh", sizeof(pbuf3), pbuf3);*pbuf3 = '3';// 释放heap 内存块3printf("HeapTest block 3 (%d bytes) at %08Xh freed",sizeof(pbuf3), pbuf3);free(pbuf3);printf("HeapTest block 2 (%d bytes) at %08Xh freed",sizeof(pbuf2), pbuf2); free(pbuf2);//释放heap内存块 1printf("HeapTest block 1 (%d bytes) at %08Xh freed",sizeof(pbuf1), pbuf1); free(pbuf1);//分配申明heap 内存块4char *pbuf4 = (char *) malloc( HEAP_BLOCK_SIZE);printf("HeapTest block 4 (%d bytes) at %08Xh", sizeof(pbuf4), pbuf4);*pbuf4 = '4';//分配申明heap 内存块5char *pbuf5 = (char *) malloc( HEAP_BLOCK_SIZE);printf("HeapTest block 5 (%d bytes) at %08Xh", sizeof(pbuf5), pbuf5);*pbuf5 = '5';//分配申明heap 内存块6char *pbuf6 = (char *) malloc( HEAP_BLOCK_SIZE);printf("HeapTest block 6 (%d bytes) at %08Xh", sizeof(pbuf6), pbuf6);*pbuf6= '6';for(;;) {Sleep(1000);}return 0;}。

相关文档
最新文档