--- /dev/null
+/* SCCS Id: @(#)heaputil.c 3.3 94/07/17 */
+/* Copyright (c) Michael Allison, Toronto, 1994 */
+/* NetHack may be freely redistributed. See license for details. */
+
+/*
+ * We want to know the following information:
+ *
+ * 1. allocations that are made but never freed, and where they occur.
+ * 2. attempts to free unallocated blocks.
+ * 3. the peak amount of heap space allocated during the program.
+ *
+ */
+
+#include "config.h"
+#include <ctype.h>
+
+#ifdef MICRO
+#include <stdlib.h>
+#endif
+
+#ifdef MICRO /* see src/alloc.c */
+# define MONITOR_HEAP_FMT
+#endif
+
+#ifdef MONITOR_HEAP_FMT
+# define PTR_FMT "%p"
+# define PTR_TYP genericptr_t /* (void *) */
+#else
+# define PTR_FMT "%lx"
+# define PTR_TYP unsigned long
+#endif
+
+extern genericptr_t FDECL(malloc,(size_t));
+#ifdef free
+#undef free
+#endif
+extern void FDECL(free,(genericptr_t));
+
+#define quit() exit(EXIT_FAILURE)
+
+static void NDECL(out_of_memory);
+static void FDECL(doline,(char *));
+static void FDECL(chain,(char *));
+static void FDECL(unchain,(char *));
+static void NDECL(walkblocks);
+static struct memblock *FDECL(findprev,(PTR_TYP));
+static void FDECL(btempl,(char *));
+
+#ifdef VMS
+static FILE *vms_fopen(name, mode) const char *name, *mode;
+{
+ return fopen(name, mode, "mbc=64", "shr=nil");
+}
+# define fopen(f,m) vms_fopen(f,m)
+#endif
+
+
+#define DEFAULTNAME "heapuse.log"
+#define MAXERR 4
+#ifndef _MAX_PATH
+#define _MAX_PATH 120
+#endif
+
+struct memblock {
+ struct memblock *next;
+ long sequence, bsize;
+ PTR_TYP address;
+ char fileinfo[5 + _MAX_PATH + 1];
+};
+
+/* a cheap way to try to split addresses into two categories */
+#define CHAIN_SELECT(X) (((unsigned long)X >> 10) & 1)
+
+#define OPERATION 0 /* first character; + for alloc, - for free */
+#define BLKSIZE 1 /* block size; 5 digits starting at 2nd char */
+#define ADDRESS 7 /* sizeof "+12345 " - sizeof "" */
+#define FILEINFO fileinfo_offset
+
+#define terminate_fields(a) \
+ a[ADDRESS - 1] = a[FILEINFO - 1] = '\0'
+#define zero_fields(a) \
+ a[OPERATION] = a[BLKSIZE] = a[ADDRESS] = a[FILEINFO] = '\0'
+
+static int fileinfo_offset;
+static struct memblock *firstblock[2] = {0,0}, *blkcache = 0;
+static long peakmem;
+static long curmem;
+static long totaldynmem;
+static long lineno;
+static FILE *infile;
+static char line[255];
+static const char *infilenm;
+static int errcount;
+static int have_template;
+
+int main(argc, argv)
+int argc;
+char *argv[];
+{
+ infilenm = (argc < 2) ? getenv("NH_HEAPLOG") : argv[1];
+ if (!infilenm || !*infilenm) infilenm = DEFAULTNAME;
+
+ infile = fopen(infilenm,"r");
+ if (!infile) {
+ printf("%s not found or unavailable\n",infilenm);
+ quit();
+ }
+
+ while (fgets(line, sizeof line, infile)) {
+ ++lineno;
+ doline(line);
+ zero_fields(line);
+ }
+
+ fclose(infile);
+ walkblocks();
+ printf("Peak heap usage was %ld bytes.\n",peakmem);
+ printf("Total heap memory allocations was %ld bytes.\n", totaldynmem);
+ exit(EXIT_SUCCESS);
+ /*NOTREACHED*/
+ return 0;
+}
+
+static void out_of_memory()
+{
+ printf("heaputil: out of memory at line %ld of %s\n",
+ lineno, infilenm);
+ quit();
+}
+
+/*
+ * Sample:
++ 43 6852:0A0A 568 ..\win\tty\wintty.c
+- 6852:0A0A 1291 ..\win\tty\wintty.c
+ * Description:
+^ size address line file ^: + => alloc, - => free
+ *
+ * Note: In environments other than MSDOS 16 bit segmented ones,
+ * the address field will just be a single string of digits.
+ *
+ * Parsing:
+ * The operation flag and allocation size are in fixed columns;
+ * the address starts at a fixed offset and its width is expected
+ * to be the same for every entry, but that width may vary from
+ * platform to platform; the line number is a right-justified
+ * 4-digit number separated from the address by one space and
+ * followed after a space by the filename; line+file+newline
+ * are treated as a single unit throughout.
+ *
+ * Only the first line obtained from the file will be scanned
+ * to determine the offsets of the various fields: operation,
+ * size, address, and fileinfo. Subsequent lines are processed
+ * by depositing NUL at the appropriate offsets in the string.
+ * This method seems to be quite fast and avoids complicated
+ * parsing.
+ */
+
+static void doline(line)
+char *line;
+{
+ if (!have_template) btempl(line);
+ if (line[OPERATION] == '+') chain(line);
+ else if (line[OPERATION] == '-') unchain(line);
+ else {
+ printf("%6ld: invalid operation, badly formatted line.\n",
+ lineno);
+ printf(" -> %s",line);
+ if (++errcount > MAXERR) {
+ printf("Giving up on this file, its not right.\n");
+ quit();
+ }
+ }
+}
+
+static void chain(line)
+char *line;
+{
+ struct memblock *block;
+ int i;
+
+ terminate_fields(line);
+ if (blkcache) {
+ block = blkcache;
+ blkcache = block->next;
+ } else {
+ block = (struct memblock *)malloc(sizeof(struct memblock));
+ if (!block) out_of_memory();
+ }
+
+ block->sequence = lineno;
+ block->bsize = atol(&line[BLKSIZE]);
+ (void)sscanf(&line[ADDRESS], PTR_FMT, &block->address);
+ Strcpy(block->fileinfo, &line[FILEINFO]);
+ if (block->address == 0) {
+ printf("%6ld: allocation of %ld bytes returned null pointer, %s",
+ block->sequence, block->bsize, block->fileinfo);
+ return;
+ }
+
+ i = CHAIN_SELECT(block->address);
+ block->next = firstblock[i];
+ firstblock[i] = block;
+
+ curmem += block->bsize;
+ if (curmem > peakmem) peakmem = curmem;
+ totaldynmem += block->bsize;
+}
+
+static void unchain(line)
+char *line;
+{
+ struct memblock *block;
+ struct memblock *rmblock = (struct memblock *)0;
+ PTR_TYP address;
+ int i;
+
+ terminate_fields(line);
+ (void)sscanf(&line[ADDRESS], PTR_FMT, &address);
+ i = CHAIN_SELECT(address);
+
+ if (address == 0) {
+ printf("%6ld: attempt to free null pointer, %s",
+ lineno, &line[FILEINFO]);
+ return;
+ } else if (firstblock[i]) {
+ /* special case, first one so no prev available */
+ if (address == firstblock[i]->address) {
+ rmblock = firstblock[i];
+ firstblock[i] = rmblock->next;
+ } else {
+ block = findprev(address);
+ if (block) {
+ rmblock = block->next;
+ block->next = rmblock->next;
+ }
+ }
+ }
+
+ if (!rmblock) {
+ printf("%6ld: attempt to free unallocated block, %s",
+ lineno, &line[FILEINFO]);
+ } else {
+ curmem -= rmblock->bsize;
+ if (curmem < 0) {
+ printf("%6ld: impossible, current memory use negative, %s",
+ lineno, &line[FILEINFO]);
+ }
+ rmblock->next = blkcache;
+ blkcache = rmblock;
+ }
+}
+
+static struct memblock *
+findprev(maddress)
+PTR_TYP maddress;
+{
+ struct memblock *tmpblk, *nextblk;
+
+ tmpblk = firstblock[CHAIN_SELECT(maddress)];
+ while (tmpblk) {
+ nextblk = tmpblk->next;
+ if (nextblk) {
+ if (maddress == nextblk->address) return tmpblk;
+ }
+ tmpblk = nextblk;
+ }
+ return (struct memblock *)0;
+}
+
+static void walkblocks()
+{
+ struct memblock *tmpblk, *nextblk;
+ int i, k;
+ long unfreedmem = 0L;
+
+ /* make a sorted list from all the chains; expected to be short */
+ tmpblk = 0;
+ do {
+ k = 0;
+ for (i = 1; i < SIZE(firstblock); i++)
+ if (!firstblock[k] || (firstblock[i] &&
+ firstblock[i]->sequence > firstblock[k]->sequence))
+ k = i;
+ nextblk = firstblock[k];
+ if (nextblk) {
+ firstblock[k] = nextblk->next;
+ nextblk->next = tmpblk;
+ tmpblk = nextblk;
+ }
+ } while (nextblk);
+
+ while (tmpblk) {
+ printf("%6ld: not freed: %5ld bytes, %s",
+ tmpblk->sequence, tmpblk->bsize, tmpblk->fileinfo);
+ unfreedmem += tmpblk->bsize;
+ nextblk = tmpblk->next;
+ free((genericptr_t)tmpblk);
+ tmpblk = nextblk;
+ }
+
+ printf("Total of %ld bytes not freed before exit.\n", unfreedmem);
+
+ /* free memblock cache */
+ while (blkcache) {
+ tmpblk = blkcache;
+ blkcache = tmpblk->next;
+ free((genericptr_t)tmpblk);
+ }
+}
+
+static void btempl(line)
+char *line;
+{
+ char *p;
+
+ p = &line[ADDRESS - 1];
+ while (isspace(*p)) ++p;
+ while (*p && *p != ' ' && *p != '\n') ++p;
+ if (*p == ' ') ++p; /* skip first space */
+ fileinfo_offset = p - line;
+
+ ++have_template;
+}
+
+/*heaputil.c*/
projects / nethack / commitdiff