src/memory/heap.hpp

Idź do dokumentacji tego pliku.

/*header file for src/memory/heap.cpp*/

#ifndef _CORE_MEMORY_HEAP_HPP
#define _CORE_MEMORY_HEAP_HPP

//necessary includes
#include "src/ipc/lock.hpp"
#include "src/common/blist.hpp"
#include "src/memory/zone.hpp"

//facility types. these are definitions specific for the panalix os.
const uint32 FAC_OWN    = 0x001f;       //the mask for the owner's id
const uint32 FAC_TYPE   = 0x07e0;       //the mask for the type's id
const uint32 FAC_MIDDLE = 0x7800;       //optional: what middleman is involved with this object
//owners
const uint32 FAC_NULL   = 0x0000;       //null
const uint32 FAC_UNDEF  = 0x0001;       //undefined
const uint32 FAC_OTHER  = 0x0002;       //other
const uint32 FAC_MEMORY = 0x0003;       //memory book keeping
const uint32 FAC_INTERR = 0x0004;       //interrupt management
const uint32 FAC_THREAD = 0x0005;       //threading
const uint32 FAC_MSG    = 0x0006;       //message passing
const uint32 FAC_MMAP   = 0x0007;       //memory maps
const uint32 FAC_SYMS   = 0x0008;       //the kernel's symbols
//types
const uint32 FAC_VMEM           = 0x0020;       //FAC_OTHER:  video memory buffer
const uint32 FAC_USEDBLOCKS     = 0x0020;       //FAC_MEMORY: book keeping: used blocks tables
const uint32 FAC_PGD            = 0x0040;       //FAC_MEMORY: a page directory
const uint32 FAC_IDT            = 0x0020;       //FAC_INTERR: the idt or idtr
const uint32 FAC_EXCLIST        = 0x0040;       //FAC_INTERR: an element of the except.c interruption handler list
const uint32 FAC_THRLIST        = 0x0020;       //FAC_THREAD: thread lists
const uint32 FAC_TSP            = 0x0040;       //FAC_THREAD: thread stack pointer
const uint32 FAC_KSP            = 0x0060;       //FAC_THREAD: kernel stack pointer
const uint32 FAC_ISP            = 0x0080;       //FAC_THREAD: interruption stack pointer
const uint32 FAC_THRSLEEP       = 0x00a0;       //FAC_THREAD: sleeping threads list
const uint32 FAC_THRRAN         = 0x00c0;       //FAC_THREAD: ran threads list
const uint32 FAC_MESSAGE        = 0x0020;       //FAC_MSG:    a message
const uint32 FAC_MSGLIST        = 0x0040;       //FAC_MSG:    a message in blist
const uint32 FAC_MEMREG         = 0x0020;       //FAC_MMAP:   a memory region
const uint32 FAC_SYMTAB         = 0x0020;       //FAC_SYMS:   a symbol table
const uint32 FAC_STRTAB         = 0x0040;       //FAC_SYMS:   a string table
const uint32 FAC_QSORTBUF       = 0x0020;       //FAC_OTHER:  qsort's temp buf
const uint32 FAC_MANGLE         = 0x0040;       //FAC_OTHER:  temporary space for the mangling routines
const uint32 FAC_MANGLE2        = 0x0040;       //FAC_OTHER:  argument type list
//middlemen
const uint32 FAC_BLIST          = 0x0800;       // src/common/blist.cpp, data hold
const uint32 FAC_BLIST_BK       = 0x1000;       // src/common/blist.cpp, book keeping
const uint32 FAC_BLIST_PTR      = 0x1800;       // src/common/blist.cpp, a pointer

namespace Memory {
namespace Heap {

const uint32 heap_magic         = 0xcafebabe;//a checksum for heap bookkeeping elements
const uint32 HEAP_GRAN          = 0x1;  //1 block of pages- default heap granulity
const uint32 HEAP_STACK_GRAN    = 0x10000;//the virtual page stack granulity- 16 pages
const uint32 HEAP_TBLE          = 0x20; //the minimal size of the used objects table
const uint32 HEAP_TBLE_GRAN     = 0x100;//if the table has to be resized, it's by this element count /*! \bug should double the table */
const uint32 HEAP_MIN_BLOCK     = 0x10; //minimal allocated block size
const uint32 HEAPBOX_NAME       = 0x10; //a name for a heapbox.. lol

const uint32 MALLOC_NOLOCKS     = 1;
const uint32 MALLOC_NORESCUE    = 2;
const uint32 MALLOC_MORECOR_NEW_NODE = 4;


/*these are bookkeeping structs for the heap management actually.*/
struct block_used
 {
        void *ptr;
        size_t size;
        union
         {
                uint32 facility;        //who does own this block of memory?
                const char *name;
         };
        int (*destruct)(class heapbox*,void*);
 };

struct block_free
 {
        block_free *prev;
        block_free *next;
        size_t size;
        uint32 checksum;
 };

extern class blist_t HeapList;  //here we store all the heaps.

void init();    /*init some basic data for heaps*/
int allocate_heapbox(class heapbox *hbx, const char *name);     //create a heapbox
addr_t morecore(size_t cnt);    //allocates some virtual space
void freecore(addr_t virt, size_t cnt); //free them

int checkMagic(block_free *item);       //checksum check
int checkMagic(block_used *item);       //checksum check
int countMagic(block_free *item);       //count checksum
int countMagic(block_used *item);       //count checksum

const uint32 PROLOG_CHECKSUM  = 0xbabaf00l;

struct block_prolog {
   uint32 ov;     // offset w used table
   uint32 check;  // ov + check should be PROLOG_CHECKSUM+heapbox_no
};


/*there are many heaps in panalix. you just need to know which one you want.*/
class heapbox
 {
protected:
public:
        class blist_t VirtAddrs;        //what virtual pages are connected with the heap
        block_used *used;       //list of allocated blocks
        uint32 begin_search;    //where to begin search for knew_used
        size_t max_blocks;      //the size of the used blocks table
        block_free *first;      //the first and last free blocks
        bool volatile NowResizingUsed;  //internal malloc val, are we now in progress of engrowing the used blocks table?
        IPC::Lock::lock_t lock_heap;            //lock on tha heap
        struct {
                uint32 volatile allocs;         //stats: how many allocated blocks are supplied?
                uint32 volatile max;            //stats: the size of the whole heap
                uint32 volatile used;           //stats: the used space
         } stats;       //stats
        char name[HEAPBOX_NAME];
   uint32 heapbox_no;
   struct blist_s *morecor_new_node;   //alokowany z wyprzedzeniem blok pamieci, ktory potrzebny jest dla morecor by zwiekszyc rozmiar sterty

        void unAnchorBlock(block_free *item);
        int take_block (block_free *item, uint32 facility, int (*destruct)(class heapbox*,void*));
        addr_t morecor(uint32 cnt, bool alloc_pgs);     //morecore
        int knew_used(void *ptr, uint32 size, uint32 facility, int (destructor)(class heapbox*,void*)); //add a block to used list
        block_free *klastfree();
        uint32 blsize(char *ptr);
        block_used *kget_info(void *ptr);
        void kdefragment(void *ptr);
        int resize_used_blocks_table(); // resizes the table, ziom
   void *mallocFuncPr(size_t size, size_t alignment, uint32 facility, int (*destruct)(class heapbox*, void*), uint32 MallocState);
        void *mallocFunc(size_t size, size_t alignment, uint32 facility, int (*destruct)(class heapbox*,void*), uint32 MallocState);//allocate memory
        int freeFuncPr(void *ptr, uint32 FreeState);
        int freeFunc(void *ptr, uint32 FreeState);
public:
//a copy to experiment with
#if 1
        int freeFunc2(void *ptr, uint32 FreeState);
        int freeFuncPr2(void *ptr, uint32 FreeState);
#endif
        heapbox();
        void init(block_used *usd, size_t max_blcks, block_free *fir, const char *nam);
        void destruct();        //dispose all memory
        void *malloc(size_t size, size_t alignment, uint32 facility, int (*destruct)(class heapbox*,void*));    //allocate memory; //stub for mallocFunc
        void *malloc(size_t size, size_t alignment, const char *name, int (*destruct)(class heapbox*,void*));   //allocate memory;// stub for mallocFunc
        int free(void *ptr);    //free it; stub for freeFunc

        uint32 allocated_count();       //returns allocs
 };


extern class heapbox heap0;     //the most principal heap
extern class ::Memory::zone virtual_pages;//a stack of free, virtual pages

  };    /*namespace Heap*/
 };     /*namespace Memory*/

void debug_heap_stats(Memory::Heap::heapbox *hp);       //output some stats, including the freelist linked list

#endif

---