buffer pool in project1 2021

[Stuip]

I am confused about the newpgImp function, when i called this function, it means that the buffermanager create a new page in disk or memory? If it is created in memory, do you need to set this isdirty variable to true or just write the page back to the disk?

[GavinRay97]

Disclaimer: I'm not an expert and am still working through this material myself.
Below is my understanding, but may not be correct.

NewPg is the function used to find/pick a page for use in the BufferPool.
If the BufferPool has empty pages (frames) available, then you use those first.

bustub/src/buffer/buffer_pool_manager_instance.cpp

Lines 59 to 66 in 783f191

	auto BufferPoolManagerInstance::NewPgImp(page_id_t *page_id) -> Page * {
	// 0. Make sure you call AllocatePage!
	// 1. If all the pages in the buffer pool are pinned, return nullptr.
	// 2. Pick a victim page P from either the free list or the replacer. Always pick from the free list first.
	// 3. Update P's metadata, zero out memory and add P to the page table.
	// 4. Set the page ID output parameter. Return a pointer to P.
	return nullptr;
	}

In the image below, frame 4 is available, so you'd want to allocate into that frame first.

If there aren't any empty pages available, you use your replacement policy to decide which
existing page should be evicted and re-used as the new page.

No disk I/O happens at this point, this is all purely in-memory

If it is created in memory, do you need to set this isdirty variable to true or just write the page back to the disk?

A page becomes dirty when there are changes to it in-memory that don't exist on-disk.

When you "sync" (flush) changes from the pages to disk, the dirty flag tells you which pages you should bother writing to disk because they have changes.

When a new page is allocated in memory, it can't be dirty, or referenced yet 👍

[GavinRay97]

Something that also helped me a lot (depending on your familiarity with programming) was the tip to just think of the BufferPoolManager as a glorified cache.

If you're familiar with Java, Guava's Cache uses an LRU eviction policy by default
The implementation of a Buffer Pool in Java could be simplistically implemented as something like this:

class BufferPoolManager {
    private static final int POOL_SIZE = 100;
    private final DiskManager diskManager;

    // LRU cache that holds POOL_SIZE pages
    //
    // When a new page is requested, if it exists in the cache, it is returned
    // Otherwise it is loaded from the DiskManager and added to the cache
    // If the cache is full, the least-recently-used page is evicted
    private final LoadingCache<PageId, Page> bufferPoolCache = CacheBuilder.newBuilder()
            .maximumSize(POOL_SIZE) // LRU eviction happens after reaching this size
            .build(new CacheLoader<>() {
                @Override
                public Page load(PageId pageId) throws Exception {
                    byte[] pageBuffer = new byte[4096];
                    diskManager.readPage(pageId.value(), pageBuffer);
                    return Page.fromBytes(pageBuffer);
                }
            });

    public BufferPoolCache(DiskManager diskManager) {
        this.diskManager = diskManager;
    }

    public Page getPage(PageId pageId) {
        return bufferPoolCache.get(pageId);
    }
}