cruft removal
[btb/d2x.git] / mem / mem.c
1 /*
2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.  
11 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
12 */
13
14
15 #ifdef RCS
16 static char rcsid[] = "$Id: mem.c,v 1.1.1.1 2001-01-19 03:29:58 bradleyb Exp $";
17 #endif
18
19
20 // Warning( "MEM: Too many malloc's!" );
21 // Warning( "MEM: Malloc returnd an already alloced block!" );
22 // Warning( "MEM: Malloc Failed!" );
23 // Warning( "MEM: Freeing the NULL pointer!" );
24 // Warning( "MEM: Freeing a non-malloced pointer!" );
25 // Warning( "MEM: %d/%d check bytes were overwritten at the end of %8x", ec, CHECKSIZE, buffer  );
26 // Warning( "MEM: %d blocks were left allocated!", numleft );
27
28 #include <conf.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <malloc.h>
33
34 #include "pstypes.h"
35 #include "mono.h"
36 #include "error.h"
37
38 #ifdef MACINTOSH
39
40         #include <Gestalt.h>
41         #include <Memory.h>
42         #include <Processes.h>
43         ubyte virtual_memory_on = 0;
44
45         #if defined(RELEASE) || defined(NDEBUG)
46                 #define MEMSTATS        0
47         #else
48                 #define MEMSTATS        1
49         #endif
50
51         
52         #if MEMSTATS
53                 static  int             sMemStatsFileInitialized        = false;
54                 static  FILE*   sMemStatsFile                           = NULL;
55                 static  char    sMemStatsFileName[32]           = "memstats.txt";
56         #endif  // end of if MEMSTATS
57         
58 #else   // no memstats on pc
59         #define MEMSTATS 0
60 #endif
61
62 #define FULL_MEM_CHECKING 1
63
64 #if defined(FULL_MEM_CHECKING) && !defined(NDEBUG)
65
66 #define CHECKSIZE 16
67 #define CHECKBYTE 0xFC
68
69 #define MAX_INDEX 10000
70
71 static unsigned int MallocBase[MAX_INDEX];
72 static unsigned int MallocSize[MAX_INDEX];
73 static unsigned int MallocRealSize[MAX_INDEX];
74 static unsigned char Present[MAX_INDEX];
75 static char * Filename[MAX_INDEX];
76 static char * Varname[MAX_INDEX];
77 static int LineNum[MAX_INDEX];
78 static int BytesMalloced = 0;
79
80 static unsigned int SmallestAddress = 0xFFFFFFF;
81 static unsigned int LargestAddress = 0x0;
82
83 int show_mem_info = 1;
84
85 static int free_list[MAX_INDEX];
86
87 static int num_blocks = 0;
88
89 static int Initialized = 0;
90
91 static int LargestIndex = 0;
92
93 int out_of_memory = 0;
94
95 void mem_display_blocks();
96
97 void mem_init()
98 {
99         int i;
100         
101         Initialized = 1;
102
103         for (i=0; i<MAX_INDEX; i++ )
104         {
105                 free_list[i] = i;
106                 MallocBase[i] = 0;
107                 MallocSize[i] = 0;
108                 MallocRealSize[i] = 0;
109                 Present[i] = 0;
110                 Filename[i] = NULL;
111                 Varname[i] = NULL;
112                 LineNum[i] = 0;
113         }
114
115         SmallestAddress = 0xFFFFFFF;
116         LargestAddress = 0x0;
117
118         num_blocks = 0;
119         LargestIndex = 0;
120
121         atexit(mem_display_blocks);
122         
123 #ifdef MACINTOSH
124
125 // need to check for virtual memory since we will need to do some
126 // tricks based on whether it is on or not
127
128         {
129                 int                     mem_type;
130                 THz                             theD2PartionPtr = nil;
131                 unsigned long   thePartitionSize = 0;
132                 
133                 MaxApplZone();
134                 MoreMasters();                  // allocate 240 more master pointers (mainly for snd handles)
135                 MoreMasters();
136                 MoreMasters();
137                 MoreMasters();
138                 virtual_memory_on = 0;
139                 if(Gestalt(gestaltVMAttr, &mem_type) == noErr)
140                         if (mem_type & 0x1)
141                                 virtual_memory_on = 1;
142                                 
143                 #if MEMSTATS
144                         sMemStatsFile = fopen(sMemStatsFileName, "wt");
145         
146                         if (sMemStatsFile != NULL)
147                         {
148                                 sMemStatsFileInitialized = true;
149         
150                                 theD2PartionPtr = ApplicationZone();
151                                 thePartitionSize =  ((unsigned long) theD2PartionPtr->bkLim) - ((unsigned long) theD2PartionPtr);
152                                 fprintf(sMemStatsFile, "\nMemory Stats File Initialized.");
153                                 fprintf(sMemStatsFile, "\nDescent 2 launched in partition of %u bytes.\n",
154                                                 thePartitionSize);
155                         }
156                 #endif  // end of ifdef MEMSTATS
157         }
158
159 #endif  // end of ifdef macintosh
160
161 }
162
163 void PrintInfo( int id )
164 {
165         fprintf( stderr, "\tBlock '%s' created in %s, line %d.\n", Varname[id], Filename[id], LineNum[id] );
166 }
167
168
169 void * mem_malloc( unsigned int size, char * var, char * filename, int line, int fill_zero )
170 {
171         unsigned int base;
172         int i, id;
173         void *ptr;
174         char * pc;
175         int * data;
176
177         if (Initialized==0)
178                 mem_init();
179
180 //      printf("malloc: %d %s %d\n", size, filename, line);
181
182 #if MEMSTATS
183         {
184                 unsigned long   theFreeMem = 0;
185         
186                 if (sMemStatsFileInitialized)
187                 {
188                         theFreeMem = FreeMem();
189                 
190                         fprintf(sMemStatsFile,
191                                         "\n%9u bytes free before attempting: MALLOC %9u bytes.",
192                                         theFreeMem,
193                                         size);
194                 }
195         }
196 #endif  // end of ifdef memstats
197
198         if ( num_blocks >= MAX_INDEX )  {
199                 fprintf( stderr,"\nMEM_OUT_OF_SLOTS: Not enough space in mem.c to hold all the mallocs.\n" );           
200                 fprintf( stderr, "\tBlock '%s' created in %s, line %d.\n", var, filename, line );
201                 Error( "MEM_OUT_OF_SLOTS" );
202         }
203
204         id = free_list[ num_blocks++ ];
205
206         if (id > LargestIndex ) LargestIndex = id;
207
208         if (id==-1)
209         {
210                 fprintf( stderr,"\nMEM_OUT_OF_SLOTS: Not enough space in mem.c to hold all the mallocs.\n" );           
211                 fprintf( stderr, "\tBlock '%s' created in %s, line %d.\n", Varname[id], Filename[id], LineNum[id] );
212                 Error( "MEM_OUT_OF_SLOTS" );
213         }
214
215 #ifndef MACINTOSH
216         ptr = malloc( size+CHECKSIZE );
217 #else
218         ptr = (void *)NewPtrClear( size+CHECKSIZE );
219 #endif
220
221         /*
222         for (j=0; j<=LargestIndex; j++ )
223         {
224                 if (Present[j] && MallocBase[j] == (unsigned int)ptr )
225                 {
226                         fprintf( stderr,"\nMEM_SPACE_USED: Malloc returned a block that is already marked as preset.\n" );
227                         fprintf( stderr, "\tBlock '%s' created in %s, line %d.\n", Varname[id], Filename[id], Line[id] );
228                         Warning( "MEM_SPACE_USED" );
229                         Int3();
230                         }
231         }
232         */
233
234         if (ptr==NULL)
235         {
236                 out_of_memory = 1;
237                 fprintf( stderr, "\nMEM_OUT_OF_MEMORY: Malloc returned NULL\n" );
238                 fprintf( stderr, "\tBlock '%s' created in %s, line %d.\n", Varname[id], Filename[id], LineNum[id] );
239                 Error( "MEM_OUT_OF_MEMORY" );
240         }
241
242         base = (unsigned int)ptr;
243         if ( base < SmallestAddress ) SmallestAddress = base;
244         if ( (base+size) > LargestAddress ) LargestAddress = base+size;
245
246         MallocBase[id] = (unsigned int)ptr;
247         data = (ssize_t *)((ssize_t)MallocBase[id]-4);
248         MallocRealSize[id] = *data;
249         MallocSize[id] = size;
250         Varname[id] = var;
251         Filename[id] = filename;
252         LineNum[id] = line;
253         Present[id]    = 1;
254
255         pc = (char *)ptr;
256
257         BytesMalloced += size;
258
259         for (i=0; i<CHECKSIZE; i++ )
260                 pc[size+i] = CHECKBYTE;
261
262         if (fill_zero)
263                 memset( ptr, 0, size );
264
265         return ptr;
266
267 }
268
269 int mem_find_id( void * buffer )
270 {
271         int i;
272
273         for (i=0; i<=LargestIndex; i++ )
274                 if (Present[i]==1)
275                         if (MallocBase[i] == (unsigned int)buffer )
276                                 return i;
277
278         // Didn't find id.
279         return -1;
280 }
281
282 int mem_check_integrity( int block_number )
283 {
284 #ifdef CHECK_DWORD_BELOW
285         int * data;
286 #endif
287         int i, ErrorCount;
288         ubyte * CheckData;
289
290         CheckData = (char *)(MallocBase[block_number] + MallocSize[block_number]);
291
292 #ifdef CHECK_DWORD_BELOW
293         data = (int *)((int)MallocBase[block_number]-4);
294
295         if ( *data != MallocRealSize[block_number] )    {
296                 fprintf( stderr, "\nMEM_BAD_LENGTH: The length field of an allocated block was overwritten.\n" );
297                 PrintInfo( block_number );
298                 //Int3();
299                 *data = MallocRealSize[block_number];
300         }
301 #endif
302         ErrorCount = 0;
303                         
304         for (i=0; i<CHECKSIZE; i++ )
305                 if (CheckData[i] != CHECKBYTE ) {
306                         ErrorCount++;
307                         fprintf( stderr, "OA: %p ", &CheckData[i] );
308                 }
309
310         if (ErrorCount &&  (!out_of_memory))    {
311                 fprintf( stderr, "\nMEM_OVERWRITE: Memory after the end of allocated block overwritten.\n" );
312                 PrintInfo( block_number );
313                 fprintf( stderr, "\t%d/%d check bytes were overwritten.\n", ErrorCount, CHECKSIZE );
314                 Int3();
315         }
316
317         return ErrorCount;
318
319 }
320
321 void mem_free( void * buffer )
322 {
323         int id;
324
325         if (Initialized==0)
326                 mem_init();
327
328 #if MEMSTATS
329         {
330                 unsigned long   theFreeMem = 0;
331         
332                 if (sMemStatsFileInitialized)
333                 {
334                         theFreeMem = FreeMem();
335                 
336                         fprintf(sMemStatsFile,
337                                         "\n%9u bytes free before attempting: FREE", theFreeMem);
338                 }
339         }
340 #endif  // end of ifdef memstats
341
342         if (buffer==NULL  &&  (!out_of_memory))
343         {
344                 fprintf( stderr, "\nMEM_FREE_NULL: An attempt was made to free the null pointer.\n" );
345                 Warning( "MEM: Freeing the NULL pointer!" );
346                 Int3();
347                 return;
348         }
349
350         id = mem_find_id( buffer );
351
352         if (id==-1 &&  (!out_of_memory))
353         {
354                 fprintf( stderr, "\nMEM_FREE_NOMALLOC: An attempt was made to free a ptr that wasn't\nallocated with mem.h included.\n" );
355                 Warning( "MEM: Freeing a non-malloced pointer!" );
356                 Int3();
357                 return;
358         }
359         
360         mem_check_integrity( id );
361         
362         BytesMalloced -= MallocSize[id];
363
364 #ifndef MACINTOSH
365         free( buffer );
366 #else
367         DisposePtr( (Ptr)buffer );
368 #endif
369         
370         
371         Present[id] = 0;
372         MallocBase[id] = 0;
373         MallocSize[id] = 0;
374
375         free_list[ --num_blocks ] = id;
376 }
377
378 void mem_display_blocks()
379 {
380         int i, numleft;
381
382         if (Initialized==0) return;
383         
384 #if MEMSTATS
385         {       
386                 if (sMemStatsFileInitialized)
387                 {
388                         unsigned long   theFreeMem = 0;
389
390                         theFreeMem = FreeMem();
391                 
392                         fprintf(sMemStatsFile,
393                                         "\n%9u bytes free before closing MEMSTATS file.", theFreeMem);
394                         fprintf(sMemStatsFile, "\nMemory Stats File Closed.");
395                         fclose(sMemStatsFile);
396                 }
397         }
398 #endif  // end of ifdef memstats
399
400         numleft = 0;
401         for (i=0; i<=LargestIndex; i++ )
402         {
403                 if (Present[i]==1 &&  (!out_of_memory))
404                 {
405                         numleft++;
406                         if (show_mem_info)      {
407                                 fprintf( stderr, "\nMEM_LEAKAGE: Memory block has not been freed.\n" );
408                                 PrintInfo( i );
409                         }
410                         mem_free( (void *)MallocBase[i] );
411                 }
412         }
413
414         if (numleft &&  (!out_of_memory))
415         {
416                 Warning( "MEM: %d blocks were left allocated!", numleft );
417         }
418
419         if (show_mem_info)      {
420                 fprintf( stderr, "\n\nMEMORY USAGE:\n" );
421                 fprintf( stderr, "  %6u Kbytes dynamic data\n", (LargestAddress-SmallestAddress+512)/1024 );
422                 fprintf( stderr, "  %6u Kbytes code/static data.\n", (SmallestAddress-(4*1024*1024)+512)/1024 );
423                 fprintf( stderr, "  ---------------------------\n" );
424                 fprintf( stderr, "  %6u Kbytes required.\n\n",  (LargestAddress-(4*1024*1024)+512)/1024 );
425         }
426 }
427
428 void mem_validate_heap()
429 {
430         int i;
431         
432         for (i=0; i<LargestIndex; i++  )
433                 if (Present[i]==1 )
434                         mem_check_integrity( i );
435 }
436
437 void mem_print_all()
438 {
439         FILE * ef;
440         int i, size = 0;
441
442         ef = fopen( "DESCENT.MEM", "wt" );
443         
444         for (i=0; i<LargestIndex; i++  )
445                 if (Present[i]==1 )     {
446                         size += MallocSize[i];
447                         //fprintf( ef, "Var:%s\t File:%s\t Line:%d\t Size:%d Base:%x\n", Varname[i], Filename[i], Line[i], MallocSize[i], MallocBase[i] );
448                         fprintf( ef, "%12d bytes in %s declared in %s, line %d\n", MallocSize[i], Varname[i], Filename[i], LineNum[i]  );
449                 }
450         fprintf( ef, "%d bytes (%d Kbytes) allocated.\n", size, size/1024 ); 
451         fclose(ef);
452 }
453
454 #else
455
456 static int Initialized = 0;
457 static unsigned int SmallestAddress = 0xFFFFFFF;
458 static unsigned int LargestAddress = 0x0;
459 static unsigned int BytesMalloced = 0;
460
461 void mem_display_blocks();
462
463 #define CHECKSIZE 16
464 #define CHECKBYTE 0xFC
465
466 int show_mem_info = 0;
467
468 void mem_init()
469 {
470         Initialized = 1;
471
472         SmallestAddress = 0xFFFFFFF;
473         LargestAddress = 0x0;
474
475         atexit(mem_display_blocks);
476
477 #ifdef MACINTOSH
478
479         // need to check for virtual memory since we will need to do some
480         // tricks based on whether it is on or not
481         
482         {
483                 int                     mem_type;
484                 THz                             theD2PartionPtr = nil;
485                 unsigned long   thePartitionSize = 0;
486                 
487                 MaxApplZone();
488                 MoreMasters();          // allocate 240 more master pointers (mainly for snd handles)
489                 MoreMasters();
490                 MoreMasters();
491                 MoreMasters();
492                 virtual_memory_on = 0;
493                 if(Gestalt(gestaltVMAttr, &mem_type) == noErr)
494                         if (mem_type & 0x1)
495                                 virtual_memory_on = 1;
496                                 
497                 #if MEMSTATS
498                         sMemStatsFile = fopen(sMemStatsFileName, "wt");
499
500                         if (sMemStatsFile != NULL)
501                         {
502                                 sMemStatsFileInitialized = true;
503
504                                 theD2PartionPtr = ApplicationZone();
505                                 thePartitionSize =  ((unsigned long) theD2PartionPtr->bkLim) - ((unsigned long) theD2PartionPtr);
506                                 fprintf(sMemStatsFile, "\nMemory Stats File Initialized.");
507                                 fprintf(sMemStatsFile, "\nDescent 2 launched in partition of %u bytes.\n",
508                                                 thePartitionSize);
509                         }
510                 #endif  // end of ifdef memstats
511         }
512         
513 #endif  // end of ifdef macintosh
514
515 }
516
517 void * mem_malloc( unsigned int size, char * var, char * filename, int line, int fill_zero )
518 {
519         unsigned int base;
520         void *ptr;
521         int * psize;
522
523         if (Initialized==0)
524                 mem_init();
525
526 #if MEMSTATS
527         {
528                 unsigned long   theFreeMem = 0;
529         
530                 if (sMemStatsFileInitialized)
531                 {
532                         theFreeMem = FreeMem();
533                 
534                         fprintf(sMemStatsFile,
535                                         "\n%9u bytes free before attempting: MALLOC %9u bytes.",
536                                         theFreeMem,
537                                         size);
538                 }
539         }
540 #endif  // end of ifdef memstats
541
542         if (size==0)    {
543                 fprintf( stderr, "\nMEM_MALLOC_ZERO: Attempting to malloc 0 bytes.\n" );
544                 fprintf( stderr, "\tVar %s, file %s, line %d.\n", var, filename, line );
545                 Error( "MEM_MALLOC_ZERO" );
546                 Int3();
547         }
548
549 #ifndef MACINTOSH
550         ptr = malloc( size + CHECKSIZE );
551 #else
552         ptr = (void *)NewPtrClear( size+CHECKSIZE );
553 #endif
554
555         if (ptr==NULL)  {
556                 fprintf( stderr, "\nMEM_OUT_OF_MEMORY: Malloc returned NULL\n" );
557                 fprintf( stderr, "\tVar %s, file %s, line %d.\n", var, filename, line );
558                 Error( "MEM_OUT_OF_MEMORY" );
559                 Int3();
560         }
561
562         base = (unsigned int)ptr;
563         if ( base < SmallestAddress ) SmallestAddress = base;
564         if ( (base+size) > LargestAddress ) LargestAddress = base+size;
565
566
567         psize = (int *)ptr;
568         psize--;
569         BytesMalloced += *psize;
570
571         if (fill_zero)
572                 memset( ptr, 0, size );
573
574         return ptr;
575 }
576
577 void mem_free( void * buffer )
578 {
579         int * psize = (int *)buffer;
580         psize--;
581
582         if (Initialized==0)
583                 mem_init();
584
585 #if MEMSTATS
586         {
587                 unsigned long   theFreeMem = 0;
588         
589                 if (sMemStatsFileInitialized)
590                 {
591                         theFreeMem = FreeMem();
592                 
593                         fprintf(sMemStatsFile,
594                                         "\n%9u bytes free before attempting: FREE", theFreeMem);
595                 }
596         }
597 #endif  // end of ifdef memstats
598
599         if (buffer==NULL)       {
600                 fprintf( stderr, "\nMEM_FREE_NULL: An attempt was made to free the null pointer.\n" );
601                 Warning( "MEM: Freeing the NULL pointer!" );
602                 Int3();
603                 return;
604         }
605
606         BytesMalloced -= *psize;
607
608 #ifndef MACINTOSH
609         free( buffer );
610 #else
611         DisposePtr( (Ptr)buffer );
612 #endif
613 }
614
615 void mem_display_blocks()
616 {
617         if (Initialized==0) return;
618
619 #if MEMSTATS
620         {       
621                 if (sMemStatsFileInitialized)
622                 {
623                         unsigned long   theFreeMem = 0;
624
625                         theFreeMem = FreeMem();
626                 
627                         fprintf(sMemStatsFile,
628                                         "\n%9u bytes free before closing MEMSTATS file.", theFreeMem);
629                         fprintf(sMemStatsFile, "\nMemory Stats File Closed.");
630                         fclose(sMemStatsFile);
631                 }
632         }
633 #endif  // end of ifdef memstats
634
635         if (BytesMalloced != 0 )        {
636                 fprintf( stderr, "\nMEM_LEAKAGE: %d bytes of memory have not been freed.\n", BytesMalloced );
637         }
638
639         if (show_mem_info)      {
640                 fprintf( stderr, "\n\nMEMORY USAGE:\n" );
641                 fprintf( stderr, "  %u Kbytes dynamic data\n", (LargestAddress-SmallestAddress+512)/1024 );
642                 fprintf( stderr, "  %u Kbytes code/static data.\n", (SmallestAddress-(4*1024*1024)+512)/1024 );
643                 fprintf( stderr, "  ---------------------------\n" );
644                 fprintf( stderr, "  %u Kbytes required.\n",     (LargestAddress-(4*1024*1024)+512)/1024 );
645         }
646 }
647
648 void mem_validate_heap()
649 {
650 }
651
652 void mem_print_all()
653 {
654 }
655
656 #endif
657
658
659 #ifdef MACINTOSH
660
661 // routine to try and compact and purge the process manager zone to squeeze
662 // some temporary memory out of it for QT purposes.
663
664 void PurgeTempMem()
665 {
666         OSErr err;
667         Handle tempHandle;
668         THz appZone, processZone;
669         Size heapSize;
670         
671         // compact the system zone to try and squeeze some temporary memory out of it
672         MaxMemSys(&heapSize);
673         
674         // compact the Process Manager zone to get more temporary memory
675         appZone = ApplicationZone();
676         tempHandle = TempNewHandle(10, &err);           // temporary allocation may fail
677         if (!err && (tempHandle != NULL) ) {
678                 processZone = HandleZone(tempHandle);
679                 if ( MemError() || (processZone == NULL) ) {
680                         DisposeHandle(tempHandle);
681                         return;
682                 }
683                 SetZone(processZone);
684                 MaxMem(&heapSize);                              // purge and compact the Process Manager Zone.
685                 SetZone(appZone);
686                 DisposeHandle(tempHandle);
687         }
688 }
689
690 #endif