20191325学习笔记10

块设备I/O和缓冲区管理

本章讨论了块设备I/O和缓冲区管理；解释了块设备I/O的原理和I/O缓冲的优点；论 述了 Unix的缓冲区管理算法，并指出了其不足之处；还利用信号量设计了新的缓冲区管理 算法，以提高I/O缓冲区的缓存效率和性能；表明了简单的PV算法易于实现，缓存效果好， 不存在死锁和饥饿问题；还提出了一个比较Unix缓冲区管理算法和PV算法性能的编程方 案。编程项目还可以帮助读者更好地理解文件系统中的I/O操作。

块设备I/O缓冲区

I/O缓冲的基本原理非常简单。文件系统使用一系列I/O缓冲区作为块设备的缓存内存。当进程试图读取（dev，blk）标识的磁盘块时。它首先在缓冲区缓存中搜索分配给磁盘块的缓冲区。如果该缓冲区存在并且包含有效数据、那么它只需从缓冲区中读取数据、而无须再次从磁盘中读取数据块。如果该缓冲区不存在，它会为磁盘块分配一个缓冲区，将数据从磁盘读人缓冲区，然后从缓冲区读取数据。当某个块被读入时、该缓冲区将被保存在缓冲区缓存中，以供任意进程对同一个块的下一次读/写请求使用。同样，当进程写入磁盘块时，它首先会获取一个分配给该块的缓冲区。然后，它将数据写入缓冲区，将缓冲区标记为脏，以延迟写入，并将其释放到缓冲区缓存中。由于脏缓冲区包含有效的数据，因此可以使用它来满足对同一块的后续读/写请求，而不会引起实际磁盘I/O。脏缓冲区只有在被重新分配到不同的块时才会写人磁盘。

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;
// assigmed disk block;int opcode;
// READ|wRITE int dirty;
// buffer data modified
int async;
// ASYNC write flag int valid;
//buffer data valid int buay;
// buffer is in use int wanted;
// some process needs this buffer struct semaphore lock=1; /
// buffer locking semaphore; value=1
struct semaphore iodone=0;// for process to wait for I/0 completion;// block data area char buf[BLKSIZE];)
} BUFFER;
BUFFER buf[NBUF],*freelist;// NBUF buffers and free buffer list

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

 

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

Unix算法的优点：1.数据的一致性；2.缓存效果；3.临界区；

Unix算法的缺点：1.效率低下；2.缓存效果不可预知；3.可能会出现饥饿；4.该算法使用只适用于单处理系统的休眠/唤醒操作。

PV算法

 

BUFFER *getblk(dev,blk)
{
    while(1){
  (1).      p(free);                              //首先获取一个空闲缓冲区
  (2).      if (bp in dev_list){                  //若该缓冲区在设备表的dev_list中
  (3).          if (bp not BUSY){                 //且处于空闲状态
                    remove from freelist;         //将其从空闲列表中删除
                    P(bp);                        //lock bp not wait
                    return bp;
                 }
            //若缓冲区存在缓存内且繁忙
                V(free);                          //放弃空闲缓冲区
  (4).          P(bp);                            //在缓冲队列中等待
                return bp;
           }
            //缓冲区不在缓存中，为磁盘创建一个缓冲区
  (5).     bp = first buffer taken out of freelist;
           P(bp);                             //lock bp no wait
  (6).     if (bp dirty){                     //若为脏缓冲区
              awrite(bp);                     //缓冲区写入磁盘
              continue;
           }
  (7).     reassign bp to (dev,blk);          //重新分配
           return bp;
      }
}
brelse (BUFFER *bp)
{
    (8).if (bp queue has waiter) {V(bp); return; }
    (9).if (bp dirty && freee queue has waiter){ awrite(bp); return;}
    (10).enter bp into (tail of) freelist; V(bp); V(free);
}

• 缓冲区唯一性

• 无重试循环

• 无不必要唤醒

• 缓存效果

• 无死锁和饥饿

PV算法缺点

• 1.一旦没有空闲状态缓冲区，所有请求进程都将被阻塞在getblk()中的(1)。

• 2.当进程从空闲列表信号量队列中唤醒时，可能发现所需缓冲区已经存在，但处于繁忙，此时将在(4)处被阻塞。

实践部分

代码：

#include<stdio.h> 
#include<stdlib.h> 
#include<unistd.h> 
#include<semaphore.h> 
#include<pthread.h> 
#define msleep(x)   usleep(x*1000) 
#define PRODUCT_SPEED       3               //生产速度 
#define CONSUM_SPEED        1               //消费速度 
#define INIT_NUM                3               //仓库原有产品数 
#define TOTAL_NUM               10          //仓库容量  
sem_t p_sem, c_sem, sh_sem; int num=INIT_NUM;  
void product(void)                          //生产产品 
{ 
    sleep(PRODUCT_SPEED); 
}  
    int add_to_lib()                                //添加产品到仓库 
{ 
        num++;//仓库中的产品增加一个 
        msleep(500); 
        return num; 
}  
void consum()                                       //消费 { sleep(CONSUM_SPEED); }  
    int sub_from_lib()                          //从仓库中取出产品 
{ 
    num--; //仓库中的产品数量减一 
    msleep(500); 
    return num; 
}  
void *productor(void *arg)          //生产者线程 
{ 
    while(1) 
    {   
        sem_wait(&p_sem);//生产信号量减一  
        product();// 生产延时           
        sem_wait(&sh_sem);//这个信号量是用来互斥的     
        printf("push into! tatol_num=%d\n",add_to_lib());   
        sem_post(&sh_sem);      
        sem_post(&c_sem);  //消费信号量加一 
    } 
}  
void *consumer(void *arg)               //消费者线程 
{ 
    while(1) 
    {       
        sem_wait(&c_sem); //消费者信号量减一        
        sem_wait(&sh_sem);  
        printf("pop out! tatol_num=%d\n",sub_from_lib());   
        sem_post(&sh_sem);          
        sem_post(&p_sem);//生产者信号量加一     
        consum();//消费延时              
    } 
}  
int main() 
{ 
    pthread_t tid1,tid2; 
    sem_init(&p_sem,0,TOTAL_NUM-INIT_NUM);  
    sem_init(&c_sem,0,INIT_NUM);  
    sem_init(&sh_sem,0,1);  
    pthread_create(&tid1,NULL,productor,NULL); 
    pthread_create(&tid2,NULL,consumer,NULL);  
    pthread_join(tid1,NULL); 
    pthread_join(tid2,NULL); 
    return 0; 
}

实践结果：