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

Merge branch 'master' of gitosis@yap.dcc.fc.up.pt:yap-6

Browse Source
This commit is contained in:
Costa Vitor 2009-08-12 10:01:34 -05:00
commit 40ea33c150
15 changed files with 769 additions and 670 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
C/absmi.c
View File

@ -1878,7 +1878,12 @@ Yap_absmi(int inp)
case _table_retry: case _table_retry:
case _table_trust: case _table_trust:
case _table_completion: case _table_completion:
low_level_trace(retry_table_generator, GEN_CP(B)->cp_pred_entry, (CELL *)(GEN_CP(B) + 1)); #ifdef DETERMINISTIC_TABLING
if (IS_DET_GEN_CP(B))
low_level_trace(retry_table_generator, DET_GEN_CP(B)->cp_pred_entry, NULL);
else
#endif /* DETERMINISTIC_TABLING */
low_level_trace(retry_table_generator, GEN_CP(B)->cp_pred_entry, (CELL *)(GEN_CP(B) + 1));
break; break;
case _table_answer_resolution: case _table_answer_resolution:
low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry, NULL); low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry, NULL);

12
C/cdmgr.c
View File

@ -5420,8 +5420,16 @@ p_choicepoint_info(void)
case _table_trust: case _table_trust:
case _table_completion: case _table_completion:
#ifdef LOW_LEVEL_TRACER #ifdef LOW_LEVEL_TRACER
pe = GEN_CP(cptr)->cp_pred_entry; #ifdef DETERMINISTIC_TABLING
t = BuildActivePred(pe, (CELL *)(GEN_CP(B) + 1)); if (IS_DET_GEN_CP(cptr)) {
pe = DET_GEN_CP(cptr)->cp_pred_entry;
t = MkVarTerm();
} else
#endif /* DETERMINISTIC_TABLING */
{
pe = GEN_CP(cptr)->cp_pred_entry;
t = BuildActivePred(pe, (CELL *)(GEN_CP(B) + 1));
}
#else #else
pe = UndefCode; pe = UndefCode;
t = MkVarTerm(); t = MkVarTerm();

1
C/gprof.c
View File

@ -52,6 +52,7 @@ static char SccsId[] = "%W% %G%";
#endif #endif
#include "absmi.h" #include "absmi.h"
#include <stdio.h>
#if HAVE_STRING_H #if HAVE_STRING_H
#include <string.h> #include <string.h>

108
C/heapgc.c
View File

@ -361,7 +361,7 @@ gc_lookup_ma_var(CELL *addr, tr_fr_ptr trp) {
gc_ma_hash_table[i].loc = trp; gc_ma_hash_table[i].loc = trp;
gc_ma_hash_table[i].more = gc_ma_h_list; gc_ma_hash_table[i].more = gc_ma_h_list;
gc_ma_h_list = gc_ma_hash_table+i; gc_ma_h_list = gc_ma_hash_table+i;
#endif #endif /* TABLING */
gc_ma_hash_table[i].next = NULL; gc_ma_hash_table[i].next = NULL;
return NULL; return NULL;
} }
@ -375,7 +375,7 @@ gc_lookup_ma_var(CELL *addr, tr_fr_ptr trp) {
has the correct new value has the correct new value
*/ */
TrailVal(nptr->loc+1) = TrailVal(trp+1); TrailVal(nptr->loc+1) = TrailVal(trp+1);
#endif #endif /* TABLING */
return nptr; return nptr;
} }
nptr = nptr->next; nptr = nptr->next;
@ -386,7 +386,7 @@ gc_lookup_ma_var(CELL *addr, tr_fr_ptr trp) {
#if TABLING #if TABLING
nptr->loc = trp; nptr->loc = trp;
nptr->more = gc_ma_h_list; nptr->more = gc_ma_h_list;
#endif #endif /* TABLING */
nptr->next = NULL; nptr->next = NULL;
gc_ma_h_list = nptr; gc_ma_h_list = nptr;
return NULL; return NULL;
@ -1748,7 +1748,7 @@ mark_trail(tr_fr_ptr trail_ptr, tr_fr_ptr trail_base, CELL *gc_H, choiceptr gc_B
#else #else
trail_base++; trail_base++;
mark_external_reference(&(TrailTerm(trail_base))); mark_external_reference(&(TrailTerm(trail_base)));
#endif #endif /* TABLING */
trail_base ++; trail_base ++;
if (HEAP_PTR(trail_cell)) { if (HEAP_PTR(trail_cell)) {
/* fool the gc into thinking this is a variable */ /* fool the gc into thinking this is a variable */
@ -1771,7 +1771,7 @@ mark_trail(tr_fr_ptr trail_ptr, tr_fr_ptr trail_base, CELL *gc_H, choiceptr gc_B
#ifdef FROZEN_STACKS #ifdef FROZEN_STACKS
RESET_VARIABLE(&TrailVal(trail_base)); RESET_VARIABLE(&TrailVal(trail_base));
#endif #endif
#endif /* TABLING */ #endif /* !TABLING */
trail_base++; trail_base++;
RESET_VARIABLE(&TrailTerm(trail_base)); RESET_VARIABLE(&TrailTerm(trail_base));
#ifdef FROZEN_STACKS #ifdef FROZEN_STACKS
@ -1794,7 +1794,7 @@ mark_trail(tr_fr_ptr trail_ptr, tr_fr_ptr trail_base, CELL *gc_H, choiceptr gc_B
gl = gl->more; gl = gl->more;
} }
} }
#endif #endif /* TABLING */
#ifdef EASY_SHUNTING #ifdef EASY_SHUNTING
sTR = (tr_fr_ptr)old_cont_top0; sTR = (tr_fr_ptr)old_cont_top0;
while (begsTR != NULL) { while (begsTR != NULL) {
@ -1877,7 +1877,7 @@ youngest_cp(choiceptr gc_B, dep_fr_ptr *depfrp)
} }
return min; return min;
} }
#endif #endif /* TABLING */
static void static void
@ -1899,14 +1899,17 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
#ifdef TABLING #ifdef TABLING
gc_B = youngest_cp(gc_B, &depfr); gc_B = youngest_cp(gc_B, &depfr);
#endif #endif /* TABLING */
while (gc_B != NULL) { while (gc_B != NULL) {
op_numbers opnum; op_numbers opnum;
register OPCODE op; register OPCODE op;
yamop *rtp = gc_B->cp_ap; yamop *rtp = gc_B->cp_ap;
mark_db_fixed((CELL *)rtp); mark_db_fixed((CELL *)rtp);
mark_db_fixed((CELL *)(gc_B->cp_cp)); #ifdef DETERMINISTIC_TABLING
if (!IS_DET_GEN_CP(gc_B))
#endif /* DETERMINISTIC_TABLING */
mark_db_fixed((CELL *)(gc_B->cp_cp));
#ifdef EASY_SHUNTING #ifdef EASY_SHUNTING
current_B = gc_B; current_B = gc_B;
prev_HB = HB; prev_HB = HB;
@ -1933,7 +1936,7 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
if (aux_sg_fr && gc_B == SgFr_gen_cp(aux_sg_fr)) { if (aux_sg_fr && gc_B == SgFr_gen_cp(aux_sg_fr)) {
aux_sg_fr = SgFr_next(aux_sg_fr); aux_sg_fr = SgFr_next(aux_sg_fr);
} }
#endif #endif /* TABLING */
if (very_verbose) { if (very_verbose) {
PredEntry *pe = Yap_PredForChoicePt(gc_B); PredEntry *pe = Yap_PredForChoicePt(gc_B);
#if defined(ANALYST) || defined(DEBUG) #if defined(ANALYST) || defined(DEBUG)
@ -1975,9 +1978,12 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
EnvSizeInCells, EnvSizeInCells,
NULL); NULL);
else if (opnum != _trust_fail) else if (opnum != _trust_fail)
mark_environments((CELL_PTR) gc_B->cp_env, #ifdef DETERMINISTIC_TABLING
EnvSize((yamop *) (gc_B->cp_cp)), if (!IS_DET_GEN_CP(gc_B))
EnvBMap((yamop *) (gc_B->cp_cp))); #endif /* DETERMINISTIC_TABLING */
mark_environments((CELL_PTR) gc_B->cp_env,
EnvSize((yamop *) (gc_B->cp_cp)),
EnvBMap((yamop *) (gc_B->cp_cp)));
/* extended choice point */ /* extended choice point */
restart_cp: restart_cp:
switch (opnum) { switch (opnum) {
@ -2061,11 +2067,18 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
case _table_completion: case _table_completion:
{ {
CELL *vars_ptr, vars; CELL *vars_ptr, vars;
vars_ptr = (CELL *)(GEN_CP(gc_B) + 1); #ifdef DETERMINISTIC_TABLING
nargs = SgFr_arity(GEN_CP(gc_B)->cp_sg_fr); if (IS_DET_GEN_CP(gc_B))
while (nargs--) { vars_ptr = (CELL *)(DET_GEN_CP(gc_B) + 1);
mark_external_reference(vars_ptr); else
vars_ptr++; #endif /* DETERMINISTIC_TABLING */
{
vars_ptr = (CELL *)(GEN_CP(gc_B) + 1);
nargs = SgFr_arity(GEN_CP(gc_B)->cp_sg_fr);
while (nargs--) {
mark_external_reference(vars_ptr);
vars_ptr++;
}
} }
vars = *vars_ptr++; vars = *vars_ptr++;
while (vars--) { while (vars--) {
@ -2138,8 +2151,8 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
vars_ptr -= 2; vars_ptr -= 2;
if (heap_arity) { if (heap_arity) {
while (heap_arity--) { while (heap_arity--) {
if (*vars_ptr == 0) if (*vars_ptr == 0) /* float/longint extension mark */
break; /* term extension mark: float/longint */ break;
mark_external_reference(vars_ptr); mark_external_reference(vars_ptr);
vars_ptr--; vars_ptr--;
} }
@ -2270,7 +2283,7 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
gc_B = youngest_cp(gc_B->cp_b, &depfr); gc_B = youngest_cp(gc_B->cp_b, &depfr);
#else #else
gc_B = gc_B->cp_b; gc_B = gc_B->cp_b;
#endif #endif /* TABLING */
} }
} }
@ -2820,7 +2833,7 @@ sweep_choicepoints(choiceptr gc_B)
#ifdef TABLING #ifdef TABLING
gc_B = youngest_cp(gc_B, &depfr); gc_B = youngest_cp(gc_B, &depfr);
#endif #endif /* TABLING */
while (gc_B != NULL) { while (gc_B != NULL) {
yamop *rtp = gc_B->cp_ap; yamop *rtp = gc_B->cp_ap;
register OPCODE op; register OPCODE op;
@ -2844,7 +2857,7 @@ sweep_choicepoints(choiceptr gc_B)
if (aux_sg_fr && gc_B == SgFr_gen_cp(aux_sg_fr)) { if (aux_sg_fr && gc_B == SgFr_gen_cp(aux_sg_fr)) {
aux_sg_fr = SgFr_next(aux_sg_fr); aux_sg_fr = SgFr_next(aux_sg_fr);
} }
#endif #endif /* TABLING */
restart_cp: restart_cp:
/* /*
@ -2941,18 +2954,25 @@ sweep_choicepoints(choiceptr gc_B)
{ {
int nargs; int nargs;
CELL *vars_ptr, vars; CELL *vars_ptr, vars;
sweep_environments(gc_B->cp_env, EnvSize(gc_B->cp_cp), EnvBMap(gc_B->cp_cp)); #ifdef DETERMINISTIC_TABLING
vars_ptr = (CELL *)(GEN_CP(gc_B) + 1); if (IS_DET_GEN_CP(gc_B))
nargs = SgFr_arity(GEN_CP(gc_B)->cp_sg_fr); vars_ptr = (CELL *)(DET_GEN_CP(gc_B) + 1);
while(nargs--) { else
CELL cp_cell = *vars_ptr; #endif /* DETERMINISTIC_TABLING */
if (MARKED_PTR(vars_ptr)) { {
UNMARK(vars_ptr); sweep_environments(gc_B->cp_env, EnvSize(gc_B->cp_cp), EnvBMap(gc_B->cp_cp));
if (HEAP_PTR(cp_cell)) { vars_ptr = (CELL *)(GEN_CP(gc_B) + 1);
into_relocation_chain(vars_ptr, GET_NEXT(cp_cell)); nargs = SgFr_arity(GEN_CP(gc_B)->cp_sg_fr);
while(nargs--) {
CELL cp_cell = *vars_ptr;
if (MARKED_PTR(vars_ptr)) {
UNMARK(vars_ptr);
if (HEAP_PTR(cp_cell)) {
into_relocation_chain(vars_ptr, GET_NEXT(cp_cell));
}
} }
vars_ptr++;
} }
vars_ptr++;
} }
vars = *vars_ptr++; vars = *vars_ptr++;
while (vars--) { while (vars--) {
@ -3050,8 +3070,8 @@ sweep_choicepoints(choiceptr gc_B)
if (heap_arity) { if (heap_arity) {
while (heap_arity--) { while (heap_arity--) {
CELL cp_cell = *vars_ptr; CELL cp_cell = *vars_ptr;
if (*vars_ptr == 0) if (*vars_ptr == 0) /* float/longint extension mark */
break; /* term extension mark: float/longint */ break;
if (MARKED_PTR(vars_ptr)) { if (MARKED_PTR(vars_ptr)) {
UNMARK(vars_ptr); UNMARK(vars_ptr);
if (HEAP_PTR(cp_cell)) { if (HEAP_PTR(cp_cell)) {
@ -3113,7 +3133,7 @@ sweep_choicepoints(choiceptr gc_B)
gc_B = youngest_cp(gc_B->cp_b, &depfr); gc_B = youngest_cp(gc_B->cp_b, &depfr);
#else #else
gc_B = gc_B->cp_b; gc_B = gc_B->cp_b;
#endif #endif /* TABLING */
} }
} }
@ -3146,14 +3166,14 @@ static inline choiceptr
update_B_H( choiceptr gc_B, CELL *current, CELL *dest, CELL *odest update_B_H( choiceptr gc_B, CELL *current, CELL *dest, CELL *odest
#ifdef TABLING #ifdef TABLING
, dep_fr_ptr *depfrp , dep_fr_ptr *depfrp
#endif #endif /* TABLING */
) { ) {
/* also make the value of H in a choicepoint /* also make the value of H in a choicepoint
coherent with the new global coherent with the new global
*/ */
#ifdef TABLING #ifdef TABLING
dep_fr_ptr depfr = *depfrp; dep_fr_ptr depfr = *depfrp;
#endif #endif /* TABLING */
while (gc_B && current <= gc_B->cp_h) { while (gc_B && current <= gc_B->cp_h) {
if (gc_B->cp_h == current) { if (gc_B->cp_h == current) {
@ -3214,14 +3234,14 @@ compact_heap(void)
gc_B = DepFr_cons_cp(depfr); gc_B = DepFr_cons_cp(depfr);
depfr = DepFr_next(depfr); depfr = DepFr_next(depfr);
} }
#endif #endif /* TABLING */
next_hb = set_next_hb(gc_B); next_hb = set_next_hb(gc_B);
dest = H0 + total_marked - 1; dest = H0 + total_marked - 1;
gc_B = update_B_H(gc_B, H, dest+1, dest+2 gc_B = update_B_H(gc_B, H, dest+1, dest+2
#ifdef TABLING #ifdef TABLING
, &depfr , &depfr
#endif #endif /* TABLING */
); );
for (current = H - 1; current >= start_from; current--) { for (current = H - 1; current >= start_from; current--) {
if (MARKED_PTR(current)) { if (MARKED_PTR(current)) {
@ -3236,7 +3256,7 @@ compact_heap(void)
gc_B = update_B_H(gc_B, current, dest, dest+1 gc_B = update_B_H(gc_B, current, dest, dest+1
#ifdef TABLING #ifdef TABLING
, &depfr , &depfr
#endif #endif /* TABLING */
); );
next_hb = set_next_hb(gc_B); next_hb = set_next_hb(gc_B);
} }
@ -3397,13 +3417,13 @@ icompact_heap(void)
gc_B = DepFr_cons_cp(depfr); gc_B = DepFr_cons_cp(depfr);
depfr = DepFr_next(depfr); depfr = DepFr_next(depfr);
} }
#endif #endif /* TABLING */
next_hb = set_next_hb(gc_B); next_hb = set_next_hb(gc_B);
dest = (CELL_PTR) H0 + total_marked - 1; dest = (CELL_PTR) H0 + total_marked - 1;
gc_B = update_B_H(gc_B, H, dest+1, dest+2 gc_B = update_B_H(gc_B, H, dest+1, dest+2
#ifdef TABLING #ifdef TABLING
, &depfr , &depfr
#endif #endif /* TABLING */
); );
for (iptr = iptop - 1; iptr >= ibase; iptr--) { for (iptr = iptop - 1; iptr >= ibase; iptr--) {
CELL ccell; CELL ccell;
@ -3415,7 +3435,7 @@ icompact_heap(void)
gc_B = update_B_H(gc_B, current, dest, dest+1 gc_B = update_B_H(gc_B, current, dest, dest+1
#ifdef TABLING #ifdef TABLING
, &depfr , &depfr
#endif #endif /* TABLING */
); );
next_hb = set_next_hb(gc_B); next_hb = set_next_hb(gc_B);
} }

4
C/iopreds.c Normal file → Executable file
View File

@ -2311,7 +2311,7 @@ p_open (void)
return FALSE; return FALSE;
encoding = IntegerOfTerm(tenc); encoding = IntegerOfTerm(tenc);
#ifdef _WIN32 #ifdef _WIN32
if (st->status & Binary_Stream_f) { if (opts & 2) {
strncat(io_mode, "b", 8); strncat(io_mode, "b", 8);
} else { } else {
strncat(io_mode, "t", 8); strncat(io_mode, "t", 8);
@ -4525,7 +4525,7 @@ p_put (void)
return (FALSE); return (FALSE);
if (Stream[sno].status & Binary_Stream_f) { if (Stream[sno].status & Binary_Stream_f) {
UNLOCK(Stream[sno].streamlock); UNLOCK(Stream[sno].streamlock);
Yap_Error(PERMISSION_ERROR_OUTPUT_BINARY_STREAM, ARG1, "get0/2"); Yap_Error(PERMISSION_ERROR_OUTPUT_BINARY_STREAM, ARG1, "put/2");
return(FALSE); return(FALSE);
} }
Stream[sno].stream_wputc (sno, (int) IntegerOfTerm (Deref (ARG2))); Stream[sno].stream_wputc (sno, (int) IntegerOfTerm (Deref (ARG2)));

1
H/amidefs.h
View File

@ -816,6 +816,7 @@ struct deterministic_choicept {
int cp_lub; /* local untried branches */ int cp_lub; /* local untried branches */
struct or_frame *cp_or_fr; /* or-frame pointer */ struct or_frame *cp_or_fr; /* or-frame pointer */
#endif /* YAPOR */ #endif /* YAPOR */
CELL *cp_h; /* necessary, otherwise we get in trouble */
}; };
typedef struct choicept { typedef struct choicept {

34
OPTYap/opt.config.h
View File

@ -31,14 +31,29 @@
/* ----------------------- ** /* ----------------------- **
** default sizes ** ** default sizes **
** ----------------------- */ ** ----------------------- */
#define MAX_TABLE_VARS 100 #define MAX_TABLE_VARS 1000
/* ------------------------------------------ ** /* ------------------------------------------ **
** trail freeze scheme (define one) ** ** trail freeze scheme (define one) **
** ------------------------------------------ */ ** ------------------------------------------ */
#define BFZ_TRAIL_SCHEME 1 #define BFZ_TRAIL_SCHEME 1
/* #define BBREG_TRAIL_SCHEME 1 */ /* #define BBREG_TRAIL_SCHEME 1 */
/* ----------------------------------------------- **
** support early completion ? (optional) **
** ----------------------------------------------- */
#define TABLING_EARLY_COMPLETION 1
/* ------------------------------------------------ **
** support trie compact pairs? (optional) **
** ------------------------------------------------ */
#define TRIE_COMPACT_PAIRS 1
/* --------------------------------------------------- **
** support deterministic tabling? (optional) **
** --------------------------------------------------- */
/* #define DETERMINISTIC_TABLING 1 */
/* ------------------------------------------------ ** /* ------------------------------------------------ **
** limit the table space size? (optional) ** ** limit the table space size? (optional) **
** ------------------------------------------------ */ ** ------------------------------------------------ */
@ -49,16 +64,6 @@
** ------------------------------------------------ */ ** ------------------------------------------------ */
/* #define INCOMPLETE_TABLING 1 */ /* #define INCOMPLETE_TABLING 1 */
/* ------------------------------------------------ **
** support trie compact pairs? (optional) **
** ------------------------------------------------ */
/* #define TRIE_COMPACT_PAIRS 1 */
/* --------------------------------------------------- **
** support deterministic tabling? (optional) **
** --------------------------------------------------- */
/* #define DETERMINISTIC_TABLING 1 */
/* ---------------------------------------- -- ** /* ---------------------------------------- -- **
** enable error checking? (optional) ** ** enable error checking? (optional) **
** ------------------------------------------- */ ** ------------------------------------------- */
@ -220,10 +225,11 @@
#ifndef TABLING #ifndef TABLING
#undef BFZ_TRAIL_SCHEME #undef BFZ_TRAIL_SCHEME
#undef BBREG_TRAIL_SCHEME #undef BBREG_TRAIL_SCHEME
#undef TRIE_COMPACT_PAIRS
#undef TABLING_EARLY_COMPLETION
#undef DETERMINISTIC_TABLING
#undef LIMIT_TABLING #undef LIMIT_TABLING
#undef INCOMPLETE_TABLING #undef INCOMPLETE_TABLING
#undef TRIE_COMPACT_PAIRS
#undef DETERMINISTIC_TABLING
#undef TABLING_ERRORS #undef TABLING_ERRORS
#endif /* !TABLING */ #endif /* !TABLING */

582
OPTYap/opt.macros.h
View File

@ -52,335 +52,335 @@ extern int Yap_page_size;
#define UPDATE_STATS(STAT, VALUE) STAT += VALUE #define UPDATE_STATS(STAT, VALUE) STAT += VALUE
#ifdef MALLOC_MEMORY_ALLOC_SCHEME /* ------------------------------------------------ */ #ifdef MALLOC_MEMORY_ALLOC_SCHEME /* ---------------------------------------------------------------- */
#define ALLOC_STRUCT(STR, STR_PAGES, STR_TYPE) \ #define ALLOC_STRUCT(STR, STR_PAGES, STR_TYPE) \
UPDATE_STATS(Pg_str_in_use(STR_PAGES), 1); \ UPDATE_STATS(Pg_str_in_use(STR_PAGES), 1); \
if ((STR = (STR_TYPE *)malloc(sizeof(STR_TYPE))) == NULL) \ if ((STR = (STR_TYPE *)malloc(sizeof(STR_TYPE))) == NULL) \
Yap_Error(FATAL_ERROR, TermNil, "malloc error (ALLOC_STRUCT)") Yap_Error(FATAL_ERROR, TermNil, "malloc error (ALLOC_STRUCT)")
#define ALLOC_NEXT_FREE_STRUCT(STR, STR_PAGES, STR_TYPE) \ #define ALLOC_NEXT_FREE_STRUCT(STR, STR_PAGES, STR_TYPE) \
ALLOC_STRUCT(STR, STR_PAGES, STR_TYPE) ALLOC_STRUCT(STR, STR_PAGES, STR_TYPE)
#define FREE_STRUCT(STR, STR_PAGES, STR_TYPE) \ #define FREE_STRUCT(STR, STR_PAGES, STR_TYPE) \
UPDATE_STATS(Pg_str_in_use(STR_PAGES), -1); \ UPDATE_STATS(Pg_str_in_use(STR_PAGES), -1); \
free(STR) free(STR)
#elif YAP_MEMORY_ALLOC_SCHEME /* ---------------------------------------------------- */ #elif YAP_MEMORY_ALLOC_SCHEME /* -------------------------------------------------------------------- */
#define ALLOC_STRUCT(STR, STR_PAGES, STR_TYPE) \ #define ALLOC_STRUCT(STR, STR_PAGES, STR_TYPE) \
{ char *ptr = Yap_AllocCodeSpace(sizeof(STR_TYPE) + sizeof(CELL)); \ { char *ptr = Yap_AllocCodeSpace(sizeof(STR_TYPE) + sizeof(CELL)); \
if (ptr) { \ if (ptr) { \
*ptr = 'y'; \ *ptr = 'y'; \
ptr += sizeof(CELL); \ ptr += sizeof(CELL); \
STR = (STR_TYPE *)ptr; \ STR = (STR_TYPE *)ptr; \
} else { \ } else { \
ptr = (char *)malloc(sizeof(STR_TYPE) + sizeof(CELL)); \ ptr = (char *)malloc(sizeof(STR_TYPE) + sizeof(CELL)); \
if (ptr) { \ if (ptr) { \
*ptr = 'm'; \ *ptr = 'm'; \
ptr += sizeof(CELL); \ ptr += sizeof(CELL); \
STR = (STR_TYPE *)ptr; \ STR = (STR_TYPE *)ptr; \
} else { \ } else { \
Yap_Error(FATAL_ERROR, TermNil, "malloc error (ALLOC_STRUCT)"); \ Yap_Error(FATAL_ERROR, TermNil, "malloc error (ALLOC_STRUCT)"); \
STR = NULL; \ STR = NULL; \
} \ } \
} \ } \
UPDATE_STATS(Pg_str_in_use(STR_PAGES), 1); \ UPDATE_STATS(Pg_str_in_use(STR_PAGES), 1); \
} }
#define ALLOC_NEXT_FREE_STRUCT(STR, STR_PAGES, STR_TYPE) \ #define ALLOC_NEXT_FREE_STRUCT(STR, STR_PAGES, STR_TYPE) \
ALLOC_STRUCT(STR, STR_PAGES, STR_TYPE) ALLOC_STRUCT(STR, STR_PAGES, STR_TYPE)
#define FREE_STRUCT(STR, STR_PAGES, STR_TYPE) \ #define FREE_STRUCT(STR, STR_PAGES, STR_TYPE) \
{ char *ptr = (char *)(STR) - sizeof(CELL); \ { char *ptr = (char *)(STR) - sizeof(CELL); \
if (ptr[0] == 'y') { \ if (ptr[0] == 'y') { \
Yap_FreeCodeSpace(ptr); \ Yap_FreeCodeSpace(ptr); \
} else \ } else \
free(ptr); \ free(ptr); \
UPDATE_STATS(Pg_str_in_use(STR_PAGES), -1); \ UPDATE_STATS(Pg_str_in_use(STR_PAGES), -1); \
} }
#elif SHM_MEMORY_ALLOC_SCHEME /* ---------------------------------------------------- */ #elif SHM_MEMORY_ALLOC_SCHEME /* -------------------------------------------------------------------- */
#ifdef LIMIT_TABLING #ifdef LIMIT_TABLING
#define INIT_PAGE(PG_HD, STR_PAGES, STR_TYPE) \ #define INIT_PAGE(PG_HD, STR_PAGES, STR_TYPE) \
{ int i; \ { int i; \
STR_TYPE *aux_str; \ STR_TYPE *aux_str; \
PgHd_str_in_use(PG_HD) = 0; \ PgHd_str_in_use(PG_HD) = 0; \
PgHd_previous(PG_HD) = NULL; \ PgHd_previous(PG_HD) = NULL; \
aux_str = (STR_TYPE *) (PG_HD + 1); \ aux_str = (STR_TYPE *) (PG_HD + 1); \
PgHd_free_str(PG_HD) = (void *) aux_str; \ PgHd_free_str(PG_HD) = (void *) aux_str; \
for (i = 1; i < Pg_str_per_pg(STR_PAGES); i++) { \ for (i = 1; i < Pg_str_per_pg(STR_PAGES); i++) { \
STRUCT_NEXT(aux_str) = aux_str + 1; \ STRUCT_NEXT(aux_str) = aux_str + 1; \
aux_str++; \ aux_str++; \
} \ } \
STRUCT_NEXT(aux_str) = NULL; \ STRUCT_NEXT(aux_str) = NULL; \
LOCK(Pg_lock(STR_PAGES)); \ LOCK(Pg_lock(STR_PAGES)); \
if ((PgHd_next(PG_HD) = Pg_free_pg(STR_PAGES)) != NULL) \ if ((PgHd_next(PG_HD) = Pg_free_pg(STR_PAGES)) != NULL) \
PgHd_previous(PgHd_next(PG_HD)) = PG_HD; \ PgHd_previous(PgHd_next(PG_HD)) = PG_HD; \
Pg_free_pg(STR_PAGES) = PG_HD; \ Pg_free_pg(STR_PAGES) = PG_HD; \
UPDATE_STATS(Pg_pg_alloc(STR_PAGES), 1); \ UPDATE_STATS(Pg_pg_alloc(STR_PAGES), 1); \
} }
#define ALLOC_PAGE(PG_HD) \ #define ALLOC_PAGE(PG_HD) \
{ int i, shmid; \ { int i, shmid; \
pg_hd_ptr aux_pg_hd; \ pg_hd_ptr aux_pg_hd; \
if ((shmid = shmget(IPC_PRIVATE, SHMMAX, SHM_R|SHM_W)) == -1) \ if ((shmid = shmget(IPC_PRIVATE, SHMMAX, SHM_R|SHM_W)) == -1) \
Yap_Error(FATAL_ERROR, TermNil, "shmget error (ALLOC_PAGE)"); \ Yap_Error(FATAL_ERROR, TermNil, "shmget error (ALLOC_PAGE)"); \
if ((PG_HD = (pg_hd_ptr) shmat(shmid, NULL, 0)) == (void *) -1) \ if ((PG_HD = (pg_hd_ptr) shmat(shmid, NULL, 0)) == (void *) -1) \
Yap_Error(FATAL_ERROR, TermNil, "shmat error (ALLOC_PAGE)"); \ Yap_Error(FATAL_ERROR, TermNil, "shmat error (ALLOC_PAGE)"); \
if (shmctl(shmid, IPC_RMID, 0) != 0) \ if (shmctl(shmid, IPC_RMID, 0) != 0) \
Yap_Error(FATAL_ERROR, TermNil, "shmctl error (ALLOC_PAGE)"); \ Yap_Error(FATAL_ERROR, TermNil, "shmctl error (ALLOC_PAGE)"); \
aux_pg_hd = (pg_hd_ptr)(((void *)PG_HD) + Yap_page_size); \ aux_pg_hd = (pg_hd_ptr)(((void *)PG_HD) + Yap_page_size); \
Pg_free_pg(GLOBAL_PAGES_void) = aux_pg_hd; \ Pg_free_pg(GLOBAL_PAGES_void) = aux_pg_hd; \
for (i = 2; i < SHMMAX / Yap_page_size; i++) { \ for (i = 2; i < SHMMAX / Yap_page_size; i++) { \
PgHd_next(aux_pg_hd) = (pg_hd_ptr)(((void *)aux_pg_hd) + Yap_page_size); \ PgHd_next(aux_pg_hd) = (pg_hd_ptr)(((void *)aux_pg_hd) + Yap_page_size); \
aux_pg_hd = PgHd_next(aux_pg_hd); \ aux_pg_hd = PgHd_next(aux_pg_hd); \
} \ } \
PgHd_next(aux_pg_hd) = NULL; \ PgHd_next(aux_pg_hd) = NULL; \
UPDATE_STATS(Pg_pg_alloc(GLOBAL_PAGES_void), SHMMAX / Yap_page_size); \ UPDATE_STATS(Pg_pg_alloc(GLOBAL_PAGES_void), SHMMAX / Yap_page_size); \
} }
#define RECOVER_UNUSED_SPACE(STR_PAGES) \ #define RECOVER_UNUSED_SPACE(STR_PAGES) \
{ sg_fr_ptr sg_fr = GLOBAL_check_sg_fr; \ { sg_fr_ptr sg_fr = GLOBAL_check_sg_fr; \
do { \ do { \
if (sg_fr) \ if (sg_fr) \
sg_fr = SgFr_next(sg_fr); \ sg_fr = SgFr_next(sg_fr); \
else \ else \
sg_fr = GLOBAL_first_sg_fr; \ sg_fr = GLOBAL_first_sg_fr; \
if (sg_fr == NULL) \ if (sg_fr == NULL) \
Yap_Error(FATAL_ERROR, TermNil, "no space left (RECOVER_UNUSED_SPACE)"); \ Yap_Error(FATAL_ERROR, TermNil, "no space left (RECOVER_UNUSED_SPACE)"); \
/* see function 'InteractSIGINT' in file 'sysbits.c' */ \ /* see function 'InteractSIGINT' in file 'sysbits.c' */ \
/* Yap_Error(PURE_ABORT, TermNil, ""); */ \ /* Yap_Error(PURE_ABORT, TermNil, ""); */ \
/* restore_absmi_regs(&Yap_standard_regs); */ \ /* restore_absmi_regs(&Yap_standard_regs); */ \
/* siglongjmp (Yap_RestartEnv, 1); */ \ /* siglongjmp (Yap_RestartEnv, 1); */ \
if (SgFr_first_answer(sg_fr) && \ if (SgFr_first_answer(sg_fr) && \
SgFr_first_answer(sg_fr) != SgFr_answer_trie(sg_fr)) { \ SgFr_first_answer(sg_fr) != SgFr_answer_trie(sg_fr)) { \
SgFr_state(sg_fr) = ready; \ SgFr_state(sg_fr) = ready; \
free_answer_hash_chain(SgFr_hash_chain(sg_fr)); \ free_answer_hash_chain(SgFr_hash_chain(sg_fr)); \
SgFr_hash_chain(sg_fr) = NULL; \ SgFr_hash_chain(sg_fr) = NULL; \
SgFr_first_answer(sg_fr) = NULL; \ SgFr_first_answer(sg_fr) = NULL; \
SgFr_last_answer(sg_fr) = NULL; \ SgFr_last_answer(sg_fr) = NULL; \
free_answer_trie_branch(TrNode_child(SgFr_answer_trie(sg_fr))); \ free_answer_trie_branch(TrNode_child(SgFr_answer_trie(sg_fr)), TRAVERSE_POSITION_FIRST); \
TrNode_child(SgFr_answer_trie(sg_fr)) = NULL; \ TrNode_child(SgFr_answer_trie(sg_fr)) = NULL; \
} \ } \
} while (Pg_free_pg(GLOBAL_PAGES_void) == Pg_free_pg(STR_PAGES)); \ } while (Pg_free_pg(GLOBAL_PAGES_void) == Pg_free_pg(STR_PAGES)); \
GLOBAL_check_sg_fr = sg_fr; \ GLOBAL_check_sg_fr = sg_fr; \
} }
#define ALLOC_STRUCT(STR, STR_PAGES, STR_TYPE) \ #define ALLOC_STRUCT(STR, STR_PAGES, STR_TYPE) \
{ pg_hd_ptr pg_hd; \ { pg_hd_ptr pg_hd; \
LOCK(Pg_lock(STR_PAGES)); \ LOCK(Pg_lock(STR_PAGES)); \
pg_hd = Pg_free_pg(STR_PAGES); \ pg_hd = Pg_free_pg(STR_PAGES); \
while (pg_hd == NULL) { \ while (pg_hd == NULL) { \
UNLOCK(Pg_lock(STR_PAGES)); \ UNLOCK(Pg_lock(STR_PAGES)); \
LOCK(Pg_lock(GLOBAL_PAGES_void)); \ LOCK(Pg_lock(GLOBAL_PAGES_void)); \
if (Pg_free_pg(GLOBAL_PAGES_void)) { \ if (Pg_free_pg(GLOBAL_PAGES_void)) { \
pg_hd = Pg_free_pg(GLOBAL_PAGES_void); \ pg_hd = Pg_free_pg(GLOBAL_PAGES_void); \
Pg_free_pg(GLOBAL_PAGES_void) = PgHd_next(pg_hd); \ Pg_free_pg(GLOBAL_PAGES_void) = PgHd_next(pg_hd); \
UPDATE_STATS(Pg_str_in_use(GLOBAL_PAGES_void), 1); \ UPDATE_STATS(Pg_str_in_use(GLOBAL_PAGES_void), 1); \
UNLOCK(Pg_lock(GLOBAL_PAGES_void)); \ UNLOCK(Pg_lock(GLOBAL_PAGES_void)); \
INIT_PAGE(pg_hd, STR_PAGES, STR_TYPE); \ INIT_PAGE(pg_hd, STR_PAGES, STR_TYPE); \
} else if (GLOBAL_MAX_PAGES != Pg_pg_alloc(GLOBAL_PAGES_void)) { \ } else if (GLOBAL_MAX_PAGES != Pg_pg_alloc(GLOBAL_PAGES_void)) { \
ALLOC_PAGE(pg_hd); \ ALLOC_PAGE(pg_hd); \
UPDATE_STATS(Pg_str_in_use(GLOBAL_PAGES_void), 1); \ UPDATE_STATS(Pg_str_in_use(GLOBAL_PAGES_void), 1); \
UNLOCK(Pg_lock(GLOBAL_PAGES_void)); \ UNLOCK(Pg_lock(GLOBAL_PAGES_void)); \
INIT_PAGE(pg_hd, STR_PAGES, STR_TYPE); \ INIT_PAGE(pg_hd, STR_PAGES, STR_TYPE); \
} else { \ } else { \
UNLOCK(Pg_lock(GLOBAL_PAGES_void)); \ UNLOCK(Pg_lock(GLOBAL_PAGES_void)); \
RECOVER_UNUSED_SPACE(STR_PAGES); \ RECOVER_UNUSED_SPACE(STR_PAGES); \
LOCK(Pg_lock(STR_PAGES)); \ LOCK(Pg_lock(STR_PAGES)); \
pg_hd = Pg_free_pg(STR_PAGES); \ pg_hd = Pg_free_pg(STR_PAGES); \
} \ } \
} \ } \
PgHd_str_in_use(pg_hd)++; \ PgHd_str_in_use(pg_hd)++; \
STR = (STR_TYPE *) PgHd_free_str(pg_hd); \ STR = (STR_TYPE *) PgHd_free_str(pg_hd); \
if ((PgHd_free_str(pg_hd) = (void *) STRUCT_NEXT(STR)) == NULL) \ if ((PgHd_free_str(pg_hd) = (void *) STRUCT_NEXT(STR)) == NULL) \
if ((Pg_free_pg(STR_PAGES) = PgHd_next(pg_hd)) != NULL) \ if ((Pg_free_pg(STR_PAGES) = PgHd_next(pg_hd)) != NULL) \
PgHd_previous(PgHd_next(pg_hd)) = NULL; \ PgHd_previous(PgHd_next(pg_hd)) = NULL; \
UPDATE_STATS(Pg_str_in_use(STR_PAGES), 1); \ UPDATE_STATS(Pg_str_in_use(STR_PAGES), 1); \
UNLOCK(Pg_lock(STR_PAGES)); \ UNLOCK(Pg_lock(STR_PAGES)); \
} }
#define ALLOC_NEXT_FREE_STRUCT(STR, STR_PAGES, STR_TYPE) \ #define ALLOC_NEXT_FREE_STRUCT(STR, STR_PAGES, STR_TYPE) \
if ((STR = LOCAL_next_free_ans_node) == NULL) { \ if ((STR = LOCAL_next_free_ans_node) == NULL) { \
pg_hd_ptr pg_hd; \ pg_hd_ptr pg_hd; \
LOCK(Pg_lock(STR_PAGES)); \ LOCK(Pg_lock(STR_PAGES)); \
pg_hd = Pg_free_pg(STR_PAGES); \ pg_hd = Pg_free_pg(STR_PAGES); \
while (pg_hd == NULL) { \ while (pg_hd == NULL) { \
UNLOCK(Pg_lock(STR_PAGES)); \ UNLOCK(Pg_lock(STR_PAGES)); \
LOCK(Pg_lock(GLOBAL_PAGES_void)); \ LOCK(Pg_lock(GLOBAL_PAGES_void)); \
if (Pg_free_pg(GLOBAL_PAGES_void)) { \ if (Pg_free_pg(GLOBAL_PAGES_void)) { \
pg_hd = Pg_free_pg(GLOBAL_PAGES_void); \ pg_hd = Pg_free_pg(GLOBAL_PAGES_void); \
Pg_free_pg(GLOBAL_PAGES_void) = PgHd_next(pg_hd); \ Pg_free_pg(GLOBAL_PAGES_void) = PgHd_next(pg_hd); \
UPDATE_STATS(Pg_str_in_use(GLOBAL_PAGES_void), 1); \ UPDATE_STATS(Pg_str_in_use(GLOBAL_PAGES_void), 1); \
UNLOCK(Pg_lock(GLOBAL_PAGES_void)); \ UNLOCK(Pg_lock(GLOBAL_PAGES_void)); \
INIT_PAGE(pg_hd, STR_PAGES, STR_TYPE); \ INIT_PAGE(pg_hd, STR_PAGES, STR_TYPE); \
} else if (GLOBAL_MAX_PAGES != Pg_pg_alloc(GLOBAL_PAGES_void)) { \ } else if (GLOBAL_MAX_PAGES != Pg_pg_alloc(GLOBAL_PAGES_void)) { \
ALLOC_PAGE(pg_hd); \ ALLOC_PAGE(pg_hd); \
UPDATE_STATS(Pg_str_in_use(GLOBAL_PAGES_void), 1); \ UPDATE_STATS(Pg_str_in_use(GLOBAL_PAGES_void), 1); \
UNLOCK(Pg_lock(GLOBAL_PAGES_void)); \ UNLOCK(Pg_lock(GLOBAL_PAGES_void)); \
INIT_PAGE(pg_hd, STR_PAGES, STR_TYPE); \ INIT_PAGE(pg_hd, STR_PAGES, STR_TYPE); \
} else { \ } else { \
UNLOCK(Pg_lock(GLOBAL_PAGES_void)); \ UNLOCK(Pg_lock(GLOBAL_PAGES_void)); \
RECOVER_UNUSED_SPACE(STR_PAGES); \ RECOVER_UNUSED_SPACE(STR_PAGES); \
LOCK(Pg_lock(STR_PAGES)); \ LOCK(Pg_lock(STR_PAGES)); \
pg_hd = Pg_free_pg(STR_PAGES); \ pg_hd = Pg_free_pg(STR_PAGES); \
} \ } \
} \ } \
PgHd_str_in_use(pg_hd) = Pg_str_per_pg(STR_PAGES); \ PgHd_str_in_use(pg_hd) = Pg_str_per_pg(STR_PAGES); \
STR = (STR_TYPE *) PgHd_free_str(pg_hd); \ STR = (STR_TYPE *) PgHd_free_str(pg_hd); \
PgHd_free_str(pg_hd) = NULL; \ PgHd_free_str(pg_hd) = NULL; \
Pg_free_pg(STR_PAGES) = PgHd_next(pg_hd); \ Pg_free_pg(STR_PAGES) = PgHd_next(pg_hd); \
UPDATE_STATS(Pg_str_in_use(STR_PAGES), -PgHd_str_in_use(pg_hd)); \ UPDATE_STATS(Pg_str_in_use(STR_PAGES), -PgHd_str_in_use(pg_hd)); \
UPDATE_STATS(Pg_str_in_use(STR_PAGES), Pg_str_per_pg(STR_PAGES)); \ UPDATE_STATS(Pg_str_in_use(STR_PAGES), Pg_str_per_pg(STR_PAGES)); \
UNLOCK(Pg_lock(STR_PAGES)); \ UNLOCK(Pg_lock(STR_PAGES)); \
} \ } \
LOCAL_next_free_ans_node = STRUCT_NEXT(STR) LOCAL_next_free_ans_node = STRUCT_NEXT(STR)
#else #else
#define ALLOC_PAGE(PG_HD) \ #define ALLOC_PAGE(PG_HD) \
LOCK(Pg_lock(GLOBAL_PAGES_void)); \ LOCK(Pg_lock(GLOBAL_PAGES_void)); \
if (Pg_free_pg(GLOBAL_PAGES_void) == NULL) { \ if (Pg_free_pg(GLOBAL_PAGES_void) == NULL) { \
int i, shmid; \ int i, shmid; \
pg_hd_ptr pg_hd, aux_pg_hd; \ pg_hd_ptr pg_hd, aux_pg_hd; \
if ((shmid = shmget(IPC_PRIVATE, SHMMAX, SHM_R|SHM_W)) == -1) \ if ((shmid = shmget(IPC_PRIVATE, SHMMAX, SHM_R|SHM_W)) == -1) \
Yap_Error(FATAL_ERROR, TermNil, "shmget error (ALLOC_PAGE)"); \ Yap_Error(FATAL_ERROR, TermNil, "shmget error (ALLOC_PAGE)"); \
if ((pg_hd = (pg_hd_ptr) shmat(shmid, NULL, 0)) == (void *) -1) \ if ((pg_hd = (pg_hd_ptr) shmat(shmid, NULL, 0)) == (void *) -1) \
Yap_Error(FATAL_ERROR, TermNil, "shmat error (ALLOC_PAGE)"); \ Yap_Error(FATAL_ERROR, TermNil, "shmat error (ALLOC_PAGE)"); \
if (shmctl(shmid, IPC_RMID, 0) != 0) \ if (shmctl(shmid, IPC_RMID, 0) != 0) \
Yap_Error(FATAL_ERROR, TermNil, "shmctl error (ALLOC_PAGE)"); \ Yap_Error(FATAL_ERROR, TermNil, "shmctl error (ALLOC_PAGE)"); \
Pg_free_pg(GLOBAL_PAGES_void) = pg_hd; \ Pg_free_pg(GLOBAL_PAGES_void) = pg_hd; \
for (i = 1; i < SHMMAX / Yap_page_size; i++) { \ for (i = 1; i < SHMMAX / Yap_page_size; i++) { \
aux_pg_hd = (pg_hd_ptr)(((void *)pg_hd) + Yap_page_size); \ aux_pg_hd = (pg_hd_ptr)(((void *)pg_hd) + Yap_page_size); \
PgHd_next(pg_hd) = aux_pg_hd; \ PgHd_next(pg_hd) = aux_pg_hd; \
pg_hd = aux_pg_hd; \ pg_hd = aux_pg_hd; \
} \ } \
PgHd_next(pg_hd) = NULL; \ PgHd_next(pg_hd) = NULL; \
UPDATE_STATS(Pg_pg_alloc(GLOBAL_PAGES_void), SHMMAX / Yap_page_size); \ UPDATE_STATS(Pg_pg_alloc(GLOBAL_PAGES_void), SHMMAX / Yap_page_size); \
} \ } \
UPDATE_STATS(Pg_str_in_use(GLOBAL_PAGES_void), 1); \ UPDATE_STATS(Pg_str_in_use(GLOBAL_PAGES_void), 1); \
PG_HD = Pg_free_pg(GLOBAL_PAGES_void); \ PG_HD = Pg_free_pg(GLOBAL_PAGES_void); \
Pg_free_pg(GLOBAL_PAGES_void) = PgHd_next(PG_HD); \ Pg_free_pg(GLOBAL_PAGES_void) = PgHd_next(PG_HD); \
UNLOCK(Pg_lock(GLOBAL_PAGES_void)) UNLOCK(Pg_lock(GLOBAL_PAGES_void))
#define ALLOC_STRUCT(STR, STR_PAGES, STR_TYPE) \ #define ALLOC_STRUCT(STR, STR_PAGES, STR_TYPE) \
{ pg_hd_ptr pg_hd; \ { pg_hd_ptr pg_hd; \
LOCK(Pg_lock(STR_PAGES)); \ LOCK(Pg_lock(STR_PAGES)); \
UPDATE_STATS(Pg_str_in_use(STR_PAGES), 1); \ UPDATE_STATS(Pg_str_in_use(STR_PAGES), 1); \
if (Pg_free_pg(STR_PAGES)) { \ if (Pg_free_pg(STR_PAGES)) { \
pg_hd = Pg_free_pg(STR_PAGES); \ pg_hd = Pg_free_pg(STR_PAGES); \
PgHd_str_in_use(pg_hd)++; \ PgHd_str_in_use(pg_hd)++; \
STR = (STR_TYPE *) PgHd_free_str(pg_hd); \ STR = (STR_TYPE *) PgHd_free_str(pg_hd); \
if ((PgHd_free_str(pg_hd) = (void *) STRUCT_NEXT(STR)) == NULL) \ if ((PgHd_free_str(pg_hd) = (void *) STRUCT_NEXT(STR)) == NULL) \
if ((Pg_free_pg(STR_PAGES) = PgHd_next(pg_hd)) != NULL) \ if ((Pg_free_pg(STR_PAGES) = PgHd_next(pg_hd)) != NULL) \
PgHd_previous(PgHd_next(pg_hd)) = NULL; \ PgHd_previous(PgHd_next(pg_hd)) = NULL; \
UNLOCK(Pg_lock(STR_PAGES)); \ UNLOCK(Pg_lock(STR_PAGES)); \
} else { \ } else { \
int i; \ int i; \
UPDATE_STATS(Pg_pg_alloc(STR_PAGES), 1); \ UPDATE_STATS(Pg_pg_alloc(STR_PAGES), 1); \
UNLOCK(Pg_lock(STR_PAGES)); \ UNLOCK(Pg_lock(STR_PAGES)); \
ALLOC_PAGE(pg_hd); \ ALLOC_PAGE(pg_hd); \
PgHd_str_in_use(pg_hd) = 1; \ PgHd_str_in_use(pg_hd) = 1; \
PgHd_previous(pg_hd) = NULL; \ PgHd_previous(pg_hd) = NULL; \
STR = (STR_TYPE *) (pg_hd + 1); \ STR = (STR_TYPE *) (pg_hd + 1); \
PgHd_free_str(pg_hd) = (void *) ++STR; \ PgHd_free_str(pg_hd) = (void *) ++STR; \
for (i = Pg_str_per_pg(STR_PAGES); i != 2; i--) { \ for (i = Pg_str_per_pg(STR_PAGES); i != 2; i--) { \
STRUCT_NEXT(STR) = STR + 1; \ STRUCT_NEXT(STR) = STR + 1; \
STR++; \ STR++; \
} \ } \
STRUCT_NEXT(STR) = NULL; \ STRUCT_NEXT(STR) = NULL; \
STR = (STR_TYPE *) (pg_hd + 1); \ STR = (STR_TYPE *) (pg_hd + 1); \
LOCK(Pg_lock(STR_PAGES)); \ LOCK(Pg_lock(STR_PAGES)); \
if ((PgHd_next(pg_hd) = Pg_free_pg(STR_PAGES)) != NULL) \ if ((PgHd_next(pg_hd) = Pg_free_pg(STR_PAGES)) != NULL) \
PgHd_previous(PgHd_next(pg_hd)) = pg_hd; \ PgHd_previous(PgHd_next(pg_hd)) = pg_hd; \
Pg_free_pg(STR_PAGES) = pg_hd; \ Pg_free_pg(STR_PAGES) = pg_hd; \
UNLOCK(Pg_lock(STR_PAGES)); \ UNLOCK(Pg_lock(STR_PAGES)); \
} \ } \
} }
#define ALLOC_NEXT_FREE_STRUCT(STR, STR_PAGES, STR_TYPE) \ #define ALLOC_NEXT_FREE_STRUCT(STR, STR_PAGES, STR_TYPE) \
if ((STR = LOCAL_next_free_ans_node) == NULL) { \ if ((STR = LOCAL_next_free_ans_node) == NULL) { \
pg_hd_ptr pg_hd; \ pg_hd_ptr pg_hd; \
LOCK(Pg_lock(STR_PAGES)); \ LOCK(Pg_lock(STR_PAGES)); \
UPDATE_STATS(Pg_str_in_use(STR_PAGES), Pg_str_per_pg(STR_PAGES)); \ UPDATE_STATS(Pg_str_in_use(STR_PAGES), Pg_str_per_pg(STR_PAGES)); \
if (Pg_free_pg(STR_PAGES)) { \ if (Pg_free_pg(STR_PAGES)) { \
pg_hd = Pg_free_pg(STR_PAGES); \ pg_hd = Pg_free_pg(STR_PAGES); \
UPDATE_STATS(Pg_str_in_use(STR_PAGES), -PgHd_str_in_use(pg_hd)); \ UPDATE_STATS(Pg_str_in_use(STR_PAGES), -PgHd_str_in_use(pg_hd)); \
PgHd_str_in_use(pg_hd) = Pg_str_per_pg(STR_PAGES); \ PgHd_str_in_use(pg_hd) = Pg_str_per_pg(STR_PAGES); \
STR = (STR_TYPE *) PgHd_free_str(pg_hd); \ STR = (STR_TYPE *) PgHd_free_str(pg_hd); \
PgHd_free_str(pg_hd) = NULL; \ PgHd_free_str(pg_hd) = NULL; \
Pg_free_pg(STR_PAGES) = PgHd_next(pg_hd); \ Pg_free_pg(STR_PAGES) = PgHd_next(pg_hd); \
UNLOCK(Pg_lock(STR_PAGES)); \ UNLOCK(Pg_lock(STR_PAGES)); \
} else { \ } else { \
int i; \ int i; \
UPDATE_STATS(Pg_pg_alloc(STR_PAGES), 1); \ UPDATE_STATS(Pg_pg_alloc(STR_PAGES), 1); \
UNLOCK(Pg_lock(STR_PAGES)); \ UNLOCK(Pg_lock(STR_PAGES)); \
ALLOC_PAGE(pg_hd); \ ALLOC_PAGE(pg_hd); \
PgHd_str_in_use(pg_hd) = Pg_str_per_pg(STR_PAGES); \ PgHd_str_in_use(pg_hd) = Pg_str_per_pg(STR_PAGES); \
PgHd_free_str(pg_hd) = NULL; \ PgHd_free_str(pg_hd) = NULL; \
PgHd_previous(pg_hd) = NULL; \ PgHd_previous(pg_hd) = NULL; \
PgHd_next(pg_hd) = NULL; \ PgHd_next(pg_hd) = NULL; \
STR = (STR_TYPE *) (pg_hd + 1); \ STR = (STR_TYPE *) (pg_hd + 1); \
for (i = Pg_str_per_pg(STR_PAGES); i != 1; i--) { \ for (i = Pg_str_per_pg(STR_PAGES); i != 1; i--) { \
STRUCT_NEXT(STR) = STR + 1; \ STRUCT_NEXT(STR) = STR + 1; \
STR++; \ STR++; \
} \ } \
STRUCT_NEXT(STR) = NULL; \ STRUCT_NEXT(STR) = NULL; \
STR = (STR_TYPE *) (pg_hd + 1); \ STR = (STR_TYPE *) (pg_hd + 1); \
} \ } \
} \ } \
LOCAL_next_free_ans_node = STRUCT_NEXT(STR) LOCAL_next_free_ans_node = STRUCT_NEXT(STR)
#endif /* LIMIT_TABLING */ #endif /* LIMIT_TABLING */
#define FREE_PAGE(PG_HD) \ #define FREE_PAGE(PG_HD) \
LOCK(Pg_lock(GLOBAL_PAGES_void)); \ LOCK(Pg_lock(GLOBAL_PAGES_void)); \
UPDATE_STATS(Pg_str_in_use(GLOBAL_PAGES_void), -1); \ UPDATE_STATS(Pg_str_in_use(GLOBAL_PAGES_void), -1); \
PgHd_next(PG_HD) = Pg_free_pg(GLOBAL_PAGES_void); \ PgHd_next(PG_HD) = Pg_free_pg(GLOBAL_PAGES_void); \
Pg_free_pg(GLOBAL_PAGES_void) = PG_HD; \ Pg_free_pg(GLOBAL_PAGES_void) = PG_HD; \
UNLOCK(Pg_lock(GLOBAL_PAGES_void)) UNLOCK(Pg_lock(GLOBAL_PAGES_void))
#define FREE_STRUCT(STR, STR_PAGES, STR_TYPE) \ #define FREE_STRUCT(STR, STR_PAGES, STR_TYPE) \
{ pg_hd_ptr pg_hd; \ { pg_hd_ptr pg_hd; \
pg_hd = PAGE_HEADER(STR); \ pg_hd = PAGE_HEADER(STR); \
LOCK(Pg_lock(STR_PAGES)); \ LOCK(Pg_lock(STR_PAGES)); \
UPDATE_STATS(Pg_str_in_use(STR_PAGES), -1); \ UPDATE_STATS(Pg_str_in_use(STR_PAGES), -1); \
if (--PgHd_str_in_use(pg_hd) == 0) { \ if (--PgHd_str_in_use(pg_hd) == 0) { \
UPDATE_STATS(Pg_pg_alloc(STR_PAGES), -1); \ UPDATE_STATS(Pg_pg_alloc(STR_PAGES), -1); \
if (PgHd_previous(pg_hd)) { \ if (PgHd_previous(pg_hd)) { \
if ((PgHd_next(PgHd_previous(pg_hd)) = PgHd_next(pg_hd)) != NULL) \ if ((PgHd_next(PgHd_previous(pg_hd)) = PgHd_next(pg_hd)) != NULL) \
PgHd_previous(PgHd_next(pg_hd)) = PgHd_previous(pg_hd); \ PgHd_previous(PgHd_next(pg_hd)) = PgHd_previous(pg_hd); \
} else { \ } else { \
if ((Pg_free_pg(STR_PAGES) = PgHd_next(pg_hd)) != NULL) \ if ((Pg_free_pg(STR_PAGES) = PgHd_next(pg_hd)) != NULL) \
PgHd_previous(PgHd_next(pg_hd)) = NULL; \ PgHd_previous(PgHd_next(pg_hd)) = NULL; \
} \ } \
UNLOCK(Pg_lock(STR_PAGES)); \ UNLOCK(Pg_lock(STR_PAGES)); \
FREE_PAGE(pg_hd); \ FREE_PAGE(pg_hd); \
} else { \ } else { \
if ((STRUCT_NEXT(STR) = (STR_TYPE *) PgHd_free_str(pg_hd)) == NULL) { \ if ((STRUCT_NEXT(STR) = (STR_TYPE *) PgHd_free_str(pg_hd)) == NULL) { \
PgHd_previous(pg_hd) = NULL; \ PgHd_previous(pg_hd) = NULL; \
if ((PgHd_next(pg_hd) = Pg_free_pg(STR_PAGES)) != NULL) \ if ((PgHd_next(pg_hd) = Pg_free_pg(STR_PAGES)) != NULL) \
PgHd_previous(PgHd_next(pg_hd)) = pg_hd; \ PgHd_previous(PgHd_next(pg_hd)) = pg_hd; \
Pg_free_pg(STR_PAGES) = pg_hd; \ Pg_free_pg(STR_PAGES) = pg_hd; \
} \ } \
PgHd_free_str(pg_hd) = (void *) STR; \ PgHd_free_str(pg_hd) = (void *) STR; \
UNLOCK(Pg_lock(STR_PAGES)); \ UNLOCK(Pg_lock(STR_PAGES)); \
} \ } \
} }
#endif /* --------------------------- MEMORY_ALLOC_SCHEME ---------------------------- */ #endif /* --------------------------- MEMORY_ALLOC_SCHEME -------------------------------------------- */
#ifdef YAPOR #ifdef YAPOR
#define ALLOC_BLOCK(BLOCK, SIZE) \ #define ALLOC_BLOCK(BLOCK, SIZE) \
if ((BLOCK = (void *) Yap_AllocCodeSpace(SIZE)) == NULL) \ if ((BLOCK = (void *) Yap_AllocCodeSpace(SIZE)) == NULL) \
Yap_Error(FATAL_ERROR, TermNil, "Yap_AllocCodeSpace error (ALLOC_BLOCK)") Yap_Error(FATAL_ERROR, TermNil, "Yap_AllocCodeSpace error (ALLOC_BLOCK)")
#define FREE_BLOCK(BLOCK) \ #define FREE_BLOCK(BLOCK) \
Yap_FreeCodeSpace((char *) (BLOCK)) Yap_FreeCodeSpace((char *) (BLOCK))
#else /* TABLING */ #else /* TABLING */
#define ALLOC_BLOCK(BLOCK, SIZE) \ #define ALLOC_BLOCK(BLOCK, SIZE) \
if ((BLOCK = malloc(SIZE)) == NULL) \ if ((BLOCK = malloc(SIZE)) == NULL) \
Yap_Error(FATAL_ERROR, TermNil, "malloc error (ALLOC_BLOCK)") Yap_Error(FATAL_ERROR, TermNil, "malloc error (ALLOC_BLOCK)")
#define FREE_BLOCK(BLOCK) \ #define FREE_BLOCK(BLOCK) \
free(BLOCK) free(BLOCK)
#endif /* YAPOR - TABLING */ #endif /* YAPOR - TABLING */
#define ALLOC_HASH_BUCKETS(BUCKET_PTR, NUM_BUCKETS) \ #define ALLOC_HASH_BUCKETS(BUCKET_PTR, NUM_BUCKETS) \
{ int i; void **ptr; \ { int i; void **ptr; \
ALLOC_BLOCK(ptr, NUM_BUCKETS * sizeof(void *)); \ ALLOC_BLOCK(ptr, NUM_BUCKETS * sizeof(void *)); \
BUCKET_PTR = (void *) ptr; \ BUCKET_PTR = (void *) ptr; \
for (i = NUM_BUCKETS; i != 0; i--) \ for (i = NUM_BUCKETS; i != 0; i--) \
*ptr++ = NULL; \ *ptr++ = NULL; \
} }
#define FREE_HASH_BUCKETS(BUCKET_PTR) FREE_BLOCK(BUCKET_PTR) #define FREE_HASH_BUCKETS(BUCKET_PTR) FREE_BLOCK(BUCKET_PTR)

4
OPTYap/opt.preds.c
View File

@ -684,7 +684,7 @@ Int p_abolish_table(void) {
sg_node = TrNode_child(TabEnt_subgoal_trie(tab_ent)); sg_node = TrNode_child(TabEnt_subgoal_trie(tab_ent));
if (sg_node) { if (sg_node) {
TrNode_child(TabEnt_subgoal_trie(tab_ent)) = NULL; TrNode_child(TabEnt_subgoal_trie(tab_ent)) = NULL;
free_subgoal_trie_branch(sg_node, TabEnt_arity(tab_ent), 0); free_subgoal_trie_branch(sg_node, TabEnt_arity(tab_ent), 0, TRAVERSE_POSITION_FIRST);
} }
return (TRUE); return (TRUE);
} }
@ -704,7 +704,7 @@ Int p_abolish_all_tables(void) {
sg_node = TrNode_child(TabEnt_subgoal_trie(tab_ent)); sg_node = TrNode_child(TabEnt_subgoal_trie(tab_ent));
if (sg_node) { if (sg_node) {
TrNode_child(TabEnt_subgoal_trie(tab_ent)) = NULL; TrNode_child(TabEnt_subgoal_trie(tab_ent)) = NULL;
free_subgoal_trie_branch(sg_node, TabEnt_arity(tab_ent), 0); free_subgoal_trie_branch(sg_node, TabEnt_arity(tab_ent), 0, TRAVERSE_POSITION_FIRST);
} }
tab_ent = TabEnt_next(tab_ent); tab_ent = TabEnt_next(tab_ent);
} }

4
OPTYap/opt.proto.h
View File

@ -67,8 +67,8 @@ sg_fr_ptr subgoal_search(yamop *preg, CELL **Yaddr);
ans_node_ptr answer_search(sg_fr_ptr sg_fr, CELL *subs_ptr); ans_node_ptr answer_search(sg_fr_ptr sg_fr, CELL *subs_ptr);
void load_answer_trie(ans_node_ptr ans_node, CELL *subs_ptr); void load_answer_trie(ans_node_ptr ans_node, CELL *subs_ptr);
void private_completion(sg_fr_ptr sg_fr); void private_completion(sg_fr_ptr sg_fr);
void free_subgoal_trie_branch(sg_node_ptr node, int nodes_left, int nodes_extra); void free_subgoal_trie_branch(sg_node_ptr node, int nodes_left, int nodes_extra, int position);
void free_answer_trie_branch(ans_node_ptr node); void free_answer_trie_branch(ans_node_ptr node, int position);
void update_answer_trie(sg_fr_ptr sg_fr); void update_answer_trie(sg_fr_ptr sg_fr);
void traverse_table(tab_ent_ptr tab_ent, int show_table); void traverse_table(tab_ent_ptr tab_ent, int show_table);
void table_stats(void); void table_stats(void);

47
OPTYap/tab.insts.i
View File

@ -95,9 +95,10 @@
/* store deterministic generator choice point */ \ /* store deterministic generator choice point */ \
HBREG = H; \ HBREG = H; \
store_yaam_reg_cpdepth(gcp); \ store_yaam_reg_cpdepth(gcp); \
gcp->cp_tr = TR; \
gcp->cp_ap = COMPLETION; \ gcp->cp_ap = COMPLETION; \
gcp->cp_b = B; \ gcp->cp_b = B; \
gcp->cp_tr = TR; \
gcp->cp_h = H; \
DET_GEN_CP(gcp)->cp_sg_fr = SG_FR; \ DET_GEN_CP(gcp)->cp_sg_fr = SG_FR; \
store_low_level_trace_info(DET_GEN_CP(gcp), TAB_ENT); \ store_low_level_trace_info(DET_GEN_CP(gcp), TAB_ENT); \
set_cut((CELL *)gcp, B); \ set_cut((CELL *)gcp, B); \
@ -748,6 +749,7 @@
choiceptr gcp = NORM_CP(DET_GEN_CP(subs_ptr) - 1); choiceptr gcp = NORM_CP(DET_GEN_CP(subs_ptr) - 1);
sg_fr_ptr sg_fr = GEN_CP(B)->cp_sg_fr; sg_fr_ptr sg_fr = GEN_CP(B)->cp_sg_fr;
DET_GEN_CP(gcp)->cp_sg_fr = sg_fr; DET_GEN_CP(gcp)->cp_sg_fr = sg_fr;
gcp->cp_h = B->cp_h;
#ifdef DEPTH_LIMIT #ifdef DEPTH_LIMIT
gcp->cp_depth = B->cp_depth; gcp->cp_depth = B->cp_depth;
#endif /* DEPTH_LIMIT */ #endif /* DEPTH_LIMIT */
@ -775,6 +777,7 @@
choiceptr gcp = NORM_CP(DET_GEN_CP(subs_ptr) - 1); choiceptr gcp = NORM_CP(DET_GEN_CP(subs_ptr) - 1);
sg_fr_ptr sg_fr = GEN_CP(B)->cp_sg_fr; sg_fr_ptr sg_fr = GEN_CP(B)->cp_sg_fr;
DET_GEN_CP(gcp)->cp_sg_fr = sg_fr; DET_GEN_CP(gcp)->cp_sg_fr = sg_fr;
gcp->cp_h = B->cp_h;
#ifdef DEPTH_LIMIT #ifdef DEPTH_LIMIT
gcp->cp_depth = B->cp_depth; gcp->cp_depth = B->cp_depth;
#endif /* DEPTH_LIMIT */ #endif /* DEPTH_LIMIT */
@ -811,19 +814,12 @@
sg_fr = GEN_CP(gcp)->cp_sg_fr; sg_fr = GEN_CP(gcp)->cp_sg_fr;
subs_ptr = (CELL *)(GEN_CP(gcp) + 1) + PREG->u.s.s; subs_ptr = (CELL *)(GEN_CP(gcp) + 1) + PREG->u.s.s;
} }
#ifdef TABLING_ERRORS #if defined(TABLING_ERRORS) && !defined(DETERMINISTIC_TABLING)
{ {
sg_fr_ptr aux_sg_fr;
int i, j, arity_args, arity_subs; int i, j, arity_args, arity_subs;
CELL *aux_args; CELL *aux_args;
CELL *aux_subs; CELL *aux_subs;
aux_sg_fr = LOCAL_top_sg_fr;
while (aux_sg_fr && aux_sg_fr != sg_fr)
aux_sg_fr = SgFr_next(aux_sg_fr);
if (aux_sg_fr == NULL)
TABLING_ERROR_MESSAGE("aux_sg_fr == NULL (table_new_answer)");
arity_args = PREG->u.s.s; arity_args = PREG->u.s.s;
arity_subs = *subs_ptr; arity_subs = *subs_ptr;
aux_args = (CELL *)(GEN_CP(gcp) + 1); aux_args = (CELL *)(GEN_CP(gcp) + 1);
@ -838,7 +834,7 @@
TABLING_ERROR_MESSAGE("j == arity_args (table_new_answer)"); TABLING_ERROR_MESSAGE("j == arity_args (table_new_answer)");
} }
} }
#endif /* TABLING_ERRORS */ #endif /* TABLING_ERRORS && !DETERMINISTIC_TABLING */
#ifdef TABLE_LOCK_AT_ENTRY_LEVEL #ifdef TABLE_LOCK_AT_ENTRY_LEVEL
LOCK(SgFr_lock(sg_fr)); LOCK(SgFr_lock(sg_fr));
#endif /* TABLE_LOCK_LEVEL */ #endif /* TABLE_LOCK_LEVEL */
@ -1001,19 +997,23 @@
#endif /* TABLING_ERRORS */ #endif /* TABLING_ERRORS */
UNLOCK(SgFr_lock(sg_fr)); UNLOCK(SgFr_lock(sg_fr));
if (IS_BATCHED_GEN_CP(gcp)) { if (IS_BATCHED_GEN_CP(gcp)) {
/* if the number of substitution variables is zero, #ifdef TABLING_EARLY_COMPLETION
an answer is sufficient to perform an early completion */ if (gcp == PROTECT_FROZEN_B(B) && (*subs_ptr == 0 || gcp->cp_ap == COMPLETION)) {
#ifdef DETERMINISTIC_TABLING /* if the current generator choice point is the topmost choice point and the current */
if (IS_DET_GEN_CP(gcp) && gcp == B) { /* call is deterministic (i.e., the number of substitution variables is zero or */
/* there are no more alternatives) then the current answer is deterministic and we */
/* can perform an early completion and remove the current generator choice point */
private_completion(sg_fr); private_completion(sg_fr);
B = B->cp_b; B = B->cp_b;
SET_BB(PROTECT_FROZEN_B(B)); SET_BB(PROTECT_FROZEN_B(B));
} else } else if (*subs_ptr == 0) {
#endif /* DETERMINISTIC_TABLING */ /* if the number of substitution variables is zero, an answer is sufficient to perform */
if (*subs_ptr == 0 && gcp->cp_ap != NULL) { /* an early completion, but the current generator choice point cannot be removed */
gcp->cp_ap = COMPLETION;
mark_as_completed(sg_fr); mark_as_completed(sg_fr);
if (gcp->cp_ap != NULL)
gcp->cp_ap = COMPLETION;
} }
#endif /* TABLING_EARLY_COMPLETION */
/* deallocate and procceed */ /* deallocate and procceed */
PREG = (yamop *) YENV[E_CP]; PREG = (yamop *) YENV[E_CP];
PREFETCH_OP(PREG); PREFETCH_OP(PREG);
@ -1025,12 +1025,15 @@
#endif /* DEPTH_LIMIT */ #endif /* DEPTH_LIMIT */
GONext(); GONext();
} else { } else {
/* if the number of substitution variables is zero, #ifdef TABLING_EARLY_COMPLETION
an answer is sufficient to perform an early completion */ if (*subs_ptr == 0) {
if (*subs_ptr == 0 && gcp->cp_ap != ANSWER_RESOLUTION) { /* if the number of substitution variables is zero, an answer is sufficient to perform */
gcp->cp_ap = COMPLETION; /* an early completion, but the current generator choice point cannot be removed */
mark_as_completed(sg_fr); mark_as_completed(sg_fr);
if (gcp->cp_ap != ANSWER_RESOLUTION)
gcp->cp_ap = COMPLETION;
} }
#endif /* TABLING_EARLY_COMPLETION */
/* fail */ /* fail */
goto fail; goto fail;
} }

32
OPTYap/tab.macros.h
View File

@ -57,6 +57,23 @@ STD_PROTO(static inline tg_sol_fr_ptr CUT_prune_tg_solution_frames, (tg_sol_fr_p
/* ----------------- **
** Defines **
** ----------------- */
#define TRAVERSE_MODE_NORMAL 0
#define TRAVERSE_MODE_FLOAT 1
#define TRAVERSE_MODE_FLOAT2 2
#define TRAVERSE_MODE_FLOAT_END 3
#define TRAVERSE_MODE_LONG 4
#define TRAVERSE_MODE_LONG_END 5
/* do not change order !!! */
#define TRAVERSE_POSITION_NEXT 0
#define TRAVERSE_POSITION_FIRST 1
#define TRAVERSE_POSITION_LAST 2
/* ----------------------- ** /* ----------------------- **
** Tabling Macros ** ** Tabling Macros **
** ----------------------- */ ** ----------------------- */
@ -591,8 +608,10 @@ void abolish_incomplete_subgoals(choiceptr prune_cp) {
UNLOCK(SgFr_lock(sg_fr)); UNLOCK(SgFr_lock(sg_fr));
} else if (SgFr_first_answer(sg_fr) == SgFr_answer_trie(sg_fr)) { } else if (SgFr_first_answer(sg_fr) == SgFr_answer_trie(sg_fr)) {
/* yes answer --> complete */ /* yes answer --> complete */
/* at this point the subgoal should be already completed (early completion) */ #ifndef TABLING_EARLY_COMPLETION
/* SgFr_state(sg_fr) = complete; */ /* with early completion, at this point the subgoal should be already completed */
SgFr_state(sg_fr) = complete;
#endif /* TABLING_EARLY_COMPLETION */
UNLOCK(SgFr_lock(sg_fr)); UNLOCK(SgFr_lock(sg_fr));
} else { } else {
/* answers --> incomplete/ready */ /* answers --> incomplete/ready */
@ -609,7 +628,7 @@ void abolish_incomplete_subgoals(choiceptr prune_cp) {
node = TrNode_child(SgFr_answer_trie(sg_fr)); node = TrNode_child(SgFr_answer_trie(sg_fr));
TrNode_child(SgFr_answer_trie(sg_fr)) = NULL; TrNode_child(SgFr_answer_trie(sg_fr)) = NULL;
UNLOCK(SgFr_lock(sg_fr)); UNLOCK(SgFr_lock(sg_fr));
free_answer_trie_branch(node); free_answer_trie_branch(node, TRAVERSE_POSITION_FIRST);
#endif /* INCOMPLETE_TABLING */ #endif /* INCOMPLETE_TABLING */
} }
#ifdef LIMIT_TABLING #ifdef LIMIT_TABLING
@ -919,7 +938,12 @@ void CUT_validate_tg_answers(tg_sol_fr_ptr valid_solutions) {
while (valid_solutions) { while (valid_solutions) {
first_answer = last_answer = NULL; first_answer = last_answer = NULL;
sg_fr = GEN_CP(TgSolFr_gen_cp(valid_solutions))->cp_sg_fr; #ifdef DETERMINISTIC_TABLING
if (IS_DET_GEN_CP(TgSolFr_gen_cp(valid_solutions)))
sg_fr = DET_GEN_CP(TgSolFr_gen_cp(valid_solutions))->cp_sg_fr;
else
#endif /* DETERMINISTIC_TABLING */
sg_fr = GEN_CP(TgSolFr_gen_cp(valid_solutions))->cp_sg_fr;
ltt_valid_solutions = valid_solutions; ltt_valid_solutions = valid_solutions;
valid_solutions = TgSolFr_next(valid_solutions); valid_solutions = TgSolFr_next(valid_solutions);
do { do {

7
OPTYap/tab.suspend.c
View File

@ -46,7 +46,12 @@ void public_completion(void) {
sg_fr_ptr top_sg_fr; sg_fr_ptr top_sg_fr;
/* complete subgoals */ /* complete subgoals */
top_sg_fr = SgFr_next(GEN_CP(LOCAL_top_cp)->cp_sg_fr); #ifdef DETERMINISTIC_TABLING
if (IS_DET_GEN_CP(LOCAL_top_cp))
top_sg_fr = SgFr_next(DET_GEN_CP(LOCAL_top_cp)->cp_sg_fr);
else
#endif /* DETERMINISTIC_TABLING */
top_sg_fr = SgFr_next(GEN_CP(LOCAL_top_cp)->cp_sg_fr);
do { do {
mark_as_completed(LOCAL_top_sg_fr); mark_as_completed(LOCAL_top_sg_fr);
LOCAL_top_sg_fr = SgFr_next(LOCAL_top_sg_fr); LOCAL_top_sg_fr = SgFr_next(LOCAL_top_sg_fr);

575
OPTYap/tab.tries.c
View File

File diff suppressed because it is too large Load Diff

21
OPTYap/tab.tries.insts.i
View File

@ -521,10 +521,11 @@
** trie_extension ** ** trie_extension **
** ------------------------ */ ** ------------------------ */
#define stack_trie_extension_instr() \ #define stack_trie_extension_instr() \
*aux_ptr-- = TrNode_entry(node); \ *aux_ptr-- = 0; /* float/longint extension mark */ \
*aux_ptr = heap_arity + 1; \ *aux_ptr-- = TrNode_entry(node); \
YENV = aux_ptr; \ *aux_ptr = heap_arity + 2; \
YENV = aux_ptr; \
next_trie_instruction(node) next_trie_instruction(node)
@ -1233,13 +1234,15 @@
Term t; Term t;
#if SIZEOF_DOUBLE == 2 * SIZEOF_INT_P #if SIZEOF_DOUBLE == 2 * SIZEOF_INT_P
heap_arity -= 4;
*t_dbl = *++aux_ptr; *t_dbl = *++aux_ptr;
++aux_ptr; /* jump the float/longint extension mark */
*(t_dbl + 1) = *++aux_ptr; *(t_dbl + 1) = *++aux_ptr;
heap_arity -= 2;
#else /* SIZEOF_DOUBLE == SIZEOF_INT_P */ #else /* SIZEOF_DOUBLE == SIZEOF_INT_P */
heap_arity -= 2;
*t_dbl = *++aux_ptr; *t_dbl = *++aux_ptr;
heap_arity -= 1;
#endif /* SIZEOF_DOUBLE x SIZEOF_INT_P */ #endif /* SIZEOF_DOUBLE x SIZEOF_INT_P */
++aux_ptr; /* jump the float/longint extension mark */
t = MkFloatTerm(dbl); t = MkFloatTerm(dbl);
stack_trie_float_longint_instr(); stack_trie_float_longint_instr();
ENDPBOp(); ENDPBOp();
@ -1266,9 +1269,11 @@
int heap_arity = *aux_ptr; int heap_arity = *aux_ptr;
int vars_arity = *(aux_ptr + heap_arity + 1); int vars_arity = *(aux_ptr + heap_arity + 1);
int subs_arity = *(aux_ptr + heap_arity + 2); int subs_arity = *(aux_ptr + heap_arity + 2);
Term t = MkLongIntTerm(*++aux_ptr); Term t;
heap_arity -= 1; heap_arity -= 2;
t = MkLongIntTerm(*++aux_ptr);
++aux_ptr; /* jump the float/longint extension mark */
stack_trie_float_longint_instr(); stack_trie_float_longint_instr();
ENDPBOp(); ENDPBOp();