Annotation of gforth/engine/profile.c, revision 1.14

1.1       anton       1: /* VM profiling support stuff
                      2: 
1.10      anton       3:   Copyright (C) 2001,2002,2003 Free Software Foundation, Inc.
1.1       anton       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
1.14    ! anton       9:   as published by the Free Software Foundation, either version 3
1.1       anton      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
1.14    ! anton      18:   along with this program; if not, see http://www.gnu.org/licenses/.
1.1       anton      19: */
                     20: 
                     21: #include "config.h"
1.7       anton      22: #include "forth.h"
1.1       anton      23: #include <stdlib.h>
                     24: #include <stdio.h>
1.2       anton      25: #include <assert.h>
1.1       anton      26: 
1.2       anton      27: 
1.1       anton      28: /* data structure: simple hash table with external chaining */
                     29: 
                     30: #define HASH_SIZE (1<<20)
                     31: 
                     32: typedef struct block_count {
                     33:   struct block_count *next; /* next in hash table */
                     34:   struct block_count *fallthrough; /* the block that this one falls
                     35:                                        through to without SUPER_END */
                     36:   Xt *ip;
                     37:   long long count;
                     38:   char **insts;
                     39:   size_t ninsts;
                     40: } block_count;
                     41: 
                     42: block_count *blocks[HASH_SIZE];
                     43: 
                     44: #define hash(p) ((((Cell)(p))/sizeof(Xt))&(HASH_SIZE-1))
                     45: 
                     46: block_count *block_lookup(Xt *ip)
                     47: {
                     48:   block_count *b = blocks[hash(ip)];
                     49: 
                     50:   while (b!=NULL && b->ip!=ip)
                     51:     b = b->next;
                     52:   return b;
                     53: }
                     54: 
                     55: /* looks up present elements, inserts absent elements */
                     56: block_count *block_insert(Xt *ip)
                     57: { 
                     58:   block_count *b = block_lookup(ip);
                     59:   block_count *new;
                     60: 
                     61:   if (b != NULL)
                     62:     return b;
                     63:   new = (block_count *)malloc(sizeof(block_count));
                     64:   new->next = blocks[hash(ip)];
                     65:   new->fallthrough = NULL;
                     66:   new->ip = ip;
                     67:   new->count = 0LL;
                     68:   new->insts = malloc(0);
1.2       anton      69:   assert(new->insts != NULL);
1.1       anton      70:   new->ninsts = 0;
                     71:   blocks[hash(ip)] = new;
                     72:   return new;
                     73: }
                     74: 
                     75: void add_inst(block_count *b, char *inst)
                     76: {
1.2       anton      77:   b->insts = realloc(b->insts, (b->ninsts+1) * sizeof(char *));
1.1       anton      78:   b->insts[b->ninsts++] = inst;
                     79: }
                     80: 
                     81: void vm_count_block(Xt *ip)
                     82: {
                     83:   block_insert(ip)->count++;
                     84: }
                     85: 
1.2       anton      86: #ifdef DIRECT_THREADED
1.9       anton      87: #define VM_IS_INST(inst, n) ((inst) == vm_prims[n])
1.2       anton      88: #else
1.9       anton      89: #define VM_IS_INST(inst, n) ((inst) == &(vm_prims[n]))
1.2       anton      90: #endif
1.1       anton      91: 
                     92: void postprocess_block(block_count *b)
                     93: {
                     94:   Xt *ip = b->ip;
                     95:   block_count *next_block;
                     96: 
                     97:   do {
1.13      anton      98: #include "profile.i"
1.1       anton      99:     /* else */
                    100:     {
                    101:       add_inst(b,"unknown");
                    102:       ip++;
                    103:     }
1.5       anton     104:   _endif_:
1.1       anton     105:     next_block = block_lookup(ip);
                    106:   } while (next_block == NULL);
                    107:   /* we fell through, so set fallthrough and update the count */
                    108:   b->fallthrough = next_block;
                    109:   /* also update the counts of all following fallthrough blocks that
                    110:      have already been processed */
                    111:   while (next_block != NULL) {
                    112:     next_block->count += b->count;
                    113:     next_block = next_block->fallthrough;
                    114:   }
                    115: }
                    116: 
                    117: /* Deal with block entry by falling through from non-SUPER_END
                    118:    instructions.  And fill the insts and ninsts fields. */
                    119: void postprocess(void)
                    120: {
                    121:   size_t i;
                    122: 
                    123:   for (i=0; i<HASH_SIZE; i++) {
                    124:     block_count *b = blocks[i];
                    125:     for (; b!=0; b = b->next)
                    126:       postprocess_block(b);
                    127:    }
                    128: }
                    129: 
1.11      anton     130: #if 1
1.6       anton     131: /* full basic blocks only */
1.1       anton     132: void print_block(FILE *file, block_count *b)
                    133: {
1.2       anton     134:   size_t i;
                    135: 
                    136:   fprintf(file,"%14lld\t",b->count);
                    137:   for (i=0; i<b->ninsts; i++)
                    138:     fprintf(file, "%s ", b->insts[i]);
                    139:   putc('\n', file);
1.3       anton     140: }
1.6       anton     141: #elif 0
                    142: /* full basic blocks and all their prefixes */
                    143: void print_block(FILE *file, block_count *b)
                    144: {
                    145:   size_t i,j;
1.3       anton     146: 
1.6       anton     147:   for (j=1; j<=b->ninsts; j++) {
                    148:     fprintf(file,"%14lld\t",b->count);
                    149:     for (i=0; i<j; i++)
                    150:       fprintf(file, "%s ", b->insts[i]);
                    151:     putc('\n', file);
                    152:   }
                    153: }
                    154: #else
                    155: /* all subsequences up to length 12 */
1.3       anton     156: void print_block(FILE *file, block_count *b)
                    157: {
                    158:   size_t i,j,k;
                    159: 
1.11      anton     160:   for (i=1; i<2; i++)
1.4       anton     161:     for (j=0; i+j<=b->ninsts; j++) {
1.3       anton     162:       fprintf(file,"%14lld\t",b->count);
                    163:       for (k=j; k<i+j; k++)
                    164:        fprintf(file, "%s ", b->insts[k]);
                    165:       putc('\n', file);
                    166:     }
1.1       anton     167: }
1.6       anton     168: #endif
1.1       anton     169: 
                    170: void vm_print_profile(FILE *file)
                    171: {
                    172:   size_t i;
                    173: 
                    174:   postprocess();
                    175:   for (i=0; i<HASH_SIZE; i++) {
                    176:     block_count *b = blocks[i];
                    177:     for (; b!=0; b = b->next)
                    178:       print_block(file, b);
                    179:    }
                    180: }

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