lab8 lock

是小肖啊！

已于 2023-08-27 19:52:43 修改

阅读量180

点赞数

分类专栏： 6.S081 文章标签：网络 java linux

于 2023-08-27 19:14:52 首次发布

本文链接：https://blog.csdn.net/aixiaoxiao13/article/details/132526482

版权

6.S081 专栏收录该内容

11 篇文章 1 订阅

订阅专栏

PreRead

第六章
3.5节：物理内存分配器
8.1-8.3

文章目录

PreRead
Memory allocator
Buffer cache

这次的lab，本质上都是通过将锁的粒度减小来获得性能的提升

第一个task，可以简单地按cpu划分，因为本来就是空闲页面，谁拥有都一样
第二个task，本质上也可以简单地按某种性质划分，但是因为我们不只需要分配，我们还需要查找。如果随便分成若干部分，那么查找起来就非常慢了。所以这也是为什么hints里提示我们用哈希表来划分

Memory allocator

tasks

你的任务是去实现per-cpu空闲链表，并且在一个cpu的空闲链表空着的时候去偷另一个cpu的空闲链表
你的所有锁的名字都应该以kmem开头，即在initlock中设置
你必须通过

kalloctest，make grade会提醒你它通过了

usertests，可以先检查一下sbrkmuch

hints

你可以使用kernel/param.h中的NCPU常数
让freerange将所有的空闲内存都给正在运行的free range
cpuid函数会返回当前的cpu号，但是它必须在中断被关闭的时候使用

因此你需要使用push_off和pop_off
看一下snprintf，学习怎么格式化字符

思路

首先，我们需要以不同的cpu号去访问不同的freelist，最方便的方法就是用一个数组，如下所示。其中count是为了借空闲页面准备的。

struct {
    struct spinlock lock;
    struct run *freelist;
    int count;
} kmem[NCPU];

然后，我们应该在kinit中先初始化各种cpu对应的lock，然后将所有空闲页面都放到运行kinit的cpu上。

这里有几个细节

首先，我是希望kinit只被一个cpu执行，这样才能保证freerange将所有页面都放到这个cpu上，因此，我需要使用push_off和pop_off将kinit包围起来
对于b_lock这个锁，也是为了借空闲页面准备的，否则可能发生死锁

void kinit() {
    push_off();
    for (int i = 0; i < NCPU; i++) {
        initlock(&kmem[i].lock, "kmem");
        kmem[i].count = 0;
    }
    initlock(&b_lock, "borrow");

    freerange(end, (void *)PHYSTOP);
    pop_off();
}

freerange函数不需要修改

在kfree函数中，当我们准备将这个空闲页面加入到一个freelist时，先关闭中断，然后获取当前cpu号，加入到对应的freelist，还是比较简单的。

其中，如果是freerange调用的kfree，可能会有push_off的嵌套，不过这没关系，只要pop_off成对出现即可

void kfree(void *pa) {
    struct run *r;
    if (((uint64)pa % PGSIZE) != 0 || (char *)pa < end || (uint64)pa >= PHYSTOP)
        panic("kfree");
    // Fill with junk to catch dangling refs.
    memset(pa, 1, PGSIZE);
    r = (struct run *)pa;

    push_off();

    int id = cpuid();
    acquire(&kmem[id].lock);
    r->next = kmem[id].freelist;
    kmem[id].freelist = r;
    kmem[id].count++;
    release(&kmem[id].lock);

    pop_off();
}

kalloc函数，如果当前cpu有空闲页面，则正常操作，否则的话，需要去借页面。我这里采用的借的策略是遍历所有cpu，如果某个cpu有空闲页面，那我就借一半，如果有3个，那我就借2个

// Allocate one 4096-byte page of physical memory.
// Returns a pointer that the kernel can use.
// Returns 0 if the memory cannot be allocated.
void *
kalloc(void) {
    struct run *r;

    push_off();
    int id = cpuid();
    acquire(&kmem[id].lock);
    r = kmem[id].freelist;
    if (r) {
        kmem[id].freelist = r->next;
        kmem[id].count--;
    }
    release(&kmem[id].lock);
    if (!r) {
        acquire(&b_lock);
        r = borrow(id);
        release(&b_lock);
    }
    if (r)
        memset((char *)r, 5, PGSIZE); // fill with junk
    pop_off();
    return (void *)r;
}

具体的borrow函数的实现如下

可以发现，在进入borrow函数之前，我就将当前cpu的freelist的锁给释放了。这是因为我进入borrow之后，会去获取其他freelist的锁，假如我是cpu a，我在borrow里要获取cpu b的锁。而b此时也在运行borrow，那它可能也在获取我的锁。如果我和b在进入borrow前都没有释放自己的锁，那必然就死锁了

另外，为什么在borrow之前要获得一个borrow的大锁呢？这是因为如果我在borrow里如果找到了一个可以借的freelist，那么我还是会获取两个锁，这也是有可能造成问题的，因为我们没有限制获取锁的顺序。为了避免可能的情况，我是用这个大锁来保平安，不过好像不会出现这种情况

void *borrow(int id) {
    for (int i = 0; i < NCPU; i++) {
        acquire(&kmem[i].lock);
        if (kmem[i].count != 0) {
            int b_count = (kmem[i].count + 1) / 2;
            struct run *r = kmem[i].freelist;
            struct run *temp = r;
            for (int i = 0; i < b_count - 1; i++) {
                temp = temp->next;
            }
            kmem[i].freelist = temp->next;
            kmem[i].count -= b_count;
            acquire(&kmem[id].lock);
            if (b_count != 1) {
                temp->next = kmem[id].freelist;
                kmem[id].freelist = r->next;
                kmem[id].count += b_count - 1;
            }
            release(&kmem[id].lock);
            release(&kmem[i].lock);
            return r;
        }
        release(&kmem[i].lock);
    }
    return 0;
}

Buffer cache

task

修改bget和brelse，使得对磁盘块的查找和释放在lock上等待的时间越少越好
通过bcachetest和usertests
请给你的所有lock一个以bcache开头的名字，在initlock中实现它
这玩意比kalloc要难太多，因为buffer是必须被所有cpu共享的，不能每个cpu一份，因此建议使用一个哈希表，给哈希表的每个桶都设置一个锁
以下情况发生冲突是没关系的，因为测试不会有这些情况
1. 两个进程访问同一个磁盘block
2. 两个进程同时miss然后需要找到一个没用过的block
3. 两个进程同时操作block，但是它们恰好在你的hash策略中碰撞了，那么你应该避免这种情况，比如调大你的哈希表的size

hints

阅读xv6的8.1到8.3
你可以使用固定长度的哈希表，同时选择一个质数去做哈希，比如13
在哈希表中查找一个buffer和为这个buffer分配一个entry必须是原子性的
删除所有缓存的链表（bcache.head），时间戳缓存使用它们上一次使用的时间（trap.c中的ticks）。有了这个改变之后，brelse不需要获得bcache的lock，bget可以基于时间戳选择最近最少使用的块
在bget中使用顺序查找实现LRU是可以的
你有时可能需要持有两个锁，即bcache锁和每个bucket的锁，保证你可以避免死锁
当你替换某一块的内容时，需要将buf从一个bucket移到另一个，记得处理这两个bucket相同的情况，否则就死锁了

思路

hints里其实就提供了一个思路，用哈希表去存可用的buf。但是到底怎么实现呢？我觉得这里的思路应该有很多，这里提供一种。

首先，我们通过blockno % prime为key，构造一个哈希表，其中prime可以取hints里的13
1. 每一个哈希表的表槽都是一个buf链表+一个表槽锁
2. 这个链表的结构可以按照原来的bcache里那个head来
3. 表槽锁就是保护这个表槽里的这个链表
然后，我们在binit中先将所有的空闲buf都放到key=0的链表中，其实放到哪都可以，平均放到每个表槽也行
在bget的时候，先根据blockno计算出key，然后去对应的表槽里找是否这个block已经被取出来了
1. 如果已经取出来了，则直接返回buf指针，这一个逻辑和原来的bget很像
2. 如果这个block还没有被取出来，那么我们就去找一个引用数为0的buf，将这个buf的内容换成我们这个block。这里又有两种情况，因此我们需要遍历整个哈希表的表槽，并遍历每个表槽的链表，在链表上执行lru算法，找到一个buf，将这个buf修改为我们的内容，然后移动到key对应的表槽
  1. 这个引用数为0的buf在我们这个表槽的链表里
  2. 这个引用数为0的buf在别的表槽里
在brelse中，就很简单，只需要将refcnt减1就行了，都不用将这个buf移动

思路就是这样，不过有一个关键点没有涉及，那就是锁，该如何安排锁呢？

首先，锁肯定是要去保护一些东西的，之前的bcache的那个大锁，是因为保护的东西太多了，所有buf都是被它保护着，这就导致很慢了，因为可能不同的cpu没有冲突，但依然要等很久。

因此，我们这里采用一种哈希表的方法，使得锁管理的范围变小。对于某个key对应的表槽的那个锁，它只需要管理blockno%prime==key的block，也就是说，我们将原来的一个锁，变成了prime个锁，使得它们管理的范围缩小了prime倍。当然了，这是对于那些存储了某些block的内容的buf而言的，如果它存储了，那么它肯定就在对应的表槽中。至于那些没有存储的，或者说引用数为0的，我们可以称为空闲buf，它们按什么方式组织都行，甚至可以专门搞一个空闲链表都可以。但是这里采用的方式比较偷懒，也比较巧，即没有存储的一开始就放在key=0的表槽链表，引用计数为0的，直接不处理，反正它们都可能在bget中被访问到

最后，锁的作用呢？我们这里有两个锁，一个锁是表槽对应的锁，一个是每个buf对应的锁，它们分别保护了什么？

表槽锁当然是保护了表槽里的那个链表，也就是保护了链表的每个节点，即一个个buf，使得链表或者每个buf在被修改时，只会有一个线程对它们进行修改
而每个buf对应的锁，它的作用是使得，在某一刻，它永远只会被一个线程所拥有，不会同时被多个线程拥有。所以这个锁使用起来非常简单，我们只需要在我们找到了一个正确的buf，将它作为res在bget中返回之前调用这个buf的锁即可

实现

首先是整体的布局

这里的bcache最好不删，因为这个变量默认就开辟了NBUF个struct buf，省的我们自己申请空间创造了
哈希表有prime个表槽，每个表槽一个链表+一个锁，链表的结构和之前的一样，一个head作为dummynode，方便操作
一些宏，主要是方便，省的后面输入一大串代码来获取锁和释放锁

#define prime 13

struct {
    struct buf buf[NBUF];
} bcache;

struct {
    struct spinlock lock;
    struct buf head;
} ht[prime];

#define LOCK(i) (acquire(&ht[i].lock));
#define UNLOCK(i) (release(&ht[i].lock));

binit函数

首先给每个表槽的锁给初始化，然后初始化这个head
将所有的buf都放到key=0的表槽中

这个过程很像之前binit，抄就完事了

void binit(void) {
    struct buf *b;

    char a[20];
    for (int i = 0; i < prime; i++) {
        snprintf(a, sizeof(a), "bcache_%d", i);
        initlock(&ht[i].lock, a);
        ht[i].head.prev = &ht[i].head;
        ht[i].head.next = &ht[i].head;
    }

    // Create linked list of buffers
    for (b = bcache.buf; b < bcache.buf + NBUF; b++) {
        initsleeplock(&b->lock, "buffer");
        insert_into_ht(b, 0);
    }
}

可以发现，这里用到了一个insert_into_ht的操作，定义如下

可以从原来的brelse抄

void insert_into_ht(struct buf *b, int key) {
    b->next = ht[key].head.next;
    b->prev = &ht[key].head;
    ht[key].head.next->prev = b;
    ht[key].head.next = b;
}

void delete_from_ht(struct buf *b) {
    b->next->prev = b->prev;
    b->prev->next = b->next;
}

brelse函数的实现也非常简单

释放这个buf的锁，其实这个释放放在哪一行都没问题
1. 因为它的refcnt还没减1，就注定了它不会被别人给夺舍
2. 只要unlock不取消掉，就没有人能够访问到它

void brelse(struct buf *b) {
    releasesleep(&b->lock);
    int key = b->blockno % prime;
    LOCK(key);
    b->refcnt -= 1;
    UNLOCK(key);
}

bpin和bunpin的实现也很简单

首先，这两个函数肯定是在一个buf已经有了一个block，并且refcnt不为0的情况下调用的
我们只需要先获得对应表槽的锁，即获得对这个buf的修改权，然后修改，就可以了

void bpin(struct buf *b) {
    int key = b->blockno % prime;
    LOCK(key);
    b->refcnt++;
    UNLOCK(key);
}

void bunpin(struct buf *b) {
    int key = b->blockno % prime;
    LOCK(key);
    b->refcnt--;
    UNLOCK(key);
}

大头戏bget来了

首先通过search_in_ht尝试去找找这个block是不是已经被读入了某个buf里，这种情况如果成功，那就和之前bget前一部分逻辑一模一样
如果失败了，那么就需要通过search_in_other去整个哈希表中找一个空闲的buf，这个操作一定会成功，否则在xv6里就直接给它来一个panic，原函数也是这么写的

static struct buf *
bget(uint dev, uint blockno) {
    struct buf *b;
    int key = blockno % prime;
    // 尝试去对应的哈希表槽查找
    LOCK(key);
    b = search_in_ht(dev, blockno, key);
    if (b) {
        UNLOCK(key);
        acquiresleep(&b->lock);
        return b;
    }
    // 至此，没有在对应的表槽找到，遍历所有哈希表的表槽，不过优先处理自己表槽的
    // 这里是带着key对应的锁去查找的
    b = search_in_other(dev, blockno, key);
    // 这个b不可能为0，否则直接panic了
    UNLOCK(key);
    acquiresleep(&b->lock);
    return b;
}

search_in_ht的实现如下所示，就是遍历链表，如果找到了，更新属性，然后返回。其中更新属性会用到update_time。

void update_time(struct buf *b) {
    acquire(&tickslock);
    b->timestamp = ticks;
    release(&tickslock);
}

struct buf *search_in_ht(uint dev, uint blockno, int key) {
    struct buf *b;
    for (b = ht[key].head.next; b != &ht[key].head; b = b->next) {
        if (b->dev == dev && b->blockno == blockno) {
            b->refcnt++;
            update_time(b);
            return b;
        }
    }
    return 0;
}

而search_in_other就比较复杂

这里采取的遍历顺序是从自己这里开始遍历，用一个cycle来控制遍历prime次，之所以这样做，是为了避免每次都是0开始遍历。这样操作相对来说会提高点性能，不会出现前面的表槽没有空闲的，后面的表槽全是空闲的
如果我们要进入的某个表槽不是自己，那么就需要获取那个表槽的锁
1. 这里是有可能死锁的
  1. 因为我们进入这个函数的时候，是带着key对应的锁的，现在又去请求i对应的锁
  2. 假如某个cpu是带着i对应的锁进入这个函数，正在请求key对应的锁，岂不是就死锁了？
  3. 感觉是自带的评测没有检查出来，这里还是有点问题的。不过懒得改了

接下来就是通过search_lru_free_in_ht去这个兄弟那里找一找有没有空闲的

struct buf *search_lru_free_in_ht(uint dev, uint blockno, int key) {
    struct buf *b;
    struct buf *lru_b = 0;
    for (b = ht[key].head.next; b != &ht[key].head; b = b->next) {
        if (b->refcnt == 0 && (lru_b == 0 || lru_b->timestamp > b->timestamp)) {
            lru_b = b;
        }
    }
    return lru_b;
}

如果没有，那么视情况释放锁，然后continue
如果有的话
1. 更新各种属性
2. 如果这个buf是别的表槽，将这个buf挪到key对应的表槽
3. 最后视情况释放这个兄弟锁，返回答案

struct buf *search_in_other(uint dev, uint blockno, int key) {
    struct buf *b;
    for (int i = key, cycle = 0; cycle < prime; cycle++, i = (i + 1) % prime) {
        // 如果不是自己，则给这个兄弟上个锁
        if (i != key) {
            LOCK(i);
        }
        // 在这个兄弟里去找一下
        b = search_lru_free_in_ht(dev, blockno, i);
        // 这个兄弟里没有空闲页面
        if (!b) {
            if (i != key) {
                UNLOCK(i);
            }
            continue;
        }
        // 在这个兄弟里找到了空闲页面
        // 先更新属性
        b->dev = dev;
        b->blockno = blockno;
        b->valid = 0;
        b->refcnt = 1;
        update_time(b);
        // 如果不是自己的哈希槽里的，将这个页面放到自己哈希表槽中
        if (i != key) {
            delete_from_ht(b);
            insert_into_ht(b, key);
        }
        // 释放哈希表的锁
        if (i != key) {
            UNLOCK(i);
        }
        return b;
    }
    panic("no free buf");
}

整体代码如下

// Buffer cache.
//
// The buffer cache is a linked list of buf structures holding
// cached copies of disk block contents.  Caching disk blocks
// in memory reduces the number of disk reads and also provides
// a synchronization point for disk blocks used by multiple processes.
//
// Interface:
// * To get a buffer for a particular disk block, call bread.
// * After changing buffer data, call bwrite to write it to disk.
// * When done with the buffer, call brelse.
// * Do not use the buffer after calling brelse.
// * Only one process at a time can use a buffer,
//     so do not keep them longer than necessary.

#include "types.h"
#include "param.h"
#include "spinlock.h"
#include "sleeplock.h"
#include "riscv.h"
#include "defs.h"
#include "fs.h"
#include "buf.h"
#include <x86_64-linux-gnu/sys/types.h>

#define prime 13

struct {
    struct buf buf[NBUF];
} bcache;

struct {
    struct spinlock lock;
    struct buf head;
} ht[prime];

#define LOCK(i) (acquire(&ht[i].lock));
#define UNLOCK(i) (release(&ht[i].lock));

void update_time(struct buf *b) {
    acquire(&tickslock);
    b->timestamp = ticks;
    release(&tickslock);
}

void insert_into_ht(struct buf *b, int key) {
    b->next = ht[key].head.next;
    b->prev = &ht[key].head;
    ht[key].head.next->prev = b;
    ht[key].head.next = b;
}

void delete_from_ht(struct buf *b) {
    b->next->prev = b->prev;
    b->prev->next = b->next;
}

void binit(void) {
    struct buf *b;

    char a[20];
    for (int i = 0; i < prime; i++) {
        snprintf(a, sizeof(a), "bcache_%d", i);
        initlock(&ht[i].lock, a);
        ht[i].head.prev = &ht[i].head;
        ht[i].head.next = &ht[i].head;
    }

    // Create linked list of buffers
    for (b = bcache.buf; b < bcache.buf + NBUF; b++) {
        initsleeplock(&b->lock, "buffer");
        insert_into_ht(b, 0);
    }
}

struct buf *search_in_ht(uint dev, uint blockno, int key) {
    struct buf *b;
    for (b = ht[key].head.next; b != &ht[key].head; b = b->next) {
        if (b->dev == dev && b->blockno == blockno) {
            b->refcnt++;
            update_time(b);
            return b;
        }
    }
    return 0;
}

struct buf *search_lru_free_in_ht(uint dev, uint blockno, int key) {
    struct buf *b;
    struct buf *lru_b = 0;
    for (b = ht[key].head.next; b != &ht[key].head; b = b->next) {
        if (b->refcnt == 0 && (lru_b == 0 || lru_b->timestamp > b->timestamp)) {
            lru_b = b;
        }
    }
    return lru_b;
}

struct buf *search_in_other(uint dev, uint blockno, int key) {
    struct buf *b;
    for (int i = key, cycle = 0; cycle < prime; cycle++, i = (i + 1) % prime) {
        // 如果不是自己，则给这个兄弟上个锁
        if (i != key) {
            LOCK(i);
        }
        // 在这个兄弟里去找一下
        b = search_lru_free_in_ht(dev, blockno, i);
        // 这个兄弟里没有空闲页面
        if (!b) {
            if (i != key) {
                UNLOCK(i);
            }
            continue;
        }
        // 在这个兄弟里找到了空闲页面
        // 先更新属性
        b->dev = dev;
        b->blockno = blockno;
        b->valid = 0;
        b->refcnt = 1;
        update_time(b);
        // 如果不是自己的哈希槽里的，将这个页面放到自己哈希表槽中
        if (i != key) {
            delete_from_ht(b);
            insert_into_ht(b, key);
        }
        // 释放哈希表的锁
        if (i != key) {
            UNLOCK(i);
        }
        return b;
    }
    panic("no free buf");
}

static struct buf *
bget(uint dev, uint blockno) {
    struct buf *b;
    int key = blockno % prime;
    // 尝试去对应的哈希表槽查找
    LOCK(key);
    b = search_in_ht(dev, blockno, key);
    if (b) {
        UNLOCK(key);
        acquiresleep(&b->lock);
        return b;
    }
    // 至此，没有在对应的表槽找到，遍历所有哈希表的表槽，不过优先处理自己表槽的
    // 这里是带着key对应的锁去查找的
    b = search_in_other(dev, blockno, key);
    // 这个b不可能为0，否则直接panic了
    UNLOCK(key);
    acquiresleep(&b->lock);
    return b;
}

// Return a locked buf with the contents of the indicated block.
struct buf *
bread(uint dev, uint blockno) {
    struct buf *b;

    b = bget(dev, blockno);
    if (!b->valid) {
        virtio_disk_rw(b, 0);
        b->valid = 1;
    }
    return b;
}

// Write b's contents to disk.  Must be locked.
void bwrite(struct buf *b) {
    if (!holdingsleep(&b->lock))
        panic("bwrite");
    virtio_disk_rw(b, 1);
}

// Release a locked buffer.
// Move to the head of the most-recently-used list.
void brelse(struct buf *b) {
    releasesleep(&b->lock);
    int key = b->blockno % prime;
    LOCK(key);
    b->refcnt -= 1;
    UNLOCK(key);
}

void bpin(struct buf *b) {
    int key = b->blockno % prime;
    LOCK(key);
    b->refcnt++;
    UNLOCK(key);
}

void bunpin(struct buf *b) {
    int key = b->blockno % prime;
    LOCK(key);
    b->refcnt--;
    UNLOCK(key);
}

是小肖啊！

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
lab8 lock

但是这里采用的方式比较偷懒，也比较巧，即没有存储的一开始就放在key=0的表槽链表，引用计数为0的，直接不处理，反正它们都可能在。这是因为如果我在borrow里如果找到了一个可以借的freelist，那么我还是会获取两个锁，这也是有可能造成问题的，因为我们没有限制获取锁的顺序。首先，锁肯定是要去保护一些东西的，之前的bcache的那个大锁，是因为保护的东西太多了，所有buf都是被它保护着，这就导致很慢了，因为可能不同的cpu没有冲突，但依然要等很久。对于某个key对应的表槽的那个锁，它只需要管理。
复制链接

扫一扫