File:  [gforth] / gforth / vmgen-ex / profile.c
Revision 1.8: download - view: text, annotated - select for diffs
Mon Dec 31 19:02:25 2007 UTC (11 years, 10 months ago) by anton
Branches: MAIN
CVS tags: v0-7-0, HEAD
updated copyright year after changing license notice

    1: /* VM profiling support stuff
    2: 
    3:   Copyright (C) 2001,2003,2007 Free Software Foundation, Inc.
    4: 
    5:   This file is part of Gforth.
    6: 
    7:   Gforth is free software; you can redistribute it and/or
    8:   modify it under the terms of the GNU General Public License
    9:   as published by the Free Software Foundation, either version 3
   10:   of the License, or (at your option) any later version.
   11: 
   12:   This program is distributed in the hope that it will be useful,
   13:   but WITHOUT ANY WARRANTY; without even the implied warranty of
   14:   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   15:   GNU General Public License for more details.
   16: 
   17:   You should have received a copy of the GNU General Public License
   18:   along with this program; if not, see http://www.gnu.org/licenses/.
   19: */
   20: 
   21: #include <stdlib.h>
   22: #include <stdio.h>
   23: #include <assert.h>
   24: #include "mini.h"
   25: 
   26: /* data structure: simple hash table with external chaining */
   27: 
   28: #define HASH_SIZE (1<<20)
   29: #define hash(p) ((((Cell)(p))/sizeof(Inst))&(HASH_SIZE-1))
   30: 
   31: #ifdef __GNUC__
   32: typedef long long long_long;
   33: #else
   34: typedef long long_long;
   35: #endif
   36: 
   37: typedef struct block_count {
   38:   struct block_count *next; /* next in hash table */
   39:   struct block_count *fallthrough; /* the block that this one falls
   40:                                        through to without SUPER_END */
   41:   Inst *ip;
   42:   long_long count;
   43:   char **insts;
   44:   size_t ninsts;
   45: } block_count;
   46: 
   47: block_count *blocks[HASH_SIZE];
   48: Inst *vmcode_end;
   49: 
   50: block_count *block_lookup(Inst *ip)
   51: {
   52:   block_count *b = blocks[hash(ip)];
   53: 
   54:   while (b!=NULL && b->ip!=ip)
   55:     b = b->next;
   56:   return b;
   57: }
   58: 
   59: /* looks up present elements, inserts absent elements */
   60: block_count *block_insert(Inst *ip)
   61: { 
   62:   block_count *b = block_lookup(ip);
   63:   block_count *new;
   64: 
   65:   if (b != NULL)
   66:     return b;
   67:   new = (block_count *)malloc(sizeof(block_count));
   68:   new->next = blocks[hash(ip)];
   69:   new->fallthrough = NULL;
   70:   new->ip = ip;
   71:   new->count = (long_long)0;
   72:   new->insts = malloc(1);
   73:   assert(new->insts != NULL);
   74:   new->ninsts = 0;
   75:   blocks[hash(ip)] = new;
   76:   return new;
   77: }
   78: 
   79: void add_inst(block_count *b, char *inst)
   80: {
   81:   b->insts = realloc(b->insts, (b->ninsts+1) * sizeof(char *));
   82:   b->insts[b->ninsts++] = inst;
   83: }
   84: 
   85: void vm_count_block(Inst *ip)
   86: {
   87:   block_insert(ip)->count++;
   88: }
   89: 
   90: void postprocess_block(block_count *b)
   91: {
   92:   Inst *ip = b->ip;
   93:   block_count *next_block=NULL;
   94: 
   95:   while (next_block == NULL && ip<vmcode_end) {
   96: #include "mini-profile.i"
   97:     /* else */
   98:     {
   99:       add_inst(b,"unknown");
  100:       ip++;
  101:     }
  102:   _endif_:
  103:     next_block = block_lookup(ip);
  104:   }
  105:   /* we fell through, so set fallthrough and update the count */
  106:   b->fallthrough = next_block;
  107:   /* also update the counts of all following fallthrough blocks that
  108:      have already been processed */
  109:   while (next_block != NULL) {
  110:     next_block->count += b->count;
  111:     next_block = next_block->fallthrough;
  112:   }
  113: }
  114: 
  115: /* Deal with block entry by falling through from non-SUPER_END
  116:    instructions.  And fill the insts and ninsts fields. */
  117: void postprocess(void)
  118: {
  119:   size_t i;
  120: 
  121:   for (i=0; i<HASH_SIZE; i++) {
  122:     block_count *b = blocks[i];
  123:     for (; b!=0; b = b->next)
  124:       postprocess_block(b);
  125:    }
  126: }
  127: 
  128: #if 0
  129: void print_block(FILE *file, block_count *b)
  130: {
  131:   size_t i;
  132: 
  133:   fprintf(file,"%14lld\t",b->count);
  134:   for (i=0; i<b->ninsts; i++)
  135:     fprintf(file, "%s ", b->insts[i]);
  136:   putc('\n', file);
  137: }
  138: #endif
  139: 
  140: void print_block(FILE *file, block_count *b)
  141: {
  142:   size_t i,j,k;
  143: 
  144:   for (i=2; i<12; i++)
  145:     for (j=0; i+j<=b->ninsts; j++) {
  146:       fprintf(file,"%14lld\t",b->count);
  147:       for (k=j; k<i+j; k++)
  148: 	fprintf(file, "%s ", b->insts[k]);
  149:       putc('\n', file);
  150:     }
  151: }
  152: 
  153: void vm_print_profile(FILE *file)
  154: {
  155:   size_t i;
  156: 
  157:   postprocess();
  158:   for (i=0; i<HASH_SIZE; i++) {
  159:     block_count *b = blocks[i];
  160:     for (; b!=0; b = b->next)
  161:       print_block(file, b);
  162:    }
  163: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>