操作系统学习之用C语言模拟FIFO算法

前言

FIFO算法比较简单，没什么好说的，就是先进先出。不过我添加了3状态，不过也只有堵塞，没有将阻塞进程唤醒的过程。

Buddy算法：操作系统学习之用C语言模拟伙伴(Buddy)算法
FIFO算法：操作系统学习之用C语言模拟FIFO算法
LRU算法：操作系统学习之用C语言模拟LRU算法
Clock算法：操作系统学习之用C语言模拟CLOCK算法
本源代码原创，转载请注明，同时由于本人才疏学浅，刚入门操作系统，如有错误敬请指教
本文原创，创作不易，转载请注明！！！
本文链接
个人博客：https://ronglin.fun/?p=199
PDF链接：见博客网站
CSDN: https://blog.csdn.net/RongLin02/article/details/117632249

算法模拟

算法解释

先来看看课本是怎么解释FIFO(First In First Out 先进先出)算法的。
FIFO策略把分配给进程的页框视为一个循环缓冲区，并按循环方式移动页。他需要的只是的一个指针，该指针在进程的页框中循环。因此这是一个实现起来最简单的页面置换策略。除简单外，这种方法所隐含的逻辑是置换驻留在内存中时间最长的页：很久以前换入内存的页，现在可能不会再用到。这一推断通常是错误的，因为经常会出现一部分程序或数据在整个程序的生命周期中使用频繁率都很高的情况，若使用FIFO算法，则这些页需要被反复地换入和换出。 ——操作系统-精髓与设计原理(第九版)P227

代码解释

简单的来说，就是这个算法实现起来很简单，但是由于程序局部性原理，可能会产生很高的缺页率，简单的用C模拟一下，如果内存调用进程，用FIFO算法，会大概发生什么情况。
来一个进程，先判断当前内存剩余大小能否放下，如果放不下，就搁置这个进程，如果放的下。就判断其是否需要io操作，如果需要，把状态切换到阻塞态,如果不需要就变成运行态。

源代码

直接看源代码叭：

#include<stdio.h>
#include<stdlib.h>
#include <time.h>
#define MAX_NUM_PROC 10
#define MAX_PROC_SIZE 300
#define MAX_MEMORY 1024


//进程结构体
//state 阻塞-1 就绪0 运行1
struct Process
{
    int pid;
    int ppid;
    int state;
    int p_size;
    int io;

    void init()
    {
        pid = -1;
        ppid = -1;
        state = 0;
        p_size = 0;
        io = 0;
    }
}procs[MAX_NUM_PROC];


void printProc(struct Process proc);

int main()
{
    int use_memory=0;
    for(int i=0;i<MAX_NUM_PROC;i++)
    {
        procs[i].init();
        procs[i].pid=i+1;
        if((i+1)%3==0)
            procs[i].io=i+1;
        srand((unsigned)time(NULL)*i);
        procs[i].p_size=rand() % MAX_PROC_SIZE +1;
    }

    for(int i=0;i<MAX_NUM_PROC;i++)
    {
        if(MAX_MEMORY - use_memory - procs[i].p_size > 0)
        {
            procs[i].state = 1;
            use_memory += procs[i].p_size;
            if(procs[i].io)
            {
                procs[i].state = -1;
            }
        }
        else
        {
            procs[i].state = 0;
        }

    }

    printf("%d\n",use_memory);
    for(int i=0;i<MAX_NUM_PROC;i++)
    {

        printProc(procs[i]);
    }

    return 0;
}

void printProc(struct Process proc)
{
    printf("pid = %d ",proc.pid);
    printf("p_size = %d ",proc.p_size);
    printf("io = %d ",proc.io);
    printf("state = %d ",proc.state);
    printf("\n");

}

输出解释

980
pid = 1 p_size = 39 io = 0 state = 1
pid = 2 p_size = 289 io = 0 state = 1
pid = 3 p_size = 171 io = 3 state = -1
pid = 4 p_size = 53 io = 0 state = 1
pid = 5 p_size = 235 io = 0 state = 1
pid = 6 p_size = 117 io = 6 state = -1
pid = 7 p_size = 299 io = 0 state = 0
pid = 8 p_size = 181 io = 0 state = 0
pid = 9 p_size = 63 io = 9 state = -1
pid = 10 p_size = 13 io = 0 state = 1

10个进程，第一行是使用的内存大小，p_size是进程所占用的空间，io是所需要的io请求序号，state是状态
一个进程刚开始被创建，如果内存放的下，就直接运行，状态变成1，如果有io请求，状态变成-1，如果内存放不下就保持0；

总结

本来最开始想用七状态模型写的，但是构思的时候发现很麻烦，要维护7个链表，时间关系，就简单的模拟一下叭 =w=