标签：int buf self 2024 2023 缓冲区 20211325 data size

20211325 2023-2024-1 《信息安全系统设计与实现（上）》第十周学习笔记

一、任务要求

自学教材第12章，提交学习笔记（10分），评分标准如下

1. 知识点归纳以及自己最有收获的内容，选择至少2个知识点利用chatgpt等工具进行苏格拉底挑战，并提交过程截图，提示过程参考下面内容（4分） “我在学***X知识点，请你以苏格拉底的方式对我进行提问，一次一个问题” 核心是要求GPT：“请你以苏格拉底的方式对我进行提问” 然后GPT就会给你提问，如果不知道问题的答案，可以反问AI：“你的理解（回答）是什么？” 如果你觉得差不多了，可以先问问GPT：“针对我XXX知识点，我理解了吗？” GPT会给出它的判断，如果你也觉得自己想清楚了，可以最后问GPT：“我的回答结束了，请对我的回答进行评价总结”，让它帮你总结一下。

2. 问题与解决思路，遇到问题最先使用chatgpt等AI工具解决，并提供过程截图（3分）

3. 实践过程截图，代码链接（2分）

4. 其他（知识的结构化，知识的完整性等，提交markdown文档，使用openeuler系统等）（1分）

二、课本知识总结

学习目标

学习理解块设备I/O和缓冲区管理；理解块设备I/O的原理和I/O缓冲的优点；讨论Unix的缓冲区管理算法；掌握PV算法，通过编程项目更好的理解文件系统中的I/O操作。

块设备I/O缓冲区

什么是块设备：

　　块设备是i/o设备中的一类，是将信息存储在固定大小的块中，每个块都有自己的地址，还可以在设备的任意位置读取一定长度的数据，例如硬盘,U盘，SD卡等。

文件系统使用一系列I/O缓冲区作为块设备的缓存内存。当进程试图读取（dev，blk）标识的磁盘块时。它首先在缓冲区缓存中搜索分配给磁盘块的缓冲区。如果该缓冲区存在并且包含有效数据、那么它只需从缓冲区中读取数据、而无须再次从磁盘中读取数据块。如果该缓冲区不存在，它会为磁盘块分配一个缓冲区，将数据从磁盘读人缓冲区，然后从缓冲区读取数据。

当某个块被读入时、该缓冲区将被保存在缓冲区缓存中，以供任意进程对同一个块的下一次读/写请求使用。

　　当进程写入磁盘块时，它首先会获取一个分配给该块的缓冲区。然后，它将数据写入缓冲区，将缓冲区标记为脏，以延迟写入，并将其释放到缓冲区缓存中。

定义一个bread（dev, blk）函数，它会返回一个包含有效数据的缓冲区(指针)。
从缓冲区读取数据后，进程通过brelse(hp)格缓冲区释放回缓冲区缓存。 write_block(dev, blk, data)函数

Unix I/O缓冲区管理算法

I/O缓冲区:内核中的一系列NBUF缓冲区用作缓冲区缓存。每个缓冲区用一个结构体表示。

typdef struct buf{
struct buf *next_free;    //freelist pointer
struct buf *next_dev；    //dev_list pointer
int dev,blk；    //assigned disk block；
int opcode；    //READ|WRITE
int dirty;    //buffer data modified
int async;    //ASYNC write flag
int valid;    //buffer data valid
int busy;    //buffer is in use
int wanted；        some process needs this buffer
struct, semaphore lock=l ；    //buffer locking semaphore； value=L
struct semaphore iodone=0；    //for process to wait for I/O completion；
char buf[BLKSIZE];    //block data area
} BUFFER;
BUFFER buf[NBUF], *freelist; // NBUF buffers and free buffer list

设备表:每个块设备用一个设备表结构表示。

struct devtab{
u16 dev;           // major device number 
BUFFER *dev_list;  // device buffer list 
BUFFER*io_queue    // device I/0 queue 
}devtab[NDEV];

缓冲区初始化:当系统启动时，所有I/O缓冲区都在空闲列表中，所有设备列表和T/O队列均为空。
缓冲区列表:当缓冲区分配给(dev,blk)时，它会被插入设备表的dev_list中。如果缓冲区当前正在使用，则会将其标记为BUSY(繁忙)并从空闲列表中删除。
Unix getblk/brelse算法
- 数据一致性：为确保数据一致性，getblk一定不能给同一个(dev, blk)分配多个缓冲区这可以通过让进程从休眠状态唤醒后再次执行“重试循环”来实现。读者可以验证分配的每个缓冲区都是唯一的一其次，脏缓冲区在重新分配之前被写出来，这保证了数据的一致性。
- 缓存效果：缓存效果可通过以下方法实现释放的緩冲区保留在设备列表中，以便可能重用，标记为延迟写入的緩冲区不会立即产生I/O,并且可以重用。缓冲区会被释放到空闲列表的末尾,但分配是从空闲列表的前面开始的，这是基于LRU (最近最少使用)原则，它有助于延长所分配缓冲区的使用期，从而提高它们的缓存效果。
- 临界区：设备中断处理程序可操作缓冲区列表，例如从设备表的I/O队列中删除 bp,更改其状态并调用brelse(bp)。所以，在getb汰和brelse中，设备中断在这些临界区中会被屏蔽。这些都是隐含的，但没有在算法中表现出来。

Unix 算法的缺点

效率低下：该算法依赖于重试循环。
缓存效果不可预知：在Unix算法中，每个释放的缓冲区都可被获取，如果缓冲区由需要空闲缓冲区的进程获取，那么将会重新分配缓冲区，即使有些进程仍然需要当前的缓冲区。
可能会出现饥饿：Unix算法基于“自由经济”原则，即每个进程都有尝试的机会，但不能保证成功，因此，可能会出现进程饥饿。
该算法使用只适用丁单处理器系统的休眠/唤醒操作

新的I/O缓冲区管理算法

计数信号量可用来表示可用资源的数量，例如∶空闲缓冲区的数量。
当多个进程等待一个资源时，信号量上的V操作只会释放一个等待进程，该进程不必重试，因为它保证拥有资源。

使用信号量的缓冲区管理算法：
　　假设有一个单处理器内核（一次运行一个进程）。使用计数信号量上的P/V来设计满足以下要求的新的缓冲区管理算法∶

保证数据一致性。
良好的缓存效果。
高效率∶没有重试循环，没有不必要的进程"唤醒"。
无死锁和饥饿。

PV算法

BUFFER *getb1k(dev,blk)：
while(1){
P(free);
//get a free buffer first 
if (bp in dev_1ist){
if (bp not BUSY){
remove bp from freelist;
P(bp);
// lock bp but does not wait
return bp;
// bp in cache but BUSY 
V(free);
// give up the free buffer
P(bp);
// wait in bp queue
return bp;
// bp not in cache,try to create a bp=(dev,blk)
bp = frist buffer taken out of freelist;
P(bp);
// lock bp,no wait
if(bp dirty){
awzite(bp);
// write bp out ASYNC,no wait
continue;
// continue from (1)
reassign bp to(dev,blk);
// mark bp data invalid,not dir 
return bp;
// end of while(1)；
brelse(BUFFER *bp)，
{
iF (bp queue has waiter)( V(bp); return; }
if(bp dirty && free queue has waiter){ awrite(bp);zeturn;}
enter bp into(tail of) freelist;V(bp);V(free);
}

PV算法的优越性：

缓冲区唯一性
无重试循环
无不必要唤醒
缓存效果
无死锁和饥饿

I/O缓冲区管理算法比较

1.系统组织

　　用户界面：这是模拟系统的用户界面部分。它会提示输人命令、显示命令执行、显示系统状态和执行结果等。在开发过程中，读者可以手动输入命令来执行任务。在最后测试过程中，任务应该有自己的输入命令序列。例如，各任务可以读取包含命令的输入文件。

2.多任务处理系统

3.磁盘驱动程序

start io（）：维护设备I/O队列，并对I/O 队列中的缓冲区执行 I/O操作。

中断处理程序：在每次I/O操作结束时，磁盘控制器会中断CPU。当接收到中断后，中断处理程序首先从 IntStatus中读取中断状态。

4.磁盘中断

从磁盘控制器到CPU的中断由 SIGUSR1（#10）信号实现。在每次I/O操作结束时，磁盘控制器会发出kill（ppid，SIGUSR1）系统调用，向父进程发送 SIGUSR1信号，充当虚拟CPU中断。

为防止竞态条件，磁盘控制器必须要从CPU接收一个中断确认，才能再次中断。

5.虚拟磁盘

使用Linux系统调用lseek（）、read（）和 write（），我们可以支持虚拟磁盘上的任何块I/O操作。

6.磁盘控制器

磁盘控制器是主进程的一个子进程。因此，它与CPU 端独立运行，除了它们之间的通信通道，通信通道是 CPU和磁盘控制器之间的接口。通信通道由主进程和子进程之间的管道实现。

命令：从 CPU到磁盘控制器的I/O命令。

DataOut：在写操作中从 CPU 到磁盘控制器的数据输出。

DataIn：在读操作中从磁盘控制器到CPU 的数据。

IntStatus：从磁盘控制器到CPU 的中断状态。

IntAck：从CPU到磁盘控制器的中断确认。

缓冲区理解

缓冲区是内存与外设（如硬盘）进行数据交互的媒介。内存与硬盘最大的区别在于，硬盘的作用仅仅是对数据信息以很低的成本做大量数据的断电保存，并不参与运算（因为 CPU 无法到硬盘上寻址），而内存除了需要对数据进行保存以外，更重要的是与 CPU、总线配合进行数据运算。缓冲区则介于两者之间，它既对数据信息进行保存，也能够参与一些像查找、组织之类的间接、辅助性运算。有了缓冲区这个媒介后，对外设而言，它仅需要考虑与缓冲区进行数据交互是否符合要求，而不需要考虑内存如何使用这些交互的数据；对内存而言，它也仅需要考虑与缓冲区交互的条件是否成熟，而不需要关心此时外设对缓冲区的交互情况。两者的组织、管理和协调将由操作系统统一操作。

缓冲区在内存中的位置示例

循环缓冲区实践

（1）c_cache.h

#ifndef C_CACHE_H
#define C_CACHE_H

struct TRingBuf {
    char *buf;
    char *end_pos_;
    char *read_pos_;
    char *write_pos_;
    //int data_size_;
    int data_write_size_;
    int data_read_size_;
};
void TRingBufCreate(struct TRingBuf *self, void *buf, int buf_size);//construct
void TRingBufWrite(struct TRingBuf *self, void *data, int data_size);
void TRingBufRead(struct TRingBuf *self, void *buf, int buf_size);
void TRingBufClear(struct TRingBuf *self);//destruct
int TRingBufSize(struct TRingBuf *self);
int TRingBufFreeSize(struct TRingBuf *self);
int TRingBufDataSize(struct TRingBuf *self);

#endif

（2）cache.c

#include "c_cache.h"
#include <string.h>
#include <stdlib.h>

void TRingBufCreate(struct TRingBuf *self, void *buf, int buf_size) {
    self->buf = (char*)buf;
    self->write_pos_ = (char*)buf;
    self->read_pos_ = (char*)buf;
    self->end_pos_ = (char*)buf + buf_size;
    //self->data_size_ = 0;
    self->data_read_size_ = 0;
    self->data_write_size_ = 0;
}

void TRingBufClear(struct TRingBuf *self) {
    self->write_pos_ = self->buf;
    self->read_pos_ = self->buf;
//self->data_size_ = 0;
    self->data_read_size_ = 0;
    self->data_write_size_ = 0;
}


int TRingBufFreeSize(struct TRingBuf *self) {
    return (self->end_pos_ - self->buf) - (self->data_write_size_ - self->data_read_size_);
}


int TRingBufDataSize(struct TRingBuf *self) {
    return self->data_write_size_ - self->data_read_size_;
}


int TRingBufSize(struct TRingBuf *self) {
    return self->end_pos_ - self->buf;
}


void TRingBufWrite(struct TRingBuf *self, void *data, int data_size) {
    int free_size = TRingBufFreeSize(self);
    int result = data_size >= free_size ? free_size : data_size;
    int size = self->end_pos_ - self->write_pos_;
    if(size > result) 
    size = result;
    memmove(self->write_pos_, data, size);
    self->write_pos_ += size;
    if(self->write_pos_ >= self->end_pos_) {
        self->write_pos_ = self->buf;
        data_size = result - size;
        if(data_size > 0) {
        memmove(self->write_pos_, (char *)data + size, data_size);
        self->write_pos_ += data_size;
        }
    }
    self->data_write_size_ += result;
}
void TRingBufRead(struct TRingBuf *self, void *buf, int buf_size) {
    int data_size = TRingBufDataSize(self);
    int result = buf_size >= data_size ? data_size : buf_size;
    int size = self->end_pos_ - self->read_pos_;
    if(size > result) size = result;
    memmove(buf,(const void *)self->read_pos_, size); 
    self->read_pos_ += size;
    if(self->read_pos_ >= self->end_pos_){
        self->read_pos_ = self->buf;
        data_size = result - size;
        if(data_size > 0) {
        memmove((char *)buf + size, self->read_pos_, data_size);
        self->read_pos_ += data_size;
        }
    }
    self->data_read_size_ += result;
}

（3）main.c

#include "c_cache.h"
#include <pthread.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

struct TRingBuf *Buf = NULL; 
void* Write(void *reg) {
    char r[] = "qwertyuiopasdfghjklzxcvbnm";
    TRingBufWrite(Buf, r, 26);
    printf("*****************************\n");
    printf("First Write success!!\n");
    printf("The data_size is %d\n",TRingBufDataSize(Buf));
    printf("The free_size is %d\n",TRingBufFreeSize(Buf));
    printf("The data of buf is :%s\n", Buf->buf);
    sleep(1);
    char s[] = "qwertyuiopasdfghjklzxcvbnm";
    TRingBufWrite(Buf, s, 26);
    printf("*****************************\n");
    printf("Second Write success!!\n");
    printf("The data_size is %d\n",TRingBufDataSize(Buf));
    printf("The free_size is %d\n",TRingBufFreeSize(Buf));
    printf("The data of buf is :%s\n", Buf->buf);
    return NULL; 
}
void* Read(void *reg) {
    char *buf = (char *)malloc(16*sizeof(char));
    TRingBufRead(Buf, buf, 16);
    printf("*****************************\n");
    printf("The result of reading is :%s\n", buf);
    free(buf);
    buf = NULL;
    printf("The data_size is %d\n",TRingBufDataSize(Buf));
    printf("The free_size is %d\n", TRingBufFreeSize(Buf));
    sleep(0.5);
    buf = (char *)malloc(16*sizeof(char));
    TRingBufRead(Buf, buf, 16);
    printf("*****************************\n");
    printf("The result of reading is :%s\n", buf);
    free(buf);
    buf = NULL;
    return NULL;
}
int main() {
    pthread_t tid[2];
    Buf = (struct TRingBuf*)malloc(sizeof(struct TRingBuf));
    char str[] = "12345678901234567890123456789012345";
    TRingBufCreate(Buf, str, 35);
    printf("*****************************\n");
    printf("The circle_cache is created!!\n");
    printf("The data_size is %d\n",TRingBufDataSize(Buf));
    printf("The free_size is %d\n", TRingBufFreeSize(Buf));
    sleep(0.01);
    int ret = pthread_create(&tid[0], NULL, Write, NULL);
    if(ret != 0) printf("pthread create fail\n");
    usleep(0.0001);
 　　int re = pthread_create(&tid[1], NULL, Read, NULL);
    if(re != 0) printf("pthread create fail\n");
    sleep(3);
    TRingBufClear(Buf);
    free(Buf);
    Buf = NULL;
    return 0;
}