YAP 7.1.0
tracer.c
1/*************************************************************************
2 * *
3 * YAP Prolog @(#)amidefs.h 1.3 3/15/90
4 * *
5 * Yap Prolog was developed at NCCUP - Universidade do Porto *
6 * *
7 * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
8 * *
9 **************************************************************************
10 * *
11 * File: tracer.h *
12 * Last rev: *
13 * mods: *
14 * comments: definitions for low level tracer *
15 * *
16 *************************************************************************/
17
18#include "Yap.h"
19
20#ifdef LOW_LEVEL_TRACER
21
22#include "YapHeap.h"
23#include "YapText.h"
24#include "Yatom.h"
25#include "attvar.h"
26#include "clause.h"
27#include "iopreds.h"
28#include "tracer.h"
29#include "yapio.h"
30
31static char *send_tracer_message(char *start, char *name, arity_t arity,
32 char *mname, CELL *args, char **s0, char *s,
33 char **top) {
34 bool expand = false;
35 size_t max = *top - (s + 1);
36 int d, min = 1024;
37 char *s1 = s;
38 do {
39 if (expand || max < 32) {
40 Int cbeg = s1 - *s0;
41 max = *top - *s0;
42 max += min;
43 *s0 = Realloc(*s0, max);
44
45 *top = *s0 + max;
46 max--;
47 s1 = *s0 + cbeg;
48 s = s1;
49 expand = false;
50 }
51 min = 1024;
52 if (name == NULL) {
53#ifdef YAPOR
54 d = snprintf(s, max, "(%d)%s", worker_id, start);
55#else
56 d = snprintf(s, max, "%s", start);
57#endif
58 } else {
59
60 if (arity) {
61 if (args)
62 d = snprintf(s, max, "%s %s:%s(", start, mname, name);
63 else
64 d = snprintf(s, max, "%s %s:%s/%lu", start, mname, name,
65 (unsigned long int)arity);
66 } else {
67 d = snprintf(s, max, "%s %s:%s", start, mname, name);
68 }
69 }
70 if (d >= max) {
71 expand = true;
72 min = d + 1024;
73 continue;
74 }
75 max -= d;
76 s += d;
77 if (args) {
78 int i;
79 for (i = 0; i < arity; i++) {
80 if (i > 0) {
81 if (max > 16) {
82 *s++ = ',';
83 *s++ = ' ';
84 max -= 2;
85 } else {
86 expand = true;
87 continue;
88 }
89 }
90 int l_max_depth = LOCAL_max_depth;
91 LOCAL_max_depth = 10;
92 const char *sn = Yap_TermToBuffer(args[i],
93 Quote_illegal_f | Handle_vars_f);
94 LOCAL_max_depth = l_max_depth;
95 size_t sz;
96 if (sn == NULL) {
97 sn = "<* error *>";
98 }
99 sz = strlen(sn);
100 if (max <= sz) {
101 min = sz + 1024;
102 expand = true;
103 continue;
104 }
105 strcpy(s, sn);
106 s += sz;
107 max -= sz;
108 }
109 if (arity) {
110 *s++ = ' ';
111 *s++ = ')';
112 max -= 2;
113 }
114 }
115 } while (expand);
116 s[0] = '\0';
117 return s;
118}
119
120#if defined(__GNUC__)
121unsigned long long vsc_count;
122#else
123unsigned long vsc_count;
124#endif
125
126#if THREADS
127static int thread_trace;
128#endif
129
130/*
131static int
132check_trail_consistency(void) {
133 tr_fr_ptr ptr = TR;
134 while (ptr > (CELL *)LOCAL_TrailBase) {
135 ptr = --ptr;
136 if (!IsVarTerm(TrailTerm(ptr))) {
137 if (IsApplTerm(TrailTerm(ptr))) {
138 CELL *cptr = (CELL *)ptr;
139 ptr = (tr_fr_ptr)(cptr-1);
140 } else {
141 if (IsPairTerm(TrailTerm(ptr))) {
142 CELL *p = RepPair(TrailTerm(ptr));
143 if IsAttVar(p) continue;
144 }
145 printf("Oops at call %ld, B->cp(%p) TR(%p) pt(%p)\n",
146vsc_count,B->cp_tr, TR, ptr);
147 return(FALSE);
148 }
149 }
150 }
151 return(TRUE);
152}
153*/
154
155volatile int v;
156
157CELL old_value = 0L, old_value2 = 0L;
158
159void jmp_deb(int), jmp_deb2(void);
160
161void jmp_deb2(void) { fprintf(stderr, "Here\n"); }
162
163void jmp_deb(int i) {
164 if (i)
165 printf("Here we go " Int_FORMAT "\n", old_value++);
166 if (old_value == 716)
167 jmp_deb2();
168}
169
170struct various_codes *sc;
171
172/*
173CELL array[332];
174
175int found = FALSE;
176
177static void
178check_area(void)
179{
180 int i, first = -1;
181 for (i= 0; i < 332; i++) {
182 if (array[i] !=((CELL *)0x187a800)[i]) {
183 if (first != -1) {
184 first = i;
185 found = TRUE;
186 }
187 fprintf(stderr,"%lld changed %d\n",vsc_count,i);
188 }
189 array[i] = ((CELL *)0x187a800)[i];
190 }
191 if (first != -1)
192 jmp_deb(i);
193}
194*/
195// PredEntry *old_p[10000];
196// Term old_x1[10000], old_x2[10000], old_x3[10000];
197
198// static CELL oldv = 0;
199
200bool low_level_trace__(yap_low_level_port port, PredEntry *pred, CELL *args) {
201 CACHE_REGS
202 char *s;
203 char *mname;
204 Int arity;
205 /* extern int gc_calls; */
206 // if (vsc_count==0) hr=HR;
207 //fprintf(stderr, " %ld %ld\n", LCL0-(CELL*)B, HR-hr);
208 //if (vsc_count==7908)
209 // jmp_deb(1);
210 int l = push_text_stack();
211 vsc_count++;
212
213//jmp_deb(1);
214 // if (!((CELL)ENV & 1))
215 // return;
216 // if (HR < ASP ) return;
217 // fif (vsc_count == 12534) jmp_deb( 2 );
218 char *buf = Malloc(512), *top = buf + 511, *b = buf;
219
220 // if (vsc_count==250) jmp_deb(1);
221 // if (!worker_id) return;
222 LOCK(Yap_low_level_trace_lock);
223 sc = Yap_heap_regs;
224// if (vsc_count == 161862) jmp_deb(1);
225#ifdef THREADS
226 LOCAL_ThreadHandle.thread_inst_count++;
227#endif
228#ifdef COMMENTED
229 b = snprintf(b, top - b, "in %p\n");
230 CELL *gc_ENV = ENV;
231 while (gc_ENV != NULL) { /* no more environments */
232 b = snprintf(b, top - b, "%ld\n", LCL0 - gc_ENV);
233 gc_ENV = (CELL *)gc_ENV[E_E]; /* link to prev
234 * environment */
235 }
236 if (old) {
237 LOCAL_ActiveError = old;
238 }
239
240 return;
241 {
242 choiceptr b_p = B;
243 while (b_p) {
244 b = snprintf(b, top - b, "%p %ld\n", b_p,
245 Yap_op_from_opcode(b_p->cp_ap->opc));
246 b_p = b_p->cp_b;
247 }
248 }
249 {
250 choiceptr myB = B;
251 while (myB)
252 myB = myB->cp_b;
253 }
254 //*(H0+(0xb65f2850-0xb64b2008)/sizeof(CELL))==0xc ||
255 // 0x4fd4d
256 if (vsc_count > 1388060LL && vsc_count < 1388070LL) {
257 if (vsc_count == 1388061LL)
258 jmp_deb(1);
259 if (vsc_count % 1LL == 0) {
260 UInt sz = Yap_regp->H0_[17];
261 UInt end = sizeof(MP_INT) / sizeof(CELL) + sz + 1;
262 b = snprintf(b, top - b, "VAL %lld %d %x/%x\n", vsc_count, sz, H0[16],
263 H0[16 + end]);
264 }
265 } else
266 return;
267 if (old) {
268 LOCAL_ActiveError = old;
269 }
270 {
271 tr_fr_ptr pt = (tr_fr_ptr)LOCAL_TrailBase;
272 if (pt[140].term == 0 && pt[140].value != 0)
273 jmp_deb(1);
274 }
275 if (worker_id != 04 || worker_id != 03)
276 return;
277 // if (vsc_count == 218280)
278 // vsc_xstop = 1;
279 if (vsc_count < 1468068888) {
280 UNLOCK(Yap_heap_regs->low_level_trace_lock);
281 return;
282 }
283 if (port != enter_pred || !pred || pred->ArityOfPE != 4 ||
284 strcmp(RepAtom(NameOfFunctor(pred->FunctorOfPred))->StrOfAE,
285 "in_between_target_phrases")) {
286 UNLOCK(Yap_heap_regs->low_level_trace_lock);
287 return;
288 }
289 if (vsc_count < 1246949400LL) {
290 UNLOCK(Yap_heap_regs->low_level_trace_lock);
291 return;
292 }
293 if (vsc_count == 1246949493LL)
294 vsc_xstop = TRUE;
295 if (vsc_count < 5646100000LL) {
296 UNLOCK(Yap_heap_regs->low_level_trace_lock);
297 return;
298 }
299 if (vsc_count == 5646100441LL)
300 vsc_xstop = TRUE;
301 if (vsc_count < 2923351500LL) {
302 UNLOCK(Yap_heap_regs->low_level_trace_lock);
303 return;
304 }
305 if (vsc_count == 123536441LL)
306 vsc_xstop = 1;
307 if (vsc_count < 5530257LL) {
308 UNLOCK(Yap_heap_regs->low_level_trace_lock);
309 return;
310 }
311 if (vsc_count == 9414280LL) {
312 vsc_xstop = TRUE;
313 }
314 if (vsc_count < 3399741LL) {
315 UNLOCK(Yap_heap_regs->low_level_trace_lock);
316 return;
317 }
318 if (TR_FZ > TR)
319 jmp_deb(1);
320 {
321 tr_fr_ptr pt = (tr_fr_ptr)LOCAL_TrailBase;
322 if (pt[153].term == 0 && pt[153].value == 0 && pt[154].term != 0 &&
323 pt[154].value != 0 && (TR > pt + 154 || TR_FZ > pt + 154))
324 jmp_deb(2);
325 if (pt[635].term == 0 && pt[635].value == 0 && pt[636].term != 0 &&
326 pt[636].value != 0 && (TR > pt + 636 || TR_FZ > pt + 636))
327 jmp_deb(3);
328 if (pt[138].term == 0 && pt[138].value == 0 && pt[139].term != 0 &&
329 pt[139].value != 0 && (TR > pt + 138 || TR_FZ > pt + 138))
330 jmp_deb(4);
331 }
332 if (vsc_count == 287939LL)
333 jmp_deb(1);
334 if (vsc_count == 173118LL)
335 jmp_deb(1);
336 if (!(vsc_count >= 287934LL && vsc_count <= 287939LL) &&
337 !(vsc_count >= 173100LL && vsc_count <= 173239LL) && vsc_count != -1) {
338 return;
339 }
340 if (vsc_count == 51021) {
341 printf("Here I go\n");
342 }
343 if (vsc_count < 52000) {
344 UNLOCK(Yap_heap_regs->low_level_trace_lock);
345 return;
346 }
347 if (vsc_count > 52000)
348 exit(0);
349 UNLOCK(Yap_heap_regs->low_level_trace_lock);
350 return;
351 if (vsc_count == 837074) {
352 printf("Here I go\n");
353 }
354 if (gc_calls < 1) {
355 UNLOCK(Yap_heap_regs->low_level_trace_lock);
356 return;
357 }
358 {
359 CELL *env_ptr = ENV;
360 PredEntry *p;
361
362 while (env_ptr) {
363 PredEntry *pe = EnvPreg(env_ptr[E_CP]);
364
365 if (p == pe) {
366 UNLOCK(Yap_heap_regs->low_level_trace_lock);
367 pop_text_stack(l);
368 return (true);
369 }
370 if (env_ptr != NULL)
371 env_ptr = (CELL *)(env_ptr[E_E]);
372 }
373 printf("\n");
374 }
375#endif
376 b += snprintf(b, top - b, "%llud " UInt_FORMAT " ", vsc_count,
377 LCL0 - (CELL *)B);
378 b += snprintf(b, top - b, Int_FORMAT " ", LCL0 - (CELL *)Yap_REGS.CUT_C_TOP);
379#if defined(THREADS) || defined(YAPOR)
380 b += snprintf(b, top - b, "(%d)", worker_id);
381#endif
382 /* check_trail_consistency(); */
383 if (pred == NULL) {
384 UNLOCK(Yap_low_level_trace_lock);
385 pop_text_stack(l);
386 return (true);
387 }
388 if (pred->ModuleOfPred == PROLOG_MODULE) {
389 if (!LOCAL_do_trace_primitives) {
390 UNLOCK(Yap_low_level_trace_lock);
391 pop_text_stack(l);
392 return (true);
393 }
394 mname = "prolog";
395 } else {
396 mname = RepAtom(AtomOfTerm(Yap_Module_Name(pred)))->StrOfAE;
397 }
398 switch (port) {
399 case enter_pred:
400 arity = pred->ArityOfPE;
401 if (arity == 0) {
402 s = (char *)RepAtom((Atom)pred->FunctorOfPred)->StrOfAE;
403 } else {
404 s = (char *)RepAtom(NameOfFunctor((pred->FunctorOfPred)))->StrOfAE;
405 }
406 /* if ((pred->ModuleOfPred == 0) && (s[0] == '$'))
407 return; */
408 b = send_tracer_message("CALL: ", s, arity, mname, args, &buf, b, &top);
409 break;
410 case try_or:
411 b = send_tracer_message("TRY_OR ", NULL, 0, NULL, args, &buf, b, &top);
412 break;
413 case retry_or:
414 b = send_tracer_message("FAIL ", NULL, 0, NULL, args, &buf, b, &top);
415 b = send_tracer_message("RETRY_OR ", NULL, 0, NULL, NULL, &buf, b, &top);
416 break;
417 case retry_table_generator:
418 b = send_tracer_message("FAIL ", NULL, 0, NULL, args, &buf, b, &top);
419 mname = (char *)RepAtom(AtomOfTerm(Yap_Module_Name(pred)))->StrOfAE;
420 arity = pred->ArityOfPE;
421 if (arity == 0)
422 s = (char *)RepAtom((Atom)pred->FunctorOfPred)->StrOfAE;
423 else
424 s = (char *)RepAtom(NameOfFunctor((pred->FunctorOfPred)))->StrOfAE;
425 b = send_tracer_message("RETRY GENERATOR: ", s, arity, mname, args, &buf, b,
426 &top);
427 break;
428 case retry_table_consumer:
429 b = send_tracer_message("FAIL ", NULL, 0, NULL, args, &buf, b, &top);
430 mname = (char *)RepAtom(AtomOfTerm(Yap_Module_Name(pred)))->StrOfAE;
431 arity = pred->ArityOfPE;
432 if (arity == 0) {
433 s = (char *)RepAtom((Atom)pred->FunctorOfPred)->StrOfAE;
434 b = send_tracer_message("RETRY CONSUMER: ", s, 0, mname, NULL, &buf, b,
435 &top);
436 } else {
437 s = (char *)RepAtom(NameOfFunctor((pred->FunctorOfPred)))->StrOfAE;
438 b = send_tracer_message("RETRY CONSUMER: ", s, pred->ArityOfPE, mname,
439 NULL, &buf, b, &top);
440 }
441 break;
442 case retry_table_loader:
443 b = send_tracer_message("FAIL ", NULL, 0, NULL, args, &buf, b, &top);
444 if (pred == UndefHook) {
445 b = send_tracer_message("RETRY LOADER ", NULL, 0, NULL, NULL, &buf, b,
446 &top);
447 } else {
448 mname = (char *)RepAtom(AtomOfTerm(Yap_Module_Name(pred)))->StrOfAE;
449 arity = pred->ArityOfPE;
450 if (arity == 0)
451 s = (char *)RepAtom((Atom)pred->FunctorOfPred)->StrOfAE;
452 else
453 s = (char *)RepAtom(NameOfFunctor((pred->FunctorOfPred)))->StrOfAE;
454 b = send_tracer_message("RETRY LOADER: ", s, 0, mname, NULL, &buf, b,
455 &top);
456 }
457 break;
458 case retry_pred:
459 b = send_tracer_message("FAIL ", NULL, 0, NULL, args, &buf, b, &top);
460 if (pred != NULL) {
461 mname = (char *)RepAtom(AtomOfTerm(Yap_Module_Name(pred)))->StrOfAE;
462 arity = pred->ArityOfPE;
463 if (pred->ModuleOfPred == IDB_MODULE) {
464 s = "recorded";
465 arity = 3;
466 } else if (arity == 0) {
467 s = (char *)RepAtom((Atom)pred->FunctorOfPred)->StrOfAE;
468 } else {
469 s = (char *)RepAtom(NameOfFunctor((pred->FunctorOfPred)))->StrOfAE;
470 }
471 b = send_tracer_message("RETRY: ", s, arity, mname, args, &buf, b, &top);
472 }
473 break;
474 }
475 UNLOCK(Yap_low_level_trace_lock);
476#if __ANDROID__
477 __android_log_print(ANDROID_LOG_DEBUG, "YAPDroid", "%s\n", buf);
478#else
479 *b++ = '\n';
480 *b = '\0';
481 fputs(buf, stderr);
482#endif
483 pop_text_stack(l);
484 return (true);
485}
486
487void toggle_low_level_trace(void) {
488 Yap_do_low_level_trace = !Yap_do_low_level_trace;
489}
490
491static Int start_low_level_trace(USES_REGS1) {
492 Yap_do_low_level_trace = TRUE;
493 return (TRUE);
494}
495
496static Int total_choicepoints(USES_REGS1) {
497 return Yap_unify(MkIntegerTerm(LOCAL_total_choicepoints), ARG1);
498}
499
500static Int reset_total_choicepoints(USES_REGS1) {
501 LOCAL_total_choicepoints = 0;
502 return TRUE;
503}
504
505static Int show_low_level_trace(USES_REGS1) {
506 fprintf(stderr, "Call counter=%lld\n", vsc_count);
507 return (TRUE);
508}
509
510#ifdef THREADS
511static Int start_low_level_trace2(USES_REGS1) {
512 thread_trace = IntegerOfTerm(Deref(ARG1)) + 1;
513 Yap_do_low_level_trace = TRUE;
514 return (TRUE);
515}
516#endif
517
518#include <stdio.h>
519
529static Int stop_low_level_trace(USES_REGS1) {
530 Yap_do_low_level_trace = FALSE;
531
532 LOCAL_do_trace_primitives = TRUE;
533#if DEBUG_LOCKS
534 debug_locks = TRUE;
535#endif
536 return (TRUE);
537}
538
539volatile int v_wait;
540
541static Int vsc_wait(USES_REGS1) {
542 while (!v_wait)
543 ;
544 return true;
545}
546
547static Int vsc_go(USES_REGS1) {
548 v_wait = 1;
549 return true;
550}
551
552void Yap_InitLowLevelTrace(void) {
553 Yap_InitCPred("start_low_level_trace", 0, start_low_level_trace,
554 SafePredFlag);
555 Yap_InitCPred("$start_low_level_trace", 0, start_low_level_trace,
556 SafePredFlag);
564#if THREADS
565 Yap_InitCPred("start_low_level_trace", 1, start_low_level_trace2,
566 SafePredFlag);
567#endif
568 Yap_InitCPred("stop_low_level_trace", 0, stop_low_level_trace, SafePredFlag);
569 Yap_InitCPred("show_low_level_trace", 0, show_low_level_trace, SafePredFlag);
570 Yap_InitCPred("$stop_low_level_trace", 0, stop_low_level_trace, SafePredFlag);
571 Yap_InitCPred("total_choicepoints", 1, total_choicepoints, SafePredFlag);
572 Yap_InitCPred("reset_total_choicepoints", 0, reset_total_choicepoints,
573 SafePredFlag);
574 Yap_InitCPred("vsc_wait", 0, vsc_wait, SafePredFlag);
575 Yap_InitCPred("vsc_go", 0, vsc_go, SafePredFlag);
576}
577
578#else
579
580static null(USES_REGS1) { return true; }
581
582void Yap_InitLowLevelTrace(void) {
583 Yap_InitCPred("$start_low_level_trace", 0, null,
584 SafePredFlag | HiddenPredFlag);
585 Yap_InitCPred("$stop_low_level_trace", 0, null,
586 SafePredFlag | HiddenPredFlag);
587}
588#endif
Main definitions.
void * Malloc(size_t sz USES_REGS)
allocate a temporary text block
Definition: alloc.c:1759
Definition: Yatom.h:544