Return to trace4.c CVS log

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

Annotation of researchv10no/cmd/trace/trace4.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include "trace.h"
        !             3: #include "trace.d"
        !             4: 
        !             5:  extern char lockplus, prefix;
        !             6:  extern struct QUEUE *s_last;
        !             7:  extern int *processes, *globvars, *state, *qsize;
        !             8:  extern int nrprocs, nrrefs, nrvars, nrqs, level, assertbl, nrtbl;
        !             9:  extern long loopsf, zapped;
        !            10:  extern struct TBL *tbl;
        !            11:  extern struct PROCSTACK **procstack;
        !            12:  extern struct VARPARS *procpars;
        !            13: 
        !            14:  short *Factor, maxr = 0;
        !            15:  double iseen=0, ireseen=0, painful=0, kurshan=0;
        !            16: 
        !            17:  struct VISIT *lastvisit;
        !            18:  struct STATE *giveme(), *setstate();
        !            19:  char *Smalloc(), *emalloc();
        !            20: 
        !            21: struct STATE *
        !            22: inloop()
        !            23: { struct STATE *tmp;
        !            24:   register struct VISIT *hook;
        !            25:   register int x; char aa;
        !            26:   int i, nrnonempty=0, nrnon=0;
        !            27:   short h, hashvalue();
        !            28: 
        !            29:        for (i = 0; i < nrqs; i++)
        !            30:                if (qsize[i] > 0)
        !            31:                {       nrnonempty += (1<<i);
        !            32:                        nrnon++;
        !            33:                }
        !            34:        h = hashvalue(nrnonempty);
        !            35:        for (x = member(h); x > 0; x--)
        !            36:        {       tmp = giveme(h, x);
        !            37:                if (samestate(tmp))
        !            38:                {       for (hook = tmp->next; hook != NULL; hook = hook->next)
        !            39:                        {
        !            40:                                if (hook->howmany != nrnonempty
        !            41:                                || !Queuesmatch(hook, nrnon))
        !            42:                                        continue;
        !            43: 
        !            44:                                if (ISANA(hook))
        !            45:                                {       if (DEPTH(hook) > level)
        !            46:                                        {       painful += 1;
        !            47:                                                continue;
        !            48:                                        }
        !            49:                                        if (prefix)
        !            50:                                                output("prefix: ", 0);
        !            51:                                        hook->prop.countme += 1;
        !            52:                                        kurshan += (double) 1;
        !            53:                                        return NULL;
        !            54:                                } else
        !            55:                                {       loopsf++;
        !            56:                                        aa = (assertbl == NONE)? 1 : assertholds();
        !            57:                                        if (aa == 0 || lockplus)
        !            58:                                                putloop(hook->prop.s, aa);
        !            59:                                        return NULL;
        !            60:                        }       }
        !            61:                        return setstate(tmp, h);
        !            62:                }
        !            63:        }
        !            64:        return setstate((struct STATE *) NULL, h);
        !            65: }
        !            66: 
        !            67: cmplvars(one, two)
        !            68:        struct LOCVARS *one;
        !            69:        struct VARPARS *two;
        !            70: { int i;
        !            71: 
        !            72:        if (one->nrlvars != two->nrlvars)
        !            73:                return 0;
        !            74: 
        !            75:        for (i = 0; i < one->nrlvars; i++)
        !            76:                if (one->lvarvals[i] != two->lvarvals[i])
        !            77:                        return 0;
        !            78: 
        !            79:        return 1;
        !            80: }
        !            81: 
        !            82: cmplocals(one, two)
        !            83:        struct VARPARS *one, *two;
        !            84: { int i;
        !            85: 
        !            86:        if (one->nrlvars != two->nrlvars)
        !            87:                return 0;
        !            88: 
        !            89:        for (i = 0; i < one->nrlvars; i++)
        !            90:                if (one->lvarvals[i] != two->lvarvals[i])
        !            91:                        return 0;
        !            92: 
        !            93:        return 1;
        !            94: }
        !            95: 
        !            96: cmparams(one, two)
        !            97:        struct VARPARS *one, *two;
        !            98: { int i;
        !            99: 
        !           100:        if (one->nrms != two->nrms || one->nrvs != two->nrvs)
        !           101:                whoops("cannot happen - cmparams");
        !           102: 
        !           103:        for (i = 0; i < one->nrms; i++)
        !           104:                if (one->ms[i] != two->ms[i])
        !           105:                        return 0;
        !           106: 
        !           107:        for (i = 0; i < one->nrvs; i++)
        !           108:                if (one->vs[i] != two->vs[i])
        !           109:                        return 0;
        !           110: 
        !           111:        return 1;
        !           112: }
        !           113: 
        !           114: cmpstacks(older, newer)
        !           115:        struct PROCSTACK *older, *newer;
        !           116: { struct PROCSTACK *tmp1 = older;
        !           117:   struct PROCSTACK *tmp2 = newer;
        !           118: 
        !           119:        while (tmp2 != NULL)
        !           120:        {       
        !           121:                if (tmp1->uptable  != tmp2->uptable
        !           122:                ||  tmp1->uptransf != tmp2->uptransf)
        !           123:                        return 0;
        !           124: 
        !           125:                if (cmplocals(tmp1->varparsaved, tmp2->varparsaved) == 0
        !           126:                ||  cmparams (tmp1->varparsaved, tmp2->varparsaved) == 0)
        !           127:                        return 0;
        !           128: 
        !           129:                tmp1 = tmp1->follow;
        !           130:                tmp2 = tmp2->follow;
        !           131:        }
        !           132:        return 1;
        !           133: }
        !           134: 
        !           135: samestate(at)
        !           136:        struct STATE *at;
        !           137: {
        !           138:        return (sameP(at->pstate) && sametempl(at->pcon));
        !           139: }
        !           140: 
        !           141: cpylvars(into, from)
        !           142:        struct LOCVARS  *into;
        !           143:        struct VARPARS *from;
        !           144: { register int i;
        !           145: 
        !           146:        into->nrlvars = from->nrlvars;
        !           147:        into->lvarvals = (short *)
        !           148:                Smalloc(from->nrlvars * sizeof(short));
        !           149:        for (i = 0; i < from->nrlvars; i++)
        !           150:                into->lvarvals[i] = from->lvarvals[i];
        !           151: }
        !           152: 
        !           153: cpylocals(into, from)
        !           154:        struct VARPARS *into, *from;
        !           155: { register int i;
        !           156: 
        !           157:        into->nrlvars = from->nrlvars;
        !           158:        into->lvarvals = (short *)
        !           159:                Smalloc(from->nrlvars * sizeof(short));
        !           160:        for (i = 0; i < from->nrlvars; i++)
        !           161:                into->lvarvals[i] = from->lvarvals[i];
        !           162: }
        !           163: 
        !           164: cpyparams(into, from)
        !           165:        struct VARPARS *into, *from;
        !           166: { int i;
        !           167: 
        !           168:        into->nrms = from->nrms;
        !           169:        into->ms = (short *)
        !           170:                Smalloc(from->nrms * sizeof(short));
        !           171:        for (i = 0; i < from->nrms; i++)
        !           172:                into->ms[i] = from->ms[i];
        !           173: 
        !           174:        into->nrvs = from->nrvs;
        !           175:        into->vs = (short *)
        !           176:                Smalloc(from->nrvs * sizeof(short));
        !           177:        for (i = 0; i < from->nrvs; i++)
        !           178:                into->vs[i] = from->vs[i];
        !           179: }
        !           180: 
        !           181: cpystacks(left, right)
        !           182:        struct PROCSTACK *left, *right;
        !           183: { struct PROCSTACK *into = left;
        !           184:   struct PROCSTACK *from = right;
        !           185: 
        !           186:        while (from != NULL)
        !           187:        {       into->varparsaved = (struct VARPARS *)
        !           188:                        Smalloc(sizeof(struct VARPARS));
        !           189:                cpylocals(into->varparsaved, from->varparsaved);
        !           190:                cpyparams(into->varparsaved, from->varparsaved);
        !           191: 
        !           192:                into->uptable  = from->uptable;
        !           193:                into->uptransf = from->uptransf;
        !           194: 
        !           195:                if ((from = from->follow) != NULL)
        !           196:                {       into->follow = (struct PROCSTACK *)
        !           197:                                Smalloc(sizeof(struct PROCSTACK));
        !           198:                        into = into->follow;
        !           199:        }       }
        !           200: }
        !           201: 
        !           202: struct STATE *
        !           203: newstate(pha)
        !           204:        int pha;
        !           205: { struct STATE *hook;
        !           206:   struct VISIT *findastate();
        !           207:   struct TEMPLATE *inTtable();
        !           208:   unsigned short *inPtable();
        !           209: 
        !           210:        hook = (struct STATE *) Smalloc(sizeof(struct STATE));
        !           211:        hook->pstate = inPtable();
        !           212:        hook->pcon   = inTtable();
        !           213:        hook->next   = findastate(hook);        /* first visit */
        !           214: 
        !           215:        insert(pha, hook);
        !           216: 
        !           217:        return hook;
        !           218: }
        !           219: 
        !           220: struct VISIT *
        !           221: oldstate(where)
        !           222:        struct STATE *where;
        !           223: { register struct VISIT *tmp;
        !           224:   struct VISIT *try, *findastate();
        !           225: 
        !           226:        ireseen += (double)1;
        !           227:        try = findastate(where);
        !           228:        
        !           229:        if (where->next == NULL)
        !           230:                where->next = try;
        !           231:        else
        !           232:        {       for (tmp = where->next; tmp->next != NULL; tmp = tmp->next)
        !           233:                        ;
        !           234:                tmp->next = try;
        !           235:        }
        !           236: 
        !           237:        return try;
        !           238: }
        !           239: 
        !           240: struct STATE *
        !           241: setstate(where, ha)
        !           242:        struct STATE *where;
        !           243: { struct STATE *tmp;
        !           244:   struct VISIT *work;
        !           245: 
        !           246:        if (where == NULL)
        !           247:        {       tmp = newstate(ha);
        !           248:                work = tmp->next;
        !           249:        } else
        !           250:        {       tmp = where;
        !           251:                work = oldstate(where);
        !           252:        }
        !           253: 
        !           254:        work->prop.s = s_last;
        !           255:        work->depth = (short) level;
        !           256: 
        !           257:        lastvisit = work;
        !           258:        relink(work);
        !           259: 
        !           260:        return tmp;
        !           261: }
        !           262: 
        !           263: struct VISIT *
        !           264: pickstate(at)
        !           265:        struct STATE *at;
        !           266: { struct VISIT *latter = NULL;
        !           267:   register struct VISIT *hook = at->next;
        !           268: 
        !           269:        for (hook = at->next; hook != NULL; hook = hook->next)
        !           270:        {       if (ISANA(hook))
        !           271:                {       if (latter == NULL)
        !           272:                                at->next = hook->next;
        !           273:                        else
        !           274:                                latter->next = hook->next;
        !           275: 
        !           276:                        efree(hook->c);
        !           277:                        hook->next = NULL;
        !           278:                        zapped++;
        !           279: 
        !           280:                        return hook;
        !           281:                }
        !           282:                latter = hook;
        !           283:        }
        !           284:        return NULL;
        !           285: }
        !           286: 
        !           287: struct VISIT *
        !           288: picknown(at, want)
        !           289:        struct STATE *at;
        !           290:        struct VISIT *want;
        !           291: { struct VISIT *latter = NULL;
        !           292:   register struct VISIT *hook;
        !           293: 
        !           294:        for (hook = at->next; hook != NULL; hook = hook->next)
        !           295:        {       if (hook == want)
        !           296:                        break;
        !           297:                latter = hook;
        !           298:        }
        !           299:        if (hook == NULL)
        !           300:                whoops("cannot happen - picknown");
        !           301: 
        !           302:        if (latter == NULL)
        !           303:                at->next = hook->next;
        !           304:        else
        !           305:                latter->next = hook->next;
        !           306: 
        !           307:        efree(hook->c);
        !           308:        hook->next = NULL;
        !           309: 
        !           310:        zapped++;
        !           311:        return hook;
        !           312: }
        !           313: 
        !           314: inihash()
        !           315: { register int i;
        !           316:   char *Smalloc();
        !           317: 
        !           318:        for (i = 0; i < nrtbl; i++)
        !           319:                if (tbl[i].nrrows > maxr)
        !           320:                        maxr = tbl[i].nrrows;
        !           321: 
        !           322:        Factor = (short *)
        !           323:                Smalloc(maxr * sizeof(short));
        !           324: 
        !           325:        for (i = 0; i < maxr; i++)
        !           326:                Factor[i] = rand()%NOTOOBIG;    /* number between 0 and 16k */
        !           327: }
        !           328: 
        !           329: short
        !           330: hashvalue(g)
        !           331: { register int i, h;
        !           332: 
        !           333:        for (i = h = 0; i < nrprocs; i++)
        !           334:        {       h = ((h << 2) | (h >> 13));     /* rotate */
        !           335:                h ^= Factor[state[i]] ^ Factor[processes[i]];
        !           336:        }
        !           337:        h += g;
        !           338:        return (h & NOTOOBIG);
        !           339: }

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