diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix profiling support.

Browse Source
This commit is contained in:
Vítor Santos Costa 2012-03-09 11:46:34 +00:00
parent 44737a5d0f
commit 36acb5f897
29 changed files with 1887 additions and 1982 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
C/absmi.c
View File

@ -2436,6 +2436,7 @@ Yap_absmi(int inp)
ENDBOp(); ENDBOp();
NoStackExecute: NoStackExecute:
CHECK_ALARM(JMPNext());
SREG = (CELL *) PREG->u.pp.p; SREG = (CELL *) PREG->u.pp.p;
PP = PREG->u.pp.p0; PP = PREG->u.pp.p0;
if (LOCAL_ActiveSignals & YAP_CDOVF_SIGNAL) { if (LOCAL_ActiveSignals & YAP_CDOVF_SIGNAL) {
@ -2578,6 +2579,7 @@ Yap_absmi(int inp)
ENDBOp(); ENDBOp();
NoStackCall: NoStackCall:
CHECK_ALARM(JMPNext());
PP = PREG->u.Osbpp.p0; PP = PREG->u.Osbpp.p0;
/* on X86 machines S will not actually be holding the pointer to pred */ /* on X86 machines S will not actually be holding the pointer to pred */
if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) { if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) {
@ -2615,6 +2617,7 @@ Yap_absmi(int inp)
so I don't need to redo it. so I don't need to redo it.
*/ */
NoStackDeallocate: NoStackDeallocate:
CHECK_ALARM(JMPNext());
{ {
CELL cut_b = LCL0-(CELL *)(SREG[E_CB]); CELL cut_b = LCL0-(CELL *)(SREG[E_CB]);
@ -2669,6 +2672,7 @@ Yap_absmi(int inp)
/* This is easier: I know there is an environment so I cannot do allocate */ /* This is easier: I know there is an environment so I cannot do allocate */
NoStackCut: NoStackCut:
CHECK_ALARM(goto do_cut);
/* find something to fool S */ /* find something to fool S */
if (!LOCAL_ActiveSignals || LOCAL_ActiveSignals & YAP_CDOVF_SIGNAL) { if (!LOCAL_ActiveSignals || LOCAL_ActiveSignals & YAP_CDOVF_SIGNAL) {
goto do_cut; goto do_cut;
@ -2689,6 +2693,7 @@ Yap_absmi(int inp)
goto do_cut; goto do_cut;
NoStackCutT: NoStackCutT:
CHECK_ALARM(goto do_cut_t);
/* find something to fool S */ /* find something to fool S */
if (!LOCAL_ActiveSignals || LOCAL_ActiveSignals & YAP_CDOVF_SIGNAL) { if (!LOCAL_ActiveSignals || LOCAL_ActiveSignals & YAP_CDOVF_SIGNAL) {
goto do_cut_t; goto do_cut_t;
@ -2709,8 +2714,9 @@ Yap_absmi(int inp)
goto do_cut_t; goto do_cut_t;
NoStackCutE: NoStackCutE:
CHECK_ALARM(goto do_cut_e);
if (!LOCAL_ActiveSignals || LOCAL_ActiveSignals & YAP_CDOVF_SIGNAL) { if (!LOCAL_ActiveSignals || LOCAL_ActiveSignals & YAP_CDOVF_SIGNAL) {
goto do_cut_t; goto do_cut_e;
} }
if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) { if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) {
LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL; LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL;
@ -2729,6 +2735,7 @@ Yap_absmi(int inp)
/* This is easier: I know there is an environment so I cannot do allocate */ /* This is easier: I know there is an environment so I cannot do allocate */
NoStackCommitY: NoStackCommitY:
CHECK_ALARM(goto do_commit_b_y);
PP = PREG->u.yps.p0; PP = PREG->u.yps.p0;
/* find something to fool S */ /* find something to fool S */
if (!LOCAL_ActiveSignals || LOCAL_ActiveSignals & YAP_CDOVF_SIGNAL) { if (!LOCAL_ActiveSignals || LOCAL_ActiveSignals & YAP_CDOVF_SIGNAL) {
@ -2751,6 +2758,7 @@ Yap_absmi(int inp)
/* Problem: have I got an environment or not? */ /* Problem: have I got an environment or not? */
NoStackCommitX: NoStackCommitX:
CHECK_ALARM(goto do_commit_b_x);
PP = PREG->u.xps.p0; PP = PREG->u.xps.p0;
/* find something to fool S */ /* find something to fool S */
if (!LOCAL_ActiveSignals || LOCAL_ActiveSignals & YAP_CDOVF_SIGNAL) { if (!LOCAL_ActiveSignals || LOCAL_ActiveSignals & YAP_CDOVF_SIGNAL) {
@ -2788,6 +2796,7 @@ Yap_absmi(int inp)
/* Problem: have I got an environment or not? */ /* Problem: have I got an environment or not? */
NoStackFail: NoStackFail:
CHECK_ALARM(goto fail);
if (LOCAL_ActiveSignals && LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) { if (LOCAL_ActiveSignals && LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) {
LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL; LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL;
if (!LOCAL_ActiveSignals) if (!LOCAL_ActiveSignals)
@ -2811,6 +2820,7 @@ Yap_absmi(int inp)
/* don't forget I cannot creep at ; */ /* don't forget I cannot creep at ; */
NoStackEither: NoStackEither:
CHECK_ALARM(goto either_notest);
if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) { if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) {
LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL; LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL;
if (!LOCAL_ActiveSignals) if (!LOCAL_ActiveSignals)
@ -2893,6 +2903,7 @@ Yap_absmi(int inp)
goto creep; goto creep;
NoStackDExecute: NoStackDExecute:
CHECK_ALARM(JMPNext());
if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) { if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) {
LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL; LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL;
if (!LOCAL_ActiveSignals) if (!LOCAL_ActiveSignals)
@ -2970,8 +2981,8 @@ Yap_absmi(int inp)
NoStackExec: NoStackExec:
CHECK_ALARM(JMPNext());
/* try performing garbage collection */ /* try performing garbage collection */
if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) { if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) {
LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL; LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL;
if (!LOCAL_ActiveSignals) if (!LOCAL_ActiveSignals)
@ -13027,6 +13038,7 @@ Yap_absmi(int inp)
ENDD(d0); ENDD(d0);
NoStackPExecute2: NoStackPExecute2:
CHECK_ALARM(goto execute2_end);
if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) { if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) {
LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL; LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL;
if (!LOCAL_ActiveSignals) if (!LOCAL_ActiveSignals)
@ -13232,6 +13244,7 @@ Yap_absmi(int inp)
ENDD(d0); ENDD(d0);
NoStackPExecute: NoStackPExecute:
CHECK_ALARM(goto execute_end);
if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) { if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) {
LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL; LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL;
if (!LOCAL_ActiveSignals) if (!LOCAL_ActiveSignals)
@ -13464,6 +13477,7 @@ Yap_absmi(int inp)
ENDD(d0); ENDD(d0);
ENDP(pt0); ENDP(pt0);
NoStackPTExecute: NoStackPTExecute:
CHECK_ALARM(goto execute_after_comma);
if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) { if (LOCAL_ActiveSignals & YAP_FAIL_SIGNAL) {
LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL; LOCAL_ActiveSignals &= ~YAP_FAIL_SIGNAL;
if (!LOCAL_ActiveSignals) if (!LOCAL_ActiveSignals)

37
C/adtdefs.c
View File

@ -847,15 +847,10 @@ Yap_NewPredPropByFunctor(FunctorEntry *fe, Term cur_mod)
} }
p->FunctorOfPred = fe; p->FunctorOfPred = fe;
WRITE_UNLOCK(fe->FRWLock); WRITE_UNLOCK(fe->FRWLock);
#ifdef LOW_PROF Yap_inform_profiler_of_clause(&(p->OpcodeOfPred), &(p->OpcodeOfPred)+1, p, GPROF_NEW_PRED_FUNC);
if (ProfilerOn && if (!(p->PredFlags & (CPredFlag|AsmPredFlag))) {
Yap_OffLineProfiler) { Yap_inform_profiler_of_clause(&(p->cs.p_code.ExpandCode), &(p->cs.p_code.ExpandCode)+1, p, GPROF_NEW_PRED_FUNC);
Yap_inform_profiler_of_clause((yamop *)&(p->OpcodeOfPred), (yamop *)(&(p->OpcodeOfPred)+1), p, 1);
if (!(p->PredFlags & (CPredFlag|AsmPredFlag))) {
Yap_inform_profiler_of_clause((yamop *)&(p->cs.p_code.ExpandCode), (yamop *)(&(p->cs.p_code.ExpandCode)+1), p, 1);
}
} }
#endif /* LOW_PROF */
return AbsPredProp(p); return AbsPredProp(p);
} }
@ -896,15 +891,10 @@ Yap_NewThreadPred(PredEntry *ap USES_REGS)
p->NextOfPE = AbsPredProp(LOCAL_ThreadHandle.local_preds); p->NextOfPE = AbsPredProp(LOCAL_ThreadHandle.local_preds);
LOCAL_ThreadHandle.local_preds = p; LOCAL_ThreadHandle.local_preds = p;
p->FunctorOfPred = ap->FunctorOfPred; p->FunctorOfPred = ap->FunctorOfPred;
#ifdef LOW_PROF Yap_inform_profiler_of_clause(&(p->OpcodeOfPred), &(p->OpcodeOfPred)+1, p, GPROF_NEW_PRED_THREAD);
if (ProfilerOn && if (!(p->PredFlags & (CPredFlag|AsmPredFlag))) {
Yap_OffLineProfiler) { Yap_inform_profiler_of_clause(&(p->cs.p_code.ExpandCode), &(p->cs.p_code.ExpandCode)+1, p, GPROF_NEW_PRED_THREAD);
Yap_inform_profiler_of_clause((yamop *)&(p->OpcodeOfPred), (yamop *)(&(p->OpcodeOfPred)+1), p, 1); }
if (!(p->PredFlags & (CPredFlag|AsmPredFlag))) {
Yap_inform_profiler_of_clause((yamop *)&(p->cs.p_code.ExpandCode), (yamop *)(&(p->cs.p_code.ExpandCode)+1), p, 1);
}
}
#endif /* LOW_PROF */
return AbsPredProp(p); return AbsPredProp(p);
} }
#endif #endif
@ -968,15 +958,10 @@ Yap_NewPredPropByAtom(AtomEntry *ae, Term cur_mod)
p0 = AbsPredProp(p); p0 = AbsPredProp(p);
p->FunctorOfPred = (Functor)AbsAtom(ae); p->FunctorOfPred = (Functor)AbsAtom(ae);
WRITE_UNLOCK(ae->ARWLock); WRITE_UNLOCK(ae->ARWLock);
#ifdef LOW_PROF Yap_inform_profiler_of_clause((yamop *)&(p->OpcodeOfPred), (yamop *)(&(p->OpcodeOfPred)+1), p, GPROF_NEW_PRED_ATOM);
if (ProfilerOn && if (!(p->PredFlags & (CPredFlag|AsmPredFlag))) {
Yap_OffLineProfiler) { Yap_inform_profiler_of_clause((yamop *)&(p->cs.p_code.ExpandCode), (yamop *)(&(p->cs.p_code.ExpandCode)+1), p, GPROF_NEW_PRED_ATOM);
Yap_inform_profiler_of_clause((yamop *)&(p->OpcodeOfPred), (yamop *)(&(p->OpcodeOfPred)+1), p, 1); }
if (!(p->PredFlags & (CPredFlag|AsmPredFlag))) {
Yap_inform_profiler_of_clause((yamop *)&(p->cs.p_code.ExpandCode), (yamop *)(&(p->cs.p_code.ExpandCode)+1), p, 1);
}
}
#endif /* LOW_PROF */
return p0; return p0;
} }

10
C/amasm.c
View File

@ -2059,6 +2059,7 @@ a_try(op_numbers opcode, CELL lab, CELL opr, int nofalts, int hascut, yamop *cod
save_machine_regs(); save_machine_regs();
siglongjmp(cip->CompilerBotch,2); siglongjmp(cip->CompilerBotch,2);
} }
Yap_inform_profiler_of_clause(newcp, (char *)(newcp)+size, ap, GPROF_INDEX);
Yap_LUIndexSpace_CP += size; Yap_LUIndexSpace_CP += size;
#ifdef DEBUG #ifdef DEBUG
Yap_NewCps++; Yap_NewCps++;
@ -3935,6 +3936,7 @@ Yap_assemble(int mode, Term t, PredEntry *ap, int is_fact, struct intermediates
cl->usc.ClSource = x; cl->usc.ClSource = x;
cl->ClSize = osize; cl->ClSize = osize;
LOCAL_ProfEnd=code_p; LOCAL_ProfEnd=code_p;
Yap_inform_profiler_of_clause(cl, LOCAL_ProfEnd, ap, GPROF_CLAUSE);
return entry_code; return entry_code;
} else { } else {
while ((cip->code_addr = (yamop *) Yap_AllocCodeSpace(size)) == NULL) { while ((cip->code_addr = (yamop *) Yap_AllocCodeSpace(size)) == NULL) {
@ -3945,6 +3947,7 @@ Yap_assemble(int mode, Term t, PredEntry *ap, int is_fact, struct intermediates
return NULL; return NULL;
} }
} }
Yap_inform_profiler_of_clause(cip->code_addr, (char *)(cip->code_addr)+size, ap, ( mode == ASSEMBLING_INDEX ? GPROF_INDEX : GPROF_CLAUSE ));
if (mode == ASSEMBLING_CLAUSE) { if (mode == ASSEMBLING_CLAUSE) {
if (ap->PredFlags & LogUpdatePredFlag) { if (ap->PredFlags & LogUpdatePredFlag) {
((LogUpdClause *)(cip->code_addr))->ClSize = size; ((LogUpdClause *)(cip->code_addr))->ClSize = size;
@ -3960,13 +3963,6 @@ Yap_assemble(int mode, Term t, PredEntry *ap, int is_fact, struct intermediates
} }
} }
code_p = do_pass(1, &entry_code, mode, &clause_has_blobs, &clause_has_dbterm, cip, size PASS_REGS); code_p = do_pass(1, &entry_code, mode, &clause_has_blobs, &clause_has_dbterm, cip, size PASS_REGS);
LOCAL_ProfEnd=code_p;
#ifdef LOW_PROF
if (ProfilerOn &&
Yap_OffLineProfiler) {
Yap_inform_profiler_of_clause(entry_code, LOCAL_ProfEnd, ap, mode == ASSEMBLING_INDEX);
}
#endif /* LOW_PROF */
return entry_code; return entry_code;
} }

2
C/c_interface.c
View File

@ -2894,7 +2894,7 @@ do_bootfile (char *bootfilename)
} }
YAP_EndConsult(bootfile); YAP_EndConsult(bootfile);
#ifdef DEBUG #ifdef DEBUG
if (output_msg) if (Yap_output_msg)
fprintf(stderr,"Boot loaded\n"); fprintf(stderr,"Boot loaded\n");
#endif #endif
} }

43
C/cdmgr.c
View File

@ -881,7 +881,7 @@ Yap_BuildMegaClause(PredEntry *ap)
StaticClause *ncl, *curcl = cl; StaticClause *ncl, *curcl = cl;
ncl = cl->ClNext; ncl = cl->ClNext;
Yap_InformOfRemoval((CODEADDR)cl); Yap_InformOfRemoval(cl);
Yap_ClauseSpace -= cl->ClSize; Yap_ClauseSpace -= cl->ClSize;
Yap_FreeCodeSpace((ADDR)cl); Yap_FreeCodeSpace((ADDR)cl);
if (curcl->ClCode == ap->cs.p_code.LastClause) if (curcl->ClCode == ap->cs.p_code.LastClause)
@ -892,6 +892,7 @@ Yap_BuildMegaClause(PredEntry *ap)
ap->cs.p_code.LastClause = ap->cs.p_code.LastClause =
mcl->ClCode; mcl->ClCode;
ap->PredFlags |= MegaClausePredFlag; ap->PredFlags |= MegaClausePredFlag;
Yap_inform_profiler_of_clause(mcl, (char *)mcl+required, ap, GPROF_MEGA);
} }
@ -913,7 +914,7 @@ split_megaclause(PredEntry *ap)
while (start) { while (start) {
StaticClause *cl = start; StaticClause *cl = start;
start = cl->ClNext; start = cl->ClNext;
Yap_InformOfRemoval((CODEADDR)cl); Yap_InformOfRemoval(cl);
Yap_ClauseSpace -= cl->ClSize; Yap_ClauseSpace -= cl->ClSize;
Yap_FreeCodeSpace((char *)cl); Yap_FreeCodeSpace((char *)cl);
} }
@ -1115,7 +1116,7 @@ release_wcls(yamop *cop, OPCODE ecs)
cop->u.sssllp.snext->u.sssllp.sprev = cop->u.sssllp.sprev; cop->u.sssllp.snext->u.sssllp.sprev = cop->u.sssllp.sprev;
} }
UNLOCK(ExpandClausesListLock); UNLOCK(ExpandClausesListLock);
Yap_InformOfRemoval((CODEADDR)cop); Yap_InformOfRemoval(cop);
Yap_FreeCodeSpace((char *)cop); Yap_FreeCodeSpace((char *)cop);
} }
} }
@ -1323,7 +1324,7 @@ kill_static_child_indxs(StaticIndex *indx, int in_use)
DeadStaticIndices = indx; DeadStaticIndices = indx;
UNLOCK(DeadStaticIndicesLock); UNLOCK(DeadStaticIndicesLock);
} else { } else {
Yap_InformOfRemoval((CODEADDR)indx); Yap_InformOfRemoval(indx);
if (indx->ClFlags & SwitchTableMask) if (indx->ClFlags & SwitchTableMask)
Yap_IndexSpace_SW -= indx->ClSize; Yap_IndexSpace_SW -= indx->ClSize;
else else
@ -1378,7 +1379,7 @@ kill_off_lu_block(LogUpdIndex *c, LogUpdIndex *parent, PredEntry *ap)
} else { } else {
DBErasedIList = c->SiblingIndex; DBErasedIList = c->SiblingIndex;
} }
Yap_InformOfRemoval((CODEADDR)c); Yap_InformOfRemoval(c);
if (c->ClFlags & SwitchTableMask) if (c->ClFlags & SwitchTableMask)
Yap_LUIndexSpace_SW -= c->ClSize; Yap_LUIndexSpace_SW -= c->ClSize;
else { else {
@ -1576,7 +1577,7 @@ retract_all(PredEntry *p, int in_use)
DeadMegaClauses = cl; DeadMegaClauses = cl;
UNLOCK(DeadMegaClausesLock); UNLOCK(DeadMegaClausesLock);
} else { } else {
Yap_InformOfRemoval((CODEADDR)cl); Yap_InformOfRemoval(cl);
Yap_ClauseSpace -= cl->ClSize; Yap_ClauseSpace -= cl->ClSize;
Yap_FreeCodeSpace((char *)cl); Yap_FreeCodeSpace((char *)cl);
} }
@ -1595,7 +1596,7 @@ retract_all(PredEntry *p, int in_use)
DeadStaticClauses = cl; DeadStaticClauses = cl;
UNLOCK(DeadStaticClausesLock); UNLOCK(DeadStaticClausesLock);
} else { } else {
Yap_InformOfRemoval((CODEADDR)cl); Yap_InformOfRemoval(cl);
Yap_ClauseSpace -= cl->ClSize; Yap_ClauseSpace -= cl->ClSize;
Yap_FreeCodeSpace((char *)cl); Yap_FreeCodeSpace((char *)cl);
} }
@ -2397,7 +2398,7 @@ Yap_EraseStaticClause(StaticClause *cl, Term mod) {
DeadStaticClauses = cl; DeadStaticClauses = cl;
UNLOCK(DeadStaticClausesLock); UNLOCK(DeadStaticClausesLock);
} else { } else {
Yap_InformOfRemoval((CODEADDR)cl); Yap_InformOfRemoval(cl);
Yap_ClauseSpace -= cl->ClSize; Yap_ClauseSpace -= cl->ClSize;
Yap_FreeCodeSpace((char *)cl); Yap_FreeCodeSpace((char *)cl);
} }
@ -4184,7 +4185,7 @@ p_clean_up_dead_clauses( USES_REGS1 )
char *pt = (char *)DeadStaticClauses; char *pt = (char *)DeadStaticClauses;
Yap_ClauseSpace -= DeadStaticClauses->ClSize; Yap_ClauseSpace -= DeadStaticClauses->ClSize;
DeadStaticClauses = DeadStaticClauses->ClNext; DeadStaticClauses = DeadStaticClauses->ClNext;
Yap_InformOfRemoval((CODEADDR)pt); Yap_InformOfRemoval(pt);
Yap_FreeCodeSpace(pt); Yap_FreeCodeSpace(pt);
} }
while (DeadStaticIndices != NULL) { while (DeadStaticIndices != NULL) {
@ -4194,14 +4195,14 @@ p_clean_up_dead_clauses( USES_REGS1 )
else else
Yap_IndexSpace_Tree -= DeadStaticIndices->ClSize; Yap_IndexSpace_Tree -= DeadStaticIndices->ClSize;
DeadStaticIndices = DeadStaticIndices->SiblingIndex; DeadStaticIndices = DeadStaticIndices->SiblingIndex;
Yap_InformOfRemoval((CODEADDR)pt); Yap_InformOfRemoval(pt);
Yap_FreeCodeSpace(pt); Yap_FreeCodeSpace(pt);
} }
while (DeadMegaClauses != NULL) { while (DeadMegaClauses != NULL) {
char *pt = (char *)DeadMegaClauses; char *pt = (char *)DeadMegaClauses;
Yap_ClauseSpace -= DeadMegaClauses->ClSize; Yap_ClauseSpace -= DeadMegaClauses->ClSize;
DeadMegaClauses = DeadMegaClauses->ClNext; DeadMegaClauses = DeadMegaClauses->ClNext;
Yap_InformOfRemoval((CODEADDR)pt); Yap_InformOfRemoval(pt);
Yap_FreeCodeSpace(pt); Yap_FreeCodeSpace(pt);
} }
return TRUE; return TRUE;
@ -5107,7 +5108,7 @@ static void
add_code_in_lu_index(LogUpdIndex *cl, PredEntry *pp) add_code_in_lu_index(LogUpdIndex *cl, PredEntry *pp)
{ {
char *code_end = (char *)cl + cl->ClSize; char *code_end = (char *)cl + cl->ClSize;
Yap_inform_profiler_of_clause(cl->ClCode, (yamop *)code_end, pp,0); Yap_inform_profiler_of_clause(cl, code_end, pp, GPROF_LU_INDEX);
cl = cl->ChildIndex; cl = cl->ChildIndex;
while (cl != NULL) { while (cl != NULL) {
add_code_in_lu_index(cl, pp); add_code_in_lu_index(cl, pp);
@ -5119,7 +5120,7 @@ static void
add_code_in_static_index(StaticIndex *cl, PredEntry *pp) add_code_in_static_index(StaticIndex *cl, PredEntry *pp)
{ {
char *code_end = (char *)cl + cl->ClSize; char *code_end = (char *)cl + cl->ClSize;
Yap_inform_profiler_of_clause(cl->ClCode, (yamop *)code_end, pp,0); Yap_inform_profiler_of_clause(cl, code_end, pp, GPROF_STATIC_INDEX);
cl = cl->ChildIndex; cl = cl->ChildIndex;
while (cl != NULL) { while (cl != NULL) {
add_code_in_static_index(cl, pp); add_code_in_static_index(cl, pp);
@ -5136,7 +5137,7 @@ add_code_in_pred(PredEntry *pp) {
/* check if the codeptr comes from the indexing code */ /* check if the codeptr comes from the indexing code */
/* highly likely this is used for indexing */ /* highly likely this is used for indexing */
Yap_inform_profiler_of_clause((yamop *)&(pp->OpcodeOfPred), (yamop *)(&(pp->OpcodeOfPred)+1), pp, 1); Yap_inform_profiler_of_clause(&(pp->OpcodeOfPred), &(pp->OpcodeOfPred)+1, pp, GPROF_INIT_OPCODE);
if (pp->PredFlags & (CPredFlag|AsmPredFlag)) { if (pp->PredFlags & (CPredFlag|AsmPredFlag)) {
char *code_end; char *code_end;
StaticClause *cl; StaticClause *cl;
@ -5144,11 +5145,11 @@ add_code_in_pred(PredEntry *pp) {
clcode = pp->CodeOfPred; clcode = pp->CodeOfPred;
cl = ClauseCodeToStaticClause(clcode); cl = ClauseCodeToStaticClause(clcode);
code_end = (char *)cl + cl->ClSize; code_end = (char *)cl + cl->ClSize;
Yap_inform_profiler_of_clause(clcode, (yamop *)code_end, pp,0); Yap_inform_profiler_of_clause(cl, code_end, pp, GPROF_INIT_SYSTEM_CODE);
UNLOCK(pp->PELock); UNLOCK(pp->PELock);
return; return;
} }
Yap_inform_profiler_of_clause((yamop *)&(pp->cs.p_code.ExpandCode), (yamop *)(&(pp->cs.p_code.ExpandCode)+1), pp, 1); Yap_inform_profiler_of_clause(&(pp->cs.p_code.ExpandCode), &(pp->cs.p_code.ExpandCode)+1, pp, GPROF_INIT_EXPAND);
clcode = pp->cs.p_code.TrueCodeOfPred; clcode = pp->cs.p_code.TrueCodeOfPred;
if (pp->PredFlags & IndexedPredFlag) { if (pp->PredFlags & IndexedPredFlag) {
if (pp->PredFlags & LogUpdatePredFlag) { if (pp->PredFlags & LogUpdatePredFlag) {
@ -5167,7 +5168,7 @@ add_code_in_pred(PredEntry *pp) {
char *code_end; char *code_end;
code_end = (char *)cl + cl->ClSize; code_end = (char *)cl + cl->ClSize;
Yap_inform_profiler_of_clause(cl->ClCode, (yamop *)code_end, pp,0); Yap_inform_profiler_of_clause(cl, code_end, pp, GPROF_INIT_LOG_UPD_CLAUSE);
cl = cl->ClNext; cl = cl->ClNext;
} while (cl != NULL); } while (cl != NULL);
} else if (pp->PredFlags & DynamicPredFlag) { } else if (pp->PredFlags & DynamicPredFlag) {
@ -5177,7 +5178,7 @@ add_code_in_pred(PredEntry *pp) {
cl = ClauseCodeToDynamicClause(clcode); cl = ClauseCodeToDynamicClause(clcode);
code_end = (CODEADDR)cl + cl->ClSize; code_end = (CODEADDR)cl + cl->ClSize;
Yap_inform_profiler_of_clause(clcode, (yamop *)code_end, pp,0); Yap_inform_profiler_of_clause(cl, code_end, pp, GPROF_INIT_DYNAMIC_CLAUSE);
if (clcode == pp->cs.p_code.LastClause) if (clcode == pp->cs.p_code.LastClause)
break; break;
clcode = NextDynamicClause(clcode); clcode = NextDynamicClause(clcode);
@ -5188,7 +5189,7 @@ add_code_in_pred(PredEntry *pp) {
char *code_end; char *code_end;
code_end = (char *)cl + cl->ClSize; code_end = (char *)cl + cl->ClSize;
Yap_inform_profiler_of_clause(cl->ClCode, (yamop *)code_end, pp,0); Yap_inform_profiler_of_clause(cl, code_end, pp,GPROF_INIT_STATIC_CLAUSE);
if (cl->ClCode == pp->cs.p_code.LastClause) if (cl->ClCode == pp->cs.p_code.LastClause)
break; break;
cl = cl->ClNext; cl = cl->ClNext;
@ -5222,8 +5223,8 @@ Yap_dump_code_area_for_profiler(void) {
} }
me = me->NextME; me = me->NextME;
} }
Yap_inform_profiler_of_clause(COMMA_CODE, FAILCODE, RepPredProp(Yap_GetPredPropByFunc(FunctorComma,0)),0); Yap_inform_profiler_of_clause(COMMA_CODE, FAILCODE, RepPredProp(Yap_GetPredPropByFunc(FunctorComma,0)), GPROF_INIT_COMMA);
Yap_inform_profiler_of_clause(FAILCODE, FAILCODE+1, RepPredProp(Yap_GetPredPropByAtom(AtomFail,0)),0); Yap_inform_profiler_of_clause(FAILCODE, FAILCODE+1, RepPredProp(Yap_GetPredPropByAtom(AtomFail,0)), GPROF_INIT_FAIL);
} }
#endif /* LOW_PROF */ #endif /* LOW_PROF */

8
C/compiler.c
View File

@ -3606,13 +3606,7 @@ Yap_cclause(volatile Term inp_clause, Int NOfArgs, Term mod, volatile Term src)
if (acode == NULL) { if (acode == NULL) {
return NULL; return NULL;
} else { } else {
#ifdef LOW_PROF return acode;
if (ProfilerOn &&
Yap_OffLineProfiler) {
Yap_inform_profiler_of_clause(acode, LOCAL_ProfEnd, cglobs.cint.CurrentPred,0);
}
#endif /* LOW_PROF */
return(acode);
} }
} }

11
C/dbase.c
View File

@ -1892,12 +1892,7 @@ record_lu(PredEntry *pe, Term t, int position)
if ((cl = new_lu_db_entry(t, pe)) == NULL) { if ((cl = new_lu_db_entry(t, pe)) == NULL) {
return NULL; return NULL;
} }
#ifdef LOW_PROF Yap_inform_profiler_of_clause(cl, (char *)cl+cl->ClSize, pe, GPROF_NEW_LU_CLAUSE);
if (ProfilerOn &&
Yap_OffLineProfiler) {
Yap_inform_profiler_of_clause(cl->ClCode, (yamop *)(cl+cl->ClSize), pe, 0);
}
#endif /* LOW_PROF */
Yap_add_logupd_clause(pe, cl, (position == MkFirst ? 2 : 0)); Yap_add_logupd_clause(pe, cl, (position == MkFirst ? 2 : 0));
return cl; return cl;
} }
@ -4086,7 +4081,7 @@ complete_lu_erase(LogUpdClause *clau)
} }
} }
} }
Yap_InformOfRemoval((CODEADDR)clau); Yap_InformOfRemoval(clau);
Yap_LUClauseSpace -= clau->ClSize; Yap_LUClauseSpace -= clau->ClSize;
Yap_FreeCodeSpace((char *)clau); Yap_FreeCodeSpace((char *)clau);
} }
@ -4198,7 +4193,7 @@ MyEraseClause(DynamicClause *clau USES_REGS)
P = np; P = np;
} }
} else { } else {
Yap_InformOfRemoval((CODEADDR)clau); Yap_InformOfRemoval(clau);
Yap_LUClauseSpace -= clau->ClSize; Yap_LUClauseSpace -= clau->ClSize;
Yap_FreeCodeSpace((char *)clau); Yap_FreeCodeSpace((char *)clau);
#ifdef DEBUG #ifdef DEBUG

505
C/gprof.c
View File

@ -129,12 +129,22 @@ typedef greg_t context_reg;
#define PROFILING_FILE 1 #define PROFILING_FILE 1
#define PROFPREDS_FILE 2 #define PROFPREDS_FILE 2
typedef struct {
char tag;
void *ptr;
} __attribute__ ((packed)) buf_ptr;
typedef struct {
gprof_info inf;
void *end;
PredEntry *pe;
} __attribute__ ((packed)) buf_extra;
typedef struct RB_red_blk_node { typedef struct RB_red_blk_node {
yamop *key; /* first address */ yamop *key; /* first address */
yamop *lim; /* end address */ yamop *lim; /* end address */
PredEntry *pe; /* parent predicate */ PredEntry *pe; /* parent predicate */
gprof_info source; /* how block was allocated */
UInt pcs; /* counter with total for each clause */ UInt pcs; /* counter with total for each clause */
int red; /* if red=0 then the node is black */ int red; /* if red=0 then the node is black */
struct RB_red_blk_node* left; struct RB_red_blk_node* left;
@ -162,16 +172,18 @@ RBTreeCreate(void) {
/* see the comment in the rb_red_blk_tree structure in red_black_tree.h */ /* see the comment in the rb_red_blk_tree structure in red_black_tree.h */
/* for information on nil and root */ /* for information on nil and root */
temp=GLOBAL_ProfilerNil= RBMalloc(sizeof(rb_red_blk_node)); temp=LOCAL_ProfilerNil= RBMalloc(sizeof(rb_red_blk_node));
temp->parent=temp->left=temp->right=temp; temp->parent=temp->left=temp->right=temp;
temp->pcs=0; temp->pcs=0;
temp->red=0; temp->red=0;
temp->key=temp->lim=NULL; temp->key=temp->lim=NULL;
temp->pe=NULL; temp->pe=NULL;
temp->source=GPROF_NO_EVENT;;
temp = RBMalloc(sizeof(rb_red_blk_node)); temp = RBMalloc(sizeof(rb_red_blk_node));
temp->parent=temp->left=temp->right=GLOBAL_ProfilerNil; temp->parent=temp->left=temp->right=LOCAL_ProfilerNil;
temp->key=temp->lim=NULL; temp->key=temp->lim=NULL;
temp->pe=NULL; temp->pe=NULL;
temp->source=GPROF_NO_EVENT;
temp->pcs=0; temp->pcs=0;
temp->red=0; temp->red=0;
return temp; return temp;
@ -199,7 +211,7 @@ RBTreeCreate(void) {
static void static void
LeftRotate(rb_red_blk_node* x) { LeftRotate(rb_red_blk_node* x) {
rb_red_blk_node* y; rb_red_blk_node* y;
rb_red_blk_node* nil=GLOBAL_ProfilerNil; rb_red_blk_node* nil=LOCAL_ProfilerNil;
/* I originally wrote this function to use the sentinel for */ /* I originally wrote this function to use the sentinel for */
/* nil to avoid checking for nil. However this introduces a */ /* nil to avoid checking for nil. However this introduces a */
@ -230,7 +242,7 @@ LeftRotate(rb_red_blk_node* x) {
x->parent=y; x->parent=y;
#ifdef DEBUG_ASSERT #ifdef DEBUG_ASSERT
Assert(!GLOBAL_ProfilerNil->red,"nil not red in LeftRotate"); Assert(!LOCAL_ProfilerNil->red,"nil not red in LeftRotate");
#endif #endif
} }
@ -255,7 +267,7 @@ LeftRotate(rb_red_blk_node* x) {
static void static void
RightRotate(rb_red_blk_node* y) { RightRotate(rb_red_blk_node* y) {
rb_red_blk_node* x; rb_red_blk_node* x;
rb_red_blk_node* nil=GLOBAL_ProfilerNil; rb_red_blk_node* nil=LOCAL_ProfilerNil;
/* I originally wrote this function to use the sentinel for */ /* I originally wrote this function to use the sentinel for */
/* nil to avoid checking for nil. However this introduces a */ /* nil to avoid checking for nil. However this introduces a */
@ -285,7 +297,7 @@ RightRotate(rb_red_blk_node* y) {
y->parent=x; y->parent=x;
#ifdef DEBUG_ASSERT #ifdef DEBUG_ASSERT
Assert(!GLOBAL_ProfilerNil->red,"nil not red in RightRotate"); Assert(!LOCAL_ProfilerNil->red,"nil not red in RightRotate");
#endif #endif
} }
@ -309,11 +321,11 @@ TreeInsertHelp(rb_red_blk_node* z) {
/* This function should only be called by InsertRBTree (see above) */ /* This function should only be called by InsertRBTree (see above) */
rb_red_blk_node* x; rb_red_blk_node* x;
rb_red_blk_node* y; rb_red_blk_node* y;
rb_red_blk_node* nil=GLOBAL_ProfilerNil; rb_red_blk_node* nil=LOCAL_ProfilerNil;
z->left=z->right=nil; z->left=z->right=nil;
y=GLOBAL_ProfilerRoot; y=LOCAL_ProfilerRoot;
x=GLOBAL_ProfilerRoot->left; x=LOCAL_ProfilerRoot->left;
while( x != nil) { while( x != nil) {
y=x; y=x;
if (x->key > z->key) { /* x.key > z.key */ if (x->key > z->key) { /* x.key > z.key */
@ -323,7 +335,7 @@ TreeInsertHelp(rb_red_blk_node* z) {
} }
} }
z->parent=y; z->parent=y;
if ( (y == GLOBAL_ProfilerRoot) || if ( (y == LOCAL_ProfilerRoot) ||
(y->key > z->key)) { /* y.key > z.key */ (y->key > z->key)) { /* y.key > z.key */
y->left=z; y->left=z;
} else { } else {
@ -331,7 +343,7 @@ TreeInsertHelp(rb_red_blk_node* z) {
} }
#ifdef DEBUG_ASSERT #ifdef DEBUG_ASSERT
Assert(!GLOBAL_ProfilerNil->red,"nil not red in TreeInsertHelp"); Assert(!LOCAL_ProfilerNil->red,"nil not red in TreeInsertHelp");
#endif #endif
} }
@ -403,12 +415,12 @@ RBTreeInsert(yamop *key, yamop *lim) {
} }
} }
} }
GLOBAL_ProfilerRoot->left->red=0; LOCAL_ProfilerRoot->left->red=0;
return newNode; return newNode;
#ifdef DEBUG_ASSERT #ifdef DEBUG_ASSERT
Assert(!GLOBAL_ProfilerNil->red,"nil not red in RBTreeInsert"); Assert(!LOCAL_ProfilerNil->red,"nil not red in RBTreeInsert");
Assert(!GLOBAL_ProfilerRoot->red,"root not red in RBTreeInsert"); Assert(!LOCAL_ProfilerRoot->red,"root not red in RBTreeInsert");
#endif #endif
} }
@ -429,10 +441,10 @@ RBTreeInsert(yamop *key, yamop *lim) {
static rb_red_blk_node* static rb_red_blk_node*
RBExactQuery(yamop* q) { RBExactQuery(yamop* q) {
rb_red_blk_node* x; rb_red_blk_node* x;
rb_red_blk_node* nil=GLOBAL_ProfilerNil; rb_red_blk_node* nil=LOCAL_ProfilerNil;
if (!GLOBAL_ProfilerRoot) return NULL; if (!LOCAL_ProfilerRoot) return NULL;
x=GLOBAL_ProfilerRoot->left; x=LOCAL_ProfilerRoot->left;
if (x == nil) return NULL; if (x == nil) return NULL;
while(x->key != q) {/*assignemnt*/ while(x->key != q) {/*assignemnt*/
if (x->key > q) { /* x->key > q */ if (x->key > q) { /* x->key > q */
@ -450,10 +462,10 @@ static rb_red_blk_node*
RBLookup(yamop *entry) { RBLookup(yamop *entry) {
rb_red_blk_node *current; rb_red_blk_node *current;
if (!GLOBAL_ProfilerRoot) if (!LOCAL_ProfilerRoot)
return NULL; return NULL;
current = GLOBAL_ProfilerRoot->left; current = LOCAL_ProfilerRoot->left;
while (current != GLOBAL_ProfilerNil) { while (current != LOCAL_ProfilerNil) {
if (current->key <= entry && current->lim >= entry) { if (current->key <= entry && current->lim >= entry) {
return current; return current;
} }
@ -483,7 +495,7 @@ RBLookup(yamop *entry) {
/***********************************************************************/ /***********************************************************************/
static void RBDeleteFixUp(rb_red_blk_node* x) { static void RBDeleteFixUp(rb_red_blk_node* x) {
rb_red_blk_node* root=GLOBAL_ProfilerRoot->left; rb_red_blk_node* root=LOCAL_ProfilerRoot->left;
rb_red_blk_node *w; rb_red_blk_node *w;
while( (!x->red) && (root != x)) { while( (!x->red) && (root != x)) {
@ -563,8 +575,8 @@ static void RBDeleteFixUp(rb_red_blk_node* x) {
static rb_red_blk_node* static rb_red_blk_node*
TreeSuccessor(rb_red_blk_node* x) { TreeSuccessor(rb_red_blk_node* x) {
rb_red_blk_node* y; rb_red_blk_node* y;
rb_red_blk_node* nil=GLOBAL_ProfilerNil; rb_red_blk_node* nil=LOCAL_ProfilerNil;
rb_red_blk_node* root=GLOBAL_ProfilerRoot; rb_red_blk_node* root=LOCAL_ProfilerRoot;
if (nil != (y = x->right)) { /* assignment to y is intentional */ if (nil != (y = x->right)) { /* assignment to y is intentional */
while(y->left != nil) { /* returns the minium of the right subtree of x */ while(y->left != nil) { /* returns the minium of the right subtree of x */
@ -602,8 +614,8 @@ static void
RBDelete(rb_red_blk_node* z){ RBDelete(rb_red_blk_node* z){
rb_red_blk_node* y; rb_red_blk_node* y;
rb_red_blk_node* x; rb_red_blk_node* x;
rb_red_blk_node* nil=GLOBAL_ProfilerNil; rb_red_blk_node* nil=LOCAL_ProfilerNil;
rb_red_blk_node* root=GLOBAL_ProfilerRoot; rb_red_blk_node* root=LOCAL_ProfilerRoot;
y= ((z->left == nil) || (z->right == nil)) ? z : TreeSuccessor(z); y= ((z->left == nil) || (z->right == nil)) ? z : TreeSuccessor(z);
x= (y->left == nil) ? y->right : y->left; x= (y->left == nil) ? y->right : y->left;
@ -656,21 +668,21 @@ int size=0;
if (name!=NULL) { if (name!=NULL) {
size=strlen(name)+1; size=strlen(name)+1;
if (GLOBAL_DIRNAME!=NULL) free(GLOBAL_DIRNAME); if (LOCAL_DIRNAME!=NULL) free(LOCAL_DIRNAME);
GLOBAL_DIRNAME=malloc(size); LOCAL_DIRNAME=malloc(size);
if (GLOBAL_DIRNAME==NULL) { printf("Profiler Out of Mem\n"); exit(1); } if (LOCAL_DIRNAME==NULL) { printf("Profiler Out of Mem\n"); exit(1); }
strcpy(GLOBAL_DIRNAME,name); strcpy(LOCAL_DIRNAME,name);
} }
if (GLOBAL_DIRNAME==NULL) { if (LOCAL_DIRNAME==NULL) {
do { do {
if (GLOBAL_DIRNAME!=NULL) free(GLOBAL_DIRNAME); if (LOCAL_DIRNAME!=NULL) free(LOCAL_DIRNAME);
size+=20; size+=20;
GLOBAL_DIRNAME=malloc(size); LOCAL_DIRNAME=malloc(size);
if (GLOBAL_DIRNAME==NULL) { printf("Profiler Out of Mem\n"); exit(1); } if (LOCAL_DIRNAME==NULL) { printf("Profiler Out of Mem\n"); exit(1); }
} while (getcwd(GLOBAL_DIRNAME, size-15)==NULL); } while (getcwd(LOCAL_DIRNAME, size-15)==NULL);
} }
return GLOBAL_DIRNAME; return LOCAL_DIRNAME;
} }
char *profile_names(int); char *profile_names(int);
@ -678,12 +690,12 @@ char *profile_names(int k) {
static char *FNAME=NULL; static char *FNAME=NULL;
int size=200; int size=200;
if (GLOBAL_DIRNAME==NULL) set_profile_dir(NULL); if (LOCAL_DIRNAME==NULL) set_profile_dir(NULL);
size=strlen(GLOBAL_DIRNAME)+40; size=strlen(LOCAL_DIRNAME)+40;
if (FNAME!=NULL) free(FNAME); if (FNAME!=NULL) free(FNAME);
FNAME=malloc(size); FNAME=malloc(size);
if (FNAME==NULL) { printf("Profiler Out of Mem\n"); exit(1); } if (FNAME==NULL) { printf("Profiler Out of Mem\n"); exit(1); }
strcpy(FNAME,GLOBAL_DIRNAME); strcpy(FNAME,LOCAL_DIRNAME);
if (k==PROFILING_FILE) { if (k==PROFILING_FILE) {
sprintf(FNAME,"%s/PROFILING_%d",FNAME,getpid()); sprintf(FNAME,"%s/PROFILING_%d",FNAME,getpid());
@ -697,26 +709,25 @@ int size=200;
void del_profile_files(void); void del_profile_files(void);
void del_profile_files() { void del_profile_files() {
if (GLOBAL_DIRNAME!=NULL) { if (LOCAL_DIRNAME!=NULL) {
remove(profile_names(PROFPREDS_FILE)); remove(profile_names(PROFPREDS_FILE));
remove(profile_names(PROFILING_FILE)); remove(profile_names(PROFILING_FILE));
} }
} }
void void
Yap_inform_profiler_of_clause(yamop *code_start, yamop *code_end, PredEntry *pe,int index_code) { Yap_inform_profiler_of_clause__(void *code_start, void *code_end, PredEntry *pe,gprof_info index_code) {
static Int order=0; buf_ptr b;
buf_extra e;
ProfPreds++; LOCAL_ProfOn = TRUE;
GLOBAL_ProfOn = TRUE; b.tag = '+';
if (FPreds != NULL) { b.ptr= code_start;
Int temp; e.inf= index_code;
e.end= code_end;
order++; e.pe= pe;
if (index_code) temp=-order; else temp=order; fwrite(&b,sizeof(b),1,LOCAL_FPreds);
fprintf(FPreds,"+%p %p %p %ld\n",code_start,code_end, pe, (long int)temp); fwrite(&e,sizeof(e),1,LOCAL_FPreds);
} LOCAL_ProfOn = FALSE;
GLOBAL_ProfOn = FALSE;
} }
typedef struct clause_entry { typedef struct clause_entry {
@ -731,7 +742,7 @@ static Int profend( USES_REGS1 );
static void static void
clean_tree(rb_red_blk_node* node) { clean_tree(rb_red_blk_node* node) {
if (node == GLOBAL_ProfilerNil) if (node == LOCAL_ProfilerNil)
return; return;
clean_tree(node->left); clean_tree(node->left);
clean_tree(node->right); clean_tree(node->right);
@ -740,18 +751,18 @@ clean_tree(rb_red_blk_node* node) {
static void static void
reset_tree(void) { reset_tree(void) {
clean_tree(GLOBAL_ProfilerRoot); clean_tree(LOCAL_ProfilerRoot);
Yap_FreeCodeSpace((char *)GLOBAL_ProfilerNil); Yap_FreeCodeSpace((char *)LOCAL_ProfilerNil);
GLOBAL_ProfilerNil = GLOBAL_ProfilerRoot = NULL; LOCAL_ProfilerNil = LOCAL_ProfilerRoot = NULL;
GLOBAL_ProfCalls = GLOBAL_ProfGCs = GLOBAL_ProfHGrows = GLOBAL_ProfSGrows = GLOBAL_ProfMallocs = GLOBAL_ProfOns = 0L; LOCAL_ProfCalls = LOCAL_ProfGCs = LOCAL_ProfHGrows = LOCAL_ProfSGrows = LOCAL_ProfMallocs = LOCAL_ProfOns = 0L;
} }
static int static int
InitProfTree(void) InitProfTree(void)
{ {
if (GLOBAL_ProfilerRoot) if (LOCAL_ProfilerRoot)
reset_tree(); reset_tree();
while (!(GLOBAL_ProfilerRoot = RBTreeCreate())) { while (!(LOCAL_ProfilerRoot = RBTreeCreate())) {
if (!Yap_growheap(FALSE, 0, NULL)) { if (!Yap_growheap(FALSE, 0, NULL)) {
Yap_Error(OUT_OF_HEAP_ERROR, TermNil, "while initialisating profiler"); Yap_Error(OUT_OF_HEAP_ERROR, TermNil, "while initialisating profiler");
return FALSE; return FALSE;
@ -760,57 +771,16 @@ InitProfTree(void)
return TRUE; return TRUE;
} }
static void LookupNode(yamop *current_p) {
rb_red_blk_node *node;
if ((node = RBLookup(current_p))) {
node->pcs++;
return;
} else {
PredEntry *pp = NULL;
CODEADDR start, end;
pp = Yap_PredEntryForCode(current_p, FIND_PRED_FROM_ANYWHERE, &start, &end);
if (!pp) {
#if DEBUG
CACHE_REGS
fprintf(stderr,"lost %p, %d\n", P, Yap_op_from_opcode(P->opc));
#endif
/* lost profiler event !! */
return;
}
#if !USE_SYSTEM_MALLOC
/* add this clause as new node to the tree */
if (start < (CODEADDR)Yap_HeapBase || start > (CODEADDR)HeapTop ||
end < (CODEADDR)Yap_HeapBase || end > (CODEADDR)HeapTop) {
#if DEBUG
fprintf(stderr,"Oops2: %p->%lu %p, %p\n", current_p, (unsigned long int)(current_p->opc), start, end);
#endif
return;
}
#endif
if (pp->ArityOfPE > 100) {
#if DEBUG
fprintf(stderr,"%p(%lu)-->%p\n",current_p,(unsigned long int)Yap_op_from_opcode(current_p->opc),pp);
#endif
return;
}
node = RBTreeInsert((yamop *)start, (yamop *)end);
node->pe = pp;
node->pcs = 1;
}
}
static void RemoveCode(CODEADDR clau) static void RemoveCode(CODEADDR clau)
{ {
rb_red_blk_node* x, *node; rb_red_blk_node* x, *node;
PredEntry *pp; PredEntry *pp;
UInt count; UInt count;
if (!GLOBAL_ProfilerRoot) return; if (!LOCAL_ProfilerRoot) return;
if (!(x = RBExactQuery((yamop *)clau))) { if (!(x = RBExactQuery((yamop *)clau))) {
/* send message */ /* send message */
GLOBAL_ProfOn = FALSE; LOCAL_ProfOn = FALSE;
return; return;
} }
pp = x->pe; pp = x->pe;
@ -823,93 +793,95 @@ static void RemoveCode(CODEADDR clau)
node->pe = pp; node->pe = pp;
node->pcs = count; node->pcs = count;
/* send message */ /* send message */
GLOBAL_ProfOn = FALSE; LOCAL_ProfOn = FALSE;
return; return;
} else { } else {
node->pcs += count; node->pcs += count;
} }
} }
#define MAX_LINE_SIZE 1024
static int static int
showprofres( USES_REGS1 ) { showprofres( USES_REGS1 ) {
char line[MAX_LINE_SIZE]; buf_ptr buf;
yamop *pr_beg, *pr_end;
PredEntry *pr_pp;
long int pr_count;
profend( PASS_REGS1 ); /* Make sure profiler has ended */ profend( PASS_REGS1 ); /* Make sure profiler has ended */
/* First part: Read information about predicates and store it on yap trail */ /* First part: Read information about predicates and store it on yap trail */
InitProfTree(); InitProfTree();
FProf=fopen(profile_names(PROFILING_FILE),"r"); LOCAL_ProfGCs=0;
if (FProf==NULL) { fclose(FProf); return FALSE; } LOCAL_ProfMallocs=0;
while (fgets(line, MAX_LINE_SIZE, FProf) != NULL) { LOCAL_ProfHGrows=0;
if (line[0] == '+') { LOCAL_ProfSGrows=0;
rb_red_blk_node *node; LOCAL_ProfIndexing=0;
sscanf(line+1,"%p %p %p %ld",&pr_beg,&pr_end,&pr_pp,&pr_count); LOCAL_FProf=fopen(profile_names(PROFILING_FILE),"r");
node = RBTreeInsert(pr_beg, pr_end); if (LOCAL_FProf==NULL) { fclose(LOCAL_FProf); return FALSE; }
node->pe = pr_pp; while (fread(&buf, sizeof(buf), 1, LOCAL_FProf)) {
node->pcs = 0; switch (buf.tag) {
} else if (line[0] == '-') { case '+':
sscanf(line+1,"%p",&pr_beg); {
RemoveCode((CODEADDR)pr_beg); rb_red_blk_node *node;
} else { buf_extra e;
rb_red_blk_node *node;
sscanf(line,"%p",&pr_beg); if (fread(&e,sizeof(buf_extra),1,LOCAL_FProf) == 0)
node = RBLookup(pr_beg); return FALSE;;
if (!node) { node = RBTreeInsert(buf.ptr, e.end);
node->pe = e.pe;
node->source = e.inf;
node->pcs = 0;
}
break;
case '?':
{
prolog_exec_mode md;
md = (prolog_exec_mode)buf.ptr;
if (md & GCMode) {
LOCAL_ProfGCs++;
} else if (md & MallocMode) {
LOCAL_ProfMallocs++;
} else if (md & GrowHeapMode) {
LOCAL_ProfHGrows++;
} else if (md & GrowStackMode) {
LOCAL_ProfSGrows++;
}
}
break;
case '-':
RemoveCode(buf.ptr);
break;
default:
{
rb_red_blk_node *node;
node = RBLookup(buf.ptr);
if (!node) {
#if DEBUG #if DEBUG
fprintf(stderr,"Oops: %p\n", pr_beg); fprintf(stderr,"Oops: %p\n", buf.ptr);
#endif #endif
} else { } else {
node->pcs++; switch(node->source) {
case GPROF_INDEX:
case GPROF_INDEX_EXPAND:
case GPROF_LU_INDEX:
case GPROF_STATIC_INDEX:
case GPROF_INIT_EXPAND:
case GPROF_INIT_LOG_UPD_CLAUSE:
case GPROF_NEW_LU_SWITCH:
case GPROF_NEW_STATIC_SWITCH:
case GPROF_NEW_EXPAND_BLOCK:
LOCAL_ProfIndexing++;
break;
default:
break;
}
node->pcs++;
}
} }
} }
} }
fclose(FProf); fclose(LOCAL_FProf);
if (GLOBAL_ProfCalls==0) if (LOCAL_ProfCalls==0)
return TRUE;
return TRUE;
}
static Int
p_test( USES_REGS1 ) {
char line[MAX_LINE_SIZE];
yamop *pr_beg, *pr_end;
PredEntry *pr_pp;
long int pr_count;
profend( PASS_REGS1 ); /* Make sure profiler has ended */
/* First part: Read information about predicates and store it on yap trail */
InitProfTree();
FProf=fopen("PROFILING_93920","r");
if (FProf==NULL) { fclose(FProf); return FALSE; }
while (fgets(line, MAX_LINE_SIZE, FProf) != NULL) {
if (line[0] == '+') {
rb_red_blk_node *node;
sscanf(line+1,"%p %p %p %ld",&pr_beg,&pr_end,&pr_pp,&pr_count);
node = RBTreeInsert(pr_beg, pr_end);
node->pe = pr_pp;
node->pcs = 0;
} else if (line[0] == '-') {
sscanf(line+1,"%p",&pr_beg);
RemoveCode((CODEADDR)pr_beg);
} else {
rb_red_blk_node *node = RBTreeInsert(pr_beg, pr_end);
node->pe = pr_pp;
node->pcs = 1;
}
}
fclose(FProf);
if (GLOBAL_ProfCalls==0)
return TRUE; return TRUE;
return TRUE; return TRUE;
} }
@ -922,44 +894,27 @@ static void
prof_alrm(int signo, siginfo_t *si, void *scv) prof_alrm(int signo, siginfo_t *si, void *scv)
{ {
CACHE_REGS CACHE_REGS
void * oldpc=(void *) CONTEXT_PC(scv); void * oldpc;
yamop *current_p; yamop *current_p;
buf_ptr b;
GLOBAL_ProfCalls++; LOCAL_ProfCalls++;
/* skip an interrupt */ /* skip an interrupt */
if (GLOBAL_ProfOn) { if (LOCAL_ProfOn) {
GLOBAL_ProfOns++; LOCAL_ProfOns++;
return; return;
} }
GLOBAL_ProfOn = TRUE; LOCAL_ProfOn = TRUE;
oldpc = (void *) CONTEXT_PC(scv);
if (LOCAL_PrologMode & TestMode) { if (LOCAL_PrologMode & TestMode) {
if (LOCAL_PrologMode & GCMode) {
GLOBAL_ProfGCs++;
GLOBAL_ProfOn = FALSE;
return;
}
if (LOCAL_PrologMode & MallocMode) {
GLOBAL_ProfMallocs++;
GLOBAL_ProfOn = FALSE;
return;
}
if (LOCAL_PrologMode & GrowHeapMode) {
GLOBAL_ProfHGrows++;
GLOBAL_ProfOn = FALSE;
return;
}
if (LOCAL_PrologMode & GrowStackMode) {
GLOBAL_ProfSGrows++;
GLOBAL_ProfOn = FALSE;
return;
}
b.tag = '?';
b.ptr= (void *)LOCAL_PrologMode;
fwrite(&b,sizeof(b),1,LOCAL_FPreds);
LOCAL_ProfOn = FALSE;
return;
} }
if (oldpc>(void *) &Yap_absmi && oldpc <= (void *) &Yap_absmiEND) { if (oldpc>(void *) &Yap_absmi && oldpc <= (void *) &Yap_absmiEND) {
CACHE_REGS CACHE_REGS
/* we are running emulator code */ /* we are running emulator code */
@ -988,34 +943,33 @@ prof_alrm(int signo, siginfo_t *si, void *scv)
#if DEBUG #if DEBUG
fprintf(stderr,"Oops: %p, %p\n", oldpc, current_p); fprintf(stderr,"Oops: %p, %p\n", oldpc, current_p);
#endif #endif
GLOBAL_ProfOn = FALSE; LOCAL_ProfOn = FALSE;
return; return;
} }
#endif #endif
if (Yap_OffLineProfiler) { b.tag = '.';
fprintf(FProf,"%p\n", current_p); b.ptr= current_p;
GLOBAL_ProfOn = FALSE; fwrite(&b,sizeof(b),1,LOCAL_FPreds);
return; LOCAL_ProfOn = FALSE;
}
LookupNode(current_p);
GLOBAL_ProfOn = FALSE;
} }
void void
Yap_InformOfRemoval(CODEADDR clau) Yap_InformOfRemoval(void *clau)
{ {
GLOBAL_ProfOn = TRUE; LOCAL_ProfOn = TRUE;
if (FPreds != NULL) { if (LOCAL_FPreds != NULL) {
/* just store info about what is going on */ /* just store info about what is going on */
fprintf(FPreds,"-%p\n",clau); buf_ptr b;
GLOBAL_ProfOn = FALSE;
b.tag = '-';
b.ptr= clau;
fwrite(&b,sizeof(b),1,LOCAL_FPreds);
LOCAL_ProfOn = FALSE;
return; return;
} }
RemoveCode(clau); LOCAL_ProfOn = FALSE;
GLOBAL_ProfOn = FALSE;
} }
static Int profend( USES_REGS1 ); static Int profend( USES_REGS1 );
@ -1025,25 +979,25 @@ profnode( USES_REGS1 ) {
Term t1 = Deref(ARG1), tleft, tright; Term t1 = Deref(ARG1), tleft, tright;
rb_red_blk_node *node; rb_red_blk_node *node;
if (!GLOBAL_ProfilerRoot) if (!LOCAL_ProfilerRoot)
return FALSE; return FALSE;
if (!(node = (rb_red_blk_node *)IntegerOfTerm(t1))) if (!(node = (rb_red_blk_node *)IntegerOfTerm(t1)))
node = GLOBAL_ProfilerRoot; node = LOCAL_ProfilerRoot;
/* /*
if (node->key) if (node->key)
fprintf(stderr,"%p: %p,%p,%d,%p(%d),%p,%p\n",node,node->key,node->lim,node->pcs,node->pe,node->pe->ArityOfPE,node->right,node->left); fprintf(stderr,"%p: %p,%p,%d,%p(%d),%p,%p\n",node,node->key,node->lim,node->pcs,node->pe,node->pe->ArityOfPE,node->right,node->left);
*/ */
if (node->left == GLOBAL_ProfilerNil) { if (node->left == LOCAL_ProfilerNil) {
tleft = TermNil; tleft = TermNil;
} else { } else {
tleft = MkIntegerTerm((Int)node->left); tleft = MkIntegerTerm((Int)node->left);
} }
if (node->left == GLOBAL_ProfilerNil) { if (node->left == LOCAL_ProfilerNil) {
tleft = TermNil; tleft = TermNil;
} else { } else {
tleft = MkIntegerTerm((Int)node->left); tleft = MkIntegerTerm((Int)node->left);
} }
if (node->right == GLOBAL_ProfilerNil) { if (node->right == LOCAL_ProfilerNil) {
tright = TermNil; tright = TermNil;
} else { } else {
tright = MkIntegerTerm((Int)node->right); tright = MkIntegerTerm((Int)node->right);
@ -1059,90 +1013,46 @@ profnode( USES_REGS1 ) {
static Int static Int
profglobs( USES_REGS1 ) { profglobs( USES_REGS1 ) {
return return
Yap_unify(ARG1,MkIntegerTerm(GLOBAL_ProfCalls)) && Yap_unify(ARG1,MkIntegerTerm(LOCAL_ProfCalls)) &&
Yap_unify(ARG2,MkIntegerTerm(GLOBAL_ProfGCs)) && Yap_unify(ARG2,MkIntegerTerm(LOCAL_ProfGCs)) &&
Yap_unify(ARG3,MkIntegerTerm(GLOBAL_ProfHGrows)) && Yap_unify(ARG3,MkIntegerTerm(LOCAL_ProfHGrows)) &&
Yap_unify(ARG4,MkIntegerTerm(GLOBAL_ProfSGrows)) && Yap_unify(ARG4,MkIntegerTerm(LOCAL_ProfSGrows)) &&
Yap_unify(ARG5,MkIntegerTerm(GLOBAL_ProfMallocs)) && Yap_unify(ARG5,MkIntegerTerm(LOCAL_ProfMallocs)) &&
Yap_unify(ARG6,MkIntegerTerm(GLOBAL_ProfOns)) ; Yap_unify(ARG6,MkIntegerTerm(LOCAL_ProfIndexing)) &&
Yap_unify(ARG7,MkIntegerTerm(LOCAL_ProfOns)) ;
} }
static Int static Int
do_profinit( USES_REGS1 ) do_profinit( USES_REGS1 )
{ {
if (Yap_OffLineProfiler) { // LOCAL_FPreds=fopen(profile_names(PROFPREDS_FILE),"w+");
// FPreds=fopen(profile_names(PROFPREDS_FILE),"w+"); // if (LOCAL_FPreds == NULL) return FALSE;
// if (FPreds == NULL) return FALSE; LOCAL_FProf=fopen(profile_names(PROFILING_FILE),"w+");
FProf=fopen(profile_names(PROFILING_FILE),"w+"); if (LOCAL_FProf==NULL) { fclose(LOCAL_FProf); return FALSE; }
if (FProf==NULL) { fclose(FProf); return FALSE; } LOCAL_FPreds = LOCAL_FProf;
FPreds = FProf;
Yap_dump_code_area_for_profiler(); Yap_dump_code_area_for_profiler();
} else {
InitProfTree();
}
return TRUE; return TRUE;
} }
static Int profinit( USES_REGS1 ) static Int profinit( USES_REGS1 )
{ {
if (ProfilerOn!=0) return (FALSE); if (LOCAL_ProfilerOn!=0) return (FALSE);
if (!do_profinit( PASS_REGS1 )) if (!do_profinit( PASS_REGS1 ))
return FALSE; return FALSE;
ProfilerOn = -1; /* Inited but not yet started */ LOCAL_ProfilerOn = -1; /* Inited but not yet started */
return(TRUE); return(TRUE);
} }
static Int profinit1( USES_REGS1 )
{
Term t = Deref(ARG1);
if (IsVarTerm(t)) {
if (Yap_OffLineProfiler)
Yap_unify(ARG1,MkAtomTerm(AtomOffline));
else
Yap_unify(ARG1,MkAtomTerm(AtomOnline));
} else if (IsAtomTerm(t)) {
char *name = RepAtom(AtomOfTerm(t))->StrOfAE;
if (!strcmp(name,"offline"))
Yap_OffLineProfiler = TRUE;
else if (!strcmp(name,"online"))
Yap_OffLineProfiler = FALSE;
else {
Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE,t,"profinit only allows offline,online");
return FALSE;
}
} else {
Yap_Error(TYPE_ERROR_ATOM,t,"profinit only allows offline,online");
return FALSE;
}
return profinit( PASS_REGS1 );
}
static Int proftype( USES_REGS1 )
{
if (Yap_OffLineProfiler)
return Yap_unify(ARG1,MkAtomTerm(AtomOffline));
else
return Yap_unify(ARG1,MkAtomTerm(AtomOnline));
}
static Int start_profilers(int msec) static Int start_profilers(int msec)
{ {
struct itimerval t; struct itimerval t;
struct sigaction sa; struct sigaction sa;
if (ProfilerOn!=-1) { if (LOCAL_ProfilerOn!=-1) {
if (Yap_OffLineProfiler) { return FALSE; /* have to go through profinit */
return FALSE; /* have to go through profinit */
} else {
CACHE_REGS
if (!do_profinit( PASS_REGS1 ))
return FALSE;
}
} }
sa.sa_sigaction=prof_alrm; sa.sa_sigaction=prof_alrm;
sigemptyset(&sa.sa_mask); sigemptyset(&sa.sa_mask);
@ -1156,15 +1066,15 @@ static Int start_profilers(int msec)
t.it_value.tv_usec=msec; t.it_value.tv_usec=msec;
setitimer(ITIMER_PROF,&t,NULL); setitimer(ITIMER_PROF,&t,NULL);
ProfilerOn = msec; LOCAL_ProfilerOn = msec;
return TRUE; return TRUE;
} }
static Int profoff( USES_REGS1 ) { static Int profoff( USES_REGS1 ) {
if (ProfilerOn>0) { if (LOCAL_ProfilerOn>0) {
setitimer(ITIMER_PROF,NULL,NULL); setitimer(ITIMER_PROF,NULL,NULL);
ProfilerOn = -1; LOCAL_ProfilerOn = -1;
return TRUE; return TRUE;
} }
return FALSE; return FALSE;
@ -1183,23 +1093,22 @@ static Int ProfOn0( USES_REGS1 ) {
} }
static Int profison( USES_REGS1 ) { static Int profison( USES_REGS1 ) {
return (ProfilerOn > 0); return (LOCAL_ProfilerOn > 0);
} }
static Int profalt( USES_REGS1 ) { static Int profalt( USES_REGS1 ) {
if (ProfilerOn==0) return(FALSE); if (LOCAL_ProfilerOn==0) return(FALSE);
if (ProfilerOn==-1) return ProfOn( PASS_REGS1 ); if (LOCAL_ProfilerOn==-1) return ProfOn( PASS_REGS1 );
return profoff( PASS_REGS1 ); return profoff( PASS_REGS1 );
} }
static Int profend( USES_REGS1 ) static Int profend( USES_REGS1 )
{ {
if (ProfilerOn==0) return(FALSE); if (LOCAL_ProfilerOn==0) return(FALSE);
profoff( PASS_REGS1 ); /* Make sure profiler is off */ profoff( PASS_REGS1 ); /* Make sure profiler is off */
ProfilerOn=0; LOCAL_ProfilerOn=0;
if (Yap_OffLineProfiler) { fclose(LOCAL_FProf);
fclose(FProf); LOCAL_FPreds = NULL;
}
return TRUE; return TRUE;
} }
@ -1249,23 +1158,19 @@ void
Yap_InitLowProf(void) Yap_InitLowProf(void)
{ {
#if LOW_PROF #if LOW_PROF
GLOBAL_ProfCalls = 0; LOCAL_ProfCalls = 0;
ProfilerOn = FALSE; LOCAL_ProfilerOn = FALSE;
Yap_OffLineProfiler = FALSE;
Yap_InitCPred("profinit",0, profinit, SafePredFlag); Yap_InitCPred("profinit",0, profinit, SafePredFlag);
Yap_InitCPred("profinit",1, profinit1, SafePredFlag);
Yap_InitCPred("$proftype",1, proftype, SafePredFlag);
Yap_InitCPred("profend" ,0, profend, SafePredFlag); Yap_InitCPred("profend" ,0, profend, SafePredFlag);
Yap_InitCPred("ProfOn" , 0, ProfOn0, SafePredFlag); Yap_InitCPred("profon" , 0, ProfOn0, SafePredFlag);
Yap_InitCPred("ProfOn" , 1, ProfOn, SafePredFlag);
Yap_InitCPred("profoff", 0, profoff, SafePredFlag); Yap_InitCPred("profoff", 0, profoff, SafePredFlag);
Yap_InitCPred("profalt", 0, profalt, SafePredFlag); Yap_InitCPred("profalt", 0, profalt, SafePredFlag);
Yap_InitCPred("$offline_showprofres", 0, profres0, SafePredFlag); Yap_InitCPred("$offline_showprofres", 0, profres0, SafePredFlag);
Yap_InitCPred("$profnode", 6, profnode, SafePredFlag); Yap_InitCPred("$profnode", 6, profnode, SafePredFlag);
Yap_InitCPred("$profglobs", 6, profglobs, SafePredFlag); Yap_InitCPred("$profglobs", 7, profglobs, SafePredFlag);
Yap_InitCPred("$profison",0 , profison, SafePredFlag); Yap_InitCPred("$profison",0 , profison, SafePredFlag);
Yap_InitCPred("$get_pred_pinfo", 4, getpredinfo, SafePredFlag); Yap_InitCPred("$get_pred_pinfo", 4, getpredinfo, SafePredFlag);
Yap_InitCPred("showprofres", 4, getpredinfo, SafePredFlag); Yap_InitCPred("showprofres", 4, getpredinfo, SafePredFlag);
Yap_InitCPred("prof_test", 0, p_test, 0);
#endif #endif
} }

27
C/index.c
View File

@ -1592,12 +1592,7 @@ emit_switch_space(UInt n, UInt item_size, struct intermediates *cint, CELL func_
cl->ClSize = sz; cl->ClSize = sz;
cl->ClPred = cint->CurrentPred; cl->ClPred = cint->CurrentPred;
/* insert into code chain */ /* insert into code chain */
#ifdef LOW_PROF Yap_inform_profiler_of_clause(cl, (CODEADDR)cl+sz, ap, GPROF_NEW_LU_SWITCH);
if (ProfilerOn &&
Yap_OffLineProfiler) {
Yap_inform_profiler_of_clause(cl->ClCode, (yamop*)((CODEADDR)cl+sz), ap, 1);
}
#endif /* LOW_PROF */
return cl->ClCode; return cl->ClCode;
} else { } else {
UInt sz = sizeof(StaticIndex)+n*item_size; UInt sz = sizeof(StaticIndex)+n*item_size;
@ -1612,12 +1607,7 @@ emit_switch_space(UInt n, UInt item_size, struct intermediates *cint, CELL func_
cl->ClFlags = SwitchTableMask; cl->ClFlags = SwitchTableMask;
cl->ClSize = sz; cl->ClSize = sz;
cl->ClPred = cint->CurrentPred; cl->ClPred = cint->CurrentPred;
#ifdef LOW_PROF Yap_inform_profiler_of_clause(cl, (CODEADDR)cl+sz, ap, GPROF_NEW_STATIC_SWITCH);
if (ProfilerOn &&
Yap_OffLineProfiler) {
Yap_inform_profiler_of_clause(cl->ClCode, (yamop*)((CODEADDR)cl+sz), ap, 1);
}
#endif /* LOW_PROF */
return cl->ClCode; return cl->ClCode;
/* insert into code chain */ /* insert into code chain */
} }
@ -1933,12 +1923,7 @@ suspend_indexing(ClauseDef *min, ClauseDef *max, PredEntry *ap, struct intermedi
} else { } else {
Yap_IndexSpace_EXT += sz; Yap_IndexSpace_EXT += sz;
} }
#ifdef LOW_PROF Yap_inform_profiler_of_clause(ncode, (CODEADDR)ncode+sz, ap, GPROF_NEW_EXPAND_BLOCK);
if (ProfilerOn &&
Yap_OffLineProfiler) {
Yap_inform_profiler_of_clause(ncode, NEXTOP(ncode,sssllp), ap, 1);
}
#endif /* LOW_PROF */
/* create an expand_block */ /* create an expand_block */
ncode->opc = Yap_opcode(_expand_clauses); ncode->opc = Yap_opcode(_expand_clauses);
ncode->u.sssllp.p = ap; ncode->u.sssllp.p = ap;
@ -1991,7 +1976,7 @@ recover_ecls_block(yamop *ipc)
Yap_expand_clauses_sz -= (UInt)(NEXTOP((yamop *)NULL,sssllp))+ipc->u.sssllp.s1*sizeof(yamop *); Yap_expand_clauses_sz -= (UInt)(NEXTOP((yamop *)NULL,sssllp))+ipc->u.sssllp.s1*sizeof(yamop *);
#endif #endif
/* no dangling pointers for gprof */ /* no dangling pointers for gprof */
Yap_InformOfRemoval((CODEADDR)ipc); Yap_InformOfRemoval(ipc);
if (ipc->u.sssllp.p->PredFlags & LogUpdatePredFlag) { if (ipc->u.sssllp.p->PredFlags & LogUpdatePredFlag) {
Yap_LUIndexSpace_EXT -= (UInt)NEXTOP((yamop *)NULL,sssllp)+ipc->u.sssllp.s1*sizeof(yamop *); Yap_LUIndexSpace_EXT -= (UInt)NEXTOP((yamop *)NULL,sssllp)+ipc->u.sssllp.s1*sizeof(yamop *);
} else } else
@ -4259,7 +4244,7 @@ replace_index_block(ClauseUnion *parent_block, yamop *cod, yamop *ncod, PredEntr
c->ParentIndex = ncl; c->ParentIndex = ncl;
c = c->SiblingIndex; c = c->SiblingIndex;
} }
Yap_InformOfRemoval((CODEADDR)cl); Yap_InformOfRemoval(cl);
Yap_LUIndexSpace_SW -= cl->ClSize; Yap_LUIndexSpace_SW -= cl->ClSize;
Yap_FreeCodeSpace((char *)cl); Yap_FreeCodeSpace((char *)cl);
} else { } else {
@ -4277,7 +4262,7 @@ replace_index_block(ClauseUnion *parent_block, yamop *cod, yamop *ncod, PredEntr
} }
c->SiblingIndex = ncl; c->SiblingIndex = ncl;
} }
Yap_InformOfRemoval((CODEADDR)cl); Yap_InformOfRemoval(cl);
Yap_IndexSpace_SW -= cl->ClSize; Yap_IndexSpace_SW -= cl->ClSize;
Yap_FreeCodeSpace((char *)cl); Yap_FreeCodeSpace((char *)cl);
} }

27
H/Yap.h
View File

@ -503,6 +503,33 @@ typedef enum
#define NUMBER_OF_YAP_FLAGS LAST_FLAG #define NUMBER_OF_YAP_FLAGS LAST_FLAG
typedef enum
{
GPROF_NO_EVENT,
GPROF_NEW_PRED_FUNC,
GPROF_NEW_PRED_THREAD,
GPROF_NEW_PRED_ATOM,
GPROF_INDEX,
GPROF_INDEX_EXPAND,
GPROF_CLAUSE,
GPROF_MEGA,
GPROF_LU_INDEX,
GPROF_STATIC_INDEX,
GPROF_INIT_OPCODE,
GPROF_INIT_SYSTEM_CODE,
GPROF_INIT_EXPAND,
GPROF_INIT_LOG_UPD_CLAUSE,
GPROF_INIT_DYNAMIC_CLAUSE,
GPROF_INIT_STATIC_CLAUSE,
GPROF_INIT_COMMA,
GPROF_INIT_FAIL,
GPROF_NEW_LU_CLAUSE,
GPROF_NEW_LU_SWITCH,
GPROF_NEW_STATIC_SWITCH,
GPROF_NEW_EXPAND_BLOCK
} gprof_info;
/************************************************************************************************* /*************************************************************************************************
prototypes prototypes
*************************************************************************************************/ *************************************************************************************************/

6
H/Yapproto.h
View File

@ -185,10 +185,12 @@ Term STD_PROTO(Yap_GetException,(void));
/* gprof.c */ /* gprof.c */
void STD_PROTO(Yap_InitLowProf,(void)); void STD_PROTO(Yap_InitLowProf,(void));
#if LOW_PROF #if LOW_PROF
void STD_PROTO(Yap_inform_profiler_of_clause,(struct yami *,struct yami *,struct pred_entry *,int)); void STD_PROTO(Yap_inform_profiler_of_clause__,(void *,void *,struct pred_entry *, gprof_info));
#define Yap_inform_profiler_of_clause(CODE0,CODEF,AP,MODE) {if (LOCAL_FPreds) Yap_inform_profiler_of_clause__(CODE0,CODEF,AP,MODE);}
#else #else
#define Yap_inform_profiler_of_clause(A,B,C,D) #define Yap_inform_profiler_of_clause(CODE0,CODEF,AP,MODE)
#endif #endif
void STD_PROTO(Yap_tell_gprof,(yamop *));
/* globals.c */ /* globals.c */
Term STD_PROTO(Yap_NewArena,(UInt,CELL *)); Term STD_PROTO(Yap_NewArena,(UInt,CELL *));

1
H/absmi.h
View File

@ -1596,3 +1596,4 @@ void SET_ASP__(CELL *yreg, Int sz USES_REGS) {
} }
#define CHECK_ALARM(CONT)

2
H/clause.h
View File

@ -339,7 +339,7 @@ void STD_PROTO(Yap_bug_location,(yamop *));
#endif #endif
#if LOW_PROF #if LOW_PROF
void STD_PROTO(Yap_InformOfRemoval,(CODEADDR)); void STD_PROTO(Yap_InformOfRemoval,(void *));
void STD_PROTO(Yap_dump_code_area_for_profiler,(void)); void STD_PROTO(Yap_dump_code_area_for_profiler,(void));
#else #else
#define Yap_InformOfRemoval(X) #define Yap_InformOfRemoval(X)

11
H/dglobals.h
View File

@ -87,17 +87,6 @@
#endif #endif
#define GLOBAL_ProfCalls Yap_global->ProfCalls_
#define GLOBAL_ProfGCs Yap_global->ProfGCs_
#define GLOBAL_ProfHGrows Yap_global->ProfHGrows_
#define GLOBAL_ProfSGrows Yap_global->ProfSGrows_
#define GLOBAL_ProfMallocs Yap_global->ProfMallocs_
#define GLOBAL_ProfOn Yap_global->ProfOn_
#define GLOBAL_ProfOns Yap_global->ProfOns_
#define GLOBAL_ProfilerRoot Yap_global->ProfilerRoot_
#define GLOBAL_ProfilerNil Yap_global->ProfilerNil_
#define GLOBAL_DIRNAME Yap_global->DIRNAME_
#if defined(COFF) || defined(A_OUT) #if defined(COFF) || defined(A_OUT)
#define GLOBAL_Executable Yap_global->Executable_ #define GLOBAL_Executable Yap_global->Executable_

9
H/dhstruct.h
View File

@ -283,15 +283,6 @@
#define LastWtimePtr Yap_heap_regs->last_wtime #define LastWtimePtr Yap_heap_regs->last_wtime
#define output_msg Yap_heap_regs->debugger_output_msg
#if LOW_PROF
#define ProfilerOn Yap_heap_regs->profiler_on
#define Yap_OffLineProfiler Yap_heap_regs->offline_profiler
#define FProf Yap_heap_regs->f_prof
#define FPreds Yap_heap_regs->f_preds
#define ProfPreds Yap_heap_regs->prof_preds
#endif /* LOW_PROF */
#define ForeignCodeLoaded Yap_heap_regs->foreign_code_loaded #define ForeignCodeLoaded Yap_heap_regs->foreign_code_loaded
#define ForeignCodeBase Yap_heap_regs->foreign_code_base #define ForeignCodeBase Yap_heap_regs->foreign_code_base
#define ForeignCodeTop Yap_heap_regs->foreign_code_top #define ForeignCodeTop Yap_heap_regs->foreign_code_top

31
H/dlocals.h
View File

@ -397,3 +397,34 @@
#define LOCAL_ImportFAILCODE LOCAL->ImportFAILCODE_ #define LOCAL_ImportFAILCODE LOCAL->ImportFAILCODE_
#define REMOTE_ImportFAILCODE(wid) REMOTE(wid)->ImportFAILCODE_ #define REMOTE_ImportFAILCODE(wid) REMOTE(wid)->ImportFAILCODE_
#define LOCAL_ProfCalls LOCAL->ProfCalls_
#define REMOTE_ProfCalls(wid) REMOTE(wid)->ProfCalls_
#define LOCAL_ProfGCs LOCAL->ProfGCs_
#define REMOTE_ProfGCs(wid) REMOTE(wid)->ProfGCs_
#define LOCAL_ProfHGrows LOCAL->ProfHGrows_
#define REMOTE_ProfHGrows(wid) REMOTE(wid)->ProfHGrows_
#define LOCAL_ProfSGrows LOCAL->ProfSGrows_
#define REMOTE_ProfSGrows(wid) REMOTE(wid)->ProfSGrows_
#define LOCAL_ProfMallocs LOCAL->ProfMallocs_
#define REMOTE_ProfMallocs(wid) REMOTE(wid)->ProfMallocs_
#define LOCAL_ProfIndexing LOCAL->ProfIndexing_
#define REMOTE_ProfIndexing(wid) REMOTE(wid)->ProfIndexing_
#define LOCAL_ProfOn LOCAL->ProfOn_
#define REMOTE_ProfOn(wid) REMOTE(wid)->ProfOn_
#define LOCAL_ProfOns LOCAL->ProfOns_
#define REMOTE_ProfOns(wid) REMOTE(wid)->ProfOns_
#define LOCAL_ProfilerRoot LOCAL->ProfilerRoot_
#define REMOTE_ProfilerRoot(wid) REMOTE(wid)->ProfilerRoot_
#define LOCAL_ProfilerNil LOCAL->ProfilerNil_
#define REMOTE_ProfilerNil(wid) REMOTE(wid)->ProfilerNil_
#define LOCAL_DIRNAME LOCAL->DIRNAME_
#define REMOTE_DIRNAME(wid) REMOTE(wid)->DIRNAME_
#if LOW_PROF
#define LOCAL_ProfilerOn LOCAL->ProfilerOn_
#define REMOTE_ProfilerOn(wid) REMOTE(wid)->ProfilerOn_
#define LOCAL_FProf LOCAL->FProf_
#define REMOTE_FProf(wid) REMOTE(wid)->FProf_
#define LOCAL_FPreds LOCAL->FPreds_
#define REMOTE_FPreds(wid) REMOTE(wid)->FPreds_
#endif /* LOW_PROF */

11
H/hglobals.h
View File

@ -87,17 +87,6 @@ typedef struct global_data {
#endif #endif
Int ProfCalls_;
Int ProfGCs_;
Int ProfHGrows_;
Int ProfSGrows_;
Int ProfMallocs_;
Int ProfOn_;
Int ProfOns_;
struct RB_red_blk_node* ProfilerRoot_;
struct RB_red_blk_node* ProfilerNil_;
char* DIRNAME_;
#if defined(COFF) || defined(A_OUT) #if defined(COFF) || defined(A_OUT)
char Executable_[YAP_FILENAME_MAX]; char Executable_[YAP_FILENAME_MAX];

17
H/hlocals.h
View File

@ -223,4 +223,21 @@ typedef struct worker_local {
UInt ImportDBRefHashTableSize_; UInt ImportDBRefHashTableSize_;
UInt ImportDBRefHashTableNum_; UInt ImportDBRefHashTableNum_;
yamop *ImportFAILCODE_; yamop *ImportFAILCODE_;
Int ProfCalls_;
Int ProfGCs_;
Int ProfHGrows_;
Int ProfSGrows_;
Int ProfMallocs_;
Int ProfIndexing_;
Int ProfOn_;
Int ProfOns_;
struct RB_red_blk_node* ProfilerRoot_;
struct RB_red_blk_node* ProfilerNil_;
char* DIRNAME_;
#if LOW_PROF
int ProfilerOn_;
FILE* FProf_;
FILE* FPreds_;
#endif /* LOW_PROF */
} w_local; } w_local;

9
H/hstruct.h
View File

@ -283,15 +283,6 @@
void *last_wtime; void *last_wtime;
int debugger_output_msg;
#if LOW_PROF
int profiler_on;
int offline_profiler;
FILE *f_prof;
FILE *f_preds;
UInt prof_preds;
#endif /* LOW_PROF */
struct ForeignLoadItem *foreign_code_loaded; struct ForeignLoadItem *foreign_code_loaded;
ADDR foreign_code_base; ADDR foreign_code_base;
ADDR foreign_code_top; ADDR foreign_code_top;

11
H/iglobals.h
View File

@ -87,17 +87,6 @@ static void InitGlobal(void) {
#endif #endif
GLOBAL_DIRNAME = NULL;
#if defined(COFF) || defined(A_OUT) #if defined(COFF) || defined(A_OUT)

9
H/ihstruct.h
View File

@ -283,15 +283,6 @@
LastWtimePtr = NULL; LastWtimePtr = NULL;
output_msg = 0L;
#if LOW_PROF
ProfilerOn = FALSE;
Yap_OffLineProfiler = FALSE;
FProf = NULL;
FPreds = NULL;
ProfPreds = 0L;
#endif /* LOW_PROF */
ForeignCodeLoaded = NULL; ForeignCodeLoaded = NULL;
ForeignCodeBase = NULL; ForeignCodeBase = NULL;
ForeignCodeTop = NULL; ForeignCodeTop = NULL;

17
H/ilocals.h
View File

@ -223,4 +223,21 @@ static void InitWorker(int wid) {
REMOTE_ImportDBRefHashTableSize(wid) = 0; REMOTE_ImportDBRefHashTableSize(wid) = 0;
REMOTE_ImportDBRefHashTableNum(wid) = 0; REMOTE_ImportDBRefHashTableNum(wid) = 0;
REMOTE_ImportFAILCODE(wid) = NULL; REMOTE_ImportFAILCODE(wid) = NULL;
REMOTE_DIRNAME(wid) = NULL;
#if LOW_PROF
REMOTE_ProfilerOn(wid) = FALSE;
REMOTE_FProf(wid) = NULL;
REMOTE_FPreds(wid) = NULL;
#endif /* LOW_PROF */
} }

11
H/rglobals.h
View File

@ -87,17 +87,6 @@ static void RestoreGlobal(void) {
#endif #endif
#if defined(COFF) || defined(A_OUT) #if defined(COFF) || defined(A_OUT)

9
H/rhstruct.h
View File

@ -283,15 +283,6 @@
LastWtimePtr = CodeVoidPAdjust(LastWtimePtr); LastWtimePtr = CodeVoidPAdjust(LastWtimePtr);
#if LOW_PROF
#endif /* LOW_PROF */
RestoreForeignCode(); RestoreForeignCode();

17
H/rlocals.h
View File

@ -223,4 +223,21 @@ static void RestoreWorker(int wid USES_REGS) {
#if LOW_PROF
#endif /* LOW_PROF */
} }

12
misc/GLOBALS
View File

@ -103,18 +103,6 @@ YP_FILE* logfile void
//int output_msg =FALSE //int output_msg =FALSE
#endif #endif
//gprof.c
Int ProfCalls void
Int ProfGCs void
Int ProfHGrows void
Int ProfSGrows void
Int ProfMallocs void
Int ProfOn void
Int ProfOns void
struct RB_red_blk_node* ProfilerRoot void
struct RB_red_blk_node* ProfilerNil void
char* DIRNAME =NULL
#if defined(COFF) || defined(A_OUT) #if defined(COFF) || defined(A_OUT)
// loada_coff.c && load_aout.c // loada_coff.c && load_aout.c
char Executable[YAP_FILENAME_MAX] void char Executable[YAP_FILENAME_MAX] void

10
misc/HEAPFIELDS
View File

@ -321,16 +321,6 @@ char *yap_lib_dir Yap_LibDir =NULL CodeCharPAdjust
/* time */ /* time */
void *last_wtime LastWtimePtr =NULL CodeVoidPAdjust void *last_wtime LastWtimePtr =NULL CodeVoidPAdjust
/* profiling */
int debugger_output_msg output_msg =0L void
#if LOW_PROF
int profiler_on ProfilerOn =FALSE void
int offline_profiler Yap_OffLineProfiler =FALSE void
FILE *f_prof FProf =NULL void
FILE *f_preds FPreds =NULL void
UInt prof_preds ProfPreds =0L void
#endif /* LOW_PROF */
/* foreign code loaded */ /* foreign code loaded */
struct ForeignLoadItem *foreign_code_loaded ForeignCodeLoaded =NULL RestoreForeignCode() struct ForeignLoadItem *foreign_code_loaded ForeignCodeLoaded =NULL RestoreForeignCode()
ADDR foreign_code_base ForeignCodeBase =NULL void ADDR foreign_code_base ForeignCodeBase =NULL void

18
misc/LOCALS
View File

@ -251,4 +251,22 @@ UInt ImportDBRefHashTableSize =0
UInt ImportDBRefHashTableNum =0 UInt ImportDBRefHashTableNum =0
yamop *ImportFAILCODE =NULL yamop *ImportFAILCODE =NULL
//gprof.c
Int ProfCalls void
Int ProfGCs void
Int ProfHGrows void
Int ProfSGrows void
Int ProfMallocs void
Int ProfIndexing void
Int ProfOn void
Int ProfOns void
struct RB_red_blk_node* ProfilerRoot void
struct RB_red_blk_node* ProfilerNil void
char* DIRNAME =NULL
#if LOW_PROF
int ProfilerOn =FALSE
FILE* FProf =NULL
FILE* FPreds =NULL
#endif /* LOW_PROF */
END_WORKER_LOCAL END_WORKER_LOCAL

8
pl/profile.yap
View File

@ -68,9 +68,9 @@ showprofres :-
showprofres(-1). showprofres(-1).
showprofres(A) :- showprofres(A) :-
('$proftype'(offline) -> '$offline_showprofres' ; true), '$offline_showprofres',
('$profison' -> profoff, Stop = true ; Stop = false), ('$profison' -> profoff, Stop = true ; Stop = false),
'$profglobs'(Tot,GCs,HGrows,SGrows,Mallocs,ProfOns), '$profglobs'(Tot,GCs,HGrows,SGrows,Mallocs,_Indexing,ProfOns),
% root node has no useful info. % root node has no useful info.
'$get_all_profinfo'(0,[],ProfInfo0,0,_TotCode), '$get_all_profinfo'(0,[],ProfInfo0,0,_TotCode),
msort(ProfInfo0,ProfInfo), msort(ProfInfo0,ProfInfo),
@ -84,6 +84,7 @@ showprofres(A) :-
; ;
format(user_error,'~d ticks, ~d accounted for (~d overhead)~n',[Tot,Accounted,ProfOns]) format(user_error,'~d ticks, ~d accounted for (~d overhead)~n',[Tot,Accounted,ProfOns])
), ),
% format(user_error,' ~d ticks in indexing code~n',[Indexing]),
A1 is A+1, A1 is A+1,
'$display_preds'(Preds, Tot, 0, 1, A1), '$display_preds'(Preds, Tot, 0, 1, A1),
(Stop = true -> profon ; true). (Stop = true -> profon ; true).
@ -123,10 +124,11 @@ showprofres(A) :-
'$display_preds'(_, _, _, N, N) :- !. '$display_preds'(_, _, _, N, N) :- !.
'$display_preds'([], _, _, _, _). '$display_preds'([], _, _, _, _).
'$display_preds'([0-_|_], _Tot, _SoFar, _I, N) :- !.
'$display_preds'([NSum-P|Ps], Tot, SoFar, I, N) :- '$display_preds'([NSum-P|Ps], Tot, SoFar, I, N) :-
Sum is -NSum, Sum is -NSum,
Perc is (100*Sum)/Tot, Perc is (100*Sum)/Tot,
Next is SoFar+Sum, Next is SoFar+Sum,
NextP is (100*Next)/Tot, NextP is (100*Next)/Tot,
( ( P = M:F/A -> ( ( P = M:F/A ->
G = M:H G = M:H