RedBase page size = 4096 bytes - 4 = 4092 bytes (4K-8K is typical)

Buffer management

Buffer function

• All data operated on in buffer.

• Client requests page (file name + page number):
  • If page is in buffer, return pointer
  • If not, bring page into buffer (perhaps displacing another page) and return pointer

Page pinning

• Won't be replaced
• Won't be written to disk by buffer manager

(1)


(2)


(3)

Buffer manager - basic functions

1. Search for page in buffer (file name + page number)
   • sequential
   • table/list
   • hashing -- RedBase

2. Replace some page in buffer
   Strategies:

     (a)
   
     (b)
   
     (c)
   
     (d)
   
     (e)
   
   

3. Reserve (allocate) set of page slots
   • for certain operations
   • for certain types of pages (header, index, metadata)
   • for certain transactions

Difference between DBMS buffer manager and OS virtual memory

• More "semantics" to pages -- different types may use different allocation strategies

• More "semantics" to page access patterns -- different and/or customized page replacement strategies

• More concurrency on pages

• Managed by software, not hardware

• Forced writes

• Others?

Relations and files

Question: Why do something different?

Records (tuples) on paged files

• fixed-length
• small
• unsorted

Simple record layout scheme:

More complex for:

Summary

RedBase Paged File (PF) component

General picture:

1. Startup: create one instance of PF_Manager class

2. File and scratch space routines:

        PF_Manager:: CreateFile
                     DestroyFile
                     OpenFile    -> initialized "file handle"
                     Close File
                     AllocateBlock  -> scratch memory page in buffer
                     DisposeBlock
   

3. Page routines:

        PF_FileHandle:: GetFirstPage   -> initialized "page handle"
                        GetLastPage    ->           "
                        GetNextPage(n) ->           "
                        GetPrevPage(n) ->           "
                        GetThisPage(n) ->           "
                        AllocatePage   ->           "
                     // All page fetches pin page automatically
                        DisposePage(n)
                        MarkDirty(n)
                        UnpinPage(n)
                        ForcePages(n)
   

4. Page Access:

        PF_PageHandle:: GetData
                        GetPageNum
   

• Page allocation is sequential initially
• Allocation is LIFO after dispose/allocate
• File scans get pages sequentially

Read document carefully!!
(return codes, error handling, statistics tracking, ...)

Also read the RedBase Logistics document carefully
(getting code, makefiles, ...)

RedBase Record Management (RM) component

General picture:

• On each page: Use bitmap, or link free slots, or ...
• Across pages: "linked list" of pages with free space

Record identifier (RID) = (page number, slot number)

1. Startup: RM_Manager class -- one instance, PF_Manager is parameter

2. File routines:

        RM_Manager:: CreateFile(record size) - set up header
                     DestroyFile
                     OpenFile -> initialized file handle
                                 (copy header)
                     Close File
   

3. Record routines:

        RM_FileHandle:: GetRec(RID)
                        InsertRec(data)
                        DeleteRec(RID)
                        UpdateRec(data,RID)
        Also ForcePages(n)
   

   Diagram of record handling:

4. Record Access:

        RM_Record:: GetData
                    GetRid
   

5. Record IDs:

        RID:: GetPageNum
              GetSlotNum
   

6. Scans:

        RM_FileScan:: OpenScan(file, attr, comp, value, pin-hint)
                   // File scan object is "scan handle", maintains state of scan
                      GetNextRec
                      CloseScan
   

   • Can suspend and resume scans at will.
   • Don't worry about modification scans concurrent with other scans.

Also read the RedBase Logistics document carefully
(testing, submission, grading)