2020 OS_HW3 RAM与Disk读写速度对比

实验目的

1. 熟悉类 UNIX 系统的 I/O 设备管理
2. 熟悉 MINIX 块设备驱动
3. 熟悉 MINIX RAM 盘

实验环境

开发环境：VS Code (GNU)

宿主机系统环境：Windows10 + WSL2（Ubuntu 20.04）

虚拟机应用：VMware WorkStation16

虚拟机环境：MINIX3

实验过程

源码版本回退

输入命令 git reset HEAD^即可回退到project-2的前一个版本（原始版本）

创建 RAM 盘并挂载

列出需要新增/修改的文件：

• /usr/src/minix/drivers/storage/memory/memory.c M
• /usr/src/minix/commands/ramdisk/Makefile M
• /usr/src/minix/commands/ramdisk/buildmyram.c U

1. 在 /usr/src/minix/drivers/storage/memory/memory.c 中将

   1
   RAMDISKS=6

   改为

   1
   RAMDISKS=7

2. 在 /usr/src/minix/commands/ramdisk/Makefile 中添加

   1
   PROG=  buildmyram

3. 添加文件 buildmyram.c （仿照 ramdisk.c 实现）

   1
   #include <minix/paths.h>
   2
   
   3
   #include <sys/ioc_memory.h>
   4
   #include <stdio.h>
   5
   #include <fcntl.h>
   6
   #include <stdlib.h>
   7
   
   8
   int
   9
   main(int argc, char* argv[]) {
   10
       int fd;
   11
       signed long size;
   12
       char* d;
   13
   
   14
       if (argc < 2 || argc > 3) {
   15
           fprintf(stderr, "usage: %s <size in MB> [device]\n",
   16
               argv[0]);
   17
           return 1;
   18
       }
   19
   
   20
       d = argc == 2 ? _PATH_RAMDISK : argv[2];
   21
       if ((fd = open(d, O_RDONLY)) < 0) {
   22
           perror(d);
   23
           return 1;
   24
       }
   25
   
   26
   #define MFACTOR 1048576
   27
       size = atol(argv[1]) * MFACTOR;
   28
   
   29
       if (size < 0) {
   30
           fprintf(stderr, "size should be non-negative.\n");
   31
           return 1;
   32
       }
   33
   
   34
       if (ioctl(fd, MIOCRAMSIZE, &size) < 0) {
   35
           perror("MIOCRAMSIZE");
   36
           return 1;
   37
       }
   38
   
   39
       fprintf(stderr, "size on %s set to %ldMB\n", d, size / MFACTOR);
   40
   
   41
       return 0;
   42
   }

4. 创建 RAM 盘

   输入命令 mknod /dev/myram b 1 13 来创建实验用 RAM 盘，可以使用 ls /dev/ | grep ram 来查看是否创建成功

   在root目录下创建文件夹 myram 便于接下来的挂载

5. 设置 RAM 大小并挂载

   由于每次重启都要重新设置 RAM 的大小并挂载，这里写一个脚本 project3.sh 来实现

   Terminal window

   1
   buildmyram 512 /dev/myram
   2
   mkfs.mfs /dev/myram
   3
   mount /dev/myram /root/myram
   4
   df

   首次运行前，需要先输入 chmod u+x project3.sh 后，输入 ./project3.sh

测试代码

任务一：探究并发数为多少时，吞吐量达到饱和

代码如下：

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <unistd.h>
4
#include <sys/types.h>
5
#include <sys/stat.h>
6
#include <fcntl.h>
7
#include <math.h>
8
#include <errno.h>
9
#include <time.h>
10

11
const char filepath[] = "/root/myram/test.txt";
12
int text[1024];
13

14
void
15
write_file(int blocksize) {
16
    int fd = open(filepath, O_RDWR | O_CREAT | O_SYNC, 0755);
17
    if (fd < 0)
18
        perror("open");
19
    for (int i = 0;i < 1000;i++) {
20
        if (write(fd, text, blocksize) != blocksize)
21
            perror("write");
22
    }
23
    lseek(fd, 0, SEEK_SET);
24
}
25

26
int
27
main(void) {
28
    memset(text, 0, sizeof text);
29
    struct timeval t1, t2;
30
    for (int num = 1; num <= 120; num++) {
31
        gettimeofday(&t1, NULL);
32
        for (int i = 0;i < num; i++) {
33
            int pid = fork();
34
            if (pid == 0) {
35
                write_file(1024);
36
                exit(0);
37
            }
38
        }
39
        while (wait(NULL) != -1)
40
            ;
41
        gettimeofday(&t2, NULL);
42
        double t = (double)(t2.tv_sec - t1.tv_sec) * 1000 + (t2.tv_usec - t1.tv_usec) / 1000;
43
        double filesize = 1000 * sizeof(text) * num / 1024.0 / 1024.0 / t;
44
        if (t == 0)
45
            filesize = 0;
46
        printf("%lf,%lf,%d\n", filesize, t / 1000.0, num);
47
    }
48
}

在 MINIX 中运行上述代码，并输出到 res.txt 中。

传输到本机后，转换为 csv 文件，使用 python 处理数据后作图

1
import numpy as np
2
import pandas as pd
3
import matplotlib.pyplot as plt
4

5
df = pd.read_csv('res.csv')
6
df.sort_values(by=['process num'], inplace=True)
7
df = pd.DataFrame(df.groupby(by=['process num']).max())
8
df = df.replace([np.inf], np.nan)
9
print(df)
10
data = df.to_numpy()
11
data = pd.DataFrame(data, columns=['concurrency', 'time'])
12
data['concurrency'] = data['concurrency'].interpolate(method='spline', order=3)
13
data = data.dropna().to_numpy()
14
y1, y2 = [], []
15
for i in range(len(data)):
16
    y1.append(data[i][0])
17
    y2.append(data[i][1])
18
y1, y2 = np.array(y1), np.array(y2)
19
x = []
20
for i in range(1, 121):
21
    x.append(i)
22
x = np.array(x)
23
plt.plot(x, y1, label='concurrency')
24
plt.plot(x, y2, label='I/O latency')
25
plt.legend()
26
plt.show()

作图如下

可以发现进程数大约在 15 时，RAM 达到饱和，使得吞吐量趋于稳定

于是，将后续的并发数设置为 15

任务二：探究在不同 block size 条件下，RAM 与 Disk 的性能对比

1. 读写函数

1
void
2
write_file(int blocksize, bool isrand, char* filepath) {
3
    int fd = open(filepath, O_RDWR | O_CREAT | O_SYNC, 0755);
4
    if (fd == -1) perror("Open");
5
    for (int i = 0;i < MAX_ITER;i++) {
6
        if (write(fd, text, blocksize) != blocksize)
7
            perror("Write");
8
        if (isrand)
9
            lseek(fd, rand() % (MAX_FILESIZE - blocksize), SEEK_SET);
10
    }
11
    lseek(fd, 0, SEEK_SET);
12
}
13

14
void
15
read_file(int blocksize, bool isrand, char* filepath) {
16
    int fd = open(filepath, O_RDWR | O_CREAT | O_SYNC, 0755);
17
    if (fd == -1) perror("Open");
18
    for (int i = 0;i < MAX_ITER;i++) {
19
        if (read(fd, buff, blocksize) != blocksize)
20
            perror("Read");
21
        if (isrand)
22
            lseek(fd, (MAX_ITER - 1) * (rand() % blocksize), SEEK_SET);
23
    }
24
    lseek(fd, 0, SEEK_SET);
25
}

2. 时间计算，这里使用 struct timeval 来记录时间

   1
   double
   2
   calc_time(struct timeval t1, struct timeval t2) {
   3
       return (double)(t2.tv_sec - t1.tv_sec) * 1000 + (t2.tv_usec - t1.tv_usec) / 1000;
   4
   }

3. main函数，接受三个参数，argv[1] 表示读R或写W，argv[2] 表示是 RAMR还是 DiskD，argv[3] 表示是顺序S还是随机R

   1
   int
   2
   main(int argc, char* argv[]) {
   3
       printf("BlockSize(KB),FileSize(MB),Speed(MB/s)\n");
   4
       srand((unsigned)time(NULL));
   5
       struct timeval t1, t2;
   6
       double t;
   7
       for (int i = 0;i < MAX_BUFFER;i += 16) {
   8
           strcat(text, "1111111111111111");
   9
       }
   10
       for (int blocksize = 64;blocksize <= 1024 * 32;blocksize = blocksize * 2) {
   11
           int proc_num = 15;
   12
           gettimeofday(&t1, NULL);
   13
           for (int i = 0;i < proc_num;i++) {
   14
               if (fork() == 0) {
   15
                   if (strcmp(argv[1], "W") == 0) {
   16
                       if (strcmp(argv[2], "R") == 0) {
   17
                           if (strcmp(argv[3], "S") == 0)
   18
                               write_file(blocksize, false, filepathram[i]);
   19
                           else
   20
                               write_file(blocksize, true, filepathram[i]);
   21
                       }
   22
                       else {
   23
                           if (strcmp(argv[3], "S") == 0)
   24
                               write_file(blocksize, false, filepathdisk[i]);
   25
                           else
   26
                               write_file(blocksize, true, filepathdisk[i]);
   27
                       }
   28
                   }
   29
                   else {
   30
                       if (strcmp(argv[3], "R") == 0) {
   31
                           if (strcmp(argv[3], "S") == 0)
   32
                               read_file(blocksize, false, filepathram[i]);
   33
                           else
   34
                               read_file(blocksize, true, filepathram[i]);
   35
                       }
   36
                       else {
   37
                           if (strcmp(argv[3], "S") == 0)
   38
                               read_file(blocksize, false, filepathdisk[i]);
   39
                           else
   40
                               read_file(blocksize, true, filepathdisk[i]);
   41
                       }
   42
                   }
   43
                   exit(0);
   44
               }
   45
           }
   46
           while (wait(NULL) != -1);
   47
           gettimeofday(&t2, NULL);
   48
           t = calc_time(t1, t2) / 1000.0;
   49
           int total_size = blocksize * proc_num * MAX_ITER;
   50
   
   51
           printf("%lf,%lf,%lf\n", 1.0 * blocksize / 1024,
   52
               1.0 * total_size / 1024 / 1024, 1.0 * total_size / t / 1024 / 1024);
   53
           // printf("blocksize_KB=%.4fKB,filesize_MB=%.4fMB,speed=%fMB/s\n",
   54
       //     (double)blocksize / 1024.0,
   55
       //     (double)total_size / 1024.0 / 1024.0,
   56
       //     (double)total_size / t / 1024.0 / 1024.0);
   57
       }
   58
       return 0;
   59
   }

完整代码如下

1
#include<stdio.h>
2
#include<stdlib.h>
3
#include<unistd.h>
4
#include<sys/types.h>
5
#include<sys/stat.h>
6
#include<sys/wait.h>
7
#include<fcntl.h>
8
#include<time.h>
9
#include<string.h>
10
#include <errno.h>
11

12
#define MAX_ITER 1000
13
#define MAX_BUFFER (1024*1024)
14
#define MAX_FILESIZE (300*1024*1024)
15
#define MAX_BUFFSIZE (1024*1024*1024)
16

17
enum bool{ false, true };
18
typedef enum bool bool;
19

20
const char* filepathram[30] = {
21
    "/root/myram/test1.txt", "/root/myram/test2.txt",
22
    "/root/myram/test3.txt","/root/myram/test4.txt",
23
    "/root/myram/test5.txt","/root/myram/test6.txt",
24
    "/root/myram/test7.txt","/root/myram/test8.txt",
25
    "/root/myram/test9.txt","/root/myram/test10.txt",
26
    "/root/myram/test11.txt", "/root/myram/test12.txt",
27
    "/root/myram/test13.txt","/root/myram/test14.txt",
28
    "/root/myram/test15.txt","/root/myram/test16.txt",
29
    "/root/myram/test17.txt"
30
};
31

32
const char* filepathdisk[30] = {
33
    "/usr/test1.txt", "/usr/test2.txt",
34
    "/usr/test3.txt", "/usr/test4.txt",
35
    "/usr/test5.txt", "/usr/test6.txt",
36
    "/usr/test7.txt", "/usr/test8.txt",
37
    "/usr/test9.txt", "/usr/test10.txt",
38
    "/usr/test11.txt", "/usr/test12.txt",
39
    "/usr/test13.txt", "/usr/test14.txt",
40
    "/usr/test15.txt", "/usr/test16.txt",
41
    "/usr/test17.txt"
42
};
43

44
char text[MAX_BUFFER] = "11111111";
45
char buff[MAX_BUFFSIZE];
46

47
void
48
write_file(int blocksize, bool isrand, char* filepath) {
49
    int fd = open(filepath, O_RDWR | O_CREAT | O_SYNC, 0755);
50
    if (fd == -1) perror("Open");
51
    for (int i = 0;i < MAX_ITER;i++) {
52
        if (write(fd, text, blocksize) != blocksize)
53
            perror("Write");
54
        if (isrand)
55
            lseek(fd, (MAX_ITER - 1) * (rand() % blocksize), SEEK_SET);
56
    }
57
    lseek(fd, 0, SEEK_SET);
58
}
59

60
void
61
read_file(int blocksize, bool isrand, char* filepath) {
62
    int fd = open(filepath, O_RDWR | O_CREAT | O_SYNC, 0755);
63
    if (fd == -1) perror("Open");
64
    for (int i = 0;i < MAX_ITER;i++) {
65
        if (read(fd, buff, blocksize) != blocksize)
66
            perror("Read");
67
        if (isrand)
68
            lseek(fd, (MAX_ITER - 1) * (rand() % blocksize), SEEK_SET);
69
    }
70
    lseek(fd, 0, SEEK_SET);
71
}
72

73
double
74
calc_time(struct timeval t1, struct timeval t2) {
75
    return (double)(t2.tv_sec - t1.tv_sec) * 1000 + (t2.tv_usec - t1.tv_usec) / 1000;
76
}
77

78
int
79
main(int argc, char* argv[]) {
80
    printf("BlockSize(KB),FileSize(MB),Speed(MB/s)\n");
81
    srand((unsigned)time(NULL));
82
    struct timeval t1, t2;
83
    double t;
84
    for (int i = 0;i < MAX_BUFFER;i += 16) {
85
        strcat(text, "1111111111111111");
86
    }
87
    for (int blocksize = 64;blocksize <= 1024 * 32;blocksize = blocksize * 2) {
88
        int proc_num = 15;
89
        gettimeofday(&t1, NULL);
90
        for (int i = 0;i < proc_num;i++) {
91
            if (fork() == 0) {
92
                if (strcmp(argv[1], "W") == 0) {
93
                    if (strcmp(argv[2], "R") == 0) {
94
                        if (strcmp(argv[3], "S") == 0)
95
                            write_file(blocksize, false, filepathram[i]);
96
                        else
97
                            write_file(blocksize, true, filepathram[i]);
98
                    }
99
                    else {
100
                        if (strcmp(argv[3], "S") == 0)
101
                            write_file(blocksize, false, filepathdisk[i]);
102
                        else
103
                            write_file(blocksize, true, filepathdisk[i]);
104
                    }
105
                }
106
                else {
107
                    if (strcmp(argv[3], "R") == 0) {
108
                        if (strcmp(argv[3], "S") == 0)
109
                            read_file(blocksize, false, filepathram[i]);
110
                        else
111
                            read_file(blocksize, true, filepathram[i]);
112
                    }
113
                    else {
114
                        if (strcmp(argv[3], "S") == 0)
115
                            read_file(blocksize, false, filepathdisk[i]);
116
                        else
117
                            read_file(blocksize, true, filepathdisk[i]);
118
                    }
119
                }
120
                exit(0);
121
            }
122
        }
123
        while (wait(NULL) != -1);
124
        gettimeofday(&t2, NULL);
125
        t = calc_time(t1, t2) / 1000.0;
126
        int total_size = blocksize * proc_num * MAX_ITER;
127

128
        printf("%lf,%lf,%lf\n", 1.0 * blocksize / 1024,
129
            1.0 * total_size / 1024 / 1024, 1.0 * total_size / t / 1024 / 1024);
130
        // printf("blocksize_KB=%.4fKB,filesize_MB=%.4fMB,speed=%fMB/s\n",
131
    //     (double)blocksize / 1024.0,
132
    //     (double)total_size / 1024.0 / 1024.0,
133
    //     (double)total_size / t / 1024.0 / 1024.0);
134
    }
135
    return 0;
136
}

编写脚本 run.sh 如下

Terminal window

1
clang mission2.c -o mission2
2

3
./mission2 W R S > RamSeqWrite.csv
4
echo RamSeqWrite Completed
5
./mission2 R R S > RamSeqRead.csv
6
echo RamSeqRead Completed
7
rm myram/*.txt
8

9
./mission2 W D S > DiskSeqWrite.csv
10
echo DiskSeqWrite Completed
11
./mission2 R D S > DiskSeqRead.csv
12
echo DiskSeqRead Completed
13
rm /usr/*.txt
14

15
./mission2 W R R > RamRdWrite.csv
16
echo RamRdWrite Completed
17
./mission2 R R R > RamRdRead.csv
18
echo RamRdRead Completed
19
rm myram/*.txt
20

21
./mission2 W D R > DiskRdWrite.csv
22
echo DiskRdWrite Completed
23
./mission2 R D R > DiskRdRead.txt
24
echo DiskRdRead Completed
25
rm /usr/*.txt

在 MINIX 环境下 chmod u+x run.sh 与 ./run.sh 即可运行。

将输出文件导入到 excel 后作图：

也可以用 python 作图

1
import numpy as np
2
import pandas as pd
3
import matplotlib.pyplot as plt
4

5
filepath = [
6
    "DataSet/RamSeqWrite.csv", "DataSet/RamSeqRead.csv",
7
    "DataSet/RamRdWrite.csv", "DataSet/RamRdRead.csv",
8
    "DataSet/DiskSeqWrite.csv", "DataSet/DiskSeqRead.csv",
9
    "DataSet/DiskRdWrite.csv", "DataSet/DiskRdRead.csv",
10
]
11

12
check = [(0, 4), (1, 5), (2, 6), (3, 7)]
13
title = ['Seq Write', 'Seq Read', 'Random Write', 'Random Read']
14
for i in range(len(check)):
15
    df1 = pd.read_csv(filepath[check[i][0]])
16
    df2 = pd.read_csv(filepath[check[i][1]])
17
    x = df1['BlockSize(KB)'].to_numpy()
18
    y1 = df1['Speed(MB/s)'].to_numpy()
19
    y2 = df2['Speed(MB/s)'].to_numpy()
20
    plt.plot(x, y1, label='Ram')
21
    plt.plot(x, y2, label='Disk')
22
    plt.xlabel('BlockSize(KB)')
23
    plt.ylabel('Speed(MB/s)')
24
    plt.title(title[i])
25
    plt.legend()
26
    plt.show()

作图如下：

总结

微内核真麻烦 😐

设计是好设计，好就好在********___********