diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'rtries' of git.dcc.fc.up.pt:yap-6.3

Browse Source 
Conflicts:
	OPTYap/tab.insts.i
	OPTYap/tab.tries.c
	OPTYap/tab.tries.i
This commit is contained in:
Vitor Santos Costa 2014-02-13 11:57:46 +00:00
commit d0efa26d8b
15 changed files with 1556 additions and 1031 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
C/stdpreds.c
View File

@ -1680,6 +1680,8 @@ p_access_yap_flags( USES_REGS1 )
tout = MkPairTerm(MkAtomTerm(AtomLocal), tout); tout = MkPairTerm(MkAtomTerm(AtomLocal), tout);
else if (IsMode_Batched(yap_flags[flag])) else if (IsMode_Batched(yap_flags[flag]))
tout = MkPairTerm(MkAtomTerm(AtomBatched), tout); tout = MkPairTerm(MkAtomTerm(AtomBatched), tout);
else if (IsMode_CoInductive(yap_flags[flag]))
tout = MkPairTerm(MkAtomTerm(AtomCoInductive), tout);
#else #else
tout = MkAtomTerm(AtomFalse); tout = MkAtomTerm(AtomFalse);
#endif /* TABLING */ #endif /* TABLING */
@ -1822,6 +1824,13 @@ p_set_yap_flags( USES_REGS1 )
tab_ent = TabEnt_next(tab_ent); tab_ent = TabEnt_next(tab_ent);
} }
SetMode_GlobalTrie(yap_flags[TABLING_MODE_FLAG]); SetMode_GlobalTrie(yap_flags[TABLING_MODE_FLAG]);
} else if (value == 7) { /* CoInductive */
tab_ent_ptr tab_ent = GLOBAL_root_tab_ent;
while(tab_ent) {
SetMode_CoInductive(TabEnt_mode(tab_ent));
tab_ent = TabEnt_next(tab_ent);
}
SetMode_CoInductive(yap_flags[TABLING_MODE_FLAG]);
} }
break; break;
#endif /* TABLING */ #endif /* TABLING */

1
H/iatoms.h
View File

@ -54,6 +54,7 @@
AtomColomn = Yap_LookupAtom(":"); AtomColomn = Yap_LookupAtom(":");
AtomCodeSpace = Yap_LookupAtom("code_space"); AtomCodeSpace = Yap_LookupAtom("code_space");
AtomCodes = Yap_LookupAtom("codes"); AtomCodes = Yap_LookupAtom("codes");
AtomCoInductive = Yap_LookupAtom("coinductive");
AtomComma = Yap_LookupAtom(","); AtomComma = Yap_LookupAtom(",");
AtomCommentHook = Yap_LookupAtom("comment_hook"); AtomCommentHook = Yap_LookupAtom("comment_hook");
AtomCompound = Yap_LookupAtom("compound"); AtomCompound = Yap_LookupAtom("compound");

1
H/ratoms.h
View File

@ -54,6 +54,7 @@
AtomColomn = AtomAdjust(AtomColomn); AtomColomn = AtomAdjust(AtomColomn);
AtomCodeSpace = AtomAdjust(AtomCodeSpace); AtomCodeSpace = AtomAdjust(AtomCodeSpace);
AtomCodes = AtomAdjust(AtomCodes); AtomCodes = AtomAdjust(AtomCodes);
AtomCoInductive = AtomAdjust(AtomCoInductive);
AtomComma = AtomAdjust(AtomComma); AtomComma = AtomAdjust(AtomComma);
AtomCommentHook = AtomAdjust(AtomCommentHook); AtomCommentHook = AtomAdjust(AtomCommentHook);
AtomCompound = AtomAdjust(AtomCompound); AtomCompound = AtomAdjust(AtomCompound);

2
H/tatoms.h
View File

@ -106,6 +106,8 @@
#define AtomCodeSpace Yap_heap_regs->AtomCodeSpace_ #define AtomCodeSpace Yap_heap_regs->AtomCodeSpace_
Atom AtomCodes_; Atom AtomCodes_;
#define AtomCodes Yap_heap_regs->AtomCodes_ #define AtomCodes Yap_heap_regs->AtomCodes_
Atom AtomCoInductive_;
#define AtomCoInductive Yap_heap_regs->AtomCoInductive_
Atom AtomComma_; Atom AtomComma_;
#define AtomComma Yap_heap_regs->AtomComma_ #define AtomComma Yap_heap_regs->AtomComma_
Atom AtomCommentHook_; Atom AtomCommentHook_;

110
ICLP2014_examples.yap Normal file
View File

@ -0,0 +1,110 @@
:- initialization(yap_flag(tabling_mode, load_answers)).
% Required to activate rational term support within the table space.
/*
ICLP2014 submission - instack/2
*/
instack(E, [H|T]) :- E == H.
instack(E, [_H|T]) :- instack(E, T).
/*
ICLP2014 submission - Example 1. member_1/2
Cyclic safe predicate with the use of instack/2 predicate.
*/
member_1(E, L) :-
member(E, L, []).
member(E, [E|_T], _).
member(_E, L, S) :-
instack(L, S),
!,
fail.
member(E, [H|T], S) :-
member(E, T, [[H|T]|S]).
/*
ICLP2014 submission - Example 2. member_2/2
Cyclic safe predicate with the use of tabling.
*/
:- table member_2/2.
member_2(E, [E|_T]).
member_2(E, [_H|T]) :-
member_2(E, T).
/*
ICLP2014 submission - Example 3. bin/1
*/
:- table bin/1.
:- tabling_mode(bin/1, coinductive).
% The two above directives are the equivalent of the :- coinductive bin/1 directive
bin([0|T]) :- bin(T).
bin([1|T]) :- bin(T).
/*
ICLP2014 submission - Example 4. comember/2
*/
:- table comember/2.
:- tabling_mode(comember/2, coinductive).
% The two above directives are the equivalent of the :- coinductive comember/2 directive
comember(H, L) :-
drop(H, L, L1),
comember(H, L1).
:- table(drop/3).
drop(H, [H|T], T).
drop(H, [_|T], T1) :- drop(H, T, T1).
%%%%%%%%%%
/*
ICLP2014 submission - Example 5. alternative drop_2/3 definition.
This definition uses instack instead of tabling.
*/
drop_2(E, L, NL) :-
drop(E, L, NL, []).
drop(_E, L, _NL, S) :-
instack(L, S),
!,
fail.
drop(E, [E|T], T, _).
drop(E, [H|T], T1, S) :-
drop(E, T, T1, [[H|T]|S]).
/*
ICLP2014 submission - Example 6. canonical_term/2
The following predicate takes a rational term and returns
the same rational term in canonical form.
*/
canonical_term(Term, Canonical) :-
Term =.. InList,
decompose_cyclic_term(Term, InList, OutList, OpenEnd, [Term]),
Canonical =.. OutList,
Canonical = OpenEnd.
decompose_cyclic_term(_CyclicTerm, [], [], _OpenEnd, _Stack).
decompose_cyclic_term(CyclicTerm, [Term|Tail], [Term|NewTail], OpenEnd, Stack) :-
acyclic_term(Term), !,
decompose_cyclic_term(CyclicTerm, Tail, NewTail, OpenEnd, Stack).
decompose_cyclic_term(CyclicTerm, [Term|Tail], [OpenEnd|NewTail], OpenEnd, Stack) :-
CyclicTerm == Term, !,
decompose_cyclic_term(CyclicTerm, Tail, NewTail, OpenEnd, Stack).
decompose_cyclic_term(CyclicTerm, [Term|Tail], [Canonical|NewTail], OpenEnd, Stack) :-
\+ instack(Term, Stack), !,
Term =.. InList,
decompose_cyclic_term(Term, InList, OutList, OpenEnd2, [Term|Stack]),
Canonical =.. OutList,
( Canonical = OpenEnd2,
Canonical == Term,
!
; OpenEnd2 = OpenEnd
),
decompose_cyclic_term(CyclicTerm, Tail, NewTail, OpenEnd, Stack).
decompose_cyclic_term(CyclicTerm, [_Term|Tail], [OpenEnd|NewTail], OpenEnd, Stack) :-
decompose_cyclic_term(CyclicTerm, Tail, NewTail, OpenEnd, Stack).

4
OPTYap/opt.config.h
View File

@ -148,6 +148,10 @@
**************************************************/ **************************************************/
/* #define OUTPUT_THREADS_TABLING 1 */ /* #define OUTPUT_THREADS_TABLING 1 */
/*********************************************************
** support rational terms ? (optional) **
*********************************************************/
#define TRIE_RATIONAL_TERMS 1

81
OPTYap/opt.preds.c
View File

@ -125,13 +125,13 @@ struct page_statistics {
while (pg_hd) { \ while (pg_hd) { \
aux_ptr = PgHd_first_str(pg_hd); \ aux_ptr = PgHd_first_str(pg_hd); \
while (aux_ptr) { \ while (aux_ptr) { \
cont++; \ cont++; \
aux_ptr = aux_ptr->next; \ aux_ptr = aux_ptr->next; \
} \ } \
pg_hd = PgHd_next(pg_hd); \ pg_hd = PgHd_next(pg_hd); \
} \ } \
TABLING_ERROR_CHECKING(CHECK_PAGE_FREE_STRUCTS, PgEnt_strs_free(PAGE) != cont); \ TABLING_ERROR_CHECKING(CHECK_PAGE_FREE_STRUCTS, PgEnt_strs_free(PAGE) != cont); \
} }
#else #else
#define CHECK_PAGE_FREE_STRUCTS(STR_TYPE, PAGE) #define CHECK_PAGE_FREE_STRUCTS(STR_TYPE, PAGE)
#endif /* DEBUG_TABLING */ #endif /* DEBUG_TABLING */
@ -173,7 +173,7 @@ struct page_statistics {
INCREMENT_PAGE_STATS(STATS, REMOTE##_PAGES(wid)); \ INCREMENT_PAGE_STATS(STATS, REMOTE##_PAGES(wid)); \
} \ } \
} \ } \
} \ } \
UNLOCK(GLOBAL_ThreadHandlesLock) UNLOCK(GLOBAL_ThreadHandlesLock)
#else #else
#define GET_ALL_PAGE_STATS(STATS, STR_TYPE, _PAGES) \ #define GET_ALL_PAGE_STATS(STATS, STR_TYPE, _PAGES) \
@ -185,10 +185,10 @@ struct page_statistics {
INIT_PAGE_STATS(STATS); \ INIT_PAGE_STATS(STATS); \
GET_ALL_PAGE_STATS(STATS, STR_TYPE, _PAGES); \ GET_ALL_PAGE_STATS(STATS, STR_TYPE, _PAGES); \
PgEnt_bytes_in_use(STATS) = PgEnt_strs_in_use(STATS) * sizeof(STR_TYPE) PgEnt_bytes_in_use(STATS) = PgEnt_strs_in_use(STATS) * sizeof(STR_TYPE)
#define SHOW_PAGE_STATS(OUT_STREAM, STR_TYPE, _PAGES, STR_NAME) \ #define SHOW_PAGE_STATS(OUT_STREAM, STR_TYPE, _PAGES, STR_NAME) \
{ struct page_statistics stats; \ { struct page_statistics stats; \
GET_PAGE_STATS(stats, STR_TYPE, _PAGES); \ GET_PAGE_STATS(stats, STR_TYPE, _PAGES); \
Sfprintf(OUT_STREAM, SHOW_PAGE_STATS_MSG(STR_NAME), SHOW_PAGE_STATS_ARGS(stats, STR_TYPE)); \ Sfprintf(OUT_STREAM, SHOW_PAGE_STATS_MSG(STR_NAME), SHOW_PAGE_STATS_ARGS(stats, STR_TYPE)); \
return stats; \ return stats; \
} }
@ -327,18 +327,18 @@ static Int p_table( USES_REGS1 ) {
for (i = 0; i < arity; i++) { for (i = 0; i < arity; i++) {
int mode = IntOfTerm(HeadOfTerm(list)); int mode = IntOfTerm(HeadOfTerm(list));
if (mode == MODE_DIRECTED_INDEX) if (mode == MODE_DIRECTED_INDEX)
pos_index++; pos_index++;
else if (mode == MODE_DIRECTED_MIN || mode == MODE_DIRECTED_MAX) else if (mode == MODE_DIRECTED_MIN || mode == MODE_DIRECTED_MAX)
pos_min_max++; pos_min_max++;
else if (mode == MODE_DIRECTED_ALL) else if (mode == MODE_DIRECTED_ALL)
pos_all++; pos_all++;
else if (mode == MODE_DIRECTED_SUM || mode == MODE_DIRECTED_LAST) { else if (mode == MODE_DIRECTED_SUM || mode == MODE_DIRECTED_LAST) {
if (pos_sum_last) { if (pos_sum_last) {
free(aux_mode_directed); free(aux_mode_directed);
Yap_Error(INTERNAL_COMPILER_ERROR, TermNil, "invalid tabling declaration for %s/%d (more than one argument with modes 'sum' and/or 'last')", AtomName(at), arity); Yap_Error(INTERNAL_COMPILER_ERROR, TermNil, "invalid tabling declaration for %s/%d (more than one argument with modes 'sum' and/or 'last')", AtomName(at), arity);
return(FALSE); return(FALSE);
} else } else
pos_sum_last = 1; pos_sum_last = 1;
} }
aux_mode_directed[i] = mode; aux_mode_directed[i] = mode;
list = TailOfTerm(list); list = TailOfTerm(list);
@ -352,15 +352,15 @@ static Int p_table( USES_REGS1 ) {
for (i = 0; i < arity; i++) { for (i = 0; i < arity; i++) {
int aux_pos = 0; int aux_pos = 0;
if (aux_mode_directed[i] == MODE_DIRECTED_INDEX) if (aux_mode_directed[i] == MODE_DIRECTED_INDEX)
aux_pos = pos_index++; aux_pos = pos_index++;
else if (aux_mode_directed[i] == MODE_DIRECTED_MIN || aux_mode_directed[i] == MODE_DIRECTED_MAX) else if (aux_mode_directed[i] == MODE_DIRECTED_MIN || aux_mode_directed[i] == MODE_DIRECTED_MAX)
aux_pos = pos_min_max++; aux_pos = pos_min_max++;
else if (aux_mode_directed[i] == MODE_DIRECTED_ALL) else if (aux_mode_directed[i] == MODE_DIRECTED_ALL)
aux_pos = pos_all++; aux_pos = pos_all++;
else if (aux_mode_directed[i] == MODE_DIRECTED_SUM || aux_mode_directed[i] == MODE_DIRECTED_LAST) else if (aux_mode_directed[i] == MODE_DIRECTED_SUM || aux_mode_directed[i] == MODE_DIRECTED_LAST)
aux_pos = pos_sum_last++; aux_pos = pos_sum_last++;
else if(aux_mode_directed[i] == MODE_DIRECTED_FIRST) else if(aux_mode_directed[i] == MODE_DIRECTED_FIRST)
aux_pos = pos_first++; aux_pos = pos_first++;
mode_directed[aux_pos] = MODE_DIRECTED_SET(i, aux_mode_directed[i]); mode_directed[aux_pos] = MODE_DIRECTED_SET(i, aux_mode_directed[i]);
} }
free(aux_mode_directed); free(aux_mode_directed);
@ -404,6 +404,8 @@ static Int p_tabling_mode( USES_REGS1 ) {
t = MkPairTerm(MkAtomTerm(AtomBatched), t); t = MkPairTerm(MkAtomTerm(AtomBatched), t);
else if (IsMode_Local(TabEnt_flags(tab_ent))) else if (IsMode_Local(TabEnt_flags(tab_ent)))
t = MkPairTerm(MkAtomTerm(AtomLocal), t); t = MkPairTerm(MkAtomTerm(AtomLocal), t);
if (IsMode_CoInductive(TabEnt_flags(tab_ent)))
t = MkPairTerm(MkAtomTerm(AtomCoInductive), t);
t = MkPairTerm(MkAtomTerm(AtomDefault), t); t = MkPairTerm(MkAtomTerm(AtomDefault), t);
t = MkPairTerm(t, TermNil); t = MkPairTerm(t, TermNil);
if (IsMode_LocalTrie(TabEnt_mode(tab_ent))) if (IsMode_LocalTrie(TabEnt_mode(tab_ent)))
@ -425,40 +427,43 @@ static Int p_tabling_mode( USES_REGS1 ) {
if (value == 1) { /* batched */ if (value == 1) { /* batched */
SetMode_Batched(TabEnt_flags(tab_ent)); SetMode_Batched(TabEnt_flags(tab_ent));
if (! IsMode_Local(yap_flags[TABLING_MODE_FLAG])) { if (! IsMode_Local(yap_flags[TABLING_MODE_FLAG])) {
SetMode_Batched(TabEnt_mode(tab_ent)); SetMode_Batched(TabEnt_mode(tab_ent));
return(TRUE); return(TRUE);
} }
} else if (value == 2) { /* local */ } else if (value == 2) { /* local */
SetMode_Local(TabEnt_flags(tab_ent)); SetMode_Local(TabEnt_flags(tab_ent));
if (! IsMode_Batched(yap_flags[TABLING_MODE_FLAG])) { if (! IsMode_Batched(yap_flags[TABLING_MODE_FLAG])) {
SetMode_Local(TabEnt_mode(tab_ent)); SetMode_Local(TabEnt_mode(tab_ent));
return(TRUE); return(TRUE);
} }
} else if (value == 3) { /* exec_answers */ } else if (value == 3) { /* exec_answers */
SetMode_ExecAnswers(TabEnt_flags(tab_ent)); SetMode_ExecAnswers(TabEnt_flags(tab_ent));
if (! IsMode_LoadAnswers(yap_flags[TABLING_MODE_FLAG])) { if (! IsMode_LoadAnswers(yap_flags[TABLING_MODE_FLAG])) {
SetMode_ExecAnswers(TabEnt_mode(tab_ent)); SetMode_ExecAnswers(TabEnt_mode(tab_ent));
return(TRUE); return(TRUE);
} }
} else if (value == 4) { /* load_answers */ } else if (value == 4) { /* load_answers */
SetMode_LoadAnswers(TabEnt_flags(tab_ent)); SetMode_LoadAnswers(TabEnt_flags(tab_ent));
if (! IsMode_ExecAnswers(yap_flags[TABLING_MODE_FLAG])) { if (! IsMode_ExecAnswers(yap_flags[TABLING_MODE_FLAG])) {
SetMode_LoadAnswers(TabEnt_mode(tab_ent)); SetMode_LoadAnswers(TabEnt_mode(tab_ent));
return(TRUE); return(TRUE);
} }
} else if (value == 5) { /* local_trie */ } else if (value == 5) { /* local_trie */
SetMode_LocalTrie(TabEnt_flags(tab_ent)); SetMode_LocalTrie(TabEnt_flags(tab_ent));
if (! IsMode_GlobalTrie(yap_flags[TABLING_MODE_FLAG])) { if (! IsMode_GlobalTrie(yap_flags[TABLING_MODE_FLAG])) {
SetMode_LocalTrie(TabEnt_mode(tab_ent)); SetMode_LocalTrie(TabEnt_mode(tab_ent));
return(TRUE); return(TRUE);
} }
} else if (value == 6) { /* global_trie */ } else if (value == 6) { /* global_trie */
SetMode_GlobalTrie(TabEnt_flags(tab_ent)); SetMode_GlobalTrie(TabEnt_flags(tab_ent));
if (! IsMode_LocalTrie(yap_flags[TABLING_MODE_FLAG])) { if (! IsMode_LocalTrie(yap_flags[TABLING_MODE_FLAG])) {
SetMode_GlobalTrie(TabEnt_mode(tab_ent)); SetMode_GlobalTrie(TabEnt_mode(tab_ent));
return(TRUE); return(TRUE);
} }
} } else if (value == 7) { /* coinductive */ //only affect the predicate flag. Also it cant be unset
SetMode_CoInductive(TabEnt_flags(tab_ent));
return(TRUE);
}
} }
return (FALSE); return (FALSE);
} }

168
OPTYap/tab.insts.i
View File

@ -513,29 +513,47 @@
GONext(); GONext();
#ifdef INCOMPLETE_TABLING #ifdef INCOMPLETE_TABLING
} else if (SgFr_state(sg_fr) == incomplete) { } else if (SgFr_state(sg_fr) == incomplete) {
/* subgoal incomplete --> start by loading the answers already found */ if (IsMode_CoInductive(TabEnt_flags(tab_ent))) {
ans_node_ptr ans_node = SgFr_first_answer(sg_fr); printf("Currently Unsupported\n");
CELL *subs_ptr = YENV; } else {
init_subgoal_frame(sg_fr); /* subgoal incomplete --> start by loading the answers already found */
UNLOCK_SG_FR(sg_fr); ans_node_ptr ans_node = SgFr_first_answer(sg_fr);
SgFr_try_answer(sg_fr) = ans_node; CELL *subs_ptr = YENV;
store_generator_node(tab_ent, sg_fr, PREG->u.Otapl.s, TRY_ANSWER); init_subgoal_frame(sg_fr);
PREG = (yamop *) CPREG; UNLOCK_SG_FR(sg_fr);
PREFETCH_OP(PREG); SgFr_try_answer(sg_fr) = ans_node;
load_answer(ans_node, subs_ptr); store_generator_node(tab_ent, sg_fr, PREG->u.Otapl.s, TRY_ANSWER);
YENV = ENV; PREG = (yamop *) CPREG;
GONext(); PREFETCH_OP(PREG);
load_answer(ans_node, subs_ptr);
YENV = ENV;
GONext();
}
#endif /* INCOMPLETE_TABLING */ #endif /* INCOMPLETE_TABLING */
} else if (SgFr_state(sg_fr) == evaluating) { } else if (SgFr_state(sg_fr) == evaluating) {
/* subgoal in evaluation */ if (IsMode_CoInductive(TabEnt_flags(tab_ent))) {
choiceptr leader_cp; /* Used for coinductive tabling strategy */
#if YAPOR CELL *subs_ptr;
int leader_dep_on_stack; subs_ptr = (CELL *) (GEN_CP(SgFr_gen_cp(sg_fr)) + 1);
#endif subs_ptr += SgFr_arity(sg_fr); // Points at the Parent goal Variables
find_dependency_node(sg_fr, leader_cp, leader_dep_on_stack); int i;
UNLOCK_SG_FR(sg_fr); for (i = 0; i < subs_ptr[0]; i++)
find_leader_node(leader_cp, leader_dep_on_stack); Yap_unify(subs_ptr[i+1], YENV[i+1]);
store_consumer_node(tab_ent, sg_fr, leader_cp, leader_dep_on_stack); /* yes answer --> procceed */
UNLOCK_SG_FR(sg_fr);
PREG = (yamop *) CPREG;
PREFETCH_OP(PREG);
YENV = ENV; // Consume the variables
GONext(); // Succeed the goal :-D
} else {
/* subgoal in evaluation */
choiceptr leader_cp;
int leader_dep_on_stack;
find_dependency_node(sg_fr, leader_cp, leader_dep_on_stack);
UNLOCK_SG_FR(sg_fr);
find_leader_node(leader_cp, leader_dep_on_stack);
store_consumer_node(tab_ent, sg_fr, leader_cp, leader_dep_on_stack);
}
#ifdef DEBUG_OPTYAP #ifdef DEBUG_OPTYAP
if (GLOBAL_parallel_mode == PARALLEL_MODE_RUNNING) { if (GLOBAL_parallel_mode == PARALLEL_MODE_RUNNING) {
choiceptr aux_cp; choiceptr aux_cp;
@ -655,29 +673,35 @@
GONext(); GONext();
#ifdef INCOMPLETE_TABLING #ifdef INCOMPLETE_TABLING
} else if (SgFr_state(sg_fr) == incomplete) { } else if (SgFr_state(sg_fr) == incomplete) {
/* subgoal incomplete --> start by loading the answers already found */ if (IsMode_CoInductive(TabEnt_flags(tab_ent))) {
ans_node_ptr ans_node = SgFr_first_answer(sg_fr); printf("Currently Unsupported\n");
CELL *subs_ptr = YENV; } else {
init_subgoal_frame(sg_fr); /* subgoal incomplete --> start by loading the answers already found */
UNLOCK_SG_FR(sg_fr); ans_node_ptr ans_node = SgFr_first_answer(sg_fr);
SgFr_try_answer(sg_fr) = ans_node; CELL *subs_ptr = YENV;
store_generator_node(tab_ent, sg_fr, PREG->u.Otapl.s, TRY_ANSWER); init_subgoal_frame(sg_fr);
PREG = (yamop *) CPREG; UNLOCK_SG_FR(sg_fr);
PREFETCH_OP(PREG); SgFr_try_answer(sg_fr) = ans_node;
load_answer(ans_node, subs_ptr); store_generator_node(tab_ent, sg_fr, PREG->u.Otapl.s, TRY_ANSWER);
YENV = ENV; PREG = (yamop *) CPREG;
GONext(); PREFETCH_OP(PREG);
load_answer(ans_node, subs_ptr);
YENV = ENV;
GONext();
}
#endif /* INCOMPLETE_TABLING */ #endif /* INCOMPLETE_TABLING */
} else if (SgFr_state(sg_fr) == evaluating) { } else if (SgFr_state(sg_fr) == evaluating) {
/* subgoal in evaluation */ if (IsMode_CoInductive(TabEnt_flags(tab_ent))) {
choiceptr leader_cp; printf("Currently Unsupported\n");
#if YAPOR } else {
int leader_dep_on_stack; /* subgoal in evaluation */
#endif choiceptr leader_cp;
find_dependency_node(sg_fr, leader_cp, leader_dep_on_stack); int leader_dep_on_stack;
UNLOCK_SG_FR(sg_fr); find_dependency_node(sg_fr, leader_cp, leader_dep_on_stack);
find_leader_node(leader_cp, leader_dep_on_stack); UNLOCK_SG_FR(sg_fr);
store_consumer_node(tab_ent, sg_fr, leader_cp, leader_dep_on_stack); find_leader_node(leader_cp, leader_dep_on_stack);
store_consumer_node(tab_ent, sg_fr, leader_cp, leader_dep_on_stack);
}
#ifdef DEBUG_OPTYAP #ifdef DEBUG_OPTYAP
if (GLOBAL_parallel_mode == PARALLEL_MODE_RUNNING) { if (GLOBAL_parallel_mode == PARALLEL_MODE_RUNNING) {
choiceptr aux_cp; choiceptr aux_cp;
@ -797,29 +821,47 @@
GONext(); GONext();
#ifdef INCOMPLETE_TABLING #ifdef INCOMPLETE_TABLING
} else if (SgFr_state(sg_fr) == incomplete) { } else if (SgFr_state(sg_fr) == incomplete) {
/* subgoal incomplete --> start by loading the answers already found */ if (IsMode_CoInductive(TabEnt_flags(tab_ent))) {
ans_node_ptr ans_node = SgFr_first_answer(sg_fr); printf("Currently Unsupported\n");
CELL *subs_ptr = YENV; } else {
init_subgoal_frame(sg_fr); /* subgoal incomplete --> start by loading the answers already found */
UNLOCK_SG_FR(sg_fr); ans_node_ptr ans_node = SgFr_first_answer(sg_fr);
SgFr_try_answer(sg_fr) = ans_node; CELL *subs_ptr = YENV;
store_generator_node(tab_ent, sg_fr, PREG->u.Otapl.s, TRY_ANSWER); init_subgoal_frame(sg_fr);
PREG = (yamop *) CPREG; UNLOCK_SG_FR(sg_fr);
PREFETCH_OP(PREG); SgFr_try_answer(sg_fr) = ans_node;
load_answer(ans_node, subs_ptr); store_generator_node(tab_ent, sg_fr, PREG->u.Otapl.s, TRY_ANSWER);
YENV = ENV; PREG = (yamop *) CPREG;
GONext(); PREFETCH_OP(PREG);
load_answer(ans_node, subs_ptr);
YENV = ENV;
GONext();
}
#endif /* INCOMPLETE_TABLING */ #endif /* INCOMPLETE_TABLING */
} else if (SgFr_state(sg_fr) == evaluating) { } else if (SgFr_state(sg_fr) == evaluating) {
/* subgoal in evaluation */ if (IsMode_CoInductive(TabEnt_flags(tab_ent))) {
choiceptr leader_cp; /* Used for coinductive tabling strategy */
#if YAPOR CELL *subs_ptr;
int leader_dep_on_stack; subs_ptr = (CELL *) (GEN_CP(SgFr_gen_cp(sg_fr)) + 1);
#endif subs_ptr += SgFr_arity(sg_fr); // Points at the Parent goal Variables
find_dependency_node(sg_fr, leader_cp, leader_dep_on_stack); int i;
UNLOCK_SG_FR(sg_fr); for (i = 0; i < subs_ptr[0]; i++)
find_leader_node(leader_cp, leader_dep_on_stack); Yap_unify(subs_ptr[i+1], YENV[i+1]);
store_consumer_node(tab_ent, sg_fr, leader_cp, leader_dep_on_stack); /* yes answer --> procceed */
UNLOCK_SG_FR(sg_fr);
PREG = (yamop *) CPREG;
PREFETCH_OP(PREG);
YENV = ENV; // Consume the variables
GONext(); // Succeed the goal :-D
} else {
/* subgoal in evaluation */
choiceptr leader_cp;
int leader_dep_on_stack;
find_dependency_node(sg_fr, leader_cp, leader_dep_on_stack);
UNLOCK_SG_FR(sg_fr);
find_leader_node(leader_cp, leader_dep_on_stack);
store_consumer_node(tab_ent, sg_fr, leader_cp, leader_dep_on_stack);
}
#ifdef DEBUG_OPTYAP #ifdef DEBUG_OPTYAP
if (GLOBAL_parallel_mode == PARALLEL_MODE_RUNNING) { if (GLOBAL_parallel_mode == PARALLEL_MODE_RUNNING) {
choiceptr aux_cp; choiceptr aux_cp;

3
OPTYap/tab.macros.h
View File

@ -88,6 +88,7 @@ static inline tg_sol_fr_ptr CUT_prune_tg_solution_frames(tg_sol_fr_ptr, int);
#define Flag_LocalTrie 0x100 #define Flag_LocalTrie 0x100
#define Flag_GlobalTrie 0x200 #define Flag_GlobalTrie 0x200
#define Flags_TrieMode (Flag_LocalTrie | Flag_GlobalTrie) #define Flags_TrieMode (Flag_LocalTrie | Flag_GlobalTrie)
#define Flag_CoInductive 0x008
#define SetMode_Batched(X) (X) = ((X) & ~Flags_SchedulingMode) | Flag_Batched #define SetMode_Batched(X) (X) = ((X) & ~Flags_SchedulingMode) | Flag_Batched
#define SetMode_Local(X) (X) = ((X) & ~Flags_SchedulingMode) | Flag_Local #define SetMode_Local(X) (X) = ((X) & ~Flags_SchedulingMode) | Flag_Local
@ -95,12 +96,14 @@ static inline tg_sol_fr_ptr CUT_prune_tg_solution_frames(tg_sol_fr_ptr, int);
#define SetMode_LoadAnswers(X) (X) = ((X) & ~Flags_AnswersMode) | Flag_LoadAnswers #define SetMode_LoadAnswers(X) (X) = ((X) & ~Flags_AnswersMode) | Flag_LoadAnswers
#define SetMode_LocalTrie(X) (X) = ((X) & ~Flags_TrieMode) | Flag_LocalTrie #define SetMode_LocalTrie(X) (X) = ((X) & ~Flags_TrieMode) | Flag_LocalTrie
#define SetMode_GlobalTrie(X) (X) = ((X) & ~Flags_TrieMode) | Flag_GlobalTrie #define SetMode_GlobalTrie(X) (X) = ((X) & ~Flags_TrieMode) | Flag_GlobalTrie
#define SetMode_CoInductive(X) (X) = (X) | Flag_CoInductive
#define IsMode_Batched(X) ((X) & Flag_Batched) #define IsMode_Batched(X) ((X) & Flag_Batched)
#define IsMode_Local(X) ((X) & Flag_Local) #define IsMode_Local(X) ((X) & Flag_Local)
#define IsMode_ExecAnswers(X) ((X) & Flag_ExecAnswers) #define IsMode_ExecAnswers(X) ((X) & Flag_ExecAnswers)
#define IsMode_LoadAnswers(X) ((X) & Flag_LoadAnswers) #define IsMode_LoadAnswers(X) ((X) & Flag_LoadAnswers)
#define IsMode_LocalTrie(X) ((X) & Flag_LocalTrie) #define IsMode_LocalTrie(X) ((X) & Flag_LocalTrie)
#define IsMode_GlobalTrie(X) ((X) & Flag_GlobalTrie) #define IsMode_GlobalTrie(X) ((X) & Flag_GlobalTrie)
#define IsMode_CoInductive(X) ((X) & Flag_CoInductive)

77
OPTYap/tab.rational.i Normal file
View File

@ -0,0 +1,77 @@
/************************************************************************
** **
** The YapTab/YapOr/OPTYap systems **
** **
** YapTab extends the Yap Prolog engine to support sequential tabling **
** YapOr extends the Yap Prolog engine to support or-parallelism **
** OPTYap extends the Yap Prolog engine to support or-parallel tabling **
** **
** **
** Yap Prolog was developed at University of Porto, Portugal **
** **
************************************************************************/
#define RationalMark 7 //0m0...111
#define IsRationalTerm(TERM) ((int) TERM == 7)
typedef struct term_array {
void* *terms;
void* *nodes;
size_t length;
size_t capacity;
} term_array;
void term_array_init(term_array *array, int capacity);
void term_array_free(term_array *array);
void term_array_push(term_array *array, void* t, void* n);
void* term_array_member(term_array array, void* t);
void term_array_init(term_array *array, int capacity) {
array->length = 0;
array->terms = malloc(capacity * sizeof(void*));
if (array->terms != NULL) {
array->capacity = capacity;
} else
Yap_Error(RESOURCE_ERROR_MEMORY, TermNil, "Out of memory."); // Handle out-of-memory
array->capacity = capacity;
array->nodes = malloc(capacity * sizeof(void*));
if (array->nodes == NULL)
Yap_Error(RESOURCE_ERROR_MEMORY, TermNil, "Out of memory."); // Handle out-of-memory
}
void term_array_free(term_array *array) {
free(array->terms);
free(array->nodes);
array->terms = NULL;
array->nodes = NULL;
array->length = 0;
array->capacity = 0;
}
void term_array_push(term_array *array, void* t, void* n) {
if (array->length == array->capacity) {
int new_capacity = array->capacity * 2;
void *new_terms = realloc(array->terms, new_capacity * sizeof(void*));
if (new_terms != NULL) {
array->terms = new_terms;
} else
Yap_Error(RESOURCE_ERROR_MEMORY, TermNil, "Out of memory."); // Handle out-of-memory
void *new_nodes = realloc(array->nodes, new_capacity * sizeof(void *));
if (new_nodes != NULL) {
array->nodes = new_nodes;
} else
Yap_Error(RESOURCE_ERROR_MEMORY, TermNil, "Out of memory."); // Handle out-of-memory
array->capacity = new_capacity;
}
array->terms[array->length] = t;
array->nodes[array->length] = n;
array->length++;
}
void* term_array_member(term_array array, void* t) {
int i;
for (i = 0; i < array.length; i++)
if (array.terms[i] == t) return array.nodes[i];
return NULL;
}

1502
OPTYap/tab.tries.c
View File

File diff suppressed because it is too large Load Diff

626
OPTYap/tab.tries.i
View File

@ -47,7 +47,7 @@
#else #else
#define SUBGOAL_CHECK_INSERT_ENTRY(TAB_ENT, NODE, ENTRY) \ #define SUBGOAL_CHECK_INSERT_ENTRY(TAB_ENT, NODE, ENTRY) \
NODE = subgoal_trie_check_insert_entry(TAB_ENT, NODE, ENTRY PASS_REGS) NODE = subgoal_trie_check_insert_entry(TAB_ENT, NODE, ENTRY PASS_REGS)
#define ANSWER_CHECK_INSERT_ENTRY(SG_FR, NODE, ENTRY, INSTR) \ #define ANSWER_CHECK_INSERT_ENTRY(SG_FR, NODE, ENTRY, INSTR) \
NODE = answer_trie_check_insert_entry(SG_FR, NODE, ENTRY, INSTR PASS_REGS) NODE = answer_trie_check_insert_entry(SG_FR, NODE, ENTRY, INSTR PASS_REGS)
#endif /* MODE_GLOBAL_TRIE_LOOP */ #endif /* MODE_GLOBAL_TRIE_LOOP */
@ -56,9 +56,9 @@
#define ANSWER_SAFE_INSERT_ENTRY(NODE, ENTRY, INSTR) \ #define ANSWER_SAFE_INSERT_ENTRY(NODE, ENTRY, INSTR) \
{ ans_node_ptr new_node; \ { ans_node_ptr new_node; \
NEW_ANSWER_TRIE_NODE(new_node, INSTR, ENTRY, NULL, NODE, NULL); \ NEW_ANSWER_TRIE_NODE(new_node, INSTR, ENTRY, NULL, NODE, NULL); \
TrNode_child(NODE) = new_node; \ TrNode_child(NODE) = new_node; \
NODE = new_node; \ NODE = new_node; \
} }
#ifdef THREADS #ifdef THREADS
#define INVALIDATE_ANSWER_TRIE_NODE(NODE, SG_FR) \ #define INVALIDATE_ANSWER_TRIE_NODE(NODE, SG_FR) \
TrNode_next(NODE) = SgFr_invalid_chain(SG_FR); \ TrNode_next(NODE) = SgFr_invalid_chain(SG_FR); \
@ -1048,19 +1048,26 @@ static inline sg_node_ptr subgoal_search_loop(tab_ent_ptr tab_ent, sg_node_ptr c
goto subgoal_search_loop_non_atomic; goto subgoal_search_loop_non_atomic;
#endif /* MODE_GLOBAL_TRIE_LOOP */ #endif /* MODE_GLOBAL_TRIE_LOOP */
#ifdef TRIE_RATIONAL_TERMS
/* Needed structures, variables to support rational terms */
term_array Ts;
void* CyclicTerm;
term_array_init(&Ts, 10);
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
do { do {
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
if (IsTableVarTerm(t)) { if (IsTableVarTerm(t)) {
t = MakeTableVarTerm(VarIndexOfTerm(t)); t = MakeTableVarTerm(VarIndexOfTerm(t));
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, t); SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, t);
} else { } else {
if (subs_arity == MAX_TABLE_VARS) if (subs_arity == MAX_TABLE_VARS)
Yap_Error(INTERNAL_ERROR, TermNil, "subgoal_search_loop: MAX_TABLE_VARS exceeded"); Yap_Error(INTERNAL_ERROR, TermNil, "subgoal_search_loop: MAX_TABLE_VARS exceeded");
STACK_PUSH_UP(t, stack_vars); STACK_PUSH_UP(t, stack_vars);
*((CELL *)t) = GLOBAL_table_var_enumerator(subs_arity); *((CELL *)t) = GLOBAL_table_var_enumerator(subs_arity);
t = MakeTableVarTerm(subs_arity); t = MakeTableVarTerm(subs_arity);
subs_arity = subs_arity + 1; subs_arity = subs_arity + 1;
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, t); SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, t);
} }
} else if (IsAtomOrIntTerm(t)) { } else if (IsAtomOrIntTerm(t)) {
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, t); SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, t);
@ -1075,48 +1082,103 @@ static inline sg_node_ptr subgoal_search_loop(tab_ent_ptr tab_ent, sg_node_ptr c
current_node = subgoal_trie_check_insert_gt_entry(tab_ent, current_node, (Term) entry_node PASS_REGS); current_node = subgoal_trie_check_insert_gt_entry(tab_ent, current_node, (Term) entry_node PASS_REGS);
#else /* ! MODE_TERMS_LOOP */ #else /* ! MODE_TERMS_LOOP */
} else } else
#ifdef TRIE_RATIONAL_TERMS
if (IsRationalTerm(t)) {
t = STACK_POP_DOWN(stack_terms);
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, t);
} else
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
#if defined(MODE_GLOBAL_TRIE_LOOP) #if defined(MODE_GLOBAL_TRIE_LOOP)
/* for the global trie, it is safe to start here in the first iteration */ /* for the global trie, it is safe to start here in the first iteration */
subgoal_search_loop_non_atomic: subgoal_search_loop_non_atomic:
#endif /* MODE_GLOBAL_TRIE_LOOP */ #endif /* MODE_GLOBAL_TRIE_LOOP */
#ifdef TRIE_COMPACT_PAIRS #ifdef TRIE_COMPACT_PAIRS
if (IsPairTerm(t)) { if (IsPairTerm(t)) {
#ifdef TRIE_RATIONAL_TERMS
CyclicTerm = NULL;
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
CELL *aux_pair = RepPair(t); CELL *aux_pair = RepPair(t);
if (aux_pair == PairTermMark) { if (aux_pair == PairTermMark) {
t = STACK_POP_DOWN(stack_terms); t = STACK_POP_DOWN(stack_terms);
if (IsPairTerm(t)) { #ifdef TRIE_RATIONAL_TERMS
aux_pair = RepPair(t); if (IsPairTerm(t) && ! IsRationalTerm(t)) {
t = Deref(aux_pair[1]); term_array_push(&Ts, (void *) t, (void *) current_node);
if (t == TermNil) { #else
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, CompactPairEndList); if (IsPairTerm(t)) {
} else { #endif /* RATIONAL TERM SUPPORT FOR TRIES */
/* AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + 2); */ aux_pair = RepPair(t);
/* AUX_STACK_CHECK_EXPAND is not necessary here because the situation of pushing ** t = Deref(aux_pair[1]);
** up 3 terms has already initially checked for the CompactPairInit term */ #ifdef TRIE_RATIONAL_TERMS
STACK_PUSH_UP(t, stack_terms); if (IsVarTerm(aux_pair[1]) || IsPairTerm(aux_pair[1])) {
STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms); CyclicTerm = term_array_member(Ts, (void *) t);
} }
STACK_PUSH_UP(Deref(aux_pair[0]), stack_terms); if (CyclicTerm != NULL) {
} else { STACK_PUSH_UP((Term) CyclicTerm, stack_terms);
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, CompactPairEndTerm); STACK_PUSH_UP((Term) RationalMark, stack_terms);
STACK_PUSH_UP(t, stack_terms); STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms);
} } else
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
if (t == TermNil) {
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, CompactPairEndList);
} else {
/* AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + 2); */
/* AUX_STACK_CHECK_EXPAND is not necessary here because the situation of pushing **
** up 3 terms has already initially checked for the CompactPairInit term */
STACK_PUSH_UP(t, stack_terms);
STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms);
}
#ifdef TRIE_RATIONAL_TERMS
CyclicTerm = NULL;
if (IsVarTerm(aux_pair[0]) || IsPairTerm(aux_pair[0]))
CyclicTerm = term_array_member(Ts, (void *) Deref(aux_pair[0]));
if (CyclicTerm != NULL) {
STACK_PUSH_UP((Term) CyclicTerm, stack_terms);
STACK_PUSH_UP((Term) RationalMark, stack_terms);
} else
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
STACK_PUSH_UP(Deref(aux_pair[0]), stack_terms);
} else {
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, CompactPairEndTerm);
STACK_PUSH_UP(t, stack_terms);
}
#if defined(MODE_GLOBAL_TRIE_LOOP) && defined(GLOBAL_TRIE_FOR_SUBTERMS) #if defined(MODE_GLOBAL_TRIE_LOOP) && defined(GLOBAL_TRIE_FOR_SUBTERMS)
} else if (current_node != GLOBAL_root_gt) { } else if (current_node != GLOBAL_root_gt) {
gt_node_ptr entry_node = subgoal_search_global_trie_terms_loop(t, &subs_arity, &stack_vars, stack_terms PASS_REGS); gt_node_ptr entry_node = subgoal_search_global_trie_terms_loop(t, &subs_arity, &stack_vars, stack_terms PASS_REGS);
current_node = global_trie_check_insert_gt_entry(current_node, (Term) entry_node PASS_REGS); current_node = global_trie_check_insert_gt_entry(current_node, (Term) entry_node PASS_REGS);
#endif /* MODE_GLOBAL_TRIE_LOOP && GLOBAL_TRIE_FOR_SUBTERMS */ #endif /* MODE_GLOBAL_TRIE_LOOP && GLOBAL_TRIE_FOR_SUBTERMS */
} else { } else {
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, CompactPairInit); #ifdef TRIE_RATIONAL_TERMS
t = Deref(aux_pair[1]); term_array_push(&Ts, (void *) t, (void *) current_node);
if (t == TermNil) { #endif /* RATIONAL TERM SUPPORT FOR TRIES */
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, CompactPairEndList); SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, CompactPairInit);
} else { t = Deref(aux_pair[1]);
AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + 2); #ifdef TRIE_RATIONAL_TERMS
STACK_PUSH_UP(t, stack_terms); if (IsVarTerm(aux_pair[1]) || IsPairTerm(aux_pair[1])) {
STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms); CyclicTerm = term_array_member(Ts, (void *) t);
} }
STACK_PUSH_UP(Deref(aux_pair[0]), stack_terms); if (CyclicTerm != NULL) {
STACK_PUSH_UP((Term) CyclicTerm, stack_terms);
STACK_PUSH_UP((Term) RationalMark, stack_terms);
STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms);
} else
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
if (t == TermNil) {
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, CompactPairEndList);
} else {
AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + 2);
STACK_PUSH_UP(t, stack_terms);
STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms);
}
#ifdef TRIE_RATIONAL_TERMS
CyclicTerm = NULL;
if (IsVarTerm(aux_pair[0]) || IsPairTerm(aux_pair[0]))
CyclicTerm = term_array_member(Ts, (void *) Deref(aux_pair[0]));
if (CyclicTerm != NULL) {
STACK_PUSH_UP((Term) CyclicTerm, stack_terms);
STACK_PUSH_UP((Term) RationalMark, stack_terms);
} else
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
STACK_PUSH_UP(Deref(aux_pair[0]), stack_terms);
} }
#if defined(MODE_GLOBAL_TRIE_LOOP) && defined(GLOBAL_TRIE_FOR_SUBTERMS) #if defined(MODE_GLOBAL_TRIE_LOOP) && defined(GLOBAL_TRIE_FOR_SUBTERMS)
} else if (current_node != GLOBAL_root_gt) { } else if (current_node != GLOBAL_root_gt) {
@ -1140,25 +1202,25 @@ static inline sg_node_ptr subgoal_search_loop(tab_ent_ptr tab_ent, sg_node_ptr c
} else if (IsApplTerm(t)) { } else if (IsApplTerm(t)) {
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
if (f == FunctorDouble) { if (f == FunctorDouble) {
union { union {
Term t_dbl[sizeof(Float)/sizeof(Term)]; Term t_dbl[sizeof(Float)/sizeof(Term)];
Float dbl; Float dbl;
} u; } u;
u.dbl = FloatOfTerm(t); u.dbl = FloatOfTerm(t);
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, AbsAppl((Term *)f)); SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, AbsAppl((Term *)f));
#if SIZEOF_DOUBLE == 2 * SIZEOF_INT_P #if SIZEOF_DOUBLE == 2 * SIZEOF_INT_P
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, u.t_dbl[1]); SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, u.t_dbl[1]);
#endif /* SIZEOF_DOUBLE x SIZEOF_INT_P */ #endif /* SIZEOF_DOUBLE x SIZEOF_INT_P */
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, u.t_dbl[0]); SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, u.t_dbl[0]);
#ifdef MODE_GLOBAL_TRIE_LOOP #ifdef MODE_GLOBAL_TRIE_LOOP
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, AbsAppl((Term *)f)); SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, AbsAppl((Term *)f));
#endif /* MODE_GLOBAL_TRIE_LOOP */ #endif /* MODE_GLOBAL_TRIE_LOOP */
} else if (f == FunctorLongInt) { } else if (f == FunctorLongInt) {
Int li = LongIntOfTerm(t); Int li = LongIntOfTerm(t);
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, AbsAppl((Term *)f)); SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, AbsAppl((Term *)f));
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, li); SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, li);
#ifdef MODE_GLOBAL_TRIE_LOOP #ifdef MODE_GLOBAL_TRIE_LOOP
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, AbsAppl((Term *)f)); SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, AbsAppl((Term *)f));
#endif /* MODE_GLOBAL_TRIE_LOOP */ #endif /* MODE_GLOBAL_TRIE_LOOP */
} else if (f == FunctorBigInt || f == FunctorString) { } else if (f == FunctorBigInt || f == FunctorString) {
CELL *new = Yap_HeapStoreOpaqueTerm(t); CELL *new = Yap_HeapStoreOpaqueTerm(t);
@ -1170,12 +1232,25 @@ static inline sg_node_ptr subgoal_search_loop(tab_ent_ptr tab_ent, sg_node_ptr c
} else if (f == FunctorDBRef) { } else if (f == FunctorDBRef) {
Yap_Error(INTERNAL_ERROR, TermNil, "subgoal_search_loop: unsupported type tag FunctorDBRef"); Yap_Error(INTERNAL_ERROR, TermNil, "subgoal_search_loop: unsupported type tag FunctorDBRef");
} else { } else {
int i; #ifdef TRIE_RATIONAL_TERMS
CELL *aux_appl = RepAppl(t); term_array_push(&Ts, (void *) t, (void *) current_node);
SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, AbsAppl((Term *)f)); #endif /* RATIONAL TERM SUPPORT FOR TRIES */
AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + ArityOfFunctor(f) - 1); int i;
for (i = ArityOfFunctor(f); i >= 1; i--) CELL *aux_appl = RepAppl(t);
STACK_PUSH_UP(Deref(aux_appl[i]), stack_terms); SUBGOAL_CHECK_INSERT_ENTRY(tab_ent, current_node, AbsAppl((Term *)f));
AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + ArityOfFunctor(f) - 1);
for (i = ArityOfFunctor(f); i >= 1; i--) {
#ifdef TRIE_RATIONAL_TERMS
CyclicTerm = NULL;
if (IsVarTerm(aux_appl[i]) || IsApplTerm(aux_appl[i]))
CyclicTerm = term_array_member(Ts, (void *) Deref(aux_appl[i]));
if (CyclicTerm != NULL) {
STACK_PUSH_UP((Term) CyclicTerm, stack_terms);
STACK_PUSH_UP((Term) RationalMark, stack_terms);
} else
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
STACK_PUSH_UP(Deref(aux_appl[i]), stack_terms);
}
} }
} else { } else {
Yap_Error(INTERNAL_ERROR, TermNil, "subgoal_search_loop: unknown type tag"); Yap_Error(INTERNAL_ERROR, TermNil, "subgoal_search_loop: unknown type tag");
@ -1183,7 +1258,9 @@ static inline sg_node_ptr subgoal_search_loop(tab_ent_ptr tab_ent, sg_node_ptr c
} }
t = STACK_POP_DOWN(stack_terms); t = STACK_POP_DOWN(stack_terms);
} while (t); } while (t);
#ifdef TRIE_RATIONAL_TERMS
term_array_free(&Ts);
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
*subs_arity_ptr = subs_arity; *subs_arity_ptr = subs_arity;
*stack_vars_ptr = stack_vars; *stack_vars_ptr = stack_vars;
return current_node; return current_node;
@ -1261,20 +1338,26 @@ static inline ans_node_ptr answer_search_loop(sg_fr_ptr sg_fr, ans_node_ptr curr
goto answer_search_loop_non_atomic; goto answer_search_loop_non_atomic;
#endif /* MODE_GLOBAL_TRIE_LOOP */ #endif /* MODE_GLOBAL_TRIE_LOOP */
#ifdef TRIE_RATIONAL_TERMS
term_array Ts;
void* CyclicTerm;
term_array_init(&Ts, 10);
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
do { do {
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
t = Deref(t); t = Deref(t);
if (IsTableVarTerm(t)) { if (IsTableVarTerm(t)) {
t = MakeTableVarTerm(VarIndexOfTerm(t)); t = MakeTableVarTerm(VarIndexOfTerm(t));
ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, t, _trie_retry_val + in_pair); ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, t, _trie_retry_val + in_pair);
} else { } else {
if (vars_arity == MAX_TABLE_VARS) if (vars_arity == MAX_TABLE_VARS)
Yap_Error(INTERNAL_ERROR, TermNil, "answer_search_loop: MAX_TABLE_VARS exceeded"); Yap_Error(INTERNAL_ERROR, TermNil, "answer_search_loop: MAX_TABLE_VARS exceeded");
stack_vars_base[vars_arity] = t; stack_vars_base[vars_arity] = t;
*((CELL *)t) = GLOBAL_table_var_enumerator(vars_arity); *((CELL *)t) = GLOBAL_table_var_enumerator(vars_arity);
t = MakeTableVarTerm(vars_arity); t = MakeTableVarTerm(vars_arity);
ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, t, _trie_retry_var + in_pair); ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, t, _trie_retry_var + in_pair);
vars_arity = vars_arity + 1; vars_arity = vars_arity + 1;
} }
#ifdef TRIE_COMPACT_PAIRS #ifdef TRIE_COMPACT_PAIRS
in_pair = 0; in_pair = 0;
@ -1294,52 +1377,109 @@ static inline ans_node_ptr answer_search_loop(sg_fr_ptr sg_fr, ans_node_ptr curr
#endif /* GLOBAL_TRIE_FOR_SUBTERMS */ #endif /* GLOBAL_TRIE_FOR_SUBTERMS */
current_node = answer_trie_check_insert_gt_entry(sg_fr, current_node, (Term) entry_node, _trie_retry_gterm + in_pair PASS_REGS); current_node = answer_trie_check_insert_gt_entry(sg_fr, current_node, (Term) entry_node, _trie_retry_gterm + in_pair PASS_REGS);
#else /* ! MODE_TERMS_LOOP */ #else /* ! MODE_TERMS_LOOP */
} else } else
#ifdef TRIE_RATIONAL_TERMS
if (IsRationalTerm(t)) {
t = STACK_POP_DOWN(stack_terms);
ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, t, _trie_retry_var + in_pair); //TODO create _trie_.._rational
} else
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
#if defined(MODE_GLOBAL_TRIE_LOOP) #if defined(MODE_GLOBAL_TRIE_LOOP)
/* for the global trie, it is safe to start here in the first iteration */ /* for the global trie, it is safe to start here in the first iteration */
answer_search_loop_non_atomic: answer_search_loop_non_atomic:
#endif /* MODE_GLOBAL_TRIE_LOOP */ #endif /* MODE_GLOBAL_TRIE_LOOP */
#ifdef TRIE_COMPACT_PAIRS #ifdef TRIE_COMPACT_PAIRS
if (IsPairTerm(t)) { if (IsPairTerm(t)) {
#ifdef TRIE_RATIONAL_TERMS
CyclicTerm = NULL;
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
CELL *aux_pair = RepPair(t); CELL *aux_pair = RepPair(t);
if (aux_pair == PairTermMark) { if (aux_pair == PairTermMark) {
t = STACK_POP_DOWN(stack_terms); t = STACK_POP_DOWN(stack_terms);
if (IsPairTerm(t)) { #ifdef TRIE_RATIONAL_TERMS
aux_pair = RepPair(t); if (IsPairTerm(t) && ! IsRationalTerm(t)) {
t = Deref(aux_pair[1]); term_array_push(&Ts, (void *) t, (void *) current_node);
if (t == TermNil) { #else
ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, CompactPairEndList, _trie_retry_pair); if (IsPairTerm(t)) {
} else { #endif /* RATIONAL TERM SUPPORT FOR TRIES */
/* AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + 2); */ aux_pair = RepPair(t);
/* AUX_STACK_CHECK_EXPAND is not necessary here because the situation of pushing ** t = Deref(aux_pair[1]);
** up 3 terms has already initially checked for the CompactPairInit term */ #ifdef TRIE_RATIONAL_TERMS
STACK_PUSH_UP(t, stack_terms); if (IsVarTerm(aux_pair[1]) || IsPairTerm(aux_pair[1])) {
STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms); CyclicTerm = term_array_member(Ts, (void *) t);
in_pair = 4; }
} if (CyclicTerm != NULL) {
STACK_PUSH_UP(Deref(aux_pair[0]), stack_terms); STACK_PUSH_UP((Term) CyclicTerm, stack_terms); // CyclicTerm
} else { STACK_PUSH_UP((Term) RationalMark, stack_terms);
ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, CompactPairEndTerm, _trie_retry_null); STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms);
STACK_PUSH_UP(t, stack_terms); in_pair = 4;
} } else
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
if (t == TermNil) {
ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, CompactPairEndList, _trie_retry_pair);
} else {
/* AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + 2); */
/* AUX_STACK_CHECK_EXPAND is not necessary here because the situation of pushing **
** up 3 terms has already initially checked for the CompactPairInit term */
STACK_PUSH_UP(t, stack_terms);
STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms);
in_pair = 4;
}
#ifdef TRIE_RATIONAL_TERMS
CyclicTerm = NULL;
if (IsVarTerm(aux_pair[0]) || IsPairTerm(aux_pair[0]))
CyclicTerm = term_array_member(Ts, (void *) Deref(aux_pair[0]));
if (CyclicTerm != NULL) {
STACK_PUSH_UP((Term) CyclicTerm, stack_terms);
STACK_PUSH_UP((Term) RationalMark, stack_terms);
} else
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
STACK_PUSH_UP(Deref(aux_pair[0]), stack_terms);
} else {
ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, CompactPairEndTerm, _trie_retry_null);
STACK_PUSH_UP(t, stack_terms);
}
#if defined(MODE_GLOBAL_TRIE_LOOP) && defined(GLOBAL_TRIE_FOR_SUBTERMS) #if defined(MODE_GLOBAL_TRIE_LOOP) && defined(GLOBAL_TRIE_FOR_SUBTERMS)
} else if (current_node != GLOBAL_root_gt) { } else if (current_node != GLOBAL_root_gt) {
gt_node_ptr entry_node = answer_search_global_trie_terms_loop(t, &vars_arity, stack_terms PASS_REGS); gt_node_ptr entry_node = answer_search_global_trie_terms_loop(t, &vars_arity, stack_terms PASS_REGS);
current_node = global_trie_check_insert_gt_entry(current_node, (Term) entry_node PASS_REGS); current_node = global_trie_check_insert_gt_entry(current_node, (Term) entry_node PASS_REGS);
#endif /* MODE_GLOBAL_TRIE_LOOP && GLOBAL_TRIE_FOR_SUBTERMS */ #endif /* MODE_GLOBAL_TRIE_LOOP && GLOBAL_TRIE_FOR_SUBTERMS */
} else { } else {
ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, CompactPairInit, _trie_retry_null + in_pair); #ifdef TRIE_RATIONAL_TERMS
t = Deref(aux_pair[1]); term_array_push(&Ts, (void *) t, (void *) current_node);
if (t == TermNil) { #endif /* RATIONAL TERM SUPPORT FOR TRIES */
ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, CompactPairEndList, _trie_retry_pair); ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, CompactPairInit, _trie_retry_null + in_pair);
in_pair = 0; t = Deref(aux_pair[1]);
} else { #ifdef TRIE_RATIONAL_TERMS
AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + 2); if (IsVarTerm(aux_pair[1]) || IsPairTerm(aux_pair[1])) {
STACK_PUSH_UP(t, stack_terms); CyclicTerm = term_array_member(Ts, (void *) t);
STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms); }
in_pair = 4; if (CyclicTerm != NULL) {
} STACK_PUSH_UP((Term) CyclicTerm, stack_terms);
STACK_PUSH_UP(Deref(aux_pair[0]), stack_terms); STACK_PUSH_UP((Term) RationalMark, stack_terms);
STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms);
in_pair = 4;
} else
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
if (t == TermNil) {
ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, CompactPairEndList, _trie_retry_pair);
in_pair = 0;
} else {
AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + 2);
STACK_PUSH_UP(t, stack_terms);
STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms);
in_pair = 4;
}
#ifdef TRIE_RATIONAL_TERMS
CyclicTerm = NULL;
if (IsVarTerm(aux_pair[0]) || IsPairTerm(aux_pair[0]))
CyclicTerm = term_array_member(Ts, (void *) Deref(aux_pair[0]));
if (CyclicTerm != NULL) {
STACK_PUSH_UP((Term) CyclicTerm, stack_terms);
STACK_PUSH_UP((Term) RationalMark, stack_terms);
} else
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
STACK_PUSH_UP(Deref(aux_pair[0]), stack_terms);
} }
#if defined(MODE_GLOBAL_TRIE_LOOP) && defined(GLOBAL_TRIE_FOR_SUBTERMS) #if defined(MODE_GLOBAL_TRIE_LOOP) && defined(GLOBAL_TRIE_FOR_SUBTERMS)
} else if (current_node != GLOBAL_root_gt) { } else if (current_node != GLOBAL_root_gt) {
@ -1363,17 +1503,17 @@ static inline ans_node_ptr answer_search_loop(sg_fr_ptr sg_fr, ans_node_ptr curr
} else if (IsApplTerm(t)) { } else if (IsApplTerm(t)) {
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
if (f == FunctorDouble) { if (f == FunctorDouble) {
union { union {
Term t_dbl[sizeof(Float)/sizeof(Term)]; Term t_dbl[sizeof(Float)/sizeof(Term)];
Float dbl; Float dbl;
} u; } u;
u.dbl = FloatOfTerm(t); u.dbl = FloatOfTerm(t);
ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, AbsAppl((Term *)f), _trie_retry_null + in_pair); ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, AbsAppl((Term *)f), _trie_retry_null + in_pair);
#if SIZEOF_DOUBLE == 2 * SIZEOF_INT_P #if SIZEOF_DOUBLE == 2 * SIZEOF_INT_P
ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, u.t_dbl[1], _trie_retry_extension); ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, u.t_dbl[1], _trie_retry_extension);
#endif /* SIZEOF_DOUBLE x SIZEOF_INT_P */ #endif /* SIZEOF_DOUBLE x SIZEOF_INT_P */
ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, u.t_dbl[0], _trie_retry_extension); ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, u.t_dbl[0], _trie_retry_extension);
ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, AbsAppl((Term *)f), _trie_retry_double); ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, AbsAppl((Term *)f), _trie_retry_double);
} else if (f == FunctorLongInt) { } else if (f == FunctorLongInt) {
Int li = LongIntOfTerm (t); Int li = LongIntOfTerm (t);
ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, AbsAppl((Term *)f), _trie_retry_null + in_pair); ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, AbsAppl((Term *)f), _trie_retry_null + in_pair);
@ -1387,12 +1527,25 @@ static inline ans_node_ptr answer_search_loop(sg_fr_ptr sg_fr, ans_node_ptr curr
} else if (f == FunctorDBRef) { } else if (f == FunctorDBRef) {
Yap_Error(INTERNAL_ERROR, TermNil, "answer_search_loop: unsupported type tag FunctorDBRef"); Yap_Error(INTERNAL_ERROR, TermNil, "answer_search_loop: unsupported type tag FunctorDBRef");
} else { } else {
int i; #ifdef TRIE_RATIONAL_TERMS
CELL *aux_appl = RepAppl(t); term_array_push(&Ts, (void *) t, (void *) current_node);
ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, AbsAppl((Term *)f), _trie_retry_appl + in_pair); #endif /* RATIONAL TERM SUPPORT FOR TRIES */
AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + ArityOfFunctor(f) - 1); int i;
for (i = ArityOfFunctor(f); i >= 1; i--) CELL *aux_appl = RepAppl(t);
STACK_PUSH_UP(Deref(aux_appl[i]), stack_terms); ANSWER_CHECK_INSERT_ENTRY(sg_fr, current_node, AbsAppl((Term *)f), _trie_retry_appl + in_pair);
AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + ArityOfFunctor(f) - 1);
for (i = ArityOfFunctor(f); i >= 1; i--) {
#ifdef TRIE_RATIONAL_TERMS
CyclicTerm = NULL;
if (IsVarTerm(aux_appl[i]) || IsApplTerm(aux_appl[i]))
CyclicTerm = term_array_member(Ts, (void *) Deref(aux_appl[i]));
if (CyclicTerm != NULL) {
STACK_PUSH_UP((Term) CyclicTerm, stack_terms);
STACK_PUSH_UP((Term) RationalMark, stack_terms);
} else
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
STACK_PUSH_UP(Deref(aux_appl[i]), stack_terms);
}
} }
#ifdef TRIE_COMPACT_PAIRS #ifdef TRIE_COMPACT_PAIRS
in_pair = 0; in_pair = 0;
@ -1403,7 +1556,9 @@ static inline ans_node_ptr answer_search_loop(sg_fr_ptr sg_fr, ans_node_ptr curr
} }
t = STACK_POP_DOWN(stack_terms); t = STACK_POP_DOWN(stack_terms);
} while (t); } while (t);
#ifdef TRIE_RATIONAL_TERMS
term_array_free(&Ts);
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
*vars_arity_ptr = vars_arity; *vars_arity_ptr = vars_arity;
return current_node; return current_node;
@ -1439,8 +1594,8 @@ static inline ans_node_ptr answer_search_min_max(sg_fr_ptr sg_fr, ans_node_ptr c
trie_value = MkLongIntTerm( (Int) TrNode_entry(child_node) ); trie_value = MkLongIntTerm( (Int) TrNode_entry(child_node) );
} else if (f == FunctorDouble) { } else if (f == FunctorDouble) {
union { union {
Term t_dbl[sizeof(Float)/sizeof(Term)]; Term t_dbl[sizeof(Float)/sizeof(Term)];
Float dbl; Float dbl;
} u; } u;
u.t_dbl[0] = TrNode_entry(child_node); u.t_dbl[0] = TrNode_entry(child_node);
#if SIZEOF_DOUBLE == 2 * SIZEOF_INT_P #if SIZEOF_DOUBLE == 2 * SIZEOF_INT_P
@ -1469,8 +1624,8 @@ static inline ans_node_ptr answer_search_min_max(sg_fr_ptr sg_fr, ans_node_ptr c
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
if (f == FunctorDouble) { if (f == FunctorDouble) {
union { union {
Term t_dbl[sizeof(Float)/sizeof(Term)]; Term t_dbl[sizeof(Float)/sizeof(Term)];
Float dbl; Float dbl;
} u; } u;
u.dbl = FloatOfTerm(t); u.dbl = FloatOfTerm(t);
ANSWER_SAFE_INSERT_ENTRY(current_node, AbsAppl((Term *)f), _trie_retry_null); ANSWER_SAFE_INSERT_ENTRY(current_node, AbsAppl((Term *)f), _trie_retry_null);
@ -1519,8 +1674,8 @@ static inline ans_node_ptr answer_search_sum(sg_fr_ptr sg_fr, ans_node_ptr curre
trie_value = MkLongIntTerm( (Int) TrNode_entry(child_node) ); trie_value = MkLongIntTerm( (Int) TrNode_entry(child_node) );
} else if (f == FunctorDouble) { } else if (f == FunctorDouble) {
union { union {
Term t_dbl[sizeof(Float)/sizeof(Term)]; Term t_dbl[sizeof(Float)/sizeof(Term)];
Float dbl; Float dbl;
} u; } u;
u.t_dbl[0] = TrNode_entry(child_node); u.t_dbl[0] = TrNode_entry(child_node);
#if SIZEOF_DOUBLE == 2 * SIZEOF_INT_P #if SIZEOF_DOUBLE == 2 * SIZEOF_INT_P
@ -1585,18 +1740,18 @@ static void invalidate_answer_trie(ans_node_ptr current_node, sg_fr_ptr sg_fr, i
do { do {
current_node = *bucket; current_node = *bucket;
if (current_node) { if (current_node) {
ans_node_ptr next_node = TrNode_next(current_node); ans_node_ptr next_node = TrNode_next(current_node);
if (IS_ANSWER_LEAF_NODE(current_node)) { if (IS_ANSWER_LEAF_NODE(current_node)) {
INVALIDATE_ANSWER_TRIE_LEAF_NODE(current_node, sg_fr); INVALIDATE_ANSWER_TRIE_LEAF_NODE(current_node, sg_fr);
} else { } else {
invalidate_answer_trie(TrNode_child(current_node), sg_fr, TRAVERSE_POSITION_FIRST PASS_REGS); invalidate_answer_trie(TrNode_child(current_node), sg_fr, TRAVERSE_POSITION_FIRST PASS_REGS);
INVALIDATE_ANSWER_TRIE_NODE(current_node, sg_fr); INVALIDATE_ANSWER_TRIE_NODE(current_node, sg_fr);
} }
while (next_node) { while (next_node) {
current_node = next_node; current_node = next_node;
next_node = TrNode_next(current_node); next_node = TrNode_next(current_node);
invalidate_answer_trie(current_node, sg_fr, TRAVERSE_POSITION_NEXT PASS_REGS); invalidate_answer_trie(current_node, sg_fr, TRAVERSE_POSITION_NEXT PASS_REGS);
} }
} }
} while (++bucket != last_bucket); } while (++bucket != last_bucket);
if (Hash_next(hash)) if (Hash_next(hash))
@ -1611,22 +1766,22 @@ static void invalidate_answer_trie(ans_node_ptr current_node, sg_fr_ptr sg_fr, i
if (position == TRAVERSE_POSITION_FIRST) { if (position == TRAVERSE_POSITION_FIRST) {
ans_node_ptr next_node = TrNode_next(current_node); ans_node_ptr next_node = TrNode_next(current_node);
if (IS_ANSWER_LEAF_NODE(current_node)) { if (IS_ANSWER_LEAF_NODE(current_node)) {
INVALIDATE_ANSWER_TRIE_LEAF_NODE(current_node, sg_fr); INVALIDATE_ANSWER_TRIE_LEAF_NODE(current_node, sg_fr);
} else { } else {
invalidate_answer_trie(TrNode_child(current_node), sg_fr, TRAVERSE_POSITION_FIRST PASS_REGS); invalidate_answer_trie(TrNode_child(current_node), sg_fr, TRAVERSE_POSITION_FIRST PASS_REGS);
INVALIDATE_ANSWER_TRIE_NODE(current_node, sg_fr); INVALIDATE_ANSWER_TRIE_NODE(current_node, sg_fr);
} }
while (next_node) { while (next_node) {
current_node = next_node; current_node = next_node;
next_node = TrNode_next(current_node); next_node = TrNode_next(current_node);
invalidate_answer_trie(current_node, sg_fr, TRAVERSE_POSITION_NEXT PASS_REGS); invalidate_answer_trie(current_node, sg_fr, TRAVERSE_POSITION_NEXT PASS_REGS);
} }
} else { } else {
if (IS_ANSWER_LEAF_NODE(current_node)) { if (IS_ANSWER_LEAF_NODE(current_node)) {
INVALIDATE_ANSWER_TRIE_LEAF_NODE(current_node, sg_fr); INVALIDATE_ANSWER_TRIE_LEAF_NODE(current_node, sg_fr);
} else { } else {
invalidate_answer_trie(TrNode_child(current_node), sg_fr, TRAVERSE_POSITION_FIRST PASS_REGS); invalidate_answer_trie(TrNode_child(current_node), sg_fr, TRAVERSE_POSITION_FIRST PASS_REGS);
INVALIDATE_ANSWER_TRIE_NODE(current_node, sg_fr); INVALIDATE_ANSWER_TRIE_NODE(current_node, sg_fr);
} }
} }
} }
@ -1692,47 +1847,115 @@ static inline CELL *load_answer_loop(ans_node_ptr current_node USES_REGS) {
current_node = (ans_node_ptr) UNTAG_ANSWER_NODE(TrNode_parent(current_node)); current_node = (ans_node_ptr) UNTAG_ANSWER_NODE(TrNode_parent(current_node));
#endif /* MODE_GLOBAL_TRIE_LOOP */ #endif /* MODE_GLOBAL_TRIE_LOOP */
#ifdef TRIE_RATIONAL_TERMS
term_array Ts;
void* CyclicTerm;
term_array_init(&Ts, 10);
Term RationalTermTMP; // a temporary temp to be used from the rational code
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
do { do {
#ifdef TRIE_RATIONAL_TERMS
CyclicTerm = term_array_member(Ts, (void *) current_node);
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
#ifdef TRIE_RATIONAL_TERMS
if (t > VarIndexOfTableTerm(MAX_TABLE_VARS) && TrNode_child((gt_node_ptr) t) != (gt_node_ptr)(1)) { //TODO: substitute the != 1 test to something more appropriate
/* Rational term */
RationalTermTMP = (Term) term_array_member(Ts, (void *) t);
if (RationalTermTMP) {
/* rational term is assigned a variable already */
AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit);
STACK_PUSH_UP(RationalTermTMP, stack_terms);
} else {
RationalTermTMP = MkVarTerm();
STACK_PUSH_UP(RationalTermTMP, stack_terms);
/* memorize the rational term and assign it a variable */
term_array_push(&Ts, (void *) t, (void *) RationalTermTMP);
}
} else
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
{
#if ! defined(MODE_GLOBAL_TRIE_LOOP) || defined(GLOBAL_TRIE_FOR_SUBTERMS) #if ! defined(MODE_GLOBAL_TRIE_LOOP) || defined(GLOBAL_TRIE_FOR_SUBTERMS)
if (t > VarIndexOfTableTerm(MAX_TABLE_VARS)) { if (t > VarIndexOfTableTerm(MAX_TABLE_VARS)) {
stack_terms = load_substitution_loop((gt_node_ptr) t, &vars_arity, stack_terms PASS_REGS); stack_terms = load_substitution_loop((gt_node_ptr) t, &vars_arity, stack_terms PASS_REGS);
} else } else
#endif /* ! MODE_GLOBAL_TRIE_LOOP || GLOBAL_TRIE_FOR_SUBTERMS */ #endif /* ! MODE_GLOBAL_TRIE_LOOP || GLOBAL_TRIE_FOR_SUBTERMS */
{ int var_index = VarIndexOfTableTerm(t); { int var_index = VarIndexOfTableTerm(t);
AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit - vars_arity + var_index + 1); AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit - vars_arity + var_index + 1);
if (var_index >= vars_arity) { if (var_index >= vars_arity) {
while (vars_arity < var_index) while (vars_arity < var_index)
stack_vars_base[vars_arity++] = 0; stack_vars_base[vars_arity++] = 0;
stack_vars_base[vars_arity++] = MkVarTerm(); stack_vars_base[vars_arity++] = MkVarTerm();
} else if (stack_vars_base[var_index] == 0) } else if (stack_vars_base[var_index] == 0)
stack_vars_base[var_index] = MkVarTerm(); stack_vars_base[var_index] = MkVarTerm();
STACK_PUSH_UP(stack_vars_base[var_index], stack_terms); STACK_PUSH_UP(stack_vars_base[var_index], stack_terms);
}
} }
} else if (IsAtomOrIntTerm(t)) { } else if (IsAtomOrIntTerm(t)) {
AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit); AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit);
#ifdef TRIE_RATIONAL_TERMS
if (CyclicTerm) {
AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + 4);
STACK_PUSH_UP((Term) RationalMark, stack_terms); // Add a rational term marker necessary as we read both ways the stack //
STACK_PUSH_UP(t, stack_terms); // Add the term //
STACK_PUSH_UP(CyclicTerm, stack_terms); // Add the variable that the term will unify with //
STACK_PUSH_UP((Term) RationalMark, stack_terms); // Add a rational term marker necessary as we read both ways the stack //
} else
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
STACK_PUSH_UP(t, stack_terms); STACK_PUSH_UP(t, stack_terms);
} else if (IsPairTerm(t)) { } else if (IsPairTerm(t)) {
#ifdef TRIE_COMPACT_PAIRS #ifdef TRIE_COMPACT_PAIRS
if (t == CompactPairInit) { if (t == CompactPairInit) {
Term *stack_aux = stack_terms_base - stack_terms_pair_offset; Term *stack_aux = stack_terms_base - stack_terms_pair_offset;
Term head, tail = STACK_POP_UP(stack_aux); Term head, tail = STACK_POP_UP(stack_aux);
while (STACK_NOT_EMPTY(stack_aux, stack_terms)) { #ifdef TRIE_RATIONAL_TERMS
head = STACK_POP_UP(stack_aux); if (IsRationalTerm(tail)) {
tail = MkPairTerm(head, tail); Yap_Error(INTERNAL_ERROR, tail, "Rational element of a Rational Term appears as the first Tail of a list");
} }
stack_terms = stack_terms_base - stack_terms_pair_offset; #endif /* RATIONAL TERM SUPPORT FOR TRIES */
stack_terms_pair_offset = (int) STACK_POP_DOWN(stack_terms); while (STACK_NOT_EMPTY(stack_aux, stack_terms)) {
STACK_PUSH_UP(tail, stack_terms); head = STACK_POP_UP(stack_aux);
#ifdef TRIE_RATIONAL_TERMS
if (IsRationalTerm(head)) {
head = STACK_POP_UP(stack_aux); // thats the rational term
RationalTermTMP = STACK_POP_UP(stack_aux); // that is the variable to unify with
(void) STACK_POP_UP(stack_aux); // eat the second rational mark
tail = MkPairTerm(head, tail);
Yap_unify(RationalTermTMP, tail);
} else
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
tail = MkPairTerm(head, tail);
}
stack_terms = stack_terms_base - stack_terms_pair_offset;
stack_terms_pair_offset = (int) STACK_POP_DOWN(stack_terms);
STACK_PUSH_UP(tail, stack_terms);
} else { /* CompactPairEndList / CompactPairEndTerm */ } else { /* CompactPairEndList / CompactPairEndTerm */
Term last; Term last;
AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + 1); AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + 1);
last = STACK_POP_DOWN(stack_terms); last = STACK_POP_DOWN(stack_terms);
STACK_PUSH_UP(stack_terms_pair_offset, stack_terms); #ifdef TRIE_RATIONAL_TERMS
stack_terms_pair_offset = (int) (stack_terms_base - stack_terms); RationalTermTMP = TermNil;
if (t == CompactPairEndList) if (IsRationalTerm(last)) { // rather unlikely case the rational term is the last of a list
STACK_PUSH_UP(TermNil, stack_terms); RationalTermTMP = STACK_POP_DOWN(stack_terms); // in this case we need to invert the term with the end of list
STACK_PUSH_UP(last, stack_terms); last = STACK_POP_DOWN(stack_terms); // variable to unify with
(void) STACK_POP_DOWN(stack_terms); // eat the second rational mark
}
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
STACK_PUSH_UP(stack_terms_pair_offset, stack_terms);
stack_terms_pair_offset = (int) (stack_terms_base - stack_terms);
if (t == CompactPairEndList)
STACK_PUSH_UP(TermNil, stack_terms);
#ifdef TRIE_RATIONAL_TERMS
if (RationalTermTMP && RationalTermTMP != TermNil) {
/* most probably this never occurs */
STACK_PUSH_UP((Term) RationalMark, stack_terms);
STACK_PUSH_UP(last, stack_terms);
STACK_PUSH_UP(RationalTermTMP, stack_terms);
STACK_PUSH_UP((Term) RationalMark, stack_terms);
} else
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
STACK_PUSH_UP(last, stack_terms);
} }
#else /* ! TRIE_COMPACT_PAIRS */ #else /* ! TRIE_COMPACT_PAIRS */
Term head = STACK_POP_DOWN(stack_terms); Term head = STACK_POP_DOWN(stack_terms);
@ -1743,20 +1966,20 @@ static inline CELL *load_answer_loop(ans_node_ptr current_node USES_REGS) {
} else if (IsApplTerm(t)) { } else if (IsApplTerm(t)) {
Functor f = (Functor) RepAppl(t); Functor f = (Functor) RepAppl(t);
if (f == FunctorDouble) { if (f == FunctorDouble) {
union { union {
Term t_dbl[sizeof(Float)/sizeof(Term)]; Term t_dbl[sizeof(Float)/sizeof(Term)];
Float dbl; Float dbl;
} u; } u;
t = TrNode_entry(current_node); t = TrNode_entry(current_node);
current_node = TrNode_parent(current_node); current_node = TrNode_parent(current_node);
u.t_dbl[0] = t; u.t_dbl[0] = t;
#if SIZEOF_DOUBLE == 2 * SIZEOF_INT_P #if SIZEOF_DOUBLE == 2 * SIZEOF_INT_P
t = TrNode_entry(current_node); t = TrNode_entry(current_node);
current_node = TrNode_parent(current_node); current_node = TrNode_parent(current_node);
u.t_dbl[1] = t; u.t_dbl[1] = t;
#endif /* SIZEOF_DOUBLE x SIZEOF_INT_P */ #endif /* SIZEOF_DOUBLE x SIZEOF_INT_P */
current_node = TrNode_parent(current_node); current_node = TrNode_parent(current_node);
t = MkFloatTerm(u.dbl); t = MkFloatTerm(u.dbl);
} else if (f == FunctorLongInt) { } else if (f == FunctorLongInt) {
Int li = TrNode_entry(current_node); Int li = TrNode_entry(current_node);
current_node = TrNode_parent(current_node); current_node = TrNode_parent(current_node);
@ -1768,17 +1991,34 @@ static inline CELL *load_answer_loop(ans_node_ptr current_node USES_REGS) {
current_node = TrNode_parent(current_node); current_node = TrNode_parent(current_node);
t = AbsAppl( ptr ); t = AbsAppl( ptr );
} else { } else {
int f_arity = ArityOfFunctor(f); int f_arity = ArityOfFunctor(f);
t = Yap_MkApplTerm(f, f_arity, stack_terms); t = Yap_MkApplTerm(f, f_arity, stack_terms);
stack_terms += f_arity; stack_terms += f_arity;
} }
AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit); AUX_STACK_CHECK_EXPAND(stack_terms, stack_terms_limit);
STACK_PUSH_UP(t, stack_terms); STACK_PUSH_UP(t, stack_terms);
} }
#ifdef TRIE_RATIONAL_TERMS
if (CyclicTerm) {
RationalTermTMP = STACK_POP_DOWN(stack_terms);
if IsRationalTerm(RationalTermTMP) {
//printf("Special Case\n");
} else if (IsPairTerm(RationalTermTMP)) {
Yap_unify((Term) CyclicTerm, RationalTermTMP);
} else if (IsApplTerm(RationalTermTMP)) {
Yap_unify((Term) CyclicTerm, RationalTermTMP);
}
STACK_PUSH_UP(RationalTermTMP, stack_terms);
}
RationalTermTMP = TermNil;
CyclicTerm = NULL;
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
t = TrNode_entry(current_node); t = TrNode_entry(current_node);
current_node = TrNode_parent(current_node); current_node = TrNode_parent(current_node);
} while (current_node); } while (current_node);
#ifdef TRIE_RATIONAL_TERMS
term_array_free(&Ts);
#endif /* RATIONAL TERM SUPPORT FOR TRIES */
#ifdef MODE_GLOBAL_TRIE_LOOP #ifdef MODE_GLOBAL_TRIE_LOOP
*vars_arity_ptr = vars_arity; *vars_arity_ptr = vars_arity;
#endif /* MODE_GLOBAL_TRIE_LOOP */ #endif /* MODE_GLOBAL_TRIE_LOOP */

1
misc/ATOMS
View File

@ -59,6 +59,7 @@ A CleanCall F "$clean_call"
A Colomn N ":" A Colomn N ":"
A CodeSpace N "code_space" A CodeSpace N "code_space"
A Codes N "codes" A Codes N "codes"
A CoInductive N "coinductive"
A Comma N "," A Comma N ","
A CommentHook N "comment_hook" A CommentHook N "comment_hook"
A Compound N "compound" A Compound N "compound"

1
pl/flags.yap
View File

@ -185,6 +185,7 @@ yap_flag(tabling_mode,Options) :-
'$transl_to_yap_flag_tabling_mode'(4,load_answers). '$transl_to_yap_flag_tabling_mode'(4,load_answers).
'$transl_to_yap_flag_tabling_mode'(5,local_trie). '$transl_to_yap_flag_tabling_mode'(5,local_trie).
'$transl_to_yap_flag_tabling_mode'(6,global_trie). '$transl_to_yap_flag_tabling_mode'(6,global_trie).
'$transl_to_yap_flag_tabling_mode'(7,coinductive).
yap_flag(informational_messages,X) :- var(X), !, yap_flag(informational_messages,X) :- var(X), !,
yap_flag(verbose, X). yap_flag(verbose, X).

1
pl/tabling.yap
View File

@ -250,6 +250,7 @@ tabling_mode(Pred,Options) :-
'$transl_to_pred_flag_tabling_mode'(4,load_answers). '$transl_to_pred_flag_tabling_mode'(4,load_answers).
'$transl_to_pred_flag_tabling_mode'(5,local_trie). '$transl_to_pred_flag_tabling_mode'(5,local_trie).
'$transl_to_pred_flag_tabling_mode'(6,global_trie). '$transl_to_pred_flag_tabling_mode'(6,global_trie).
'$transl_to_pred_flag_tabling_mode'(7,coinductive).