diff --git a/C/amasm.c b/C/amasm.c index f40b1d4e0..9062f2747 100644 --- a/C/amasm.c +++ b/C/amasm.c @@ -11,8 +11,13 @@ * File: amasm.c * * comments: abstract machine assembler * * * -* Last rev: $Date: 2006-10-11 14:53:57 $ * +* Last rev: $Date: 2006-11-06 18:35:03 $ * * $Log: not supported by cvs2svn $ +* Revision 1.90 2006/10/11 14:53:57 vsc +* fix memory leak +* fix overflow handling +* VS: ---------------------------------------------------------------------- +* * Revision 1.89 2006/10/10 14:08:16 vsc * small fixes on threaded implementation. * @@ -1483,9 +1488,15 @@ a_4sw(op_numbers opcode, yamop *code_p, int pass_no, struct intermediates *cip) code_p->u.ollll.l3 = emit_ilabel(seq_ptr[2], cip); code_p->u.ollll.l4 = emit_ilabel(seq_ptr[3], cip); if (cip->CurrentPred->PredFlags & LogUpdatePredFlag) { - Yap_FreeCodeSpace((char *)ClauseCodeToLogUpdIndex(ars)); + LogUpdIndex *icl = ClauseCodeToLogUpdIndex(ars); + + Yap_LUIndexSpace_Tree -= icl->ClSize; + Yap_FreeCodeSpace((char *)icl); } else { - Yap_FreeCodeSpace((char *)ClauseCodeToStaticIndex(ars)); + StaticIndex *icl = ClauseCodeToStaticIndex(ars); + + Yap_IndexSpace_Tree -= icl->ClSize; + Yap_FreeCodeSpace((char *)icl); } } GONEXT(ollll); @@ -1690,6 +1701,7 @@ a_try(op_numbers opcode, CELL lab, CELL opr, int nofalts, int hascut, yamop *cod save_machine_regs(); longjmp(cip->CompilerBotch,2); } + Yap_LUIndexSpace_CP += size; #ifdef DEBUG Yap_NewCps++; Yap_LiveCps++; @@ -3254,9 +3266,11 @@ do_pass(int pass_no, yamop **entry_codep, int assembling, int *clause_has_blobsp a_fetch_vv(&cmp_info, pass_no, cip); break; case fetch_args_vc_op: + case fetch_args_vi_op: a_fetch_vc(&cmp_info, pass_no, cip); break; case fetch_args_cv_op: + case fetch_args_iv_op: a_fetch_cv(&cmp_info, pass_no, cip); break; case f_val_op: @@ -3332,7 +3346,7 @@ do_pass(int pass_no, yamop **entry_codep, int assembling, int *clause_has_blobsp static DBTerm * -fetch_clause_space(Term* tp, UInt size, struct intermediates *cip) +fetch_clause_space(Term* tp, UInt size, struct intermediates *cip, UInt *osizep) { CELL *h0 = H; DBTerm *x; @@ -3340,7 +3354,7 @@ fetch_clause_space(Term* tp, UInt size, struct intermediates *cip) /* This stuff should be just about fetching the space from the data-base, unfortunately we have to do all sorts of error handling :-( */ H = (CELL *)cip->freep; - while ((x = Yap_StoreTermInDBPlusExtraSpace(*tp, size)) == NULL) { + while ((x = Yap_StoreTermInDBPlusExtraSpace(*tp, size, osizep)) == NULL) { H = h0; switch (Yap_Error_TYPE) { @@ -3412,13 +3426,14 @@ Yap_assemble(int mode, Term t, PredEntry *ap, int is_fact, struct intermediates !is_fact) { DBTerm *x; LogUpdClause *cl; + UInt osize; - if(!(x = fetch_clause_space(&t,size,cip))){ + if(!(x = fetch_clause_space(&t,size,cip,&osize))){ return NULL; } cl = (LogUpdClause *)((CODEADDR)x-(UInt)size); - cl->ClSize += sizeof(DBTerm) + sizeof(CELL)*x->NOfCells; cl->ClSource = x; + cl->ClSize = osize; cip->code_addr = (yamop *)cl; } else if (mode == ASSEMBLING_CLAUSE && (ap->PredFlags & SourcePredFlag || @@ -3426,15 +3441,17 @@ Yap_assemble(int mode, Term t, PredEntry *ap, int is_fact, struct intermediates !is_fact) { DBTerm *x; StaticClause *cl; - if(!(x = fetch_clause_space(&t,size,cip))) { + UInt osize; + + if(!(x = fetch_clause_space(&t,size,cip,&osize))) { return NULL; } cl = (StaticClause *)((CODEADDR)x-(UInt)size); cip->code_addr = (yamop *)cl; code_p = do_pass(1, &entry_code, mode, &clause_has_blobs, cip, size); /* make sure we copy after second pass */ - cl->ClSize += sizeof(DBTerm) + sizeof(CELL)*x->NOfCells; cl->usc.ClSource = x; + cl->ClSize = osize; ProfEnd=code_p; return entry_code; } else { @@ -3446,6 +3463,17 @@ Yap_assemble(int mode, Term t, PredEntry *ap, int is_fact, struct intermediates return NULL; } } + if (mode == ASSEMBLING_CLAUSE) { + if (ap->PredFlags & LogUpdatePredFlag) { + Yap_LUClauseSpace += size; + } else + Yap_ClauseSpace += size; + } else { + if (ap->PredFlags & LogUpdatePredFlag) { + Yap_LUIndexSpace_Tree += size; + } else + Yap_IndexSpace_Tree += size; + } } code_p = do_pass(1, &entry_code, mode, &clause_has_blobs, cip, size); ProfEnd=code_p; diff --git a/C/cdmgr.c b/C/cdmgr.c index d174b1fdb..9127e39de 100644 --- a/C/cdmgr.c +++ b/C/cdmgr.c @@ -11,8 +11,11 @@ * File: cdmgr.c * * comments: Code manager * * * -* Last rev: $Date: 2006-10-16 17:12:48 $,$Author: vsc $ * +* Last rev: $Date: 2006-11-06 18:35:03 $,$Author: vsc $ * * $Log: not supported by cvs2svn $ +* Revision 1.196 2006/10/16 17:12:48 vsc +* fixes for threaded version. +* * Revision 1.195 2006/10/11 17:24:36 vsc * make sure we only follow pointers *before* we removed the respective code block, * ie don't kill the child before checking pointers from parent! @@ -635,6 +638,7 @@ Yap_BuildMegaClause(PredEntry *ap) return; } } + Yap_ClauseSpace += required; /* cool, it's our turn to do the conversion */ mcl->ClFlags = MegaMask | has_blobs; mcl->ClSize = sz*ap->cs.p_code.NOfClauses; @@ -664,6 +668,7 @@ Yap_BuildMegaClause(PredEntry *ap) ncl = cl->ClNext; Yap_InformOfRemoval((CODEADDR)cl); + Yap_ClauseSpace -= cl->ClSize; Yap_FreeCodeSpace((ADDR)cl); if (curcl->ClCode == ap->cs.p_code.LastClause) break; @@ -696,6 +701,7 @@ split_megaclause(PredEntry *ap) StaticClause *cl = start; start = cl->ClNext; Yap_InformOfRemoval((CODEADDR)cl); + Yap_ClauseSpace -= cl->ClSize; Yap_FreeCodeSpace((char *)cl); } if (ap->ArityOfPE) { @@ -707,6 +713,7 @@ split_megaclause(PredEntry *ap) return; } } + Yap_ClauseSpace += sizeof(StaticClause)+mcl->ClItemSize; new->ClFlags = FactMask; new->ClSize = mcl->ClItemSize; new->usc.ClPred = ap; @@ -878,6 +885,11 @@ release_wcls(yamop *cop, OPCODE ecs) Yap_expand_clauses_sz -= (UInt)(NEXTOP((yamop *)NULL,sp)+cop->u.sp.s1*sizeof(yamop *)); #endif Yap_InformOfRemoval((CODEADDR)cop); + if (cop->u.sp.p->PredFlags & LogUpdatePredFlag) { + Yap_LUIndexSpace_EXT -= (UInt)NEXTOP((yamop *)NULL,sp)+cop->u.sp.s1*sizeof(yamop *); + } else { + Yap_IndexSpace_EXT -= (UInt)NEXTOP((yamop *)NULL,sp)+cop->u.sp.s1*sizeof(yamop *); + } Yap_FreeCodeSpace((char *)cop); } } @@ -944,6 +956,7 @@ cleanup_dangling_indices(yamop *ipc, yamop *beg, yamop *end, yamop *suspend_code yamop *oipc = ipc; decrease_ref_counter(ipc->u.lld.d->ClCode, beg, end, suspend_code); ipc = ipc->u.lld.n; + Yap_LUIndexSpace_CP -= (UInt)NEXTOP((yamop *)NULL,lld); Yap_FreeCodeSpace((ADDR)oipc); #ifdef DEBUG Yap_DirtyCps--; @@ -960,6 +973,7 @@ cleanup_dangling_indices(yamop *ipc, yamop *beg, yamop *end, yamop *suspend_code Yap_FreedCps++; #endif decrease_ref_counter(ipc->u.lld.d->ClCode, beg, end, suspend_code); + Yap_LUIndexSpace_CP -= (UInt)NEXTOP((yamop *)NULL,lld); Yap_FreeCodeSpace((ADDR)ipc); end = ipc; return; @@ -1082,6 +1096,10 @@ kill_static_child_indxs(StaticIndex *indx, int in_use) UNLOCK(DeadStaticIndicesLock); } else { Yap_InformOfRemoval((CODEADDR)indx); + if (indx->ClFlags & SwitchTableMask) + Yap_IndexSpace_SW -= indx->ClSize; + else + Yap_IndexSpace_Tree -= indx->ClSize; Yap_FreeCodeSpace((char *)indx); } } @@ -1143,6 +1161,11 @@ kill_off_lu_block(LogUpdIndex *c, LogUpdIndex *parent, PredEntry *ap) } } Yap_InformOfRemoval((CODEADDR)c); + if (c->ClFlags & SwitchTableMask) + Yap_LUIndexSpace_SW -= c->ClSize; + else { + Yap_LUIndexSpace_Tree -= c->ClSize; + } Yap_FreeCodeSpace((char *)c); } @@ -1348,6 +1371,7 @@ retract_all(PredEntry *p, int in_use) UNLOCK(DeadMegaClausesLock); } else { Yap_InformOfRemoval((CODEADDR)cl); + Yap_ClauseSpace -= cl->ClSize; Yap_FreeCodeSpace((char *)cl); } /* make sure this is not a MegaClause */ @@ -1366,6 +1390,7 @@ retract_all(PredEntry *p, int in_use) UNLOCK(DeadStaticClausesLock); } else { Yap_InformOfRemoval((CODEADDR)cl); + Yap_ClauseSpace -= cl->ClSize; Yap_FreeCodeSpace((char *)cl); } p->cs.p_code.NOfClauses--; @@ -1479,6 +1504,7 @@ add_first_dynamic(PredEntry *p, yamop *cp, int spy_flag) Yap_Error(OUT_OF_HEAP_ERROR,TermNil,"Heap crashed against Stacks"); return; } + Yap_ClauseSpace += (Int)NEXTOP(NEXTOP(NEXTOP(ncp,ld),e),l); /* skip the first entry, this contains the back link and will always be empty for this entry */ ncp = (yamop *)(((CELL *)ncp)+1); @@ -2070,6 +2096,7 @@ Yap_EraseStaticClause(StaticClause *cl, Term mod) { UNLOCK(DeadStaticClausesLock); } else { Yap_InformOfRemoval((CODEADDR)cl); + Yap_ClauseSpace -= cl->ClSize; Yap_FreeCodeSpace((char *)cl); } if (ap->cs.p_code.NOfClauses == 0) { @@ -4575,18 +4602,24 @@ p_clean_up_dead_clauses(void) { while (DeadStaticClauses != NULL) { char *pt = (char *)DeadStaticClauses; + Yap_ClauseSpace -= DeadStaticClauses->ClSize; DeadStaticClauses = DeadStaticClauses->ClNext; Yap_InformOfRemoval((CODEADDR)pt); Yap_FreeCodeSpace(pt); } while (DeadStaticIndices != NULL) { char *pt = (char *)DeadStaticIndices; + if (DeadStaticIndices->ClFlags & SwitchTableMask) + Yap_IndexSpace_SW -= DeadStaticIndices->ClSize; + else + Yap_IndexSpace_Tree -= DeadStaticIndices->ClSize; DeadStaticIndices = DeadStaticIndices->SiblingIndex; Yap_InformOfRemoval((CODEADDR)pt); Yap_FreeCodeSpace(pt); } while (DeadMegaClauses != NULL) { char *pt = (char *)DeadMegaClauses; + Yap_ClauseSpace -= DeadMegaClauses->ClSize; DeadMegaClauses = DeadMegaClauses->ClNext; Yap_InformOfRemoval((CODEADDR)pt); Yap_FreeCodeSpace(pt); diff --git a/C/compiler.c b/C/compiler.c index 9c69d5ec5..062675e5b 100644 --- a/C/compiler.c +++ b/C/compiler.c @@ -11,8 +11,12 @@ * File: compiler.c * * comments: Clause compiler * * * -* Last rev: $Date: 2006-10-11 15:08:03 $,$Author: vsc $ * +* Last rev: $Date: 2006-11-06 18:35:03 $,$Author: vsc $ * * $Log: not supported by cvs2svn $ +* Revision 1.81 2006/10/11 15:08:03 vsc +* fix bb entries +* comment development code for timestamp overflow. +* * Revision 1.80 2006/09/20 20:03:51 vsc * improve indexing on floats * fix sending large lists to DB @@ -894,7 +898,7 @@ c_bifun(Int Op, Term t1, Term t2, Term t3, int mod, compiler_struct *cglobs) /* first temp */ Int v1 = --cglobs->tmpreg; - Yap_emit(fetch_args_vc_op, IntegerOfTerm(t2), Zero, &cglobs->cint); + Yap_emit(fetch_args_vi_op, IntegerOfTerm(t2), 0L, &cglobs->cint); /* these should be the arguments */ c_var(t1, v1, 0, 0, cglobs); /* now we know where the arguments are */ @@ -1130,7 +1134,7 @@ c_bifun(Int Op, Term t1, Term t2, Term t3, int mod, compiler_struct *cglobs) } else if (IsIntegerTerm(t1)) { /* first temp */ Int v1 = --cglobs->tmpreg; - Yap_emit(fetch_args_cv_op, IntegerOfTerm(t1), Zero, &cglobs->cint); + Yap_emit(fetch_args_iv_op, IntegerOfTerm(t1), 0L, &cglobs->cint); /* these should be the arguments */ c_var(t2, v1, 0, 0, cglobs); /* now we know where the arguments are */ @@ -1217,7 +1221,7 @@ c_functor(Term Goal, int mod, compiler_struct *cglobs) } else if (IsVarTerm(t2) && IsNewVar(t2) && IsVarTerm(t3) && IsNewVar(t3)) { Int v1 = --cglobs->tmpreg; - Yap_emit(fetch_args_vc_op, Zero, Zero, &cglobs->cint); + Yap_emit(fetch_args_vi_op, Zero, Zero, &cglobs->cint); c_var(t1, v1, 0, 0, cglobs); c_var(t2,f_flag,(unsigned int)_functor, 0, cglobs); c_var(t3,f_flag,(unsigned int)_functor, 0, cglobs); @@ -2698,6 +2702,8 @@ c_layout(compiler_struct *cglobs) break; case fetch_args_cv_op: case fetch_args_vc_op: + case fetch_args_iv_op: + case fetch_args_vi_op: rn_to_kill[1]=rn_to_kill[0]=0; if (cglobs->cint.cpc->nextInst && cglobs->cint.cpc->nextInst->op == put_val_op && diff --git a/C/dbase.c b/C/dbase.c index b8b1b6fd9..4dc0936e7 100644 --- a/C/dbase.c +++ b/C/dbase.c @@ -157,6 +157,7 @@ typedef struct db_globs { SFKeep *SFAr, *TopSF; /* Where are we putting our SFunctors */ #endif DBRef found_one; /* Place where we started recording */ + UInt sz; /* total size */ } dbglobs; static dbglobs *s_dbg; @@ -322,6 +323,7 @@ static void create_hash_table(DBProp p, Int hint) { hint <<= 1; /* clean up the table */ pt = tbl = (hash_db_entry *)AllocDBSpace(hint*sizeof(hash_db_entry)); + Yap_LUClauseSpace += hint*sizeof(hash_db_entry); for (i=0; i< hint; i++) { pt->key = NULL; pt++; @@ -1219,7 +1221,7 @@ generate_dberror_msg(int errnumb, UInt sz, char *msg) } static DBRef -CreateDBWithDBRef(Term Tm, DBProp p) +CreateDBWithDBRef(Term Tm, DBProp p, struct db_globs *dbg) { DBRef pp, dbr = DBRefOfTerm(Tm); DBTerm *ppt; @@ -1229,12 +1231,15 @@ CreateDBWithDBRef(Term Tm, DBProp p) if (ppt == NULL) { return generate_dberror_msg(OUT_OF_HEAP_ERROR, TermNil, "could not allocate space"); } + dbg->sz = sizeof(DBTerm)+2*sizeof(CELL); + Yap_LUClauseSpace += sizeof(DBTerm)+2*sizeof(CELL); pp = (DBRef)ppt; } else { pp = AllocDBSpace(DBLength(2*sizeof(DBRef))); if (pp == NULL) { return generate_dberror_msg(OUT_OF_HEAP_ERROR, 0, "could not allocate space"); } + Yap_LUClauseSpace += DBLength(2*sizeof(DBRef)); pp->id = FunctorDBRef; pp->Flags = DBNoVars|DBComplex|DBWithRefs; INIT_LOCK(pp->lock); @@ -1259,7 +1264,7 @@ CreateDBWithDBRef(Term Tm, DBProp p) } static DBTerm * -CreateDBTermForAtom(Term Tm, UInt extra_size) { +CreateDBTermForAtom(Term Tm, UInt extra_size, struct db_globs *dbg) { DBTerm *ppt; ADDR ptr; @@ -1267,6 +1272,8 @@ CreateDBTermForAtom(Term Tm, UInt extra_size) { if (ptr == NULL) { return (DBTerm *)generate_dberror_msg(OUT_OF_HEAP_ERROR, 0, "could not allocate space"); } + Yap_LUClauseSpace += extra_size+sizeof(DBTerm); + dbg->sz = extra_size+sizeof(DBTerm); ppt = (DBTerm *)(ptr+extra_size); ppt->NOfCells = 0; ppt->DBRefs = NULL; @@ -1279,7 +1286,7 @@ CreateDBTermForAtom(Term Tm, UInt extra_size) { } static DBTerm * -CreateDBTermForVar(UInt extra_size) +CreateDBTermForVar(UInt extra_size, struct db_globs *dbg) { DBTerm *ppt; ADDR ptr; @@ -1288,6 +1295,8 @@ CreateDBTermForVar(UInt extra_size) if (ptr == NULL) { return (DBTerm *)generate_dberror_msg(OUT_OF_HEAP_ERROR, 0, "could not allocate space"); } + Yap_LUClauseSpace += extra_size+sizeof(DBTerm); + dbg->sz = extra_size+sizeof(DBTerm); ppt = (DBTerm *)(ptr+extra_size); ppt->NOfCells = 0; ppt->DBRefs = NULL; @@ -1311,6 +1320,8 @@ CreateDBRefForAtom(Term Tm, DBProp p, int InFlag, struct db_globs *dbg) { if (pp == NIL) { return generate_dberror_msg(OUT_OF_HEAP_ERROR, 0, "could not allocate space"); } + Yap_LUClauseSpace += DBLength(NIL); + dbg->sz = DBLength(NIL); pp->id = FunctorDBRef; INIT_LOCK(pp->lock); INIT_DBREF_COUNT(pp); @@ -1335,6 +1346,8 @@ CreateDBRefForVar(Term Tm, DBProp p, int InFlag, struct db_globs *dbg) { if (pp == NULL) { return generate_dberror_msg(OUT_OF_HEAP_ERROR, 0, "could not allocate space"); } + Yap_LUClauseSpace += DBLength(NULL); + dbg->sz = DBLength(NULL); pp->id = FunctorDBRef; pp->Flags = DBVar; pp->DBT.Entry = (CELL) Tm; @@ -1367,14 +1380,14 @@ CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat, UInt extra_size, struc #ifdef COROUTINING if (!SafeIsAttachedTerm(Tm)) { #endif - DBRef out = (DBRef)CreateDBTermForVar(extra_size); + DBRef out = (DBRef)CreateDBTermForVar(extra_size, dbg); *pstat = TRUE; return out; #ifdef COROUTINING } #endif } else if (IsAtomOrIntTerm(Tm)) { - DBRef out = (DBRef)CreateDBTermForAtom(Tm, extra_size); + DBRef out = (DBRef)CreateDBTermForAtom(Tm, extra_size, dbg); *pstat = FALSE; return out; } @@ -1465,7 +1478,7 @@ CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat, UInt extra_size, struc break; case (CELL)FunctorDBRef: Yap_ReleasePreAllocCodeSpace((ADDR)pp0); - return CreateDBWithDBRef(Tm, p); + return CreateDBWithDBRef(Tm, p, dbg); #ifdef USE_GMP case (CELL)FunctorBigInt: ntp = copy_big_int(ntp0, RepAppl(Tm)); @@ -1547,6 +1560,8 @@ CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat, UInt extra_size, struc Yap_ReleasePreAllocCodeSpace((ADDR)pp0); return generate_dberror_msg(OUT_OF_HEAP_ERROR, (UInt)DBLength(CodeAbs), "heap crashed against stacks"); } + Yap_LUClauseSpace += (CELL)CodeAbs+extra_size+sizeof(DBTerm); + dbg->sz = (CELL)CodeAbs+extra_size+sizeof(DBTerm); pp = (DBRef)ppt; } else { pp = AllocDBSpace(DBLength(CodeAbs)); @@ -1554,6 +1569,8 @@ CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat, UInt extra_size, struc Yap_ReleasePreAllocCodeSpace((ADDR)pp0); return generate_dberror_msg(OUT_OF_HEAP_ERROR, (UInt)DBLength(CodeAbs), "heap crashed against stacks"); } + Yap_LUClauseSpace += DBLength(CodeAbs); + dbg->sz = DBLength(CodeAbs); pp->id = FunctorDBRef; pp->Flags = flag; INIT_LOCK(pp->lock); @@ -1806,7 +1823,7 @@ new_lu_db_entry(Term t, PredEntry *pe) cl->ClPred = pe; cl->ClExt = NULL; cl->ClPrev = cl->ClNext = NULL; - cl->ClSize = ((CODEADDR)&(x->Contents)-(CODEADDR)cl)+x->NOfCells*sizeof(CELL); + cl->ClSize = dbg.sz; /* Support for timestamps */ if (pe && pe->LastCallOfPred != LUCALL_ASSERT) { ++pe->TimeStampOfPred; @@ -2487,6 +2504,7 @@ init_int_keys(void) { p[0] = NIL; p++; } + Yap_LUClauseSpace += sizeof(Prop)*INT_KEYS_SIZE; } } @@ -2500,6 +2518,7 @@ init_int_lu_keys(void) { p[0] = NULL; p++; } + Yap_LUClauseSpace += sizeof(Prop)*INT_KEYS_SIZE; } } @@ -2507,6 +2526,7 @@ static int resize_int_keys(UInt new_size) { Prop *new; UInt i; + UInt old_size = INT_KEYS_SIZE; YAPEnterCriticalSection(); if (INT_KEYS == NULL) { @@ -2522,6 +2542,7 @@ resize_int_keys(UInt new_size) { Yap_ErrorMessage = "could not allocate space"; return(FALSE); } + Yap_LUClauseSpace += sizeof(Prop)*new_size; for (i = 0; i < new_size; i++) { new[i] = NIL; } @@ -2538,6 +2559,7 @@ resize_int_keys(UInt new_size) { } } } + Yap_LUClauseSpace -= sizeof(Prop)*old_size; Yap_FreeCodeSpace((char *)INT_KEYS); INT_KEYS = new; INT_KEYS_SIZE = new_size; @@ -3896,6 +3918,7 @@ RemoveDBEntry(DBRef entryref) entryref->n->p = entryref->p; else entryref->Parent->L0 = entryref->p; + /* Yap_LUClauseSpace -= entryref->Size; */ FreeDBSpace((char *) entryref); } @@ -4022,6 +4045,7 @@ complete_lu_erase(LogUpdClause *clau) } } Yap_InformOfRemoval((CODEADDR)clau); + Yap_LUClauseSpace -= clau->ClSize; Yap_FreeCodeSpace((char *)clau); } @@ -4156,6 +4180,7 @@ MyEraseClause(DynamicClause *clau) } } else { Yap_InformOfRemoval((CODEADDR)clau); + Yap_LUClauseSpace -= clau->ClSize; Yap_FreeCodeSpace((char *)clau); #ifdef DEBUG if (ref->NOfRefsTo) @@ -4942,13 +4967,16 @@ Yap_StoreTermInDB(Term t, int nargs) { } DBTerm * -Yap_StoreTermInDBPlusExtraSpace(Term t, UInt extra_size) { +Yap_StoreTermInDBPlusExtraSpace(Term t, UInt extra_size, UInt *sz) { int needs_vars; struct db_globs dbg; + DBTerm *o; s_dbg = &dbg; - return (DBTerm *)CreateDBStruct(t, (DBProp)NULL, - InQueue, &needs_vars, extra_size, &dbg); + o = (DBTerm *)CreateDBStruct(t, (DBProp)NULL, + InQueue, &needs_vars, extra_size, &dbg); + *sz = dbg.sz; + return o; } @@ -4964,6 +4992,7 @@ p_init_queue(void) return(FALSE); } } + /* Yap_LUClauseSpace += sizeof(db_queue); */ dbq->id = FunctorDBRef; dbq->Flags = DBClMask; dbq->FirstInQueue = dbq->LastInQueue = NULL; @@ -4995,6 +5024,7 @@ p_enqueue(void) return FALSE; } } + /* Yap_LUClauseSpace += sizeof(QueueEntry); */ t = Deref(ARG1); x->DBT = StoreTermInDB(Deref(ARG2), 2); if (x->DBT == NULL) { diff --git a/C/grow.c b/C/grow.c index eb6c89e20..f20a899a0 100644 --- a/C/grow.c +++ b/C/grow.c @@ -590,6 +590,7 @@ static_growglobal(long size, CELL **ptr, CELL *hsplit) UInt minimal_request = 0L; long size0, sz = size; char vb_msg1 = '\0', *vb_msg2; + int do_grow = TRUE; if (hsplit) { /* just a little bit of sanity checking */ @@ -598,25 +599,31 @@ static_growglobal(long size, CELL **ptr, CELL *hsplit) return FALSE; else if (hsplit == (CELL *)omax) hsplit = NULL; + if (size+H < ASP+4096) { + /* don't need to expand stacks */ + do_grow = FALSE; + } } - /* adjust to a multiple of 256) */ - Yap_PrologMode |= GrowStackMode; if (size < ((char *)H0-omax)/8) size = ((char *)H0-omax)/8; size0 = size = AdjustPageSize(size); + /* adjust to a multiple of 256) */ Yap_ErrorMessage = NULL; - if (!Yap_ExtendWorkSpace(size)) { + Yap_PrologMode |= GrowStackMode; + start_growth_time = Yap_cputime(); + if (do_grow) { + if (!Yap_ExtendWorkSpace(size)) { - Yap_ErrorMessage = NULL; - size += AdjustPageSize(((CELL)Yap_TrailTop-(CELL)Yap_GlobalBase)+MinHeapGap); minimal_request = size; - size = Yap_ExtendWorkSpaceThroughHole(size); - if (size < 0) { - Yap_ErrorMessage = "Global Stack crashed against Local Stack"; - Yap_PrologMode &= ~GrowStackMode; - return FALSE; + Yap_ErrorMessage = NULL; + size += AdjustPageSize(((CELL)Yap_TrailTop-(CELL)Yap_GlobalBase)+MinHeapGap); minimal_request = size; + size = Yap_ExtendWorkSpaceThroughHole(size); + if (size < 0) { + Yap_ErrorMessage = "Global Stack crashed against Local Stack"; + Yap_PrologMode &= ~GrowStackMode; + return FALSE; + } } } - start_growth_time = Yap_cputime(); gc_verbose = Yap_is_gc_verbose(); delay_overflows++; if (gc_verbose) { @@ -640,10 +647,18 @@ static_growglobal(long size, CELL **ptr, CELL *hsplit) #if USE_SYSTEM_MALLOC /* we always run the risk of shifting memory */ size0 = Yap_GlobalBase-old_GlobalBase; - DelayDiff = size0; - TrDiff = LDiff = GDiff = size+size0; + if (do_grow) { + DelayDiff = size0; + TrDiff = LDiff = GDiff = size+size0; + } else { + TrDiff = DelayDiff = LDiff = 0; + GDiff = size; + } #else - if (minimal_request) { + if (!do_grow) { + TrDiff = DelayDiff = LDiff = 0; + GDiff = size; + } else if (minimal_request) { DelayDiff = size-size0; TrDiff = LDiff = GDiff = size; } else { @@ -661,11 +676,13 @@ static_growglobal(long size, CELL **ptr, CELL *hsplit) XDiff = HDiff = 0; Yap_GlobalBase = old_GlobalBase; SetHeapRegs(); - MoveLocalAndTrail(); - if (hsplit) { - MoveGlobalWithHole(); - } else { - MoveExpandedGlobal(); + if (do_grow) { + MoveLocalAndTrail(); + if (hsplit) { + MoveGlobalWithHole(); + } else { + MoveExpandedGlobal(); + } } AdjustStacksAndTrail(); AdjustRegs(MaxTemps); @@ -721,9 +738,9 @@ fix_compiler_instructions(PInstr *pcpc) case save_appl_op: case save_b_op: case commit_b_op: + case fetch_args_vv_op: case fetch_args_cv_op: case fetch_args_vc_op: - case fetch_args_vv_op: pcpc->rnd1 = GlobalAdjust(pcpc->rnd1); break; case get_float_op: @@ -822,6 +839,8 @@ fix_compiler_instructions(PInstr *pcpc) case enter_lu_op: case empty_call_op: case blob_op: + case fetch_args_vi_op: + case fetch_args_iv_op: #ifdef TABLING case table_new_answer_op: case table_try_single_op: diff --git a/C/heapgc.c b/C/heapgc.c index cdd53b196..bd23a0a15 100644 --- a/C/heapgc.c +++ b/C/heapgc.c @@ -2103,6 +2103,7 @@ CleanDeadClauses(void) while (cl) { if (!ref_in_use((DBRef)cl)) { char *ocl = (char *)cl; + Yap_ClauseSpace -= cl->ClSize; cl = cl->ClNext; *cptr = cl; Yap_FreeCodeSpace(ocl); @@ -2121,6 +2122,10 @@ CleanDeadClauses(void) while (cl) { if (!ref_in_use((DBRef)cl)) { char *ocl = (char *)cl; + if (cl->ClFlags & SwitchTableMask) + Yap_IndexSpace_SW -= cl->ClSize; + else + Yap_IndexSpace_Tree -= cl->ClSize; cl = cl->SiblingIndex; *cptr = cl; Yap_FreeCodeSpace(ocl); @@ -2139,6 +2144,7 @@ CleanDeadClauses(void) while (cl) { if (!ref_in_use((DBRef)cl)) { char *ocl = (char *)cl; + Yap_ClauseSpace -= cl->ClSize; cl = cl->ClNext; *cptr = cl; Yap_FreeCodeSpace(ocl); diff --git a/C/index.c b/C/index.c index a7d0f0a72..f2080a516 100644 --- a/C/index.c +++ b/C/index.c @@ -11,8 +11,11 @@ * File: index.c * * comments: Indexing a Prolog predicate * * * -* Last rev: $Date: 2006-10-25 02:31:07 $,$Author: vsc $ * +* Last rev: $Date: 2006-11-06 18:35:04 $,$Author: vsc $ * * $Log: not supported by cvs2svn $ +* Revision 1.174 2006/10/25 02:31:07 vsc +* fix emulation of trust_logical +* * Revision 1.173 2006/10/18 13:47:31 vsc * index.c implementation of trust_logical was decrementing the wrong * cp_tr @@ -434,6 +437,11 @@ cleanup_sw_on_clauses(CELL larg, UInt sz, OPCODE ecls) #if DEBUG Yap_expand_clauses_sz -= (UInt)(NEXTOP((yamop *)NULL,sp))+xp->u.sp.s1*sizeof(yamop *); #endif + if (xp->u.sp.p->PredFlags & LogUpdatePredFlag) { + // fprintf(stderr,"VSC %p %d - %d\n",xp,(UInt)NEXTOP((yamop *)NULL,sp)+xp->u.sp.s1*sizeof(yamop *),Yap_LUIndexSpace_EXT); + Yap_LUIndexSpace_EXT -= (UInt)NEXTOP((yamop *)NULL,sp)+xp->u.sp.s1*sizeof(yamop *); + } else + Yap_IndexSpace_EXT -= (UInt)(NEXTOP((yamop *)NULL,sp))+xp->u.sp.s1*sizeof(yamop *); Yap_FreeCodeSpace((char *)xp); return nsz; } else { @@ -482,10 +490,12 @@ recover_from_failed_susp_on_cls(struct intermediates *cint, UInt sz) if (log_upd_pred) { LogUpdIndex *lcl = ClauseCodeToLogUpdIndex(cpc->rnd2); sz += sizeof(LogUpdIndex)+cases*sizeof(AtomSwiEntry); + Yap_LUIndexSpace_SW -= sizeof(LogUpdIndex)+cases*sizeof(AtomSwiEntry); Yap_FreeCodeSpace((char *)lcl); } else { StaticIndex *scl = ClauseCodeToStaticIndex(cpc->rnd2); sz += sizeof(StaticIndex)+cases*sizeof(AtomSwiEntry); + Yap_IndexSpace_SW -= sizeof(StaticIndex)+cases*sizeof(AtomSwiEntry); Yap_FreeCodeSpace((char *)scl); } } @@ -502,9 +512,11 @@ recover_from_failed_susp_on_cls(struct intermediates *cint, UInt sz) if (log_upd_pred) { LogUpdIndex *lcl = ClauseCodeToLogUpdIndex(cpc->rnd2); sz += sizeof(LogUpdIndex)+cases*sizeof(FuncSwiEntry); + Yap_LUIndexSpace_SW -= sizeof(LogUpdIndex)+cases*sizeof(FuncSwiEntry); Yap_FreeCodeSpace((char *)lcl); } else { StaticIndex *scl = ClauseCodeToStaticIndex(cpc->rnd2); + Yap_IndexSpace_SW -= sizeof(StaticIndex)+cases*sizeof(FuncSwiEntry); sz += sizeof(StaticIndex)+cases*sizeof(FuncSwiEntry); Yap_FreeCodeSpace((char *)scl); } @@ -3425,11 +3437,15 @@ static void emit_try(ClauseDef *cl, struct intermediates *cint, int var_group, int first, int clauses, int clleft, UInt nxtlbl) { PredEntry *ap = cint->CurrentPred; - yamop *clcode = cl->CurrentCode; + yamop *clcode; compiler_vm_op comp_op; - if (ap->PredFlags & TabledPredFlag) { + if (ap->PredFlags & LogUpdatePredFlag) { + clcode = cl->Code; + } else if (ap->PredFlags & TabledPredFlag) { clcode = NEXTOP(cl->Code, ld); + } else { + clcode = cl->CurrentCode; } comp_op = emit_optry(var_group, first, clauses, clleft, cint->CurrentPred); @@ -3456,6 +3472,7 @@ emit_switch_space(UInt n, UInt item_size, struct intermediates *cint) save_machine_regs(); longjmp(cint->CompilerBotch,2); } + Yap_LUIndexSpace_SW += sz; cl->ClFlags = SwitchTableMask|LogUpdMask; cl->ClSize = sz; cl->ClPred = cint->CurrentPred; @@ -3475,6 +3492,7 @@ emit_switch_space(UInt n, UInt item_size, struct intermediates *cint) save_machine_regs(); longjmp(cint->CompilerBotch,2); } + Yap_IndexSpace_SW += sz; cl->ClFlags = SwitchTableMask; cl->ClSize = sz; cl->ClPred = cint->CurrentPred; @@ -3809,6 +3827,12 @@ suspend_indexing(ClauseDef *min, ClauseDef *max, PredEntry *ap, struct intermedi save_machine_regs(); longjmp(cint->CompilerBotch, 2); } + if (ap->PredFlags & LogUpdatePredFlag) { + // fprintf(stderr,"VSC %p %d + %d\n",ncode,sz,Yap_LUIndexSpace_EXT); + Yap_LUIndexSpace_EXT += sz; + } else { + Yap_IndexSpace_EXT += sz; + } #ifdef LOW_PROF if (ProfilerOn && Yap_OffLineProfiler) { @@ -3867,6 +3891,10 @@ recover_ecls_block(yamop *ipc) #endif /* no dangling pointers for gprof */ Yap_InformOfRemoval((CODEADDR)ipc); + if (ipc->u.sp.p->PredFlags & LogUpdatePredFlag) { + Yap_LUIndexSpace_EXT -= (UInt)NEXTOP((yamop *)NULL,sp)+ipc->u.sp.s1*sizeof(yamop *); + } else + Yap_IndexSpace_EXT -= (UInt)NEXTOP((yamop *)NULL,sp)+ipc->u.sp.s1*sizeof(yamop *); Yap_FreeCodeSpace((char *)ipc); } } @@ -4416,23 +4444,18 @@ do_compound_index(ClauseDef *min0, ClauseDef* max0, Term* sreg, struct intermedi cl++; } group = (GroupDef *)top; - ngroups = groups_in(min, max, group); + ngroups = groups_in(min, max, group); if (ngroups == 1 && group->VarClauses == 0) { /* ok, we are doing a sub-argument */ - /* process groups */ - *newlabp = new_label(cint); + /* process group */ + + found_index = TRUE; + ret_lab = new_label(cint); top = (CELL *)(group+1); - newlabp = do_nonvar_group(group, (sreg == NULL ? 0L : Deref(sreg[i])), i+1, (isvt ? NULL : sreg), arity, *newlabp, cint, argno, argno == 1, (last_arg && i+1 == arity), fail_l, clleft, top); - if (newlabp == NULL) { - found_index = TRUE; + if (do_nonvar_group(group, (sreg == NULL ? 0L : Deref(sreg[i])), i+1, (isvt ? NULL : sreg), arity, *newlabp, cint, argno, argno == 1, (last_arg && i+1 == arity), fail_l, clleft, top) == NULL) { top = top0; break; } - if (sreg == NULL || !isvt) { - found_index = TRUE; - } else { - done_work |= TRUE; - } } top = top0; i++; @@ -5624,8 +5647,9 @@ expand_index(struct intermediates *cint) { lab = do_index(cls, max, cint, argno+1, fail_l, isfirstcl, clleft, top); } } - if (labp && !(lab & 1)) + if (labp && !(lab & 1)) { *labp = (yamop *)lab; /* in case we have a single clause */ + } return labp; } @@ -5722,9 +5746,17 @@ ExpandIndex(PredEntry *ap, int ExtraArgs) { } #endif if ((labp = expand_index(&cint)) == NULL) { + if (expand_clauses) { + P = FAILCODE; + recover_ecls_block(expand_clauses); + } return FAILCODE; } if (*labp == FAILCODE) { + if (expand_clauses) { + P = FAILCODE; + recover_ecls_block(expand_clauses); + } return FAILCODE; } #ifdef DEBUG @@ -5744,9 +5776,17 @@ ExpandIndex(PredEntry *ap, int ExtraArgs) { } } else { /* single case */ + if (expand_clauses) { + P = *labp; + recover_ecls_block(expand_clauses); + } return *labp; } if (indx_out == NULL) { + if (expand_clauses) { + P = FAILCODE; + recover_ecls_block(expand_clauses); + } return FAILCODE; } *labp = indx_out; @@ -5958,6 +5998,7 @@ replace_index_block(ClauseUnion *parent_block, yamop *cod, yamop *ncod, PredEntr c = c->SiblingIndex; } Yap_InformOfRemoval((CODEADDR)cl); + Yap_LUIndexSpace_SW -= cl->ClSize; Yap_FreeCodeSpace((char *)cl); } else { StaticIndex @@ -5975,6 +6016,7 @@ replace_index_block(ClauseUnion *parent_block, yamop *cod, yamop *ncod, PredEntr c->SiblingIndex = ncl; } Yap_InformOfRemoval((CODEADDR)cl); + Yap_IndexSpace_SW -= cl->ClSize; Yap_FreeCodeSpace((char *)cl); } } @@ -6154,17 +6196,18 @@ remove_clause_from_index(yamop **prevp, yamop *curp, LogUpdClause *cl) { if (curp->u.lld.d == cl) { yamop *newp = curp->u.lld.n; - *prevp = newp; newp->opc = curp->opc; + *prevp = newp; } else { - yamop *ocurp; + yamop *ocurp, *ocurp0 = curp; while (curp->u.lld.d != cl) { ocurp = curp; curp = curp->u.lld.n; } /* in case we were the last */ - ocurp->opc = curp->opc; + if (ocurp != ocurp0) + ocurp->opc = curp->opc; ocurp->u.lld.n = curp->u.lld.n; ocurp->u.lld.t.block = curp->u.lld.t.block; } @@ -6173,6 +6216,7 @@ remove_clause_from_index(yamop **prevp, yamop *curp, LogUpdClause *cl) Yap_FreedCps++; #endif clean_ref_to_clause(cl); + Yap_LUIndexSpace_CP -= (UInt)NEXTOP((yamop*)NULL,lld); Yap_FreeCodeSpace((ADDR)curp); } @@ -6219,11 +6263,13 @@ remove_dirty_clauses_from_index(yamop **prevp, yamop *curp) previouscurp->opc = endop; previouscurp->u.lld.t.block = curp->u.lld.t.block; previouscurp->u.lld.n = NULL; + Yap_LUIndexSpace_CP -= (UInt)NEXTOP((yamop*)NULL,lld); Yap_FreeCodeSpace((ADDR)curp); return; } previouscurp->u.lld.n = curp->u.lld.n; curp = curp->u.lld.n; + Yap_LUIndexSpace_CP -= (UInt)NEXTOP((yamop*)NULL,lld); Yap_FreeCodeSpace((ADDR)ocurp); } else { previouscurp = curp; @@ -6534,13 +6580,14 @@ add_try(PredEntry *ap, ClauseDef *cls, yamop *next, struct intermediates *cint) { yamop *newcp; UInt size = (UInt)NEXTOP((yamop *)NULL,lld); - LogUpdClause *lcl = ClauseCodeToLogUpdClause(cls->CurrentCode); + LogUpdClause *lcl = ClauseCodeToLogUpdClause(cls->Code); if ((newcp = (yamop *)Yap_AllocCodeSpace(size)) == NULL) { /* OOOPS, got in trouble, must do a longjmp and recover space */ save_machine_regs(); longjmp(cint->CompilerBotch,2); } + Yap_LUIndexSpace_CP += size; #ifdef DEBUG Yap_NewCps++; Yap_LiveCps++; @@ -6558,7 +6605,7 @@ add_trust(LogUpdIndex *icl, ClauseDef *cls, struct intermediates *cint) { yamop *newcp; UInt size = (UInt)NEXTOP((yamop *)NULL,lld); - LogUpdClause *lcl = ClauseCodeToLogUpdClause(cls->CurrentCode); + LogUpdClause *lcl = ClauseCodeToLogUpdClause(cls->Code); PredEntry *ap = lcl->ClPred; if ((newcp = (yamop *)Yap_AllocCodeSpace(size)) == NULL) { @@ -6566,6 +6613,7 @@ add_trust(LogUpdIndex *icl, ClauseDef *cls, struct intermediates *cint) save_machine_regs(); longjmp(cint->CompilerBotch,2); } + Yap_LUIndexSpace_CP += size; #ifdef DEBUG Yap_NewCps++; Yap_LiveCps++; diff --git a/C/init.c b/C/init.c index 3a25421d9..888a2cca6 100644 --- a/C/init.c +++ b/C/init.c @@ -485,6 +485,7 @@ Yap_InitCPred(char *Name, unsigned long int Arity, CPredicate code, int flags) /* already exists */ cl = ClauseCodeToStaticClause(pe->CodeOfPred); if ((flags | StandardPredFlag | CPredFlag) != pe->PredFlags) { + Yap_ClauseSpace -= cl->ClSize; Yap_FreeCodeSpace((ADDR)cl); cl = NULL; } @@ -505,6 +506,7 @@ Yap_InitCPred(char *Name, unsigned long int Arity, CPredicate code, int flags) return; } } else { + Yap_ClauseSpace += sz; cl->ClFlags = StaticMask; cl->ClNext = NULL; cl->ClSize = sz; @@ -567,6 +569,7 @@ Yap_InitCmpPred(char *Name, unsigned long int Arity, CmpPredicate cmp_code, int return; } } else { + Yap_ClauseSpace += sz; cl->ClFlags = StaticMask; cl->ClNext = NULL; cl->ClSize = sz; @@ -615,6 +618,7 @@ Yap_InitAsmPred(char *Name, unsigned long int Arity, int code, CPredicate def, Yap_Error(OUT_OF_HEAP_ERROR,TermNil,"No Heap Space in InitAsmPred"); return; } + Yap_ClauseSpace += (CELL)NEXTOP(NEXTOP(NEXTOP(((yamop *)p_code),sla),p),l); cl->ClFlags = StaticMask; cl->ClNext = NULL; cl->ClSize = (CELL)NEXTOP(NEXTOP(NEXTOP(((yamop *)p_code),sla),e),e); @@ -751,9 +755,11 @@ Yap_InitCPredBack(char *Name, unsigned long int Arity, cl->ClFlags = StaticMask; cl->ClNext = NULL; #ifdef CUT_C + Yap_ClauseSpace += (CELL)NEXTOP(NEXTOP(NEXTOP(NEXTOP(code,lds),lds),lds),l); cl->ClSize = (CELL)NEXTOP(NEXTOP(NEXTOP(NEXTOP(code,lds),lds),lds),e); #else + Yap_ClauseSpace += (CELL)NEXTOP(NEXTOP(NEXTOP(code,lds),lds),l); cl->ClSize = (CELL)NEXTOP(NEXTOP(NEXTOP(code,lds),lds),e); #endif @@ -1249,6 +1255,7 @@ InitCodes(void) #endif /* YAPOR */ Yap_heap_regs->db_erased_marker = (DBRef)Yap_AllocCodeSpace(sizeof(DBStruct)); + Yap_LUClauseSpace += sizeof(DBStruct); Yap_heap_regs->db_erased_marker->id = FunctorDBRef; Yap_heap_regs->db_erased_marker->Flags = ErasedMask; Yap_heap_regs->db_erased_marker->Code = NULL; @@ -1256,6 +1263,7 @@ InitCodes(void) Yap_heap_regs->db_erased_marker->Parent = NULL; Yap_heap_regs->logdb_erased_marker = (LogUpdClause *)Yap_AllocCodeSpace(sizeof(LogUpdClause)+(UInt)NEXTOP((yamop*)NULL,e)); + Yap_LUClauseSpace += sizeof(LogUpdClause)+(UInt)NEXTOP((yamop*)NULL,e); Yap_heap_regs->logdb_erased_marker->Id = FunctorDBRef; Yap_heap_regs->logdb_erased_marker->ClFlags = ErasedMask|LogUpdMask; Yap_heap_regs->logdb_erased_marker->ClSource = NULL; @@ -1329,7 +1337,15 @@ Yap_InitWorkspace(int Heap, int Stack, int Trail, int max_table_size, #else Yap_InitMemory (Trail, Heap, Stack); #endif /* YAPOR */ - + Yap_ClauseSpace = 0; + Yap_IndexSpace_Tree = 0; + Yap_IndexSpace_EXT = 0; + Yap_IndexSpace_SW = 0; + Yap_LUClauseSpace = 0; + Yap_LUIndexSpace_Tree = 0; + Yap_LUIndexSpace_CP = 0; + Yap_LUIndexSpace_EXT = 0; + Yap_LUIndexSpace_SW = 0; #if defined(YAPOR) || defined(TABLING) Yap_init_global(max_table_size, n_workers, sch_loop, delay_load); #endif /* YAPOR || TABLING */ diff --git a/C/stdpreds.c b/C/stdpreds.c index d12985ae7..d86894363 100644 --- a/C/stdpreds.c +++ b/C/stdpreds.c @@ -11,8 +11,11 @@ * File: stdpreds.c * * comments: General-purpose C implemented system predicates * * * -* Last rev: $Date: 2006-10-10 14:08:17 $,$Author: vsc $ * +* Last rev: $Date: 2006-11-06 18:35:04 $,$Author: vsc $ * * $Log: not supported by cvs2svn $ +* Revision 1.110 2006/10/10 14:08:17 vsc +* small fixes on threaded implementation. +* * Revision 1.109 2006/09/15 19:32:47 vsc * ichanges for QSAR * @@ -2510,6 +2513,7 @@ p_statistics_stacks_info(void) } + static Int p_statistics_trail_info(void) { @@ -2551,6 +2555,41 @@ p_statistics_atom_info(void) } +static Int +p_statistics_db_size(void) +{ + Term t = MkIntegerTerm(Yap_ClauseSpace); + Term tit = MkIntegerTerm(Yap_IndexSpace_Tree); + Term tis = MkIntegerTerm(Yap_IndexSpace_SW); + Term tie = MkIntegerTerm(Yap_IndexSpace_EXT); + + return + Yap_unify(t, ARG1) && + Yap_unify(tit, ARG2) && + Yap_unify(tis, ARG3) && + Yap_unify(tie, ARG4); + +} + +static Int +p_statistics_lu_db_size(void) +{ + Term t = MkIntegerTerm(Yap_LUClauseSpace); + Term tit = MkIntegerTerm(Yap_LUIndexSpace_Tree); + Term tic = MkIntegerTerm(Yap_LUIndexSpace_CP); + Term tix = MkIntegerTerm(Yap_LUIndexSpace_EXT); + Term tis = MkIntegerTerm(Yap_LUIndexSpace_SW); + + return + Yap_unify(t, ARG1) && + Yap_unify(tit, ARG2) && + Yap_unify(tic, ARG3) && + Yap_unify(tix, ARG4) && + Yap_unify(tis, ARG5); +} + + + static Term mk_argc_list(void) { @@ -3030,6 +3069,8 @@ Yap_InitCPreds(void) Yap_InitCPred("$statistics_stacks_info", 3, p_statistics_stacks_info, SafePredFlag|SyncPredFlag|HiddenPredFlag); Yap_InitCPred("$statistics_trail_info", 2, p_statistics_trail_info, SafePredFlag|SyncPredFlag|HiddenPredFlag); Yap_InitCPred("$statistics_atom_info", 2, p_statistics_atom_info, SafePredFlag|SyncPredFlag|HiddenPredFlag); + Yap_InitCPred("$statistics_db_size", 4, p_statistics_db_size, SafePredFlag|SyncPredFlag|HiddenPredFlag); + Yap_InitCPred("$statistics_lu_db_size", 5, p_statistics_lu_db_size, SafePredFlag|SyncPredFlag|HiddenPredFlag); Yap_InitCPred("$argv", 1, p_argv, SafePredFlag|HiddenPredFlag); Yap_InitCPred("$runtime", 2, p_runtime, SafePredFlag|SyncPredFlag|HiddenPredFlag); Yap_InitCPred("$cputime", 2, p_cputime, SafePredFlag|SyncPredFlag|HiddenPredFlag); diff --git a/C/tracer.c b/C/tracer.c index 0c2c9c9bf..765cd4553 100644 --- a/C/tracer.c +++ b/C/tracer.c @@ -161,6 +161,8 @@ low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args) LOCK(Yap_heap_regs->low_level_trace_lock); sc = Yap_heap_regs; vsc_count++; + if (vsc_count < 59000) + return; #ifdef COMMENTED if (worker_id != 04 || worker_id != 03) return; // if (vsc_count == 218280) diff --git a/H/Heap.h b/H/Heap.h index de15fde45..43c0dfadb 100644 --- a/H/Heap.h +++ b/H/Heap.h @@ -10,7 +10,7 @@ * File: Heap.h * * mods: * * comments: Heap Init Structure * -* version: $Id: Heap.h,v 1.107 2006-10-11 14:53:57 vsc Exp $ * +* version: $Id: Heap.h,v 1.108 2006-11-06 18:35:05 vsc Exp $ * *************************************************************************/ /* information that can be stored in Code Space */ @@ -197,6 +197,9 @@ typedef struct various_codes { special_functors funcs; UInt hole_size; struct malloc_state *av_; + + UInt clause_space, index_space_Tree, index_space_EXT, index_space_SW; + UInt lu_clause_space, lu_index_space_Tree, lu_index_space_CP, lu_index_space_EXT, lu_index_space_SW; #if USE_DL_MALLOC struct memory_hole memory_holes[MAX_DLMALLOC_HOLES]; UInt nof_memory_holes; @@ -554,6 +557,15 @@ struct various_codes *Yap_heap_regs; #define Yap_HoleSize Yap_heap_regs->hole_size #define Yap_av Yap_heap_regs->av_ +#define Yap_ClauseSpace Yap_heap_regs->clause_space +#define Yap_IndexSpace_Tree Yap_heap_regs->index_space_Tree +#define Yap_IndexSpace_EXT Yap_heap_regs->index_space_EXT +#define Yap_IndexSpace_SW Yap_heap_regs->index_space_SW +#define Yap_LUClauseSpace Yap_heap_regs->lu_clause_space +#define Yap_LUIndexSpace_Tree Yap_heap_regs->lu_index_space_Tree +#define Yap_LUIndexSpace_CP Yap_heap_regs->lu_index_space_CP +#define Yap_LUIndexSpace_EXT Yap_heap_regs->lu_index_space_EXT +#define Yap_LUIndexSpace_SW Yap_heap_regs->lu_index_space_SW #define Yap_MemoryHoles Yap_heap_regs->memory_holes #define Yap_NOfMemoryHoles Yap_heap_regs->nof_memory_holes #if USE_DL_MALLOC || (USE_SYSTEM_MALLOC && HAVE_MALLINFO) diff --git a/H/Yatom.h b/H/Yatom.h index 65cc7287f..2da2dfc0d 100644 --- a/H/Yatom.h +++ b/H/Yatom.h @@ -1197,7 +1197,7 @@ int STD_PROTO (Yap_RemoveIndexation, (PredEntry *)); /* dbase.c */ void STD_PROTO (Yap_ErDBE, (DBRef)); DBTerm *STD_PROTO (Yap_StoreTermInDB, (Term, int)); -DBTerm *STD_PROTO (Yap_StoreTermInDBPlusExtraSpace, (Term, UInt)); +DBTerm *STD_PROTO (Yap_StoreTermInDBPlusExtraSpace, (Term, UInt, UInt *)); Term STD_PROTO (Yap_FetchTermFromDB, (DBTerm *)); void STD_PROTO (Yap_ReleaseTermFromDB, (DBTerm *)); diff --git a/H/compile.h b/H/compile.h index 62cc74e0b..ae655f7f7 100644 --- a/H/compile.h +++ b/H/compile.h @@ -124,6 +124,8 @@ typedef enum compiler_op { fetch_args_vv_op, fetch_args_cv_op, fetch_args_vc_op, + fetch_args_iv_op, + fetch_args_vi_op, f_var_op, f_val_op, enter_profiling_op, diff --git a/changes-5.1.html b/changes-5.1.html index ceaac5273..8433b614a 100644 --- a/changes-5.1.html +++ b/changes-5.1.html @@ -16,6 +16,10 @@

Yap-5.1.2: