YAP 7.1.0
opt.macros.h
1/************************************************************************
2** **
3** The YapTab/YapOr/OPTYap systems **
4** **
5** YapTab extends the Yap Prolog engine to support sequential tabling **
6** YapOr extends the Yap Prolog engine to support or-parallelism **
7** OPTYap extends the Yap Prolog engine to support or-parallel tabling **
8** **
9** **
10** Yap Prolog was developed at University of Porto, Portugal **
11** **
12************************************************************************/
13
14/************************************************************************
15** Memory management **
16************************************************************************/
17
18extern size_t Yap_page_size;
19
20#ifdef USE_PAGES_MALLOC
21#include <sys/shm.h>
22#endif /* USE_PAGES_MALLOC */
23
24#define SHMMAX 0x2000000 /* 32 Mbytes: works fine with linux */
25/* #define SHMMAX 0x400000 - 4 Mbytes: shmget limit for Mac (?) */
26/* #define SHMMAX 0x800000 - 8 Mbytes: shmget limit for Solaris (?) */
27
28#if SIZEOF_INT_P == 4
29#define OPTYAP_ALIGN 3
30#define ALIGNMASK 0xfffffffc
31#elif SIZEOF_INT_P == 8
32#define OPTYAP_ALIGN 7
33#define ALIGNMASK 0xfffffff8
34#else
35#define ALIGN OOOOPPS!!! Unknown Pointer Sizeof
36#define ALIGNMASK OOOOPPS!!! Unknown Pointer Sizeof
37#endif /* SIZEOF_INT_P */
38
39#define ADJUST_SIZE(SIZE) ((SIZE + OPTYAP_ALIGN) & ALIGNMASK)
40#define ADJUST_SIZE_TO_PAGE(SIZE) ((SIZE) - (SIZE) % Yap_page_size + Yap_page_size)
41#define PAGE_HEADER(STR) (pg_hd_ptr)((unsigned long int)STR - (unsigned long int)STR % Yap_page_size)
42#define STRUCT_NEXT(STR) ((STR)->next)
43#define UPDATE_STATS(STAT, VALUE) STAT += VALUE
44
45#ifdef YAPOR
46#define LOCK_PAGE_ENTRY(PG_ENT) LOCK(PgEnt_lock(PG_ENT))
47#define UNLOCK_PAGE_ENTRY(PG_ENT) UNLOCK(PgEnt_lock(PG_ENT))
48#else
49#define LOCK_PAGE_ENTRY(PG_ENT)
50#define UNLOCK_PAGE_ENTRY(PG_ENT)
51#endif
52
53#ifdef USE_SYSTEM_MALLOC
54/*******************************************************************************************
55** USE_SYSTEM_MALLOC **
56*******************************************************************************************/
57#define ALLOC_BLOCK(STR, SIZE, STR_TYPE) \
58 if ((STR = (STR_TYPE *) malloc(SIZE)) == NULL) \
59 Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "ALLOC_BLOCK: malloc error")
60#define FREE_BLOCK(STR) \
61 free(STR)
62#else
63/*******************************************************************************************
64** ! USE_SYSTEM_MALLOC **
65*******************************************************************************************/
66#define ALLOC_BLOCK(STR, SIZE, STR_TYPE) \
67 { char *block_ptr; \
68 if ((block_ptr = Yap_AllocCodeSpace(SIZE + sizeof(CELL))) != NULL) \
69 *block_ptr = 'y'; \
70 else if ((block_ptr = (char *) malloc(SIZE + sizeof(CELL))) != NULL) \
71 *block_ptr = 'm'; \
72 else \
73 Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "ALLOC_BLOCK: malloc error"); \
74 block_ptr += sizeof(CELL); \
75 STR = (STR_TYPE *) block_ptr; \
76 }
77#define FREE_BLOCK(STR) \
78 { char *block_ptr = (char *)(STR) - sizeof(CELL); \
79 if (block_ptr[0] == 'y') \
80 Yap_FreeCodeSpace(block_ptr); \
81 else \
82 free(block_ptr); \
83 }
84#endif /***********************************************************************************/
85
86#define INIT_BUCKETS(BUCKET_PTR, NUM_BUCKETS) \
87 { int i; void **init_bucket_ptr; \
88 init_bucket_ptr = (void **) BUCKET_PTR; \
89 for (i = NUM_BUCKETS; i != 0; i--) \
90 *init_bucket_ptr++ = NULL; \
91 }
92#define ALLOC_BUCKETS(BUCKET_PTR, NUM_BUCKETS) \
93 { void **alloc_bucket_ptr; \
94 ALLOC_BLOCK(alloc_bucket_ptr, NUM_BUCKETS * sizeof(void *), void *); \
95 INIT_BUCKETS(alloc_bucket_ptr, NUM_BUCKETS); \
96 BUCKET_PTR = (void *) alloc_bucket_ptr; \
97 }
98#define FREE_BUCKETS(BUCKET_PTR) FREE_BLOCK(BUCKET_PTR)
99
100#ifndef USE_PAGES_MALLOC
101/*******************************************************************************************
102** ! USE_PAGES_MALLOC **
103*******************************************************************************************/
104#define MOVE_PAGES(FROM_PG_ENT, TO_PG_ENT) \
105 UPDATE_STATS(PgEnt_strs_in_use(TO_PG_ENT), PgEnt_strs_in_use(FROM_PG_ENT)); \
106 PgEnt_strs_in_use(FROM_PG_ENT) = 0
107#define DETACH_PAGES(_PG_ENT) \
108 LOCK(PgEnt_lock(GLOBAL##_PG_ENT)); \
109 MOVE_PAGES(LOCAL##_PG_ENT, GLOBAL##_PG_ENT); \
110 UNLOCK(PgEnt_lock(GLOBAL##_PG_ENT))
111#define ATTACH_PAGES(_PG_ENT) \
112 MOVE_PAGES(GLOBAL##_PG_ENT, LOCAL##_PG_ENT)
113#define GET_FREE_STRUCT(STR, STR_TYPE, PG_ENT, EXTRA_PG_ENT) \
114 LOCK_PAGE_ENTRY(PG_ENT); \
115 UPDATE_STATS(PgEnt_strs_in_use(PG_ENT), 1); \
116 UNLOCK_PAGE_ENTRY(PG_ENT); \
117 ALLOC_BLOCK(STR, sizeof(STR_TYPE), STR_TYPE)
118#define GET_NEXT_FREE_STRUCT(LOCAL_STR, STR, STR_TYPE, PG_ENT) \
119 GET_FREE_STRUCT(STR, STR_TYPE, PG_ENT, ___NOT_USED___)
120#define PUT_FREE_STRUCT(STR, STR_TYPE, PG_ENT) \
121 LOCK_PAGE_ENTRY(PG_ENT); \
122 UPDATE_STATS(PgEnt_strs_in_use(PG_ENT), -1); \
123 UNLOCK_PAGE_ENTRY(PG_ENT); \
124 FREE_BLOCK(STR)
125#else
126/*******************************************************************************************
127** USE_PAGES_MALLOC **
128*******************************************************************************************/
129#define MOVE_PAGES(FROM_PG_ENT, TO_PG_ENT) \
130 if (PgEnt_first(TO_PG_ENT)) { \
131 PgHd_next(PgEnt_last(TO_PG_ENT)) = PgEnt_first(FROM_PG_ENT); \
132 PgHd_previous(PgEnt_first(FROM_PG_ENT)) = PgEnt_last(TO_PG_ENT); \
133 } else \
134 PgEnt_first(TO_PG_ENT) = PgEnt_first(FROM_PG_ENT); \
135 PgEnt_last(TO_PG_ENT) = PgEnt_last(FROM_PG_ENT); \
136 UPDATE_STATS(PgEnt_pages_in_use(TO_PG_ENT), PgEnt_pages_in_use(FROM_PG_ENT)); \
137 UPDATE_STATS(PgEnt_strs_in_use(TO_PG_ENT), PgEnt_strs_in_use(FROM_PG_ENT)); \
138 PgEnt_first(FROM_PG_ENT) = PgEnt_last(FROM_PG_ENT) = NULL; \
139 PgEnt_pages_in_use(FROM_PG_ENT) = PgEnt_strs_in_use(FROM_PG_ENT) = 0
140
141#define DETACH_PAGES(_PG_ENT) \
142 if (PgEnt_first(LOCAL##_PG_ENT)) { \
143 LOCK(PgEnt_lock(GLOBAL##_PG_ENT)); \
144 MOVE_PAGES(LOCAL##_PG_ENT, GLOBAL##_PG_ENT); \
145 UNLOCK(PgEnt_lock(GLOBAL##_PG_ENT)); \
146 }
147
148#define ATTACH_PAGES(_PG_ENT) \
149 if (PgEnt_first(GLOBAL##_PG_ENT)) { \
150 MOVE_PAGES(GLOBAL##_PG_ENT, LOCAL##_PG_ENT); \
151 }
152
153/*******************************************************************************************
154#define GET_PAGE_FIRST_LEVEL(PG_HD) GET_VOID_PAGE(PG_HD)
155#define GET_VOID_PAGE_NEXT_LEVEL(PG_HD) GET_ALLOC_PAGE(PG_HD)
156#define GET_ALLOC_PAGE_NEXT_LEVEL(PG_HD)
157*******************************************************************************************/
158#define GET_PAGE_FIRST_LEVEL(PG_HD) GET_ALLOC_PAGE(PG_HD)
159#define GET_ALLOC_PAGE_NEXT_LEVEL(PG_HD) GET_VOID_PAGE(PG_HD)
160#define GET_VOID_PAGE_NEXT_LEVEL(PG_HD)
161
162#define GET_ALLOC_PAGE(PG_HD) \
163 LOCK(PgEnt_lock(GLOBAL_pages_alloc)); \
164 if ((PG_HD = PgEnt_first(GLOBAL_pages_alloc)) == NULL) { \
165 UNLOCK(PgEnt_lock(GLOBAL_pages_alloc)); \
166 GET_ALLOC_PAGE_NEXT_LEVEL(PG_HD); \
167 } else { \
168 PgEnt_first(GLOBAL_pages_alloc) = (pg_hd_ptr)(((void *)PG_HD) + Yap_page_size); \
169 if (PgEnt_first(GLOBAL_pages_alloc) == PgEnt_last(GLOBAL_pages_alloc)) \
170 PgEnt_first(GLOBAL_pages_alloc) = NULL; \
171 UNLOCK(PgEnt_lock(GLOBAL_pages_alloc)); \
172 }
173
174#define GET_VOID_PAGE(PG_HD) \
175 LOCK(PgEnt_lock(GLOBAL_pages_void)); \
176 if ((PG_HD = PgEnt_first(GLOBAL_pages_void)) == NULL) { \
177 UNLOCK(PgEnt_lock(GLOBAL_pages_void)); \
178 GET_VOID_PAGE_NEXT_LEVEL(PG_HD); \
179 } else { \
180 if ((PgEnt_first(GLOBAL_pages_void) = PgHd_next(PG_HD)) == NULL) \
181 PgEnt_last(GLOBAL_pages_void) = NULL; \
182 UNLOCK(PgEnt_lock(GLOBAL_pages_void)); \
183 }
184
185#define PUT_PAGE(PG_HD, PG_ENT) \
186 if ((PgHd_next(PG_HD) = PgEnt_first(PG_ENT)) == NULL) \
187 PgEnt_last(PG_ENT) = PG_HD; \
188 else \
189 PgHd_previous(PgHd_next(PG_HD)) = PG_HD; \
190 PgEnt_first(PG_ENT) = PG_HD; \
191 UPDATE_STATS(PgEnt_pages_in_use(PG_ENT), 1)
192
193#define PUT_VOID_PAGE(PG_HD, PG_ENT) \
194 if ((PgHd_next(PG_HD) = PgEnt_first(PG_ENT)) == NULL) \
195 PgEnt_last(PG_ENT) = PG_HD; \
196 PgEnt_first(PG_ENT) = PG_HD
197
198#ifdef THREADS
199#define GET_FREE_PAGE(PG_HD) \
200 if ((PG_HD = PgEnt_first(LOCAL_pages_void)) == NULL) { \
201 GET_PAGE_FIRST_LEVEL(PG_HD); \
202 } else { \
203 if ((PgEnt_first(LOCAL_pages_void) = PgHd_next(PG_HD)) == NULL) \
204 PgEnt_last(LOCAL_pages_void) = NULL; \
205 }
206#define PUT_FREE_PAGE(PG_HD) \
207 PUT_VOID_PAGE(PG_HD, LOCAL_pages_void)
208#else
209#define GET_FREE_PAGE(PG_HD) \
210 GET_PAGE_FIRST_LEVEL(PG_HD)
211#define PUT_FREE_PAGE(PG_HD) \
212 PUT_VOID_PAGE(PG_HD, GLOBAL_pages_void)
213#endif
214
215#define INIT_PAGE(PG_HD, STR_TYPE, PG_ENT) \
216 PgHd_strs_in_use(PG_HD) = 0; \
217 PgHd_previous(PG_HD) = NULL; \
218 PgHd_next(PG_HD) = NULL; \
219 PgHd_first_str(PG_HD) = NULL; \
220 PgHd_alloc_area(PG_HD) = (void *) (PG_HD + 1); \
221 PgHd_alloc_area(PG_HD) += sizeof(STR_TYPE) * PgEnt_strs_per_page(PG_ENT)
222
223/*******************************************************************************************
224#define OLD_INIT_PAGE(PG_HD, STR_TYPE, PG_ENT) \
225 { int i; \
226 STR_TYPE *aux_str; \
227 PgHd_strs_in_use(PG_HD) = 0; \
228 PgHd_previous(PG_HD) = NULL; \
229 PgHd_next(PG_HD) = NULL; \
230 PgHd_alloc_area(PG_HD) = NULL; \
231 PgHd_first_str(PG_HD) = (void *) (PG_HD + 1); \
232 aux_str = (STR_TYPE *) PgHd_first_str(PG_HD); \
233 for (i = 1; i < PgEnt_strs_per_page(PG_ENT); i++) { \
234 STRUCT_NEXT(aux_str) = aux_str + 1; \
235 aux_str++; \
236 } \
237 STRUCT_NEXT(aux_str) = NULL; \
238 }
239*******************************************************************************************/
240
241#define ALLOC_SPACE() \
242 LOCK(PgEnt_lock(GLOBAL_pages_alloc)); \
243 if (PgEnt_first(GLOBAL_pages_alloc) == NULL) { \
244 int shmid; \
245 void *mem_block; \
246 if ((shmid = shmget(IPC_PRIVATE, SHMMAX, SHM_R|SHM_W)) == -1) \
247 Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "shmget error (ALLOC_PAGE)"); \
248 if ((mem_block = shmat(shmid, NULL, 0)) == (void *) -1) \
249 Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "shmat error (ALLOC_PAGE)"); \
250 if (shmctl(shmid, IPC_RMID, 0) != 0) \
251 Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "shmctl error (ALLOC_PAGE)"); \
252 PgEnt_first(GLOBAL_pages_alloc) = (pg_hd_ptr)(mem_block + Yap_page_size); \
253 PgEnt_last(GLOBAL_pages_alloc) = (pg_hd_ptr)(mem_block + SHMMAX); \
254 UPDATE_STATS(PgEnt_pages_in_use(GLOBAL_pages_alloc), SHMMAX / Yap_page_size); \
255 } \
256 UNLOCK(PgEnt_lock(GLOBAL_pages_alloc))
257
258#ifdef LIMIT_TABLING
259#define RECOVER_ALLOC_SPACE(PG_ENT, EXTRA_PG_ENT) \
260 if (GLOBAL_max_pages == PgEnt_pages_in_use(GLOBAL_pages_alloc)) { \
261 sg_fr_ptr sg_fr = GLOBAL_check_sg_fr; \
262 do { \
263 if (sg_fr) \
264 sg_fr = SgFr_next(sg_fr); \
265 else \
266 sg_fr = GLOBAL_first_sg_fr; \
267 if (sg_fr == NULL) \
268 Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "no space left (RECOVER_SPACE)"); \
269 /* see function 'InteractSIGINT' in file 'sysbits.c' */ \
270 /* Yap_Error(PURE_ABORT_EVENT, TermNil, ""); */ \
271 /* restore_absmi_regs(&Yap_standard_regs); */ \
272 /* siglongjmp (LOCAL_RestartEnv, 1); */ \
273 if (SgFr_first_answer(sg_fr) && \
274 SgFr_first_answer(sg_fr) != SgFr_answer_trie(sg_fr)) { \
275 SgFr_state(sg_fr) = ready; \
276 free_answer_hash_chain(SgFr_hash_chain(sg_fr)); \
277 SgFr_hash_chain(sg_fr) = NULL; \
278 SgFr_first_answer(sg_fr) = NULL; \
279 SgFr_last_answer(sg_fr) = NULL; \
280 free_answer_trie(TrNode_child(SgFr_answer_trie(sg_fr)), \
281 TRAVERSE_MODE_NORMAL, TRAVERSE_POSITION_FIRST); \
282 TrNode_child(SgFr_answer_trie(sg_fr)) = NULL; \
283 } \
284 } while (PgEnt_first(GLOBAL_pages_void) == PgEnt_first(PG_ENT)); \
285 GLOBAL_check_sg_fr = sg_fr; \
286 } else { \
287 ALLOC_SPACE(); \
288 }
289#elif THREADS
290#define RECOVER_ALLOC_SPACE(PG_ENT, EXTRA_PG_ENT) \
291 LOCK(PgEnt_lock(EXTRA_PG_ENT)); \
292 if (PgEnt_first(EXTRA_PG_ENT)) { \
293 MOVE_PAGES(EXTRA_PG_ENT, PG_ENT); \
294 UNLOCK(PgEnt_lock(EXTRA_PG_ENT)); \
295 } else { \
296 UNLOCK(PgEnt_lock(EXTRA_PG_ENT)); \
297 ALLOC_SPACE(); \
298 }
299#else
300#define RECOVER_ALLOC_SPACE(PG_ENT, EXTRA_PG_ENT) \
301 ALLOC_SPACE()
302#endif
303
304#define TEST_GET_FREE_PAGE(PG_HD, STR_TYPE, PG_ENT, EXTRA_PG_ENT) \
305 while (PG_HD == NULL) { \
306 UNLOCK_PAGE_ENTRY(PG_ENT); \
307 GET_FREE_PAGE(PG_HD); \
308 if (PG_HD) { \
309 INIT_PAGE(PG_HD, STR_TYPE, PG_ENT); \
310 LOCK_PAGE_ENTRY(PG_ENT); \
311 PUT_PAGE(PG_HD, PG_ENT); \
312 } else { \
313 RECOVER_ALLOC_SPACE(PG_ENT, EXTRA_PG_ENT); \
314 LOCK_PAGE_ENTRY(PG_ENT); \
315 PG_HD = PgEnt_first(PG_ENT); \
316 } \
317 }
318
319#define GET_FREE_STRUCT(STR, STR_TYPE, PG_ENT, EXTRA_PG_ENT) \
320 { pg_hd_ptr pg_hd; \
321 LOCK_PAGE_ENTRY(PG_ENT); \
322 pg_hd = PgEnt_first(PG_ENT); \
323 TEST_GET_FREE_PAGE(pg_hd, STR_TYPE, PG_ENT, EXTRA_PG_ENT); \
324 if (PgHd_alloc_area(pg_hd)) { \
325 STR = ((STR_TYPE *) PgHd_alloc_area(pg_hd)) - 1; \
326 if (STR == (STR_TYPE *) (pg_hd + 1)) \
327 PgHd_alloc_area(pg_hd) = NULL; \
328 else \
329 PgHd_alloc_area(pg_hd) = (void *) STR; \
330 } else { \
331 STR = (STR_TYPE *) PgHd_first_str(pg_hd); \
332 PgHd_first_str(pg_hd) = (void *) STRUCT_NEXT(STR); \
333 } \
334 if (PgHd_alloc_area(pg_hd) == NULL && PgHd_first_str(pg_hd) == NULL) { \
335 if ((PgEnt_first(PG_ENT) = PgHd_next(pg_hd)) == NULL) \
336 PgEnt_last(PG_ENT) = NULL; \
337 else \
338 PgHd_previous(PgHd_next(pg_hd)) = NULL; \
339 } \
340 UPDATE_STATS(PgHd_strs_in_use(pg_hd), 1); \
341 UPDATE_STATS(PgEnt_strs_in_use(PG_ENT), 1); \
342 UNLOCK_PAGE_ENTRY(PG_ENT); \
343 }
344
345/*******************************************************************************************
346#define OLD_GET_FREE_STRUCT(STR, STR_TYPE, PG_ENT, EXTRA_PG_ENT) \
347 { pg_hd_ptr pg_hd; \
348 LOCK_PAGE_ENTRY(PG_ENT); \
349 pg_hd = PgEnt_first(PG_ENT); \
350 TEST_GET_FREE_PAGE(pg_hd, STR_TYPE, PG_ENT, EXTRA_PG_ENT); \
351 STR = (STR_TYPE *) PgHd_first_str(pg_hd); \
352 if ((PgHd_first_str(pg_hd) = (void *) STRUCT_NEXT(STR)) == NULL) { \
353 if ((PgEnt_first(PG_ENT) = PgHd_next(pg_hd)) == NULL) \
354 PgEnt_last(PG_ENT) = NULL; \
355 else \
356 PgHd_previous(PgHd_next(pg_hd)) = NULL; \
357 } \
358 UPDATE_STATS(PgHd_strs_in_use(pg_hd), 1); \
359 UPDATE_STATS(PgEnt_strs_in_use(PG_ENT), 1); \
360 UNLOCK_PAGE_ENTRY(PG_ENT); \
361 }
362*******************************************************************************************/
363
364#define GET_NEXT_FREE_STRUCT(LOCAL_STR, STR, STR_TYPE, PG_ENT) \
365 STR = LOCAL_STR; \
366 if (STR == NULL) { \
367 pg_hd_ptr pg_hd; \
368 LOCK_PAGE_ENTRY(PG_ENT); \
369 pg_hd = PgEnt_first(PG_ENT); \
370 TEST_GET_FREE_PAGE(pg_hd, STR_TYPE, PG_ENT, ___NOT_USED___); \
371 STR = (STR_TYPE *) PgHd_first_str(pg_hd); \
372 PgHd_first_str(pg_hd) = NULL; \
373 PgHd_strs_in_use(pg_hd) = PgEnt_strs_per_page(PG_ENT); \
374 if ((PgEnt_first(PG_ENT) = PgHd_next(pg_hd)) == NULL) \
375 PgEnt_last(PG_ENT) = NULL; \
376 else \
377 PgHd_previous(PgHd_next(pg_hd)) = NULL; \
378 UPDATE_STATS(PgEnt_strs_in_use(PG_ENT), -PgHd_strs_in_use(pg_hd)); \
379 UPDATE_STATS(PgEnt_strs_in_use(PG_ENT), PgEnt_strs_per_page(PG_ENT)); \
380 UNLOCK_PAGE_ENTRY(PG_ENT); \
381 } \
382 LOCAL_STR = STRUCT_NEXT(STR)
383
384#define PUT_FREE_STRUCT(STR, STR_TYPE, PG_ENT) \
385 { pg_hd_ptr pg_hd; \
386 pg_hd = PAGE_HEADER(STR); \
387 LOCK_PAGE_ENTRY(PG_ENT); \
388 UPDATE_STATS(PgEnt_strs_in_use(PG_ENT), -1); \
389 if (--PgHd_strs_in_use(pg_hd) == 0) { \
390 UPDATE_STATS(PgEnt_pages_in_use(PG_ENT), -1); \
391 if (PgHd_previous(pg_hd)) { \
392 if ((PgHd_next(PgHd_previous(pg_hd)) = PgHd_next(pg_hd)) == NULL) \
393 PgEnt_last(PG_ENT) = PgHd_previous(pg_hd); \
394 else \
395 PgHd_previous(PgHd_next(pg_hd)) = PgHd_previous(pg_hd); \
396 } else { \
397 if ((PgEnt_first(PG_ENT) = PgHd_next(pg_hd)) == NULL) \
398 PgEnt_last(PG_ENT) = NULL; \
399 else \
400 PgHd_previous(PgHd_next(pg_hd)) = NULL; \
401 } \
402 UNLOCK_PAGE_ENTRY(PG_ENT); \
403 LOCK_PAGE_ENTRY(GLOBAL_pages_void); \
404 PUT_FREE_PAGE(pg_hd); \
405 UNLOCK_PAGE_ENTRY(GLOBAL_pages_void); \
406 } else { \
407 STRUCT_NEXT(STR) = (STR_TYPE *) PgHd_first_str(pg_hd); \
408 if (PgHd_alloc_area(pg_hd) == NULL && PgHd_first_str(pg_hd) == NULL) { \
409 PgHd_next(pg_hd) = NULL; \
410 if ((PgHd_previous(pg_hd) = PgEnt_last(PG_ENT)) != NULL) \
411 PgHd_next(PgHd_previous(pg_hd)) = pg_hd; \
412 PgEnt_last(PG_ENT) = pg_hd; \
413 } \
414 PgHd_first_str(pg_hd) = (void *) STR; \
415 UNLOCK_PAGE_ENTRY(PG_ENT); \
416 } \
417 }
418#endif /***********************************************************************************/
419
420#if defined(THREADS) && defined(TABLING)
421#define ALLOC_STRUCT(STR, STR_TYPE, _PG_ENT) \
422 GET_FREE_STRUCT(STR, STR_TYPE, LOCAL##_PG_ENT, GLOBAL##_PG_ENT)
423#define FREE_STRUCT(STR, STR_TYPE, _PG_ENT) \
424 PUT_FREE_STRUCT(STR, STR_TYPE, LOCAL##_PG_ENT)
425#else
426#define ALLOC_STRUCT(STR, STR_TYPE, _PG_ENT) \
427 GET_FREE_STRUCT(STR, STR_TYPE, GLOBAL##_PG_ENT, ___NOT_USED___)
428#define FREE_STRUCT(STR, STR_TYPE, _PG_ENT) \
429 PUT_FREE_STRUCT(STR, STR_TYPE, GLOBAL##_PG_ENT)
430#endif
431#define ALLOC_NEXT_STRUCT(LOCAL_STR, STR, STR_TYPE, _PG_ENT) \
432 GET_NEXT_FREE_STRUCT(LOCAL_STR, STR, STR_TYPE, GLOBAL##_PG_ENT)
433
434#define ALLOC_TABLE_ENTRY(STR) ALLOC_STRUCT(STR, struct table_entry, _pages_tab_ent)
435#define FREE_TABLE_ENTRY(STR) FREE_STRUCT(STR, struct table_entry, _pages_tab_ent)
436
437#define ALLOC_SUBGOAL_ENTRY(STR) ALLOC_STRUCT(STR, struct subgoal_entry, _pages_sg_ent)
438#define FREE_SUBGOAL_ENTRY(STR) FREE_STRUCT(STR, struct subgoal_entry, _pages_sg_ent)
439
440#define ALLOC_SUBGOAL_FRAME(STR) ALLOC_STRUCT(STR, struct subgoal_frame, _pages_sg_fr)
441#define FREE_SUBGOAL_FRAME(STR) FREE_STRUCT(STR, struct subgoal_frame, _pages_sg_fr)
442
443#define ALLOC_DEPENDENCY_FRAME(STR) ALLOC_STRUCT(STR, struct dependency_frame, _pages_dep_fr)
444#define FREE_DEPENDENCY_FRAME(STR) FREE_STRUCT(STR, struct dependency_frame, _pages_dep_fr)
445
446#define ALLOC_SUBGOAL_TRIE_NODE(STR) ALLOC_STRUCT(STR, struct subgoal_trie_node, _pages_sg_node)
447#define FREE_SUBGOAL_TRIE_NODE(STR) FREE_STRUCT(STR, struct subgoal_trie_node, _pages_sg_node)
448
449#define ALLOC_SUBGOAL_TRIE_HASH(STR) ALLOC_STRUCT(STR, struct subgoal_trie_hash, _pages_sg_hash)
450#define FREE_SUBGOAL_TRIE_HASH(STR) FREE_STRUCT(STR, struct subgoal_trie_hash, _pages_sg_hash)
451
452#ifdef YAPOR
453#define ALLOC_ANSWER_TRIE_NODE(STR) ALLOC_NEXT_STRUCT(LOCAL_next_free_ans_node, STR, struct answer_trie_node, _pages_ans_node)
454#else
455#define ALLOC_ANSWER_TRIE_NODE(STR) ALLOC_STRUCT(STR, struct answer_trie_node, _pages_ans_node)
456#endif
457#define FREE_ANSWER_TRIE_NODE(STR) FREE_STRUCT(STR, struct answer_trie_node, _pages_ans_node)
458
459#define ALLOC_ANSWER_TRIE_HASH(STR) ALLOC_STRUCT(STR, struct answer_trie_hash, _pages_ans_hash)
460#define FREE_ANSWER_TRIE_HASH(STR) FREE_STRUCT(STR, struct answer_trie_hash, _pages_ans_hash)
461
462#define ALLOC_ANSWER_REF_NODE(STR) ALLOC_STRUCT(STR, struct answer_ref_node, _pages_ans_ref_node)
463#define FREE_ANSWER_REF_NODE(STR) FREE_STRUCT(STR, struct answer_ref_node, _pages_ans_ref_node)
464
465#define ALLOC_GLOBAL_TRIE_NODE(STR) ALLOC_STRUCT(STR, struct global_trie_node, _pages_gt_node)
466#define FREE_GLOBAL_TRIE_NODE(STR) FREE_STRUCT(STR, struct global_trie_node, _pages_gt_node)
467
468#define ALLOC_GLOBAL_TRIE_HASH(STR) ALLOC_STRUCT(STR, struct global_trie_hash, _pages_gt_hash)
469#define FREE_GLOBAL_TRIE_HASH(STR) FREE_STRUCT(STR, struct global_trie_hash, _pages_gt_hash)
470
471#define ALLOC_OR_FRAME(STR) ALLOC_STRUCT(STR, struct or_frame, _pages_or_fr)
472#define FREE_OR_FRAME(STR) FREE_STRUCT(STR, struct or_frame, _pages_or_fr)
473
474#define ALLOC_QG_SOLUTION_FRAME(STR) ALLOC_STRUCT(STR, struct query_goal_solution_frame, _pages_qg_sol_fr)
475#define FREE_QG_SOLUTION_FRAME(STR) FREE_STRUCT(STR, struct query_goal_solution_frame, _pages_qg_sol_fr)
476
477#define ALLOC_QG_ANSWER_FRAME(STR) ALLOC_STRUCT(STR, struct query_goal_answer_frame, _pages_qg_ans_fr)
478#define FREE_QG_ANSWER_FRAME(STR) FREE_STRUCT(STR, struct query_goal_answer_frame, _pages_qg_ans_fr)
479
480#define ALLOC_SUSPENSION_FRAME(STR) ALLOC_STRUCT(STR, struct suspension_frame, _pages_susp_fr)
481#define FREE_SUSPENSION_FRAME(STR) FREE_BLOCK(SuspFr_global_start(STR)); \
482 FREE_STRUCT(STR, struct suspension_frame, _pages_susp_fr)
483
484#define ALLOC_TG_SOLUTION_FRAME(STR) ALLOC_STRUCT(STR, struct table_subgoal_solution_frame, _pages_tg_sol_fr)
485#define FREE_TG_SOLUTION_FRAME(STR) FREE_STRUCT(STR, struct table_subgoal_solution_frame, _pages_tg_sol_fr)
486
487#define ALLOC_TG_ANSWER_FRAME(STR) ALLOC_STRUCT(STR, struct table_subgoal_answer_frame, _pages_tg_ans_fr)
488#define FREE_TG_ANSWER_FRAME(STR) FREE_STRUCT(STR, struct table_subgoal_answer_frame, _pages_tg_ans_fr)
489
490
491
492/************************************************************************
493** Bitmap manipulation **
494************************************************************************/
495
496#define BITMAP_empty(b) ((b) == 0)
497#define BITMAP_member(b,n) (((b) & (1<<(n))) != 0)
498#define BITMAP_alone(b,n) ((b) == (1<<(n)))
499#define BITMAP_subset(b1,b2) (((b1) & (b2)) == b2)
500#define BITMAP_same(b1,b2) ((b1) == (b2))
501#define BITMAP_clear(b) ((b) = 0)
502#define BITMAP_and(b1,b2) ((b1) &= (b2))
503#define BITMAP_minus(b1,b2) ((b1) &= ~(b2))
504#define BITMAP_insert(b,n) ((b) |= (1<<(n)))
505#define BITMAP_delete(b,n) ((b) &= (~(1<<(n))))
506#define BITMAP_copy(b1,b2) ((b1) = (b2))
507#define BITMAP_intersection(b1,b2,b3) ((b1) = ((b2) & (b3)))
508#define BITMAP_difference(b1,b2,b3) ((b1) = ((b2) & (~(b3))))
509
510
511
512/************************************************************************
513** Debug macros **
514************************************************************************/
515
516#define INFORMATION_MESSAGE(MESSAGE, ...) \
517 fprintf( stderr, "[ " MESSAGE " ]\n", __VA_ARGS__)
518
519#ifdef YAPOR
520#define ERROR_MESSAGE(MESSAGE) \
521 Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "W%d - " MESSAGE, worker_id)
522#else
523#define ERROR_MESSAGE(MESSAGE) \
524 Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, MESSAGE)
525#endif /* YAPOR */
526
527#ifdef DEBUG_TABLING
528#define TABLING_ERROR_CHECKING(PROCEDURE,TEST) \
529 if (TEST) ERROR_MESSAGE(#PROCEDURE ": " #TEST)
530#else
531#define TABLING_ERROR_CHECKING(PROCEDURE,TEST)
532#endif /* DEBUG_TABLING */
533
534#ifdef DEBUG_YAPOR
535#define YAPOR_ERROR_CHECKING(PROCEDURE,TEST) \
536 if (TEST) ERROR_MESSAGE(#PROCEDURE ": " #TEST)
537#else
538#define YAPOR_ERROR_CHECKING(PROCEDURE,TEST)
539#endif /* DEBUG_YAPOR */
540
541#ifdef DEBUG_OPTYAP
542#define OPTYAP_ERROR_CHECKING(PROCEDURE,TEST) \
543 if (TEST) ERROR_MESSAGE(#PROCEDURE ": " #TEST)
544#else
545#define OPTYAP_ERROR_CHECKING(PROCEDURE,TEST)
546#endif /* DEBUG_OPTYAP */
547
548#ifdef OUTPUT_THREADS_TABLING
549#define INFO_THREADS(MESSAGE, ARGS...) \
550 fprintf(LOCAL_thread_output, "[ " MESSAGE " ]\n", ##ARGS)
551#define INFO_THREADS_MAIN_THREAD(MESSAGE, ARGS...) \
552 Sfprintf(Serror, "[ " MESSAGE " ]\n", ##ARGS)
553#else
554#define INFO_THREADS(MESG, ...)
555#define INFO_THREADS_MAIN_THREAD(MESSAGE, ...)
556#endif /* OUTPUT_THREADS_TABLING */