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

Merge branch 'master' of ssh://git.dcc.fc.up.pt/yap-6.3

Browse Source
This commit is contained in:
Vítor Santos Costa 2014-11-25 12:04:05 +00:00
commit 1ca062f558
8 changed files with 316 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
C/absmi.c
View File

@ -1493,12 +1493,16 @@ spy_goal( USES_REGS1 )
HR += 2;
{
PredEntry *pt0;
#if THREADS
LOCK(GLOBAL_ThreadHandlesLock);
#endif
pt0 = SpyCode;
P_before_spy = P;
P = pt0->CodeOfPred;
/* for profiler */
#if THREADS
UNLOCK(GLOBAL_ThreadHandlesLock);
#endif
#ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace)
low_level_trace(enter_pred,pt0,XREGS+1);

4
OPTYap/locks_x86.h
View File

@ -71,10 +71,10 @@ extern int debug_locks;
__BASE_FILE__, __LINE__,&(LOCK_VAR)); \
spin_unlock((spinlock_t *)&(LOCK_VAR))
#else
#define LOCK(LOCK_VAR) do { \
#define LOCK(LOCK_VAR) { do { \
if (TRY_LOCK(&(LOCK_VAR))) break; \
while (IS_LOCKED(LOCK_VAR)) continue; \
} while (1)
} while (1); }
#define IS_LOCKED(LOCK_VAR) ((LOCK_VAR) != 0)
#define IS_UNLOCKED(LOCK_VAR) ((LOCK_VAR) == 0)
#define UNLOCK(LOCK_VAR) spin_unlock((spinlock_t *)&(LOCK_VAR))

6
library/tries/base_dbtries.c
View File

@ -238,9 +238,11 @@ YAP_Term trie_depth_breadth(TrEntry trie, TrEntry db_trie, YAP_Int opt_level, YA
set_depth_breadth_reduction_current_data(NULL);
/* We only need to simplify the trie once! */
/* This can be a 10% overhead for sld cases :-( */
// printf("simplification\n"); trie_print(trie);
if (TrNode_child(TrEntry_trie(trie)))
simplification_reduction(trie);
while (TrNode_child(TrEntry_trie(trie))) {
// printf("depth\n"); trie_print(trie);
nested_trie = depth_reduction(trie, depth_node, opt_level);
if (nested_trie) {
set_depth_breadth_reduction_current_data(get_data_from_trie_node(nested_trie));
@ -248,6 +250,7 @@ YAP_Term trie_depth_breadth(TrEntry trie, TrEntry db_trie, YAP_Int opt_level, YA
*end_counter = core_get_label_counter();
return YAP_MkApplTerm((YAP_Functor)(~ApplTag & TrNode_entry(TrNode_parent(nested_trie))), 1, &TrNode_entry(nested_trie));
}
// printf("breadth\n"); trie_print(trie);
nested_trie = breadth_reduction(trie, breadth_node, opt_level);
if (nested_trie) {
set_depth_breadth_reduction_current_data(get_data_from_trie_node(nested_trie));
@ -276,7 +279,8 @@ TrData trie_get_depth_breadth_reduction_current_data(void) {
void trie_replace_nested_trie(TrEntry trie, YAP_Int nested_trie_id, YAP_Term new_term) {
core_depth_breadth_trie_replace_nested_trie(TrNode_child(TrEntry_trie(trie)), nested_trie_id, new_term);
CURRENT_TRIE = trie;
core_depth_breadth_trie_replace_nested_trie(TrNode_child(TrEntry_trie(trie)), nested_trie_id, new_term, &trie_data_construct, &trie_data_destruct);
return;
}

33
library/tries/base_tries.c
View File

@ -74,8 +74,23 @@ void trie_data_destruct(TrNode node) {
data = (TrData) GET_DATA_FROM_LEAF_TRIE_NODE(node);
trie = TrData_trie(data);
if (data == TrEntry_traverse_data(trie))
if (data == TrEntry_traverse_data(trie)) {
if (CURRENT_TRAVERSE_MODE == TRAVERSE_MODE_FORWARD) {
TrEntry_traverse_data(trie) = TrData_previous(data);
} else {
if (TrData_next(data)) {
TrEntry_traverse_data(trie) = TrData_next(data);
} else {
TrData special;
new_struct(special, TYPE_TR_DATA, SIZEOF_TR_DATA);
TrData_next(special) = NULL;
TrData_previous(special) = TrData_previous(data);
TrData_trie(special) = NULL;
TrData_leaf(special) = NULL;
TrEntry_traverse_data(trie) = special; /* This special data is necessery to allow proper backwards traverse when the last entry is removed this is freed only if the trie is kept traversing */
}
}
}
if (TrData_next(data)) {
TrData_previous(TrData_next(data)) = TrData_previous(data);
TrData_next(TrData_previous(data)) = TrData_next(data);
@ -211,10 +226,19 @@ TrData trie_traverse_init(TrEntry trie, TrData init_data) {
TrData trie_traverse_cont(TrEntry trie) {
TrData data;
TrData data, temp = NULL;
data = TrEntry_traverse_data(trie);
if (data) {
if (!TrData_trie(data)) {
if (TrEntry_first_data(trie)) {
temp = data;
} else {
free_trie_data(data);
data = NULL;
TrEntry_traverse_data(trie) = NULL;
return NULL;
}
}
if (CURRENT_TRAVERSE_MODE == TRAVERSE_MODE_FORWARD)
data = TrData_next(data);
else {
@ -223,6 +247,8 @@ TrData trie_traverse_cont(TrEntry trie) {
data = NULL;
}
TrEntry_traverse_data(trie) = data;
if (temp)
free_trie_data(temp);
}
return data;
}
@ -325,7 +351,6 @@ void trie_print(TrEntry trie) {
void trie_data_construct(TrNode node) {
TrData data;
new_trie_data(data, CURRENT_TRIE, node);
PUT_DATA_IN_LEAF_TRIE_NODE(node, data);
return;

112
library/tries/core_dbtries.c
View File

@ -210,9 +210,9 @@ int traverse_get_counter(TrNode node);
YAP_Term generate_label(YAP_Int Index);
YAP_Term update_depth_breadth_trie(TrEngine engine, TrNode root, YAP_Int opt_level, void (*construct_function)(TrNode), void (*destruct_function)(TrNode), void (*copy_function)(TrNode, TrNode), void (*correct_order_function)(void));
YAP_Term get_return_node_term(TrNode node);
void traverse_and_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_Term new_term);
TrNode replace_nested_trie(TrNode node, TrNode child, YAP_Term new_term);
void check_attach_childs(TrNode search_child, TrNode existing_child);
void traverse_and_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_Term new_term, void (*construct_function)(TrNode), void (*destruct_function)(TrNode));
TrNode replace_nested_trie(TrNode node, TrNode child, YAP_Term new_term, void (*construct_function)(TrNode), void (*destruct_function)(TrNode));
void check_attach_childs(TrNode parent, TrNode search_child, TrNode existing_child, void (*construct_function)(TrNode), void (*destruct_function)(TrNode));
TrNode get_simplification_sibling(TrNode node);
TrNode check_parent_first(TrNode node);
TrNode TrNode_myparent(TrNode node);
@ -257,18 +257,18 @@ void core_set_trie_db_opt_min_prefix(YAP_Int min_prefix) {
void core_depth_breadth_trie_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_Term new_term) {
traverse_and_replace_nested_trie(node, nested_trie_id, new_term);
void core_depth_breadth_trie_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_Term new_term, void (*construct_function)(TrNode), void (*destruct_function)(TrNode)) {
traverse_and_replace_nested_trie(node, nested_trie_id, new_term, construct_function, destruct_function);
return;
}
inline
void traverse_and_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_Term new_term) {
void traverse_and_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_Term new_term, void (*construct_function)(TrNode), void (*destruct_function)(TrNode)) {
TrNode child, temp;
if (TrNode_entry(node) == PairEndTag) {
if (TrNode_next(node))
traverse_and_replace_nested_trie(TrNode_next(node), nested_trie_id, new_term);
traverse_and_replace_nested_trie(TrNode_next(node), nested_trie_id, new_term, construct_function, destruct_function);
return;
} else if (IS_HASH_NODE(node)) {
printf("HASH NODE ERROR: db_tries do not support hash nodes.\n");
@ -280,7 +280,7 @@ void traverse_and_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_T
do {
if ((node = *--bucket)) {
do {
traverse_and_replace_nested_trie(node, nested_trie_id, new_term);
traverse_and_replace_nested_trie(node, nested_trie_id, new_term, construct_function, destruct_function);
node = TrNode_next(node);
} while(node);
}
@ -303,13 +303,13 @@ void traverse_and_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_T
do {
if (YAP_IntOfTerm(TrNode_entry(child)) == nested_trie_id) {
temp = TrNode_previous(node);
node = replace_nested_trie(node, child, new_term);
node = replace_nested_trie(node, child, new_term, construct_function, destruct_function);
if (temp) {
temp = TrNode_next(node);
if (temp)
node = temp;
} else {
traverse_and_replace_nested_trie(TrNode_child(node), nested_trie_id, new_term);
traverse_and_replace_nested_trie(TrNode_child(node), nested_trie_id, new_term, construct_function, destruct_function);
return;
}
}
@ -322,10 +322,10 @@ void traverse_and_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_T
do {
if (YAP_IntOfTerm(TrNode_entry(child)) == nested_trie_id) {
temp = TrNode_next(node);
node = replace_nested_trie(node, child, new_term);
traverse_and_replace_nested_trie(TrNode_child(node), nested_trie_id, new_term);
node = replace_nested_trie(node, child, new_term, construct_function, destruct_function);
traverse_and_replace_nested_trie(TrNode_child(node), nested_trie_id, new_term, construct_function, destruct_function);
if(temp)
traverse_and_replace_nested_trie(temp, nested_trie_id, new_term);
traverse_and_replace_nested_trie(temp, nested_trie_id, new_term, construct_function, destruct_function);
return;
}
child = TrNode_next(child);
@ -333,17 +333,16 @@ void traverse_and_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_T
}
}
}
traverse_and_replace_nested_trie(TrNode_child(node), nested_trie_id, new_term);
traverse_and_replace_nested_trie(TrNode_child(node), nested_trie_id, new_term, construct_function, destruct_function);
if (TrNode_next(node))
traverse_and_replace_nested_trie(TrNode_next(node), nested_trie_id, new_term);
traverse_and_replace_nested_trie(TrNode_next(node), nested_trie_id, new_term, construct_function, destruct_function);
}
return;
}
/* fixmeeee */
TrNode replace_nested_trie(TrNode node, TrNode child, YAP_Term new_term) {
TrNode replace_nested_trie(TrNode node, TrNode child, YAP_Term new_term, void (*construct_function)(TrNode), void (*destruct_function)(TrNode)) {
TrNode newnode, temp, newnodef = NULL;
YAP_Term term_search = (YAP_Term) NULL;
if (YAP_IsApplTerm(new_term)) {
YAP_Term new_term_functor = ApplTag | ((YAP_Term) YAP_FunctorOfTerm(new_term));
YAP_Int arity = YAP_ArityOfFunctor(YAP_FunctorOfTerm(new_term));
@ -369,27 +368,19 @@ TrNode replace_nested_trie(TrNode node, TrNode child, YAP_Term new_term) {
TrNode_previous(TrNode_child(newnodef)) = newnode;
TrNode_child(newnodef) = newnode;
} else {
// Rewind to first uncle node
temp = TrNode_parent(node);
if (IS_FUNCTOR_NODE(temp))
term_search = TrNode_entry(temp);
/* Check if one of the node siblings have new_term */
temp = node;
while (TrNode_previous(temp))
temp = TrNode_previous(temp);
// Handles cases like not(t(?)) but doesn't handle case like not(not(...)
if (term_search) {
while (temp && TrNode_entry(temp) != term_search)
temp = TrNode_next(temp);
if (temp)
temp = TrNode_child(temp);
}
while (temp && TrNode_entry(temp) != new_term)
temp = TrNode_next(temp);
if (temp) { // Found a node we can reuse
if (temp) {
newnode = temp;
// Check if the childs of node/child exist already otherwise attach them
check_attach_childs(TrNode_child(child), TrNode_child(newnode));
//DATA_DESTRUCT_FUNCTION = destruct_function;
check_attach_childs(newnode, TrNode_child(child), TrNode_child(newnode), construct_function, destruct_function);
DATA_DESTRUCT_FUNCTION = destruct_function;
remove_child_nodes(TrNode_child(child));
TrNode_child(child) = NULL;
remove_entry(child);
return newnode;
} else { // Make a new node
@ -426,20 +417,56 @@ TrNode replace_nested_trie(TrNode node, TrNode child, YAP_Term new_term) {
}
void check_attach_childs(TrNode search_child, TrNode existing_child) {
void check_attach_childs(TrNode parent, TrNode search_child, TrNode existing_child, void (*construct_function)(TrNode), void (*destruct_function)(TrNode)) {
TrNode newnode;
// Check if the childs of node/child exist already otherwise attach them
do {
while(existing_child && (TrNode_entry(existing_child) != TrNode_entry(search_child)))
while(existing_child && (TrNode_entry(existing_child) != PairEndTag) && (TrNode_entry(existing_child) != TrNode_entry(search_child)))
existing_child = TrNode_next(existing_child);
if (existing_child) {
if (TrNode_entry(existing_child) != PairEndTag) {
check_attach_childs(TrNode_child(search_child), TrNode_child(existing_child));
}
} else {
printf("Need to attach child!\n");
abort();
}
if (TrNode_entry(existing_child) != PairEndTag)
check_attach_childs(existing_child, TrNode_child(search_child), TrNode_child(existing_child), construct_function, destruct_function);
existing_child = TrNode_child(parent);
search_child = TrNode_next(search_child);
} else if (TrNode_entry(search_child) == PairEndTag) {
newnode = parent;
DATA_DESTRUCT_FUNCTION = destruct_function;
remove_child_nodes(TrNode_child(newnode));
TrNode_child(newnode) = NULL;
newnode = trie_node_check_insert(newnode, PairEndTag);
INCREMENT_ENTRIES(CURRENT_TRIE_ENGINE);
(*construct_function)(newnode);
return;
} else {
existing_child = search_child;
search_child = TrNode_next(search_child);
if(TrNode_child(TrNode_parent(existing_child)) == existing_child) {
if(TrNode_next(existing_child)) {
TrNode_child(TrNode_parent(existing_child)) = TrNode_next(existing_child);
} else {
newnode = TrNode_parent(existing_child);
// DATA_DESTRUCT_FUNCTION = destruct_function;
// remove_child_nodes(TrNode_child(newnode));
TrNode_child(newnode) = NULL;
newnode = trie_node_check_insert(newnode, PairEndTag);
INCREMENT_ENTRIES(CURRENT_TRIE_ENGINE);
(*construct_function)(newnode);
}
}
if (TrNode_next(existing_child))
TrNode_previous(TrNode_next(existing_child)) = TrNode_previous(existing_child);
if (TrNode_previous(existing_child))
TrNode_next(TrNode_previous(existing_child)) = TrNode_next(existing_child);
TrNode_parent(existing_child) = parent;
TrNode_previous(existing_child) = NULL;
TrNode_next(existing_child) = TrNode_child(parent);
TrNode_previous(TrNode_child(parent)) = existing_child;
TrNode_child(parent) = existing_child;
existing_child = TrNode_child(parent);
}
} while(search_child);
}
@ -624,7 +651,7 @@ TrNode core_breadth_reduction(TrEngine engine, TrNode node, TrNode breadth_node,
stack_args_base = stack_args = AUXILIARY_TERM_STACK;
stack_top = AUXILIARY_TERM_STACK + CURRENT_AUXILIARY_TERM_STACK_SIZE - 1;
node = TrNode_parent(TrNode_parent(node));
// printf("start node: "); displaynode(node);
// printf("start node: "); displaynode(node);
if (IS_FUNCTOR_NODE(node)) {
while(IS_FUNCTOR_NODE(node))
node = TrNode_parent(node);
@ -633,7 +660,7 @@ TrNode core_breadth_reduction(TrEngine engine, TrNode node, TrNode breadth_node,
child = TrNode_child(child);
} else
child = TrNode_child(node);
// printf("Chosen start node: "); displaynode(child);
// printf("Chosen start node: "); displaynode(child);
if (IS_HASH_NODE(child)) {
printf("HASH NODE ERROR: db_tries do not support hash nodes.\n");
abort();
@ -729,7 +756,6 @@ TrNode core_breadth_reduction(TrEngine engine, TrNode node, TrNode breadth_node,
/* nested trie: stop procedure and return nested trie node */
if (IS_FUNCTOR_NODE(TrNode_parent(child)) && (strcmp(YAP_AtomName(YAP_NameOfFunctor((YAP_Functor)(~ApplTag & TrNode_entry(TrNode_parent(child))))), NESTED_TRIE_TERM) == 0))
return child;
PUSH_DOWN(stack_args, TrNode_entry(child), stack_top);
count++;
if (IS_FUNCTOR_NODE(TrNode_parent(child))) {

2
library/tries/core_dbtries.h
View File

@ -225,6 +225,6 @@ TrNode core_breadth_reduction(TrEngine engine, TrNode node, TrNode breadth_no
YAP_Term core_get_trie_db_return_term(void);
void core_set_trie_db_return_term(YAP_Term return_value);
YAP_Int core_db_trie_get_optimization_level_count(YAP_Int opt_level);
void core_depth_breadth_trie_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_Term new_term);
void core_depth_breadth_trie_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_Term new_term, void (*construct_function)(TrNode), void (*destruct_function)(TrNode));
YAP_Int core_get_trie_db_opt_min_prefix(void);
void core_set_trie_db_opt_min_prefix(YAP_Int min_prefix);

4
library/tries/core_tries.c
View File

@ -971,9 +971,9 @@ void remove_child_nodes(TrNode node) {
}
if (TrNode_next(node))
remove_child_nodes(TrNode_next(node));
if (!IS_LEAF_TRIE_NODE(node))
if (!IS_LEAF_TRIE_NODE(node)) {
remove_child_nodes(TrNode_child(node));
else {
} else {
if (DATA_DESTRUCT_FUNCTION)
(*DATA_DESTRUCT_FUNCTION)(node);
DECREMENT_ENTRIES(CURRENT_TRIE_ENGINE);

4
pl/messages.yap
View File

@ -404,8 +404,10 @@ domain_error(delete_file_option, Opt) --> !,
[ 'invalid list of options ~w' - [Opt] ].
domain_error(encoding, Opt) --> !,
[ 'invalid encoding ~w' - [Opt] ].
domain_error(flag_value, [Opt,Flag]) --> !,
[ 'invalid value ~w for flag ~w' - [Opt,Flag] ].
domain_error(flag_value, Opt) --> !,
[ 'invalid value ~w for flag ~w' - [Opt] ].
[ 'invalid value ~w for flag' - [Opt] ].
domain_error(io_mode, Opt) --> !,
[ 'invalid io mode ~w' - [Opt] ].
domain_error(mutable, Opt) --> !,