OSDev.org

arabasso wrote:I was thinking about implementing a good memory manager for my OS project and I thought of several possibilities. The first was related to paging. In my OS project, reserve the first 1GB of memory to the kernel, and the rest for the user programs.

If each program has its own address space, so I conclude it would be interesting to allocate all the kernel Page Tables (for 1GB, 256 PTs would be used). Thus, 1 MB of memory is used, but has the advantage that when I was a new process, just copy the kernel page tables for pages tables of the processes, then all these pages mapped on kernel page tables would be available instantaneously.

Or I could go by placing the page tables when necessary, but there would be a serious problem if I change the page directory (in my OS, each process has its own page directory). With this, if I carry a module or anything else once I've uploaded a process, I would have to remap the page tables of all processes loaded.

Another thing is with respect to the algorithm to allocate / deallocate memory for the kernel and modules. I'm using double linked list heap algorithm to allocate / deallocate memory for the kernel. As I understand it, the heap algorithm seems "somewhat slow." The first thing I did to improve the heap algorithm was to remove it the page aligned allocation. Instead I created a bitmap containing all the pages in use (a bitmap for stack modules and kernel threads, another bitmap for processes's PTs and PDs, and so on). All these structures are stored in the kernel heap.

Another thing is with respect to the algorithm to allocate / deallocate memory for the kernel and modules. I'm using double linked list heap algorithm to allocate / deallocate memory for the kernel. As I understand it, the heap algorithm seems "somewhat slow." The first thing I did to improve the heap algorithm was to remove it the page aligned allocation. Instead I created a bitmap containing all the pages in use (a bitmap for stack modules and kernel threads, another bitmap for processes's PTs and PDs, and so on). All these structures are stored in the kernel heap.

Usually the page tables that map the kernel are created only once, and pointed to by all of the page directories. Having more than one copy of the kernel page tables is a recipe for disaster, because you need the kernel to be the same in all processes, and managing a hundred copies of them would be very hard and slow.

I guess by 'heap algorithm' you mean something like userspace malloc. Have you considered a buddy allocator or a slab allocator ? A slab allocator is particularly good for allocating memory for kernel objects that are created and destroyed like process tables, thread structures etc. A buddy allocator might be better for allocating memory (especially bigger contiguous blocks) for loadable modules and kernel stacks. I wrap all my kernel allocation routines up in one function called kmalloc and let it decide which algorith to use depending on the amount of memory being allocated.

struct Block
{
    unsigned short magic;
    bool free;
    unsigned long size;

    Block * next;
    Block * prev;
    Block * nextFree;
};

arabasso wrote:The big problem is that if each process has its own address space up to 1GB, so I can not simply use the same page directory for all processes.

gerryg400 wrote:http://ptgmedia.pearsoncmg.com/images/0 ... n_book.pdf

This book has an entire chapter on the linux slab allocator.

- gerryg400