YAP 7.1.0
or.copy_engine.c
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** Includes **
16** ------------------ */
17
18#include "Yap.h"
19#ifdef YAPOR_COPY
20#ifdef HAVE_STRING_H
21#include <string.h>
22#endif /* HAVE_STRING_H */
23#include "Yatom.h"
24#include "YapHeap.h"
25#include "or.macros.h"
26#ifdef TABLING
27#include "tab.macros.h"
28#else
29#include "opt.mavar.h"
30#endif /* TABLING */
31
32
33
34/* ------------------------------------- **
35** Local functions declaration **
36** ------------------------------------- */
37
38static void share_private_nodes(int worker_q);
39
40
41
42/* ---------------------- **
43** Local macros **
44** ---------------------- */
45
46#define INCREMENTAL_COPY 1
47#if INCREMENTAL_COPY
48#define COMPUTE_SEGMENTS_TO_COPY_TO(Q) \
49 if (REMOTE_top_cp(Q) == GLOBAL_root_cp) \
50 REMOTE_start_global_copy(Q) = (CELL) (H0); \
51 else \
52 REMOTE_start_global_copy(Q) = (CELL) (REMOTE_top_cp(Q)->cp_h); \
53 REMOTE_end_global_copy(Q) = (CELL) (B->cp_h); \
54 REMOTE_start_local_copy(Q) = (CELL) (B); \
55 REMOTE_end_local_copy(Q) = (CELL) (REMOTE_top_cp(Q)); \
56 REMOTE_start_trail_copy(Q) = (CELL) (REMOTE_top_cp(Q)->cp_tr); \
57 REMOTE_end_trail_copy(Q) = (CELL) (TR)
58#else
59#define COMPUTE_SEGMENTS_TO_COPY_TO(Q) \
60 REMOTE_start_global_copy(Q) = (CELL) (H0); \
61 REMOTE_end_global_copy(Q) = (CELL) (HR); \
62 REMOTE_start_local_copy(Q) = (CELL) (B); \
63 REMOTE_end_local_copy(Q) = (CELL) (GLOBAL_root_cp); \
64 REMOTE_start_trail_copy(Q) = (CELL) (GLOBAL_root_cp->cp_tr); \
65 REMOTE_end_trail_copy(Q) = (CELL) (TR)
66#endif
67
68#define P_COPY_GLOBAL_TO(Q) \
69 memcpy((void *) (worker_offset(Q) + REMOTE_start_global_copy(Q)), \
70 (void *) REMOTE_start_global_copy(Q), \
71 (size_t) (REMOTE_end_global_copy(Q) - REMOTE_start_global_copy(Q)))
72#define Q_COPY_GLOBAL_FROM(P) \
73 memcpy((void *) LOCAL_start_global_copy, \
74 (void *) (worker_offset(P) + LOCAL_start_global_copy), \
75 (size_t) (LOCAL_end_global_copy - LOCAL_start_global_copy))
76
77#define P_COPY_LOCAL_TO(Q) \
78 memcpy((void *) (worker_offset(Q) + REMOTE_start_local_copy(Q)), \
79 (void *) REMOTE_start_local_copy(Q), \
80 (size_t) (REMOTE_end_local_copy(Q) - REMOTE_start_local_copy(Q)))
81#define Q_COPY_LOCAL_FROM(P) \
82 memcpy((void *) LOCAL_start_local_copy, \
83 (void *) (worker_offset(P) + LOCAL_start_local_copy), \
84 (size_t) (LOCAL_end_local_copy - LOCAL_start_local_copy))
85
86#define P_COPY_TRAIL_TO(Q) \
87 memcpy((void *) (worker_offset(Q) + REMOTE_start_trail_copy(Q)), \
88 (void *) REMOTE_start_trail_copy(Q), \
89 (size_t) (REMOTE_end_trail_copy(Q) - REMOTE_start_trail_copy(Q)))
90#define Q_COPY_TRAIL_FROM(P) \
91 memcpy((void *) LOCAL_start_trail_copy, \
92 (void *) (worker_offset(P) + LOCAL_start_trail_copy), \
93 (size_t) (LOCAL_end_trail_copy - LOCAL_start_trail_copy))
94
95
96
97/* -------------------------- **
98** Global functions **
99** -------------------------- */
100
101void make_root_choice_point(void) {
102 if (worker_id == 0) {
103 LOCAL_top_cp = GLOBAL_root_cp = OrFr_node(GLOBAL_root_or_fr) = B;
104 } else {
105 B = LOCAL_top_cp = GLOBAL_root_cp;
106 B->cp_tr = TR = ((choiceptr) (worker_offset(0) + (CELL)(B)))->cp_tr;
107 }
108 // B->cp_h = H0;
109 B->cp_ap = GETWORK;
110 B->cp_or_fr = GLOBAL_root_or_fr;
111 LOCAL_top_or_fr = GLOBAL_root_or_fr;
112 LOCAL_load = 0;
113 Set_LOCAL_prune_request(NULL);
114 BRANCH(worker_id, 0) = 0;
115#ifdef TABLING_INNER_CUTS
116 LOCAL_pruning_scope = NULL;
117#endif /* TABLING_INNER_CUTS */
118#ifdef TABLING
119 LOCAL_top_cp_on_stack = LOCAL_top_cp;
120 adjust_freeze_registers();
121#endif /* TABLING */
122 return;
123}
124
125
126void free_root_choice_point(void) {
127 B = LOCAL_top_cp->cp_b;
128#ifdef TABLING
129 LOCAL_top_cp_on_stack =
130#endif /* TABLING */
131 LOCAL_top_cp = GLOBAL_root_cp = OrFr_node(GLOBAL_root_or_fr) = (choiceptr) LOCAL_LocalBase;
132 return;
133}
134
135
136int p_share_work(void) {
137 int worker_q = LOCAL_share_request;
138
139 if (! BITMAP_member(OrFr_members(REMOTE_top_or_fr(worker_q)), worker_id) ||
140 B == REMOTE_top_cp(worker_q) ||
141 (LOCAL_load <= GLOBAL_delayed_release_load && OrFr_nearest_livenode(LOCAL_top_or_fr) == NULL)) {
142 /* refuse sharing request */
143 REMOTE_reply_signal(LOCAL_share_request) = no_sharing;
144 LOCAL_share_request = MAX_WORKERS;
145 PUT_OUT_REQUESTABLE(worker_id);
146 return 0;
147 }
148 /* sharing request accepted */
149 COMPUTE_SEGMENTS_TO_COPY_TO(worker_q);
150 REMOTE_q_fase_signal(worker_q) = Q_idle;
151 REMOTE_p_fase_signal(worker_q) = P_idle;
152#ifndef TABLING
153 /* wait for incomplete installations */
154 while (LOCAL_reply_signal != worker_ready);
155#endif /* TABLING */
156 LOCAL_reply_signal = sharing;
157 REMOTE_reply_signal(worker_q) = sharing;
158 share_private_nodes(worker_q);
159 if(Get_LOCAL_prune_request())
160 CUT_send_prune_request(worker_q, Get_LOCAL_prune_request());
161 REMOTE_reply_signal(worker_q) = nodes_shared;
162 /* copy local stack ? */
163 LOCK(REMOTE_lock_signals(worker_q));
164 if (REMOTE_q_fase_signal(worker_q) < local) {
165 REMOTE_p_fase_signal(worker_q) = local;
166 UNLOCK(REMOTE_lock_signals(worker_q));
167 P_COPY_LOCAL_TO(worker_q);
168 } else {
169 UNLOCK(REMOTE_lock_signals(worker_q));
170 goto sync_with_q;
171 }
172 /* copy global stack ? */
173 LOCK(REMOTE_lock_signals(worker_q));
174 if (REMOTE_q_fase_signal(worker_q) < global) {
175 REMOTE_p_fase_signal(worker_q) = global;
176 UNLOCK(REMOTE_lock_signals(worker_q));
177 P_COPY_GLOBAL_TO(worker_q);
178 } else {
179 UNLOCK(REMOTE_lock_signals(worker_q));
180 goto sync_with_q;
181 }
182 /* copy trail stack ? */
183 LOCK(REMOTE_lock_signals(worker_q));
184 if (REMOTE_q_fase_signal(worker_q) < trail) {
185 REMOTE_p_fase_signal(worker_q) = trail;
186 UNLOCK(REMOTE_lock_signals(worker_q));
187 P_COPY_TRAIL_TO(worker_q);
188 } else UNLOCK(REMOTE_lock_signals(worker_q));
189
190sync_with_q:
191 REMOTE_reply_signal(worker_q) = copy_done;
192 while (LOCAL_reply_signal == sharing);
193 while (REMOTE_reply_signal(worker_q) != worker_ready);
194 LOCAL_share_request = MAX_WORKERS;
195 PUT_IN_REQUESTABLE(worker_id);
196
197 return 1;
198}
199
200
201int q_share_work(int worker_p) {
202 register tr_fr_ptr aux_tr;
203 register CELL aux_cell;
204
205 LOCK_OR_FRAME(LOCAL_top_or_fr);
206 if (REMOTE_prune_request(worker_p)) {
207 /* worker p with prune request */
208 UNLOCK_OR_FRAME(LOCAL_top_or_fr);
209 return FALSE;
210 }
211 YAPOR_ERROR_CHECKING(q_share_work, Get_OrFr_pend_prune_cp(LOCAL_top_or_fr) && BRANCH_LTT(worker_p, OrFr_depth(LOCAL_top_or_fr)) < OrFr_pend_prune_ltt(LOCAL_top_or_fr));
212 /* there is no pending prune with worker p at right --> safe move to worker p branch */
213 CUT_reset_prune_request();
214 if(Get_LOCAL_prune_request()){
215 UNLOCK_OR_FRAME(LOCAL_top_or_fr);
216 return FALSE;
217 }
218 BRANCH(worker_id, OrFr_depth(LOCAL_top_or_fr)) = BRANCH(worker_p, OrFr_depth(LOCAL_top_or_fr));
219 UNLOCK_OR_FRAME(LOCAL_top_or_fr);
220
221 /* unbind variables */
222 aux_tr = LOCAL_top_cp->cp_tr;
223 TABLING_ERROR_CHECKING(q_share_work, TR < aux_tr);
224 while (aux_tr != TR) {
225 aux_cell = TrailTerm(--TR);
226 /* check for global or local variables */
227 if (IsVarTerm(aux_cell)) {
228 RESET_VARIABLE(aux_cell);
229#ifdef TABLING
230 } else if (IsPairTerm(aux_cell)) {
231 aux_cell = (CELL) RepPair(aux_cell);
232 if (IN_BETWEEN(LOCAL_TrailBase, aux_cell, LOCAL_TrailTop)) {
233 /* avoid frozen segments */
234 TR = (tr_fr_ptr) aux_cell;
235 TABLING_ERROR_CHECKING(q_share_work, TR > (tr_fr_ptr) LOCAL_TrailTop);
236 TABLING_ERROR_CHECKING(q_share_work, TR < aux_tr);
237 }
238#endif /* TABLING */
239#ifdef MULTI_ASSIGNMENT_VARIABLES
240 } else if (IsApplTerm(aux_cell)) {
241 CELL *aux_ptr = RepAppl(aux_cell);
242 Term aux_val = TrailTerm(--aux_tr);
243 *aux_ptr = aux_val;
244#endif /* MULTI_ASSIGNMENT_VARIABLES */
245 }
246 }
247
248 OPTYAP_ERROR_CHECKING(q_share_work, LOCAL_top_cp != LOCAL_top_cp_on_stack);
249 OPTYAP_ERROR_CHECKING(q_share_work, YOUNGER_CP(B_FZ, LOCAL_top_cp));
250 YAPOR_ERROR_CHECKING(q_share_work, LOCAL_reply_signal != worker_ready);
251
252 /* make sharing request */
253 LOCK_WORKER(worker_p);
254 if (BITMAP_member(GLOBAL_bm_idle_workers, worker_p) ||
255 REMOTE_share_request(worker_p) != MAX_WORKERS) {
256 /* worker p is idle or has another request */
257 UNLOCK_WORKER(worker_p);
258 return FALSE;
259 }
260 REMOTE_share_request(worker_p) = worker_id;
261 UNLOCK_WORKER(worker_p);
262
263 /* wait for an answer */
264 while (LOCAL_reply_signal == worker_ready);
265 if (LOCAL_reply_signal == no_sharing) {
266 /* sharing request refused */
267 LOCAL_reply_signal = worker_ready;
268 return FALSE;
269 }
270
271 /* copy trail stack ? */
272 LOCK(LOCAL_lock_signals);
273 if (LOCAL_p_fase_signal > trail) {
274 LOCAL_q_fase_signal = trail;
275 UNLOCK(LOCAL_lock_signals);
276 Q_COPY_TRAIL_FROM(worker_p);
277 } else {
278 UNLOCK(LOCAL_lock_signals);
279 goto sync_with_p;
280 }
281
282 /* copy global stack ? */
283 LOCK(LOCAL_lock_signals);
284 if (LOCAL_p_fase_signal > global) {
285 LOCAL_q_fase_signal = global;
286 UNLOCK(LOCAL_lock_signals);
287 Q_COPY_GLOBAL_FROM(worker_p);
288 } else {
289 UNLOCK(LOCAL_lock_signals);
290 goto sync_with_p;
291 }
292
293 /* copy local stack ? */
294 while (LOCAL_reply_signal < nodes_shared);
295 LOCK(LOCAL_lock_signals);
296 if (LOCAL_p_fase_signal > local) {
297 LOCAL_q_fase_signal = local;
298 UNLOCK(LOCAL_lock_signals);
299 Q_COPY_LOCAL_FROM(worker_p);
300 } else UNLOCK(LOCAL_lock_signals);
301
302sync_with_p:
303#ifdef TABLING
304 REMOTE_reply_signal(worker_p) = worker_ready;
305#else
306 REMOTE_reply_signal(worker_p) = copy_done;
307#endif /* TABLING */
308 while (LOCAL_reply_signal != copy_done);
309
310#if INCREMENTAL_COPY
311 /* install fase --> TR and LOCAL_top_cp->cp_tr are equal */
312 aux_tr = ((choiceptr) LOCAL_start_local_copy)->cp_tr;
313 TR = ((choiceptr) LOCAL_end_local_copy)->cp_tr;
314 Yap_NEW_MAHASH((ma_h_inner_struct *)HR);
315 while (TR != aux_tr) {
316 aux_cell = TrailTerm(--aux_tr);
317 if (IsVarTerm(aux_cell)) {
318 if (aux_cell < LOCAL_start_global_copy || EQUAL_OR_YOUNGER_CP((choiceptr)LOCAL_end_local_copy, (choiceptr)aux_cell)) {
319 YAPOR_ERROR_CHECKING(q_share_work, (CELL *)aux_cell < H0);
320 YAPOR_ERROR_CHECKING(q_share_work, (ADDR)aux_cell > LOCAL_LocalBase);
321#ifdef TABLING
322 *((CELL *) aux_cell) = TrailVal(aux_tr);
323#else
324 *((CELL *) aux_cell) = *((CELL *) (worker_offset(worker_p) + aux_cell));
325#endif /* TABLING */
326 }
327#ifdef TABLING
328 } else if (IsPairTerm(aux_cell)) {
329 aux_cell = (CELL) RepPair(aux_cell);
330 if (IN_BETWEEN(LOCAL_TrailBase, aux_cell, LOCAL_TrailTop)) {
331 /* avoid frozen segments */
332 aux_tr = (tr_fr_ptr) aux_cell;
333 }
334#endif /* TABLING */
335#ifdef MULTI_ASSIGNMENT_VARIABLES
336 } else if (IsApplTerm(aux_cell)) {
337 CELL *cell_ptr = RepAppl(aux_cell);
338 if (((CELL *)aux_cell < LOCAL_top_cp->cp_h ||
339 EQUAL_OR_YOUNGER_CP(LOCAL_top_cp, (choiceptr)aux_cell)) &&
340 !Yap_lookup_ma_var(cell_ptr)) {
341 /* first time we found the variable, let's put the new value */
342#ifdef TABLING
343 *cell_ptr = TrailVal(aux_tr);
344#else
345 *cell_ptr = *((CELL *) (worker_offset(worker_p) + (CELL)cell_ptr));
346#endif /* TABLING */
347 }
348 /* skip the old value */
349 aux_tr--;
350#endif /* MULTI_ASSIGNMENT_VARIABLES */
351 }
352 }
353#endif /* incremental */
354
355 /* update registers and return */
356 PUT_OUT_ROOT_NODE(worker_id);
357#ifndef TABLING
358 REMOTE_reply_signal(worker_p) = worker_ready;
359#endif /* TABLING */
360 TR = (tr_fr_ptr) LOCAL_end_trail_copy;
361 LOCAL_reply_signal = worker_ready;
362 PUT_IN_REQUESTABLE(worker_id);
363#ifdef TABLING
364 adjust_freeze_registers();
365#endif /* TABLING */
366 return TRUE;
367}
368
369
370/* ------------------------- **
371** Local functions **
372** ------------------------- */
373
374static
375void share_private_nodes(int worker_q) {
376 choiceptr sharing_node = B;
377
378#ifdef DEBUG_OPTYAP
379 OPTYAP_ERROR_CHECKING(share_private_nodes, YOUNGER_CP(LOCAL_top_cp, LOCAL_top_cp_on_stack));
380 { choiceptr aux_cp = B;
381 while (aux_cp != LOCAL_top_cp) {
382 OPTYAP_ERROR_CHECKING(share_private_nodes, YOUNGER_CP(LOCAL_top_cp, aux_cp));
383 OPTYAP_ERROR_CHECKING(share_private_nodes, EQUAL_OR_YOUNGER_CP(LOCAL_top_cp_on_stack, aux_cp));
384 aux_cp = aux_cp->cp_b;
385 }
386 }
387#endif /* DEBUG_OPTYAP */
388
389#ifdef TABLING
390 /* check if the branch is already shared */
391 if (EQUAL_OR_YOUNGER_CP(LOCAL_top_cp_on_stack, sharing_node)) {
392 or_fr_ptr or_frame;
393 sg_fr_ptr sg_frame;
394 dep_fr_ptr dep_frame;
395
396#ifdef DEBUG_OPTYAP
397 { or_fr_ptr aux_or_fr;
398 aux_or_fr = LOCAL_top_or_fr;
399 while (aux_or_fr != REMOTE_top_or_fr(worker_q)) {
400 OPTYAP_ERROR_CHECKING(share_private_nodes, YOUNGER_CP(OrFr_node(REMOTE_top_or_fr(worker_q)), OrFr_node(aux_or_fr)));
401 aux_or_fr = OrFr_next_on_stack(aux_or_fr);
402 }
403 }
404#endif /* DEBUG_OPTYAP */
405
406 /* update old shared nodes */
407 or_frame = LOCAL_top_or_fr;
408 while (or_frame != REMOTE_top_or_fr(worker_q)) {
409 LOCK_OR_FRAME(or_frame);
410 BRANCH(worker_q, OrFr_depth(or_frame)) = BRANCH(worker_id, OrFr_depth(or_frame));
411 OrFr_owners(or_frame)++;
412 if (BITMAP_member(OrFr_members(or_frame), worker_id))
413 BITMAP_insert(OrFr_members(or_frame), worker_q);
414 UNLOCK_OR_FRAME(or_frame);
415 or_frame = OrFr_next_on_stack(or_frame);
416 }
417
418 /* update worker Q top subgoal frame */
419 sg_frame = LOCAL_top_sg_fr;
420 while (sg_frame && YOUNGER_CP(SgFr_gen_cp(sg_frame), sharing_node)) {
421 sg_frame = SgFr_next(sg_frame);
422 }
423 REMOTE_top_sg_fr(worker_q) = sg_frame;
424
425 /* update worker Q top dependency frame */
426 dep_frame = LOCAL_top_dep_fr;
427 while (YOUNGER_CP(DepFr_cons_cp(dep_frame), sharing_node)) {
428 dep_frame = DepFr_next(dep_frame);
429 }
430 REMOTE_top_dep_fr(worker_q) = dep_frame;
431
432 /* update worker Q top shared nodes */
433 REMOTE_top_cp_on_stack(worker_q) = REMOTE_top_cp(worker_q) = LOCAL_top_cp;
434 REMOTE_top_or_fr(worker_q) = LOCAL_top_or_fr;
435 } else
436#endif /* TABLING */
437 {
438 int depth;
439 bitmap bm_workers;
440 or_fr_ptr or_frame, previous_or_frame;
441#ifdef TABLING
442 choiceptr consumer_cp, next_node_on_branch;
443 dep_fr_ptr dep_frame;
444 sg_fr_ptr sg_frame;
445 CELL *stack, *stack_limit;
446
447 /* find top dependency frame above current choice point */
448 dep_frame = LOCAL_top_dep_fr;
449 while (EQUAL_OR_YOUNGER_CP(DepFr_cons_cp(dep_frame), sharing_node)) {
450 dep_frame = DepFr_next(dep_frame);
451 }
452 /* initialize tabling auxiliary variables */
453 consumer_cp = DepFr_cons_cp(dep_frame);
454 next_node_on_branch = NULL;
455 stack_limit = (CELL *)TR;
456 stack = (CELL *)LOCAL_TrailTop;
457#endif /* TABLING */
458
459 /* initialize auxiliary variables */
460 BITMAP_clear(bm_workers);
461 BITMAP_insert(bm_workers, worker_id);
462 BITMAP_insert(bm_workers, worker_q);
463 previous_or_frame = NULL;
464 depth = OrFr_depth(LOCAL_top_or_fr);
465
466 /* sharing loop */
467#ifdef TABLING
468 while (YOUNGER_CP(sharing_node, LOCAL_top_cp_on_stack)) {
469#else
470 while (sharing_node != LOCAL_top_cp) {
471#endif /* TABLING */
472
473#ifdef DEBUG_OPTYAP
474 if (next_node_on_branch) {
475 choiceptr aux_cp = B;
476 while (aux_cp != next_node_on_branch) {
477 OPTYAP_ERROR_CHECKING(share_private_nodes, sharing_node == aux_cp);
478 OPTYAP_ERROR_CHECKING(share_private_nodes, YOUNGER_CP(next_node_on_branch, aux_cp));
479 aux_cp = aux_cp->cp_b;
480 }
481 } else {
482 choiceptr aux_cp = B;
483 while (aux_cp != sharing_node) {
484 OPTYAP_ERROR_CHECKING(share_private_nodes, YOUNGER_CP(sharing_node, aux_cp));
485 aux_cp = aux_cp->cp_b;
486 }
487 }
488#endif /* DEBUG_OPTYAP */
489
490 ALLOC_OR_FRAME(or_frame);
491 if (previous_or_frame) {
492#ifdef TABLING
493 OrFr_next_on_stack(previous_or_frame) =
494#endif /* TABLING */
495 OrFr_nearest_livenode(previous_or_frame) = OrFr_next(previous_or_frame) = or_frame;
496 }
497 previous_or_frame = or_frame;
498 depth++;
499 INIT_LOCK(OrFr_lock(or_frame));
500 OrFr_node(or_frame) = sharing_node;
501 OrFr_alternative(or_frame) = sharing_node->cp_ap;
502 OrFr_pend_prune_cp(or_frame) = NULL;
503 OrFr_nearest_leftnode(or_frame) = LOCAL_top_or_fr;
504 OrFr_qg_solutions(or_frame) = NULL;
505#ifdef TABLING_INNER_CUTS
506 OrFr_tg_solutions(or_frame) = NULL;
507#endif /* TABLING_INNER_CUTS */
508#ifdef TABLING
509 OrFr_suspensions(or_frame) = NULL;
510 OrFr_nearest_suspnode(or_frame) = or_frame;
511 OrFr_owners(or_frame) = 2;
512 if (next_node_on_branch)
513 BITMAP_clear(OrFr_members(or_frame));
514 else
515#endif /* TABLING */
516 OrFr_members(or_frame) = bm_workers;
517
518 YAPOR_ERROR_CHECKING(share_private_nodes, sharing_node->cp_ap == GETWORK || sharing_node->cp_ap == GETWORK_SEQ);
519 if (sharing_node->cp_ap && YAMOP_SEQ(sharing_node->cp_ap)) {
520 sharing_node->cp_ap = GETWORK_SEQ;
521 } else {
522 sharing_node->cp_ap = GETWORK;
523 }
524 sharing_node->cp_or_fr = or_frame;
525 sharing_node = sharing_node->cp_b;
526
527#ifdef TABLING
528 /* when next_node_on_branch is not NULL the **
529 ** sharing_node belongs to a frozen branch. */
530 if (YOUNGER_CP(consumer_cp, sharing_node)) {
531 /* frozen stack segment */
532 if (! next_node_on_branch)
533 next_node_on_branch = sharing_node;
534 STACK_PUSH_UP(or_frame, stack);
535 STACK_CHECK_EXPAND(stack, stack_limit);
536 STACK_PUSH_UP(sharing_node, stack);
537 STACK_CHECK_EXPAND(stack, stack_limit);
538 sharing_node = consumer_cp;
539 dep_frame = DepFr_next(dep_frame);
540 consumer_cp = DepFr_cons_cp(dep_frame);
541 } else if (consumer_cp == sharing_node) {
542 dep_frame = DepFr_next(dep_frame);
543 consumer_cp = DepFr_cons_cp(dep_frame);
544 }
545 if (next_node_on_branch == sharing_node)
546 next_node_on_branch = NULL;
547#endif /* TABLING */
548 OPTYAP_ERROR_CHECKING(share_private_nodes, next_node_on_branch && YOUNGER_CP(next_node_on_branch, sharing_node));
549 }
550
551 /* initialize last or-frame pointer */
552 or_frame = sharing_node->cp_or_fr;
553 if (previous_or_frame) {
554#ifdef TABLING
555 OrFr_next_on_stack(previous_or_frame) =
556#endif /* TABLING */
557 OrFr_nearest_livenode(previous_or_frame) = OrFr_next(previous_or_frame) = or_frame;
558 }
559
560#ifdef TABLING
561 /* update or-frames stored in auxiliary stack */
562 while (STACK_NOT_EMPTY(stack, (CELL *)LOCAL_TrailTop)) {
563 next_node_on_branch = (choiceptr) STACK_POP_DOWN(stack);
564 or_frame = (or_fr_ptr) STACK_POP_DOWN(stack);
565 OrFr_nearest_livenode(or_frame) = OrFr_next(or_frame) = next_node_on_branch->cp_or_fr;
566 }
567#endif /* TABLING */
568
569 /* update depth */
570 if (depth >= MAX_BRANCH_DEPTH)
571 Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "maximum depth exceded (share_private_nodes)");
572 or_frame = B->cp_or_fr;
573#ifdef TABLING
574 previous_or_frame = LOCAL_top_cp_on_stack->cp_or_fr;
575 while (or_frame != previous_or_frame) {
576#else
577 while (or_frame != LOCAL_top_or_fr) {
578#endif /* TABLING */
579 unsigned int branch;
580 if (OrFr_alternative(or_frame)) {
581 branch = YAMOP_OR_ARG(OrFr_alternative(or_frame)) + 1;
582 } else {
583 branch = 1;
584 }
585 branch |= YAMOP_CUT_FLAG; /* in doubt, assume cut */
586 BRANCH(worker_id, depth) = BRANCH(worker_q, depth) = branch;
587 OrFr_depth(or_frame) = depth--;
588 or_frame = OrFr_next_on_stack(or_frame);
589 }
590
591 YAPOR_ERROR_CHECKING(share_private_nodes, depth != OrFr_depth(LOCAL_top_or_fr));
592
593#ifdef DEBUG_OPTYAP
594 { or_fr_ptr aux_or_fr = B->cp_or_fr;
595 choiceptr aux_cp;
596 while (aux_or_fr != LOCAL_top_cp_on_stack->cp_or_fr) {
597 aux_cp = OrFr_node(aux_or_fr);
598 OPTYAP_ERROR_CHECKING(share_private_nodes, OrFr_next(aux_or_fr) != aux_cp->cp_b->cp_or_fr);
599 OPTYAP_ERROR_CHECKING(share_private_nodes, OrFr_nearest_livenode(aux_or_fr) != aux_cp->cp_b->cp_or_fr);
600 aux_or_fr = OrFr_next_on_stack(aux_or_fr);
601 }
602 aux_or_fr = B->cp_or_fr;
603 while (aux_or_fr != LOCAL_top_cp_on_stack->cp_or_fr) {
604 or_fr_ptr nearest_leftnode = OrFr_nearest_leftnode(aux_or_fr);
605 aux_cp = OrFr_node(aux_or_fr);
606 while (OrFr_node(nearest_leftnode) != aux_cp) {
607 OPTYAP_ERROR_CHECKING(share_private_nodes, YOUNGER_CP(OrFr_node(nearest_leftnode), aux_cp));
608 aux_cp = aux_cp->cp_b;
609 }
610 aux_or_fr = OrFr_next_on_stack(aux_or_fr);
611 }
612 }
613#endif /* DEBUG_OPTYAP */
614
615 /* update old shared nodes */
616 while (or_frame != REMOTE_top_or_fr(worker_q)) {
617 LOCK_OR_FRAME(or_frame);
618 BRANCH(worker_q, OrFr_depth(or_frame)) = BRANCH(worker_id, OrFr_depth(or_frame));
619#ifdef TABLING
620 OrFr_owners(or_frame)++;
621 if (BITMAP_member(OrFr_members(or_frame), worker_id))
622#endif /* TABLING */
623 BITMAP_insert(OrFr_members(or_frame), worker_q);
624 UNLOCK_OR_FRAME(or_frame);
625 or_frame = OrFr_next_on_stack(or_frame);
626 }
627
628 LOCK_OR_FRAME(REMOTE_top_or_fr(worker_q));
629 or_fr_ptr old_top = REMOTE_top_or_fr(worker_q);
630 Set_REMOTE_top_cp(worker_q,B);
631 Set_LOCAL_top_cp(B);
632 REMOTE_top_or_fr(worker_q) = LOCAL_top_or_fr = Get_LOCAL_top_cp()->cp_or_fr;
633 UNLOCK_OR_FRAME(old_top);
634
635#ifdef TABLING
636 /* update subgoal frames in the maintained private branches */
637 sg_frame = LOCAL_top_sg_fr;
638 while (sg_frame && YOUNGER_CP(SgFr_gen_cp(sg_frame), B)) {
639 choiceptr top_cp_on_branch;
640 top_cp_on_branch = SgFr_gen_cp(sg_frame);
641 while (YOUNGER_CP(top_cp_on_branch, B)) {
642 top_cp_on_branch = top_cp_on_branch->cp_b;
643 }
644 SgFr_gen_top_or_fr(sg_frame) = top_cp_on_branch->cp_or_fr;
645 sg_frame = SgFr_next(sg_frame);
646 }
647 /* update worker Q top subgoal frame */
648 REMOTE_top_sg_fr(worker_q) = sg_frame;
649 /* update subgoal frames in the recently shared branches */
650 while (sg_frame && YOUNGER_CP(SgFr_gen_cp(sg_frame), LOCAL_top_cp_on_stack)) {
651 SgFr_gen_worker(sg_frame) = MAX_WORKERS;
652 SgFr_gen_top_or_fr(sg_frame) = SgFr_gen_cp(sg_frame)->cp_or_fr;
653 sg_frame = SgFr_next(sg_frame);
654 }
655
656 /* update dependency frames in the maintained private branches */
657 dep_frame = LOCAL_top_dep_fr;
658 while (YOUNGER_CP(DepFr_cons_cp(dep_frame), B)) {
659 choiceptr top_cp_on_branch;
660 top_cp_on_branch = DepFr_cons_cp(dep_frame);
661 while (YOUNGER_CP(top_cp_on_branch, B)) {
662 top_cp_on_branch = top_cp_on_branch->cp_b;
663 }
664 DepFr_top_or_fr(dep_frame) = top_cp_on_branch->cp_or_fr;
665 dep_frame = DepFr_next(dep_frame);
666 }
667 /* update worker Q top dependency frame */
668 REMOTE_top_dep_fr(worker_q) = dep_frame;
669 /* update dependency frames in the recently shared branches */
670 while (YOUNGER_CP(DepFr_cons_cp(dep_frame), LOCAL_top_cp_on_stack)) {
671 DepFr_top_or_fr(dep_frame) = DepFr_cons_cp(dep_frame)->cp_or_fr;
672 dep_frame = DepFr_next(dep_frame);
673 }
674#endif /* TABLING */
675
676#ifdef DEBUG_OPTYAP
677 { dep_fr_ptr aux_dep_fr = LOCAL_top_dep_fr;
678 while(aux_dep_fr != GLOBAL_root_dep_fr) {
679 choiceptr top_cp_on_branch;
680 top_cp_on_branch = DepFr_cons_cp(aux_dep_fr);
681 while (YOUNGER_CP(top_cp_on_branch, B)) {
682 top_cp_on_branch = top_cp_on_branch->cp_b;
683 }
684 OPTYAP_ERROR_CHECKING(share_private_nodes, top_cp_on_branch->cp_or_fr != DepFr_top_or_fr(aux_dep_fr));
685 aux_dep_fr = DepFr_next(aux_dep_fr);
686 }
687 }
688#endif /* DEBUG_OPTYAP */
689
690 /* update top shared nodes */
691#ifdef TABLING
692 REMOTE_top_cp_on_stack(worker_q) = LOCAL_top_cp_on_stack =
693#endif /* TABLING */
694 REMOTE_top_cp(worker_q) = LOCAL_top_cp = B;
695 REMOTE_top_or_fr(worker_q) = LOCAL_top_or_fr = LOCAL_top_cp->cp_or_fr;
696 }
697
698#ifdef TABLING_INNER_CUTS
699 /* update worker Q pruning scope */
700 if (LOCAL_pruning_scope && EQUAL_OR_YOUNGER_CP(LOCAL_top_cp, LOCAL_pruning_scope)) {
701 REMOTE_pruning_scope(worker_q) = LOCAL_pruning_scope;
702 PUT_IN_PRUNING(worker_q);
703 } else {
704 PUT_OUT_PRUNING(worker_q);
705 REMOTE_pruning_scope(worker_q) = NULL;
706 }
707#endif /* TABLING_INNER_CUTS */
708
709 /* update worker Q prune request */
710 if (LOCAL_prune_request) {
711 CUT_send_prune_request(worker_q, LOCAL_prune_request);
712 }
713
714 /* update load and return */
715 REMOTE_load(worker_q) = LOCAL_load = 0;
716 return;
717}
718#endif /* YAPOR_COPY */
719
Yap.h
Main definitions.
or_frame
Definition: or.structs.h:61
branch_descriptor
Definition: compiler.c:188
dependency_frame
Definition: tab.structs.h:381
subgoal_frame
Definition: tab.structs.h:296