Return to zone.h CVS log

Up to [Quake] / quake1

Annotation of quake1/zone.h, revision 1.1.1.1

1.1       root        1: /*
                      2:  memory allocation
                      3: 
                      4: 
                      5: H_??? The hunk manages the entire memory block given to quake.  It must be
                      6: contiguous.  Memory can be allocated from either the low or high end in a
                      7: stack fashion.  The only way memory is released is by resetting one of the
                      8: pointers.
                      9: 
                     10: Hunk allocations should be given a name, so the Hunk_Print () function
                     11: can display usage.
                     12: 
                     13: Hunk allocations are guaranteed to be 16 byte aligned.
                     14: 
                     15: The video buffers are allocated high to avoid leaving a hole underneath
                     16: server allocations when changing to a higher video mode.
                     17: 
                     18: 
                     19: Z_??? Zone memory functions used for small, dynamic allocations like text
                     20: strings from command input.  There is only about 48K for it, allocated at
                     21: the very bottom of the hunk.
                     22: 
                     23: Cache_??? Cache memory is for objects that can be dynamically loaded and
                     24: can usefully stay persistant between levels.  The size of the cache
                     25: fluctuates from level to level.
                     26: 
                     27: To allocate a cachable object
                     28: 
                     29: 
                     30: Temp_??? Temp memory is used for file loading and surface caching.  The size
                     31: of the cache memory is adjusted so that there is a minimum of 512k remaining
                     32: for temp memory.
                     33: 
                     34: 
                     35: ------ Top of Memory -------
                     36: 
                     37: high hunk allocations
                     38: 
                     39: <--- high hunk reset point held by vid
                     40: 
                     41: video buffer
                     42: 
                     43: z buffer
                     44: 
                     45: surface cache
                     46: 
                     47: <--- high hunk used
                     48: 
                     49: cachable memory
                     50: 
                     51: <--- low hunk used
                     52: 
                     53: client and server low hunk allocations
                     54: 
                     55: <-- low hunk reset point held by host
                     56: 
                     57: startup hunk allocations
                     58: 
                     59: Zone block
                     60: 
                     61: ----- Bottom of Memory -----
                     62: 
                     63: 
                     64: 
                     65: */
                     66: 
                     67: void Memory_Init (void *buf, int size);
                     68: 
                     69: void Z_Free (void *ptr);
                     70: void *Z_Malloc (int size);                     // returns 0 filled memory
                     71: void *Z_TagMalloc (int size, int tag);
                     72: 
                     73: void Z_DumpHeap (void);
                     74: void Z_CheckHeap (void);
                     75: int Z_FreeMemory (void);
                     76: 
                     77: void *Hunk_Alloc (int size);           // returns 0 filled memory
                     78: void *Hunk_AllocName (int size, char *name);
                     79: 
                     80: void *Hunk_HighAllocName (int size, char *name);
                     81: 
                     82: int    Hunk_LowMark (void);
                     83: void Hunk_FreeToLowMark (int mark);
                     84: 
                     85: int    Hunk_HighMark (void);
                     86: void Hunk_FreeToHighMark (int mark);
                     87: 
                     88: void *Hunk_TempAlloc (int size);
                     89: 
                     90: void Hunk_Check (void);
                     91: 
                     92: typedef struct cache_user_s
                     93: {
                     94:        void    *data;
                     95: } cache_user_t;
                     96: 
                     97: void Cache_Flush (void);
                     98: 
                     99: void *Cache_Check (cache_user_t *c);
                    100: // returns the cached data, and moves to the head of the LRU list
                    101: // if present, otherwise returns NULL
                    102: 
                    103: void Cache_Free (cache_user_t *c);
                    104: 
                    105: void *Cache_Alloc (cache_user_t *c, int size, char *name);
                    106: // Returns NULL if all purgable data was tossed and there still
                    107: // wasn't enough room.
                    108: 
                    109: void Cache_Report (void);
                    110: 
                    111: 
                    112: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.