the trie locking data structure (node field or global lock array) is now defined explicitly

OPTYap/opt.config.h

@@ -20,13 +20,12 @@
 /******************************************************************************************
 **      use shared pages memory alloc scheme for OPTYap data structures? (optional)      **
 ******************************************************************************************/
-
 /* #define USE_PAGES_MALLOC 1 */
 
 
 
 /************************************************************************
-**                   TABLING Configuration Parameters                  **
+**                   Tabling Configuration Parameters                  **
 ************************************************************************/
 
 /****************************
@@ -43,7 +42,7 @@
 /*********************************************************
 **      support mode directed tabling ? (optional)      **
 *********************************************************/
-/* #define MODE_DIRECTED_TABLING 1 */
+#define MODE_DIRECTED_TABLING 1
 
 /****************************************************
 **      support early completion ? (optional)      **
@@ -83,7 +82,7 @@
 
 
 /************************************************************************
-**                    YAPOR Configuration Parameters                   **
+**                    YapOr Configuration Parameters                   **
 ************************************************************************/
 
 /****************************
@@ -107,14 +106,14 @@
 
 
 /************************************************************************
-**                   OPTYAP Configuration Parameters                   **
+**                   OPTYap Configuration Parameters                   **
 ************************************************************************/
 
 /****************************
 **      default sizes      **
 ****************************/
-#define LOCK_AT_WRITE_LEVEL_BUCKETS 512
 #define TG_ANSWER_SLOTS    20
+#define TRIE_LOCK_BUCKETS 512
 
 /*************************************************************************
 **      tries locking scheme (mandatory, define one per trie type)      **
@@ -146,9 +145,18 @@
 /* #define GLOBAL_TRIE_LOCK_AT_WRITE_LEVEL 1 */
 /* #define GLOBAL_TRIE_ALLOC_BEFORE_CHECK  1 */
 
-/**********************************************
+/*******************************************************************
-**      support inner cuts ? (optional)      **
+**      tries locking data structure (mandatory, define one)      **
-**********************************************/
+********************************************************************
+** Data structure to be used for locking the trie when using the  **
+** (TRIE_TYPE)_LOCK_AT_[NODE|WRITE]_LEVEL schemes                 **
+*******************************************************************/
+#define TRIE_LOCK_USING_NODE_FIELD   1
+/* #define TRIE_LOCK_USING_GLOBAL_ARRAY 1 */
+
+/******************************************************
+**      support tabling inner cuts ? (optional)      **
+******************************************************/
 #define TABLING_INNER_CUTS 1
 
 /*********************************************************
@@ -164,30 +172,48 @@
 
 #ifndef USE_PAGES_MALLOC
 #undef LIMIT_TABLING
-#endif /* !USE_PAGES_MALLOC */
+#endif /* ! USE_PAGES_MALLOC */
+
+
+#ifdef TABLING
+#if !defined(BFZ_TRAIL_SCHEME) && !defined(BBREG_TRAIL_SCHEME)
+#error Define a trail scheme
+#endif
+#if defined(BFZ_TRAIL_SCHEME) && defined(BBREG_TRAIL_SCHEME)
+#error Do not define multiple trail schemes
+#endif
+#else /* ! TABLING */
+#undef BFZ_TRAIL_SCHEME
+#undef BBREG_TRAIL_SCHEME
+#undef MODE_DIRECTED_TABLING
+#undef TABLING_EARLY_COMPLETION
+#undef TRIE_COMPACT_PAIRS
+#undef GLOBAL_TRIE_FOR_SUBTERMS
+#undef INCOMPLETE_TABLING
+#undef LIMIT_TABLING
+#undef DETERMINISTIC_TABLING
+#undef DEBUG_TABLING
+#endif /* TABLING */
+
 
 #ifdef YAPOR
 #ifdef i386 /* For i386 machines we use shared memory segments */
 #undef MMAP_MEMORY_MAPPING_SCHEME
 #define SHM_MEMORY_MAPPING_SCHEME
-#endif /* i386 */
+#endif
 #if !defined(MMAP_MEMORY_MAPPING_SCHEME) && !defined(SHM_MEMORY_MAPPING_SCHEME)
 #error Define a memory mapping scheme
-#endif /* !MMAP_MEMORY_MAPPING_SCHEME && !SHM_MEMORY_MAPPING_SCHEME */
+#endif
 #if defined(MMAP_MEMORY_MAPPING_SCHEME) && defined(SHM_MEMORY_MAPPING_SCHEME)
 #error Do not define multiple memory mapping schemes
-#endif /* MMAP_MEMORY_MAPPING_SCHEME && SHM_MEMORY_MAPPING_SCHEME */
+#endif
 #undef LIMIT_TABLING
+#else /* ! YAPOR */
+#undef MMAP_MEMORY_MAPPING_SCHEME
+#undef SHM_MEMORY_MAPPING_SCHEME
+#undef DEBUG_YAPOR
 #endif /* YAPOR */
 
-#ifdef TABLING
-#if !defined(BFZ_TRAIL_SCHEME) && !defined(BBREG_TRAIL_SCHEME)
-#error Define a trail scheme
-#endif /* !BFZ_TRAIL_SCHEME && !BBREG_TRAIL_SCHEME */
-#if defined(BFZ_TRAIL_SCHEME) && defined(BBREG_TRAIL_SCHEME)
-#error Do not define multiple trail schemes
-#endif /* BFZ_TRAIL_SCHEME && BBREG_TRAIL_SCHEME */
-#endif /* TABLING */
 
 #if defined(YAPOR) && defined(TABLING)
 /* SUBGOAL_TRIE_LOCK_LEVEL */
@@ -231,8 +257,36 @@
 #endif
 #ifndef GLOBAL_TRIE_LOCK_AT_WRITE_LEVEL
 #undef GLOBAL_TRIE_ALLOC_BEFORE_CHECK
-#endif 
+#endif
-#else
+/* TRIE_LOCK_USING_NODE_FIELD / TRIE_LOCK_USING_GLOBAL_ARRAY */
+#if !defined(TRIE_LOCK_USING_NODE_FIELD) && !defined(TRIE_LOCK_USING_GLOBAL_ARRAY)
+#error Define a trie lock data structure
+#endif
+#if defined(TRIE_LOCK_USING_NODE_FIELD) && defined(TRIE_LOCK_USING_GLOBAL_ARRAY)
+#error Do not define multiple trie lock data structures
+#endif
+#ifdef TRIE_LOCK_USING_NODE_FIELD
+#if defined(SUBGOAL_TRIE_LOCK_AT_NODE_LEVEL) || defined(SUBGOAL_TRIE_LOCK_AT_WRITE_LEVEL)
+#define SUBGOAL_TRIE_LOCK_USING_NODE_FIELD   1
+#endif
+#if defined(ANSWER_TRIE_LOCK_AT_NODE_LEVEL) || defined(ANSWER_TRIE_LOCK_AT_WRITE_LEVEL)
+#define ANSWER_TRIE_LOCK_USING_NODE_FIELD    1
+#endif
+#if defined(GLOBAL_TRIE_LOCK_AT_NODE_LEVEL) || defined(GLOBAL_TRIE_LOCK_AT_WRITE_LEVEL)
+#define GLOBAL_TRIE_LOCK_USING_NODE_FIELD    1
+#endif
+#elif TRIE_LOCK_USING_GLOBAL_ARRAY
+#if defined(SUBGOAL_TRIE_LOCK_AT_NODE_LEVEL) || defined(SUBGOAL_TRIE_LOCK_AT_WRITE_LEVEL)
+#define SUBGOAL_TRIE_LOCK_USING_GLOBAL_ARRAY 1
+#endif
+#if defined(ANSWER_TRIE_LOCK_AT_NODE_LEVEL) || defined(ANSWER_TRIE_LOCK_AT_WRITE_LEVEL)
+#define ANSWER_TRIE_LOCK_USING_GLOBAL_ARRAY  1
+#endif
+#if defined(GLOBAL_TRIE_LOCK_AT_NODE_LEVEL) || defined(GLOBAL_TRIE_LOCK_AT_WRITE_LEVEL)
+#define GLOBAL_TRIE_LOCK_USING_GLOBAL_ARRAY  1
+#endif
+#endif
+#else /* ! TABLING || ! YAPOR */
 #undef SUBGOAL_TRIE_LOCK_AT_ENTRY_LEVEL
 #undef SUBGOAL_TRIE_LOCK_AT_NODE_LEVEL
 #undef SUBGOAL_TRIE_LOCK_AT_WRITE_LEVEL
@@ -244,28 +298,12 @@
 #undef GLOBAL_TRIE_LOCK_AT_NODE_LEVEL
 #undef GLOBAL_TRIE_LOCK_AT_WRITE_LEVEL
 #undef GLOBAL_TRIE_ALLOC_BEFORE_CHECK
-#endif /* YAPOR && TABLING */
+#undef TRIE_LOCK_USING_NODE_FIELD
-
+#undef TRIE_LOCK_USING_GLOBAL_ARRAY
-#if !defined(TABLING) || !defined(YAPOR)
 #undef TABLING_INNER_CUTS
 #undef TIMESTAMP_CHECK
-#endif /* !TABLING || !YAPOR */
+#endif /* YAPOR && TABLING */
 
-#ifndef YAPOR
-#undef DEBUG_YAPOR
-#endif /* !YAPOR */
-
-#ifndef TABLING
-#undef BFZ_TRAIL_SCHEME
-#undef BBREG_TRAIL_SCHEME
-#undef TABLING_EARLY_COMPLETION
-#undef TRIE_COMPACT_PAIRS
-#undef GLOBAL_TRIE_FOR_SUBTERMS
-#undef DETERMINISTIC_TABLING
-#undef LIMIT_TABLING
-#undef INCOMPLETE_TABLING
-#undef DEBUG_TABLING
-#endif /* !TABLING */
 
 #if defined(DEBUG_YAPOR) && defined(DEBUG_TABLING)
 #define DEBUG_OPTYAP

OPTYap/opt.init.c

@@ -147,10 +147,10 @@ void Yap_init_global_optyap_data(int max_table_size, int n_workers, int sch_loop
     CELL *pt = GLOBAL_table_var_enumerator_addr(i);
     RESET_VARIABLE(pt);
   }
-#if defined(SUBGOAL_TRIE_LOCK_AT_WRITE_LEVEL) || defined(ANSWER_TRIE_LOCK_AT_WRITE_LEVEL) || defined(GLOBAL_TRIE_LOCK_AT_WRITE_LEVEL)
+#ifdef TRIE_LOCK_USING_GLOBAL_ARRAY
-  for (i = 0; i < LOCK_AT_WRITE_LEVEL_BUCKETS; i++)
+  for (i = 0; i < TRIE_LOCK_BUCKETS; i++)
-    INIT_LOCK(GLOBAL_write_level_locks(i));
+    INIT_LOCK(GLOBAL_trie_locks(i));
-#endif /* SUBGOAL_TRIE_LOCK_AT_WRITE_LEVEL || ANSWER_TRIE_LOCK_AT_WRITE_LEVEL || GLOBAL_TRIE_LOCK_AT_WRITE_LEVEL */
+#endif /* TRIE_LOCK_USING_GLOBAL_ARRAY */
 #endif /* TABLING */
 
   return;

OPTYap/opt.structs.h

@@ -213,9 +213,9 @@ struct global_optyap_data {
   struct dependency_frame *root_dependency_frame;
 #endif /* YAPOR */
   CELL table_var_enumerator[MAX_TABLE_VARS];
-#if defined(SUBGOAL_TRIE_LOCK_AT_WRITE_LEVEL) || defined(ANSWER_TRIE_LOCK_AT_WRITE_LEVEL) || defined(GLOBAL_TRIE_LOCK_AT_WRITE_LEVEL)
+#ifdef TRIE_LOCK_USING_GLOBAL_ARRAY
-  lockvar write_level_locks[LOCK_AT_WRITE_LEVEL_BUCKETS];
+  lockvar trie_locks[TRIE_LOCK_BUCKETS];
-#endif /* SUBGOAL_TRIE_LOCK_AT_WRITE_LEVEL || ANSWER_TRIE_LOCK_AT_WRITE_LEVEL || GLOBAL_TRIE_LOCK_AT_WRITE_LEVEL */
+#endif /* TRIE_LOCK_USING_GLOBAL_ARRAY */
 #ifdef TIMESTAMP_CHECK
   long timestamp;
 #endif /* TIMESTAMP_CHECK */
@@ -282,7 +282,7 @@ struct global_optyap_data {
 #define GLOBAL_root_dep_fr                      (GLOBAL_optyap_data.root_dependency_frame)
 #define GLOBAL_table_var_enumerator(index)      (GLOBAL_optyap_data.table_var_enumerator[index])
 #define GLOBAL_table_var_enumerator_addr(index) (GLOBAL_optyap_data.table_var_enumerator + (index))
-#define GLOBAL_write_level_locks(index)         (GLOBAL_optyap_data.write_level_locks[index])
+#define GLOBAL_trie_locks(index)                (GLOBAL_optyap_data.trie_locks[index])
 #define GLOBAL_timestamp                        (GLOBAL_optyap_data.timestamp)
 
 

OPTYap/tab.macros.h

@@ -170,6 +170,7 @@ static inline tg_sol_fr_ptr CUT_prune_tg_solution_frames(tg_sol_fr_ptr, int);
 #define IS_ANSWER_TRIE_HASH(NODE)   (TrNode_instr(NODE) == ANSWER_TRIE_HASH_MARK)
 #define GLOBAL_TRIE_HASH_MARK       ((Term) MakeTableVarTerm(MAX_TABLE_VARS))
 #define IS_GLOBAL_TRIE_HASH(NODE)   (TrNode_entry(NODE) == GLOBAL_TRIE_HASH_MARK)
+#define HASH_TRIE_LOCK(NODE)        GLOBAL_trie_locks((((unsigned long int) (NODE)) >> 5) & (TRIE_LOCK_BUCKETS - 1))
 
 /* auxiliary stack */
 #define STACK_PUSH_UP(ITEM, STACK)          *--(STACK) = (CELL)(ITEM)
@@ -272,62 +273,15 @@ static inline tg_sol_fr_ptr CUT_prune_tg_solution_frames(tg_sol_fr_ptr, int);
 #define AnsHash_init_previous_field(HASH, SG_FR)
 #endif /* MODE_DIRECTED_TABLING */
 
-#define HASH_WRITE_LEVEL_LOCK(NODE)  GLOBAL_write_level_locks((((unsigned long int) (NODE)) >> 5) & (LOCK_AT_WRITE_LEVEL_BUCKETS - 1))
-
 #ifdef SUBGOAL_TRIE_LOCK_AT_ENTRY_LEVEL
 #define LOCK_SUBGOAL_TRIE(TAB_ENT)    LOCK(TabEnt_lock(TAB_ENT))
 #define UNLOCK_SUBGOAL_TRIE(TAB_ENT)  UNLOCK(TabEnt_lock(TAB_ENT))
-#else
-#define LOCK_SUBGOAL_TRIE(TAB_ENT)
-#define UNLOCK_SUBGOAL_TRIE(TAB_ENT)
-#endif /* SUBGOAL_TRIE_LOCK_AT_ENTRY_LEVEL */
-
-#ifdef SUBGOAL_TRIE_LOCK_AT_NODE_LEVEL
-#define LOCK_SUBGOAL_NODE(NODE)    LOCK(TrNode_lock(NODE))
-#define UNLOCK_SUBGOAL_NODE(NODE)  UNLOCK(TrNode_lock(NODE))
-#elif SUBGOAL_TRIE_LOCK_AT_WRITE_LEVEL
-#define LOCK_SUBGOAL_NODE(NODE)    LOCK(HASH_WRITE_LEVEL_LOCK(NODE))
-#define UNLOCK_SUBGOAL_NODE(NODE)  UNLOCK(HASH_WRITE_LEVEL_LOCK(NODE))
-#else
-#define LOCK_SUBGOAL_NODE(NODE)
-#define UNLOCK_SUBGOAL_NODE(NODE)
-#endif /* SUBGOAL_TRIE_LOCK_LEVEL */
-
-#ifdef ANSWER_TRIE_LOCK_AT_ENTRY_LEVEL
-#define LOCK_ANSWER_TRIE(SG_FR)    LOCK(SgFr_lock(SG_FR))
-#define UNLOCK_ANSWER_TRIE(SG_FR)  UNLOCK(SgFr_lock(SG_FR))
-#else
-#define LOCK_ANSWER_TRIE(SG_FR)
-#define UNLOCK_ANSWER_TRIE(SG_FR)
-#endif /* ANSWER_TRIE_LOCK_AT_ENTRY_LEVEL */
-
-#ifdef ANSWER_TRIE_LOCK_AT_NODE_LEVEL
-#define LOCK_ANSWER_NODE(NODE)    LOCK(TrNode_lock(NODE))
-#define UNLOCK_ANSWER_NODE(NODE)  UNLOCK(TrNode_lock(NODE))
-#elif ANSWER_TRIE_LOCK_AT_WRITE_LEVEL
-#define LOCK_ANSWER_NODE(NODE)    LOCK(HASH_WRITE_LEVEL_LOCK(NODE))
-#define UNLOCK_ANSWER_NODE(NODE)  UNLOCK(HASH_WRITE_LEVEL_LOCK(NODE))
-#else
-#define LOCK_ANSWER_NODE(NODE)
-#define UNLOCK_ANSWER_NODE(NODE)
-#endif /* ANSWER_TRIE_LOCK_LEVEL */
-
-#ifdef GLOBAL_TRIE_LOCK_AT_NODE_LEVEL
-#define LOCK_GLOBAL_NODE(NODE)    LOCK(TrNode_lock(NODE))
-#define UNLOCK_GLOBAL_NODE(NODE)  UNLOCK(TrNode_lock(NODE))
-#elif GLOBAL_TRIE_LOCK_AT_WRITE_LEVEL
-#define LOCK_GLOBAL_NODE(NODE)    LOCK(HASH_WRITE_LEVEL_LOCK(NODE))
-#define UNLOCK_GLOBAL_NODE(NODE)  UNLOCK(HASH_WRITE_LEVEL_LOCK(NODE))
-#else
-#define LOCK_GLOBAL_NODE(NODE)
-#define UNLOCK_GLOBAL_NODE(NODE)
-#endif /* GLOBAL_TRIE_LOCK_LEVEL */
-
-#ifdef SUBGOAL_TRIE_LOCK_AT_ENTRY_LEVEL
 #define SgHash_init_next_field(HASH, TAB_ENT)          \
         Hash_next(HASH) = TabEnt_hash_chain(TAB_ENT);  \
         TabEnt_hash_chain(TAB_ENT) = HASH
 #else
+#define LOCK_SUBGOAL_TRIE(TAB_ENT)
+#define UNLOCK_SUBGOAL_TRIE(TAB_ENT)
 #define SgHash_init_next_field(HASH, TAB_ENT)          \
         LOCK(TabEnt_lock(TAB_ENT));                    \
         Hash_next(HASH) = TabEnt_hash_chain(TAB_ENT);  \
@@ -336,36 +290,64 @@ static inline tg_sol_fr_ptr CUT_prune_tg_solution_frames(tg_sol_fr_ptr, int);
 #endif /* SUBGOAL_TRIE_LOCK_AT_ENTRY_LEVEL */
 
 #ifdef ANSWER_TRIE_LOCK_AT_ENTRY_LEVEL
-#define AnsHash_init_chain_fields(HASH, SG_FR)         \
+#define LOCK_ANSWER_TRIE(SG_FR)    LOCK(SgFr_lock(SG_FR))
-        AnsHash_init_previous_field(HASH, SG_FR);      \
+#define UNLOCK_ANSWER_TRIE(SG_FR)  UNLOCK(SgFr_lock(SG_FR))
-        Hash_next(HASH) = SgFr_hash_chain(SG_FR);      \
+#define AnsHash_init_chain_fields(HASH, SG_FR)     \
+        AnsHash_init_previous_field(HASH, SG_FR);  \
+        Hash_next(HASH) = SgFr_hash_chain(SG_FR);  \
 	SgFr_hash_chain(SG_FR) = HASH
 #else
-#define AnsHash_init_chain_fields(HASH, SG_FR)         \
+#define LOCK_ANSWER_TRIE(SG_FR)
-        LOCK(SgFr_lock(SG_FR));                        \
+#define UNLOCK_ANSWER_TRIE(SG_FR)
-        AnsHash_init_previous_field(HASH, SG_FR);      \
+#define AnsHash_init_chain_fields(HASH, SG_FR)     \
-        Hash_next(HASH) = SgFr_hash_chain(SG_FR);      \
+        LOCK(SgFr_lock(SG_FR));                    \
-        SgFr_hash_chain(SG_FR) = HASH;                 \
+        AnsHash_init_previous_field(HASH, SG_FR);  \
+        Hash_next(HASH) = SgFr_hash_chain(SG_FR);  \
+        SgFr_hash_chain(SG_FR) = HASH;             \
         UNLOCK(SgFr_lock(SG_FR))
 #endif /* ANSWER_TRIE_LOCK_AT_ENTRY_LEVEL */
 
-#ifdef SUBGOAL_TRIE_LOCK_AT_NODE_LEVEL
+#ifdef SUBGOAL_TRIE_LOCK_USING_NODE_FIELD
+#define LOCK_SUBGOAL_NODE(NODE)       LOCK(TrNode_lock(NODE))
+#define UNLOCK_SUBGOAL_NODE(NODE)     UNLOCK(TrNode_lock(NODE))
 #define SgNode_init_lock_field(NODE)  INIT_LOCK(TrNode_lock(NODE))
-#else
+#elif SUBGOAL_TRIE_LOCK_USING_GLOBAL_ARRAY
+#define LOCK_SUBGOAL_NODE(NODE)       LOCK(HASH_TRIE_LOCK(NODE))
+#define UNLOCK_SUBGOAL_NODE(NODE)     UNLOCK(HASH_TRIE_LOCK(NODE))
 #define SgNode_init_lock_field(NODE)
-#endif /* SUBGOAL_TRIE_LOCK_AT_NODE_LEVEL */
+#else
+#define LOCK_SUBGOAL_NODE(NODE)
+#define UNLOCK_SUBGOAL_NODE(NODE)
+#define SgNode_init_lock_field(NODE)
+#endif /* SUBGOAL_TRIE_LOCK_LEVEL */
 
-#ifdef ANSWER_TRIE_LOCK_AT_NODE_LEVEL
+#ifdef ANSWER_TRIE_LOCK_USING_NODE_FIELD
+#define LOCK_ANSWER_NODE(NODE)         LOCK(TrNode_lock(NODE))
+#define UNLOCK_ANSWER_NODE(NODE)       UNLOCK(TrNode_lock(NODE))
 #define AnsNode_init_lock_field(NODE)  INIT_LOCK(TrNode_lock(NODE))
-#else
+#elif ANSWER_TRIE_LOCK_USING_GLOBAL_ARRAY
+#define LOCK_ANSWER_NODE(NODE)         LOCK(HASH_TRIE_LOCK(NODE))
+#define UNLOCK_ANSWER_NODE(NODE)       UNLOCK(HASH_TRIE_LOCK(NODE))
 #define AnsNode_init_lock_field(NODE)
-#endif /* ANSWER_TRIE_LOCK_AT_NODE_LEVEL */
-
-#ifdef GLOBAL_TRIE_LOCK_AT_NODE_LEVEL
-#define GtNode_init_lock_field(NODE)  INIT_LOCK(TrNode_lock(NODE))
 #else
+#define LOCK_ANSWER_NODE(NODE)
+#define UNLOCK_ANSWER_NODE(NODE)
+#define AnsNode_init_lock_field(NODE)
+#endif /* ANSWER_TRIE_LOCK_LEVEL */
+
+#ifdef GLOBAL_TRIE_LOCK_USING_NODE_FIELD
+#define LOCK_GLOBAL_NODE(NODE)        LOCK(TrNode_lock(NODE))
+#define UNLOCK_GLOBAL_NODE(NODE)      UNLOCK(TrNode_lock(NODE))
+#define GtNode_init_lock_field(NODE)  INIT_LOCK(TrNode_lock(NODE))
+#elif GLOBAL_TRIE_LOCK_USING_GLOBAL_ARRAY
+#define LOCK_GLOBAL_NODE(NODE)        LOCK(HASH_TRIE_LOCK(NODE))
+#define UNLOCK_GLOBAL_NODE(NODE)      UNLOCK(HASH_TRIE_LOCK(NODE))
 #define GtNode_init_lock_field(NODE)
-#endif /* GLOBAL_TRIE_LOCK_AT_NODE_LEVEL */
+#else
+#define LOCK_GLOBAL_NODE(NODE)
+#define UNLOCK_GLOBAL_NODE(NODE)
+#define GtNode_init_lock_field(NODE)
+#endif /* GLOBAL_TRIE_LOCK_LEVEL */
 
 #define new_table_entry(TAB_ENT, PRED_ENTRY, ATOM, ARITY, MODE_ARRAY)  \
         { register sg_node_ptr sg_node;                                \

OPTYap/tab.structs.h

@@ -58,9 +58,9 @@ typedef struct subgoal_trie_node {
   struct subgoal_trie_node *parent;
   struct subgoal_trie_node *child;
   struct subgoal_trie_node *next;
-#ifdef SUBGOAL_TRIE_LOCK_AT_NODE_LEVEL
+#ifdef SUBGOAL_TRIE_LOCK_USING_NODE_FIELD
   lockvar lock;
-#endif /* SUBGOAL_TRIE_LOCK_AT_NODE_LEVEL */
+#endif /* SUBGOAL_TRIE_LOCK_USING_NODE_FIELD */
 } *sg_node_ptr;
 
 typedef struct answer_trie_node {
@@ -72,9 +72,9 @@ typedef struct answer_trie_node {
   struct answer_trie_node *parent;
   struct answer_trie_node *child;
   struct answer_trie_node *next;
-#ifdef ANSWER_TRIE_LOCK_AT_NODE_LEVEL
+#ifdef ANSWER_TRIE_LOCK_USING_NODE_FIELD
   lockvar lock;
-#endif /* ANSWER_TRIE_LOCK_AT_NODE_LEVEL */
+#endif /* ANSWER_TRIE_LOCK_USING_NODE_FIELD */
 } *ans_node_ptr;
 
 typedef struct global_trie_node {
@@ -82,9 +82,9 @@ typedef struct global_trie_node {
   struct global_trie_node *parent;
   struct global_trie_node *child;
   struct global_trie_node *next;
-#ifdef GLOBAL_TRIE_LOCK_AT_NODE_LEVEL
+#ifdef GLOBAL_TRIE_LOCK_USING_NODE_FIELD
   lockvar lock;
-#endif /* GLOBAL_TRIE_LOCK_AT_NODE_LEVEL */
+#endif /* GLOBAL_TRIE_LOCK_USING_NODE_FIELD */
 } *gt_node_ptr;
 
 #define TrNode_instr(X)   ((X)->trie_instruction)

OPTYap/tab.tries.c

@@ -1113,9 +1113,9 @@ ans_node_ptr mode_directed_answer_search(sg_fr_ptr sg_fr, CELL *subs_ptr) {
     int n_subs = MODE_DIRECTED_GET_ARG(mode_directed[j]);
     do {
       TABLING_ERROR_CHECKING(answer_search, IsNonVarTerm(subs_ptr[i]));
-      if (mode == MODE_DIRECTED_INDEX || mode == MODE_DIRECTED_ALL)
+      if (mode == MODE_DIRECTED_INDEX || mode == MODE_DIRECTED_ALL) {
 	current_ans_node = answer_search_loop(sg_fr, current_ans_node, Deref(subs_ptr[i]), &vars_arity);
-      else {
+      } else {
 	LOCK_ANSWER_NODE(current_ans_node);
 	if (TrNode_child(current_ans_node) == NULL) {
 #ifdef YAPOR