![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to zone.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quakeworld / client|
Return to zone.c CVS log | Up to [Quake] / quakeworld / client |
1.1 root 1: /*
2: Copyright (C) 1996-1997 Id Software, Inc.
3:
4: This program is free software; you can redistribute it and/or
5: modify it under the terms of the GNU General Public License
6: as published by the Free Software Foundation; either version 2
7: of the License, or (at your option) any later version.
8:
9: This program is distributed in the hope that it will be useful,
10: but WITHOUT ANY WARRANTY; without even the implied warranty of
11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12:
13: See the GNU General Public License for more details.
14:
15: You should have received a copy of the GNU General Public License
16: along with this program; if not, write to the Free Software
17: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18:
19: */
20: // Z_zone.c
21:
22: #include "quakedef.h"
23:
24: #define DYNAMIC_SIZE 0x20000
25:
26: #define ZONEID 0x1d4a11
27: #define MINFRAGMENT 64
28:
29: typedef struct memblock_s
30: {
31: int size; // including the header and possibly tiny fragments
32: int tag; // a tag of 0 is a free block
33: int id; // should be ZONEID
34: struct memblock_s *next, *prev;
35: int pad; // pad to 64 bit boundary
36: } memblock_t;
37:
38: typedef struct
39: {
40: int size; // total bytes malloced, including header
41: memblock_t blocklist; // start / end cap for linked list
42: memblock_t *rover;
43: } memzone_t;
44:
45: void Cache_FreeLow (int new_low_hunk);
46: void Cache_FreeHigh (int new_high_hunk);
47:
48:
49: /*
50: ==============================================================================
51:
52: ZONE MEMORY ALLOCATION
53:
54: There is never any space between memblocks, and there will never be two
55: contiguous free memblocks.
56:
57: The rover can be left pointing at a non-empty block
58:
59: The zone calls are pretty much only used for small strings and structures,
60: all big things are allocated on the hunk.
61: ==============================================================================
62: */
63:
64: memzone_t *mainzone;
65:
66: void Z_ClearZone (memzone_t *zone, int size);
67:
68:
69: /*
70: ========================
71: Z_ClearZone
72: ========================
73: */
74: void Z_ClearZone (memzone_t *zone, int size)
75: {
76: memblock_t *block;
77:
78: // set the entire zone to one free block
79:
80: zone->blocklist.next = zone->blocklist.prev = block =
81: (memblock_t *)( (byte *)zone + sizeof(memzone_t) );
82: zone->blocklist.tag = 1; // in use block
83: zone->blocklist.id = 0;
84: zone->blocklist.size = 0;
85: zone->rover = block;
86:
87: block->prev = block->next = &zone->blocklist;
88: block->tag = 0; // free block
89: block->id = ZONEID;
90: block->size = size - sizeof(memzone_t);
91: }
92:
93:
94: /*
95: ========================
96: Z_Free
97: ========================
98: */
99: void Z_Free (void *ptr)
100: {
101: memblock_t *block, *other;
102:
103: if (!ptr)
104: Sys_Error ("Z_Free: NULL pointer");
105:
106: block = (memblock_t *) ( (byte *)ptr - sizeof(memblock_t));
107: if (block->id != ZONEID)
108: Sys_Error ("Z_Free: freed a pointer without ZONEID");
109: if (block->tag == 0)
110: Sys_Error ("Z_Free: freed a freed pointer");
111:
112: block->tag = 0; // mark as free
113:
114: other = block->prev;
115: if (!other->tag)
116: { // merge with previous free block
117: other->size += block->size;
118: other->next = block->next;
119: other->next->prev = other;
120: if (block == mainzone->rover)
121: mainzone->rover = other;
122: block = other;
123: }
124:
125: other = block->next;
126: if (!other->tag)
127: { // merge the next free block onto the end
128: block->size += other->size;
129: block->next = other->next;
130: block->next->prev = block;
131: if (other == mainzone->rover)
132: mainzone->rover = block;
133: }
134: }
135:
136:
137: /*
138: ========================
139: Z_Malloc
140: ========================
141: */
142: void *Z_Malloc (int size)
143: {
144: void *buf;
145:
146: Z_CheckHeap (); // DEBUG
147: buf = Z_TagMalloc (size, 1);
148: if (!buf)
149: Sys_Error ("Z_Malloc: failed on allocation of %i bytes",size);
150: Q_memset (buf, 0, size);
151:
152: return buf;
153: }
154:
155: void *Z_TagMalloc (int size, int tag)
156: {
157: int extra;
158: memblock_t *start, *rover, *new, *base;
159:
160: if (!tag)
161: Sys_Error ("Z_TagMalloc: tried to use a 0 tag");
162:
163: //
164: // scan through the block list looking for the first free block
165: // of sufficient size
166: //
167: size += sizeof(memblock_t); // account for size of block header
168: size += 4; // space for memory trash tester
169: size = (size + 7) & ~7; // align to 8-byte boundary
170:
171: base = rover = mainzone->rover;
172: start = base->prev;
173:
174: do
175: {
176: if (rover == start) // scaned all the way around the list
177: return NULL;
178: if (rover->tag)
179: base = rover = rover->next;
180: else
181: rover = rover->next;
182: } while (base->tag || base->size < size);
183:
184: //
185: // found a block big enough
186: //
187: extra = base->size - size;
188: if (extra > MINFRAGMENT)
189: { // there will be a free fragment after the allocated block
190: new = (memblock_t *) ((byte *)base + size );
191: new->size = extra;
192: new->tag = 0; // free block
193: new->prev = base;
194: new->id = ZONEID;
195: new->next = base->next;
196: new->next->prev = new;
197: base->next = new;
198: base->size = size;
199: }
200:
201: base->tag = tag; // no longer a free block
202:
203: mainzone->rover = base->next; // next allocation will start looking here
204:
205: base->id = ZONEID;
206:
207: // marker for memory trash testing
208: *(int *)((byte *)base + base->size - 4) = ZONEID;
209:
210: return (void *) ((byte *)base + sizeof(memblock_t));
211: }
212:
213:
214: /*
215: ========================
216: Z_Print
217: ========================
218: */
219: void Z_Print (memzone_t *zone)
220: {
221: memblock_t *block;
222:
223: Con_Printf ("zone size: %i location: %p\n",mainzone->size,mainzone);
224:
225: for (block = zone->blocklist.next ; ; block = block->next)
226: {
227: Con_Printf ("block:%p size:%7i tag:%3i\n",
228: block, block->size, block->tag);
229:
230: if (block->next == &zone->blocklist)
231: break; // all blocks have been hit
232: if ( (byte *)block + block->size != (byte *)block->next)
233: Con_Printf ("ERROR: block size does not touch the next block\n");
234: if ( block->next->prev != block)
235: Con_Printf ("ERROR: next block doesn't have proper back link\n");
236: if (!block->tag && !block->next->tag)
237: Con_Printf ("ERROR: two consecutive free blocks\n");
238: }
239: }
240:
241:
242: /*
243: ========================
244: Z_CheckHeap
245: ========================
246: */
247: void Z_CheckHeap (void)
248: {
249: memblock_t *block;
250:
251: for (block = mainzone->blocklist.next ; ; block = block->next)
252: {
253: if (block->next == &mainzone->blocklist)
254: break; // all blocks have been hit
255: if ( (byte *)block + block->size != (byte *)block->next)
256: Sys_Error ("Z_CheckHeap: block size does not touch the next block\n");
257: if ( block->next->prev != block)
258: Sys_Error ("Z_CheckHeap: next block doesn't have proper back link\n");
259: if (!block->tag && !block->next->tag)
260: Sys_Error ("Z_CheckHeap: two consecutive free blocks\n");
261: }
262: }
263:
264: //============================================================================
265:
266: #define HUNK_SENTINAL 0x1df001ed
267:
268: typedef struct
269: {
270: int sentinal;
271: int size; // including sizeof(hunk_t), -1 = not allocated
272: char name[8];
273: } hunk_t;
274:
275: byte *hunk_base;
276: int hunk_size;
277:
278: int hunk_low_used;
279: int hunk_high_used;
280:
281: qboolean hunk_tempactive;
282: int hunk_tempmark;
283:
284: void R_FreeTextures (void);
285:
286: /*
287: ==============
288: Hunk_Check
289:
290: Run consistancy and sentinal trahing checks
291: ==============
292: */
293: void Hunk_Check (void)
294: {
295: hunk_t *h;
296:
297: for (h = (hunk_t *)hunk_base ; (byte *)h != hunk_base + hunk_low_used ; )
298: {
299: if (h->sentinal != HUNK_SENTINAL)
300: Sys_Error ("Hunk_Check: trahsed sentinal");
301: if (h->size < 16 || h->size + (byte *)h - hunk_base > hunk_size)
302: Sys_Error ("Hunk_Check: bad size");
303: h = (hunk_t *)((byte *)h+h->size);
304: }
305: }
306:
307: /*
308: ==============
309: Hunk_Print
310:
311: If "all" is specified, every single allocation is printed.
312: Otherwise, allocations with the same name will be totaled up before printing.
313: ==============
314: */
315: void Hunk_Print (qboolean all)
316: {
317: hunk_t *h, *next, *endlow, *starthigh, *endhigh;
318: int count, sum;
319: int totalblocks;
320: char name[9];
321:
322: name[8] = 0;
323: count = 0;
324: sum = 0;
325: totalblocks = 0;
326:
327: h = (hunk_t *)hunk_base;
328: endlow = (hunk_t *)(hunk_base + hunk_low_used);
329: starthigh = (hunk_t *)(hunk_base + hunk_size - hunk_high_used);
330: endhigh = (hunk_t *)(hunk_base + hunk_size);
331:
332: Con_Printf (" :%8i total hunk size\n", hunk_size);
333: Con_Printf ("-------------------------\n");
334:
335: while (1)
336: {
337: //
338: // skip to the high hunk if done with low hunk
339: //
340: if ( h == endlow )
341: {
342: Con_Printf ("-------------------------\n");
343: Con_Printf (" :%8i REMAINING\n", hunk_size - hunk_low_used - hunk_high_used);
344: Con_Printf ("-------------------------\n");
345: h = starthigh;
346: }
347:
348: //
349: // if totally done, break
350: //
351: if ( h == endhigh )
352: break;
353:
354: //
355: // run consistancy checks
356: //
357: if (h->sentinal != HUNK_SENTINAL)
358: Sys_Error ("Hunk_Check: trahsed sentinal");
359: if (h->size < 16 || h->size + (byte *)h - hunk_base > hunk_size)
360: Sys_Error ("Hunk_Check: bad size");
361:
362: next = (hunk_t *)((byte *)h+h->size);
363: count++;
364: totalblocks++;
365: sum += h->size;
366:
367: //
368: // print the single block
369: //
370: memcpy (name, h->name, 8);
371: if (all)
372: Con_Printf ("%8p :%8i %8s\n",h, h->size, name);
373:
374: //
375: // print the total
376: //
377: if (next == endlow || next == endhigh ||
378: strncmp (h->name, next->name, 8) )
379: {
380: if (!all)
381: Con_Printf (" :%8i %8s (TOTAL)\n",sum, name);
382: count = 0;
383: sum = 0;
384: }
385:
386: h = next;
387: }
388:
389: Con_Printf ("-------------------------\n");
390: Con_Printf ("%8i total blocks\n", totalblocks);
391:
392: }
393:
394: /*
395: ===================
396: Hunk_AllocName
397: ===================
398: */
399: void *Hunk_AllocName (int size, char *name)
400: {
401: hunk_t *h;
402:
403: #ifdef PARANOID
404: Hunk_Check ();
405: #endif
406:
407: if (size < 0)
408: Sys_Error ("Hunk_Alloc: bad size: %i", size);
409:
410: size = sizeof(hunk_t) + ((size+15)&~15);
411:
412: if (hunk_size - hunk_low_used - hunk_high_used < size)
413: // Sys_Error ("Hunk_Alloc: failed on %i bytes",size);
414: #ifdef _WIN32
415: Sys_Error ("Not enough RAM allocated. Try starting using \"-heapsize 16000\" on the QuakeWorld command line.");
416: #else
417: Sys_Error ("Not enough RAM allocated. Try starting using \"-mem 16\" on the QuakeWorld command line.");
418: #endif
419:
420: h = (hunk_t *)(hunk_base + hunk_low_used);
421: hunk_low_used += size;
422:
423: Cache_FreeLow (hunk_low_used);
424:
425: memset (h, 0, size);
426:
427: h->size = size;
428: h->sentinal = HUNK_SENTINAL;
429: Q_strncpy (h->name, name, 8);
430:
431: return (void *)(h+1);
432: }
433:
434: /*
435: ===================
436: Hunk_Alloc
437: ===================
438: */
439: void *Hunk_Alloc (int size)
440: {
441: return Hunk_AllocName (size, "unknown");
442: }
443:
444: int Hunk_LowMark (void)
445: {
446: return hunk_low_used;
447: }
448:
449: void Hunk_FreeToLowMark (int mark)
450: {
451: if (mark < 0 || mark > hunk_low_used)
452: Sys_Error ("Hunk_FreeToLowMark: bad mark %i", mark);
453: memset (hunk_base + mark, 0, hunk_low_used - mark);
454: hunk_low_used = mark;
455: }
456:
457: int Hunk_HighMark (void)
458: {
459: if (hunk_tempactive)
460: {
461: hunk_tempactive = false;
462: Hunk_FreeToHighMark (hunk_tempmark);
463: }
464:
465: return hunk_high_used;
466: }
467:
468: void Hunk_FreeToHighMark (int mark)
469: {
470: if (hunk_tempactive)
471: {
472: hunk_tempactive = false;
473: Hunk_FreeToHighMark (hunk_tempmark);
474: }
475: if (mark < 0 || mark > hunk_high_used)
476: Sys_Error ("Hunk_FreeToHighMark: bad mark %i", mark);
477: memset (hunk_base + hunk_size - hunk_high_used, 0, hunk_high_used - mark);
478: hunk_high_used = mark;
479: }
480:
481:
482: /*
483: ===================
484: Hunk_HighAllocName
485: ===================
486: */
487: void *Hunk_HighAllocName (int size, char *name)
488: {
489: hunk_t *h;
490:
491: if (size < 0)
492: Sys_Error ("Hunk_HighAllocName: bad size: %i", size);
493:
494: if (hunk_tempactive)
495: {
496: Hunk_FreeToHighMark (hunk_tempmark);
497: hunk_tempactive = false;
498: }
499:
500: #ifdef PARANOID
501: Hunk_Check ();
502: #endif
503:
504: size = sizeof(hunk_t) + ((size+15)&~15);
505:
506: if (hunk_size - hunk_low_used - hunk_high_used < size)
507: {
508: Con_Printf ("Hunk_HighAlloc: failed on %i bytes\n",size);
509: return NULL;
510: }
511:
512: hunk_high_used += size;
513: Cache_FreeHigh (hunk_high_used);
514:
515: h = (hunk_t *)(hunk_base + hunk_size - hunk_high_used);
516:
517: memset (h, 0, size);
518: h->size = size;
519: h->sentinal = HUNK_SENTINAL;
520: Q_strncpy (h->name, name, 8);
521:
522: return (void *)(h+1);
523: }
524:
525:
526: /*
527: =================
528: Hunk_TempAlloc
529:
530: Return space from the top of the hunk
531: =================
532: */
533: void *Hunk_TempAlloc (int size)
534: {
535: void *buf;
536:
537: size = (size+15)&~15;
538:
539: if (hunk_tempactive)
540: {
541: Hunk_FreeToHighMark (hunk_tempmark);
542: hunk_tempactive = false;
543: }
544:
545: hunk_tempmark = Hunk_HighMark ();
546:
547: buf = Hunk_HighAllocName (size, "temp");
548:
549: hunk_tempactive = true;
550:
551: return buf;
552: }
553:
554: /*
555: ===============================================================================
556:
557: CACHE MEMORY
558:
559: ===============================================================================
560: */
561:
562: typedef struct cache_system_s
563: {
564: int size; // including this header
565: cache_user_t *user;
566: char name[16];
567: struct cache_system_s *prev, *next;
568: struct cache_system_s *lru_prev, *lru_next; // for LRU flushing
569: } cache_system_t;
570:
571: cache_system_t *Cache_TryAlloc (int size, qboolean nobottom);
572:
573: cache_system_t cache_head;
574:
575: /*
576: ===========
577: Cache_Move
578: ===========
579: */
580: void Cache_Move ( cache_system_t *c)
581: {
582: cache_system_t *new;
583:
584: // we are clearing up space at the bottom, so only allocate it late
585: new = Cache_TryAlloc (c->size, true);
586: if (new)
587: {
588: // Con_Printf ("cache_move ok\n");
589:
590: Q_memcpy ( new+1, c+1, c->size - sizeof(cache_system_t) );
591: new->user = c->user;
592: Q_memcpy (new->name, c->name, sizeof(new->name));
593: Cache_Free (c->user);
594: new->user->data = (void *)(new+1);
595: }
596: else
597: {
598: // Con_Printf ("cache_move failed\n");
599:
600: Cache_Free (c->user); // tough luck...
601: }
602: }
603:
604: /*
605: ============
606: Cache_FreeLow
607:
608: Throw things out until the hunk can be expanded to the given point
609: ============
610: */
611: void Cache_FreeLow (int new_low_hunk)
612: {
613: cache_system_t *c;
614:
615: while (1)
616: {
617: c = cache_head.next;
618: if (c == &cache_head)
619: return; // nothing in cache at all
620: if ((byte *)c >= hunk_base + new_low_hunk)
621: return; // there is space to grow the hunk
622: Cache_Move ( c ); // reclaim the space
623: }
624: }
625:
626: /*
627: ============
628: Cache_FreeHigh
629:
630: Throw things out until the hunk can be expanded to the given point
631: ============
632: */
633: void Cache_FreeHigh (int new_high_hunk)
634: {
635: cache_system_t *c, *prev;
636:
637: prev = NULL;
638: while (1)
639: {
640: c = cache_head.prev;
641: if (c == &cache_head)
642: return; // nothing in cache at all
643: if ( (byte *)c + c->size <= hunk_base + hunk_size - new_high_hunk)
644: return; // there is space to grow the hunk
645: if (c == prev)
646: Cache_Free (c->user); // didn't move out of the way
647: else
648: {
649: Cache_Move (c); // try to move it
650: prev = c;
651: }
652: }
653: }
654:
655: void Cache_UnlinkLRU (cache_system_t *cs)
656: {
657: if (!cs->lru_next || !cs->lru_prev)
658: Sys_Error ("Cache_UnlinkLRU: NULL link");
659:
660: cs->lru_next->lru_prev = cs->lru_prev;
661: cs->lru_prev->lru_next = cs->lru_next;
662:
663: cs->lru_prev = cs->lru_next = NULL;
664: }
665:
666: void Cache_MakeLRU (cache_system_t *cs)
667: {
668: if (cs->lru_next || cs->lru_prev)
669: Sys_Error ("Cache_MakeLRU: active link");
670:
671: cache_head.lru_next->lru_prev = cs;
672: cs->lru_next = cache_head.lru_next;
673: cs->lru_prev = &cache_head;
674: cache_head.lru_next = cs;
675: }
676:
677: /*
678: ============
679: Cache_TryAlloc
680:
681: Looks for a free block of memory between the high and low hunk marks
682: Size should already include the header and padding
683: ============
684: */
685: cache_system_t *Cache_TryAlloc (int size, qboolean nobottom)
686: {
687: cache_system_t *cs, *new;
688:
689: // is the cache completely empty?
690:
691: if (!nobottom && cache_head.prev == &cache_head)
692: {
693: if (hunk_size - hunk_high_used - hunk_low_used < size)
694: Sys_Error ("Cache_TryAlloc: %i is greater then free hunk", size);
695:
696: new = (cache_system_t *) (hunk_base + hunk_low_used);
697: memset (new, 0, sizeof(*new));
698: new->size = size;
699:
700: cache_head.prev = cache_head.next = new;
701: new->prev = new->next = &cache_head;
702:
703: Cache_MakeLRU (new);
704: return new;
705: }
706:
707: // search from the bottom up for space
708:
709: new = (cache_system_t *) (hunk_base + hunk_low_used);
710: cs = cache_head.next;
711:
712: do
713: {
714: if (!nobottom || cs != cache_head.next)
715: {
716: if ( (byte *)cs - (byte *)new >= size)
717: { // found space
718: memset (new, 0, sizeof(*new));
719: new->size = size;
720:
721: new->next = cs;
722: new->prev = cs->prev;
723: cs->prev->next = new;
724: cs->prev = new;
725:
726: Cache_MakeLRU (new);
727:
728: return new;
729: }
730: }
731:
732: // continue looking
733: new = (cache_system_t *)((byte *)cs + cs->size);
734: cs = cs->next;
735:
736: } while (cs != &cache_head);
737:
738: // try to allocate one at the very end
739: if ( hunk_base + hunk_size - hunk_high_used - (byte *)new >= size)
740: {
741: memset (new, 0, sizeof(*new));
742: new->size = size;
743:
744: new->next = &cache_head;
745: new->prev = cache_head.prev;
746: cache_head.prev->next = new;
747: cache_head.prev = new;
748:
749: Cache_MakeLRU (new);
750:
751: return new;
752: }
753:
754: return NULL; // couldn't allocate
755: }
756:
757: /*
758: ============
759: Cache_Flush
760:
761: Throw everything out, so new data will be demand cached
762: ============
763: */
764: void Cache_Flush (void)
765: {
766: while (cache_head.next != &cache_head)
767: Cache_Free ( cache_head.next->user ); // reclaim the space
768: }
769:
770:
771: /*
772: ============
773: Cache_Print
774:
775: ============
776: */
777: void Cache_Print (void)
778: {
779: cache_system_t *cd;
780:
781: for (cd = cache_head.next ; cd != &cache_head ; cd = cd->next)
782: {
783: Con_Printf ("%8i : %s\n", cd->size, cd->name);
784: }
785: }
786:
787: /*
788: ============
789: Cache_Report
790:
791: ============
792: */
793: void Cache_Report (void)
794: {
795: Con_DPrintf ("%4.1f megabyte data cache\n", (hunk_size - hunk_high_used - hunk_low_used) / (float)(1024*1024) );
796: }
797:
798: /*
799: ============
800: Cache_Compact
801:
802: ============
803: */
804: void Cache_Compact (void)
805: {
806: }
807:
808: /*
809: ============
810: Cache_Init
811:
812: ============
813: */
814: void Cache_Init (void)
815: {
816: cache_head.next = cache_head.prev = &cache_head;
817: cache_head.lru_next = cache_head.lru_prev = &cache_head;
818:
819: Cmd_AddCommand ("flush", Cache_Flush);
820: }
821:
822: /*
823: ==============
824: Cache_Free
825:
826: Frees the memory and removes it from the LRU list
827: ==============
828: */
829: void Cache_Free (cache_user_t *c)
830: {
831: cache_system_t *cs;
832:
833: if (!c->data)
834: Sys_Error ("Cache_Free: not allocated");
835:
836: cs = ((cache_system_t *)c->data) - 1;
837:
838: cs->prev->next = cs->next;
839: cs->next->prev = cs->prev;
840: cs->next = cs->prev = NULL;
841:
842: c->data = NULL;
843:
844: Cache_UnlinkLRU (cs);
845: }
846:
847:
848:
849: /*
850: ==============
851: Cache_Check
852: ==============
853: */
854: void *Cache_Check (cache_user_t *c)
855: {
856: cache_system_t *cs;
857:
858: if (!c->data)
859: return NULL;
860:
861: cs = ((cache_system_t *)c->data) - 1;
862:
863: // move to head of LRU
864: Cache_UnlinkLRU (cs);
865: Cache_MakeLRU (cs);
866:
867: return c->data;
868: }
869:
870:
871: /*
872: ==============
873: Cache_Alloc
874: ==============
875: */
876: void *Cache_Alloc (cache_user_t *c, int size, char *name)
877: {
878: cache_system_t *cs;
879:
880: if (c->data)
881: Sys_Error ("Cache_Alloc: allready allocated");
882:
883: if (size <= 0)
884: Sys_Error ("Cache_Alloc: size %i", size);
885:
886: size = (size + sizeof(cache_system_t) + 15) & ~15;
887:
888: // find memory for it
889: while (1)
890: {
891: cs = Cache_TryAlloc (size, false);
892: if (cs)
893: {
894: strncpy (cs->name, name, sizeof(cs->name)-1);
895: c->data = (void *)(cs+1);
896: cs->user = c;
897: break;
898: }
899:
900: // free the least recently used cahedat
901: if (cache_head.lru_prev == &cache_head)
902: Sys_Error ("Cache_Alloc: out of memory");
903: // not enough memory at all
904: Cache_Free ( cache_head.lru_prev->user );
905: }
906:
907: return Cache_Check (c);
908: }
909:
910: //============================================================================
911:
912:
913: /*
914: ========================
915: Memory_Init
916: ========================
917: */
918: void Memory_Init (void *buf, int size)
919: {
920: int p;
921: int zonesize = DYNAMIC_SIZE;
922:
923: hunk_base = buf;
924: hunk_size = size;
925: hunk_low_used = 0;
926: hunk_high_used = 0;
927:
928: Cache_Init ();
929: p = COM_CheckParm ("-zone");
930: if (p)
931: {
932: if (p < com_argc-1)
933: zonesize = Q_atoi (com_argv[p+1]) * 1024;
934: else
935: Sys_Error ("Memory_Init: you must specify a size in KB after -zone");
936: }
937: mainzone = Hunk_AllocName ( zonesize, "zone" );
938: Z_ClearZone (mainzone, zonesize);
939: }
940:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.