incremental copying with or-threads.

C/grow.c

@@ -37,6 +37,12 @@
 #define DelayTop() H0
 #endif
 
+typedef enum {
+  STACK_SHIFTING = 0,
+  STACK_COPYING = 1,
+  STACK_INCREMENTAL_COPYING = 2
+} what_stack_copying;
+
 static int heap_overflows = 0;
 static Int total_heap_overflow_time = 0;
 
@@ -66,8 +72,8 @@ STATIC_PROTO(void MoveGlobal, (void));
 STATIC_PROTO(void MoveLocalAndTrail, (void));
 STATIC_PROTO(void SetHeapRegs, (int));
 STATIC_PROTO(void AdjustTrail, (int, int));
-STATIC_PROTO(void AdjustLocal, (void));
+STATIC_PROTO(void AdjustLocal, (int));
-STATIC_PROTO(void AdjustGlobal, (long));
+STATIC_PROTO(void AdjustGlobal, (long, int));
 STATIC_PROTO(void AdjustGrowStack, (void));
 STATIC_PROTO(int  static_growheap, (long,int,struct intermediates *,tr_fr_ptr *, TokEntry **, VarEntry **));
 STATIC_PROTO(void cpcellsd, (CELL *, CELL *, CELL));
@@ -75,6 +81,7 @@ STATIC_PROTO(CELL AdjustAppl, (CELL));
 STATIC_PROTO(CELL AdjustPair, (CELL));
 STATIC_PROTO(void AdjustStacksAndTrail, (long, int));
 STATIC_PROTO(void AdjustRegs, (int));
+STATIC_PROTO(Term AdjustGlobTerm, (Term));
 
 static void
 LeaveGrowMode(prolog_exec_mode grow_mode)
@@ -223,6 +230,97 @@ CopyLocalAndTrail(void)
 #endif
 }
 
+static void
+IncrementalCopyStacksFromWorker(void)
+{
+  memcpy((void *) PtoGloAdjust((CELL *)LOCAL_start_global_copy),
+	 (void *) (LOCAL_start_global_copy),
+	 (size_t) (LOCAL_end_global_copy - LOCAL_start_global_copy));
+  memcpy((void *) PtoLocAdjust((CELL *)LOCAL_start_local_copy),
+	 (void *) LOCAL_start_local_copy,
+	 (size_t) (LOCAL_end_local_copy - LOCAL_start_local_copy));
+  memcpy((void *) PtoTRAdjust((tr_fr_ptr)LOCAL_start_trail_copy),
+	 (void *) (LOCAL_start_trail_copy),
+	 (size_t) (LOCAL_end_trail_copy - LOCAL_start_trail_copy));
+}
+
+#if THREADS
+
+#include "opt.mavar.h"
+
+static CELL
+worker_p_binding(int worker_p, CELL *aux_ptr)
+{
+  if (aux_ptr > H) {
+    CELL reg = ThreadHandle[worker_p].current_yaam_regs->LCL0_[aux_ptr-LCL0];
+    reg = AdjustGlobTerm(reg);
+    return reg;
+  } else {
+    CELL reg = ThreadHandle[worker_p].current_yaam_regs->H0_[aux_ptr-H0];
+    reg = AdjustGlobTerm(reg);
+    return reg;
+  }
+}
+
+static void
+RestoreTrail(int worker_p)
+{
+  tr_fr_ptr aux_tr;
+
+  /* install fase --> TR and LOCAL_top_cp->cp_tr are equal */
+  aux_tr = ((choiceptr) LOCAL_start_local_copy)->cp_tr;
+  TR = ((choiceptr) LOCAL_end_local_copy)->cp_tr;
+  if (TR == aux_tr)
+    return;
+  if (aux_tr < TR){
+    Yap_Error(SYSTEM_ERROR, TermNil, "oops");
+  }
+  Yap_NEW_MAHASH((ma_h_inner_struct *)H);
+  while (TR != aux_tr) {
+    CELL aux_cell = TrailTerm(--aux_tr);
+    if (IsVarTerm(aux_cell)) {
+      if (aux_cell < LOCAL_start_global_copy || 
+          EQUAL_OR_YOUNGER_CP((choiceptr)LOCAL_end_local_copy, (choiceptr)aux_cell)) {
+#ifdef YAPOR_ERRORS
+        if ((CELL *)aux_cell < H0)
+          YAPOR_ERROR_MESSAGE("aux_cell < H0 (q_share_work)");
+        if ((ADDR)aux_cell > Yap_LocalBase)
+          YAPOR_ERROR_MESSAGE("aux_cell > LocalBase (q_share_work)");
+#endif /* YAPOR_ERRORS */
+#ifdef TABLING
+        *((CELL *) aux_cell) = TrailVal(aux_tr);
+#else
+        *((CELL *) aux_cell) = worker_p_binding(worker_p, CellPtr(aux_cell));
+#endif /* TABLING */
+      }
+#ifdef TABLING 
+    } else if (IsPairTerm(aux_cell)) {
+      /* avoid frozen segments */
+      aux_cell = (CELL) RepPair(aux_cell);
+      if ((ADDR) aux_cell >= TrailBase)
+        aux_tr = (tr_fr_ptr) aux_cell;
+#endif /* TABLING */
+#ifdef MULTI_ASSIGNMENT_VARIABLES
+    } else if (IsApplTerm(aux_cell)) {
+      CELL *cell_ptr = RepAppl(aux_cell);
+      if (((CELL *)aux_cell < Get_LOCAL_top_cp()->cp_h || 
+	   EQUAL_OR_YOUNGER_CP(Get_LOCAL_top_cp(), (choiceptr)aux_cell)) &&
+	  !Yap_lookup_ma_var(cell_ptr)) {
+	/* first time we found the variable, let's put the new value */
+#ifdef TABLING
+        *cell_ptr = TrailVal(aux_tr);
+#else
+        *cell_ptr = worker_p_binding(worker_p, cell_ptr);
+#endif /* TABLING */
+      }
+      /* skip the old value */
+      aux_tr--;
+#endif /* MULTI_ASSIGNMENT_VARIABLES */
+    }
+  }
+}
+#endif /* incremental */
+
 static void
 MoveGlobal(void)
 {
@@ -310,11 +408,16 @@ AdjustPair(register CELL t0)
 static void
 AdjustTrail(int adjusting_heap, int thread_copying)
 {
-  volatile tr_fr_ptr ptt;
+  volatile tr_fr_ptr ptt, tr_base = (tr_fr_ptr)Yap_TrailBase;
 
-  ptt = TR;
+  if (thread_copying == STACK_INCREMENTAL_COPYING) {
+    ptt =  (tr_fr_ptr)(LOCAL_end_trail_copy);
+    tr_base =  (tr_fr_ptr)(LOCAL_start_trail_copy);
+  } else {
+    ptt = TR;
+  }
   /* moving the trail is simple */
-  while (ptt != (tr_fr_ptr)Yap_TrailBase) {
+  while (ptt != tr_base) {
     register CELL reg = TrailTerm(ptt-1);
 #ifdef FROZEN_STACKS
     register CELL reg2 = TrailVal(ptt-1);
@@ -359,13 +462,19 @@ AdjustTrail(int adjusting_heap, int thread_copying)
 }
 
 static void
-AdjustLocal(void)
+AdjustLocal(int thread_copying)
 {
-  register CELL   reg, *pt;
+  register CELL   reg, *pt, *pt_bot;
 
   /* Adjusting the local */
-  pt = LCL0;
+  if (thread_copying == STACK_INCREMENTAL_COPYING) {
-  while (pt > ASP) {
+    pt =  (CELL *) (LOCAL_end_local_copy);
+    pt_bot =  (CELL *) (LOCAL_start_local_copy);
+  } else {
+    pt = LCL0;
+    pt_bot = ASP;
+  }
+  while (pt > pt_bot) {
     reg = *--pt;
     if (IsVarTerm(reg)) {
       if (IsOldLocal(reg))
@@ -407,9 +516,9 @@ AdjustGlobTerm(Term reg)
 static volatile CELL *cpt=NULL;
 
 static void
-AdjustGlobal(long sz)
+AdjustGlobal(long sz, int thread_copying)
 {
-  CELL *pt;
+  CELL *pt, *pt_max;
   ArrayEntry *al = DynamicArrays;
   StaticArrayEntry *sal = StaticArrays;
   GlobalEntry *gl = GlobalVariables;
@@ -443,8 +552,15 @@ AdjustGlobal(long sz)
    * to clean the global now that functors are just variables pointing to
    * the code 
    */
+  if (thread_copying == STACK_INCREMENTAL_COPYING) {
+    pt =  (CELL *) (LOCAL_start_global_copy);
+    pt_max =  (CELL *) (LOCAL_end_global_copy);
+  } else {
+    pt = CurrentDelayTop;
+    pt_max = (H-sz/CellSize);
+  }
   pt = CurrentDelayTop;
-  while (pt < (H-sz/CellSize)) {
+  while (pt < pt_max) {
     CELL reg;
     
     cpt = pt;
@@ -508,8 +624,8 @@ static void
 AdjustStacksAndTrail(long sz, int copying_threads)
 {
   AdjustTrail(TRUE, copying_threads);
-  AdjustLocal();
+  AdjustLocal(copying_threads);
-  AdjustGlobal(sz);
+  AdjustGlobal(sz, copying_threads);
 }
 
 void
@@ -525,8 +641,8 @@ Yap_AdjustStacksAndTrail(void)
 static void
 AdjustGrowStack(void)
 {
-  AdjustTrail(FALSE, FALSE);
+  AdjustTrail(FALSE, STACK_SHIFTING);
-  AdjustLocal();
+  AdjustLocal(STACK_SHIFTING);
 }
 
 static void
@@ -1703,7 +1819,7 @@ p_inform_heap_overflows(void)
 
 #if THREADS
 void
-Yap_CopyThreadStacks(int worker_q, int worker_p)
+Yap_CopyThreadStacks(int worker_q, int worker_p, int incremental)
 {
   Int size;
 
@@ -1711,7 +1827,7 @@ Yap_CopyThreadStacks(int worker_q, int worker_p)
   Int p_size = ThreadHandle[worker_p].ssize+ThreadHandle[worker_p].tsize;
   Int q_size = ThreadHandle[worker_q].ssize+ThreadHandle[worker_q].tsize;
   if (p_size != q_size) {
-    if (!(ThreadHandle[worker_q].stack_address = malloc(p_size*1024))) {
+    if (!(ThreadHandle[worker_q].stack_address = realloc(ThreadHandle[worker_q].stack_address,p_size*1024))) {
       exit(1);
     }
   }
@@ -1732,6 +1848,7 @@ Yap_CopyThreadStacks(int worker_q, int worker_p)
   ENV = ThreadHandle[worker_p].current_yaam_regs->ENV_;
   YENV = ThreadHandle[worker_p].current_yaam_regs->YENV_;
   ASP = ThreadHandle[worker_p].current_yaam_regs->ASP_;
+  TR = ThreadHandle[worker_p].current_yaam_regs->TR_;
   if (ASP > CellPtr(B))
     ASP = CellPtr(B);
   LCL0 = ThreadHandle[worker_p].current_yaam_regs->LCL0_;
@@ -1739,16 +1856,33 @@ Yap_CopyThreadStacks(int worker_q, int worker_p)
   Yap_REGS.CUT_C_TOP = ThreadHandle[worker_p].current_yaam_regs->CUT_C_TOP;
 #endif
   DelayedVars = ThreadHandle[worker_p].current_yaam_regs->DelayedVars_;
-  TR = ThreadHandle[worker_p].current_yaam_regs->TR_;
   CurrentDelayTop = (CELL *)DelayTop();
   DynamicArrays = NULL;
   StaticArrays = NULL;
   GlobalVariables = NULL;
   SetHeapRegs(TRUE);
-  CopyLocalAndTrail();
+  if (incremental) {
-  MoveGlobal();
+    IncrementalCopyStacksFromWorker();
-  AdjustStacksAndTrail(0, TRUE);
+    LOCAL_start_global_copy = 
-  AdjustRegs(MaxTemps);
+      (CELL)PtoGloAdjust((CELL *)LOCAL_start_global_copy);
+    LOCAL_end_global_copy = 
+      (CELL)PtoGloAdjust((CELL *)LOCAL_end_global_copy);
+    LOCAL_start_local_copy = 
+      (CELL)PtoLocAdjust((CELL *)LOCAL_start_local_copy);
+    LOCAL_end_local_copy = 
+      (CELL)PtoLocAdjust((CELL *)LOCAL_end_local_copy);
+    LOCAL_start_trail_copy = 
+      (CELL)PtoTRAdjust((CELL *)LOCAL_start_trail_copy);
+    LOCAL_end_trail_copy = 
+      (CELL)PtoTRAdjust((CELL *)LOCAL_end_trail_copy);
+    AdjustStacksAndTrail(0, STACK_INCREMENTAL_COPYING);
+    RestoreTrail(worker_p);
+    TR = (tr_fr_ptr) LOCAL_end_trail_copy;
+  } else {
+    CopyLocalAndTrail();
+    MoveGlobal();
+    AdjustStacksAndTrail(0, STACK_COPYING);
+  }
 }
 #endif
 

H/Yapproto.h

@@ -206,7 +206,7 @@ int     STD_PROTO(Yap_growtrail,     (long, int));
 int     STD_PROTO(Yap_growglobal,    (CELL **));
 CELL  **STD_PROTO(Yap_shift_visit,   (CELL **, CELL ***));
 #ifdef THREADS
-void   STD_PROTO(Yap_CopyThreadStacks, (int, int));
+void   STD_PROTO(Yap_CopyThreadStacks, (int, int, int));
 #endif
 
 /* heapgc.c */

OPTYap/or.threadengine.c

@@ -28,6 +28,14 @@
 #endif /* TABLING */
 
 
+#define INCREMENTAL_COPYING 1
+#define COMPUTE_SEGMENTS_TO_COPY_TO(Q)                                   \
+        REMOTE_start_global_copy(Q) = (CELL) (REMOTE_top_cp(Q)->cp_h);   \
+        REMOTE_end_global_copy(Q)   = (CELL) (B->cp_h);                  \
+        REMOTE_start_local_copy(Q)  = (CELL) (B);                        \
+        REMOTE_end_local_copy(Q)    = (CELL) (REMOTE_top_cp(Q));         \
+        REMOTE_start_trail_copy(Q)  = (CELL) (REMOTE_top_cp(Q)->cp_tr);  \
+        REMOTE_end_trail_copy(Q)    = (CELL) (TR)
 
 /* ------------------------------------- **
 **      Local functions declaration      **
@@ -51,9 +59,21 @@ void make_root_choice_point(void) {
     Set_LOCAL_top_cp(B);
     Set_GLOBAL_root_cp(B);
   } else {
+    choiceptr imageB;
+
     Set_LOCAL_top_cp(Get_GLOBAL_root_cp());
     B = Get_GLOBAL_root_cp();
-    B->cp_tr = TR = ((choiceptr) (worker_offset(0) + (CELL)(B)))->cp_tr;
+    /*
+      this is tricky, we need to get the B from some other stack
+      and convert back to our own stack;
+     */
+    OldLCL0 = LCL0;
+    LCL0 = ThreadHandle[0].current_yaam_regs->LCL0_;
+    imageB = Get_GLOBAL_root_cp();
+    /* we know B */
+    B->cp_tr = TR = 
+      (tr_fr_ptr)((CELL)(imageB->cp_tr)+((CELL)OldLCL0-(CELL)LCL0));
+    LCL0 = OldLCL0;
   }
   B->cp_h = H0;
   B->cp_ap = GETWORK;
@@ -98,6 +118,7 @@ int p_share_work(void) {
     return TRUE;
   }
   /* sharing request accepted */
+  COMPUTE_SEGMENTS_TO_COPY_TO(worker_q);
   REMOTE_q_fase_signal(worker_q) = Q_idle;
   REMOTE_p_fase_signal(worker_q) = P_idle;
 #ifndef TABLING
@@ -109,13 +130,13 @@ int p_share_work(void) {
   share_private_nodes(worker_q);
   REMOTE_reply_signal(worker_q) = nodes_shared;
   while (LOCAL_reply_signal == sharing);
+  while (REMOTE_reply_signal(worker_q) != worker_ready);
   LOCAL_share_request = MAX_WORKERS;
   PUT_IN_REQUESTABLE(worker_id);
 
   return TRUE;
 }
 
-
 int q_share_work(int worker_p) {
   LOCK_OR_FRAME(LOCAL_top_or_fr);
   if (Get_REMOTE_prune_request(worker_p)) {
@@ -164,7 +185,12 @@ int q_share_work(int worker_p) {
   }
   while (LOCAL_reply_signal == sharing);
 
-  Yap_CopyThreadStacks(worker_id, worker_p);
+#if INCREMENTAL_COPYING
+  Yap_CopyThreadStacks(worker_id, worker_p, TRUE);
+#else
+  Yap_CopyThreadStacks(worker_id, worker_p, FALSE);
+#endif
+
 
   /* update registers and return */
 #ifndef TABLING

packages/jpl

@@ -1 +1 @@
-Subproject commit d661852f76fe24441d983ef6f4e60ba90cfe17c4
+Subproject commit 88983bfdf74cfd89cd509fa2dd8060f2f9761917