oslab2 进程通信与内存管理

进程的软中断通信

代码

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <signal.h>

int flag=0;

void inter_handler(int sig) {
    // TODO
if (sig == SIGINT || sig == SIGQUIT || sig == SIGALRM){
        flag = sig;
    }
}
void waiting() {
    // TODO
    while(flag==0){
        pause();
    }
}
int main() {
    // TODO: 五秒之后或接收到两个信号
    signal(SIGINT, inter_handler);
    signal(SIGQUIT, inter_handler); 
    signal(SIGALRM, inter_handler);
    alarm(5);
    pid_t pid1=-1, pid2=-1;
    while (pid1 == -1)pid1=fork();//创建子进程1
    if (pid1 > 0) {//子进程创建成功,当前为父进程
        while (pid2 == -1)pid2=fork();//创建子进程2
        if (pid2 > 0) {
            // TODO: 父进程
            // 等待信号
            waiting();
            printf("\n%d stop test\n",flag);
            sleep(1);
            kill(pid1, 16);  // 向子进程1发送信号16
            kill(pid2, 17);  // 向子进程2发送信号17
            wait(NULL);//等待子进程1
            wait(NULL);//等待子进程2
            printf("\nParent process is killed!!\n");
        } else {
            // TODO: 子进程 2
            signal(17,inter_handler);
            pause();//子进程2等待软中断信号17
            printf("\n17 stop test\n");
            printf("\nChild process2 is killed by parent!!\n");
            return 0;
        }
    } else {//当前不是父进程
        // TODO:子进程 1
        signal(16,inter_handler);
        pause();//子进程1等待软中断信号16
        printf("\n16 stop test\n");
        printf("\nChild process1 is killed by parent!!\n");
        return 0;
    }
    return 0;
}

运行结果

5秒内按下 Ctrl+C

file-20251118214246904.png

5秒内按 Ctrl+\

file-20251118214304149.png

5秒内不进行任何操作

file-20251118233014877.png

实验报告问题回答

  1. 你最初认为运行结果会怎么样?写出你猜测的结果。
    预计父进程会创建两个子进程,收到信号后杀死它们,然后自己结束
  2. 实际的结果什么样?有什么特点?在接收不同中断前后有什么差别?请将 5 秒内中断和 5 秒后中断的运行结果截图,试对产生该现象的原因进行分析。
    三种中断源都会触发相同流程;差别:只是触发信号编号不同,但处理逻辑一致
  3. 改为闹钟中断后,程序运行的结果是什么样子? 与之前有什么不同?
    在5s内没有任何操作,然后程序会自动触发软中断,输出14 stop test,其余一致。区别是这种方式是自动的,不需要手动输入信号。
  4. kill 命令在程序中使用了几次?每次的作用是什么?执行后的现象是什么?
    两次,分别向子进程1发送信号 16,向子进程2发送信号17。子进程收到后终止。
  5. 使用 kill 命令可以在进程的外部杀死进程。进程怎样能主动退出?这两种退出方式哪种更好一些?
    主动退出的方法:

进程的管道通信

代码

/*管道通信实验程序 */
#include <unistd.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>

int pid1, pid2; // 定义两个进程变量
int main()
{
    int fd[2];
    char InPipe[4000]; // 定义读缓冲区
    char c1 ='1', c2 ='2';
    pipe(fd); // 创建管道

    while ((pid1 = fork()) == -1); // 如果进程 1 创建不成功,则空循环
    if (pid1 == 0)
    {//子进程1
        lockf(fd[1],1,0);    // 锁定管道
        for(int i = 0 ; i < 2000; i++)
            write(fd[1], &c1, 1); 
        sleep(5);
        lockf(fd[1],0,0); // 解除管道的锁定
        exit(0);  // 结束进程 1
    }
    else
    {//父进程
        while ((pid2 = fork()) == -1); // 若进程 2 创建不成功,则空循环
        if (pid2 == 0)
        {//子进程2
            lockf(fd[1], 1, 0);
        for(int i = 0 ; i < 2000; i++)
            write(fd[1], &c2, 1); 
            sleep(5);
            lockf(fd[1], 0, 0);
            exit(0);
        }
        else
        {//父进程
            wait(NULL);                // 等待子进程 1 结束
            wait(NULL);                // 等待子进程 2 结束
            int end = read(fd[0], InPipe, 4000);  
            InPipe[end] = '\0';    // 加字符串结束符
            printf("%s\n", InPipe); // 显示读出的数据
            exit(0);                // 父进程结束
        }
    }
}

运行结果、

有锁

file-20251119002612308.png

无锁

file-20251119002712800.png

实验报告

  1. 你最初认为运行结果会怎么样?
    输出1111.....11111.....2222.....22222
  2. 实际的结果什么样?有什么特点?试对产生该现象的原因进行分析。
    在不加锁的情况下,输出就是1与2交叉的。加锁的情况下则不存在交叉,分别输出2000个1和2000个2。对管道写端加互斥锁,使得两个子进程不能同时写入管道。
  3. 实验中管道通信是怎样实现同步与互斥的?如果不控制同步与互斥会发生什么后果?

页面的置换

代码

#include <stdio.h>
#include <stdlib.h>

#define MAX_REF 1000      // 最大引用串长度
#define MAX_MEM 20        // 最大物理块数

int ref[MAX_REF];         // 页面引用串
int ref_len;              // 引用串长度
int mem_size;             // 物理块数

void debug_print_mem(int mem[], int mem_size) {
    printf("[ ");
    for (int i = 0; i < mem_size; i++) {
        if (mem[i] == -1) printf("_ ");
        else printf("%d ", mem[i]);
    }
    printf("]");
}

void FIFO()
{
    int mem[MAX_MEM], front = 0;
    int faults = 0;
    for (int i = 0; i < mem_size; i++)
        mem[i] = -1;//初始化


    for (int i = 0; i < ref_len; i++) {
        int page = ref[i];
        int hit = 0;
        for (int j = 0; j < mem_size; j++) {
            if (mem[j] == page) {
                hit = 1;
                break;
            }
        }

        if (!hit) {     // 缺页
            faults++;
            mem[front] = page;
            front = (front + 1) % mem_size;

            debug_print_mem(mem, mem_size);
            printf("\n");
        }
    }

    printf("\nFIFO 总缺页次数:%d,缺页率:%.2f%%\n",
           faults, faults * 100.0 / ref_len);
}

void LRU()
{
    int mem[MAX_MEM], last_used[MAX_MEM];
    int faults = 0;
    for (int i = 0; i < mem_size; i++) {
        mem[i] = -1;
        last_used[i] = -1;
    }

    for (int t = 0; t < ref_len; t++) {
        int page = ref[t];
        int hit = 0;

        for (int j = 0; j < mem_size; j++) {
            if (mem[j] == page) {
                hit = 1;
                last_used[j] = t;
                break;
            }
        }

        if (!hit) {   // 缺页
            faults++;
            printf("缺页 -> 调入页面 %d : ", page);
            int victim = 0;
            for (int j = 1; j < mem_size; j++)
                if (last_used[j] < last_used[victim])
                    victim = j;
            mem[victim] = page;
            last_used[victim] = t;

            debug_print_mem(mem, mem_size);
            printf("\n");
        }
    }

    printf("\nLRU 总缺页次数:%d,缺页率:%.2f%%\n",
           faults, faults * 100.0 / ref_len);
}

void gen_random_ref()
{
    printf("请输入引用串长度:");
    scanf("%d", &ref_len);

    for (int i = 0; i < ref_len; i++)
        ref[i] = rand() % 10;     // 0~9 的页面号

    printf("随机生成的引用串:\n");
    for (int i = 0; i < ref_len; i++)
        printf("%d ", ref[i]);
    printf("\n");
}

void input_ref()
{
    printf("请输入引用串长度:");
    scanf("%d", &ref_len);

    printf("逐个输入页面号:\n");
    for (int i = 0; i < ref_len; i++) {
        scanf("%d", &ref[i]);
    }
}

int main()
{
    int choice;
    mem_size = 5;
    printf("\n引用串生成方式:\n1. 随机生成\n2. 手动输入\n选择:");
    scanf("%d", &choice);

    if (choice == 1) gen_random_ref();
    else input_ref();

    printf("\n选择页面置换算法:\n1. FIFO\n2. LRU\n选择:");
    scanf("%d", &choice);

    if (choice == 1) FIFO();
    else LRU();

    return 0;
}

运行结果

FIFO

file-20251119164338522.png

LRU

file-20251119164539647.png

Belady

物理块数3:
file-20251119164254229.png
物理块数4:
file-20251119164314897.png

实验报告

  1. 从实现和性能方面,比较分析 FIFO 和 LRU 算法。
    FIFO:先进先出,一般使用队列,不体现局部性原理,比较简单,可能会出现Belady异常。
    LRU:优先替换长时间未使用的,一般增加带时间戳的数据,体现局部性原理,使用过的数据在一定时间内或一定位置内可能会被多次使用,较复杂。由于局部性原理,缺页率一般会更低。
  2. LRU 算法是基于程序的局部性原理而提出的算法,你模拟实现的 LRU 算法有没有体现出该特点?如果有,是如何实现的?
    每次访问页面时都对其时间戳进行更新,如果缺页,则找到时间戳最久的进行替换,这样保证最近使用过的页面不会被替换。
  3. 在设计内存管理程序时,应如何提高内存利用率。