home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 mARCH / PCWK3A99.iso / Linux / DDD331 / DDD-3_1_.000 / DDD-3_1_ / ddd-3.1.1 / ddd / MemCheck.h < prev    next >
C/C++ Source or Header  |  1998-09-21  |  5KB  |  174 lines
  1. // $Id: MemCheck.h,v 1.7 1998/09/21 19:12:57 zeller Exp $ -*- C++ -*-
  2. // Memory Checker
  3.  
  4. // Copyright (C) 1995 Technische Universitaet Braunschweig, Germany.
  5. // Written by Andreas Zeller <zeller@ips.cs.tu-bs.de>.
  6. // 
  7. // This file is part of the ICE Library.
  8. // 
  9. // The ICE Library is free software; you can redistribute it and/or
  10. // modify it under the terms of the GNU Library General Public
  11. // License as published by the Free Software Foundation; either
  12. // version 2 of the License, or (at your option) any later version.
  13. // 
  14. // The ICE Library is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17. // See the GNU Library General Public License for more details.
  18. // 
  19. // You should have received a copy of the GNU Library General Public
  20. // License along with the ICE Library -- see the file COPYING.LIB.
  21. // If not, write to the Free Software Foundation, Inc.,
  22. // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23. // 
  24. // ICE is the incremental configuration environment.
  25. // For details, see the ICE World-Wide-Web page, 
  26. // `http://www.cs.tu-bs.de/softech/ice/',
  27. // or send a mail to the ICE developers <ice@ips.cs.tu-bs.de>.
  28.  
  29. #ifndef _ICE_MemCheck_h
  30. #define _ICE_MemCheck_h
  31.  
  32. #ifdef __GNUG__
  33. #pragma interface
  34. #endif
  35.  
  36. #include <iostream.h>
  37. #include "strclass.h"
  38.  
  39. // Include this file in any module you wish to debug.
  40. // Include "MemCheckD.h" in your main module to enable memory checking.
  41.  
  42. // MemCheckHeader -- for internal use only
  43.  
  44. const unsigned MAGIC = 3917580; // Marks start of block
  45. const char WIPEOUT   = '@';    // Filled in free()'d blocks
  46. typedef double Align;
  47.     
  48. class MemCheckHeader {
  49.     friend class MemCheck;
  50.  
  51. private:
  52.     union {
  53.     struct Block {
  54.         MemCheckHeader *ptr;    // Next block
  55.         unsigned size;        // Actual size of this block
  56.         unsigned magic;        // Magic number (debugging only)
  57.         unsigned requested;        // Requested size (debugging only)
  58.         unsigned tic;        // ID of this block (debugging only)
  59.         unsigned dummy;        // Required by gcc-2.5.5 (otherwise crash)
  60.     } s;
  61.     Align x;
  62.     };
  63.  
  64. public:
  65.     void init()
  66.     {
  67.     // build a single circular list
  68.     s.ptr       = this;
  69.     s.size      = 0;
  70.     s.magic     = MAGIC;
  71.     s.requested = 0;
  72.     s.tic       = 0;
  73.     }
  74. };
  75.  
  76.  
  77. // The MemCheck class is just a prefix for common operations.
  78. // These are usually enabled with the new/delete operators (see below).
  79. // 
  80. // Other common usages include:
  81. // MemCheck::map(cout);   // show all allocated blocks
  82. // MemCheck::log = 1;     // log all new/delete operations
  83.  
  84. class MemCheck {
  85.     friend class MemChecker;
  86.     
  87. private:
  88.     static MemCheckHeader *freep;    // Free list
  89.     static MemCheckHeader *allocp;    // Alloc list
  90.  
  91.     static MemCheckHeader freebase;    // Start of free list
  92.     static MemCheckHeader allocbase;    // Start of alloc list
  93.  
  94.     static unsigned tics;            // Next available ID
  95.     static unsigned freeBytes;        // Sum of bytes in free list
  96.     static unsigned allocBytes;            // Sum of bytes in alloc list
  97.  
  98.     static MemCheckHeader *morecore(unsigned nunits);
  99.     static void _free(MemCheckHeader *bp);
  100.     static void validate(MemCheckHeader *bp, char *src);
  101.  
  102.     // initialize
  103.     static void init();
  104.  
  105. public:
  106.     // Allocate nbytes of memory
  107.     static void *alloc(unsigned nbytes);
  108.  
  109.     // Free block at p
  110.     static void free(void *p);
  111.  
  112.     // Issue a map of all allocated blocks (starting with block #start)
  113.     static void map(ostream& os, unsigned start = 0, char *prefix = "");
  114.  
  115.     // Return current block number
  116.     static unsigned tic() { return tics; }
  117.  
  118.     // Return current memory usage
  119.     static unsigned in_free()  { return freeBytes; }
  120.     static unsigned in_alloc() { return allocBytes; }
  121.  
  122.     // If non-zero, log all alloc/free operations
  123.     static int log;
  124.  
  125.     // If non-zero, wipeout memory after being free'd
  126.     static int wipeout_free;
  127.  
  128.     // validate
  129.     static int OK();
  130. };
  131.  
  132.  
  133. // A MemChecker object may be used to show all allocations that occured
  134. // during its lifetime. For instance,
  135. //
  136. // {
  137. //     MemChecker m("f()");
  138. //     f();
  139. // } // all allocations done by f will be reported here
  140.  
  141. class MemChecker {
  142. private:
  143.     string prefix;
  144.     unsigned start;
  145.  
  146. public:
  147.     MemChecker(char *pfx = ""):
  148.         prefix(pfx), start(MemCheck::tic())
  149.     {}
  150.  
  151.     ~MemChecker()
  152.     {
  153.     MemCheck::map(clog, start, prefix);
  154.     }
  155. };
  156.  
  157. // Setup if required
  158. inline void MemCheck::init()
  159. {
  160.     if (freebase.s.magic != MAGIC)
  161.     {
  162.     freebase.init();
  163.     allocbase.init();
  164.     freep      = &freebase;
  165.     allocp     = &allocbase;
  166.     freeBytes  = 0;
  167.     allocBytes = 0;
  168.     tics       = 1;
  169.     }
  170. }
  171.  
  172. #endif // _ICE_MemCheck_h
  173. // DON'T ADD ANYTHING BEHIND THIS #endif
  174.