操作系统存储管理实验报告

1、北京邮电大学操作系统实验实验报告实验日期：2021-12-20实验名称：存储管理一、实验目的 2二、实验内容 3三、实验分析 3?对于伙伴算法 3?对于虚拟存储区和内存工作区的不同算法 3四、编程实现?伙伴算法.4.446?原理?伙伴的概念?内存的释放?位图法?运行结果演示?伪代码5 6?根本思想 7?伪代码实现 7.?运行结果演示 7?先进先岀法( Fisrt In First Out ) ?根本思想?伪代码实现.8?运行结果演示.? 最近最久未使用 ( Least Recently Used )?根本思想?伪代码实现.9?运行结果演示.?最不经常使用法 ( Least Frequently

2、 Used )?根本思想?伪代码实现.9?运行结果演示10.? 最近未使用法 (No Used Recently )10?根本思想1.0?伪代码实现.10?运行结果演示11五、各种算法运行综合比拟 11六、实验心得 12七、程序源代码 13?伙伴算法 . 14?最正确置换算法 23?先进先出法 . 27?最近最久未使用 30?最不经常使用法 34?最近未使用法 37、实验目的，了通过模拟实现内存分配的伙伴算法和请求页式存储管理的几种根本页面置换算法 解存储技术的特点。掌握虚拟存储请求页式存储管理中几种根本页面置换算法的根本思想 和实现过程，并比拟 它们的效率。二、实验内容?实现一个内存管理的伙

3、伴算法，实现内存块申请时的分配和释放后的回收 。?设计一个虚拟存储区和内存工作区，并使用下述算法计算访问命中率 。1) 最正确置换算法( Optimal )2) 先进先出法 ( Fisrt In First Out )3) 最近最久未使用 ( Least Rece ntly Used )4) 最不经常使用法 ( Least Freque ntly Used )5) 最近未使用法 (No Used Recen tly ) 其中，命中率 =1-页面失效次数 / 页地址流长度。 试对上述算法的性能加以较各：页面个数和命中率间的关系；同样情况下的命中率比拟 。三、实验分析?对于伙伴算法，用随机函数仿真

4、进程进行内存申请，并且以较为随机的次序进行释放 。对其碎片进行统计，当申请分配内存失败时区分实际空间缺乏和由于碎片而不能满足 。 ?对于虚拟存储区和内存工作区的不同算法，其中主要的流程：首先用 srand() 和 rand()函数定义和产生指令序列，然后将指令序列变换成相应的页地址流 ，并针对不同的算法计 算出相应的命中率。实验可先从一个具体的例子出发 。(1) 通过随机数产生一个指令序列，共 320 条指令。指令的地址按下述原那么生成：A: 50% 的指令是顺序执行的B: 25% 的指令是均匀分布在前地址局部C: 25% 的指令是均匀分布在后地址局部具体的实施方法是：A:在0 , 319:的

5、指令地址之间随机选取一起点mmC :在前地址0,m+1 :中随机选取一条指令并执行，该指令的地址为D : 顺序执行一条指令，其地址为 m +1E:在后地址m +2 319 :中随机选取一条指令并执行2将指令序列变换为页地址流设：页面大小为1K ；用户内存容量4页到32页；用户虚存容量为32K。在用户虚存中，按每 K存放10条指令排列虚存地址，即 320条指令在虚存中的存放方 式为:第0条-第9条指令为第0页对应虚存地址为 0, 9:第10条-第19条指令为第1页对应虚存地址为 10, 19:第310条-第319条指令为第31页对应虚存地址为 310, 319 :按以上方式，用户指令可组成32页

6、。四、编程实现?伙伴算法?原理：伙伴算法把所有的空闲页面分为10个块组，每组中块的大小是 2的幕次方个页面，例如，第0组中块的大小都为2 0 1个页面，第1组中块的大小为都为21 2个页面，第 9组中块的大小都为29 512个页 面。也就是说， 每一组中块的大小是相同的 且这同样大小的块形成一 个链表。?伙伴的概念，满足以下三个条件的称为伙伴1两个块大小相同2两个块地址连续3两个块必须是从同一个大块中别离出来的。?内存的释放，是分配的逆过程，也可以看作是伙伴的合并过程。当释放一个块时，先在其对应的链表中考查是否有伙伴存在，如果没有伙伴块，就直接把要释放的块挂入链表头；如果有，那么从链表中摘下伙

7、伴，合并成一个大块,然后继续考查合并后的块在更大一级链表中是否有伙伴存在，直到不能合并或者已 经合并到了最大的块 2个页面?位图法，通常我们用位图来实现整个过程中，位 图的某一位对应两个互为伙伴的块，为I表示其中一块分配出去了 ，为0表示两块都空闲。伙伴算法中无论是分配还是释放内存块都只对相应的位图位进行异或操作。分配内存时对位图的操作是为释放过程效劳是否存在，如果对相应位的异或操作得1，那么没有伙伴可以合并，如果异或操作得 0，就进行合并，并且继续按这种方式合并伙伴，直到不能合并，而且在释放过程中尽可处理内存请求为止。如上所述，伙伴算法综合 利用了位图和链表的方式，较为高效地实现了内存的分配

8、和释放 能的合并小块内存，有效的消除了内存碎片。?伪代码struct node/* 建立结构数组，定义链表链接 */int much;int flag,flag_left,flag_right;struct n ode *leftchild,*rightchild,*father; 左右儿子父亲指针 ;struct IN_Tint num;int space;struct node *temp;void search_tree(struct node *head,i nt space,i nt really_ need)/内存节点的最大可用空间比应该分配内存小时分配失败否那么如果内存节点的大小

9、正好等于应该分配内存分配成功 否那么如果该内存节点尚未分配子女节点分配左右子女 递归处理该请求，依照做子女先分配 否那么假设左右子女最小的可用空间比需要的内存还大 取小者分配内存否那么取可用空间比需要的内存大者分配内存修改节点可用空间与碎片大小void back_to_space(i nt i) ?运行结果演示随机生成的20组内存分配请求这是内存分配结果，其中，对于内存不够时会有显示，提示?根本思想：发生缺页时，有些页面在内存中，其中有一页见很快被访问(也包含紧接着 的下一条指令的那页)，而其他页面那么可能要到 10、100或者1000条指令后才会被访问 每个页面都可以用在该页面 首次被访问前

10、所要执行的指令数进行标记?伪代码实现void OPT()for(i=0;iLEN;i+)如果帧已经填满假设在帧中找到该页命中，退出否那么找到最远使用的页面置换 假设帧未填满命中，那么退出否那么，参加空闲帧中?运行结果演示?先进先出法(Fisrt In First Out )?根本思想：FIFO最简单的页置换算法，FIFO的页置换的算法为每个页记录着该页调入内存的时间当必须置换一页时，将选择最旧的页。注意并不需要记录调入一页确实切时间，可以创立一个FIFO队列来管理内存中的所有页。队列中的首页将被置换。当需要调入页时，将它参加到队列的尾部。FIFO的页置换算法很好理解和实现，但是，其性能并不是很

11、好。所替代的页可能是很久以前使用的、现已不再使用的初始化模块，另一方面，所替代的页可能包含一个以前初始化的并且不断使用的常用变量 。?伪代码实现void FIFO()for(i=0;iLEN;i+)如果帧已经填满假设在帧中找到该页命中，退出否那么找到最先进入的页面置换假设帧未填满命中，那么退出否那么，参加空闲帧中?运行结果演示最近最久未使用(Least Rece ntly Used )?根本思想：LRU置换为每个页关联该页上次使用的时间。当必须置换一次的时候 ，LRU选择最长时间没有使用的页，这种策略为向后看最优页置换算法。LRU置换算法被认为相当不错，其主要问题是如何实现LRU置换，页帧的排

12、序序列按页帧上次使用时间来定，有 两种可行方法:计算器为每个页表项关联一个使用时间域，并为CPU增加一个逻辑时钟或者计数器。对每次内存引用，计算器都会增加，每次内存引用的时候时钟存放器的内容会被复制到相应页所对应的页表项的使用时间域内。用这种方式就得到每页的最近使用时间。置换具有最小时间的页。这种方案需要搜索页表已经查找LRU也，且每次内存访问都要写入内存。在改变页表时，因CPU调度，也必须保持时间。必须考虑时钟溢出。栈 每当引用一个页，该页就从栈中删除并放在顶部。这样，栈顶部总是最近使用的页，栈底部总是LRU页。由于必须是从栈中删除项，所以，该栈可实现为具有头部指针和尾指是LRU页。针的双向

13、链表。虽然每个更新有点费事，但是置换不需要搜索；尾部指针指向栈底部，就?伪代码实现void LRU() for(i=0;iLEN;i+)如果帧已经填满假设在帧中找到该页命中，并将该页放到帧的最后，标志最近使用退出 否那么找到最近最不常用的页面置换假设帧未填满命中，那么退出否那么，参加空闲帧中?运行结果演示?最不经常使用法(Least Freque ntly Used )?根本思想：即LFU算法(Least Frequently Used algorithm)。这种算法选择近期最少 访问的页面作为被替换的页面。显然，这是一种非常合理的算法，因为到目前为止最少使用的页面，很可能也是将来最少访问的页

14、面。该算法既充分利用了主存中页面调度情况的历史信息，又正确反映了程序的局部性。该算法在需要淘汰某一页时，首先淘汰到当前时间为止，被访问次数最少的那一页。该算法只要在页表中给每一页增设一个访问计数器即可实现。每当该页被访问时，访问计数器加 1 ,而发生一次缺页中断时，那么淘汰计数值最小的那一页，并将所有的计数器清零。?伪代码实现void LFU() 最不经常使用法for(i=0;iLEN;i+)如果帧已经填满假设在帧中找到该页命中，该页面标志计数器加1,退出否那么找到计数值最小的页面置换假设帧未填满，命中该页面标志计数器加1，退出否那么，参加空闲帧中?运行结果演示?最近未使用法(No Used

15、Recen tly )?根本思想：该算法在需要淘汰某一页时，从那些最近一个时期内未被访问的页中任选一页淘汰。NRU为操作系统请求分页存储管理中的页面淘汰算法，又名近似的LRU置换算法。当一存储块中的页面访问时，其相应的页面访问位由硬件自动置“ 1而由页面管理 体制软件周期性地(设周期为T,其值通常为几百毫秒)，把所有的页面访问位重新置为“0这样，在时间T内，某些被访问的页面，其对应的访问位为“1而未访问的页面，其 对应的访问位为“0查寻页面访问位为“0勺页面。在查找过程中，那些被访问的页所对应的访问位被重新置为 “0由此可见，实际上这种近似 LRU算法，已经退化成一种 最近不用的算法 NRU

16、( Not Recently Used )。?伪代码实现void NUR() 最近未使用法void NRU() 最近未使用法for(i=0;iLEN;i+)模拟周期性将每一页的计数器清0如果帧已经填满假设在帧中找到该页命中，该页面标志计数器置1退出否那么找到计数值为 0的页面置换，并将新页面计数器置假设所有计数值为1，那么选首页置换假设帧未填满，命中，该页面标志计数器置1，退出否那么，参加空闲帧中，并将新页面计数器置1?运行结果演示五、各种算法运行综合比拟因为每个算法在运行时请求是随机分配的，所以要比拟不同算法的优劣需要将不同的算法放在一个程序中，并行执行，打印在一块，方便观察六、实验心得，开

17、始编伙伴算法时，没有考虑合并1: 要编程的第一件事情是先把这个算法的思想弄明白 状况，没有设置对于相同伙伴的合并的判断位 ，以至于到了后来只能重新修改结构2: 没搞清楚伙伴的定义，未考虑到伙伴的地址必须块地址连续 ，强行将两个大小相同，但 地址不知道连不连续的块合并在一起 ，最后发现这样会导致程序停止运行 ，这个问题一直 到写报告时，将书上相关知识写入文档时才发现 ，然后豁然开朗，改变了合并方式，程序 就可以正常运行了 。这个经历也让我发现了边写实验报告 ，边编程的重要性，比一味的编 程更重要的是，在发现错误时，首先要考虑的是自己的编程思想是否正确 ，其次才是语法 问题。3: 合并是一个链式问

18、题，不是合并一次就可以的，而是每一次合并都要一直检测，在更大一级的链表中是否有伙伴存在，直到不能合并或者已经合并到了最大块为止 。4: 位图法是一种很好的标志位方法。有了它可以很方便的寻找空闲块，并进行相关的合并分配操作。用二进制的思想考虑问题 ，有时候可以事半功倍。5: 很久以前是老师强制我们在编程前先画流程图 ，做为作业的一局部，现在，我发现先画 个流程图或者先写个伪代码能让人先对程序的整体框架有一个把握 ，就像树的主干一样 如果流程图画对了的话，接下来把程序的具体实现填充进去 ，就可以很方便的实现程序功 能了。在伙伴算法实现中，因为没有从全局出发，导致的反复的修改程序，让我体会到了 一定

19、要画出。在实验报告中，为了，来说明编程思想。正确的流程图，或是先写对伪代码再进行编程的重要性简洁，我没有附加流程图，但是将相应的伪代码写入报告6: 下面对于五种页面的置换算法进行了编程实验 师给出了实现的分析，对于如何入手写出了详细的方法这局部实现起来就比拟简单了 ，因为老。对于虚拟存储区和内存工作区的不同算法，其中主要的流程：首先用srand()和rand()函数定义和产生指令序列，然后将 指令序列变换成相应的页地址流，并针对不同的算法计算出相应的命中率。并给出了具体的例子来帮我们分析实验。这局部的难点就在于区分不同的算法，并对各种算法的排序问题和取代给 出自己的方法7:最正确置换算法使用的

20、是最远使用的页面置换，又叫向前看最优置换算法 。而 LRU 选择最长时间没有使用的页，这种策略为向后看最优页置换算法。& LRU 置换算法关于页帧的排序序列按页帧上次使用时间来定，有两种可行方法：计算器和栈。在这次实验中我选用了计算法方法 ，这只需要加标志位即可，用栈的话还得另外 再加操作， 比拟复杂。9: 在打印各种算法的命中率时，我想按照制表法来打印，结果发现总是有错位现象，因为每次请求是随机分配，所以无法限定打印方式，总是有错位现象。，同时也熟悉了10 : 这次实现，通过编程的实验，让我对各种算法的原理了解的更为深刻 一下编程的方法，将 C 编程方法温习了一下。温故而知新，学到了很多 七

21、、程序源代码?伙伴算法#in clude#in clude#in clude#in clude struct nodeint much;int flag,flag_left,flag_right;struct node *leftchild,*rightchild,*father;struct IN_Tint num;int space;struct node *temp;struct IN_T str20;struct node *root,*temp_root,*temp;struct node *temp_l,*temp_r;int total_space=1024,space_num1

22、025;int apply_ num=0,release_ num=0,fi nd_space=0,str_lock20;void produce_ num()int i;for(i=0;i0)space_ nu mt_;total_space=total_space-t;return t;elseint temp=t;t=t*2;while(t0)space_ nu mt_;int temp_2=t/2;while(temp_2=temp)space_ nu mtemp_2+; temp_2=temp_2/2;total_space=total_space-temp;break;elset=

23、t*2;if(tmuch=space&(head-flag=O)if(space=really_ need)head-flag=1;temp=head;elseint x=space/really_ need;x=x/2;while(x)temp_l=(struct no de*)malloc(sizeof(struct no de); temp_r=(struct no de*)malloc(sizeof(struct no de); head-flag=1;head-leftchild=temp_l;head-rightchild=temp_r;temp_l-father=head;tem

24、p_l-much=(head-much)/2;temp_l-flag=1;temp_l-leftchild=NULL;temp_l-rightchild=NULL;temp_r-father=head;temp_r-much=(head-much)/2;temp_r-flag=0;temp_r-leftchild=NULL;temp_r-rightchild=NULL;x=x/2;head=head-leftchild;temp=head;search_tree(head-leftchild,space,really_ need); search_tree(head-rightchild,sp

25、ace,really_ need);void back_to_space(i nt i)struct node *tempx=(struct no de*)malloc(sizeof(struct no de); int or_no t=0;total_space=total_space+stri.space;tempx=stri.temp;prin tf(already release the %d of %dn s,tri.space,stri. nu m); tempx_flag=O;space_ nu mtempx-much+;tempx=tempx-father;if(tempx)i

26、f(tempx-leftchild-flag=0) tempx-flag_left=0;elsetempx-flag_left=1;if(tempx-rightchild-flag=0) tempx-flag_right=0;elsetempx-flag_right=1;while(tempx!=NULL)&(tempx-flag+(tempx-flag_left)+(tempx- flag_right)=1)tempx-flag=0;tempx-flag_left=tempx-flag_right=0;space_ nu m(tempx-leftchild)-much=space_ nu m

27、(tempx-leftchild)- much-2;space_ nu mtempx-much+; tempx-leftchild=tempx-rightchild=NULL;tempx=tempx-father;if(tempx)if(tempx-leftchild-flag=0) tempx-flag_left=0;elsetempx-flag_left=1;if(tempx-rightchild-flag=0) tempx-flag_right=0;elsetempx-flag_right=1;int how_much_space(i nt a)if(a512) return 1024;

28、if(a256) return 512;if(a128) return 256;if(a64) return 128;if(a32) return 64;if(a16) return 32;if(a8) return 16;if(a4) return 8;if(a2) return 4;if(a1) return 2;else return 1;DWORD WINAPI release 。 while(1)Sleep(ra nd()%3);if(apply_ num)int c=ra nd()%apply_ num;if(str_lockc=0)back_to_space(c);str_loc

29、kc=1;release_ nu m+;if(release_ num=20) break;DWORD WINAPI apply()while(1)Sleep(ra nd()%3);int t=how_much_space(strapply_ nu m. nu m); n eed how big space if(total_space=t)int have_space=search(t);if(have_space)temp_root=root;search_tree(temp_root,have_space,t);strapply_ nu m.space=t;strapply_ nu m.

30、temp=(struct no de*)malloc(sizeof(struct no de);strapply_ nu m.temp=temp;prin tf(already give %d the %dn ,strapply_ nu m. nu m,t);apply_ nu m+;if(apply_ num=20) break;elseprin tf(There is no space to apply %d because offragme nt.n,strapply_ nu m. nu m);Sleep(2000);elseprin tf(There is no much space

31、to apply %d!n,strapply_ nu m. nu m);Sleep(2000); int mai n()DWORD Threadld1,Threadld2;HANDLE ThreadHa ndle1,ThreadHa ndle2;/根节点的初始化，貌似方法比拟 2。root=(struct no de*)malloc(sizeof(struct no de); temp_root=(struct no de*)malloc(sizeof(struct no de); temp=(struct no de*)malloc(sizeof(struct no de); root-fa

32、ther=NULL;root-leftchild=NULL;root-rightchild=NULL; root-much=1024;root-flag=0;root-flag_left=root-flag_right=0; temp_root=root;/srand (time(NULL);produce_ num();int i;for(i=0;i1025;i+)space_ nu mi=0;space_ nu m1024=1;for(i=0;i20;i+)str_locki=0;ThreadHa ndle 仁 CreateThread(NULL,O,release,NULL,O, &Th

33、readld1);ThreadHa ndle2=CreateThread(NULL,0,apply,NULL,0, &Threadld2);if(ThreadHa ndle1!=NULL)WaitForSi ngleObject(ThreadHa ndle1,INFINITE);CloseHa ndle(ThreadHa ndle1);if(ThreadHa ndle2!=NULL)WaitForSi ngleObject(ThreadHa ndle2,INFINITE);CloseHa ndle(ThreadHa ndle2);system(pause);?最正确置换算法#in clude#

34、in clude#in clude#in clude int str320;/320 条指令int page32; 物理内存页int page_lock32;in t cou nt_nu m32;int error=0;int already_give n=0;int fin d_page(i nt i)return (i/10);int page_scheldu in g_opt(i nt num)int i,j,m,n,count,find;for(i=0;i nu m;i+) pagei=_1;page_locki=0;for(i=0;i320;i+)fin d=0;coun t=0;f

35、or(j=0;jalready_give n;j+)if(page j=stri)fin d=1;break;if(!fi nd)error+;for(n=0; nnu m; n+)page_lock n=0;if(already_give nnum)pagealready_give n=stri;already_g iven+;elsefor(m=i;m320&(co untnu m);m+)for(n=0; nnu m; n+) if(strm=page n) page_lock n=1; coun t+;for(n=0; nnu m; n+)if(page_lock n=0)page n

36、=stri; break;main ()int i,j,m,n,upper,least,x=0;for(i=0;i320;i+)stri=i;i=0;upper=319;least=0;srand (time(NULL);while(i80)/every time 4 ordersm=least+ra nd()%(upper+1); m/ 执行 m+1strx+=fi nd_page(m+1);n=least+ra nd()%(m+2); m/ 执行 n 和 n+1strx+=fi nd_page( n);strx+=fi nd_page( n+1); n=n+2+ra nd()%(320-n

37、-2);/ 执行 nstrx+=fi nd_page( n);upper =n;least=0;i+;printf(当前运行的算法是OPT算法n);for( j=4;j33;j+)prin tf(%d:t,j);error=0;for(i=0;i32;i+)pagei=0;page_locki=0;i=0;error=0;already_give n=0;page_scheldu in g_opt(j);prin tf(%.2f,%dt,1-(float)error/320,error);if( j-3)%3=0&j!=4)prin tf(n );prin tf(n );system(paus

38、e);?先进先出法#in clude#in clude#in clude#in clude int str320;/320 条指令int page32; 物理内存页int page_lock32;in t cou nt_nu m32;int error=0;int already_give n=0;int fin d_page(i nt i)return (i/10);int page_scheldu in g_fifo(i nt num)int i,j,m,n,count=0,find;for(i=0;i320;i+)fin d=0;coun t=0;for(j=0;jalready_giv

39、e n;j+)if(pagej=stri) fin d=1;break;if(fin d=0)if(already_give nnum)pagealready_give n=stri; already_give n+;else if(already_give n=num)for(j=0;jalready_give n_1;j+)pagej=pagej+1;page j=stri;error+;main ()int i,j,m,n,upper,least,x=O;for(i=0;i320;i+)stri=i;i=0;upper=319;least=0;srand (time(NULL);whil

40、e(i80)/every time 4 ordersm=least+ra nd()%(upper+1); m/ 执行 m+1strx+=fi nd_page(m+1);n=least+ra nd()%(m+2); m/ 执行 n 和 n+1strx+=fi nd_page( n);strx+=fi nd_page( n+1); n=n+2+ra nd()%(320-n-2);/ 执行 nstrx+=fi nd_page( n);upper =n;least=0;i+;printf(当前运行的算法是FIFO算法n);for( j=4;j33;j+)prin tf(%d:t,j);error=0;

41、page_locki=0;i=0;error=0;already_give n=0;page_scheldu in g_fifo(j);prin tf(%.2f,%dt,1-(float)error/320,error);if( j-3)%3=0&j!=4)prin tf(n );prin tf(n );system(pause);?最近最久未使用#in clude#in clude#in clude#in clude int str320;/320 条指令int page32;/ 物理内存页int page_lock32;in t cou nt_nu m32;int error=0;int

42、already_give n=0;int fin d_page(i nt i)return (i/10);int page_scheldu in g_LRU(i nt num)int i,j,m,n,count=O,find;for(i=0;i320;i+)fin d=0;coun t=0;for(j=0;jalready_give n;j+)if(page j=stri)fin d=1;for( j=i;jalready_give n-1;j+)page j=pagej+1;pagej=stri;break;if(fin d=0)if(already_give nnum)pagealread

43、y_give n=stri;already_give n+;else if(already_give n=num)for( j=O;jalready_give n_1;j+)page j=pagej+1;pagej=stri;error+;main ()int i,j,m,n,upper,least,x=O;for(i=0;i320;i+)stri=i;i=0;upper=319;least=0;srand (time(NULL);while(i80)/every time 4 ordersm=least+ra nd()%(upper+1); m/ 执行 m+1 strx+=fi nd_pag

44、e(m+1); n=least+ra nd()%(m+2); m / 执行 n 和 n+1 strx+=fi nd_page( n); strx+=fi nd_page( n+1); n=n+2+ra nd()%(320-n-2);/ 执行 nstrx+=fi nd_page( n); upper =n;least=0;printf(当前运行的算法是LRU算法n);for( j=4;j33;j+)prin tf(%d:t,j);error=0;for(i=0;i32;i+)pagei=0;page_locki=0;i=0;error=0;already_give n=0;page_scheld

45、u in g_LRU( j);prin tf(%.2f,%dt,1-(float)error/320,error);if( j-3)%3=0&j!=4)prin tf(n );prin tf(n );system(pause);?最不经常使用法#in clude#in clude#in clude#in clude int str320;/320 条指令int page32; 物理内存页int page_lock32;in t cou nt_nu m32;int error=0;int already_give n=0;int fin d_page(i nt i)return (i/10);i

46、nt page_scheldu in g_LFU(i nt num)int i,j,m,n,count,find,least,least_lock;for(n=0;n 32; n+)count_numn=0;for(i=0;i nu m;i+)pagei=-1;for(i=0;i320;i+)fin d=0;for(j=0;jalready_give n;j+)if(pagej=stri)fin d=1;break;if(!fi nd)error+;if(already_give nnum)pagealready_give n=stri;already_g iven+;count_nu mstri+;elseleast=co unt_nu mpageO;least_lock=0;for(n=1; nnum;n+)if(co unt_nu mpage nleast)least=co unt_numpage n; least_lock=n;pageleast_lock=stri;count_nu mstri+;main ()int i,j,m,n,upper,least,x=O;for(i=0;i320;i+)stri=i;i=0;upper=319;least=0;srand (time(NULL);while(i80)/every time 4 orders m=lea