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

solaris fixes for threads

Browse Source 
get rid of SizeOfBlock


git-svn-id: https://yap.svn.sf.net/svnroot/yap/trunk@1018 b08c6af1-5177-4d33-ba66-4b1c6b8b522a
This commit is contained in:
vsc 2004-03-05 15:26:33 +00:00
parent 69f6496e7e
commit caa0b26665
14 changed files with 111 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
C/agc.c
View File

@ -326,7 +326,7 @@ clean_atoms(void)
#endif #endif
*patm = at->NextOfAE; *patm = at->NextOfAE;
atm = at->NextOfAE; atm = at->NextOfAE;
agc_collected += Yap_SizeOfBlock((CODEADDR)at); agc_collected += sizeof(AtomEntry)+strlen(at->StrOfAE);
Yap_FreeCodeSpace((char *)at); Yap_FreeCodeSpace((char *)at);
} }
} }
@ -346,7 +346,7 @@ clean_atoms(void)
#endif #endif
*patm = at->NextOfAE; *patm = at->NextOfAE;
atm = at->NextOfAE; atm = at->NextOfAE;
agc_collected += Yap_SizeOfBlock((CODEADDR)at); agc_collected += sizeof(AtomEntry) + strlen(at->StrOfAE);
Yap_FreeCodeSpace((char *)at); Yap_FreeCodeSpace((char *)at);
} }
} }

30
C/alloc.c
View File

@ -12,7 +12,7 @@
* Last rev: * * Last rev: *
* mods: * * mods: *
* comments: allocating space * * comments: allocating space *
* version:$Id: alloc.c,v 1.47 2004-02-20 18:56:06 vsc Exp $ * * version:$Id: alloc.c,v 1.48 2004-03-05 15:26:32 vsc Exp $ *
*************************************************************************/ *************************************************************************/
#ifdef SCCS #ifdef SCCS
static char SccsId[] = "%W% %G%"; static char SccsId[] = "%W% %G%";
@ -56,40 +56,28 @@ static char SccsId[] = "%W% %G%";
#if USE_SYSTEM_MALLOC #if USE_SYSTEM_MALLOC
int
Yap_SizeOfBlock(CODEADDR p)
{
return ((UInt *)p)[-1];
}
char * char *
Yap_AllocCodeSpace(unsigned int size) Yap_AllocCodeSpace(unsigned int size)
{ {
char *ptr = malloc(size+sizeof(UInt)); return malloc(size);
UInt *pi = (UInt *)ptr;
pi[0] = size;
return (char *)(pi+1);
} }
void void
Yap_FreeCodeSpace(char *p) Yap_FreeCodeSpace(char *p)
{ {
free (p-sizeof(UInt)); free (p);
} }
char * char *
Yap_AllocAtomSpace(unsigned int size) Yap_AllocAtomSpace(unsigned int size)
{ {
char *ptr = malloc(size+sizeof(UInt)); return malloc(size);
UInt *pi = (UInt *)ptr;
pi[0] = size;
return (char *)(pi+1);
} }
void void
Yap_FreeAtomSpace(char *p) Yap_FreeAtomSpace(char *p)
{ {
free (p-sizeof(UInt)); free (p);
} }
/* If you need to dinamically allocate space from the heap, this is /* If you need to dinamically allocate space from the heap, this is
@ -259,14 +247,6 @@ STATIC_PROTO(void AddToFreeList, (BlockHeader *));
#define MinHGap 256*K #define MinHGap 256*K
int
Yap_SizeOfBlock(CODEADDR p)
{
BlockHeader *b = (BlockHeader *) (p - sizeof(YAP_SEG_SIZE));
YAP_SEG_SIZE s = (b->b_size) & ~InUseFlag;
return ((s - 1) * sizeof(YAP_SEG_SIZE));
}
static void static void
RemoveFromFreeList(BlockHeader *b) RemoveFromFreeList(BlockHeader *b)
{ {

17
C/amasm.c
View File

@ -99,7 +99,7 @@ STATIC_PROTO(yamop *a_xigl, (op_numbers, yamop *, int, struct PSEUDO *));
STATIC_PROTO(yamop *a_ucons, (int *, compiler_vm_op, yamop *, int, struct intermediates *)); STATIC_PROTO(yamop *a_ucons, (int *, compiler_vm_op, yamop *, int, struct intermediates *));
STATIC_PROTO(yamop *a_uvar, (yamop *, int, struct intermediates *)); STATIC_PROTO(yamop *a_uvar, (yamop *, int, struct intermediates *));
STATIC_PROTO(yamop *a_wvar, (yamop *, int, struct intermediates *)); STATIC_PROTO(yamop *a_wvar, (yamop *, int, struct intermediates *));
STATIC_PROTO(yamop *do_pass, (int, yamop **, int, int *, struct intermediates *)); STATIC_PROTO(yamop *do_pass, (int, yamop **, int, int *, struct intermediates *, UInt));
#ifdef DEBUG_OPCODES #ifdef DEBUG_OPCODES
STATIC_PROTO(void DumpOpCodes, (void)); STATIC_PROTO(void DumpOpCodes, (void));
#endif #endif
@ -2075,7 +2075,7 @@ a_f2(int var, cmp_op_info *cmp_info, yamop *code_p, int pass_no, struct intermed
#endif /* YAPOR */ #endif /* YAPOR */
static yamop * static yamop *
do_pass(int pass_no, yamop **entry_codep, int assembling, int *clause_has_blobsp, struct intermediates *cip) do_pass(int pass_no, yamop **entry_codep, int assembling, int *clause_has_blobsp, struct intermediates *cip, UInt size)
{ {
#ifdef YAPOR #ifdef YAPOR
#define EITHER_INST 50 #define EITHER_INST 50
@ -2117,6 +2117,7 @@ do_pass(int pass_no, yamop **entry_codep, int assembling, int *clause_has_blobsp
cl_u->luc.ClFlags = LogUpdMask; cl_u->luc.ClFlags = LogUpdMask;
cl_u->luc.ClRefCount = 0; cl_u->luc.ClRefCount = 0;
cl_u->luc.ClPred = cip->CurrentPred; cl_u->luc.ClPred = cip->CurrentPred;
cl_u->luc.ClSize = size;
if (*clause_has_blobsp) { if (*clause_has_blobsp) {
cl_u->luc.ClFlags |= HasBlobsMask; cl_u->luc.ClFlags |= HasBlobsMask;
} }
@ -2134,6 +2135,7 @@ do_pass(int pass_no, yamop **entry_codep, int assembling, int *clause_has_blobsp
if (*clause_has_blobsp) { if (*clause_has_blobsp) {
cl_u->ic.ClFlags |= HasBlobsMask; cl_u->ic.ClFlags |= HasBlobsMask;
} }
cl_u->ic.ClSize = size;
cl_u->ic.ClRefCount = 0; cl_u->ic.ClRefCount = 0;
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
INIT_LOCK(cl_u->ic.ClLock); INIT_LOCK(cl_u->ic.ClLock);
@ -2147,6 +2149,7 @@ do_pass(int pass_no, yamop **entry_codep, int assembling, int *clause_has_blobsp
cl_u->sc.Id = FunctorDBRef; cl_u->sc.Id = FunctorDBRef;
cl_u->sc.ClFlags = StaticMask; cl_u->sc.ClFlags = StaticMask;
cl_u->sc.ClNext = NULL; cl_u->sc.ClNext = NULL;
cl_u->sc.ClSize = size;
if (*clause_has_blobsp) { if (*clause_has_blobsp) {
cl_u->sc.ClFlags |= HasBlobsMask; cl_u->sc.ClFlags |= HasBlobsMask;
} }
@ -2170,6 +2173,7 @@ do_pass(int pass_no, yamop **entry_codep, int assembling, int *clause_has_blobsp
cl_u->lui.ChildIndex = NULL; cl_u->lui.ChildIndex = NULL;
cl_u->lui.SiblingIndex = NULL; cl_u->lui.SiblingIndex = NULL;
cl_u->lui.u.pred = cip->CurrentPred; cl_u->lui.u.pred = cip->CurrentPred;
cl_u->lui.ClSize = size;
cl_u->lui.ClRefCount = 0; cl_u->lui.ClRefCount = 0;
INIT_LOCK(cl_u->lui.ClLock); INIT_LOCK(cl_u->lui.ClLock);
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
@ -2190,6 +2194,7 @@ do_pass(int pass_no, yamop **entry_codep, int assembling, int *clause_has_blobsp
#endif #endif
} else { } else {
if (pass_no) { if (pass_no) {
cl_u->si.ClSize = size;
cl_u->si.ClFlags = IndexMask; cl_u->si.ClFlags = IndexMask;
cl_u->si.ChildIndex = NULL; cl_u->si.ChildIndex = NULL;
cl_u->si.SiblingIndex = NULL; cl_u->si.SiblingIndex = NULL;
@ -2766,14 +2771,14 @@ Yap_assemble(int mode, Term t, PredEntry *ap, int is_fact, struct intermediates
* computes labels offsets and total code size 2 - the second pass * computes labels offsets and total code size 2 - the second pass
* produces the final version of the code * produces the final version of the code
*/ */
CELL size; UInt size = 0;
yamop *entry_code; yamop *entry_code;
yamop *code_p; yamop *code_p;
int clause_has_blobs = FALSE; int clause_has_blobs = FALSE;
cip->label_offset = (int *)cip->freep; cip->label_offset = (int *)cip->freep;
cip->code_addr = NULL; cip->code_addr = NULL;
code_p = do_pass(0, &entry_code, mode, &clause_has_blobs, cip); code_p = do_pass(0, &entry_code, mode, &clause_has_blobs, cip, size);
size = size =
(CELL)NEXTOP(NEXTOP(NEXTOP((yamop *)(((DynamicClause *)NULL)->ClCode),ld),sla),e); (CELL)NEXTOP(NEXTOP(NEXTOP((yamop *)(((DynamicClause *)NULL)->ClCode),ld),sla),e);
if ((CELL)code_p > size) if ((CELL)code_p > size)
@ -2845,7 +2850,7 @@ Yap_assemble(int mode, Term t, PredEntry *ap, int is_fact, struct intermediates
H = h0; H = h0;
cl = (StaticClause *)((CODEADDR)x-(UInt)size); cl = (StaticClause *)((CODEADDR)x-(UInt)size);
cip->code_addr = (yamop *)cl; cip->code_addr = (yamop *)cl;
code_p = do_pass(1, &entry_code, mode, &clause_has_blobs, cip); code_p = do_pass(1, &entry_code, mode, &clause_has_blobs, cip, size);
/* make sure we copy after second pass */ /* make sure we copy after second pass */
cl->usc.ClSource = x; cl->usc.ClSource = x;
ProfEnd=code_p; ProfEnd=code_p;
@ -2858,7 +2863,7 @@ Yap_assemble(int mode, Term t, PredEntry *ap, int is_fact, struct intermediates
} }
} }
} }
code_p = do_pass(1, &entry_code, mode, &clause_has_blobs, cip); code_p = do_pass(1, &entry_code, mode, &clause_has_blobs, cip, size);
ProfEnd=code_p; ProfEnd=code_p;
return entry_code; return entry_code;
} }

2
C/c_interface.c
View File

@ -861,7 +861,6 @@ YAP_Init(YAP_init_args *yap_init)
{ {
int restore_result; int restore_result;
CELL Trail = 0, Stack = 0, Heap = 0; CELL Trail = 0, Stack = 0, Heap = 0;
BACKUP_MACHINE_REGS();
Yap_argv = yap_init->Argv; Yap_argv = yap_init->Argv;
Yap_argc = yap_init->Argc; Yap_argc = yap_init->Argc;
@ -895,6 +894,7 @@ YAP_Init(YAP_init_args *yap_init)
yap_init->DelayedReleaseLoad yap_init->DelayedReleaseLoad
); );
Yap_InitExStacks (Trail, Stack); Yap_InitExStacks (Trail, Stack);
BACKUP_MACHINE_REGS();
Yap_InitYaamRegs(); Yap_InitYaamRegs();
#if HAVE_MPI #if HAVE_MPI

54
C/cdmgr.c
View File

@ -383,7 +383,7 @@ decrease_log_indices(LogUpdIndex *c, yamop *suspend_code)
beg->u.Ill.l1 != beg->u.Ill.l2) { beg->u.Ill.l1 != beg->u.Ill.l2) {
end = beg->u.Ill.l2; end = beg->u.Ill.l2;
} else { } else {
end = (yamop *)((CODEADDR)c+Yap_SizeOfBlock((CODEADDR)c)); end = (yamop *)((CODEADDR)c+c->ClSize);
} }
ipc = beg; ipc = beg;
cleanup_dangling_indices(ipc, beg, end, suspend_code); cleanup_dangling_indices(ipc, beg, end, suspend_code);
@ -668,8 +668,10 @@ retract_all(PredEntry *p, int in_use)
do { do {
if (cl->ClFlags & HasBlobsMask) { if (cl->ClFlags & HasBlobsMask) {
DeadClause *dcl = (DeadClause *)cl; DeadClause *dcl = (DeadClause *)cl;
UInt sz = cl->ClSize;
dcl->NextCl = DeadClauses; dcl->NextCl = DeadClauses;
dcl->ClFlags = 0; dcl->ClFlags = 0;
dcl->ClSize = sz;
DeadClauses = dcl; DeadClauses = dcl;
} else { } else {
Yap_FreeCodeSpace((char *)cl); Yap_FreeCodeSpace((char *)cl);
@ -1289,8 +1291,10 @@ Yap_EraseStaticClause(StaticClause *cl, Term mod) {
WRITE_UNLOCK(ap->PRWLock); WRITE_UNLOCK(ap->PRWLock);
if (cl->ClFlags & HasBlobsMask || static_in_use(ap,TRUE)) { if (cl->ClFlags & HasBlobsMask || static_in_use(ap,TRUE)) {
DeadClause *dcl = (DeadClause *)cl; DeadClause *dcl = (DeadClause *)cl;
UInt sz = cl->ClSize;
dcl->NextCl = DeadClauses; dcl->NextCl = DeadClauses;
dcl->ClFlags = 0; dcl->ClFlags = 0;
dcl->ClSize = sz;
DeadClauses = dcl; DeadClauses = dcl;
} else { } else {
Yap_FreeCodeSpace((char *)cl); Yap_FreeCodeSpace((char *)cl);
@ -1631,8 +1635,10 @@ purge_clauses(PredEntry *pred)
do { do {
if (cl->ClFlags & HasBlobsMask || in_use) { if (cl->ClFlags & HasBlobsMask || in_use) {
DeadClause *dcl = (DeadClause *)cl; DeadClause *dcl = (DeadClause *)cl;
UInt sz = cl->ClSize;
dcl->NextCl = DeadClauses; dcl->NextCl = DeadClauses;
dcl->ClFlags = 0; dcl->ClFlags = 0;
dcl->ClSize = sz;
DeadClauses = dcl; DeadClauses = dcl;
} else { } else {
Yap_FreeCodeSpace((char *)cl); Yap_FreeCodeSpace((char *)cl);
@ -2226,7 +2232,7 @@ static yamop *cur_clause(PredEntry *pe, yamop *codeptr)
cl = ClauseCodeToStaticClause(pe->cs.p_code.FirstClause); cl = ClauseCodeToStaticClause(pe->cs.p_code.FirstClause);
do { do {
if (IN_BLOCK(codeptr,cl,Yap_SizeOfBlock((CODEADDR)cl))) { if (IN_BLOCK(codeptr,cl,cl->ClSize)) {
return cl->ClCode; return cl->ClCode;
} }
if (cl->ClCode == pe->cs.p_code.LastClause) if (cl->ClCode == pe->cs.p_code.LastClause)
@ -2242,7 +2248,7 @@ static yamop *cur_log_upd_clause(PredEntry *pe, yamop *codeptr)
LogUpdClause *cl; LogUpdClause *cl;
cl = ClauseCodeToLogUpdClause(pe->cs.p_code.FirstClause); cl = ClauseCodeToLogUpdClause(pe->cs.p_code.FirstClause);
do { do {
if (IN_BLOCK(codeptr,cl->ClCode,Yap_SizeOfBlock((CODEADDR)cl))) { if (IN_BLOCK(codeptr,cl->ClCode,cl->ClSize)) {
return((yamop *)cl->ClCode); return((yamop *)cl->ClCode);
} }
cl = cl->ClNext; cl = cl->ClNext;
@ -2255,7 +2261,7 @@ static LogUpdIndex *
find_owner_log_index(LogUpdIndex *cl, yamop *code_p) find_owner_log_index(LogUpdIndex *cl, yamop *code_p)
{ {
yamop *code_beg = cl->ClCode; yamop *code_beg = cl->ClCode;
yamop *code_end = (yamop *)((char *)cl + Yap_SizeOfBlock((CODEADDR)cl)); yamop *code_end = (yamop *)((char *)cl + cl->ClSize);
if (code_p >= code_beg && code_p <= code_end) { if (code_p >= code_beg && code_p <= code_end) {
return cl; return cl;
@ -2275,7 +2281,7 @@ static StaticIndex *
find_owner_static_index(StaticIndex *cl, yamop *code_p) find_owner_static_index(StaticIndex *cl, yamop *code_p)
{ {
yamop *code_beg = cl->ClCode; yamop *code_beg = cl->ClCode;
yamop *code_end = (yamop *)((char *)cl + Yap_SizeOfBlock((CODEADDR)cl)); yamop *code_end = (yamop *)((char *)cl + cl->ClSize);
if (code_p >= code_beg && code_p <= code_end) { if (code_p >= code_beg && code_p <= code_end) {
return cl; return cl;
@ -2595,7 +2601,7 @@ code_in_pred_info(PredEntry *pp, Atom *pat, UInt *parity) {
static int static int
code_in_pred_lu_index(LogUpdIndex *icl, yamop *codeptr) { code_in_pred_lu_index(LogUpdIndex *icl, yamop *codeptr) {
LogUpdIndex *cicl; LogUpdIndex *cicl;
if (IN_BLOCK(codeptr,icl,Yap_SizeOfBlock((CODEADDR)icl))) { if (IN_BLOCK(codeptr,icl,icl->ClSize)) {
return TRUE; return TRUE;
} }
cicl = icl->ChildIndex; cicl = icl->ChildIndex;
@ -2610,7 +2616,7 @@ code_in_pred_lu_index(LogUpdIndex *icl, yamop *codeptr) {
static int static int
code_in_pred_s_index(StaticIndex *icl, yamop *codeptr) { code_in_pred_s_index(StaticIndex *icl, yamop *codeptr) {
StaticIndex *cicl; StaticIndex *cicl;
if (IN_BLOCK(codeptr,icl,Yap_SizeOfBlock((CODEADDR)icl))) { if (IN_BLOCK(codeptr,icl,icl->ClSize)) {
return TRUE; return TRUE;
} }
cicl = icl->ChildIndex; cicl = icl->ChildIndex;
@ -2649,17 +2655,17 @@ code_in_pred(PredEntry *pp, Atom *pat, UInt *parity, yamop *codeptr) {
char *code_end; char *code_end;
if (pp->PredFlags & LogUpdatePredFlag) { if (pp->PredFlags & LogUpdatePredFlag) {
LogUpdClause *cl = ClauseCodeToLogUpdClause(pp->cs.p_code.TrueCodeOfPred); LogUpdClause *cl = ClauseCodeToLogUpdClause(pp->cs.p_code.TrueCodeOfPred);
code_end = (char *)cl + Yap_SizeOfBlock((CODEADDR)cl); code_end = (char *)cl + cl->ClSize;
} else if (!(pp->PredFlags & DynamicPredFlag)) { } else if (!(pp->PredFlags & DynamicPredFlag)) {
code_end = NULL; code_end = NULL;
} else { } else {
StaticClause *cl = ClauseCodeToStaticClause(pp->cs.p_code.TrueCodeOfPred); StaticClause *cl = ClauseCodeToStaticClause(pp->cs.p_code.TrueCodeOfPred);
code_end = (char *)cl + Yap_SizeOfBlock((CODEADDR)cl); code_end = (char *)cl + cl->ClSize;
} }
if (pp->PredFlags & LogUpdatePredFlag) { if (pp->PredFlags & LogUpdatePredFlag) {
LogUpdClause *cl = ClauseCodeToLogUpdClause(clcode); LogUpdClause *cl = ClauseCodeToLogUpdClause(clcode);
do { do {
if (IN_BLOCK(codeptr,(CODEADDR)cl,Yap_SizeOfBlock((CODEADDR)cl))) { if (IN_BLOCK(codeptr,(CODEADDR)cl,cl->ClSize)) {
clause_was_found(pp, pat, parity); clause_was_found(pp, pat, parity);
READ_UNLOCK(pp->PRWLock); READ_UNLOCK(pp->PRWLock);
return i; return i;
@ -2669,10 +2675,10 @@ code_in_pred(PredEntry *pp, Atom *pat, UInt *parity, yamop *codeptr) {
} while (cl != NULL); } while (cl != NULL);
} else if (pp->PredFlags & DynamicPredFlag) { } else if (pp->PredFlags & DynamicPredFlag) {
do { do {
CODEADDR cl; DynamicClause *cl;
cl = (CODEADDR)ClauseCodeToDynamicClause(clcode); cl = ClauseCodeToDynamicClause(clcode);
if (IN_BLOCK(codeptr,cl,Yap_SizeOfBlock((CODEADDR)cl))) { if (IN_BLOCK(codeptr,cl,cl->ClSize)) {
clause_was_found(pp, pat, parity); clause_was_found(pp, pat, parity);
READ_UNLOCK(pp->PRWLock); READ_UNLOCK(pp->PRWLock);
return i; return i;
@ -2687,7 +2693,7 @@ code_in_pred(PredEntry *pp, Atom *pat, UInt *parity, yamop *codeptr) {
cl = ClauseCodeToStaticClause(clcode); cl = ClauseCodeToStaticClause(clcode);
do { do {
if (IN_BLOCK(codeptr,cl,Yap_SizeOfBlock((CODEADDR)cl))) { if (IN_BLOCK(codeptr,cl,cl->ClSize)) {
clause_was_found(pp, pat, parity); clause_was_found(pp, pat, parity);
READ_UNLOCK(pp->PRWLock); READ_UNLOCK(pp->PRWLock);
return i; return i;
@ -3471,7 +3477,7 @@ add_code_in_pred(PredEntry *pp) {
clcode = pp->CodeOfPred; clcode = pp->CodeOfPred;
cl = ClauseCodeToStaticClause(clcode); cl = ClauseCodeToStaticClause(clcode);
code_end = (char *)cl + Yap_SizeOfBlock((CODEADDR)cl); code_end = (char *)cl + cl->ClSize;
Yap_inform_profiler_of_clause(clcode, (yamop *)code_end, pp,0); Yap_inform_profiler_of_clause(clcode, (yamop *)code_end, pp,0);
READ_UNLOCK(pp->PRWLock); READ_UNLOCK(pp->PRWLock);
return; return;
@ -3481,10 +3487,10 @@ add_code_in_pred(PredEntry *pp) {
char *code_end; char *code_end;
if (pp->PredFlags & LogUpdatePredFlag) { if (pp->PredFlags & LogUpdatePredFlag) {
LogUpdIndex *cl = ClauseCodeToLogUpdIndex(clcode); LogUpdIndex *cl = ClauseCodeToLogUpdIndex(clcode);
code_end = (char *)cl + Yap_SizeOfBlock((CODEADDR)cl); code_end = (char *)cl + cl->ClSize;
} else { } else {
StaticIndex *cl = ClauseCodeToStaticIndex(clcode); StaticIndex *cl = ClauseCodeToStaticIndex(clcode);
code_end = (char *)cl + Yap_SizeOfBlock((CODEADDR)cl); code_end = (char *)cl + cl->ClSize;
} }
Yap_inform_profiler_of_clause(clcode, (yamop *)code_end, pp,0); Yap_inform_profiler_of_clause(clcode, (yamop *)code_end, pp,0);
} }
@ -3495,17 +3501,17 @@ add_code_in_pred(PredEntry *pp) {
do { do {
char *code_end; char *code_end;
code_end = (char *)cl + Yap_SizeOfBlock((CODEADDR)cl); code_end = (char *)cl + cl->ClSize;
Yap_inform_profiler_of_clause(cl->ClCode, (yamop *)code_end, pp,0); Yap_inform_profiler_of_clause(cl->ClCode, (yamop *)code_end, pp,0);
cl = cl->ClNext; cl = cl->ClNext;
} while (cl != NULL); } while (cl != NULL);
} else if (pp->PredFlags & DynamicPredFlag) { } else if (pp->PredFlags & DynamicPredFlag) {
do { do {
CODEADDR cl; DynamicClause *cl;
char *code_end; char *code_end;
cl = (CODEADDR)ClauseCodeToDynamicClause(clcode); cl = ClauseCodeToDynamicClause(clcode);
code_end = cl + Yap_SizeOfBlock((CODEADDR)cl); code_end = (CODEADDR)cl + cl->ClSize;
Yap_inform_profiler_of_clause(clcode, (yamop *)code_end, pp,0); Yap_inform_profiler_of_clause(clcode, (yamop *)code_end, pp,0);
if (clcode == pp->cs.p_code.LastClause) if (clcode == pp->cs.p_code.LastClause)
break; break;
@ -3516,7 +3522,7 @@ add_code_in_pred(PredEntry *pp) {
do { do {
char *code_end; char *code_end;
code_end = (char *)cl + Yap_SizeOfBlock((CODEADDR)cl); code_end = (char *)cl + cl->ClSize;
Yap_inform_profiler_of_clause(cl->ClCode, (yamop *)code_end, pp,0); Yap_inform_profiler_of_clause(cl->ClCode, (yamop *)code_end, pp,0);
if (cl->ClCode == pp->cs.p_code.FirstClause) if (cl->ClCode == pp->cs.p_code.FirstClause)
break; break;
@ -3558,7 +3564,7 @@ Yap_dump_code_area_for_profiler(void) {
static UInt static UInt
index_ssz(StaticIndex *x) index_ssz(StaticIndex *x)
{ {
UInt sz = Yap_SizeOfBlock((CODEADDR)x); UInt sz = x->ClSize;
x = x->ChildIndex; x = x->ChildIndex;
while (x != NULL) { while (x != NULL) {
sz += index_ssz(x); sz += index_ssz(x);
@ -3576,7 +3582,7 @@ static_statistics(PredEntry *pe)
if (pe->cs.p_code.NOfClauses) { if (pe->cs.p_code.NOfClauses) {
do { do {
cls++; cls++;
sz += Yap_SizeOfBlock((CODEADDR)cl); sz += cl->ClSize;
if (cl->ClCode == pe->cs.p_code.LastClause) if (cl->ClCode == pe->cs.p_code.LastClause)
break; break;
cl = cl->ClNext; cl = cl->ClNext;

16
C/dbase.c
View File

@ -3489,7 +3489,7 @@ p_first_instance(void)
static UInt static UInt
index_sz(LogUpdIndex *x) index_sz(LogUpdIndex *x)
{ {
UInt sz = Yap_SizeOfBlock((CODEADDR)x); UInt sz = x->ClSize;
x = x->ChildIndex; x = x->ChildIndex;
while (x != NULL) { while (x != NULL) {
sz += index_sz(x); sz += index_sz(x);
@ -3513,7 +3513,7 @@ lu_statistics(PredEntry *pe)
x = ClauseCodeToLogUpdClause(pe->cs.p_code.FirstClause); x = ClauseCodeToLogUpdClause(pe->cs.p_code.FirstClause);
while (x != NULL) { while (x != NULL) {
cls++; cls++;
sz += Yap_SizeOfBlock((CODEADDR)x); sz += x->ClSize;
x = x->ClNext; x = x->ClNext;
} }
} }
@ -3549,10 +3549,10 @@ p_key_statistics(void)
x = p->First; x = p->First;
while (x != NULL) { while (x != NULL) {
cls++; cls++;
sz += Yap_SizeOfBlock((CODEADDR)x); sz += sizeof(DBStruct)+sizeof(CELL)*x->DBT.NOfCells;
if (x->Code) { if (x->Code) {
DynamicClause *cl = ClauseCodeToDynamicClause(x->Code); DynamicClause *cl = ClauseCodeToDynamicClause(x->Code);
sz += Yap_SizeOfBlock((CODEADDR)cl); sz += cl->ClSize;
} }
x = NextDBRef(x); x = NextDBRef(x);
} }
@ -3574,12 +3574,12 @@ p_total_erased(void)
/* only for log upds */ /* only for log upds */
while (cl) { while (cl) {
cls++; cls++;
sz += Yap_SizeOfBlock((CODEADDR)cl); sz += cl->ClSize;
cl = cl->ClNext; cl = cl->ClNext;
} }
while (icl) { while (icl) {
icls++; icls++;
isz += Yap_SizeOfBlock((CODEADDR)icl); isz += icl->ClSize;
icl = icl->SiblingIndex; icl = icl->SiblingIndex;
} }
return return
@ -3605,7 +3605,7 @@ p_key_erased_statistics(void)
while (cl) { while (cl) {
if (cl->ClPred == pe) { if (cl->ClPred == pe) {
cls++; cls++;
sz += Yap_SizeOfBlock((CODEADDR)cl); sz += cl->ClSize;
} }
cl = cl->ClNext; cl = cl->ClNext;
} }
@ -3616,7 +3616,7 @@ p_key_erased_statistics(void)
c = c->u.ParentIndex; c = c->u.ParentIndex;
if (pe == c->u.pred) { if (pe == c->u.pred) {
icls++; icls++;
isz += Yap_SizeOfBlock((CODEADDR)icl); isz += c->ClSize;
} }
icl = icl->SiblingIndex; icl = icl->SiblingIndex;
} }

20
C/heapgc.c
View File

@ -503,7 +503,7 @@ static dbentry db_vec, db_vec0;
/* init the table */ /* init the table */
static void static void
store_in_dbtable(CODEADDR entry, db_entry_type db_type) store_in_dbtable(CODEADDR entry, CODEADDR end, db_entry_type db_type)
{ {
dbentry parent = db_vec0; dbentry parent = db_vec0;
dbentry new = db_vec; dbentry new = db_vec;
@ -512,7 +512,7 @@ store_in_dbtable(CODEADDR entry, db_entry_type db_type)
Yap_growtrail(64 * 1024L); Yap_growtrail(64 * 1024L);
new->val = entry; new->val = entry;
new->db_type = db_type; new->db_type = db_type;
new->lim = entry+Yap_SizeOfBlock((CODEADDR)entry); new->lim = entry+sizeof(DBStruct)+sizeof(CELL)*((DBRef)entry)->DBT.NOfCells;
new->left = new->right = NULL; new->left = new->right = NULL;
if (db_vec == db_vec0) { if (db_vec == db_vec0) {
db_vec++; db_vec++;
@ -616,20 +616,26 @@ init_dbtable(tr_fr_ptr trail_ptr) {
/* for the moment, if all references to the term in the stacks /* for the moment, if all references to the term in the stacks
are only pointers, reset the flag */ are only pointers, reset the flag */
if (FlagOn(DBClMask, flags)) { if (FlagOn(DBClMask, flags)) {
store_in_dbtable((CODEADDR)DBStructFlagsToDBStruct(pt0), db_entry); DBRef dbr = DBStructFlagsToDBStruct(pt0);
store_in_dbtable((CODEADDR)dbr,
(CODEADDR)dbr+sizeof(DBStruct)+sizeof(CELL)*dbr->DBT.NOfCells,
db_entry);
} else if (flags & LogUpdMask) { } else if (flags & LogUpdMask) {
if (flags & IndexMask) { if (flags & IndexMask) {
store_in_dbtable((CODEADDR)ClauseFlagsToLogUpdIndex(pt0), li_entry); LogUpdIndex *li = ClauseFlagsToLogUpdIndex(pt0);
store_in_dbtable((CODEADDR)li, (CODEADDR)li+li->ClSize, li_entry);
} else { } else {
store_in_dbtable((CODEADDR)ClauseFlagsToLogUpdClause(pt0), lcl_entry); LogUpdClause *cli = ClauseFlagsToLogUpdClause(pt0);
store_in_dbtable((CODEADDR)cli, (CODEADDR)cli+cli->ClSize, lcl_entry);
} }
} else { } else {
store_in_dbtable((CODEADDR)ClauseFlagsToDynamicClause(pt0), cl_entry); DynamicClause *dcl = ClauseFlagsToDynamicClause(pt0);
store_in_dbtable((CODEADDR)dcl, (CODEADDR)dcl->ClSize, dcl_entry);
} }
} }
} }
while (cl != NULL) { while (cl != NULL) {
store_in_dbtable((CODEADDR)cl, dcl_entry); store_in_dbtable((CODEADDR)cl, (CODEADDR)cl+cl->ClSize, dcl_entry);
cl = cl->NextCl; cl = cl->NextCl;
} }
if (db_vec == db_vec0) { if (db_vec == db_vec0) {

24
C/index.c
View File

@ -2406,23 +2406,27 @@ emit_switch_space(UInt n, UInt item_size, struct intermediates *cint)
PredEntry *ap = cint->CurrentPred; PredEntry *ap = cint->CurrentPred;
if (ap->PredFlags & LogUpdatePredFlag) { if (ap->PredFlags & LogUpdatePredFlag) {
LogUpdIndex *cl = (LogUpdIndex *)Yap_AllocCodeSpace(sizeof(LogUpdIndex)+n*item_size); UInt sz = sizeof(LogUpdIndex)+n*item_size;
LogUpdIndex *cl = (LogUpdIndex *)Yap_AllocCodeSpace(sz);
if (cl == NULL) { if (cl == NULL) {
Yap_Error_Size = sizeof(LogUpdIndex)+n*item_size; Yap_Error_Size = sizeof(LogUpdIndex)+n*item_size;
/* grow stack */ /* grow stack */
longjmp(cint->CompilerBotch,2); longjmp(cint->CompilerBotch,2);
} }
cl->ClFlags = SwitchTableMask|LogUpdMask; cl->ClFlags = SwitchTableMask|LogUpdMask;
cl->ClSize = sz;
/* insert into code chain */ /* insert into code chain */
return cl->ClCode; return cl->ClCode;
} else { } else {
StaticIndex *cl = (StaticIndex *)Yap_AllocCodeSpace(sizeof(StaticIndex)+n*item_size); UInt sz = sizeof(StaticIndex)+n*item_size;
StaticIndex *cl = (StaticIndex *)Yap_AllocCodeSpace(sz);
if (cl == NULL) { if (cl == NULL) {
Yap_Error_Size = sizeof(LogUpdIndex)+n*item_size; Yap_Error_Size = sizeof(LogUpdIndex)+n*item_size;
/* grow stack */ /* grow stack */
longjmp(cint->CompilerBotch,2); longjmp(cint->CompilerBotch,2);
} }
cl->ClFlags = SwitchTableMask; cl->ClFlags = SwitchTableMask;
cl->ClSize = sz;
return cl->ClCode; return cl->ClCode;
/* insert into code chain */ /* insert into code chain */
} }
@ -4323,10 +4327,15 @@ cross_block(path_stack_entry *sp, yamop **pipc, PredEntry *ap)
ClauseUnion *block; ClauseUnion *block;
do { do {
UInt bsize;
while ((--tsp)->flag != block_entry); while ((--tsp)->flag != block_entry);
block = tsp->u.cle.block; block = tsp->u.cle.block;
if (block->lui.ClFlags & LogUpdMask)
bsize = block->lui.ClSize;
else
bsize = block->si.ClSize;
if (ipc > (yamop *)block && if (ipc > (yamop *)block &&
ipc <= (yamop *)((CODEADDR)block + Yap_SizeOfBlock((CODEADDR)block))) { ipc <= (yamop *)((CODEADDR)block + bsize)) {
path_stack_entry *nsp = tsp+1; path_stack_entry *nsp = tsp+1;
for (;tsp<sp;tsp++) { for (;tsp<sp;tsp++) {
if (tsp->flag == pc_entry) { if (tsp->flag == pc_entry) {
@ -4926,6 +4935,8 @@ insertz_in_lu_block(LogUpdIndex *blk, PredEntry *ap, yamop *code)
{ {
op_numbers op = Yap_op_from_opcode(blk->ClCode->opc); op_numbers op = Yap_op_from_opcode(blk->ClCode->opc);
yamop *end, *last, *where, *next; yamop *end, *last, *where, *next;
UInt bsize;
/* make sure this is something I can work with */ /* make sure this is something I can work with */
if (op != _enter_lu_pred && op != _stale_lu_index) { if (op != _enter_lu_pred && op != _stale_lu_index) {
if (blk->ClFlags & SwitchRootMask) { if (blk->ClFlags & SwitchRootMask) {
@ -4937,7 +4948,8 @@ insertz_in_lu_block(LogUpdIndex *blk, PredEntry *ap, yamop *code)
} }
/* ok, we are in a sequence of try-retry-trust instructions, or something /* ok, we are in a sequence of try-retry-trust instructions, or something
similar */ similar */
end = (yamop *)((CODEADDR)blk+Yap_SizeOfBlock((CODEADDR)blk)); bsize = blk->ClSize;
end = (yamop *)((CODEADDR)blk+bsize);
where = last = blk->ClCode->u.Ill.l2; where = last = blk->ClCode->u.Ill.l2;
next = NEXTOP(NEXTOP(where, ld),p); /* trust logical followed by trust */ next = NEXTOP(NEXTOP(where, ld),p); /* trust logical followed by trust */
last = PREVOP(last, ld); last = PREVOP(last, ld);
@ -6158,11 +6170,11 @@ Yap_RemoveClauseFromIndex(PredEntry *ap, yamop *beg) {
if (ap->PredFlags & LogUpdatePredFlag) { if (ap->PredFlags & LogUpdatePredFlag) {
LogUpdClause *c = ClauseCodeToLogUpdClause(beg); LogUpdClause *c = ClauseCodeToLogUpdClause(beg);
cl.Code = cl.CurrentCode = beg; cl.Code = cl.CurrentCode = beg;
last = (yamop *)((CODEADDR)c+Yap_SizeOfBlock((CODEADDR)c)); last = (yamop *)((CODEADDR)c+c->ClSize);
} else { } else {
StaticClause *c = ClauseCodeToStaticClause(beg); StaticClause *c = ClauseCodeToStaticClause(beg);
cl.Code = cl.CurrentCode = beg; cl.Code = cl.CurrentCode = beg;
last = (yamop *)((CODEADDR)c+Yap_SizeOfBlock((CODEADDR)c)); last = (yamop *)((CODEADDR)c+c->ClSize);
} }
sp = push_path(stack, NULL, &cl); sp = push_path(stack, NULL, &cl);
if (ap->cs.p_code.NOfClauses == 0) { if (ap->cs.p_code.NOfClauses == 0) {

1
C/threads.c
View File

@ -214,7 +214,6 @@ static Int
p_thread_exit(void) p_thread_exit(void)
{ {
thread_die(worker_id, FALSE); thread_die(worker_id, FALSE);
fprintf(stderr,"here i go %d %ld\n", worker_id, ThreadHandle[worker_id].handle);
pthread_exit(NULL); pthread_exit(NULL);
return TRUE; return TRUE;
} }

3
C/unify.c
View File

@ -295,6 +295,9 @@ cufail:
#if SHADOW_REGS #if SHADOW_REGS
#if defined(B) || defined(TR) #if defined(B) || defined(TR)
#undef Yap_REGS #undef Yap_REGS
#if PUSH_REGS
#define Yap_REGS (*Yap_regp)
#endif
#endif /* defined(B) || defined(TR) */ #endif /* defined(B) || defined(TR) */
#endif #endif
} }

16
H/Regs.h
View File

@ -10,7 +10,7 @@
* File: Regs.h * * File: Regs.h *
* mods: * * mods: *
* comments: YAP abstract machine registers * * comments: YAP abstract machine registers *
* version: $Id: Regs.h,v 1.26 2004-02-12 12:37:11 vsc Exp $ * * version: $Id: Regs.h,v 1.27 2004-03-05 15:26:33 vsc Exp $ *
*************************************************************************/ *************************************************************************/
@ -185,7 +185,7 @@ extern int Yap_stack_overflows;
#define H0 Yap_REGS.H0_ /* base of heap (global) stack */ #define H0 Yap_REGS.H0_ /* base of heap (global) stack */
#define LCL0 Yap_REGS.LCL0_ /* local stack base */ #define LCL0 Yap_REGS.LCL0_ /* local stack base */
#if defined(__GNUC__) && defined(sparc) && !defined(__NetBSD__) #if defined(__GNUC__) && defined(sparc) && !defined(__NetBSD__) && !defined(THREADS)
#define P Yap_REGS.P_ /* prolog machine program counter */ #define P Yap_REGS.P_ /* prolog machine program counter */
#define YENV Yap_REGS.YENV_ /* current environment (may differ from ENV)*/ #define YENV Yap_REGS.YENV_ /* current environment (may differ from ENV)*/
@ -193,7 +193,7 @@ extern int Yap_stack_overflows;
register CELL *H asm ("g6"); register CELL *H asm ("g6");
register tr_fr_ptr TR asm ("g7"); register tr_fr_ptr TR asm ("g7");
#ifdef __svr4__ #if defined(__svr4__)
register choiceptr B asm ("g5"); register choiceptr B asm ("g5");
#else #else
#define B Yap_REGS.B_ /* latest choice point */ #define B Yap_REGS.B_ /* latest choice point */
@ -205,7 +205,7 @@ register choiceptr B asm ("g5");
EXTERN inline void save_machine_regs(void) { EXTERN inline void save_machine_regs(void) {
Yap_REGS.H_ = H; Yap_REGS.H_ = H;
Yap_REGS.TR_ = TR; Yap_REGS.TR_ = TR;
#ifdef __svr4__ #if defined(__svr4__)
Yap_REGS.B_ = B; Yap_REGS.B_ = B;
#endif #endif
} }
@ -213,7 +213,7 @@ EXTERN inline void save_machine_regs(void) {
EXTERN inline void restore_machine_regs(void) { EXTERN inline void restore_machine_regs(void) {
H = Yap_REGS.H_; H = Yap_REGS.H_;
TR = Yap_REGS.TR_; TR = Yap_REGS.TR_;
#ifdef __svr4__ #if defined(__svr4__)
B = Yap_REGS.B_; B = Yap_REGS.B_;
#endif #endif
} }
@ -243,18 +243,18 @@ EXTERN inline void restore_H(void) {
#define RECOVER_H() save_H(); H = BK_H #define RECOVER_H() save_H(); H = BK_H
EXTERN inline void save_B(void) { EXTERN inline void save_B(void) {
#ifdef __svr4__ #if defined(__svr4__)
Yap_REGS.B_ = B; Yap_REGS.B_ = B;
#endif #endif
} }
EXTERN inline void restore_B(void) { EXTERN inline void restore_B(void) {
#ifdef __svr4__ #if defined(__svr4__)
B = Yap_REGS.B_; B = Yap_REGS.B_;
#endif #endif
} }
#ifdef __svr4__ #if defined(__svr4__)
#define BACKUP_B() choiceptr BK_B = B; restore_B() #define BACKUP_B() choiceptr BK_B = B; restore_B()
#define RECOVER_B() save_B(); B = BK_B #define RECOVER_B() save_B(); B = BK_B

3
H/Yapproto.h
View File

@ -10,7 +10,7 @@
* File: Yap.proto * * File: Yap.proto *
* mods: * * mods: *
* comments: Function declarations for YAP * * comments: Function declarations for YAP *
* version: $Id: Yapproto.h,v 1.50 2004-03-04 18:33:33 vsc Exp $ * * version: $Id: Yapproto.h,v 1.51 2004-03-05 15:26:33 vsc Exp $ *
*************************************************************************/ *************************************************************************/
/* prototype file for Yap */ /* prototype file for Yap */
@ -68,7 +68,6 @@ void STD_PROTO(Yap_atom_gc, (void));
void STD_PROTO(Yap_init_agc, (void)); void STD_PROTO(Yap_init_agc, (void));
/* alloc.c */ /* alloc.c */
int STD_PROTO(Yap_SizeOfBlock,(CODEADDR));
void STD_PROTO(Yap_FreeCodeSpace,(char *)); void STD_PROTO(Yap_FreeCodeSpace,(char *));
char *STD_PROTO(Yap_AllocAtomSpace,(unsigned int)); char *STD_PROTO(Yap_AllocAtomSpace,(unsigned int));
char *STD_PROTO(Yap_AllocCodeSpace,(unsigned int)); char *STD_PROTO(Yap_AllocCodeSpace,(unsigned int));

8
H/clause.h
View File

@ -46,6 +46,7 @@ typedef struct logic_upd_index {
/* A lock for manipulating the clause */ /* A lock for manipulating the clause */
lockvar ClLock; lockvar ClLock;
#endif #endif
UInt ClSize;
union { union {
PredEntry *pred; PredEntry *pred;
struct logic_upd_index *ParentIndex; struct logic_upd_index *ParentIndex;
@ -67,6 +68,7 @@ typedef struct logic_upd_clause {
/* A lock for manipulating the clause */ /* A lock for manipulating the clause */
lockvar ClLock; lockvar ClLock;
#endif #endif
UInt ClSize;
/* extra clause information for logical update indices and facts */ /* extra clause information for logical update indices and facts */
/* indices that may still backtrack to this clause */ /* indices that may still backtrack to this clause */
UInt ClRefCount; UInt ClRefCount;
@ -88,6 +90,7 @@ typedef struct dynamic_clause {
/* A lock for manipulating the clause */ /* A lock for manipulating the clause */
lockvar ClLock; lockvar ClLock;
#endif #endif
UInt ClSize;
UInt ClRefCount; UInt ClRefCount;
yamop *ClPrevious; /* immediate update clause */ yamop *ClPrevious; /* immediate update clause */
/* The instructions, at least one of the form sl */ /* The instructions, at least one of the form sl */
@ -97,6 +100,7 @@ typedef struct dynamic_clause {
typedef struct static_index { typedef struct static_index {
/* A set of flags describing info on the clause */ /* A set of flags describing info on the clause */
CELL ClFlags; CELL ClFlags;
UInt ClSize;
struct static_index *SiblingIndex; struct static_index *SiblingIndex;
struct static_index *ChildIndex; struct static_index *ChildIndex;
/* The instructions, at least one of the form sl */ /* The instructions, at least one of the form sl */
@ -107,6 +111,7 @@ typedef struct static_clause {
/* A set of flags describing info on the clause */ /* A set of flags describing info on the clause */
Functor Id; Functor Id;
CELL ClFlags; CELL ClFlags;
UInt ClSize;
union { union {
DBTerm *ClSource; DBTerm *ClSource;
PredEntry *ClPred; PredEntry *ClPred;
@ -118,12 +123,13 @@ typedef struct static_clause {
typedef struct dead_clause { typedef struct dead_clause {
CELL ClFlags; CELL ClFlags;
struct dead_clause *NextCl; /* dead clause */
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
/* A lock for manipulating the clause */ /* A lock for manipulating the clause */
lockvar ClLock; lockvar ClLock;
UInt ref_count; UInt ref_count;
#endif #endif
UInt ClSize;
struct dead_clause *NextCl; /* dead clause */
} DeadClause; } DeadClause;
typedef union clause_obj { typedef union clause_obj {

8
m4/Yatom.h.m4
View File

@ -197,13 +197,13 @@ typedef enum {
/* profile data */ /* profile data */
typedef struct { typedef struct {
#if defined(YAPOR) || defined(THREADS)
lockvar lock; /* a simple lock to protect this entry */
#endif
YAP_ULONG_LONG NOfEntries; /* nbr of times head unification succeeded*/ YAP_ULONG_LONG NOfEntries; /* nbr of times head unification succeeded*/
YAP_ULONG_LONG NOfHeadSuccesses; /* nbr of times head unification succeeded*/ YAP_ULONG_LONG NOfHeadSuccesses; /* nbr of times head unification succeeded*/
YAP_ULONG_LONG NOfRetries; /* nbr of times a clause for the pred YAP_ULONG_LONG NOfRetries; /* nbr of times a clause for the pred
was retried */ was retried */
#if defined(YAPOR) || defined(THREADS)
lockvar lock; /* a simple lock to protect this entry */
#endif
} profile_data; } profile_data;
typedef struct pred_entry { typedef struct pred_entry {
@ -238,10 +238,10 @@ typedef struct pred_entry {
tab_ent_ptr TableOfPred; tab_ent_ptr TableOfPred;
#endif /* TABLING */ #endif /* TABLING */
Term ModuleOfPred; /* module for this definition */ Term ModuleOfPred; /* module for this definition */
struct pred_entry *NextPredOfModule; /* next pred for same module */
/* This must be at an odd number of cells, otherwise it /* This must be at an odd number of cells, otherwise it
will not be aligned on RISC machines */ will not be aligned on RISC machines */
profile_data StatisticsForPred; /* enable profiling for predicate */ profile_data StatisticsForPred; /* enable profiling for predicate */
struct pred_entry *NextPredOfModule; /* next pred for same module */
} PredEntry; } PredEntry;
#define PEProp ((PropFlags)(0x0000)) #define PEProp ((PropFlags)(0x0000))