YAP 7.1.0
opt.preds.c
1/************************************************************************
2** **
3** The YapTab/YapOr/OPTYap systems **
4** **
5** YapTab extends the Yap Prolog engine to support sequential tabling **
6** YapOr extends the Yap Prolog engine to support or-parallelism **
7** OPTYap extends the Yap Prolog engine to support or-parallel tabling **
8** **
9** **
10** Yap Prolog was developed at University of Porto, Portugal **
11** **
12************************************************************************/
13
14/************************************
15** Includes & Prototypes **
16************************************/
17
18#include "Yap.h"
19#if defined(YAPOR) || defined(TABLING)
20#include "YapHeap.h"
21#include "Yatom.h"
22#ifdef YAPOR
23#if HAVE_STRING_H
24#include <string.h>
25#endif /* HAVE_STRING_H */
26#if HAVE_SYS_TIME_H
27#include <sys/time.h>
28#endif /* HAVE_SYS_TIME_H */
29#include "or.macros.h"
30#endif /* YAPOR */
31#ifdef TABLING
32#include "tab.macros.h"
33#endif /* TABLING */
34#include "iopreds.h"
35
36#ifdef TABLING
37static Int p_freeze_choice_point(USES_REGS1);
38static Int p_wake_choice_point(USES_REGS1);
39static Int p_abolish_frozen_choice_points_until(USES_REGS1);
40static Int p_abolish_frozen_choice_points_all(USES_REGS1);
41static Int p_table(USES_REGS1);
42static Int p_tabling_mode(USES_REGS1);
43static Int p_abolish_table(USES_REGS1);
44static Int p_abolish_all_tables(USES_REGS1);
45static Int p_show_tabled_predicates(USES_REGS1);
46static Int p_show_table(USES_REGS1);
47static Int p_show_all_tables(USES_REGS1);
48static Int p_show_global_trie(USES_REGS1);
49static Int p_show_statistics_table(USES_REGS1);
50static Int p_show_statistics_tabling(USES_REGS1);
51static Int p_show_statistics_global_trie(USES_REGS1);
52#endif /* TABLING */
53
54static Int p_yapor_workers(USES_REGS1);
55#ifdef YAPOR
56static Int p_parallel_mode(USES_REGS1);
57static Int p_yapor_start(USES_REGS1);
58static Int p_worker(USES_REGS1);
59static Int p_parallel_new_answer(USES_REGS1);
60static Int p_parallel_get_answers(USES_REGS1);
61static Int p_show_statistics_or(USES_REGS1);
62#endif /* YAPOR */
63#if defined(YAPOR) && defined(TABLING)
64static Int p_show_statistics_opt(USES_REGS1);
65#endif /* YAPOR && TABLING */
66static Int p_get_optyap_statistics(USES_REGS1);
67
68#ifdef YAPOR
69static inline realtime current_time(void);
70#endif /* YAPOR */
71
72#ifdef TABLING
73static inline struct page_statistics show_statistics_table_entries(FILE *out);
74#if defined(THREADS_FULL_SHARING) || defined(THREADS_CONSUMER_SHARING)
75static inline struct page_statistics show_statistics_subgoal_entries(FILE *out);
76#endif /* THREADS_FULL_SHARING || THREADS_CONSUMER_SHARING */
77static inline struct page_statistics show_statistics_subgoal_frames(FILE *out);
78static inline struct page_statistics
79show_statistics_dependency_frames(FILE *out);
80static inline struct page_statistics
81show_statistics_subgoal_trie_nodes(FILE *out);
82static inline struct page_statistics
83show_statistics_subgoal_trie_hashes(FILE *out);
84static inline struct page_statistics
85show_statistics_answer_trie_nodes(FILE *out);
86static inline struct page_statistics
87show_statistics_answer_trie_hashes(FILE *out);
88#if defined(THREADS_FULL_SHARING)
89static inline struct page_statistics
90show_statistics_answer_ref_nodes(FILE *out);
91#endif /* THREADS_FULL_SHARING */
92static inline struct page_statistics
93show_statistics_global_trie_nodes(FILE *out);
94static inline struct page_statistics
95show_statistics_global_trie_hashes(FILE *out);
96#endif /* TABLING */
97#ifdef YAPOR
98static inline struct page_statistics show_statistics_or_frames(FILE *out);
99static inline struct page_statistics
100show_statistics_query_goal_solution_frames(FILE *out);
101static inline struct page_statistics
102show_statistics_query_goal_answer_frames(FILE *out);
103#endif /* YAPOR */
104#if defined(YAPOR) && defined(TABLING)
105static inline struct page_statistics
106show_statistics_suspension_frames(FILE *out);
107#ifdef TABLING_INNER_CUTS
108static inline struct page_statistics
109show_statistics_table_subgoal_solution_frames(FILE *out);
110static inline struct page_statistics
111show_statistics_table_subgoal_answer_frames(FILE *out);
112#endif /* TABLING_INNER_CUTS */
113#endif /* YAPOR && TABLING */
114
115/************************************
116** Macros & Declarations **
117************************************/
118
119struct page_statistics {
120#ifdef USE_PAGES_MALLOC
121 long pages_in_use; /* same as struct pages (opt.structs.h) */
122#endif /* USE_PAGES_MALLOC */
123 size_t structs_in_use; /* same as struct pages (opt.structs.h) */
124 long bytes_in_use;
125};
126
127#define PgEnt_bytes_in_use(STATS) STATS.bytes_in_use
128
129#ifdef USE_PAGES_MALLOC
130#ifdef DEBUG_TABLING
131#define CHECK_PAGE_FREE_STRUCTS(STR_TYPE, PAGE) \
132 { \
133 pg_hd_ptr pg_hd; \
134 STR_TYPE *aux_ptr; \
135 long cont = 0; \
136 pg_hd = PgEnt_first(PAGE); \
137 while (pg_hd) { \
138 aux_ptr = PgHd_first_str(pg_hd); \
139 while (aux_ptr) { \
140 cont++; \
141 aux_ptr = aux_ptr->next; \
142 } \
143 pg_hd = PgHd_next(pg_hd); \
144 } \
145 TABLING_ERROR_CHECKING(CHECK_PAGE_FREE_STRUCTS, \
146 PgEnt_strs_free(PAGE) != cont); \
147 }
148#else
149#define CHECK_PAGE_FREE_STRUCTS(STR_TYPE, PAGE)
150#endif /* DEBUG_TABLING */
151#define INIT_PAGE_STATS(STATS) \
152 PgEnt_pages_in_use(STATS) = 0; \
153 PgEnt_strs_in_use(STATS) = 0
154#define INCREMENT_PAGE_STATS(STATS, PAGE) \
155 PgEnt_pages_in_use(STATS) += PgEnt_pages_in_use(PAGE); \
156 PgEnt_strs_in_use(STATS) += PgEnt_strs_in_use(PAGE)
157#define INCREMENT_AUX_STATS(STATS, BYTES, PAGES) \
158 BYTES += PgEnt_bytes_in_use(STATS); \
159 PAGES += PgEnt_pages_in_use(STATS)
160#define SHOW_PAGE_STATS_MSG(STR_NAME) \
161 " " STR_NAME " %10" Int_F " bytes (%ld pages and %ld structs in use)\n"
162#define SHOW_PAGE_STATS_ARGS(STATS, STR_TYPE) \
163 PgEnt_strs_in_use(STATS) * sizeof(STR_TYPE), PgEnt_pages_in_use(STATS), \
164 PgEnt_strs_in_use(STATS)
165#else /* !USE_PAGES_MALLOC */
166#define CHECK_PAGE_FREE_STRUCTS(STR_TYPE, PAGE)
167#define INIT_PAGE_STATS(STATS) PgEnt_strs_in_use(STATS) = 0
168#define INCREMENT_PAGE_STATS(STATS, PAGE) \
169 PgEnt_strs_in_use(STATS) += PgEnt_strs_in_use(PAGE)
170#define INCREMENT_AUX_STATS(STATS, BYTES, PAGES) \
171 BYTES += PgEnt_bytes_in_use(STATS)
172#define SHOW_PAGE_STATS_MSG(STR_NAME) \
173 " %s %10" Int_F "s bytes (%" Sizet_F " ; structs in use)\n", STR_NAME
174#define SHOW_PAGE_STATS_ARGS(STATS, STR_TYPE) \
175 PgEnt_strs_in_use(STATS) * sizeof(STR_TYPE), PgEnt_strs_in_use(STATS)
176#endif /* USE_PAGES_MALLOC */
177
178#if defined(THREADS) && defined(TABLING)
179#define GET_ALL_PAGE_STATS(STATS, STR_TYPE, _PAGES) \
180 LOCK(GLOBAL_ThreadHandlesLock); \
181 CHECK_PAGE_FREE_STRUCTS(STR_TYPE, GLOBAL##_PAGES); \
182 INCREMENT_PAGE_STATS(STATS, GLOBAL##_PAGES); \
183 { \
184 int wid; \
185 for (wid = 0; wid < MAX_THREADS; wid++) { \
186 if (!Yap_local[wid]) \
187 break; \
188 if (REMOTE_ThreadHandle(wid).in_use) { \
189 CHECK_PAGE_FREE_STRUCTS(STR_TYPE, REMOTE##_PAGES(wid)); \
190 INCREMENT_PAGE_STATS(STATS, REMOTE##_PAGES(wid)); \
191 } \
192 } \
193 } \
194 UNLOCK(GLOBAL_ThreadHandlesLock)
195#else
196#define GET_ALL_PAGE_STATS(STATS, STR_TYPE, _PAGES) \
197 CHECK_PAGE_FREE_STRUCTS(STR_TYPE, GLOBAL##_PAGES); \
198 INCREMENT_PAGE_STATS(STATS, GLOBAL##_PAGES)
199#endif
200
201#define GET_PAGE_STATS(STATS, STR_TYPE, _PAGES) \
202 INIT_PAGE_STATS(STATS); \
203 GET_ALL_PAGE_STATS(STATS, STR_TYPE, _PAGES); \
204 PgEnt_bytes_in_use(STATS) = PgEnt_strs_in_use(STATS) * sizeof(STR_TYPE)
205#define SHOW_PAGE_STATS(OUT_STREAM, STR_TYPE, _PAGES, STR_NAME) \
206 { \
207 struct page_statistics stats; \
208 GET_PAGE_STATS(stats, STR_TYPE, _PAGES); \
209 fprintf(OUT_STREAM, SHOW_PAGE_STATS_MSG(STR_NAME), \
210 SHOW_PAGE_STATS_ARGS(stats, STR_TYPE)); \
211 return stats; \
212 }
213
214/*******************************
215** Global functions **
216*******************************/
217
218void Yap_init_optyap_preds(void) {
219 Yap_InitCPred("$c_yapor_workers", 1, p_yapor_workers,
220 SafePredFlag | SyncPredFlag);
221#ifdef TABLING
222 Yap_InitCPred("freeze_choice_point", 1, p_freeze_choice_point,
223 SafePredFlag | SyncPredFlag);
224 Yap_InitCPred("wake_choice_point", 1, p_wake_choice_point,
225 SafePredFlag | SyncPredFlag);
226 Yap_InitCPred("abolish_frozen_choice_points", 1,
227 p_abolish_frozen_choice_points_until,
228 SafePredFlag | SyncPredFlag);
229 Yap_InitCPred("abolish_frozen_choice_points", 0,
230 p_abolish_frozen_choice_points_all,
231 SafePredFlag | SyncPredFlag);
232 Yap_InitCPred("$c_table", 3, p_table, SafePredFlag | SyncPredFlag);
233 Yap_InitCPred("$c_tabling_mode", 3, p_tabling_mode,
234 SafePredFlag | SyncPredFlag);
235 Yap_InitCPred("$c_abolish_table", 2, p_abolish_table,
236 SafePredFlag | SyncPredFlag);
237 Yap_InitCPred("abolish_all_tables", 0, p_abolish_all_tables,
238 SafePredFlag | SyncPredFlag);
247 Yap_InitCPred("show_tabled_predicates", 1, p_show_tabled_predicates,
248 SafePredFlag | SyncPredFlag);
249 Yap_InitCPred("$c_show_table", 3, p_show_table, SafePredFlag | SyncPredFlag);
250 Yap_InitCPred("show_all_tables", 1, p_show_all_tables,
251 SafePredFlag | SyncPredFlag);
252 Yap_InitCPred("show_global_trie", 1, p_show_global_trie,
253 SafePredFlag | SyncPredFlag);
254 Yap_InitCPred("$c_table_statistics", 3, p_show_statistics_table,
255 SafePredFlag | SyncPredFlag);
256 Yap_InitCPred("tabling_statistics", 1, p_show_statistics_tabling,
257 SafePredFlag | SyncPredFlag);
258 Yap_InitCPred("global_trie_statistics", 1, p_show_statistics_global_trie,
259 SafePredFlag | SyncPredFlag);
260#endif /* TABLING */
261#ifdef YAPOR
262 Yap_InitCPred("parallel_mode", 1, p_parallel_mode,
263 SafePredFlag | SyncPredFlag);
264 Yap_InitCPred("$c_yapor_start", 0, p_yapor_start,
265 SafePredFlag | SyncPredFlag);
266 Yap_InitCPred("$c_worker", 0, p_worker, SafePredFlag | SyncPredFlag);
267 Yap_InitCPred("$c_parallel_new_answer", 1, p_parallel_new_answer,
268 SafePredFlag | SyncPredFlag);
269 Yap_InitCPred("$c_parallel_get_answers", 1, p_parallel_get_answers,
270 SafePredFlag | SyncPredFlag);
271 Yap_InitCPred("or_statistics", 1, p_show_statistics_or,
272 SafePredFlag | SyncPredFlag);
273#endif /* YAPOR */
274#if defined(YAPOR) && defined(TABLING)
275 Yap_InitCPred("opt_statistics", 1, p_show_statistics_opt,
276 SafePredFlag | SyncPredFlag);
277#endif /* YAPOR && TABLING */
278 Yap_InitCPred("$c_get_optyap_statistics", 3, p_get_optyap_statistics,
279 SafePredFlag | SyncPredFlag);
280}
281
282#ifdef YAPOR
283void finish_yapor(void) {
284 GLOBAL_execution_time = current_time() - GLOBAL_execution_time;
285 GLOBAL_parallel_mode = PARALLEL_MODE_ON;
286 return;
287}
288#endif /* YAPOR */
289
290/***********************************
291** Tabling C Predicates **
292***********************************/
293
294#ifdef TABLING
295static Int p_freeze_choice_point(USES_REGS1) {
296 if (IsVarTerm(Deref(ARG1))) {
297 Int offset = freeze_current_cp();
298 return Yap_unify(ARG1, MkIntegerTerm(offset));
299 }
300 return (FALSE);
301}
302
303static Int p_wake_choice_point(USES_REGS1) {
304 Term term_offset = Deref(ARG1);
305 if (IsIntegerTerm(term_offset))
306 wake_frozen_cp(IntegerOfTerm(term_offset));
307 return (FALSE);
308}
309
310static Int p_abolish_frozen_choice_points_until(USES_REGS1) {
311 Term term_offset = Deref(ARG1);
312 if (IsIntegerTerm(term_offset))
313 abolish_frozen_cps_until(IntegerOfTerm(term_offset));
314 return (TRUE);
315}
316
317static Int p_abolish_frozen_choice_points_all(USES_REGS1) {
318 abolish_frozen_cps_all();
319 return (TRUE);
320}
321
322static Int p_table(USES_REGS1) {
323 Term mod, t, list;
324 PredEntry *pe;
325 Atom at;
326 int arity;
327 tab_ent_ptr tab_ent;
328#ifdef MODE_DIRECTED_TABLING
329 int *mode_directed = NULL;
330#endif /* MODE_DIRECTED_TABLING */
331
332 mod = Deref(ARG1);
333 t = Deref(ARG2);
334 list = Deref(ARG3);
335
336 if (IsAtomTerm(t)) {
337 at = AtomOfTerm(t);
338 pe = RepPredProp(PredPropByAtom(at, mod));
339 arity = 0;
340 } else if (IsApplTerm(t)) {
341 at = NameOfFunctor(FunctorOfTerm(t));
342 pe = RepPredProp(PredPropByFunc(FunctorOfTerm(t), mod));
343 arity = ArityOfFunctor(FunctorOfTerm(t));
344 } else
345 return (FALSE);
346 if (list != TermNil) { /* non-empty list */
347#ifndef MODE_DIRECTED_TABLING
348 Yap_Error(SYSTEM_ERROR_COMPILER, TermNil, "invalid tabling declaration for "
349 "%s/%d (mode directed tabling "
350 "not enabled)",
351 AtomName(at), arity);
352 return (FALSE);
353#else
354 /*************************************************************************************
355 The mode operator declaration is reordered as follows:
356 1. arguments with mode 'index' (any number)
357 2. arguments with mode 'min' and 'max' (any number, following the
358 original order)
359 3. arguments with mode 'all' (any number)
360 4. arguments with mode 'sum' or 'last' (only one of the two is allowed)
361 5. arguments with mode 'first' (any number)
362 *************************************************************************************/
363 int pos_index = 0;
364 int pos_min_max = 0;
365 int pos_all = 0;
366 int pos_sum_last = 0;
367 int pos_first = 0;
368 int i;
369 int *aux_mode_directed;
370
371 aux_mode_directed = malloc(arity * sizeof(int));
372 for (i = 0; i < arity; i++) {
373 int mode = IntOfTerm(HeadOfTerm(list));
374 if (mode == MODE_DIRECTED_INDEX)
375 pos_index++;
376 else if (mode == MODE_DIRECTED_MIN || mode == MODE_DIRECTED_MAX)
377 pos_min_max++;
378 else if (mode == MODE_DIRECTED_ALL)
379 pos_all++;
380 else if (mode == MODE_DIRECTED_SUM || mode == MODE_DIRECTED_LAST) {
381 if (pos_sum_last) {
382 free(aux_mode_directed);
383 Yap_Error(SYSTEM_ERROR_COMPILER, TermNil,
384 "invalid tabling declaration for %s/%d (more than one "
385 "argument with modes 'sum' and/or 'last')",
386 AtomName(at), arity);
387 return (FALSE);
388 } else
389 pos_sum_last = 1;
390 }
391 aux_mode_directed[i] = mode;
392 list = TailOfTerm(list);
393 }
394 pos_first = pos_index + pos_min_max + pos_all + pos_sum_last;
395 pos_sum_last = pos_index + pos_min_max + pos_all;
396 pos_all = pos_index + pos_min_max;
397 pos_min_max = pos_index;
398 pos_index = 0;
399 ALLOC_BLOCK(mode_directed, arity * sizeof(int), int);
400 for (i = 0; i < arity; i++) {
401 int aux_pos = 0;
402 if (aux_mode_directed[i] == MODE_DIRECTED_INDEX)
403 aux_pos = pos_index++;
404 else if (aux_mode_directed[i] == MODE_DIRECTED_MIN ||
405 aux_mode_directed[i] == MODE_DIRECTED_MAX)
406 aux_pos = pos_min_max++;
407 else if (aux_mode_directed[i] == MODE_DIRECTED_ALL)
408 aux_pos = pos_all++;
409 else if (aux_mode_directed[i] == MODE_DIRECTED_SUM ||
410 aux_mode_directed[i] == MODE_DIRECTED_LAST)
411 aux_pos = pos_sum_last++;
412 else if (aux_mode_directed[i] == MODE_DIRECTED_FIRST)
413 aux_pos = pos_first++;
414 mode_directed[aux_pos] = MODE_DIRECTED_SET(i, aux_mode_directed[i]);
415 }
416 free(aux_mode_directed);
417#endif /* MODE_DIRECTED_TABLING */
418 }
419 if (pe->PredFlags & TabledPredFlag)
420 return (TRUE); /* predicate already tabled */
421 if (pe->cs.p_code.FirstClause)
422 return (FALSE); /* predicate already compiled */
423 if (!(pe->PredFlags & TabledPredFlag)) {
424 pe->PredFlags |= TabledPredFlag;
425 new_table_entry(tab_ent, pe, at, arity, mode_directed);
426 pe->TableOfPred = tab_ent;
427 }
428 return (TRUE);
429}
430
431static Int p_tabling_mode(USES_REGS1) {
432 Term mod, t, tvalue;
433 tab_ent_ptr tab_ent;
434
435 mod = Deref(ARG1);
436 t = Deref(ARG2);
437 if (IsAtomTerm(t))
438 tab_ent = RepPredProp(PredPropByAtom(AtomOfTerm(t), mod))->TableOfPred;
439 else if (IsApplTerm(t))
440 tab_ent = RepPredProp(PredPropByFunc(FunctorOfTerm(t), mod))->TableOfPred;
441 else
442 return (FALSE);
443 tvalue = Deref(ARG3);
444 if (IsVarTerm(tvalue)) {
445 t = TermNil;
446 if (IsMode_LocalTrie(TabEnt_flags(tab_ent)))
447 t = MkPairTerm(MkAtomTerm(AtomLocalTrie), t);
448 else if (IsMode_GlobalTrie(TabEnt_flags(tab_ent)))
449 t = MkPairTerm(MkAtomTerm(AtomGlobalTrie), t);
450 if (IsMode_ExecAnswers(TabEnt_flags(tab_ent)))
451 t = MkPairTerm(MkAtomTerm(AtomExecAnswers), t);
452 else if (IsMode_LoadAnswers(TabEnt_flags(tab_ent)))
453 t = MkPairTerm(MkAtomTerm(AtomLoadAnswers), t);
454 if (IsMode_Batched(TabEnt_flags(tab_ent)))
455 t = MkPairTerm(MkAtomTerm(AtomBatched), t);
456 else if (IsMode_Local(TabEnt_flags(tab_ent)))
457 t = MkPairTerm(MkAtomTerm(AtomLocal), t);
458 if (IsMode_CoInductive(TabEnt_flags(tab_ent)))
459 t = MkPairTerm(MkAtomTerm(AtomCoInductive), t);
460 t = MkPairTerm(MkAtomTerm(AtomDefault), t);
461 t = MkPairTerm(t, TermNil);
462 if (IsMode_LocalTrie(TabEnt_mode(tab_ent)))
463 t = MkPairTerm(MkAtomTerm(AtomLocalTrie), t);
464 else if (IsMode_GlobalTrie(TabEnt_mode(tab_ent)))
465 t = MkPairTerm(MkAtomTerm(AtomGlobalTrie), t);
466 if (IsMode_ExecAnswers(TabEnt_mode(tab_ent)))
467 t = MkPairTerm(MkAtomTerm(AtomExecAnswers), t);
468 else if (IsMode_LoadAnswers(TabEnt_mode(tab_ent)))
469 t = MkPairTerm(MkAtomTerm(AtomLoadAnswers), t);
470 if (IsMode_Batched(TabEnt_mode(tab_ent)))
471 t = MkPairTerm(MkAtomTerm(AtomBatched), t);
472 else if (IsMode_Local(TabEnt_mode(tab_ent)))
473 t = MkPairTerm(MkAtomTerm(AtomLocal), t);
474 YapBind((CELL *)tvalue, t);
475 return (TRUE);
476 } else if (IsIntTerm(tvalue)) {
477 Int value = IntOfTerm(tvalue);
478 if (value == 1) { /* batched */
479 SetMode_Batched(TabEnt_flags(tab_ent));
480 if (!IsMode_Local(LOCAL_TabMode)) {
481 SetMode_Batched(TabEnt_mode(tab_ent));
482 return (TRUE);
483 }
484 } else if (value == 2) { /* local */
485 SetMode_Local(TabEnt_flags(tab_ent));
486 if (!IsMode_Batched(LOCAL_TabMode)) {
487 SetMode_Local(TabEnt_mode(tab_ent));
488 return (TRUE);
489 }
490 } else if (value == 3) { /* exec_answers */
491 SetMode_ExecAnswers(TabEnt_flags(tab_ent));
492 if (!IsMode_LoadAnswers(LOCAL_TabMode)) {
493 SetMode_ExecAnswers(TabEnt_mode(tab_ent));
494 return (TRUE);
495 }
496 } else if (value == 4) { /* load_answers */
497 SetMode_LoadAnswers(TabEnt_flags(tab_ent));
498 if (!IsMode_ExecAnswers(LOCAL_TabMode)) {
499 SetMode_LoadAnswers(TabEnt_mode(tab_ent));
500 return (TRUE);
501 }
502 } else if (value == 5) { /* local_trie */
503 SetMode_LocalTrie(TabEnt_flags(tab_ent));
504 if (!IsMode_GlobalTrie(LOCAL_TabMode)) {
505 SetMode_LocalTrie(TabEnt_mode(tab_ent));
506 return (TRUE);
507 }
508 } else if (value == 6) { /* global_trie */
509 SetMode_GlobalTrie(TabEnt_flags(tab_ent));
510 if (!IsMode_LocalTrie(LOCAL_TabMode)) {
511 SetMode_GlobalTrie(TabEnt_mode(tab_ent));
512 return (TRUE);
513 }
514 } else if (value == 7) {
515 /* coinductive */ // only affect the predicate flag. Also it cant be unset
516 SetMode_CoInductive(TabEnt_flags(tab_ent));
517 return (TRUE);
518 }
519 }
520 return (FALSE);
521}
522
523static Int p_abolish_table(USES_REGS1) {
524 Term mod, t;
525 tab_ent_ptr tab_ent;
526
527 mod = Deref(ARG1);
528 t = Deref(ARG2);
529 if (IsAtomTerm(t))
530 tab_ent = RepPredProp(PredPropByAtom(AtomOfTerm(t), mod))->TableOfPred;
531 else if (IsApplTerm(t))
532 tab_ent = RepPredProp(PredPropByFunc(FunctorOfTerm(t), mod))->TableOfPred;
533 else
534 return (FALSE);
535 abolish_table(tab_ent);
536 return (TRUE);
537}
538
539static Int p_abolish_all_tables(USES_REGS1) {
540 tab_ent_ptr tab_ent;
541
542 tab_ent = GLOBAL_root_tab_ent;
543 while (tab_ent) {
544 abolish_table(tab_ent);
545 tab_ent = TabEnt_next(tab_ent);
546 }
547 return (TRUE);
548}
549
550static Int p_show_tabled_predicates(USES_REGS1) {
551 FILE *out;
552 tab_ent_ptr tab_ent;
553 Term t = Deref(ARG1);
554
555 if (!IsStreamTerm(t))
556 return FALSE;
557 if (!(out = Yap_GetStreamHandle(t)->file))
558 return FALSE;
559 tab_ent = GLOBAL_root_tab_ent;
560 fprintf(out, "Tabled predicates\n");
561 if (tab_ent == NULL)
562 fprintf(out, " NONE\n");
563 else
564 while (tab_ent) {
565 fprintf(out, " %s/%d\n", AtomName(TabEnt_atom(tab_ent)),
566 TabEnt_arity(tab_ent));
567 tab_ent = TabEnt_next(tab_ent);
568 }
569 // PL_release_stream(out);
570 return (TRUE);
571}
572
573static Int p_show_table(USES_REGS1) {
574 Term mod, t;
575 tab_ent_ptr tab_ent;
576 Term t1 = Deref(ARG1);
577 FILE *out;
578
579 if (!IsStreamTerm(t1))
580 return FALSE;
581 if (!(out = Yap_GetStreamHandle(t1)->file))
582 return FALSE;
583 mod = Deref(ARG2);
584 t = Deref(ARG3);
585 if (IsAtomTerm(t))
586 tab_ent = RepPredProp(PredPropByAtom(AtomOfTerm(t), mod))->TableOfPred;
587 else if (IsApplTerm(t))
588 tab_ent = RepPredProp(PredPropByFunc(FunctorOfTerm(t), mod))->TableOfPred;
589 else {
590 return (FALSE);
591 }
592 showTable(tab_ent, SHOW_MODE_STRUCTURE, out);
593 return (TRUE);
594}
595
596static Int p_show_all_tables(USES_REGS1) {
597 tab_ent_ptr tab_ent;
598 Term t = Deref(ARG1);
599 FILE *out;
600
601 if (!IsStreamTerm(t))
602 return FALSE;
603 if (!(out = Yap_GetStreamHandle(t)->file))
604 return FALSE;
605 tab_ent = GLOBAL_root_tab_ent;
606 while (tab_ent) {
607 showTable(tab_ent, SHOW_MODE_STRUCTURE, out);
608 tab_ent = TabEnt_next(tab_ent);
609 }
610 return (TRUE);
611}
612
613static Int p_show_global_trie(USES_REGS1) {
614 Term t = Deref(ARG1);
615 FILE *out;
616
617 if (!IsStreamTerm(t))
618 return FALSE;
619 if (!(out = Yap_GetStreamHandle(t)->file))
620 return FALSE;
621 showGlobalTrie(SHOW_MODE_STRUCTURE, out);
622 return (TRUE);
623}
624
625static Int p_show_statistics_table(USES_REGS1) {
626 Term mod, t;
627 tab_ent_ptr tab_ent;
628 Term t1 = Deref(ARG1);
629 FILE *out;
630
631 if (!IsStreamTerm(t1))
632 return FALSE;
633 if (!(out = Yap_GetStreamHandle(t1)->file))
634 return FALSE;
635 mod = Deref(ARG2);
636 t = Deref(ARG3);
637 if (IsAtomTerm(t))
638 tab_ent = RepPredProp(PredPropByAtom(AtomOfTerm(t), mod))->TableOfPred;
639 else if (IsApplTerm(t))
640 tab_ent = RepPredProp(PredPropByFunc(FunctorOfTerm(t), mod))->TableOfPred;
641 else {
642 // PL_release_stream(out);
643 return (FALSE);
644 }
645 showTable(tab_ent, SHOW_MODE_STATISTICS, out);
646 return (TRUE);
647}
648
649static Int p_show_statistics_tabling(USES_REGS1) {
650 struct page_statistics stats;
651 long bytes, total_bytes = 0;
652#ifdef USE_PAGES_MALLOC
653 long total_pages = 0;
654#endif /* USE_PAGES_MALLOC */
655 FILE *out;
656 Term t = Deref(ARG1);
657
658 if (!IsStreamTerm(t))
659 return FALSE;
660 if (!(out = Yap_GetStreamHandle(t)->file))
661 return FALSE;
662 bytes = 0;
663 fprintf(out, "Execution data structures\n");
664 stats = show_statistics_table_entries(out);
665 INCREMENT_AUX_STATS(stats, bytes, total_pages);
666#if defined(THREADS_FULL_SHARING) || defined(THREADS_CONSUMER_SHARING)
667 stats = show_statistics_subgoal_entries(out);
668 INCREMENT_AUX_STATS(stats, bytes, total_pages);
669#endif /* THREADS_FULL_SHARING || THREADS_CONSUMER_SHARING */
670 stats = show_statistics_subgoal_frames(out);
671 INCREMENT_AUX_STATS(stats, bytes, total_pages);
672 stats = show_statistics_dependency_frames(out);
673 INCREMENT_AUX_STATS(stats, bytes, total_pages);
674 fprintf(out, " Memory in use (I): %10ld bytes\n\n", bytes);
675 total_bytes += bytes;
676 bytes = 0;
677 fprintf(out, "Local trie data structures\n");
678 stats = show_statistics_subgoal_trie_nodes(out);
679 INCREMENT_AUX_STATS(stats, bytes, total_pages);
680 stats = show_statistics_answer_trie_nodes(out);
681 INCREMENT_AUX_STATS(stats, bytes, total_pages);
682 stats = show_statistics_subgoal_trie_hashes(out);
683 INCREMENT_AUX_STATS(stats, bytes, total_pages);
684 stats = show_statistics_answer_trie_hashes(out);
685 INCREMENT_AUX_STATS(stats, bytes, total_pages);
686#if defined(THREADS_FULL_SHARING)
687 stats = show_statistics_answer_ref_nodes(out);
688 INCREMENT_AUX_STATS(stats, bytes, total_pages);
689#endif /* THREADS_FULL_SHARING */
690 fprintf(out, " Memory in use (II): %10ld bytes\n\n", bytes);
691 total_bytes += bytes;
692 bytes = 0;
693 fprintf(out, "Global trie data structures\n");
694 stats = show_statistics_global_trie_nodes(out);
695 INCREMENT_AUX_STATS(stats, bytes, total_pages);
696 stats = show_statistics_global_trie_hashes(out);
697 INCREMENT_AUX_STATS(stats, bytes, total_pages);
698 fprintf(out, " Memory in use (III): %10ld bytes\n\n", bytes);
699 total_bytes += bytes;
700#ifdef USE_PAGES_MALLOC
701 fprintf(out,
702 "Total memory in use (I+II+III): %10ld bytes (%ld pages in use)\n",
703 total_bytes, total_pages);
704 fprintf(
705 out,
706 "Total memory allocated: %10ld bytes (%ld pages in total)\n",
707 PgEnt_pages_in_use(GLOBAL_pages_alloc) * Yap_page_size,
708 PgEnt_pages_in_use(GLOBAL_pages_alloc));
709#else
710 fprintf(out, "Total memory in use (I+II+III): %10ld bytes\n", total_bytes);
711#endif /* USE_PAGES_MALLOC */
712 // PL_release_stream(out);
713 return (TRUE);
714}
715
716static Int p_show_statistics_global_trie(USES_REGS1) {
717 Term t = Deref(ARG1);
718 FILE *out;
719
720 if (!IsStreamTerm(t))
721 return FALSE;
722 if (!(out = Yap_GetStreamHandle(t)->file))
723 return FALSE;
724 showGlobalTrie(SHOW_MODE_STATISTICS, out);
725 return (TRUE);
726}
727#endif /* TABLING */
728
729/*********************************
730** YapOr C Predicates **
731*********************************/
732
733#ifdef YAPOR
734static Int p_parallel_mode(USES_REGS1) {
735 Term t;
736 t = Deref(ARG1);
737 if (IsVarTerm(t)) {
738 Term ta;
739 if (GLOBAL_parallel_mode == PARALLEL_MODE_OFF)
740 ta = MkAtomTerm(Yap_LookupAtom("off"));
741 else if (GLOBAL_parallel_mode == PARALLEL_MODE_ON)
742 ta = MkAtomTerm(Yap_LookupAtom("on"));
743 else /* PARALLEL_MODE_RUNNING */
744 ta = MkAtomTerm(Yap_LookupAtom("running"));
745 YapBind((CELL *)t, ta);
746 return (TRUE);
747 }
748 if (IsAtomTerm(t) && GLOBAL_parallel_mode != PARALLEL_MODE_RUNNING) {
749 char *s;
750 s = RepAtom(AtomOfTerm(t))->StrOfAE;
751 if (strcmp(s, "on") == 0) {
752 GLOBAL_parallel_mode = PARALLEL_MODE_ON;
753 return (TRUE);
754 }
755 if (strcmp(s, "off") == 0) {
756 GLOBAL_parallel_mode = PARALLEL_MODE_OFF;
757 return (TRUE);
758 }
759 return (FALSE); /* PARALLEL_MODE_RUNNING */
760 }
761 return (FALSE);
762}
763
764static Int p_yapor_start(USES_REGS1) {
765#ifdef TIMESTAMP_CHECK
766 GLOBAL_timestamp = 0;
767#endif /* TIMESTAMP_CHECK */
768 BITMAP_delete(GLOBAL_bm_idle_workers, 0);
769 BITMAP_clear(GLOBAL_bm_invisible_workers);
770 BITMAP_clear(GLOBAL_bm_requestable_workers);
771#ifdef TABLING_INNER_CUTS
772 BITMAP_clear(GLOBAL_bm_pruning_workers);
773#endif /* TABLING_INNER_CUTS */
774 make_root_choice_point();
775 GLOBAL_parallel_mode = PARALLEL_MODE_RUNNING;
776 GLOBAL_execution_time = current_time();
777 BITMAP_clear(GLOBAL_bm_finished_workers);
778 return (TRUE);
779}
780
781static Int p_yapor_workers(USES_REGS1) {
782#ifdef YAPOR_THREADS
783 return Yap_unify(MkIntegerTerm(GLOBAL_number_workers), ARG1);
784#else
785 return FALSE;
786#endif /* YAPOR_THREADS */
787}
788
789static Int p_worker(USES_REGS1) {
790 CurrentModule = USER_MODULE;
791 P = GETWORK_FIRST_TIME;
792 return TRUE;
793}
794
795static Int p_parallel_new_answer(USES_REGS1) {
796 qg_ans_fr_ptr actual_answer;
797 or_fr_ptr leftmost_or_fr;
798
799 ALLOC_QG_ANSWER_FRAME(actual_answer);
800 AnsFr_answer(actual_answer) = Deref(ARG1);
801 AnsFr_next(actual_answer) = NULL;
802 leftmost_or_fr = CUT_leftmost_or_frame();
803 LOCK_OR_FRAME(leftmost_or_fr);
804 if (Get_LOCAL_prune_request()) {
805 UNLOCK_OR_FRAME(leftmost_or_fr);
806 FREE_QG_ANSWER_FRAME(actual_answer);
807 } else {
808 CUT_store_answer(leftmost_or_fr, actual_answer);
809 UNLOCK_OR_FRAME(leftmost_or_fr);
810 }
811 return (TRUE);
812}
813
814static Int p_parallel_get_answers(USES_REGS1) {
815 Term t = TermNil;
816
817 if (OrFr_qg_solutions(LOCAL_top_or_fr)) {
818 qg_ans_fr_ptr aux_answer1, aux_answer2;
819 aux_answer1 = SolFr_first(OrFr_qg_solutions(LOCAL_top_or_fr));
820 while (aux_answer1) {
821 t = MkPairTerm(AnsFr_answer(aux_answer1), t);
822 aux_answer2 = aux_answer1;
823 aux_answer1 = AnsFr_next(aux_answer1);
824 FREE_QG_ANSWER_FRAME(aux_answer2);
825 }
826 FREE_QG_SOLUTION_FRAME(OrFr_qg_solutions(LOCAL_top_or_fr));
827 OrFr_qg_solutions(LOCAL_top_or_fr) = NULL;
828 }
829 Yap_unify(ARG1, t);
830 return (TRUE);
831}
832
833static Int p_show_statistics_or(USES_REGS1) {
834 struct page_statistics stats;
835 long bytes, total_bytes = 0;
836#ifdef USE_PAGES_MALLOC
837 long total_pages = 0;
838#endif /* USE_PAGES_MALLOC */
839 Term t = Deref(ARG1);
840
841 if (!IsStreamTerm(t))
842 return FALSE;
843 \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ bytes =
844 0;
845 fprintf(out, "Execution data structures\n");
846 stats = show_statistics_or_frames(out);
847 INCREMENT_AUX_STATS(stats, bytes, total_pages);
848 fprintf(out, " Memory in use (I): %10ld bytes\n\n", bytes);
849 total_bytes += bytes;
850 bytes = 0;
851 fprintf(out, "Cut support data structures\n");
852 stats = show_statistics_query_goal_solution_frames(out);
853 INCREMENT_AUX_STATS(stats, bytes, total_pages);
854 stats = show_statistics_query_goal_answer_frames(out);
855 INCREMENT_AUX_STATS(stats, bytes, total_pages);
856 fprintf(out, " Memory in use (II): %10ld bytes\n\n", bytes);
857 total_bytes += bytes;
858#ifdef USE_PAGES_MALLOC
859 fprintf(out,
860 "Total memory in use (I+II): %10ld bytes (%ld pages in use)\n",
861 total_bytes, total_pages);
862 fprintf(
863 out,
864 "Total memory allocated: %10ld bytes (%ld pages in total)\n",
865 PgEnt_pages_in_use(GLOBAL_pages_alloc) * Yap_page_size,
866 PgEnt_pages_in_use(GLOBAL_pages_alloc));
867#else
868 fprintf(out, "Total memory in use (I+II): %10ld bytes\n", total_bytes);
869#endif /* USE_PAGES_MALLOC */
870 PL_release_stream(out);
871 return (TRUE);
872}
873
874#else
875
876static Int p_yapor_workers(USES_REGS1) { return FALSE; }
877#endif /* YAPOR */
878
879/**********************************
880 ** OPTYap C Predicates **
881**********************************/
882
883#if defined(YAPOR) && defined(TABLING)
884static Int p_show_statistics_opt(USES_REGS1) {
885 struct page_statistics stats;
886 long bytes, total_bytes = 0;
887#ifdef USE_PAGES_MALLOC
888 long total_pages = 0;
889#endif /* USE_PAGES_MALLOC */
890 FILE *out;
891 Term t = Deref(ARG1);
892
893 if (IsVarTerm(t) || !IsAtomTerm(t))
894 return FALSE;
895 if (!(out = Yap_GetStreamHandle(AtomOfTerm(t))))
896 return FALSE;
897 bytes = 0;
898 fprintf(out, "Execution data structures\n");
899 stats = show_statistics_table_entries(out);
900 INCREMENT_AUX_STATS(stats, bytes, total_pages);
901#if defined(THREADS_FULL_SHARING) || defined(THREADS_CONSUMER_SHARING)
902 stats = show_statistics_subgoal_entries(out);
903 INCREMENT_AUX_STATS(stats, bytes, total_pages);
904#endif /* THREADS_FULL_SHARING || THREADS_CONSUMER_SHARING */
905 stats = show_statistics_subgoal_frames(out);
906 INCREMENT_AUX_STATS(stats, bytes, total_pages);
907 stats = show_statistics_dependency_frames(out);
908 INCREMENT_AUX_STATS(stats, bytes, total_pages);
909 stats = show_statistics_or_frames(out);
910 INCREMENT_AUX_STATS(stats, bytes, total_pages);
911 stats = show_statistics_suspension_frames(out);
912 INCREMENT_AUX_STATS(stats, bytes, total_pages);
913 fprintf(out, " Memory in use (I): %10ld bytes\n\n", bytes);
914 total_bytes += bytes;
915 bytes = 0;
916 fprintf(out, "Local trie data structures\n");
917 stats = show_statistics_subgoal_trie_nodes(out);
918 INCREMENT_AUX_STATS(stats, bytes, total_pages);
919 stats = show_statistics_answer_trie_nodes(out);
920 INCREMENT_AUX_STATS(stats, bytes, total_pages);
921 stats = show_statistics_subgoal_trie_hashes(out);
922 INCREMENT_AUX_STATS(stats, bytes, total_pages);
923 stats = show_statistics_answer_trie_hashes(out);
924 INCREMENT_AUX_STATS(stats, bytes, total_pages);
925#if defined(THREADS_FULL_SHARING)
926 stats = show_statistics_answer_ref_nodes(out);
927 INCREMENT_AUX_STATS(stats, bytes, total_pages);
928#endif /* THREADS_FULL_SHARING */
929 fprintf(out, " Memory in use (II): %10ld bytes\n\n", bytes);
930 total_bytes += bytes;
931 bytes = 0;
932 fprintf(out, "Global trie data structures\n");
933 stats = show_statistics_global_trie_nodes(out);
934 INCREMENT_AUX_STATS(stats, bytes, total_pages);
935 stats = show_statistics_global_trie_hashes(out);
936 INCREMENT_AUX_STATS(stats, bytes, total_pages);
937 fprintf(out, " Memory in use (III): %10ld bytes\n\n", bytes);
938 total_bytes += bytes;
939 bytes = 0;
940 fprintf(out, "Cut support data structures\n");
941 stats = show_statistics_query_goal_solution_frames(out);
942 INCREMENT_AUX_STATS(stats, bytes, total_pages);
943 stats = show_statistics_query_goal_answer_frames(out);
944 INCREMENT_AUX_STATS(stats, bytes, total_pages);
945#ifdef TABLING_INNER_CUTS
946 stats = show_statistics_table_subgoal_solution_frames(out);
947 INCREMENT_AUX_STATS(stats, bytes, total_pages);
948 stats = show_statistics_table_subgoal_answer_frames(out);
949 INCREMENT_AUX_STATS(stats, bytes, total_pages);
950#endif /* TABLING_INNER_CUTS */
951 fprintf(out, " Memory in use (IV): %10ld bytes\n\n", bytes);
952 total_bytes += bytes;
953#ifdef USE_PAGES_MALLOC
954 fprintf(out,
955 "Total memory in use (I+II+III+IV): %10ld bytes (%ld pages in use)\n",
956 total_bytes, total_pages);
957 fprintf(
958 out,
959 "Total memory allocated: %10ld bytes (%ld pages in total)\n",
960 PgEnt_pages_in_use(GLOBAL_pages_alloc) * Yap_page_size,
961 PgEnt_pages_in_use(GLOBAL_pages_alloc));
962#else
963 fprintf(out, "Total memory in use (I+II+III+IV): %10ld bytes\n", total_bytes);
964#endif /* USE_PAGES_MALLOC */
965 PL_release_stream(out);
966 return (TRUE);
967}
968#endif /* YAPOR && TABLING */
969
970static Int p_get_optyap_statistics(USES_REGS1) {
971 struct page_statistics stats;
972 Int value, bytes = 0, structs = -1;
973 Term tbytes, tstructs;
974
975 value = IntOfTerm(Deref(ARG1));
976#ifdef TABLING
977 if (value == 0 || value == 1) { /* table_entries */
978 GET_PAGE_STATS(stats, struct table_entry, _pages_tab_ent);
979 bytes += PgEnt_bytes_in_use(stats);
980 if (value != 0)
981 structs = PgEnt_strs_in_use(stats);
982 }
983#if defined(THREADS_FULL_SHARING) || defined(THREADS_CONSUMER_SHARING)
984 if (value == 0 || value == 16) { /* subgoal_entries */
985 GET_PAGE_STATS(stats, struct subgoal_entry, _pages_sg_ent);
986 bytes += PgEnt_bytes_in_use(stats);
987 if (value != 0)
988 structs = PgEnt_strs_in_use(stats);
989 }
990#endif
991 if (value == 0 || value == 2) { /* subgoal_frames */
992 GET_PAGE_STATS(stats, struct subgoal_frame, _pages_sg_fr);
993 bytes += PgEnt_bytes_in_use(stats);
994 if (value != 0)
995 structs = PgEnt_strs_in_use(stats);
996 }
997 if (value == 0 || value == 3) { /* dependency_frames */
998 GET_PAGE_STATS(stats, struct dependency_frame, _pages_dep_fr);
999 bytes += PgEnt_bytes_in_use(stats);
1000 if (value != 0)
1001 structs = PgEnt_strs_in_use(stats);
1002 }
1003 if (value == 0 || value == 6) { /* subgoal_trie_nodes */
1004 GET_PAGE_STATS(stats, struct subgoal_trie_node, _pages_sg_node);
1005 bytes += PgEnt_bytes_in_use(stats);
1006 if (value != 0)
1007 structs = PgEnt_strs_in_use(stats);
1008 }
1009 if (value == 0 || value == 8) { /* subgoal_trie_hashes */
1010 GET_PAGE_STATS(stats, struct subgoal_trie_hash, _pages_sg_hash);
1011 bytes += PgEnt_bytes_in_use(stats);
1012 if (value != 0)
1013 structs = PgEnt_strs_in_use(stats);
1014 }
1015 if (value == 0 || value == 7) { /* answer_trie_nodes */
1016 GET_PAGE_STATS(stats, struct answer_trie_node, _pages_ans_node);
1017 bytes += PgEnt_bytes_in_use(stats);
1018 if (value != 0)
1019 structs = PgEnt_strs_in_use(stats);
1020 }
1021 if (value == 0 || value == 9) { /* answer_trie_hashes */
1022 GET_PAGE_STATS(stats, struct answer_trie_hash, _pages_ans_hash);
1023 bytes += PgEnt_bytes_in_use(stats);
1024 if (value != 0)
1025 structs = PgEnt_strs_in_use(stats);
1026 }
1027#if defined(THREADS_FULL_SHARING)
1028 if (value == 0 || value == 17) { /* answer_ref_nodes */
1029 GET_PAGE_STATS(stats, struct answer_ref_node, _pages_ans_ref_node);
1030 bytes += PgEnt_bytes_in_use(stats);
1031 if (value != 0)
1032 structs = PgEnt_strs_in_use(stats);
1033 }
1034#endif
1035 if (value == 0 || value == 10) { /* global_trie_nodes */
1036 GET_PAGE_STATS(stats, struct global_trie_node, _pages_gt_node);
1037 bytes += PgEnt_bytes_in_use(stats);
1038 if (value != 0)
1039 structs = PgEnt_strs_in_use(stats);
1040 }
1041 if (value == 0 || value == 11) { /* global_trie_hashes */
1042 GET_PAGE_STATS(stats, struct global_trie_hash, _pages_gt_hash);
1043 bytes += PgEnt_bytes_in_use(stats);
1044 if (value != 0)
1045 structs = PgEnt_strs_in_use(stats);
1046 }
1047#endif /* TABLING */
1048#ifdef YAPOR
1049 if (value == 0 || value == 4) { /* or_frames */
1050 GET_PAGE_STATS(stats, struct or_frame, _pages_or_fr);
1051 bytes += PgEnt_bytes_in_use(stats);
1052 if (value != 0)
1053 structs = PgEnt_strs_in_use(stats);
1054 }
1055 if (value == 0 || value == 12) { /* query_goal_solution_frames */
1056 GET_PAGE_STATS(stats, struct query_goal_solution_frame, _pages_qg_sol_fr);
1057 bytes += PgEnt_bytes_in_use(stats);
1058 if (value != 0)
1059 structs = PgEnt_strs_in_use(stats);
1060 }
1061 if (value == 0 || value == 13) { /* query_goal_answer_frames */
1062 GET_PAGE_STATS(stats, struct query_goal_answer_frame, _pages_qg_ans_fr);
1063 bytes += PgEnt_bytes_in_use(stats);
1064 if (value != 0)
1065 structs = PgEnt_strs_in_use(stats);
1066 }
1067#endif /* YAPOR */
1068#if defined(YAPOR) && defined(TABLING)
1069 if (value == 0 || value == 5) { /* suspension_frames */
1070 GET_PAGE_STATS(stats, struct suspension_frame, _pages_susp_fr);
1071 bytes += PgEnt_bytes_in_use(stats);
1072 if (value != 0)
1073 structs = PgEnt_strs_in_use(stats);
1074 }
1075#ifdef TABLING_INNER_CUTS
1076 if (value == 0 || value == 14) { /* table_subgoal_solution_frames */
1077 GET_PAGE_STATS(stats, struct table_subgoal_solution_frame,
1078 _pages_tg_sol_fr);
1079 bytes += PgEnt_bytes_in_use(stats);
1080 if (value != 0)
1081 structs = PgEnt_strs_in_use(stats);
1082 }
1083 if (value == 0 || value == 15) { /* table_subgoal_answer_frames */
1084 GET_PAGE_STATS(stats, struct table_subgoal_answer_frame, _pages_tg_ans_fr);
1085 bytes += PgEnt_bytes_in_use(stats);
1086 if (value != 0)
1087 structs = PgEnt_strs_in_use(stats);
1088 }
1089#endif /* TABLING_INNER_CUTS */
1090#endif /* YAPOR && TABLING */
1091
1092 if (value == 0) { /* total_memory */
1093#ifdef USE_PAGES_MALLOC
1094 structs = PgEnt_pages_in_use(GLOBAL_pages_alloc) * Yap_page_size;
1095#else
1096 structs = bytes;
1097#endif /* USE_PAGES_MALLOC */
1098 }
1099 if (structs == -1)
1100 return (FALSE);
1101 tbytes = Deref(ARG2);
1102 tstructs = Deref(ARG3);
1103 if (IsVarTerm(tbytes)) {
1104 YapBind((CELL *)tbytes, MkIntTerm(bytes));
1105 } else if (IsIntTerm(tbytes) && IntOfTerm(tbytes) != bytes)
1106 return (FALSE);
1107 if (IsVarTerm(tstructs)) {
1108 YapBind((CELL *)tstructs, MkIntTerm(structs));
1109 } else if (IsIntTerm(tstructs) && IntOfTerm(tstructs) != structs)
1110 return (FALSE);
1111 return (TRUE);
1112}
1113
1114/******************************
1115** Local functions **
1116******************************/
1117
1118#ifdef YAPOR
1119static inline realtime current_time(void) {
1120#define TIME_RESOLUTION 1000000
1121 struct timeval tempo;
1122 gettimeofday(&tempo, NULL);
1123 return ((realtime)tempo.tv_sec + (realtime)tempo.tv_usec / TIME_RESOLUTION);
1124 /* to get time as Yap */
1125 /*
1126 double now, interval;
1127 Yap_cputime_interval(&now, &interval);
1128 return ((realtime)now);
1129 */
1130}
1131#endif /* YAPOR */
1132
1133#ifdef TABLING
1134static inline struct page_statistics show_statistics_table_entries(FILE *out) {
1135 SHOW_PAGE_STATS(out, struct table_entry, _pages_tab_ent,
1136 "Table entries: ");
1137}
1138
1139#if defined(THREADS_FULL_SHARING) || defined(THREADS_CONSUMER_SHARING)
1140static inline struct page_statistics
1141show_statistics_subgoal_entries(FILE *out) {
1142 SHOW_PAGE_STATS(out, struct subgoal_entry, _pages_sg_ent,
1143 "Subgoal entries: ");
1144}
1145#endif /* THREADS_FULL_SHARING || THREADS_CONSUMER_SHARING */
1146
1147static inline struct page_statistics show_statistics_subgoal_frames(FILE *out) {
1148 SHOW_PAGE_STATS(out, struct subgoal_frame, _pages_sg_fr,
1149 "Subgoal frames: ");
1150}
1151
1152static inline struct page_statistics
1153show_statistics_dependency_frames(FILE *out) {
1154 SHOW_PAGE_STATS(out, struct dependency_frame, _pages_dep_fr,
1155 "Dependency frames: ");
1156}
1157
1158static inline struct page_statistics
1159show_statistics_subgoal_trie_nodes(FILE *out) {
1160 SHOW_PAGE_STATS(out, struct subgoal_trie_node, _pages_sg_node,
1161 "Subgoal trie nodes: ");
1162}
1163
1164static inline struct page_statistics
1165show_statistics_subgoal_trie_hashes(FILE *out) {
1166 SHOW_PAGE_STATS(out, struct subgoal_trie_hash, _pages_sg_hash,
1167 "Subgoal trie hashes: ");
1168}
1169
1170static inline struct page_statistics
1171show_statistics_answer_trie_nodes(FILE *out) {
1172 SHOW_PAGE_STATS(out, struct answer_trie_node, _pages_ans_node,
1173 "Answer trie nodes: ");
1174}
1175
1176static inline struct page_statistics
1177show_statistics_answer_trie_hashes(FILE *out) {
1178 SHOW_PAGE_STATS(out, struct answer_trie_hash, _pages_ans_hash,
1179 "Answer trie hashes: ");
1180}
1181
1182#if defined(THREADS_FULL_SHARING)
1183static inline struct page_statistics
1184show_statistics_answer_ref_nodes(FILE *out) {
1185 SHOW_PAGE_STATS(out, struct answer_ref_node, _pages_ans_ref_node,
1186 "Answer ref nodes: ");
1187}
1188#endif /* THREADS_FULL_SHARING */
1189
1190static inline struct page_statistics
1191show_statistics_global_trie_nodes(FILE *out) {
1192 SHOW_PAGE_STATS(out, struct global_trie_node, _pages_gt_node,
1193 "Global trie nodes: ");
1194}
1195
1196static inline struct page_statistics
1197show_statistics_global_trie_hashes(FILE *out) {
1198 SHOW_PAGE_STATS(out, struct global_trie_hash, _pages_gt_hash,
1199 "Global trie hashes: ");
1200}
1201#endif /* TABLING */
1202
1203#ifdef YAPOR
1204static inline struct page_statistics show_statistics_or_frames(FILE *out) {
1205 SHOW_PAGE_STATS(out, struct or_frame, _pages_or_fr,
1206 "Or-frames: ");
1207}
1208
1209static inline struct page_statistics
1210show_statistics_query_goal_solution_frames(FILE *out) {
1211 SHOW_PAGE_STATS(out, struct query_goal_solution_frame, _pages_qg_sol_fr,
1212 "Query goal solution frames: ");
1213}
1214
1215static inline struct page_statistics
1216show_statistics_query_goal_answer_frames(FILE *out) {
1217 SHOW_PAGE_STATS(out, struct query_goal_answer_frame, _pages_qg_ans_fr,
1218 "Query goal answer frames: ");
1219}
1220#endif /* YAPOR */
1221
1222#if defined(YAPOR) && defined(TABLING)
1223static inline struct page_statistics
1224show_statistics_suspension_frames(FILE *out) {
1225 SHOW_PAGE_STATS(out, struct suspension_frame, _pages_susp_fr,
1226 "Suspension frames: ");
1227}
1228
1229#ifdef TABLING_INNER_CUTS
1230static inline struct page_statistics
1231show_statistics_table_subgoal_solution_frames(FILE *out) {
1232 SHOW_PAGE_STATS(out, struct table_subgoal_solution_frame, _pages_tg_sol_fr,
1233 "Table subgoal solution frames:");
1234}
1235
1236static inline struct page_statistics
1237show_statistics_table_subgoal_answer_frames(FILE *out) {
1238 SHOW_PAGE_STATS(out, struct table_subgoal_answer_frame, _pages_tg_ans_fr,
1239 "Table subgoal answer frames: ");
1240}
1241#endif /* TABLING_INNER_CUTS */
1242#endif /* YAPOR && TABLING */
1243#endif /* YAPOR || TABLING */
Yap.h
Main definitions.
or_frame
Definition: or.structs.h:61
query_goal_answer_frame
Definition: or.structs.h:153
query_goal_solution_frame
Definition: or.structs.h:135
answer_trie_hash
Definition: tab.structs.h:140
answer_trie_node
Definition: tab.structs.h:70
dependency_frame
Definition: tab.structs.h:381
global_trie_hash
Definition: tab.structs.h:153
global_trie_node
Definition: tab.structs.h:84
pred_entry
Definition: Yatom.h:544
subgoal_entry
Definition: tab.structs.h:240
subgoal_frame
Definition: tab.structs.h:296
subgoal_trie_hash
Definition: tab.structs.h:128
subgoal_trie_node
Definition: tab.structs.h:60
table_entry
Definition: tab.structs.h:22