Operating System Project - Develop Heap Memory Manager in C

Explore phase one of the virtual memory page allocator by requesting and releasing a complete page with mmap and unmap on Linux. Understand page size and allocation granularity.

Explore how mmap allocates and deallocates virtual memory pages between a user-space Linux memory manager and the kernel via the system call interface, highlighting noncontiguous pages and heap memory.

Explore two API signatures for virtual memory: allocate contiguous pages from the kernel to userspace and release them back, using units and the bottom address, returning the start address.

Implement Linux memory manager APIs to allocate and release virtual memory pages using mmap and munmap, with initialization via m_init and system page size detection.

Register page families by sending each structure's name and size from the user space application to the Linux memory manager during initialization, using kernel-allocated virtual memory pages to store data.

Shows how the Linux memory manager registers page families by requesting memory pages with mmap, stores each family's name and size, and links pages for iteration.

Implement the page family instantiation algorithm in m.c to register a page family by name and size, manage the global VM page pointer, and allocate or extend pages as needed.

Integrate the Linux memory manager with external applications by exposing a user API header that defines registration macros and structures, enabling apps to initialize and register data types (employee, student).

Design data structures for meta and data blocks in a heap memory manager, where each data block has a preceding meta block and meta blocks manage metadata and free/allocated chains.

Define four-field meta block data structure for heap memory manager, including is_free, block_size, next/previous pointers, and offset, to map blocks to linux memory page and enable constant-time malloc/free.

Learn to define five header macros for meta block management: compute field offsets, fetch hosting pages, move to next or previous blocks, and use block size for address calculation.

update the memcache file by redefining the block metadata structure, adding macros to manipulate metadata, and defining a boolean data type for false and true to enable compilation and testing.

When a memory page is allocated, treat it as a free data block guarded by a meta block. Malloc splits it into an allocated block and a remaining free block.

Explore how splitting a free data block during malloc adjusts previous and next pointers of related meta blocks, including penultimate and anti penultimate blocks, in a virtual memory page.

Block merging begins when the memory manager frees a data block, merging consecutive free blocks in the virtual memory page into a bigger free block to prevent fragmentation.

The api that performs block merge merges two consecutive free blocks in a virtual memory page by updating block size, next and previous pointers, creating a single larger free block.

Explore how the Linux memory manager handles virtual memory page management, including page families, first pages, a doubly linked list, and the meta and free data blocks.

Explore vm page deletion API in Linux memory manager, deleting a virtual memory page from the page family, handling head or middle list positions, and returning it to kernel space.

Apply the worst fit memory allocation strategy by selecting virtual memory page with the largest free data block to satisfy malloc requests and outline needed data structures and APIs.

gl threads, a glue-based doubly linked list, and reorder a priority queue of free data blocks to implement best fit and first fit in the Linux memory manager.

Implement the mm_split_free_data_block_for_allocation API to split a free data block, update meta blocks, manage no/partial/full splits, handle soft and hard internal fragmentation, update priority queue, and prepare x malloc testing.

Begin phase eight by testing and validating the heap memory manager, writing printing functions to dump the Linux memory manager's state and a demo app to claim memory, then verify.

Demonstrates testing a Linux memory manager by claiming five objects (three employees and two students) and printing its internal state and memory usage, including page families and meta blocks.

Explore optional CLI integration for a C-based Linux memory manager, enabling command-line control to dump memory statistics without hooking printers, and learn to integrate a CLI library into C/C++ projects.

Implement the x3 free call to return memory to memory manager, handle block merging and fragmentation, and finalize the m3 blocks api to free blocks and return pages to kernel.

Explore two scenarios for handling hard internal fragmentation when freeing blocks in a virtual memory page: non-uppermost blocks absorb interior fragmentation, while page-boundary blocks absorb boundary fragmentation, via xfree implementation.

Demonstrate end-to-end testing of a Linux memory manager in C by allocating and freeing blocks across three scenarios, printing memory state, and validating block merging and statistics.