Return to trace5.c CVS log

Up to [Research Unix] / researchv8dc / cmd / trace

Annotation of researchv8dc/cmd/trace/trace5.c, revision 1.1.1.1

1.1       root        1: #include "stdio.h"
                      2: #include "trace.h"
                      3: #include "trace.d"
                      4: 
                      5:  extern struct QUEUE **head, **tail;
                      6:  extern int *qsize;
                      7:  extern int nrqs, level, maxreached;
                      8:  extern double iseen, ireseen, zapper;
                      9:  char *Realloc(), *Emalloc(), *Smalloc(), *emalloc();
                     10: 
                     11:  struct HTABLE {
                     12:        struct STATE **index;           /* index [h] [ibound]    */
                     13:        short ibound;                   /* nr of available slots */
                     14:        short nr;                       /* nr of occupied  slots */
                     15:  } oldstates[NOTOOBIG+1];              /* index of hash values  */
                     16: 
                     17:  int hbound = 0, hlast = 0;
                     18:  short igrowth  = 8;
                     19: 
                     20: growindex(h)
                     21: { int nsz = (int) oldstates[h].ibound + igrowth;
                     22: 
                     23:        if (nsz == igrowth)
                     24:                oldstates[h].index = (struct STATE **)
                     25:                        Emalloc(nsz * sizeof(struct STATE *));
                     26:        else
                     27:                oldstates[h].index = (struct STATE **)
                     28:                        Realloc(oldstates[h].index, nsz * sizeof(struct STATE *));
                     29:        
                     30:        oldstates[h].ibound = (short) nsz;
                     31: 
                     32: }
                     33: 
                     34: initable()
                     35: { register int i;
                     36: 
                     37:        for (i = 0; i < NOTOOBIG+1; i++)
                     38:        {       oldstates[i].nr = 0;
                     39:                oldstates[i].ibound = 0;
                     40:        }
                     41:        hbound = NOTOOBIG+1;
                     42: }
                     43: 
                     44: insert(h, pnt)         /* enter state pointer into the table at hash value h */
                     45:        struct STATE *pnt;
                     46: { short cin;
                     47: 
                     48:        if (h >= hbound)
                     49:        {       fprintf(stderr, "h %d, hbound %d, NOTOOBIG %d\n",h,hbound,NOTOOBIG);
                     50:                whoops("cannot happen - insert");
                     51:        }
                     52:        cin = oldstates[h].nr++;
                     53: 
                     54:        iseen += (long) 1;
                     55: 
                     56:        if (cin >= oldstates[h].ibound)
                     57:                growindex(h);
                     58: 
                     59:        oldstates[h].index[cin] = pnt;
                     60: }
                     61: 
                     62: mark(stt, vis)
                     63:        struct STATE *stt;
                     64:        struct VISIT *vis;
                     65: { int h = stt->hash;
                     66: 
                     67:        if (h >= hbound)
                     68:                whoops("cannot happen - mark");
                     69:        efree(vis->prop.h);
                     70:        vis->analyzed = 1;
                     71: 
                     72: }
                     73: 
                     74: relink(vis)
                     75:        struct VISIT *vis;
                     76: { struct CONTS *inqtable();
                     77:   register int i, j, k;
                     78: 
                     79:        for (i = j = 0; i < nrqs ; i++)
                     80:                if (qsize[i] > 0)
                     81:                        j++;
                     82: 
                     83:        vis->howmany = (char) j;
                     84: 
                     85:        if (zapper == 0)        /* grow without bound */
                     86:                vis->prop.c = (struct CONTS **)
                     87:                        Smalloc(j * sizeof(struct CONTS *));
                     88:        else
                     89:                vis->prop.c = (struct CONTS **)
                     90:                        emalloc(j * sizeof(struct CONTS *));
                     91: 
                     92:        for (i = k = 0; i < nrqs; i++)
                     93:        {       if ((j = qsize[i]) == 0)
                     94:                        continue;
                     95: 
                     96:                vis->prop.c[k++] = inqtable(i);
                     97:        }
                     98: }
                     99: 
                    100: member(h) { return (h < hbound) ? oldstates[h].nr : 0; }
                    101: 
                    102: struct STATE *
                    103: giveme(h, n)
                    104: { int m = n - 1;
                    105:        if (h >= hbound || oldstates[h].nr <= m || oldstates[h].index[m] == NULL)
                    106:                whoops("cannot happen - giveme");
                    107: 
                    108:        return oldstates[h].index[m];
                    109: }
                    110: 
                    111: struct VISIT *
                    112: findany(avoid)
                    113:        struct STATE *avoid;
                    114: { register int i, j;
                    115:   struct VISIT *try = NULL;
                    116:   struct VISIT *pickstate();
                    117: 
                    118:        for (i = (hlast+1)%hbound; i != hlast; i++, i %= hbound)
                    119:        for (j = 0; j < oldstates[i].nr; j++)
                    120:                if (oldstates[i].index[j]->nrvisits > 0
                    121:                &&  oldstates[i].index[j] != avoid
                    122:                &&  (try = pickstate(oldstates[i].index[j])) != NULL)
                    123:                {       hlast = i;
                    124:                        return try;
                    125:                }
                    126:        return (struct VISIT *) Smalloc(sizeof(struct VISIT));
                    127: }
                    128: 
                    129: struct VISIT *
                    130: findastate(avoid)
                    131:        struct STATE *avoid;
                    132: { struct VISIT *findany(), *picknown(), *try;
                    133:   struct Spoke   *getspoke(),  *trs2;
                    134:   struct Swiffle *unswiffle(), *trs1;
                    135: 
                    136:        if (ireseen < zapper || zapper == 0)
                    137:                return (struct VISIT *) Smalloc(sizeof(struct VISIT));
                    138: 
                    139:        if ((trs1 = unswiffle(avoid)) != NULL
                    140:        &&  (try = picknown(trs1->st, trs1->vi)) != NULL)
                    141:                return try;
                    142: 
                    143: /*     if ((trs2 = getspoke(avoid)) != NULL
                    144:        &&  (try = picknown(trs2->st, trs2->vi)) != NULL)
                    145:                return try;
                    146: */
                    147:        return findany(avoid);  /* last resort */
                    148: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.