MahnoKropotkinvich/xv6-labs-2024-solution
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

debugging lock lab without LRU

Browse Source
This commit is contained in:
whatever 2024-11-25 14:20:37 +08:00
parent 1e6d8a660f
commit c8587aba91
5 changed files with 186 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
fs.img.bk
View File

Binary file not shown.

180
kernel/bio.c
View File

@ -23,32 +23,98 @@
#include "fs.h"
#include "buf.h"
// TODO: use sleeplock instead of spinlock
struct {
struct spinlock lock;
struct buf buf[NBUF];
#define NHASH 233
// struct hash_t{
// uint pos;
// struct hash_t *nxt;
// }hash[NHASH];
uint hash_head[NHASH];
uint nxt[NBUF];
struct spinlock hashlock[NHASH];
uint freelist_head;
// Linked list of all buffers, through prev/next.
// Sorted by how recently the buffer was used.
// head.next is most recent, head.prev is least.
struct buf head;
// struct buf head;
struct spinlock freelistlock;
} bcache;
uint hasher(uint dev,uint blockno){
return blockno%NHASH;
}
int hash_get(uint dev,uint blockno){
const uint hash_pos=hasher(dev, blockno);
int pos=-1;
acquire(&bcache.hashlock[hash_pos]);
for(int cur=bcache.hash_head[hash_pos];cur!=-1;cur=bcache.nxt[cur])
if(bcache.buf[cur].dev==dev && bcache.buf[cur].blockno==blockno){
pos=cur;
goto RET;
}
RET:
release(&bcache.hashlock[hash_pos]);
// printf("%u\n",pos);
return pos;
}
void hash_add(uint dev,uint blockno,uint buf_pos){
const uint hash_pos=hasher(dev, blockno);
acquire(&bcache.hashlock[hash_pos]);
bcache.nxt[buf_pos]=bcache.hash_head[hash_pos];
bcache.hash_head[hash_pos]=buf_pos;
release(&bcache.hashlock[hash_pos]);
}
void hash_del(uint dev,uint blockno){
const uint hash_pos=hasher(dev, blockno);
acquire(&bcache.hashlock[hash_pos]);
for(int cur=bcache.hash_head[hash_pos],pre=-2;cur!=-1;cur=bcache.nxt[cur]){
if(bcache.buf[cur].dev==dev && bcache.buf[cur].blockno==blockno){
if(pre==-2){// the head is what we are looking for
bcache.hash_head[hash_pos]=bcache.nxt[cur];
}else{
bcache.nxt[pre]=bcache.nxt[cur];
}
bcache.nxt[cur]=-1;
break;
}
pre=cur;
}
release(&bcache.hashlock[hash_pos]);
}
void
binit(void)
{
struct buf *b;
initlock(&bcache.lock, "bcache");
initlock(&bcache.freelistlock, "bcache_freelist");
for(int i=0;i<NHASH;i++){
initlock(&bcache.hashlock[i], "bcache_hashtable");
bcache.hash_head[i]=-1;
}
bcache.freelist_head=-1;
// Create linked list of buffers
bcache.head.prev = &bcache.head;
bcache.head.next = &bcache.head;
// bcache.head.prev = &bcache.head;
// bcache.head.next = &bcache.head;
for(b = bcache.buf; b < bcache.buf+NBUF; b++){
b->next = bcache.head.next;
b->prev = &bcache.head;
// b->next = bcache.head.next;
// b->prev = &bcache.head;
initsleeplock(&b->lock, "buffer");
bcache.head.next->prev = b;
bcache.head.next = b;
const uint cur=b-bcache.buf;
bcache.nxt[cur]=bcache.freelist_head;
bcache.freelist_head=cur;
// bcache.head.next->prev = b;
// bcache.head.next = b;
}
}
@ -60,31 +126,51 @@ bget(uint dev, uint blockno)
{
struct buf *b;
acquire(&bcache.lock);
int pos=hash_get(dev, blockno);
// Is the block already cached?
for(b = bcache.head.next; b != &bcache.head; b = b->next){
if(b->dev == dev && b->blockno == blockno){
b->refcnt++;
release(&bcache.lock);
acquiresleep(&b->lock);
return b;
}
// for(b = bcache.head.next; b != &bcache.head; b = b->next){
// if(b->dev == dev && b->blockno == blockno){
// b->refcnt++;
// release(&bcache.lock);
// acquiresleep(&b->lock);
// return b;
// }
// }
if(pos>=0){
b=&bcache.buf[pos];
++b->refcnt;
acquiresleep(&b->lock);
return b;
}
// Not cached.
// Recycle the least recently used (LRU) unused buffer.
for(b = bcache.head.prev; b != &bcache.head; b = b->prev){
if(b->refcnt == 0) {
b->dev = dev;
b->blockno = blockno;
b->valid = 0;
b->refcnt = 1;
release(&bcache.lock);
acquiresleep(&b->lock);
return b;
}
}
acquire(&bcache.freelistlock);
// for(b = bcache.head.prev; b != &bcache.head; b = b->prev){
// if(b->refcnt == 0) {
// hash_add(dev, blockno, b-bcache.buf);
// b->dev = dev;
// b->blockno = blockno;
// b->valid = 0;
// b->refcnt = 1;
// release(&bcache.lock);
// acquiresleep(&b->lock);
// return b;
// }
// }
// for(uint cur=bcache.freelist_head;cur!=-1;cur=bcache.nxt[cur])
// DEBUG();
// printf("%u\n",bcache.freelist_head);
b=&bcache.buf[bcache.freelist_head];
hash_add(dev,blockno,bcache.freelist_head);
b->dev=dev;
b->blockno=blockno;
b->valid=0;
b->refcnt=1;
bcache.freelist_head=bcache.nxt[bcache.freelist_head];
release(&bcache.freelistlock);
acquiresleep(&b->lock);
return b;
panic("bget: no buffers");
}
@ -121,33 +207,43 @@ brelse(struct buf *b)
releasesleep(&b->lock);
acquire(&bcache.lock);
// acquire(&bcache.lock);
b->refcnt--;
if (b->refcnt == 0) {
hash_del(b->dev, b->blockno);
// no one is waiting for it.
b->next->prev = b->prev;
b->prev->next = b->next;
b->next = bcache.head.next;
b->prev = &bcache.head;
bcache.head.next->prev = b;
bcache.head.next = b;
// b->next->prev = b->prev;
// b->prev->next = b->next;
// b->next = bcache.head.next;
// b->prev = &bcache.head;
// bcache.head.next->prev = b;
// bcache.head.next = b;gi
acquire(&bcache.freelistlock);
const int pos=b-bcache.buf;
bcache.nxt[pos]=bcache.freelist_head;
bcache.freelist_head=pos;
// DEBUG();
// printf("%u\n",bcache.freelist_head);
release(&bcache.freelistlock);
}
release(&bcache.lock);
// release(&bcache.lock);
}
void
bpin(struct buf *b) {
acquire(&bcache.lock);
// acquire(&bcache.lock);
b->refcnt++;
release(&bcache.lock);
// release(&bcache.lock);
}
void
bunpin(struct buf *b) {
acquire(&bcache.lock);
// acquire(&bcache.lock);
b->refcnt--;
release(&bcache.lock);
// release(&bcache.lock);
}

4
kernel/buf.h
View File

@ -5,8 +5,8 @@ struct buf {
uint blockno;
struct sleeplock lock;
uint refcnt;
struct buf *prev; // LRU cache list
struct buf *next;
// struct buf *prev; // LRU cache list
// struct buf *next;
uchar data[BSIZE];
};

1
kernel/defs.h
View File

@ -237,3 +237,4 @@ void netinit(void);
void net_rx(char *buf, int len);
#endif
#define DEBUG() printf("File: %s, Line: %d, Function: %s\n", __FILE__, __LINE__, __func__)

76
kernel/kalloc.c
View File

@ -46,10 +46,9 @@ freerange(void *pa_start, void *pa_end)
// initializing the allocator; see kinit above.)
void
kfree(void *pa)
{
push_off();
const int cpu=cpuid();
{
struct run *r;
int id;
if(((uint64)pa % PGSIZE) != 0 || (char*)pa < end || (uint64)pa >= PHYSTOP)
panic("kfree");
@ -58,11 +57,20 @@ kfree(void *pa)
memset(pa, 1, PGSIZE);
r = (struct run*)pa;
acquire(&kmem[cpu].lock);
r->next = kmem[cpu].freelist;
kmem[cpu].freelist = r;
release(&kmem[cpu].lock);
push_off();
id = cpuid();
pop_off();
acquire(&kmem[id].lock);
r->next = kmem[id].freelist;
kmem[id].freelist = r;
release(&kmem[id].lock);
/*acquire(&kmem.lock);
r->next = kmem.freelist;
kmem.freelist = r;
release(&kmem.lock);*/
}
// Allocate one 4096-byte page of physical memory.
@ -71,33 +79,39 @@ kfree(void *pa)
void *
kalloc(void)
{
push_off();
struct run *r;
const int cpu=cpuid();
acquire(&kmem[cpu].lock);
r = kmem[cpu].freelist;
int id;
push_off();
id = cpuid();
pop_off();
acquire(&kmem[id].lock);
r = kmem[id].freelist;
if (r)
kmem[id].freelist = r->next;
release(&kmem[id].lock);
if (r)
goto kallocinit;
for (int i=(id+1)%NCPU; i!=id; i=(i+1)%NCPU) {
acquire(&kmem[i].lock);
r = kmem[i].freelist;
if (r)
kmem[i].freelist = r->next;
release(&kmem[i].lock);
if (r)
goto kallocinit;
}
/*acquire(&kmem.lock);
r = kmem.freelist;
if(r)
kmem[cpu].freelist = r->next;
while(!r)
for(int i=0;i<NCPU;++i){
if(i==cpu)
continue;
if(kmem[i].lock.locked)
continue;
acquire(&kmem[i].lock);
r=kmem[i].freelist;
if(r){
kmem[i].freelist = r->next;
goto fine;
}
release(&kmem[i].lock);
continue;
fine:
break;
}
release(&kmem[cpu].lock);
kmem.freelist = r->next;
release(&kmem.lock);*/
kallocinit:
if(r)
memset((char*)r, 5, PGSIZE); // fill with junk
pop_off();
return (void*)r;
}