![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to trace4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / trace|
Return to trace4.c CVS log | Up to [Research Unix] / researchv10no / cmd / trace |
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.