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

moved several global variables to misc/GLOBALS

Browse Source
This commit is contained in:
Joao 2011-05-25 16:40:36 +01:00
parent 8170f6d3cb
commit 971ad94311
63 changed files with 1724 additions and 1329 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
C/absmi.c
View File

@ -784,8 +784,8 @@ Yap_absmi(int inp)
op_switch:
#ifdef ANALYST
Yap_opcount[opcode]++;
Yap_2opcount[old_op][opcode]++;
GLOBAL_opcount[opcode]++;
GLOBAL_2opcount[old_op][opcode]++;
#ifdef DEBUG_XX
ops_done++;
/* if (B->cp_b > 0x103fff90)
@ -3037,12 +3037,12 @@ Yap_absmi(int inp)
/* I need this for Windows and other systems where SIGINT
is not proceesed by same thread as absmi */
LOCK(LOCAL_SignalLock);
if (Yap_PrologMode & (AbortMode|InterruptMode)) {
if (LOCAL_PrologMode & (AbortMode|InterruptMode)) {
CreepFlag = CalculateStackGap();
UNLOCK(LOCAL_SignalLock);
/* same instruction */
if (Yap_PrologMode & InterruptMode) {
Yap_PrologMode &= ~InterruptMode;
if (LOCAL_PrologMode & InterruptMode) {
LOCAL_PrologMode &= ~InterruptMode;
SET_ASP(YREG, E_CB*sizeof(CELL));
saveregs();
Yap_ProcessSIGINT();
@ -7102,7 +7102,7 @@ Yap_absmi(int inp)
yamop *savedP;
Yap_StartSlots( PASS_REGS1 );
Yap_PrologMode = UserCCallMode;
LOCAL_PrologMode = UserCCallMode;
{
PredEntry *p = PREG->u.Osbpp.p;
@ -7115,7 +7115,7 @@ Yap_absmi(int inp)
}
Yap_CloseSlots( PASS_REGS1 );
setregs();
Yap_PrologMode = UserMode;
LOCAL_PrologMode = UserMode;
restore_machine_regs();
PREG = savedP;
}
@ -7283,7 +7283,7 @@ Yap_absmi(int inp)
#endif
SET_BB(B_YREG);
ENDCACHE_Y();
Yap_PrologMode = UserCCallMode;
LOCAL_PrologMode = UserCCallMode;
ASP = YREG;
/* for slots to work */
Yap_StartSlots( PASS_REGS1 );
@ -7293,7 +7293,7 @@ Yap_absmi(int inp)
EX = 0L;
restore_machine_regs();
setregs();
Yap_PrologMode = UserMode;
LOCAL_PrologMode = UserMode;
Yap_CloseSlots( PASS_REGS1 );
if (!SREG) {
FAIL();
@ -7326,7 +7326,7 @@ Yap_absmi(int inp)
restore_args(PREG->u.OtapFs.s);
ENDCACHE_Y();
Yap_PrologMode = UserCCallMode;
LOCAL_PrologMode = UserCCallMode;
SET_ASP(YREG, E_CB*sizeof(CELL));
/* for slots to work */
Yap_StartSlots( PASS_REGS1 );
@ -7336,7 +7336,7 @@ Yap_absmi(int inp)
EX = 0L;
restore_machine_regs();
setregs();
Yap_PrologMode = UserMode;
LOCAL_PrologMode = UserMode;
Yap_CloseSlots( PASS_REGS1 );
if (!SREG) {
#ifdef CUT_C

38
C/agc.c
View File

@ -29,20 +29,12 @@ static char SccsId[] = "@(#)agc.c 1.3 3/15/90";
/* #define DEBUG_RESTORE1 1 */
/* #define DEBUG_RESTORE2 1 */
/* #define DEBUG_RESTORE3 1 */
#define errout Yap_stderr
#define errout GLOBAL_stderr
#endif
STATIC_PROTO(void RestoreEntries, (PropEntry *, int USES_REGS));
STATIC_PROTO(void CleanCode, (PredEntry * USES_REGS));
static int agc_calls;
static YAP_ULONG_LONG agc_collected;
static Int tot_agc_time = 0; /* total time spent in GC */
static Int tot_agc_recovered = 0; /* number of heap objects in all garbage collections */
#define AtomMarkedBit 1
static inline void
@ -392,12 +384,12 @@ clean_atom_list(AtomHashEntry *HashPtr)
#ifdef DEBUG_RESTORE3
fprintf(stderr, "Purged %p:%S\n", at, at->WStrOfAE);
#endif
agc_collected += sizeof(AtomEntry)+wcslen(at->WStrOfAE);
GLOBAL_agc_collected += sizeof(AtomEntry)+wcslen(at->WStrOfAE);
} else {
#ifdef DEBUG_RESTORE3
fprintf(stderr, "Purged %p:%s patm=%p %p\n", at, at->StrOfAE, patm, at->NextOfAE);
#endif
agc_collected += sizeof(AtomEntry)+strlen(at->StrOfAE);
GLOBAL_agc_collected += sizeof(AtomEntry)+strlen(at->StrOfAE);
}
*patm = atm = at->NextOfAE;
Yap_FreeCodeSpace((char *)at);
@ -447,13 +439,13 @@ atom_gc(USES_REGS1)
if (Yap_GetValue(AtomGcTrace) != TermNil)
gc_trace = 1;
agc_calls++;
agc_collected = 0;
GLOBAL_agc_calls++;
GLOBAL_agc_collected = 0;
if (gc_trace) {
fprintf(Yap_stderr, "%% agc:\n");
fprintf(GLOBAL_stderr, "%% agc:\n");
} else if (gc_verbose) {
fprintf(Yap_stderr, "%% Start of atom garbage collection %d:\n", agc_calls);
fprintf(GLOBAL_stderr, "%% Start of atom garbage collection %d:\n", GLOBAL_agc_calls);
}
time_start = Yap_cputime();
/* get the number of active registers */
@ -464,15 +456,15 @@ atom_gc(USES_REGS1)
clean_atoms();
YAPLeaveCriticalSection();
agc_time = Yap_cputime()-time_start;
tot_agc_time += agc_time;
tot_agc_recovered += agc_collected;
GLOBAL_tot_agc_time += agc_time;
GLOBAL_tot_agc_recovered += GLOBAL_agc_collected;
if (gc_verbose) {
#ifdef _WIN32
fprintf(Yap_stderr, "%% Collected %I64d bytes.\n", agc_collected);
fprintf(GLOBAL_stderr, "%% Collected %I64d bytes.\n", GLOBAL_agc_collected);
#else
fprintf(Yap_stderr, "%% Collected %lld bytes.\n", agc_collected);
fprintf(GLOBAL_stderr, "%% Collected %lld bytes.\n", GLOBAL_agc_collected);
#endif
fprintf(Yap_stderr, "%% GC %d took %g sec, total of %g sec doing GC so far.\n", agc_calls, (double)agc_time/1000, (double)tot_agc_time/1000);
fprintf(GLOBAL_stderr, "%% GC %d took %g sec, total of %g sec doing GC so far.\n", GLOBAL_agc_calls, (double)agc_time/1000, (double)GLOBAL_tot_agc_time/1000);
}
}
@ -494,9 +486,9 @@ p_atom_gc(USES_REGS1)
static Int
p_inform_agc(USES_REGS1)
{
Term tn = MkIntegerTerm(tot_agc_time);
Term tt = MkIntegerTerm(agc_calls);
Term ts = MkIntegerTerm(tot_agc_recovered);
Term tn = MkIntegerTerm(GLOBAL_tot_agc_time);
Term tt = MkIntegerTerm(GLOBAL_agc_calls);
Term ts = MkIntegerTerm(GLOBAL_tot_agc_recovered);
return
Yap_unify(tn, ARG2) &&

92
C/alloc.c
View File

@ -128,6 +128,7 @@ long long unsigned int tmalloc;
static inline char *
call_malloc(unsigned long int size)
{
CACHE_REGS
char *out;
#if USE_DL_MALLOC
LOCK(DLMallocLock);
@ -137,13 +138,13 @@ call_malloc(unsigned long int size)
tmalloc += size;
size += sizeof(CELL);
#endif
Yap_PrologMode |= MallocMode;
LOCAL_PrologMode |= MallocMode;
out = (char *) my_malloc(size);
#if INSTRUMENT_MALLOC
*(CELL*)out = size-sizeof(CELL);
out += sizeof(CELL);
#endif
Yap_PrologMode &= ~MallocMode;
LOCAL_PrologMode &= ~MallocMode;
#if USE_DL_MALLOC
UNLOCK(DLMallocLock);
#endif
@ -160,6 +161,7 @@ Yap_AllocCodeSpace(unsigned long int size)
static inline char *
call_realloc(char *p, unsigned long int size)
{
CACHE_REGS
char *out;
#if USE_DL_MALLOC
LOCK(DLMallocLock);
@ -171,13 +173,13 @@ call_realloc(char *p, unsigned long int size)
p -= sizeof(CELL);
tmalloc -= *(CELL*)p;
#endif
Yap_PrologMode |= MallocMode;
LOCAL_PrologMode |= MallocMode;
out = (char *) my_realloc0(p, size);
#if INSTRUMENT_MALLOC
*(CELL*)out = size-sizeof(CELL);
out += sizeof(CELL);
#endif
Yap_PrologMode &= ~MallocMode;
LOCAL_PrologMode &= ~MallocMode;
#if USE_DL_MALLOC
UNLOCK(DLMallocLock);
#endif
@ -194,17 +196,18 @@ Yap_ReallocCodeSpace(char *p, unsigned long int size)
void
Yap_FreeCodeSpace(char *p)
{
CACHE_REGS
#if USE_DL_MALLOC
LOCK(DLMallocLock);
#endif
Yap_PrologMode |= MallocMode;
LOCAL_PrologMode |= MallocMode;
#if INSTRUMENT_MALLOC
p -= sizeof(CELL);
tmalloc -= *(CELL*)p;
frees++;
#endif
my_free (p);
Yap_PrologMode &= ~MallocMode;
LOCAL_PrologMode &= ~MallocMode;
#if USE_DL_MALLOC
UNLOCK(DLMallocLock);
#endif
@ -220,17 +223,18 @@ Yap_AllocAtomSpace(unsigned long int size)
void
Yap_FreeAtomSpace(char *p)
{
CACHE_REGS
#if USE_DL_MALLOC
LOCK(DLMallocLock);
#endif
Yap_PrologMode |= MallocMode;
LOCAL_PrologMode |= MallocMode;
#if INSTRUMENT_MALLOC
p -= sizeof(CELL);
tmalloc -= *(CELL*)p;
frees++;
#endif
my_free (p);
Yap_PrologMode &= ~MallocMode;
LOCAL_PrologMode &= ~MallocMode;
#if USE_DL_MALLOC
UNLOCK(DLMallocLock);
#endif
@ -250,14 +254,14 @@ Yap_InitPreAllocCodeSpace(void)
#if USE_DL_MALLOC
LOCK(DLMallocLock);
#endif
Yap_PrologMode |= MallocMode;
LOCAL_PrologMode |= MallocMode;
#if INSTRUMENT_MALLOC
mallocs++;
tmalloc += sz;
sz += sizeof(CELL);
#endif
while (!(ptr = my_malloc(sz))) {
Yap_PrologMode &= ~MallocMode;
LOCAL_PrologMode &= ~MallocMode;
#if USE_DL_MALLOC
UNLOCK(DLMallocLock);
#endif
@ -273,9 +277,9 @@ Yap_InitPreAllocCodeSpace(void)
#if USE_DL_MALLOC
LOCK(DLMallocLock);
#endif
Yap_PrologMode |= MallocMode;
LOCAL_PrologMode |= MallocMode;
}
Yap_PrologMode &= ~MallocMode;
LOCAL_PrologMode &= ~MallocMode;
#if USE_DL_MALLOC
UNLOCK(DLMallocLock);
#endif
@ -305,20 +309,20 @@ Yap_ExpandPreAllocCodeSpace(UInt sz0, void *cip, int safe)
#if USE_DL_MALLOC
LOCK(DLMallocLock);
#endif
Yap_PrologMode |= MallocMode;
LOCAL_PrologMode |= MallocMode;
#if INSTRUMENT_MALLOC
reallocs++;
tmalloc -= LOCAL_ScratchPad.sz;
tmalloc += sz;
#endif
if (!(ptr = my_realloc(LOCAL_ScratchPad.ptr, sz, LOCAL_ScratchPad.sz, safe))) {
Yap_PrologMode &= ~MallocMode;
LOCAL_PrologMode &= ~MallocMode;
#if USE_DL_MALLOC
UNLOCK(DLMallocLock);
#endif
return NULL;
}
Yap_PrologMode &= ~MallocMode;
LOCAL_PrologMode &= ~MallocMode;
#if USE_DL_MALLOC
UNLOCK(DLMallocLock);
#endif
@ -375,7 +379,7 @@ InitExStacks(int Trail, int Stack)
AuxSp = NULL;
#ifdef DEBUG
if (Yap_output_msg) {
if (GLOBAL_output_msg) {
UInt ta;
fprintf(stderr, "HeapBase = %p GlobalBase = %p\n LocalBase = %p TrailTop = %p\n",
@ -818,9 +822,9 @@ static int
ExtendWorkSpace(Int s, int fixed_allocation)
{
LPVOID b = brk;
prolog_exec_mode OldPrologMode = Yap_PrologMode;
prolog_exec_mode OldPrologMode = LOCAL_PrologMode;
Yap_PrologMode = ExtendStackMode;
LOCAL_PrologMode = ExtendStackMode;
#if DEBUG_WIN32_ALLOC
fprintf(stderr,"trying: %p (" Int_FORMAT "K) %d\n",b, s/1024, fixed_allocation);
@ -834,7 +838,7 @@ ExtendWorkSpace(Int s, int fixed_allocation)
}
}
if (!b) {
Yap_PrologMode = OldPrologMode;
LOCAL_PrologMode = OldPrologMode;
#if DEBUG_WIN32_ALLOC
{
char msg[256];
@ -853,7 +857,7 @@ ExtendWorkSpace(Int s, int fixed_allocation)
snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
"VirtualAlloc could not commit %ld bytes",
(long int)s);
Yap_PrologMode = OldPrologMode;
LOCAL_PrologMode = OldPrologMode;
#if DEBUG_WIN32_ALLOC
fprintf(stderr,"NOT OK2: %p--%p\n",b,brk);
#endif
@ -863,7 +867,7 @@ ExtendWorkSpace(Int s, int fixed_allocation)
#if DEBUG_WIN32_ALLOC
fprintf(stderr,"OK: %p--%p " Int_FORMAT "\n",b, brk, s);
#endif
Yap_PrologMode = OldPrologMode;
LOCAL_PrologMode = OldPrologMode;
return TRUE;
}
@ -1126,16 +1130,16 @@ ExtendWorkSpace(Int s, int fixed_allocation)
return(FALSE);
#else
MALLOC_T a;
prolog_exec_mode OldPrologMode = Yap_PrologMode;
prolog_exec_mode OldPrologMode = LOCAL_PrologMode;
MALLOC_T base = WorkSpaceTop;
if (fixed_allocation == MAP_FIXED)
base = WorkSpaceTop;
else
base = 0L;
Yap_PrologMode = ExtendStackMode;
LOCAL_PrologMode = ExtendStackMode;
a = mmap_extension(s, base, fixed_allocation);
Yap_PrologMode = OldPrologMode;
LOCAL_PrologMode = OldPrologMode;
if (a == (MALLOC_T) - 1) {
LOCAL_ErrorMessage = LOCAL_ErrorSay;
#if HAVE_STRERROR
@ -1153,7 +1157,7 @@ ExtendWorkSpace(Int s, int fixed_allocation)
LOCAL_ErrorMessage = LOCAL_ErrorSay;
snprintf5(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
"mmap could not grow memory at %p, got %p", WorkSpaceTop, a );
Yap_PrologMode = OldPrologMode;
LOCAL_PrologMode = OldPrologMode;
return FALSE;
}
} else if (a < WorkSpaceTop) {
@ -1164,7 +1168,7 @@ ExtendWorkSpace(Int s, int fixed_allocation)
return res;
}
WorkSpaceTop = (char *) a + s;
Yap_PrologMode = OldPrologMode;
LOCAL_PrologMode = OldPrologMode;
return TRUE;
#endif /* YAPOR */
}
@ -1215,33 +1219,33 @@ ExtendWorkSpace(Int s)
{
MALLOC_T ptr;
int shm_id;
prolog_exec_mode OldPrologMode = Yap_PrologMode;
prolog_exec_mode OldPrologMode = LOCAL_PrologMode;
Yap_PrologMode = ExtendStackMode;
LOCAL_PrologMode = ExtendStackMode;
/* mapping heap area */
if((shm_id = shmget(IPC_PRIVATE, (size_t)s, SHM_R|SHM_W)) == -1) {
LOCAL_ErrorMessage = LOCAL_ErrorSay;
snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
"could not shmget %d bytes", s);
Yap_PrologMode = OldPrologMode;
LOCAL_PrologMode = OldPrologMode;
return(FALSE);
}
if((ptr = (MALLOC_T)shmat(shm_id, WorkSpaceTop, 0)) == (MALLOC_T) -1) {
LOCAL_ErrorMessage = LOCAL_ErrorSay;
snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
"could not shmat at %p", MMAP_ADDR);
Yap_PrologMode = OldPrologMode;
LOCAL_PrologMode = OldPrologMode;
return(FALSE);
}
if (shmctl(shm_id, IPC_RMID, 0) != 0) {
LOCAL_ErrorMessage = LOCAL_ErrorSay;
snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
"could not remove shm segment", shm_id);
Yap_PrologMode = OldPrologMode;
LOCAL_PrologMode = OldPrologMode;
return(FALSE);
}
WorkSpaceTop = (char *) ptr + s;
Yap_PrologMode = OldPrologMode;
LOCAL_PrologMode = OldPrologMode;
return(TRUE);
}
@ -1290,17 +1294,17 @@ static int
ExtendWorkSpace(Int s)
{
MALLOC_T ptr = (MALLOC_T)sbrk(s);
prolog_exec_mode OldPrologMode = Yap_PrologMode;
prolog_exec_mode OldPrologMode = LOCAL_PrologMode;
Yap_PrologMode = ExtendStackMode;
LOCAL_PrologMode = ExtendStackMode;
if (ptr == ((MALLOC_T) - 1)) {
LOCAL_ErrorMessage = LOCAL_ErrorSay;
snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
"could not expand stacks over %d bytes", s);
Yap_PrologMode = OldPrologMode;
LOCAL_PrologMode = OldPrologMode;
return(FALSE);
}
Yap_PrologMode = OldPrologMode;
LOCAL_PrologMode = OldPrologMode;
return TRUE;
}
@ -1420,9 +1424,9 @@ static int
ExtendWorkSpace(Int s)
{
MALLOC_T ptr;
prolog_exec_mode OldPrologMode = Yap_PrologMode;
prolog_exec_mode OldPrologMode = LOCAL_PrologMode;
Yap_PrologMode = ExtendStackMode;
LOCAL_PrologMode = ExtendStackMode;
total_space += s;
if (total_space < MAX_SPACE) return TRUE;
ptr = (MALLOC_T)realloc((void *)Yap_HeapBase, total_space);
@ -1430,24 +1434,24 @@ ExtendWorkSpace(Int s)
LOCAL_ErrorMessage = LOCAL_ErrorSay;
snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
"could not allocate %d bytes", s);
Yap_PrologMode = OldPrologMode;
LOCAL_PrologMode = OldPrologMode;
return FALSE;
}
if (ptr != (MALLOC_T)Yap_HeapBase) {
LOCAL_ErrorMessage = LOCAL_ErrorSay;
snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
"could not expand contiguous stacks %d bytes", s);
Yap_PrologMode = OldPrologMode;
LOCAL_PrologMode = OldPrologMode;
return FALSE;
}
if ((CELL)ptr & MBIT) {
LOCAL_ErrorMessage = LOCAL_ErrorSay;
snprintf5(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
"memory at %p conflicts with MBIT %lx", ptr, (unsigned long)MBIT);
Yap_PrologMode = OldPrologMode;
LOCAL_PrologMode = OldPrologMode;
return FALSE;
}
Yap_PrologMode = OldPrologMode;
LOCAL_PrologMode = OldPrologMode;
return TRUE;
}
@ -1530,11 +1534,11 @@ Yap_InitMemory(UInt Trail, UInt Heap, UInt Stack)
#ifdef DEBUG
#if SIZEOF_INT_P!=SIZEOF_INT
if (Yap_output_msg) {
if (GLOBAL_output_msg) {
fprintf(stderr, "HeapBase = %p GlobalBase = %p\n LocalBase = %p TrailTop = %p\n",
Yap_HeapBase, LOCAL_GlobalBase, LOCAL_LocalBase, LOCAL_TrailTop);
#else
if (Yap_output_msg) {
if (GLOBAL_output_msg) {
fprintf(stderr, "HeapBase = %x GlobalBase = %x\n LocalBase = %x TrailTop = %x\n",
(UInt) Yap_HeapBase, (UInt) LOCAL_GlobalBase,
(UInt) LOCAL_LocalBase, (UInt) LOCAL_TrailTop);

4
C/amasm.c
View File

@ -434,8 +434,8 @@ DumpOpCodes(void)
while (i < 30) {
for (j = i; j <= _std_top; j += 25)
fprintf(Yap_stderr, "%5d %6lx", j, absmadr(j));
fputc('\n',Yap_stderr);
fprintf(GLOBAL_stderr, "%5d %6lx", j, absmadr(j));
fputc('\n',GLOBAL_stderr);
++i;
}
}

644
C/analyst.c
View File

@ -28,9 +28,7 @@ static char SccsId[] = "%W% %G%";
#include <string.h>
#endif
YAP_ULONG_LONG Yap_opcount[_std_top + 1];
YAP_ULONG_LONG Yap_2opcount[_std_top + 1][_std_top + 1];
STATIC_PROTO(Int p_reset_op_counters, (void));
@ -43,7 +41,7 @@ p_reset_op_counters()
int i;
for (i = 0; i <= _std_top; ++i)
Yap_opcount[i] = 0;
GLOBAL_opcount[i] = 0;
return TRUE;
}
@ -52,26 +50,26 @@ print_instruction(int inst)
{
int j;
fprintf(Yap_stderr, "%s", Yap_op_names[inst]);
fprintf(GLOBAL_stderr, "%s", Yap_op_names[inst]);
for (j = strlen(Yap_op_names[inst]); j < 25; j++)
putc(' ', Yap_stderr);
j = Yap_opcount[inst];
putc(' ', GLOBAL_stderr);
j = GLOBAL_opcount[inst];
if (j < 100000000) {
putc(' ', Yap_stderr);
putc(' ', GLOBAL_stderr);
if (j < 10000000) {
putc(' ', Yap_stderr);
putc(' ', GLOBAL_stderr);
if (j < 1000000) {
putc(' ', Yap_stderr);
putc(' ', GLOBAL_stderr);
if (j < 100000) {
putc(' ', Yap_stderr);
putc(' ', GLOBAL_stderr);
if (j < 10000) {
putc(' ', Yap_stderr);
putc(' ', GLOBAL_stderr);
if (j < 1000) {
putc(' ', Yap_stderr);
putc(' ', GLOBAL_stderr);
if (j < 100) {
putc(' ', Yap_stderr);
putc(' ', GLOBAL_stderr);
if (j < 10) {
putc(' ', Yap_stderr);
putc(' ', GLOBAL_stderr);
}
}
}
@ -80,7 +78,7 @@ print_instruction(int inst)
}
}
}
fprintf(Yap_stderr, "%llu\n", Yap_opcount[inst]);
fprintf(GLOBAL_stderr, "%llu\n", GLOBAL_opcount[inst]);
}
static Int
@ -98,18 +96,18 @@ p_show_op_counters()
wchar_t *program;
program = RepAtom(at1)->WStrOfAE;
fprintf(Yap_stderr, "\n Instructions Executed in %S\n", program);
fprintf(GLOBAL_stderr, "\n Instructions Executed in %S\n", program);
} else {
char *program;
program = RepAtom(at1)->StrOfAE;
fprintf(Yap_stderr, "\n Instructions Executed in %s\n", program);
fprintf(GLOBAL_stderr, "\n Instructions Executed in %s\n", program);
}
}
for (i = 0; i <= _std_top; ++i)
print_instruction(i);
fprintf(Yap_stderr, "\n Control Instructions \n");
fprintf(GLOBAL_stderr, "\n Control Instructions \n");
print_instruction(_op_fail);
print_instruction(_execute);
print_instruction(_dexecute);
@ -121,7 +119,7 @@ p_show_op_counters()
print_instruction(_allocate);
print_instruction(_deallocate);
fprintf(Yap_stderr, "\n Choice Point Manipulation Instructions\n");
fprintf(GLOBAL_stderr, "\n Choice Point Manipulation Instructions\n");
print_instruction(_try_me);
print_instruction(_retry_me);
print_instruction(_trust_me);
@ -130,38 +128,38 @@ p_show_op_counters()
print_instruction(_retry);
print_instruction(_trust);
fprintf(Yap_stderr, "\n Disjunction Instructions\n");
fprintf(GLOBAL_stderr, "\n Disjunction Instructions\n");
print_instruction(_either);
print_instruction(_or_else);
print_instruction(_or_last);
print_instruction(_jump);
print_instruction(_move_back);
fprintf(Yap_stderr, "\n Dynamic Predicates Choicepoint Instructions\n");
fprintf(GLOBAL_stderr, "\n Dynamic Predicates Choicepoint Instructions\n");
print_instruction(_try_and_mark);
print_instruction(_retry_and_mark);
fprintf(Yap_stderr, "\n C Predicates Choicepoint Instructions\n");
fprintf(GLOBAL_stderr, "\n C Predicates Choicepoint Instructions\n");
print_instruction(_try_c);
print_instruction(_retry_c);
fprintf(Yap_stderr, "\n Indexing Instructions\n");
fprintf(Yap_stderr, "\n Switch on Type\n");
fprintf(GLOBAL_stderr, "\n Indexing Instructions\n");
fprintf(GLOBAL_stderr, "\n Switch on Type\n");
print_instruction(_switch_on_type);
print_instruction(_switch_list_nl);
print_instruction(_switch_on_arg_type);
print_instruction(_switch_on_sub_arg_type);
fprintf(Yap_stderr, "\n Switch on Value\n");
fprintf(GLOBAL_stderr, "\n Switch on Value\n");
print_instruction(_if_cons);
print_instruction(_go_on_cons);
print_instruction(_switch_on_cons);
print_instruction(_if_func);
print_instruction(_go_on_func);
print_instruction(_switch_on_func);
fprintf(Yap_stderr, "\n Other Switches\n");
fprintf(GLOBAL_stderr, "\n Other Switches\n");
print_instruction(_if_not_then);
fprintf(Yap_stderr, "\n Get Instructions\n");
fprintf(GLOBAL_stderr, "\n Get Instructions\n");
print_instruction(_get_x_var);
print_instruction(_get_y_var);
print_instruction(_get_x_val);
@ -174,7 +172,7 @@ p_show_op_counters()
print_instruction(_get_6atoms);
print_instruction(_get_list);
print_instruction(_get_struct);
fprintf(Yap_stderr, "\n Optimised Get Instructions\n");
fprintf(GLOBAL_stderr, "\n Optimised Get Instructions\n");
print_instruction(_glist_valx);
print_instruction(_glist_valy);
print_instruction(_gl_void_varx);
@ -182,7 +180,7 @@ p_show_op_counters()
print_instruction(_gl_void_valx);
print_instruction(_gl_void_valy);
fprintf(Yap_stderr, "\n Unify Read Instructions\n");
fprintf(GLOBAL_stderr, "\n Unify Read Instructions\n");
print_instruction(_unify_x_var);
print_instruction(_unify_x_var2);
print_instruction(_unify_y_var);
@ -195,7 +193,7 @@ p_show_op_counters()
print_instruction(_unify_n_voids);
print_instruction(_unify_list);
print_instruction(_unify_struct);
fprintf(Yap_stderr, "\n Unify Last Read Instructions\n");
fprintf(GLOBAL_stderr, "\n Unify Last Read Instructions\n");
print_instruction(_unify_l_x_var);
print_instruction(_unify_l_x_var2);
print_instruction(_unify_l_y_var);
@ -208,7 +206,7 @@ p_show_op_counters()
print_instruction(_unify_l_list);
print_instruction(_unify_l_struc);
fprintf(Yap_stderr, "\n Unify Write Instructions\n");
fprintf(GLOBAL_stderr, "\n Unify Write Instructions\n");
print_instruction(_unify_x_var_write);
print_instruction(_unify_x_var2_write);
print_instruction(_unify_y_var_write);
@ -221,7 +219,7 @@ p_show_op_counters()
print_instruction(_unify_n_voids_write);
print_instruction(_unify_list_write);
print_instruction(_unify_struct_write);
fprintf(Yap_stderr, "\n Unify Last Read Instructions\n");
fprintf(GLOBAL_stderr, "\n Unify Last Read Instructions\n");
print_instruction(_unify_l_x_var_write);
print_instruction(_unify_l_x_var2_write);
print_instruction(_unify_l_y_var_write);
@ -234,7 +232,7 @@ p_show_op_counters()
print_instruction(_unify_l_list_write);
print_instruction(_unify_l_struc_write);
fprintf(Yap_stderr, "\n Put Instructions\n");
fprintf(GLOBAL_stderr, "\n Put Instructions\n");
print_instruction(_put_x_var);
print_instruction(_put_y_var);
print_instruction(_put_x_val);
@ -245,7 +243,7 @@ p_show_op_counters()
print_instruction(_put_list);
print_instruction(_put_struct);
fprintf(Yap_stderr, "\n Write Instructions\n");
fprintf(GLOBAL_stderr, "\n Write Instructions\n");
print_instruction(_write_x_var);
print_instruction(_write_y_var);
print_instruction(_write_x_val);
@ -257,11 +255,11 @@ p_show_op_counters()
print_instruction(_write_n_voids);
print_instruction(_write_list);
print_instruction(_write_struct);
fprintf(Yap_stderr, "\n Last Write Instructions\n");
fprintf(GLOBAL_stderr, "\n Last Write Instructions\n");
print_instruction(_write_l_list);
print_instruction(_write_l_struc);
fprintf(Yap_stderr, "\n Miscellaneous Instructions\n");
fprintf(GLOBAL_stderr, "\n Miscellaneous Instructions\n");
print_instruction(_cut);
print_instruction(_cut_t);
print_instruction(_cut_e);
@ -292,11 +290,11 @@ p_show_op_counters()
typedef struct {
int nxvar, nxval, nyvar, nyval, ncons, nlist, nstru, nmisc;
} uYap_opcount;
} uGLOBAL_opcount;
typedef struct {
int ncalls, nexecs, nproceeds, ncallbips, ncuts, nallocs, ndeallocs;
} cYap_opcount;
} cGLOBAL_opcount;
typedef struct {
int ntries, nretries, ntrusts;
@ -306,8 +304,8 @@ static Int
p_show_ops_by_group(void)
{
uYap_opcount c_get, c_unify, c_put, c_write;
cYap_opcount c_control;
uGLOBAL_opcount c_get, c_unify, c_put, c_write;
cGLOBAL_opcount c_control;
ccpcount c_cp;
int gets, unifies, puts, writes, controls, choice_pts, indexes, misc,
total;
@ -322,261 +320,261 @@ p_show_ops_by_group(void)
wchar_t *program;
program = RepAtom(at1)->WStrOfAE;
fprintf(Yap_stderr, "\n Instructions Executed in %S\n", program);
fprintf(GLOBAL_stderr, "\n Instructions Executed in %S\n", program);
} else {
char *program;
program = RepAtom(at1)->StrOfAE;
fprintf(Yap_stderr, "\n Instructions Executed in %s\n", program);
fprintf(GLOBAL_stderr, "\n Instructions Executed in %s\n", program);
}
c_get.nxvar =
Yap_opcount[_get_x_var];
GLOBAL_opcount[_get_x_var];
c_get.nyvar =
Yap_opcount[_get_y_var];
GLOBAL_opcount[_get_y_var];
c_get.nxval =
Yap_opcount[_get_x_val];
GLOBAL_opcount[_get_x_val];
c_get.nyval =
Yap_opcount[_get_y_val];
GLOBAL_opcount[_get_y_val];
c_get.ncons =
Yap_opcount[_get_atom]+
Yap_opcount[_get_2atoms]+
Yap_opcount[_get_3atoms]+
Yap_opcount[_get_4atoms]+
Yap_opcount[_get_5atoms]+
Yap_opcount[_get_6atoms];
GLOBAL_opcount[_get_atom]+
GLOBAL_opcount[_get_2atoms]+
GLOBAL_opcount[_get_3atoms]+
GLOBAL_opcount[_get_4atoms]+
GLOBAL_opcount[_get_5atoms]+
GLOBAL_opcount[_get_6atoms];
c_get.nlist =
Yap_opcount[_get_list] +
Yap_opcount[_glist_valx] +
Yap_opcount[_glist_valy] +
Yap_opcount[_gl_void_varx] +
Yap_opcount[_gl_void_vary] +
Yap_opcount[_gl_void_valx] +
Yap_opcount[_gl_void_valy];
GLOBAL_opcount[_get_list] +
GLOBAL_opcount[_glist_valx] +
GLOBAL_opcount[_glist_valy] +
GLOBAL_opcount[_gl_void_varx] +
GLOBAL_opcount[_gl_void_vary] +
GLOBAL_opcount[_gl_void_valx] +
GLOBAL_opcount[_gl_void_valy];
c_get.nstru =
Yap_opcount[_get_struct];
GLOBAL_opcount[_get_struct];
gets = c_get.nxvar + c_get.nyvar + c_get.nxval + c_get.nyval +
c_get.ncons + c_get.nlist + c_get.nstru;
c_unify.nxvar =
Yap_opcount[_unify_x_var] +
Yap_opcount[_unify_void] +
Yap_opcount[_unify_n_voids] +
2 * Yap_opcount[_unify_x_var2] +
2 * Yap_opcount[_gl_void_varx] +
Yap_opcount[_gl_void_vary] +
Yap_opcount[_gl_void_valx] +
Yap_opcount[_unify_l_x_var] +
Yap_opcount[_unify_l_void] +
Yap_opcount[_unify_l_n_voids] +
2 * Yap_opcount[_unify_l_x_var2] +
Yap_opcount[_unify_x_var_write] +
Yap_opcount[_unify_void_write] +
Yap_opcount[_unify_n_voids_write] +
2 * Yap_opcount[_unify_x_var2_write] +
Yap_opcount[_unify_l_x_var_write] +
Yap_opcount[_unify_l_void_write] +
Yap_opcount[_unify_l_n_voids_write] +
2 * Yap_opcount[_unify_l_x_var2_write];
GLOBAL_opcount[_unify_x_var] +
GLOBAL_opcount[_unify_void] +
GLOBAL_opcount[_unify_n_voids] +
2 * GLOBAL_opcount[_unify_x_var2] +
2 * GLOBAL_opcount[_gl_void_varx] +
GLOBAL_opcount[_gl_void_vary] +
GLOBAL_opcount[_gl_void_valx] +
GLOBAL_opcount[_unify_l_x_var] +
GLOBAL_opcount[_unify_l_void] +
GLOBAL_opcount[_unify_l_n_voids] +
2 * GLOBAL_opcount[_unify_l_x_var2] +
GLOBAL_opcount[_unify_x_var_write] +
GLOBAL_opcount[_unify_void_write] +
GLOBAL_opcount[_unify_n_voids_write] +
2 * GLOBAL_opcount[_unify_x_var2_write] +
GLOBAL_opcount[_unify_l_x_var_write] +
GLOBAL_opcount[_unify_l_void_write] +
GLOBAL_opcount[_unify_l_n_voids_write] +
2 * GLOBAL_opcount[_unify_l_x_var2_write];
c_unify.nyvar =
Yap_opcount[_unify_y_var] +
Yap_opcount[_gl_void_vary] +
Yap_opcount[_unify_l_y_var] +
Yap_opcount[_unify_y_var_write] +
Yap_opcount[_unify_l_y_var_write];
GLOBAL_opcount[_unify_y_var] +
GLOBAL_opcount[_gl_void_vary] +
GLOBAL_opcount[_unify_l_y_var] +
GLOBAL_opcount[_unify_y_var_write] +
GLOBAL_opcount[_unify_l_y_var_write];
c_unify.nxval =
Yap_opcount[_unify_x_val] +
Yap_opcount[_unify_x_loc] +
Yap_opcount[_glist_valx] +
Yap_opcount[_gl_void_valx] +
Yap_opcount[_unify_l_x_val] +
Yap_opcount[_unify_l_x_loc] +
Yap_opcount[_unify_x_val_write] +
Yap_opcount[_unify_x_loc_write] +
Yap_opcount[_unify_l_x_val_write] +
Yap_opcount[_unify_l_x_loc_write];
GLOBAL_opcount[_unify_x_val] +
GLOBAL_opcount[_unify_x_loc] +
GLOBAL_opcount[_glist_valx] +
GLOBAL_opcount[_gl_void_valx] +
GLOBAL_opcount[_unify_l_x_val] +
GLOBAL_opcount[_unify_l_x_loc] +
GLOBAL_opcount[_unify_x_val_write] +
GLOBAL_opcount[_unify_x_loc_write] +
GLOBAL_opcount[_unify_l_x_val_write] +
GLOBAL_opcount[_unify_l_x_loc_write];
c_unify.nyval =
Yap_opcount[_unify_y_val] +
Yap_opcount[_unify_y_loc] +
Yap_opcount[_glist_valy] +
Yap_opcount[_gl_void_valy] +
Yap_opcount[_unify_l_y_val] +
Yap_opcount[_unify_l_y_loc] +
Yap_opcount[_unify_y_val_write] +
Yap_opcount[_unify_y_loc_write] +
Yap_opcount[_unify_l_y_val_write] +
Yap_opcount[_unify_l_y_loc_write];
GLOBAL_opcount[_unify_y_val] +
GLOBAL_opcount[_unify_y_loc] +
GLOBAL_opcount[_glist_valy] +
GLOBAL_opcount[_gl_void_valy] +
GLOBAL_opcount[_unify_l_y_val] +
GLOBAL_opcount[_unify_l_y_loc] +
GLOBAL_opcount[_unify_y_val_write] +
GLOBAL_opcount[_unify_y_loc_write] +
GLOBAL_opcount[_unify_l_y_val_write] +
GLOBAL_opcount[_unify_l_y_loc_write];
c_unify.ncons =
Yap_opcount[_unify_atom] +
Yap_opcount[_unify_n_atoms] +
Yap_opcount[_unify_l_atom] +
Yap_opcount[_unify_atom_write] +
Yap_opcount[_unify_n_atoms_write] +
Yap_opcount[_unify_l_atom_write];
GLOBAL_opcount[_unify_atom] +
GLOBAL_opcount[_unify_n_atoms] +
GLOBAL_opcount[_unify_l_atom] +
GLOBAL_opcount[_unify_atom_write] +
GLOBAL_opcount[_unify_n_atoms_write] +
GLOBAL_opcount[_unify_l_atom_write];
c_unify.nlist =
Yap_opcount[_unify_list] +
Yap_opcount[_unify_l_list] +
Yap_opcount[_unify_list_write] +
Yap_opcount[_unify_l_list_write];
GLOBAL_opcount[_unify_list] +
GLOBAL_opcount[_unify_l_list] +
GLOBAL_opcount[_unify_list_write] +
GLOBAL_opcount[_unify_l_list_write];
c_unify.nstru =
Yap_opcount[_unify_struct] +
Yap_opcount[_unify_l_struc] +
Yap_opcount[_unify_struct_write] +
Yap_opcount[_unify_l_struc_write];
GLOBAL_opcount[_unify_struct] +
GLOBAL_opcount[_unify_l_struc] +
GLOBAL_opcount[_unify_struct_write] +
GLOBAL_opcount[_unify_l_struc_write];
c_unify.nmisc =
Yap_opcount[_pop] +
Yap_opcount[_pop_n];
GLOBAL_opcount[_pop] +
GLOBAL_opcount[_pop_n];
unifies = c_unify.nxvar + c_unify.nyvar + c_unify.nxval + c_unify.nyval +
c_unify.ncons + c_unify.nlist + c_unify.nstru + c_unify.nmisc;
c_put.nxvar =
Yap_opcount[_put_x_var];
GLOBAL_opcount[_put_x_var];
c_put.nyvar =
Yap_opcount[_put_y_var];
GLOBAL_opcount[_put_y_var];
c_put.nxval =
Yap_opcount[_put_x_val]+
2*Yap_opcount[_put_xx_val];
GLOBAL_opcount[_put_x_val]+
2*GLOBAL_opcount[_put_xx_val];
c_put.nyval =
Yap_opcount[_put_y_val];
GLOBAL_opcount[_put_y_val];
c_put.ncons =
Yap_opcount[_put_atom];
GLOBAL_opcount[_put_atom];
c_put.nlist =
Yap_opcount[_put_list];
GLOBAL_opcount[_put_list];
c_put.nstru =
Yap_opcount[_put_struct];
GLOBAL_opcount[_put_struct];
puts = c_put.nxvar + c_put.nyvar + c_put.nxval + c_put.nyval +
c_put.ncons + c_put.nlist + c_put.nstru;
c_write.nxvar =
Yap_opcount[_write_x_var] +
Yap_opcount[_write_void] +
Yap_opcount[_write_n_voids];
GLOBAL_opcount[_write_x_var] +
GLOBAL_opcount[_write_void] +
GLOBAL_opcount[_write_n_voids];
c_write.nyvar =
Yap_opcount[_write_y_var];
GLOBAL_opcount[_write_y_var];
c_write.nxval =
Yap_opcount[_write_x_val];
GLOBAL_opcount[_write_x_val];
c_write.nyval =
Yap_opcount[_write_y_val];
GLOBAL_opcount[_write_y_val];
c_write.ncons =
Yap_opcount[_write_atom];
GLOBAL_opcount[_write_atom];
c_write.nlist =
Yap_opcount[_write_list];
GLOBAL_opcount[_write_list];
c_write.nstru =
Yap_opcount[_write_struct];
GLOBAL_opcount[_write_struct];
writes = c_write.nxvar + c_write.nyvar + c_write.nxval + c_write.nyval +
c_write.ncons + c_write.nlist + c_write.nstru;
c_control.nexecs =
Yap_opcount[_execute] +
Yap_opcount[_dexecute];
GLOBAL_opcount[_execute] +
GLOBAL_opcount[_dexecute];
c_control.ncalls =
Yap_opcount[_call] +
Yap_opcount[_fcall];
GLOBAL_opcount[_call] +
GLOBAL_opcount[_fcall];
c_control.nproceeds =
Yap_opcount[_procceed];
GLOBAL_opcount[_procceed];
c_control.ncallbips =
Yap_opcount[_call_cpred] +
Yap_opcount[_call_c_wfail] +
Yap_opcount[_try_c] +
Yap_opcount[_retry_c] +
Yap_opcount[_op_fail] +
Yap_opcount[_trust_fail] +
Yap_opcount[_p_atom_x] +
Yap_opcount[_p_atom_y] +
Yap_opcount[_p_atomic_x] +
Yap_opcount[_p_atomic_y] +
Yap_opcount[_p_compound_x] +
Yap_opcount[_p_compound_y] +
Yap_opcount[_p_float_x] +
Yap_opcount[_p_float_y] +
Yap_opcount[_p_integer_x] +
Yap_opcount[_p_integer_y] +
Yap_opcount[_p_nonvar_x] +
Yap_opcount[_p_nonvar_y] +
Yap_opcount[_p_number_x] +
Yap_opcount[_p_number_y] +
Yap_opcount[_p_var_x] +
Yap_opcount[_p_var_y] +
Yap_opcount[_p_db_ref_x] +
Yap_opcount[_p_db_ref_y] +
Yap_opcount[_p_cut_by_x] +
Yap_opcount[_p_cut_by_y] +
Yap_opcount[_p_primitive_x] +
Yap_opcount[_p_primitive_y] +
Yap_opcount[_p_equal] +
Yap_opcount[_p_plus_vv] +
Yap_opcount[_p_plus_vc] +
Yap_opcount[_p_plus_y_vv] +
Yap_opcount[_p_plus_y_vc] +
Yap_opcount[_p_minus_vv] +
Yap_opcount[_p_minus_cv] +
Yap_opcount[_p_minus_y_vv] +
Yap_opcount[_p_minus_y_cv] +
Yap_opcount[_p_times_vv] +
Yap_opcount[_p_times_vc] +
Yap_opcount[_p_times_y_vv] +
Yap_opcount[_p_times_y_vc] +
Yap_opcount[_p_div_vv] +
Yap_opcount[_p_div_vc] +
Yap_opcount[_p_div_cv] +
Yap_opcount[_p_div_y_vv] +
Yap_opcount[_p_div_y_vc] +
Yap_opcount[_p_div_y_cv] +
Yap_opcount[_p_or_vv] +
Yap_opcount[_p_or_vc] +
Yap_opcount[_p_or_y_vv] +
Yap_opcount[_p_or_y_vc] +
Yap_opcount[_p_and_vv] +
Yap_opcount[_p_and_vc] +
Yap_opcount[_p_and_y_vv] +
Yap_opcount[_p_and_y_vc] +
Yap_opcount[_p_sll_vv] +
Yap_opcount[_p_sll_vc] +
Yap_opcount[_p_sll_y_vv] +
Yap_opcount[_p_sll_y_vc] +
Yap_opcount[_p_slr_vv] +
Yap_opcount[_p_slr_vc] +
Yap_opcount[_p_slr_y_vv] +
Yap_opcount[_p_slr_y_vc] +
Yap_opcount[_p_dif] +
Yap_opcount[_p_eq] +
Yap_opcount[_p_arg_vv] +
Yap_opcount[_p_arg_cv] +
Yap_opcount[_p_arg_y_vv] +
Yap_opcount[_p_arg_y_cv] +
Yap_opcount[_p_functor] +
Yap_opcount[_p_func2s_vv] +
Yap_opcount[_p_func2s_cv] +
Yap_opcount[_p_func2s_vc] +
Yap_opcount[_p_func2s_y_vv] +
Yap_opcount[_p_func2s_y_cv] +
Yap_opcount[_p_func2s_y_vc] +
Yap_opcount[_p_func2f_xx] +
Yap_opcount[_p_func2f_xy] +
Yap_opcount[_p_func2f_yx] +
Yap_opcount[_p_func2f_yy];
GLOBAL_opcount[_call_cpred] +
GLOBAL_opcount[_call_c_wfail] +
GLOBAL_opcount[_try_c] +
GLOBAL_opcount[_retry_c] +
GLOBAL_opcount[_op_fail] +
GLOBAL_opcount[_trust_fail] +
GLOBAL_opcount[_p_atom_x] +
GLOBAL_opcount[_p_atom_y] +
GLOBAL_opcount[_p_atomic_x] +
GLOBAL_opcount[_p_atomic_y] +
GLOBAL_opcount[_p_compound_x] +
GLOBAL_opcount[_p_compound_y] +
GLOBAL_opcount[_p_float_x] +
GLOBAL_opcount[_p_float_y] +
GLOBAL_opcount[_p_integer_x] +
GLOBAL_opcount[_p_integer_y] +
GLOBAL_opcount[_p_nonvar_x] +
GLOBAL_opcount[_p_nonvar_y] +
GLOBAL_opcount[_p_number_x] +
GLOBAL_opcount[_p_number_y] +
GLOBAL_opcount[_p_var_x] +
GLOBAL_opcount[_p_var_y] +
GLOBAL_opcount[_p_db_ref_x] +
GLOBAL_opcount[_p_db_ref_y] +
GLOBAL_opcount[_p_cut_by_x] +
GLOBAL_opcount[_p_cut_by_y] +
GLOBAL_opcount[_p_primitive_x] +
GLOBAL_opcount[_p_primitive_y] +
GLOBAL_opcount[_p_equal] +
GLOBAL_opcount[_p_plus_vv] +
GLOBAL_opcount[_p_plus_vc] +
GLOBAL_opcount[_p_plus_y_vv] +
GLOBAL_opcount[_p_plus_y_vc] +
GLOBAL_opcount[_p_minus_vv] +
GLOBAL_opcount[_p_minus_cv] +
GLOBAL_opcount[_p_minus_y_vv] +
GLOBAL_opcount[_p_minus_y_cv] +
GLOBAL_opcount[_p_times_vv] +
GLOBAL_opcount[_p_times_vc] +
GLOBAL_opcount[_p_times_y_vv] +
GLOBAL_opcount[_p_times_y_vc] +
GLOBAL_opcount[_p_div_vv] +
GLOBAL_opcount[_p_div_vc] +
GLOBAL_opcount[_p_div_cv] +
GLOBAL_opcount[_p_div_y_vv] +
GLOBAL_opcount[_p_div_y_vc] +
GLOBAL_opcount[_p_div_y_cv] +
GLOBAL_opcount[_p_or_vv] +
GLOBAL_opcount[_p_or_vc] +
GLOBAL_opcount[_p_or_y_vv] +
GLOBAL_opcount[_p_or_y_vc] +
GLOBAL_opcount[_p_and_vv] +
GLOBAL_opcount[_p_and_vc] +
GLOBAL_opcount[_p_and_y_vv] +
GLOBAL_opcount[_p_and_y_vc] +
GLOBAL_opcount[_p_sll_vv] +
GLOBAL_opcount[_p_sll_vc] +
GLOBAL_opcount[_p_sll_y_vv] +
GLOBAL_opcount[_p_sll_y_vc] +
GLOBAL_opcount[_p_slr_vv] +
GLOBAL_opcount[_p_slr_vc] +
GLOBAL_opcount[_p_slr_y_vv] +
GLOBAL_opcount[_p_slr_y_vc] +
GLOBAL_opcount[_p_dif] +
GLOBAL_opcount[_p_eq] +
GLOBAL_opcount[_p_arg_vv] +
GLOBAL_opcount[_p_arg_cv] +
GLOBAL_opcount[_p_arg_y_vv] +
GLOBAL_opcount[_p_arg_y_cv] +
GLOBAL_opcount[_p_functor] +
GLOBAL_opcount[_p_func2s_vv] +
GLOBAL_opcount[_p_func2s_cv] +
GLOBAL_opcount[_p_func2s_vc] +
GLOBAL_opcount[_p_func2s_y_vv] +
GLOBAL_opcount[_p_func2s_y_cv] +
GLOBAL_opcount[_p_func2s_y_vc] +
GLOBAL_opcount[_p_func2f_xx] +
GLOBAL_opcount[_p_func2f_xy] +
GLOBAL_opcount[_p_func2f_yx] +
GLOBAL_opcount[_p_func2f_yy];
c_control.ncuts =
Yap_opcount[_cut] +
Yap_opcount[_cut_t] +
Yap_opcount[_cut_e] +
Yap_opcount[_commit_b_x] +
Yap_opcount[_commit_b_y];
GLOBAL_opcount[_cut] +
GLOBAL_opcount[_cut_t] +
GLOBAL_opcount[_cut_e] +
GLOBAL_opcount[_commit_b_x] +
GLOBAL_opcount[_commit_b_y];
c_control.nallocs =
Yap_opcount[_allocate] +
Yap_opcount[_fcall];
GLOBAL_opcount[_allocate] +
GLOBAL_opcount[_fcall];
c_control.ndeallocs =
Yap_opcount[_dexecute] +
Yap_opcount[_deallocate];
GLOBAL_opcount[_dexecute] +
GLOBAL_opcount[_deallocate];
controls =
c_control.nexecs +
@ -585,30 +583,30 @@ p_show_ops_by_group(void)
c_control.ncuts +
c_control.nallocs +
c_control.ndeallocs +
Yap_opcount[_jump] +
Yap_opcount[_move_back] +
Yap_opcount[_try_in];
GLOBAL_opcount[_jump] +
GLOBAL_opcount[_move_back] +
GLOBAL_opcount[_try_in];
c_cp.ntries =
Yap_opcount[_try_me] +
Yap_opcount[_try_and_mark] +
Yap_opcount[_try_c] +
Yap_opcount[_try_clause] +
Yap_opcount[_either];
GLOBAL_opcount[_try_me] +
GLOBAL_opcount[_try_and_mark] +
GLOBAL_opcount[_try_c] +
GLOBAL_opcount[_try_clause] +
GLOBAL_opcount[_either];
c_cp.nretries =
Yap_opcount[_retry_me] +
Yap_opcount[_retry_and_mark] +
Yap_opcount[_retry_c] +
Yap_opcount[_retry] +
Yap_opcount[_or_else];
GLOBAL_opcount[_retry_me] +
GLOBAL_opcount[_retry_and_mark] +
GLOBAL_opcount[_retry_c] +
GLOBAL_opcount[_retry] +
GLOBAL_opcount[_or_else];
c_cp.ntrusts =
Yap_opcount[_trust_me] +
Yap_opcount[_trust] +
Yap_opcount[_or_last];
GLOBAL_opcount[_trust_me] +
GLOBAL_opcount[_trust] +
GLOBAL_opcount[_or_last];
choice_pts =
c_cp.ntries +
@ -616,70 +614,70 @@ p_show_ops_by_group(void)
c_cp.ntrusts;
indexes =
Yap_opcount[_jump_if_var] +
Yap_opcount[_switch_on_type] +
Yap_opcount[_switch_list_nl] +
Yap_opcount[_switch_on_arg_type] +
Yap_opcount[_switch_on_sub_arg_type] +
Yap_opcount[_switch_on_cons] +
Yap_opcount[_go_on_cons] +
Yap_opcount[_if_cons] +
Yap_opcount[_switch_on_func] +
Yap_opcount[_go_on_func] +
Yap_opcount[_if_func] +
Yap_opcount[_if_not_then];
GLOBAL_opcount[_jump_if_var] +
GLOBAL_opcount[_switch_on_type] +
GLOBAL_opcount[_switch_list_nl] +
GLOBAL_opcount[_switch_on_arg_type] +
GLOBAL_opcount[_switch_on_sub_arg_type] +
GLOBAL_opcount[_switch_on_cons] +
GLOBAL_opcount[_go_on_cons] +
GLOBAL_opcount[_if_cons] +
GLOBAL_opcount[_switch_on_func] +
GLOBAL_opcount[_go_on_func] +
GLOBAL_opcount[_if_func] +
GLOBAL_opcount[_if_not_then];
misc =
c_control.ncallbips +
Yap_opcount[_Ystop] +
Yap_opcount[_Nstop] +
Yap_opcount[_index_pred] +
Yap_opcount[_lock_pred] +
GLOBAL_opcount[_Ystop] +
GLOBAL_opcount[_Nstop] +
GLOBAL_opcount[_index_pred] +
GLOBAL_opcount[_lock_pred] +
#if THREADS
Yap_opcount[_thread_local] +
GLOBAL_opcount[_thread_local] +
#endif
Yap_opcount[_save_b_x] +
Yap_opcount[_save_b_y] +
Yap_opcount[_undef_p] +
Yap_opcount[_spy_pred] +
Yap_opcount[_spy_or_trymark] +
Yap_opcount[_save_pair_x] +
Yap_opcount[_save_pair_y] +
Yap_opcount[_save_pair_x_write] +
Yap_opcount[_save_pair_y_write] +
Yap_opcount[_save_appl_x] +
Yap_opcount[_save_appl_y] +
Yap_opcount[_save_appl_x_write] +
Yap_opcount[_save_appl_y_write];
GLOBAL_opcount[_save_b_x] +
GLOBAL_opcount[_save_b_y] +
GLOBAL_opcount[_undef_p] +
GLOBAL_opcount[_spy_pred] +
GLOBAL_opcount[_spy_or_trymark] +
GLOBAL_opcount[_save_pair_x] +
GLOBAL_opcount[_save_pair_y] +
GLOBAL_opcount[_save_pair_x_write] +
GLOBAL_opcount[_save_pair_y_write] +
GLOBAL_opcount[_save_appl_x] +
GLOBAL_opcount[_save_appl_y] +
GLOBAL_opcount[_save_appl_x_write] +
GLOBAL_opcount[_save_appl_y_write];
total = gets + unifies + puts + writes + controls + choice_pts + indexes + misc;
/* for (i = 0; i <= _std_top; ++i)
* print_instruction(i);
*/
fprintf(Yap_stderr, "Groups are\n\n");
fprintf(Yap_stderr, " GET instructions: %8d (%3d%%)\n", gets,
fprintf(GLOBAL_stderr, "Groups are\n\n");
fprintf(GLOBAL_stderr, " GET instructions: %8d (%3d%%)\n", gets,
(gets * 100) / total);
fprintf(Yap_stderr, " UNIFY instructions: %8d (%3d%%)\n", unifies,
fprintf(GLOBAL_stderr, " UNIFY instructions: %8d (%3d%%)\n", unifies,
(unifies * 100) / total);
fprintf(Yap_stderr, " PUT instructions: %8d (%3d%%)\n", puts,
fprintf(GLOBAL_stderr, " PUT instructions: %8d (%3d%%)\n", puts,
(puts * 100) / total);
fprintf(Yap_stderr, " WRITE instructions: %8d (%3d%%)\n", writes,
fprintf(GLOBAL_stderr, " WRITE instructions: %8d (%3d%%)\n", writes,
(writes * 100) / total);
fprintf(Yap_stderr, " CONTROL instructions: %8d (%3d%%)\n", controls,
fprintf(GLOBAL_stderr, " CONTROL instructions: %8d (%3d%%)\n", controls,
(controls * 100) / total);
fprintf(Yap_stderr, " CHOICE POINT instructions: %8d (%3d%%)\n", choice_pts,
fprintf(GLOBAL_stderr, " CHOICE POINT instructions: %8d (%3d%%)\n", choice_pts,
(choice_pts * 100) / total);
fprintf(Yap_stderr, " INDEXING instructions: %8d (%3d%%)\n", indexes,
fprintf(GLOBAL_stderr, " INDEXING instructions: %8d (%3d%%)\n", indexes,
(indexes * 100) / total);
fprintf(Yap_stderr, " MISCELLANEOUS instructions: %8d (%3d%%)\n", misc,
fprintf(GLOBAL_stderr, " MISCELLANEOUS instructions: %8d (%3d%%)\n", misc,
(misc * 100) / total);
fprintf(Yap_stderr, "_______________________________________________\n");
fprintf(Yap_stderr, " TOTAL instructions: %8d (%3d%%)\n\n", total,
fprintf(GLOBAL_stderr, "_______________________________________________\n");
fprintf(GLOBAL_stderr, " TOTAL instructions: %8d (%3d%%)\n\n", total,
(total * 100) / total);
fprintf(Yap_stderr, "\n Analysis of Unification Instructions in %s \n", program);
fprintf(Yap_stderr, " XVAR, YVAR, XVAL, YVAL, CONS, LIST, STRUCT\n");
fprintf(Yap_stderr, " GET: %8d %8d %8d %8d %8d %8d %8d\n",
fprintf(GLOBAL_stderr, "\n Analysis of Unification Instructions in %s \n", program);
fprintf(GLOBAL_stderr, " XVAR, YVAR, XVAL, YVAL, CONS, LIST, STRUCT\n");
fprintf(GLOBAL_stderr, " GET: %8d %8d %8d %8d %8d %8d %8d\n",
c_get.nxvar,
c_get.nyvar,
c_get.nxval,
@ -687,7 +685,7 @@ p_show_ops_by_group(void)
c_get.ncons,
c_get.nlist,
c_get.nstru);
fprintf(Yap_stderr, "UNIFY: %8d %8d %8d %8d %8d %8d %8d\n",
fprintf(GLOBAL_stderr, "UNIFY: %8d %8d %8d %8d %8d %8d %8d\n",
c_unify.nxvar,
c_unify.nyvar,
c_unify.nxval,
@ -695,7 +693,7 @@ p_show_ops_by_group(void)
c_unify.ncons,
c_unify.nlist,
c_unify.nstru);
fprintf(Yap_stderr, " PUT: %8d %8d %8d %8d %8d %8d %8d\n",
fprintf(GLOBAL_stderr, " PUT: %8d %8d %8d %8d %8d %8d %8d\n",
c_put.nxvar,
c_put.nyvar,
c_put.nxval,
@ -703,7 +701,7 @@ p_show_ops_by_group(void)
c_put.ncons,
c_put.nlist,
c_put.nstru);
fprintf(Yap_stderr, "WRITE: %8d %8d %8d %8d %8d %8d %8d\n",
fprintf(GLOBAL_stderr, "WRITE: %8d %8d %8d %8d %8d %8d %8d\n",
c_write.nxvar,
c_write.nyvar,
c_write.nxval,
@ -711,8 +709,8 @@ p_show_ops_by_group(void)
c_write.ncons,
c_write.nlist,
c_write.nstru);
fprintf(Yap_stderr, " ___________________________________________________\n");
fprintf(Yap_stderr, "TOTAL: %8d %8d %8d %8d %8d %8d %8d\n",
fprintf(GLOBAL_stderr, " ___________________________________________________\n");
fprintf(GLOBAL_stderr, "TOTAL: %8d %8d %8d %8d %8d %8d %8d\n",
c_get.nxvar + c_unify.nxvar + c_put.nxvar + c_write.nxvar,
c_get.nyvar + c_unify.nyvar + c_put.nyvar + c_write.nyvar,
c_get.nxval + c_unify.nxval + c_put.nxval + c_write.nxval,
@ -722,9 +720,9 @@ p_show_ops_by_group(void)
c_get.nstru + c_unify.nstru + c_put.nstru + c_write.nstru
);
fprintf(Yap_stderr, "\n Analysis of Unification Instructions in %s \n", program);
fprintf(Yap_stderr, " XVAR, YVAR, XVAL, YVAL, CONS, LIST, STRUCT\n");
fprintf(Yap_stderr, " GET: %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%%\n",
fprintf(GLOBAL_stderr, "\n Analysis of Unification Instructions in %s \n", program);
fprintf(GLOBAL_stderr, " XVAR, YVAR, XVAL, YVAL, CONS, LIST, STRUCT\n");
fprintf(GLOBAL_stderr, " GET: %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%%\n",
(((double) c_get.nxvar) * 100) / total,
(((double) c_get.nyvar) * 100) / total,
(((double) c_get.nxval) * 100) / total,
@ -732,7 +730,7 @@ p_show_ops_by_group(void)
(((double) c_get.ncons) * 100) / total,
(((double) c_get.nlist) * 100) / total,
(((double) c_get.nstru) * 100) / total);
fprintf(Yap_stderr, "UNIFY: %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%%\n",
fprintf(GLOBAL_stderr, "UNIFY: %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%%\n",
(((double) c_unify.nxvar) * 100) / total,
(((double) c_unify.nyvar) * 100) / total,
(((double) c_unify.nxval) * 100) / total,
@ -740,7 +738,7 @@ p_show_ops_by_group(void)
(((double) c_unify.ncons) * 100) / total,
(((double) c_unify.nlist) * 100) / total,
(((double) c_unify.nstru) * 100) / total);
fprintf(Yap_stderr, " PUT: %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%%\n",
fprintf(GLOBAL_stderr, " PUT: %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%%\n",
(((double) c_put.nxvar) * 100) / total,
(((double) c_put.nyvar) * 100) / total,
(((double) c_put.nxval) * 100) / total,
@ -748,7 +746,7 @@ p_show_ops_by_group(void)
(((double) c_put.ncons) * 100) / total,
(((double) c_put.nlist) * 100) / total,
(((double) c_put.nstru) * 100) / total);
fprintf(Yap_stderr, "WRITE: %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%%\n",
fprintf(GLOBAL_stderr, "WRITE: %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%%\n",
(((double) c_write.nxvar) * 100) / total,
(((double) c_write.nyvar) * 100) / total,
(((double) c_write.nxval) * 100) / total,
@ -756,8 +754,8 @@ p_show_ops_by_group(void)
(((double) c_write.ncons) * 100) / total,
(((double) c_write.nlist) * 100) / total,
(((double) c_write.nstru) * 100) / total);
fprintf(Yap_stderr, " ___________________________________________________\n");
fprintf(Yap_stderr, "TOTAL: %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%%\n",
fprintf(GLOBAL_stderr, " ___________________________________________________\n");
fprintf(GLOBAL_stderr, "TOTAL: %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%% %3.2f%%\n",
(((double) c_get.nxvar + c_unify.nxvar + c_put.nxvar + c_write.nxvar) * 100) / total,
(((double) c_get.nyvar + c_unify.nyvar + c_put.nyvar + c_write.nyvar) * 100) / total,
(((double) c_get.nxval + c_unify.nxval + c_put.nxval + c_write.nxval) * 100) / total,
@ -767,36 +765,36 @@ p_show_ops_by_group(void)
(((double) c_get.nstru + c_unify.nstru + c_put.nstru + c_write.nstru) * 100) / total
);
fprintf(Yap_stderr, "\n Control Instructions Executed in %s \n", program);
fprintf(Yap_stderr, "Grouped as\n\n");
fprintf(Yap_stderr, " CALL instructions: %8d (%3d%%)\n",
fprintf(GLOBAL_stderr, "\n Control Instructions Executed in %s \n", program);
fprintf(GLOBAL_stderr, "Grouped as\n\n");
fprintf(GLOBAL_stderr, " CALL instructions: %8d (%3d%%)\n",
c_control.ncalls, (c_control.ncalls * 100) / total);
fprintf(Yap_stderr, " PROCEED instructions: %8d (%3d%%)\n",
fprintf(GLOBAL_stderr, " PROCEED instructions: %8d (%3d%%)\n",
c_control.nproceeds, (c_control.nproceeds * 100) / total);
fprintf(Yap_stderr, " EXECUTE instructions: %8d (%3d%%)\n",
fprintf(GLOBAL_stderr, " EXECUTE instructions: %8d (%3d%%)\n",
c_control.nexecs, (c_control.nexecs * 100) / total);
fprintf(Yap_stderr, " CUT instructions: %8d (%3d%%)\n",
fprintf(GLOBAL_stderr, " CUT instructions: %8d (%3d%%)\n",
c_control.ncuts, (c_control.ncuts * 100) / total);
fprintf(Yap_stderr, " CALL_BIP instructions: %8d (%3d%%)\n",
fprintf(GLOBAL_stderr, " CALL_BIP instructions: %8d (%3d%%)\n",
c_control.ncallbips, (c_control.ncallbips * 100) / total);
fprintf(Yap_stderr, " ALLOCATE instructions: %8d (%3d%%)\n",
fprintf(GLOBAL_stderr, " ALLOCATE instructions: %8d (%3d%%)\n",
c_control.nallocs, (c_control.nallocs * 100) / total);
fprintf(Yap_stderr, " DEALLOCATE instructions: %8d (%3d%%)\n",
fprintf(GLOBAL_stderr, " DEALLOCATE instructions: %8d (%3d%%)\n",
c_control.ndeallocs, (c_control.ndeallocs * 100) / total);
fprintf(Yap_stderr, "_______________________________________________\n");
fprintf(Yap_stderr, " TOTAL instructions: %8d (%3d%%)\n\n", total,
fprintf(GLOBAL_stderr, "_______________________________________________\n");
fprintf(GLOBAL_stderr, " TOTAL instructions: %8d (%3d%%)\n\n", total,
(total * 100) / total);
fprintf(Yap_stderr, "\n Choice Point Manipulation Instructions Executed in %s \n", program);
fprintf(Yap_stderr, "Grouped as\n\n");
fprintf(Yap_stderr, " TRY instructions: %8d (%3d%%)\n",
fprintf(GLOBAL_stderr, "\n Choice Point Manipulation Instructions Executed in %s \n", program);
fprintf(GLOBAL_stderr, "Grouped as\n\n");
fprintf(GLOBAL_stderr, " TRY instructions: %8d (%3d%%)\n",
c_cp.ntries, (c_cp.ntries * 100) / total);
fprintf(Yap_stderr, " RETRY instructions: %8d (%3d%%)\n",
fprintf(GLOBAL_stderr, " RETRY instructions: %8d (%3d%%)\n",
c_cp.nretries, (c_cp.nretries * 100) / total);
fprintf(Yap_stderr, " TRUST instructions: %8d (%3d%%)\n",
fprintf(GLOBAL_stderr, " TRUST instructions: %8d (%3d%%)\n",
c_cp.ntrusts, (c_cp.ntrusts * 100) / total);
fprintf(Yap_stderr, "_______________________________________________\n");
fprintf(Yap_stderr, " TOTAL instructions: %8d (%3d%%)\n\n", total,
fprintf(GLOBAL_stderr, "_______________________________________________\n");
fprintf(GLOBAL_stderr, " TOTAL instructions: %8d (%3d%%)\n\n", total,
(total * 100) / total);
return TRUE;
@ -828,7 +826,7 @@ p_show_sequences(void)
return FALSE;
}
for (i = 0; i <= _std_top; ++i) {
sum += Yap_opcount[i];
sum += GLOBAL_opcount[i];
}
for (i = 0; i <= _std_top; ++i) {
for (j = 0; j <= _std_top; ++j) {

11
C/arrays.c
View File

@ -158,12 +158,11 @@ typedef struct MMAP_ARRAY_BLOCK {
struct MMAP_ARRAY_BLOCK *next;
} mmap_array_block;
static mmap_array_block *mmap_arrays = NULL;
static Int
CloseMmappedArray(StaticArrayEntry *pp, void *area USES_REGS)
{
mmap_array_block *ptr = mmap_arrays, *optr = mmap_arrays;
mmap_array_block *ptr = GLOBAL_mmap_arrays, *optr = GLOBAL_mmap_arrays;
while (ptr != NULL && ptr->start != area) {
ptr = ptr->next;
@ -193,7 +192,7 @@ CloseMmappedArray(StaticArrayEntry *pp, void *area USES_REGS)
static void
ResizeMmappedArray(StaticArrayEntry *pp, Int dim, void *area USES_REGS)
{
mmap_array_block *ptr = mmap_arrays;
mmap_array_block *ptr = GLOBAL_mmap_arrays;
size_t total_size;
while (ptr != NULL && ptr->start != area) {
ptr = ptr->next;
@ -1383,8 +1382,8 @@ p_create_mmapped_array( USES_REGS1 )
ptr->items = size;
ptr->start = (void *)array_addr;
ptr->fd = fd;
ptr->next = mmap_arrays;
mmap_arrays = ptr;
ptr->next = GLOBAL_mmap_arrays;
GLOBAL_mmap_arrays = ptr;
WRITE_UNLOCK(pp->ArRWLock);
WRITE_UNLOCK(ae->ARWLock);
return TRUE;
@ -2244,7 +2243,7 @@ static Int
p_sync_mmapped_arrays( USES_REGS1 )
{
#ifdef HAVE_MMAP
mmap_array_block *ptr = mmap_arrays;
mmap_array_block *ptr = GLOBAL_mmap_arrays;
while (ptr != NULL) {
msync(ptr->start, ptr->size, MS_SYNC);
ptr = ptr->next;

10
C/attvar.c
View File

@ -1044,11 +1044,11 @@ void Yap_InitAttVarPreds(void)
Term OldCurrentModule = CurrentModule;
CurrentModule = ATTRIBUTES_MODULE;
#ifdef COROUTINING
attas[attvars_ext].bind_op = WakeAttVar;
attas[attvars_ext].copy_term_op = CopyAttVar;
attas[attvars_ext].to_term_op = AttVarToTerm;
attas[attvars_ext].term_to_op = TermToAttVar;
attas[attvars_ext].mark_op = mark_attvar;
GLOBAL_attas[attvars_ext].bind_op = WakeAttVar;
GLOBAL_attas[attvars_ext].copy_term_op = CopyAttVar;
GLOBAL_attas[attvars_ext].to_term_op = AttVarToTerm;
GLOBAL_attas[attvars_ext].term_to_op = TermToAttVar;
GLOBAL_attas[attvars_ext].mark_op = mark_attvar;
Yap_InitCPred("get_att", 4, p_get_att, SafePredFlag);
Yap_InitCPred("get_module_atts", 2, p_get_atts, SafePredFlag);
Yap_InitCPred("has_module_atts", 2, p_has_atts, SafePredFlag);

40
C/c_interface.c
View File

@ -2138,9 +2138,9 @@ run_emulator(YAP_dogoalinfo *dgi)
int out;
BACKUP_MACHINE_REGS();
Yap_PrologMode = UserMode;
LOCAL_PrologMode = UserMode;
out = Yap_absmi(0);
Yap_PrologMode = UserCCallMode;
LOCAL_PrologMode = UserCCallMode;
myB = (choiceptr)(LCL0-dgi->b);
CP = myB->cp_cp;
if (!out ) {
@ -2274,9 +2274,9 @@ YAP_RunGoal(Term t)
BACKUP_MACHINE_REGS();
LOCAL_AllowRestart = FALSE;
Yap_PrologMode = UserMode;
LOCAL_PrologMode = UserMode;
out = Yap_RunTopGoal(t);
Yap_PrologMode = UserCCallMode;
LOCAL_PrologMode = UserCCallMode;
if (out) {
P = (yamop *)ENV[E_CP];
ENV = (CELL *)ENV[E_E];
@ -2300,9 +2300,9 @@ YAP_RunGoalOnce(Term t)
yamop *old_CP = CP;
BACKUP_MACHINE_REGS();
Yap_PrologMode = UserMode;
LOCAL_PrologMode = UserMode;
out = Yap_RunTopGoal(t);
Yap_PrologMode = UserCCallMode;
LOCAL_PrologMode = UserCCallMode;
if (out) {
choiceptr cut_pt;
@ -2338,9 +2338,9 @@ YAP_RestartGoal(void)
if (LOCAL_AllowRestart) {
P = (yamop *)FAILCODE;
do_putcf = myputc;
Yap_PrologMode = UserMode;
LOCAL_PrologMode = UserMode;
out = Yap_exec_absmi(TRUE);
Yap_PrologMode = UserCCallMode;
LOCAL_PrologMode = UserCCallMode;
if (out == FALSE) {
/* cleanup */
Yap_CloseSlots( PASS_REGS1 );
@ -2396,12 +2396,13 @@ YAP_ShutdownGoal(int backtrack)
X_API int
YAP_ContinueGoal(void)
{
CACHE_REGS
int out;
BACKUP_MACHINE_REGS();
Yap_PrologMode = UserMode;
LOCAL_PrologMode = UserMode;
out = Yap_exec_absmi(TRUE);
Yap_PrologMode = UserCCallMode;
LOCAL_PrologMode = UserCCallMode;
RECOVER_MACHINE_REGS();
return(out);
@ -2708,14 +2709,16 @@ YAP_Init(YAP_init_args *yap_init)
CELL Trail = 0, Stack = 0, Heap = 0, Atts = 0;
static char boot_file[256];
/* Init signal handling, time and memory page size, required by later functions */
Yap_InitSysbits ();
Yap_InitPageSize();
//Yap_InitSysbits();
#if defined(YAPOR_COPY) || defined(YAPOR_COW) || defined(YAPOR_SBA)
Yap_init_yapor_global_local_memory();
LOCAL = REMOTE(0);
#endif /* YAPOR_COPY || YAPOR_COW || YAPOR_SBA */
Yap_argv = yap_init->Argv;
Yap_argc = yap_init->Argc;
/* Init signal handling, time and memory page size, required by later functions */
Yap_InitSysbits();
GLOBAL_argv = yap_init->Argv;
GLOBAL_argc = yap_init->Argc;
#if !BOOT_FROM_SAVED_STATE
if (yap_init->SavedState) {
fprintf(stderr,"[ WARNING: threaded YAP will ignore saved state %s ]\n",yap_init->SavedState);
@ -2760,7 +2763,7 @@ YAP_Init(YAP_init_args *yap_init)
} else {
Heap = yap_init->HeapSize;
}
Yap_PrologShouldHandleInterrupts = yap_init->PrologShouldHandleInterrupts;
GLOBAL_PrologShouldHandleInterrupts = yap_init->PrologShouldHandleInterrupts;
Yap_InitWorkspace(Heap, Stack, Trail, Atts,
yap_init->MaxTableSpaceSize,
yap_init->NumberWorkers,
@ -3056,7 +3059,7 @@ X_API void
YAP_SetOutputMessage(void)
{
#if DEBUG
Yap_output_msg = TRUE;
GLOBAL_output_msg = TRUE;
#endif
}
@ -3097,10 +3100,11 @@ YAP_Throw(Term t)
X_API void
YAP_AsyncThrow(Term t)
{
CACHE_REGS
BACKUP_MACHINE_REGS();
Yap_PrologMode |= AsyncIntMode;
LOCAL_PrologMode |= AsyncIntMode;
Yap_JumpToEnv(t);
Yap_PrologMode &= ~AsyncIntMode;
LOCAL_PrologMode &= ~AsyncIntMode;
RECOVER_MACHINE_REGS();
}

4
C/cdmgr.c
View File

@ -958,7 +958,7 @@ IPred(PredEntry *ap, UInt NSlots, yamop *next_pc)
#ifdef DEBUG
CACHE_REGS
if (Yap_Option['i' - 'a' + 1]) {
if (GLOBAL_Option['i' - 'a' + 1]) {
Term tmod = ap->ModuleOfPred;
if (!tmod)
tmod = TermProlog;
@ -1017,7 +1017,7 @@ IPred(PredEntry *ap, UInt NSlots, yamop *next_pc)
ap->OpcodeOfPred = ap->CodeOfPred->opc;
}
#ifdef DEBUG
if (Yap_Option['i' - 'a' + 1])
if (GLOBAL_Option['i' - 'a' + 1])
Yap_DebugPutc(LOCAL_c_error_stream,'\n');
#endif
}

6
C/compiler.c
View File

@ -3547,7 +3547,7 @@ Yap_cclause(volatile Term inp_clause, Int NOfArgs, Term mod, volatile Term src)
if (LOCAL_ErrorMessage)
return (0);
#ifdef DEBUG
if (Yap_Option['g' - 96])
if (GLOBAL_Option['g' - 96])
Yap_ShowCode(&cglobs.cint);
#endif
} else {
@ -3580,7 +3580,7 @@ Yap_cclause(volatile Term inp_clause, Int NOfArgs, Term mod, volatile Term src)
if (LOCAL_ErrorMessage)
return (0);
#ifdef DEBUG
if (Yap_Option['g' - 96])
if (GLOBAL_Option['g' - 96])
Yap_ShowCode(&cglobs.cint);
#endif
/* phase 2: classify variables and optimize temporaries */
@ -3596,7 +3596,7 @@ Yap_cclause(volatile Term inp_clause, Int NOfArgs, Term mod, volatile Term src)
/* eliminate superfluous pop's and unify_var's */
c_optimize(cglobs.cint.CodeStart);
#ifdef DEBUG
if (Yap_Option['f' - 96])
if (GLOBAL_Option['f' - 96])
Yap_ShowCode(&cglobs.cint);
#endif

5
C/computils.c
View File

@ -75,12 +75,7 @@ STATIC_PROTO (void ShowOp, (char *, struct PSEUDO *));
* afterwards
*/
#ifdef DEBUG
char Yap_Option[20];
YP_FILE *Yap_logfile;
#endif
typedef struct mem_blk {
union {

25
C/dbase.c
View File

@ -160,7 +160,6 @@ typedef struct db_globs {
UInt sz; /* total size */
} dbglobs;
static dbglobs *s_dbg;
#ifdef SUPPORT_HASH_TABLES
typedef struct {
@ -368,7 +367,7 @@ static Int cmpclls(CELL *a,CELL *b,Int n)
#if !THREADS
int Yap_DBTrailOverflow()
{
return((CELL *)s_dbg->lr > (CELL *)s_dbg->tofref - 2048);
return((CELL *)LOCAL_s_dbg->lr > (CELL *)LOCAL_s_dbg->tofref - 2048);
}
#endif
@ -906,7 +905,7 @@ static CELL *MkDBTerm(register CELL *pt0, register CELL *pt0_end,
the variable, the constraint in some cannonical form, what type
of constraint, and a list pointer */
t[0] = (CELL)ptd0;
t[1] = attas[ExtFromCell(ptd0)].to_term_op(ptd0);
t[1] = GLOBAL_attas[ExtFromCell(ptd0)].to_term_op(ptd0);
t[2] = MkIntegerTerm(ExtFromCell(ptd0));
t[3] = ConstraintsTerm;
ConstraintsTerm = Yap_MkApplTerm(FunctorClist, 4, t);
@ -1647,7 +1646,7 @@ record(int Flag, Term key, Term t_data, Term t_code USES_REGS)
int needs_vars;
struct db_globs dbg;
s_dbg = &dbg;
LOCAL_s_dbg = &dbg;
dbg.found_one = NULL;
#ifdef SFUNC
FathersPlace = NIL;
@ -1724,7 +1723,7 @@ record_at(int Flag, DBRef r0, Term t_data, Term t_code USES_REGS)
int needs_vars;
struct db_globs dbg;
s_dbg = &dbg;
LOCAL_s_dbg = &dbg;
#ifdef SFUNC
FathersPlace = NIL;
#endif
@ -1799,6 +1798,7 @@ record_at(int Flag, DBRef r0, Term t_data, Term t_code USES_REGS)
static LogUpdClause *
new_lu_db_entry(Term t, PredEntry *pe)
{
CACHE_REGS
DBTerm *x;
LogUpdClause *cl;
yamop *ipc;
@ -1811,7 +1811,7 @@ new_lu_db_entry(Term t, PredEntry *pe)
if (!(pe->PredFlags & ThreadLocalPredFlag))
d_flag |= InQueue;
#endif
s_dbg = &dbg;
LOCAL_s_dbg = &dbg;
ipc = NEXTOP(((LogUpdClause *)NULL)->ClCode,e);
if ((x = (DBTerm *)CreateDBStruct(t, NULL, d_flag, &needs_vars, (UInt)ipc, &dbg)) == NULL) {
return NULL; /* crash */
@ -2358,7 +2358,7 @@ copy_attachments(CELL *ts USES_REGS)
while (TRUE) {
/* store away in case there is an overflow */
if (attas[IntegerOfTerm(ts[2])].term_to_op(ts[1], ts[0] PASS_REGS) == FALSE) {
if (GLOBAL_attas[IntegerOfTerm(ts[2])].term_to_op(ts[1], ts[0] PASS_REGS) == FALSE) {
/* oops, we did not have enough space to copy the elements */
/* reset queue of woken up goals */
TR = tr0;
@ -2466,9 +2466,9 @@ GetDBTerm(DBTerm *DBSP USES_REGS)
}
pt = CellPtr(DBSP->Contents);
if (H+NOf > ASP-CalculateStackGap()/sizeof(CELL)) {
if (Yap_PrologMode & InErrorMode) {
if (LOCAL_PrologMode & InErrorMode) {
if (H+NOf > ASP)
fprintf(Yap_stderr, "\n\n [ FATAL ERROR: No Stack for Error Handling ]\n");
fprintf(GLOBAL_stderr, "\n\n [ FATAL ERROR: No Stack for Error Handling ]\n");
Yap_exit( 1);
} else {
LOCAL_Error_TYPE = OUT_OF_STACK_ERROR;
@ -4197,7 +4197,7 @@ MyEraseClause(DynamicClause *clau USES_REGS)
Yap_FreeCodeSpace((char *)clau);
#ifdef DEBUG
if (ref->NOfRefsTo)
fprintf(Yap_stderr, "Error: references to dynamic clause\n");
fprintf(GLOBAL_stderr, "Error: references to dynamic clause\n");
#endif
RemoveDBEntry(ref PASS_REGS);
}
@ -5048,7 +5048,7 @@ StoreTermInDB(Term t, int nargs USES_REGS)
int needs_vars;
struct db_globs dbg;
s_dbg = &dbg;
LOCAL_s_dbg = &dbg;
LOCAL_Error_Size = 0;
while ((x = (DBTerm *)CreateDBStruct(t, (DBProp)NULL,
InQueue, &needs_vars, 0, &dbg)) == NULL) {
@ -5076,11 +5076,12 @@ Yap_StoreTermInDB(Term t, int nargs) {
DBTerm *
Yap_StoreTermInDBPlusExtraSpace(Term t, UInt extra_size, UInt *sz) {
CACHE_REGS
int needs_vars;
struct db_globs dbg;
DBTerm *o;
s_dbg = &dbg;
LOCAL_s_dbg = &dbg;
o = (DBTerm *)CreateDBStruct(t, (DBProp)NULL,
InQueue, &needs_vars, extra_size, &dbg);
*sz = dbg.sz;

42
C/errors.c
View File

@ -264,7 +264,7 @@ dump_stack( USES_REGS1 )
return;
#if DEBUG
fprintf(stderr,"%% YAP regs: P=%p, CP=%p, ASP=%p, H=%p, TR=%p, HeapTop=%p\n",P,CP,ASP,H,TR,HeapTop);
fprintf(stderr,"%% YAP mode: %ux\n",(unsigned int)Yap_PrologMode);
fprintf(stderr,"%% YAP mode: %ux\n",(unsigned int)LOCAL_PrologMode);
if (LOCAL_ErrorMessage)
fprintf(stderr,"%% LOCAL_ErrorMessage: %s\n",LOCAL_ErrorMessage);
#endif
@ -352,7 +352,7 @@ static void
error_exit_yap (int value)
{
CACHE_REGS
if (!(Yap_PrologMode & BootMode)) {
if (!(LOCAL_PrologMode & BootMode)) {
dump_stack( PASS_REGS1 );
#if DEBUG
#endif
@ -395,10 +395,10 @@ Yap_Error(yap_error_number type, Term where, char *format,...)
if (where == 0L)
where = TermNil;
#if DEBUG_STRICT
if (Yap_heap_regs && !(Yap_PrologMode & BootMode))
fprintf(stderr,"***** Processing Error %d (%lx,%x) %s***\n", type, (unsigned long int)LOCAL_ActiveSignals,Yap_PrologMode,format);
if (Yap_heap_regs && !(LOCAL_PrologMode & BootMode))
fprintf(stderr,"***** Processing Error %d (%lx,%x) %s***\n", type, (unsigned long int)LOCAL_ActiveSignals,LOCAL_PrologMode,format);
else
fprintf(stderr,"***** Processing Error %d (%x) %s***\n", type,Yap_PrologMode,format);
fprintf(stderr,"***** Processing Error %d (%x) %s***\n", type,LOCAL_PrologMode,format);
#endif
if (type == INTERRUPT_ERROR) {
fprintf(stderr,"%% YAP exiting: cannot handle signal %d\n",
@ -406,7 +406,7 @@ Yap_Error(yap_error_number type, Term where, char *format,...)
Yap_exit(1);
}
/* disallow recursive error handling */
if (Yap_PrologMode & InErrorMode) {
if (LOCAL_PrologMode & InErrorMode) {
/* error within error */
va_start (ap, format);
/* now build the error string */
@ -444,7 +444,7 @@ Yap_Error(yap_error_number type, Term where, char *format,...)
} else {
tmpbuf[0] = '\0';
}
if (Yap_PrologMode == UserCCallMode) {
if (LOCAL_PrologMode == UserCCallMode) {
fprintf(stderr,"%%\n%%\n");
fprintf(stderr,"%% YAP OOOPS in USER C-CODE: %s.\n",tmpbuf);
fprintf(stderr,"%%\n%%\n");
@ -458,12 +458,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...)
if (P == (yamop *)(FAILCODE))
return P;
/* PURE_ABORT may not have set where correctly, BootMode may not have the data terms ready */
if (type == PURE_ABORT || Yap_PrologMode & BootMode) {
if (type == PURE_ABORT || LOCAL_PrologMode & BootMode) {
where = TermNil;
Yap_PrologMode &= ~AbortMode;
Yap_PrologMode |= InErrorMode;
LOCAL_PrologMode &= ~AbortMode;
LOCAL_PrologMode |= InErrorMode;
/* make sure failure will be seen at next port */
if (Yap_PrologMode & AsyncIntMode)
if (LOCAL_PrologMode & AsyncIntMode)
Yap_signal(YAP_FAIL_SIGNAL);
P = FAILCODE;
} else {
@ -474,8 +474,8 @@ Yap_Error(yap_error_number type, Term where, char *format,...)
where = Deref(where);
}
/* Exit Abort Mode, if we were there */
Yap_PrologMode &= ~AbortMode;
Yap_PrologMode |= InErrorMode;
LOCAL_PrologMode &= ~AbortMode;
LOCAL_PrologMode |= InErrorMode;
if (!(where = Yap_CopyTerm(where))) {
where = TermNil;
}
@ -493,7 +493,7 @@ Yap_Error(yap_error_number type, Term where, char *format,...)
else
tmpbuf[0] = '\0';
va_end (ap);
if (Yap_PrologMode & BootMode) {
if (LOCAL_PrologMode & BootMode) {
/* crash in flames! */
fprintf(stderr,"%% YAP Fatal Error: %s exiting....\n",tmpbuf);
error_exit_yap (1);
@ -506,7 +506,7 @@ Yap_Error(yap_error_number type, Term where, char *format,...)
{
fprintf(stderr,"%% Internal YAP Error: %s exiting....\n",tmpbuf);
serious = TRUE;
if (Yap_PrologMode & BootMode) {
if (LOCAL_PrologMode & BootMode) {
fprintf(stderr,"%% YAP crashed while booting %s\n",tmpbuf);
} else {
detect_bug_location(P, FIND_PRED_FROM_ANYWHERE, tmpbuf, YAP_BUF_SIZE);
@ -535,7 +535,7 @@ Yap_Error(yap_error_number type, Term where, char *format,...)
LOCAL_RetriesCounterOn = FALSE;
Yap_JumpToEnv(MkAtomTerm(AtomCallCounter));
P = (yamop *)FAILCODE;
Yap_PrologMode &= ~InErrorMode;
LOCAL_PrologMode &= ~InErrorMode;
return(P);
case PRED_ENTRY_COUNTER_UNDERFLOW:
/* Do a long jump */
@ -544,7 +544,7 @@ Yap_Error(yap_error_number type, Term where, char *format,...)
LOCAL_RetriesCounterOn = FALSE;
Yap_JumpToEnv(MkAtomTerm(AtomCallAndRetryCounter));
P = (yamop *)FAILCODE;
Yap_PrologMode &= ~InErrorMode;
LOCAL_PrologMode &= ~InErrorMode;
return(P);
case RETRY_COUNTER_UNDERFLOW:
/* Do a long jump */
@ -553,7 +553,7 @@ Yap_Error(yap_error_number type, Term where, char *format,...)
LOCAL_RetriesCounterOn = FALSE;
Yap_JumpToEnv(MkAtomTerm(AtomRetryCounter));
P = (yamop *)FAILCODE;
Yap_PrologMode &= ~InErrorMode;
LOCAL_PrologMode &= ~InErrorMode;
return(P);
case CONSISTENCY_ERROR:
{
@ -1861,7 +1861,7 @@ E);
/* disable active signals at this point */
LOCAL_ActiveSignals = 0;
CreepFlag = CalculateStackGap();
Yap_PrologMode &= ~InErrorMode;
LOCAL_PrologMode &= ~InErrorMode;
LOCK(LOCAL_SignalLock);
/* we might be in the middle of a critical region */
if (LOCAL_InterruptsDisabled) {
@ -1877,7 +1877,7 @@ E);
/* wait if we we are in user code,
it's up to her to decide */
if (Yap_PrologMode & UserCCallMode) {
if (LOCAL_PrologMode & UserCCallMode) {
if (!(EX = Yap_StoreTermInDB(Yap_MkApplTerm(fun, 2, nt), 0))) {
/* fat chance */
siglongjmp(LOCAL_RestartEnv,1);
@ -1890,7 +1890,7 @@ E);
P = (yamop *)FAILCODE;
}
} else {
Yap_PrologMode &= ~InErrorMode;
LOCAL_PrologMode &= ~InErrorMode;
}
return P;
}

2
C/eval.c
View File

@ -34,7 +34,7 @@ static char SccsId[] = "%W% %G%";
#include <unistd.h>
#endif
yap_error_number Yap_matherror = YAP_NO_ERROR;
static Term
Eval(Term t USES_REGS)

20
C/exec.c
View File

@ -951,7 +951,7 @@ exec_absmi(int top USES_REGS)
case 1:
{ /* restart */
/* otherwise, SetDBForThrow will fail entering critical mode */
Yap_PrologMode = UserMode;
LOCAL_PrologMode = UserMode;
/* find out where to cut to */
/* siglongjmp resets the TR hardware register */
/* TR and B are crucial, they might have been changed, or not */
@ -966,7 +966,7 @@ exec_absmi(int top USES_REGS)
/* forget any signals active, we're reborne */
LOCAL_ActiveSignals = 0;
CreepFlag = CalculateStackGap();
Yap_PrologMode = UserMode;
LOCAL_PrologMode = UserMode;
UNLOCK(LOCAL_SignalLock);
P = (yamop *)FAILCODE;
}
@ -975,11 +975,11 @@ exec_absmi(int top USES_REGS)
{
/* arithmetic exception */
/* must be done here, otherwise siglongjmp will clobber all the registers */
Yap_Error(Yap_matherror,TermNil,NULL);
Yap_Error(LOCAL_matherror ,TermNil,NULL);
/* reset the registers so that we don't have trash in abstract machine */
Yap_set_fpu_exceptions(yap_flags[LANGUAGE_MODE_FLAG] == 1);
P = (yamop *)FAILCODE;
Yap_PrologMode = UserMode;
LOCAL_PrologMode = UserMode;
}
break;
case 3:
@ -988,10 +988,10 @@ exec_absmi(int top USES_REGS)
}
default:
/* do nothing */
Yap_PrologMode = UserMode;
LOCAL_PrologMode = UserMode;
}
} else {
Yap_PrologMode = UserMode;
LOCAL_PrologMode = UserMode;
}
Yap_CloseSlots( PASS_REGS1 );
YENV = ASP;
@ -1280,7 +1280,7 @@ Yap_RunTopGoal(Term t)
UNLOCK(ppe->PELock);
#if !USE_SYSTEM_MALLOC
if (LOCAL_TrailTop - HeapTop < 2048) {
Yap_PrologMode = BootMode;
LOCAL_PrologMode = BootMode;
Yap_Error(OUT_OF_TRAIL_ERROR,TermNil,
"unable to boot because of too little Trail space");
}
@ -1515,7 +1515,7 @@ JumpToEnv(Term t USES_REGS) {
LOCAL_BallTerm = NULL;
P = (yamop *)FAILCODE;
/* make sure failure will be seen at next port */
if (Yap_PrologMode & AsyncIntMode) {
if (LOCAL_PrologMode & AsyncIntMode) {
Yap_signal(YAP_FAIL_SIGNAL);
}
HB = B->cp_h;
@ -1560,7 +1560,7 @@ JumpToEnv(Term t USES_REGS) {
/* B->cp_h = H; */
/* I could backtrack here, but it is easier to leave the unwinding
to the emulator */
if (Yap_PrologMode & AsyncIntMode) {
if (LOCAL_PrologMode & AsyncIntMode) {
Yap_signal(YAP_FAIL_SIGNAL);
}
P = (yamop *)FAILCODE;
@ -1575,7 +1575,7 @@ JumpToEnv(Term t USES_REGS) {
Int
Yap_JumpToEnv(Term t) {
CACHE_REGS
if (Yap_PrologMode & BootMode) {
if (LOCAL_PrologMode & BootMode) {
return FALSE;
}
return JumpToEnv(t PASS_REGS);

2
C/globals.c
View File

@ -474,7 +474,7 @@ copy_complex_term(register CELL *pt0, register CELL *pt0_end, int share, int cop
CELL new;
bp = to_visit;
if (!attas[ExtFromCell(ptd0)].copy_term_op(ptd0, &bp, ptf PASS_REGS)) {
if (!GLOBAL_attas[ExtFromCell(ptd0)].copy_term_op(ptd0, &bp, ptf PASS_REGS)) {
goto overflow;
}
to_visit = bp;

193
C/gprof.c
View File

@ -123,13 +123,13 @@ typedef greg_t context_reg;
#include <ucontext.h>
#endif
static Int ProfCalls, ProfGCs, ProfHGrows, ProfSGrows, ProfMallocs, ProfOn, ProfOns;
#define TIMER_DEFAULT 100
#define PROFILING_FILE 1
#define PROFPREDS_FILE 2
static char *DIRNAME=NULL;
typedef struct RB_red_blk_node {
yamop *key; /* first address */
@ -142,7 +142,7 @@ typedef struct RB_red_blk_node {
struct RB_red_blk_node* parent;
} rb_red_blk_node;
static rb_red_blk_node *ProfilerRoot, *ProfilerNil;
static rb_red_blk_node *
RBMalloc(UInt size)
@ -162,14 +162,14 @@ RBTreeCreate(void) {
/* see the comment in the rb_red_blk_tree structure in red_black_tree.h */
/* for information on nil and root */
temp=ProfilerNil= RBMalloc(sizeof(rb_red_blk_node));
temp=GLOBAL_ProfilerNil= RBMalloc(sizeof(rb_red_blk_node));
temp->parent=temp->left=temp->right=temp;
temp->pcs=0;
temp->red=0;
temp->key=temp->lim=NULL;
temp->pe=NULL;
temp = RBMalloc(sizeof(rb_red_blk_node));
temp->parent=temp->left=temp->right=ProfilerNil;
temp->parent=temp->left=temp->right=GLOBAL_ProfilerNil;
temp->key=temp->lim=NULL;
temp->pe=NULL;
temp->pcs=0;
@ -199,7 +199,7 @@ RBTreeCreate(void) {
static void
LeftRotate(rb_red_blk_node* x) {
rb_red_blk_node* y;
rb_red_blk_node* nil=ProfilerNil;
rb_red_blk_node* nil=GLOBAL_ProfilerNil;
/* I originally wrote this function to use the sentinel for */
/* nil to avoid checking for nil. However this introduces a */
@ -230,7 +230,7 @@ LeftRotate(rb_red_blk_node* x) {
x->parent=y;
#ifdef DEBUG_ASSERT
Assert(!ProfilerNil->red,"nil not red in LeftRotate");
Assert(!GLOBAL_ProfilerNil->red,"nil not red in LeftRotate");
#endif
}
@ -255,7 +255,7 @@ LeftRotate(rb_red_blk_node* x) {
static void
RightRotate(rb_red_blk_node* y) {
rb_red_blk_node* x;
rb_red_blk_node* nil=ProfilerNil;
rb_red_blk_node* nil=GLOBAL_ProfilerNil;
/* I originally wrote this function to use the sentinel for */
/* nil to avoid checking for nil. However this introduces a */
@ -285,7 +285,7 @@ RightRotate(rb_red_blk_node* y) {
y->parent=x;
#ifdef DEBUG_ASSERT
Assert(!ProfilerNil->red,"nil not red in RightRotate");
Assert(!GLOBAL_ProfilerNil->red,"nil not red in RightRotate");
#endif
}
@ -309,11 +309,11 @@ TreeInsertHelp(rb_red_blk_node* z) {
/* This function should only be called by InsertRBTree (see above) */
rb_red_blk_node* x;
rb_red_blk_node* y;
rb_red_blk_node* nil=ProfilerNil;
rb_red_blk_node* nil=GLOBAL_ProfilerNil;
z->left=z->right=nil;
y=ProfilerRoot;
x=ProfilerRoot->left;
y=GLOBAL_ProfilerRoot;
x=GLOBAL_ProfilerRoot->left;
while( x != nil) {
y=x;
if (x->key > z->key) { /* x.key > z.key */
@ -323,7 +323,7 @@ TreeInsertHelp(rb_red_blk_node* z) {
}
}
z->parent=y;
if ( (y == ProfilerRoot) ||
if ( (y == GLOBAL_ProfilerRoot) ||
(y->key > z->key)) { /* y.key > z.key */
y->left=z;
} else {
@ -331,7 +331,7 @@ TreeInsertHelp(rb_red_blk_node* z) {
}
#ifdef DEBUG_ASSERT
Assert(!ProfilerNil->red,"nil not red in TreeInsertHelp");
Assert(!GLOBAL_ProfilerNil->red,"nil not red in TreeInsertHelp");
#endif
}
@ -403,12 +403,12 @@ RBTreeInsert(yamop *key, yamop *lim) {
}
}
}
ProfilerRoot->left->red=0;
GLOBAL_ProfilerRoot->left->red=0;
return newNode;
#ifdef DEBUG_ASSERT
Assert(!ProfilerNil->red,"nil not red in RBTreeInsert");
Assert(!ProfilerRoot->red,"root not red in RBTreeInsert");
Assert(!GLOBAL_ProfilerNil->red,"nil not red in RBTreeInsert");
Assert(!GLOBAL_ProfilerRoot->red,"root not red in RBTreeInsert");
#endif
}
@ -429,10 +429,10 @@ RBTreeInsert(yamop *key, yamop *lim) {
static rb_red_blk_node*
RBExactQuery(yamop* q) {
rb_red_blk_node* x;
rb_red_blk_node* nil=ProfilerNil;
rb_red_blk_node* nil=GLOBAL_ProfilerNil;
if (!ProfilerRoot) return NULL;
x=ProfilerRoot->left;
if (!GLOBAL_ProfilerRoot) return NULL;
x=GLOBAL_ProfilerRoot->left;
if (x == nil) return NULL;
while(x->key != q) {/*assignemnt*/
if (x->key > q) { /* x->key > q */
@ -450,10 +450,10 @@ static rb_red_blk_node*
RBLookup(yamop *entry) {
rb_red_blk_node *current;
if (!ProfilerRoot)
if (!GLOBAL_ProfilerRoot)
return NULL;
current = ProfilerRoot->left;
while (current != ProfilerNil) {
current = GLOBAL_ProfilerRoot->left;
while (current != GLOBAL_ProfilerNil) {
if (current->key <= entry && current->lim >= entry) {
return current;
}
@ -483,7 +483,7 @@ RBLookup(yamop *entry) {
/***********************************************************************/
static void RBDeleteFixUp(rb_red_blk_node* x) {
rb_red_blk_node* root=ProfilerRoot->left;
rb_red_blk_node* root=GLOBAL_ProfilerRoot->left;
rb_red_blk_node *w;
while( (!x->red) && (root != x)) {
@ -563,8 +563,8 @@ static void RBDeleteFixUp(rb_red_blk_node* x) {
static rb_red_blk_node*
TreeSuccessor(rb_red_blk_node* x) {
rb_red_blk_node* y;
rb_red_blk_node* nil=ProfilerNil;
rb_red_blk_node* root=ProfilerRoot;
rb_red_blk_node* nil=GLOBAL_ProfilerNil;
rb_red_blk_node* root=GLOBAL_ProfilerRoot;
if (nil != (y = x->right)) { /* assignment to y is intentional */
while(y->left != nil) { /* returns the minium of the right subtree of x */
@ -602,8 +602,8 @@ static void
RBDelete(rb_red_blk_node* z){
rb_red_blk_node* y;
rb_red_blk_node* x;
rb_red_blk_node* nil=ProfilerNil;
rb_red_blk_node* root=ProfilerRoot;
rb_red_blk_node* nil=GLOBAL_ProfilerNil;
rb_red_blk_node* root=GLOBAL_ProfilerRoot;
y= ((z->left == nil) || (z->right == nil)) ? z : TreeSuccessor(z);
x= (y->left == nil) ? y->right : y->left;
@ -656,21 +656,21 @@ int size=0;
if (name!=NULL) {
size=strlen(name)+1;
if (DIRNAME!=NULL) free(DIRNAME);
DIRNAME=malloc(size);
if (DIRNAME==NULL) { printf("Profiler Out of Mem\n"); exit(1); }
strcpy(DIRNAME,name);
if (GLOBAL_DIRNAME!=NULL) free(GLOBAL_DIRNAME);
GLOBAL_DIRNAME=malloc(size);
if (GLOBAL_DIRNAME==NULL) { printf("Profiler Out of Mem\n"); exit(1); }
strcpy(GLOBAL_DIRNAME,name);
}
if (DIRNAME==NULL) {
if (GLOBAL_DIRNAME==NULL) {
do {
if (DIRNAME!=NULL) free(DIRNAME);
if (GLOBAL_DIRNAME!=NULL) free(GLOBAL_DIRNAME);
size+=20;
DIRNAME=malloc(size);
if (DIRNAME==NULL) { printf("Profiler Out of Mem\n"); exit(1); }
} while (getcwd(DIRNAME, size-15)==NULL);
GLOBAL_DIRNAME=malloc(size);
if (GLOBAL_DIRNAME==NULL) { printf("Profiler Out of Mem\n"); exit(1); }
} while (getcwd(GLOBAL_DIRNAME, size-15)==NULL);
}
return DIRNAME;
return GLOBAL_DIRNAME;
}
char *profile_names(int);
@ -678,12 +678,12 @@ char *profile_names(int k) {
static char *FNAME=NULL;
int size=200;
if (DIRNAME==NULL) set_profile_dir(NULL);
size=strlen(DIRNAME)+40;
if (GLOBAL_DIRNAME==NULL) set_profile_dir(NULL);
size=strlen(GLOBAL_DIRNAME)+40;
if (FNAME!=NULL) free(FNAME);
FNAME=malloc(size);
if (FNAME==NULL) { printf("Profiler Out of Mem\n"); exit(1); }
strcpy(FNAME,DIRNAME);
strcpy(FNAME,GLOBAL_DIRNAME);
if (k==PROFILING_FILE) {
sprintf(FNAME,"%s/PROFILING_%d",FNAME,getpid());
@ -697,7 +697,7 @@ int size=200;
void del_profile_files(void);
void del_profile_files() {
if (DIRNAME!=NULL) {
if (GLOBAL_DIRNAME!=NULL) {
remove(profile_names(PROFPREDS_FILE));
remove(profile_names(PROFILING_FILE));
}
@ -708,7 +708,7 @@ Yap_inform_profiler_of_clause(yamop *code_start, yamop *code_end, PredEntry *pe,
static Int order=0;
ProfPreds++;
ProfOn = TRUE;
GLOBAL_ProfOn = TRUE;
if (FPreds != NULL) {
Int temp;
@ -716,7 +716,7 @@ static Int order=0;
if (index_code) temp=-order; else temp=order;
fprintf(FPreds,"+%p %p %p %ld\n",code_start,code_end, pe, (long int)temp);
}
ProfOn = FALSE;
GLOBAL_ProfOn = FALSE;
}
typedef struct clause_entry {
@ -731,7 +731,7 @@ static Int profend( USES_REGS1 );
static void
clean_tree(rb_red_blk_node* node) {
if (node == ProfilerNil)
if (node == GLOBAL_ProfilerNil)
return;
clean_tree(node->left);
clean_tree(node->right);
@ -740,18 +740,18 @@ clean_tree(rb_red_blk_node* node) {
static void
reset_tree(void) {
clean_tree(ProfilerRoot);
Yap_FreeCodeSpace((char *)ProfilerNil);
ProfilerNil = ProfilerRoot = NULL;
ProfCalls = ProfGCs = ProfHGrows = ProfSGrows = ProfMallocs = ProfOns = 0L;
clean_tree(GLOBAL_ProfilerRoot);
Yap_FreeCodeSpace((char *)GLOBAL_ProfilerNil);
GLOBAL_ProfilerNil = GLOBAL_ProfilerRoot = NULL;
GLOBAL_ProfCalls = GLOBAL_ProfGCs = GLOBAL_ProfHGrows = GLOBAL_ProfSGrows = GLOBAL_ProfMallocs = GLOBAL_ProfOns = 0L;
}
static int
InitProfTree(void)
{
if (ProfilerRoot)
if (GLOBAL_ProfilerRoot)
reset_tree();
while (!(ProfilerRoot = RBTreeCreate())) {
while (!(GLOBAL_ProfilerRoot = RBTreeCreate())) {
if (!Yap_growheap(FALSE, 0, NULL)) {
Yap_Error(OUT_OF_HEAP_ERROR, TermNil, "while initialisating profiler");
return FALSE;
@ -807,10 +807,10 @@ static void RemoveCode(CODEADDR clau)
PredEntry *pp;
UInt count;
if (!ProfilerRoot) return;
if (!GLOBAL_ProfilerRoot) return;
if (!(x = RBExactQuery((yamop *)clau))) {
/* send message */
ProfOn = FALSE;
GLOBAL_ProfOn = FALSE;
return;
}
pp = x->pe;
@ -823,7 +823,7 @@ static void RemoveCode(CODEADDR clau)
node->pe = pp;
node->pcs = count;
/* send message */
ProfOn = FALSE;
GLOBAL_ProfOn = FALSE;
return;
} else {
node->pcs += count;
@ -872,7 +872,7 @@ showprofres( USES_REGS1 ) {
}
}
fclose(FProf);
if (ProfCalls==0)
if (GLOBAL_ProfCalls==0)
return TRUE;
return TRUE;
}
@ -909,7 +909,7 @@ p_test( USES_REGS1 ) {
}
}
fclose(FProf);
if (ProfCalls==0)
if (GLOBAL_ProfCalls==0)
return TRUE;
return TRUE;
}
@ -921,38 +921,39 @@ p_test( USES_REGS1 ) {
static void
prof_alrm(int signo, siginfo_t *si, void *scv)
{
CACHE_REGS
void * oldpc=(void *) CONTEXT_PC(scv);
yamop *current_p;
ProfCalls++;
GLOBAL_ProfCalls++;
/* skip an interrupt */
if (ProfOn) {
ProfOns++;
if (GLOBAL_ProfOn) {
GLOBAL_ProfOns++;
return;
}
ProfOn = TRUE;
if (Yap_PrologMode & TestMode) {
if (Yap_PrologMode & GCMode) {
ProfGCs++;
ProfOn = FALSE;
GLOBAL_ProfOn = TRUE;
if (LOCAL_PrologMode & TestMode) {
if (LOCAL_PrologMode & GCMode) {
GLOBAL_ProfGCs++;
GLOBAL_ProfOn = FALSE;
return;
}
if (Yap_PrologMode & MallocMode) {
ProfMallocs++;
ProfOn = FALSE;
if (LOCAL_PrologMode & MallocMode) {
GLOBAL_ProfMallocs++;
GLOBAL_ProfOn = FALSE;
return;
}
if (Yap_PrologMode & GrowHeapMode) {
ProfHGrows++;
ProfOn = FALSE;
if (LOCAL_PrologMode & GrowHeapMode) {
GLOBAL_ProfHGrows++;
GLOBAL_ProfOn = FALSE;
return;
}
if (Yap_PrologMode & GrowStackMode) {
ProfSGrows++;
ProfOn = FALSE;
if (LOCAL_PrologMode & GrowStackMode) {
GLOBAL_ProfSGrows++;
GLOBAL_ProfOn = FALSE;
return;
}
@ -987,34 +988,34 @@ prof_alrm(int signo, siginfo_t *si, void *scv)
#if DEBUG
fprintf(stderr,"Oops: %p, %p\n", oldpc, current_p);
#endif
ProfOn = FALSE;
GLOBAL_ProfOn = FALSE;
return;
}
#endif
if (Yap_OffLineProfiler) {
fprintf(FProf,"%p\n", current_p);
ProfOn = FALSE;
GLOBAL_ProfOn = FALSE;
return;
}
LookupNode(current_p);
ProfOn = FALSE;
GLOBAL_ProfOn = FALSE;
}
void
Yap_InformOfRemoval(CODEADDR clau)
{
ProfOn = TRUE;
GLOBAL_ProfOn = TRUE;
if (FPreds != NULL) {
/* just store info about what is going on */
fprintf(FPreds,"-%p\n",clau);
ProfOn = FALSE;
GLOBAL_ProfOn = FALSE;
return;
}
RemoveCode(clau);
ProfOn = FALSE;
GLOBAL_ProfOn = FALSE;
}
static Int profend( USES_REGS1 );
@ -1024,25 +1025,25 @@ profnode( USES_REGS1 ) {
Term t1 = Deref(ARG1), tleft, tright;
rb_red_blk_node *node;
if (!ProfilerRoot)
if (!GLOBAL_ProfilerRoot)
return FALSE;
if (!(node = (rb_red_blk_node *)IntegerOfTerm(t1)))
node = ProfilerRoot;
node = GLOBAL_ProfilerRoot;
/*
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);
*/
if (node->left == ProfilerNil) {
if (node->left == GLOBAL_ProfilerNil) {
tleft = TermNil;
} else {
tleft = MkIntegerTerm((Int)node->left);
}
if (node->left == ProfilerNil) {
if (node->left == GLOBAL_ProfilerNil) {
tleft = TermNil;
} else {
tleft = MkIntegerTerm((Int)node->left);
}
if (node->right == ProfilerNil) {
if (node->right == GLOBAL_ProfilerNil) {
tright = TermNil;
} else {
tright = MkIntegerTerm((Int)node->right);
@ -1058,12 +1059,12 @@ profnode( USES_REGS1 ) {
static Int
profglobs( USES_REGS1 ) {
return
Yap_unify(ARG1,MkIntegerTerm(ProfCalls)) &&
Yap_unify(ARG2,MkIntegerTerm(ProfGCs)) &&
Yap_unify(ARG3,MkIntegerTerm(ProfHGrows)) &&
Yap_unify(ARG4,MkIntegerTerm(ProfSGrows)) &&
Yap_unify(ARG5,MkIntegerTerm(ProfMallocs)) &&
Yap_unify(ARG6,MkIntegerTerm(ProfOns)) ;
Yap_unify(ARG1,MkIntegerTerm(GLOBAL_ProfCalls)) &&
Yap_unify(ARG2,MkIntegerTerm(GLOBAL_ProfGCs)) &&
Yap_unify(ARG3,MkIntegerTerm(GLOBAL_ProfHGrows)) &&
Yap_unify(ARG4,MkIntegerTerm(GLOBAL_ProfSGrows)) &&
Yap_unify(ARG5,MkIntegerTerm(GLOBAL_ProfMallocs)) &&
Yap_unify(ARG6,MkIntegerTerm(GLOBAL_ProfOns)) ;
}
static Int
@ -1169,14 +1170,14 @@ static Int profoff( USES_REGS1 ) {
return FALSE;
}
static Int profon( USES_REGS1 ) {
static Int ProfOn( USES_REGS1 ) {
Term p;
profoff( PASS_REGS1 );
p=Deref(ARG1);
return(start_profilers(IntOfTerm(p)));
}
static Int profon0( USES_REGS1 ) {
static Int ProfOn0( USES_REGS1 ) {
profoff( PASS_REGS1 );
return(start_profilers(TIMER_DEFAULT));
}
@ -1187,7 +1188,7 @@ static Int profison( USES_REGS1 ) {
static Int profalt( USES_REGS1 ) {
if (ProfilerOn==0) return(FALSE);
if (ProfilerOn==-1) return profon( PASS_REGS1 );
if (ProfilerOn==-1) return ProfOn( PASS_REGS1 );
return profoff( PASS_REGS1 );
}
@ -1248,15 +1249,15 @@ void
Yap_InitLowProf(void)
{
#if LOW_PROF
ProfCalls = 0;
GLOBAL_ProfCalls = 0;
ProfilerOn = FALSE;
Yap_OffLineProfiler = FALSE;
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("profon" , 0, profon0, SafePredFlag);
Yap_InitCPred("profon" , 1, profon, SafePredFlag);
Yap_InitCPred("ProfOn" , 0, ProfOn0, SafePredFlag);
Yap_InitCPred("ProfOn" , 1, ProfOn, SafePredFlag);
Yap_InitCPred("profoff", 0, profoff, SafePredFlag);
Yap_InitCPred("profalt", 0, profalt, SafePredFlag);
Yap_InitCPred("$offline_showprofres", 0, profres0, SafePredFlag);

157
C/grow.c
View File

@ -42,20 +42,7 @@ typedef enum {
STACK_INCREMENTAL_COPYING = 2
} what_stack_copying;
static int heap_overflows = 0;
static Int total_heap_overflow_time = 0;
int stack_overflows = 0;
static Int total_stack_overflow_time = 0;
int delay_overflows = 0;
static Int total_delay_overflow_time = 0;
static int trail_overflows = 0;
static Int total_trail_overflow_time = 0;
static int atom_table_overflows = 0;
static Int total_atom_table_overflow_time = 0;
STATIC_PROTO(Int p_growheap, ( USES_REGS1 ));
STATIC_PROTO(Int p_growstack, ( USES_REGS1 ));
@ -85,10 +72,11 @@ STATIC_PROTO(Term AdjustGlobTerm, (Term CACHE_TYPE));
static void
LeaveGrowMode(prolog_exec_mode grow_mode)
{
Yap_PrologMode &= ~grow_mode;
if (Yap_PrologMode & AbortMode) {
CACHE_REGS
Yap_PrologMode &= ~AbortMode;
LOCAL_PrologMode &= ~grow_mode;
if (LOCAL_PrologMode & AbortMode) {
CACHE_REGS
LOCAL_PrologMode &= ~AbortMode;
Yap_Error(PURE_ABORT, TermNil, "");
/* in case someone mangles the P register */
save_machine_regs();
@ -121,7 +109,7 @@ static void
SetHeapRegs(int copying_threads USES_REGS)
{
#ifdef undf7
fprintf(Yap_stderr,"HeapBase = %x\tHeapTop=%x\nGlobalBase=%x\tGlobalTop=%x\nLocalBase=%x\tLocatTop=%x\n", Yap_HeapBase, HeapTop, LOCAL_GlobalBase, H, LCL0, ASP);
fprintf(GLOBAL_stderr,"HeapBase = %x\tHeapTop=%x\nGlobalBase=%x\tGlobalTop=%x\nLocalBase=%x\tLocatTop=%x\n", Yap_HeapBase, HeapTop, LOCAL_GlobalBase, H, LCL0, ASP);
#endif
/* The old stack pointers */
LOCAL_OldLCL0 = LCL0;
@ -373,7 +361,7 @@ AdjustAppl(register CELL t0 USES_REGS)
#ifdef DEBUG
else {
/* strange cell */
/* fprintf(Yap_stderr,"% garbage appl %lx found in stacks by stack shifter\n", t0);*/
/* fprintf(GLOBAL_stderr,"% garbage appl %lx found in stacks by stack shifter\n", t0);*/
}
#endif
return(t0);
@ -391,7 +379,7 @@ AdjustPair(register CELL t0 USES_REGS)
else if (IsHeapP(t))
return (AbsPair(CellPtoHeapAdjust(t)));
#ifdef DEBUG
/* fprintf(Yap_stderr,"% garbage pair %lx found in stacks by stack shifter\n", t0);*/
/* fprintf(GLOBAL_stderr,"% garbage pair %lx found in stacks by stack shifter\n", t0);*/
#endif
return(t0);
}
@ -788,13 +776,13 @@ static_growheap(long size, int fix_code, struct intermediates *cip, tr_fr_ptr *o
}
start_growth_time = Yap_cputime();
gc_verbose = Yap_is_gc_verbose();
heap_overflows++;
LOCAL_heap_overflows++;
if (gc_verbose) {
#if defined(YAPOR_THREADS)
fprintf(Yap_stderr, "%% Worker Id %d:\n", worker_id);
fprintf(GLOBAL_stderr, "%% Worker Id %d:\n", worker_id);
#endif
fprintf(Yap_stderr, "%% Database Overflow %d\n", heap_overflows);
fprintf(Yap_stderr, "%% growing the heap %ld bytes\n", size);
fprintf(GLOBAL_stderr, "%% Database Overflow %d\n", LOCAL_heap_overflows);
fprintf(GLOBAL_stderr, "%% growing the heap %ld bytes\n", size);
}
/* CreepFlag is set to force heap expansion */
if (LOCAL_ActiveSignals == YAP_CDOVF_SIGNAL) {
@ -835,10 +823,10 @@ static_growheap(long size, int fix_code, struct intermediates *cip, tr_fr_ptr *o
if (minimal_request)
Yap_AllocHole(minimal_request, size);
growth_time = Yap_cputime()-start_growth_time;
total_heap_overflow_time += growth_time;
LOCAL_total_heap_overflow_time += growth_time;
if (gc_verbose) {
fprintf(Yap_stderr, "%% took %g sec\n", (double)growth_time/1000);
fprintf(Yap_stderr, "%% Total of %g sec expanding Database\n", (double)total_heap_overflow_time/1000);
fprintf(GLOBAL_stderr, "%% took %g sec\n", (double)growth_time/1000);
fprintf(GLOBAL_stderr, "%% Total of %g sec expanding Database\n", (double)LOCAL_total_heap_overflow_time/1000);
}
return(TRUE);
}
@ -900,7 +888,7 @@ static_growglobal(long request, CELL **ptr, CELL *hsplit USES_REGS)
}
/* adjust to a multiple of 256) */
LOCAL_ErrorMessage = NULL;
Yap_PrologMode |= GrowStackMode;
LOCAL_PrologMode |= GrowStackMode;
start_growth_time = Yap_cputime();
if (do_grow) {
if (!GLOBAL_AllowGlobalExpansion) {
@ -922,7 +910,7 @@ static_growglobal(long request, CELL **ptr, CELL *hsplit USES_REGS)
}
}
gc_verbose = Yap_is_gc_verbose();
delay_overflows++;
LOCAL_delay_overflows++;
if (gc_verbose) {
if (hsplit) {
if (hsplit > H0) {
@ -937,10 +925,10 @@ static_growglobal(long request, CELL **ptr, CELL *hsplit USES_REGS)
vb_msg2 = "Delay";
}
#if defined(YAPOR_THREADS)
fprintf(Yap_stderr, "%% Worker Id %d:\n", worker_id);
fprintf(GLOBAL_stderr, "%% Worker Id %d:\n", worker_id);
#endif
fprintf(Yap_stderr, "%% %cO %s Overflow %d\n", vb_msg1, vb_msg2, delay_overflows);
fprintf(Yap_stderr, "%% %cO growing the stacks %ld bytes\n", vb_msg1, size);
fprintf(GLOBAL_stderr, "%% %cO %s Overflow %d\n", vb_msg1, vb_msg2, LOCAL_delay_overflows);
fprintf(GLOBAL_stderr, "%% %cO growing the stacks %ld bytes\n", vb_msg1, size);
}
ASP -= 256;
YAPEnterCriticalSection();
@ -1019,10 +1007,10 @@ static_growglobal(long request, CELL **ptr, CELL *hsplit USES_REGS)
Yap_AllocHole(minimal_request, size);
}
growth_time = Yap_cputime()-start_growth_time;
total_delay_overflow_time += growth_time;
LOCAL_total_delay_overflow_time += growth_time;
if (gc_verbose) {
fprintf(Yap_stderr, "%% %cO took %g sec\n", vb_msg1, (double)growth_time/1000);
fprintf(Yap_stderr, "%% %cO Total of %g sec expanding stacks \n", vb_msg1, (double)total_delay_overflow_time/1000);
fprintf(GLOBAL_stderr, "%% %cO took %g sec\n", vb_msg1, (double)growth_time/1000);
fprintf(GLOBAL_stderr, "%% %cO Total of %g sec expanding stacks \n", vb_msg1, (double)LOCAL_total_delay_overflow_time/1000);
}
LeaveGrowMode(GrowStackMode);
if (hsplit) {
@ -1246,7 +1234,7 @@ static int
do_growheap(int fix_code, UInt in_size, struct intermediates *cip, tr_fr_ptr *old_trp, TokEntry **tksp, VarEntry **vep USES_REGS)
{
unsigned long size = sizeof(CELL) * K16;
int shift_factor = (heap_overflows > 8 ? 8 : heap_overflows);
int shift_factor = (LOCAL_heap_overflows > 8 ? 8 : LOCAL_heap_overflows);
unsigned long sz = size << shift_factor;
if (sz < in_size) {
@ -1355,13 +1343,13 @@ growatomtable( USES_REGS1 )
#endif
return FALSE;
}
atom_table_overflows++;
LOCAL_atom_table_overflows ++;
if (gc_verbose) {
#if defined(YAPOR_THREADS)
fprintf(Yap_stderr, "%% Worker Id %d:\n", worker_id);
fprintf(GLOBAL_stderr, "%% Worker Id %d:\n", worker_id);
#endif
fprintf(Yap_stderr, "%% Atom Table Overflow %d\n", atom_table_overflows);
fprintf(Yap_stderr, "%% growing the atom table to %ld entries\n", (long int)(nsize));
fprintf(GLOBAL_stderr, "%% Atom Table Overflow %d\n", LOCAL_atom_table_overflows );
fprintf(GLOBAL_stderr, "%% growing the atom table to %ld entries\n", (long int)(nsize));
}
YAPEnterCriticalSection();
init_new_table(ntb, nsize);
@ -1371,10 +1359,10 @@ growatomtable( USES_REGS1 )
AtomHashTableSize = nsize;
YAPLeaveCriticalSection();
growth_time = Yap_cputime()-start_growth_time;
total_atom_table_overflow_time += growth_time;
LOCAL_total_atom_table_overflow_time += growth_time;
if (gc_verbose) {
fprintf(Yap_stderr, "%% took %g sec\n", (double)growth_time/1000);
fprintf(Yap_stderr, "%% Total of %g sec expanding atom table \n", (double)total_atom_table_overflow_time/1000);
fprintf(GLOBAL_stderr, "%% took %g sec\n", (double)growth_time/1000);
fprintf(GLOBAL_stderr, "%% Total of %g sec expanding atom table \n", (double)LOCAL_total_atom_table_overflow_time/1000);
}
#if USE_SYSTEM_MALLOC
return TRUE;
@ -1480,7 +1468,7 @@ Yap_growstack(long size)
CACHE_REGS
int res;
Yap_PrologMode |= GrowStackMode;
LOCAL_PrologMode |= GrowStackMode;
res=growstack(size PASS_REGS);
LeaveGrowMode(GrowStackMode);
return res;
@ -1602,25 +1590,25 @@ growstack(long size USES_REGS)
LOCAL_ErrorMessage = NULL;
start_growth_time = Yap_cputime();
gc_verbose = Yap_is_gc_verbose();
stack_overflows++;
LOCAL_stack_overflows++;
if (gc_verbose) {
#if defined(YAPOR) || defined(THREADS)
fprintf(Yap_stderr, "%% Worker Id %d:\n", worker_id);
fprintf(GLOBAL_stderr, "%% Worker Id %d:\n", worker_id);
#endif
fprintf(Yap_stderr, "%% Stack Overflow %d\n", stack_overflows);
fprintf(Yap_stderr, "%% Global: %8ld cells (%p-%p)\n", (unsigned long int)(H-(CELL *)LOCAL_GlobalBase),LOCAL_GlobalBase,H);
fprintf(Yap_stderr, "%% Local:%8ld cells (%p-%p)\n", (unsigned long int)(LCL0-ASP),LCL0,ASP);
fprintf(Yap_stderr, "%% Trail:%8ld cells (%p-%p)\n",
fprintf(GLOBAL_stderr, "%% Stack Overflow %d\n", LOCAL_stack_overflows);
fprintf(GLOBAL_stderr, "%% Global: %8ld cells (%p-%p)\n", (unsigned long int)(H-(CELL *)LOCAL_GlobalBase),LOCAL_GlobalBase,H);
fprintf(GLOBAL_stderr, "%% Local:%8ld cells (%p-%p)\n", (unsigned long int)(LCL0-ASP),LCL0,ASP);
fprintf(GLOBAL_stderr, "%% Trail:%8ld cells (%p-%p)\n",
(unsigned long int)(TR-(tr_fr_ptr)LOCAL_TrailBase),LOCAL_TrailBase,TR);
fprintf(Yap_stderr, "%% Growing the stacks %ld bytes\n", size);
fprintf(GLOBAL_stderr, "%% Growing the stacks %ld bytes\n", size);
}
if (!execute_growstack(size, FALSE, FALSE, NULL, NULL, NULL PASS_REGS))
return FALSE;
growth_time = Yap_cputime()-start_growth_time;
total_stack_overflow_time += growth_time;
LOCAL_total_stack_overflow_time += growth_time;
if (gc_verbose) {
fprintf(Yap_stderr, "%% took %g sec\n", (double)growth_time/1000);
fprintf(Yap_stderr, "%% Total of %g sec expanding stacks \n", (double)total_stack_overflow_time/1000);
fprintf(GLOBAL_stderr, "%% took %g sec\n", (double)growth_time/1000);
fprintf(GLOBAL_stderr, "%% Total of %g sec expanding stacks \n", (double)LOCAL_total_stack_overflow_time/1000);
}
return TRUE;
}
@ -1634,33 +1622,33 @@ Yap_growstack_in_parser(tr_fr_ptr *old_trp, TokEntry **tksp, VarEntry **vep)
UInt start_growth_time, growth_time;
int gc_verbose;
Yap_PrologMode |= GrowStackMode;
LOCAL_PrologMode |= GrowStackMode;
/* adjust to a multiple of 256) */
size = AdjustPageSize((ADDR)LCL0-LOCAL_GlobalBase);
LOCAL_ErrorMessage = NULL;
start_growth_time = Yap_cputime();
gc_verbose = Yap_is_gc_verbose();
stack_overflows++;
LOCAL_stack_overflows++;
if (gc_verbose) {
#if defined(YAPOR) || defined(THREADS)
fprintf(Yap_stderr, "%% Worker Id %d:\n", worker_id);
fprintf(GLOBAL_stderr, "%% Worker Id %d:\n", worker_id);
#endif
fprintf(Yap_stderr, "%% Stack Overflow %d\n", stack_overflows);
fprintf(Yap_stderr, "%% Global: %8ld cells (%p-%p)\n", (unsigned long int)(H-(CELL *)LOCAL_GlobalBase),LOCAL_GlobalBase,H);
fprintf(Yap_stderr, "%% Local:%8ld cells (%p-%p)\n", (unsigned long int)(LCL0-ASP),LCL0,ASP);
fprintf(Yap_stderr, "%% Trail:%8ld cells (%p-%p)\n",
fprintf(GLOBAL_stderr, "%% Stack Overflow %d\n", LOCAL_stack_overflows);
fprintf(GLOBAL_stderr, "%% Global: %8ld cells (%p-%p)\n", (unsigned long int)(H-(CELL *)LOCAL_GlobalBase),LOCAL_GlobalBase,H);
fprintf(GLOBAL_stderr, "%% Local:%8ld cells (%p-%p)\n", (unsigned long int)(LCL0-ASP),LCL0,ASP);
fprintf(GLOBAL_stderr, "%% Trail:%8ld cells (%p-%p)\n",
(unsigned long int)(TR-(tr_fr_ptr)LOCAL_TrailBase),LOCAL_TrailBase,TR);
fprintf(Yap_stderr, "%% Growing the stacks %ld bytes\n", (unsigned long int)size);
fprintf(GLOBAL_stderr, "%% Growing the stacks %ld bytes\n", (unsigned long int)size);
}
if (!execute_growstack(size, FALSE, TRUE, old_trp, tksp, vep PASS_REGS)) {
LeaveGrowMode(GrowStackMode);
return FALSE;
}
growth_time = Yap_cputime()-start_growth_time;
total_stack_overflow_time += growth_time;
LOCAL_total_stack_overflow_time += growth_time;
if (gc_verbose) {
fprintf(Yap_stderr, "%% took %g sec\n", (double)growth_time/1000);
fprintf(Yap_stderr, "%% Total of %g sec expanding stacks \n", (double)total_stack_overflow_time/1000);
fprintf(GLOBAL_stderr, "%% took %g sec\n", (double)growth_time/1000);
fprintf(GLOBAL_stderr, "%% Total of %g sec expanding stacks \n", (double)LOCAL_total_stack_overflow_time/1000);
}
LeaveGrowMode(GrowStackMode);
return TRUE;
@ -1688,19 +1676,19 @@ static int do_growtrail(long size, int contiguous_only, int in_parser, tr_fr_ptr
size=size0;
/* adjust to a multiple of 256) */
size = AdjustPageSize(size);
trail_overflows++;
LOCAL_trail_overflows++;
if (gc_verbose) {
#if defined(YAPOR) || defined(THREADS)
fprintf(Yap_stderr, "%% Worker Id %d:\n", worker_id);
fprintf(GLOBAL_stderr, "%% Worker Id %d:\n", worker_id);
#endif
fprintf(Yap_stderr, "%% Trail Overflow %d\n", trail_overflows);
fprintf(GLOBAL_stderr, "%% Trail Overflow %d\n", LOCAL_trail_overflows);
#if USE_SYSTEM_MALLOC
fprintf(Yap_stderr, "%% Heap: %8ld cells (%p-%p)\n", (unsigned long int)(H-(CELL *)LOCAL_GlobalBase),(CELL *)LOCAL_GlobalBase,H);
fprintf(Yap_stderr, "%% Local:%8ld cells (%p-%p)\n", (unsigned long int)(LCL0-ASP),LCL0,ASP);
fprintf(Yap_stderr, "%% Trail:%8ld cells (%p-%p)\n",
fprintf(GLOBAL_stderr, "%% Heap: %8ld cells (%p-%p)\n", (unsigned long int)(H-(CELL *)LOCAL_GlobalBase),(CELL *)LOCAL_GlobalBase,H);
fprintf(GLOBAL_stderr, "%% Local:%8ld cells (%p-%p)\n", (unsigned long int)(LCL0-ASP),LCL0,ASP);
fprintf(GLOBAL_stderr, "%% Trail:%8ld cells (%p-%p)\n",
(unsigned long int)(TR-(tr_fr_ptr)LOCAL_TrailBase),LOCAL_TrailBase,TR);
#endif
fprintf(Yap_stderr, "%% growing the trail %ld bytes\n", size);
fprintf(GLOBAL_stderr, "%% growing the trail %ld bytes\n", size);
}
LOCAL_ErrorMessage = NULL;
if (!GLOBAL_AllowTrailExpansion) {
@ -1714,7 +1702,7 @@ static int do_growtrail(long size, int contiguous_only, int in_parser, tr_fr_ptr
LOCAL_ErrorMessage = NULL;
if (contiguous_only) {
/* I can't expand in this case */
trail_overflows--;
LOCAL_trail_overflows--;
return FALSE;
}
execute_growstack(size, TRUE, in_parser, old_trp, tksp, vep PASS_REGS);
@ -1729,10 +1717,10 @@ static int do_growtrail(long size, int contiguous_only, int in_parser, tr_fr_ptr
}
#endif
growth_time = Yap_cputime()-start_growth_time;
total_trail_overflow_time += growth_time;
LOCAL_total_trail_overflow_time += growth_time;
if (gc_verbose) {
fprintf(Yap_stderr, "%% took %g sec\n", (double)growth_time/1000);
fprintf(Yap_stderr, "%% Total of %g sec expanding trail \n", (double)total_trail_overflow_time/1000);
fprintf(GLOBAL_stderr, "%% took %g sec\n", (double)growth_time/1000);
fprintf(GLOBAL_stderr, "%% Total of %g sec expanding trail \n", (double)LOCAL_total_trail_overflow_time/1000);
}
LOCK(LOCAL_SignalLock);
if (LOCAL_ActiveSignals == YAP_TROVF_SIGNAL) {
@ -1801,8 +1789,8 @@ Yap_shift_visit(CELL **to_visit, CELL ***to_visit_maxp)
static Int
p_inform_trail_overflows( USES_REGS1 )
{
Term tn = MkIntTerm(trail_overflows);
Term tt = MkIntegerTerm(total_trail_overflow_time);
Term tn = MkIntTerm(LOCAL_trail_overflows);
Term tt = MkIntegerTerm(LOCAL_total_trail_overflow_time);
return(Yap_unify(tn, ARG1) && Yap_unify(tt, ARG2));
}
@ -1831,8 +1819,8 @@ p_growheap( USES_REGS1 )
static Int
p_inform_heap_overflows( USES_REGS1 )
{
Term tn = MkIntTerm(heap_overflows);
Term tt = MkIntegerTerm(total_heap_overflow_time);
Term tn = MkIntTerm(LOCAL_heap_overflows);
Term tt = MkIntegerTerm(LOCAL_total_heap_overflow_time);
return(Yap_unify(tn, ARG1) && Yap_unify(tt, ARG2));
}
@ -1929,8 +1917,8 @@ p_growstack( USES_REGS1 )
static Int
p_inform_stack_overflows( USES_REGS1 )
{ /* */
Term tn = MkIntTerm(stack_overflows);
Term tt = MkIntegerTerm(total_stack_overflow_time);
Term tn = MkIntTerm(LOCAL_stack_overflows);
Term tt = MkIntegerTerm(LOCAL_total_stack_overflow_time);
return(Yap_unify(tn, ARG1) && Yap_unify(tt, ARG2));
@ -1939,9 +1927,10 @@ p_inform_stack_overflows( USES_REGS1 )
Int
Yap_total_stack_shift_time(void)
{
return(total_heap_overflow_time+
total_stack_overflow_time+
total_trail_overflow_time);
CACHE_REGS
return(LOCAL_total_heap_overflow_time+
LOCAL_total_stack_overflow_time+
LOCAL_total_trail_overflow_time);
}
void

132
C/heapgc.c
View File

@ -978,17 +978,17 @@ inc_vars_of_type(CELL *curr,gc_types val) {
static void
put_type_info(unsigned long total)
{
fprintf(Yap_stderr,"%% type info for %lu cells\n", total);
fprintf(Yap_stderr,"%% %lu vars\n", vars[gc_var]);
fprintf(Yap_stderr,"%% %lu refs\n", vars[gc_ref]);
fprintf(Yap_stderr,"%% %lu references from env\n", env_vars);
fprintf(Yap_stderr,"%% %lu atoms\n", vars[gc_atom]);
fprintf(Yap_stderr,"%% %lu small ints\n", vars[gc_int]);
fprintf(Yap_stderr,"%% %lu other numbers\n", vars[gc_num]);
fprintf(Yap_stderr,"%% %lu lists\n", vars[gc_list]);
fprintf(Yap_stderr,"%% %lu compound terms\n", vars[gc_appl]);
fprintf(Yap_stderr,"%% %lu functors\n", vars[gc_func]);
fprintf(Yap_stderr,"%% %lu suspensions\n", vars[gc_susp]);
fprintf(GLOBAL_stderr,"%% type info for %lu cells\n", total);
fprintf(GLOBAL_stderr,"%% %lu vars\n", vars[gc_var]);
fprintf(GLOBAL_stderr,"%% %lu refs\n", vars[gc_ref]);
fprintf(GLOBAL_stderr,"%% %lu references from env\n", env_vars);
fprintf(GLOBAL_stderr,"%% %lu atoms\n", vars[gc_atom]);
fprintf(GLOBAL_stderr,"%% %lu small ints\n", vars[gc_int]);
fprintf(GLOBAL_stderr,"%% %lu other numbers\n", vars[gc_num]);
fprintf(GLOBAL_stderr,"%% %lu lists\n", vars[gc_list]);
fprintf(GLOBAL_stderr,"%% %lu compound terms\n", vars[gc_appl]);
fprintf(GLOBAL_stderr,"%% %lu functors\n", vars[gc_func]);
fprintf(GLOBAL_stderr,"%% %lu suspensions\n", vars[gc_susp]);
}
static void
@ -1214,7 +1214,7 @@ mark_variable(CELL_PTR current USES_REGS)
goto begin;
#ifdef DEBUG
} else if (next < (CELL *)LOCAL_GlobalBase || next > (CELL *)LOCAL_TrailTop) {
fprintf(Yap_stderr, "OOPS in GC: marking, current=%p, *current=" UInt_FORMAT " next=%p\n", current, ccur, next);
fprintf(GLOBAL_stderr, "OOPS in GC: marking, current=%p, *current=" UInt_FORMAT " next=%p\n", current, ccur, next);
#endif
} else {
#ifdef COROUTING
@ -1455,7 +1455,7 @@ mark_environments(CELL_PTR gc_ENV, OPREG size, CELL *pvbmap USES_REGS)
#ifdef DEBUG
if (size < 0 || size > 512)
fprintf(Yap_stderr,"OOPS in GC: env size for %p is " UInt_FORMAT "\n", gc_ENV, (CELL)size);
fprintf(GLOBAL_stderr,"OOPS in GC: env size for %p is " UInt_FORMAT "\n", gc_ENV, (CELL)size);
#endif
mark_db_fixed((CELL *)gc_ENV[E_CP] PASS_REGS);
/* for each saved variable */
@ -1533,14 +1533,14 @@ mark_environments(CELL_PTR gc_ENV, OPREG size, CELL *pvbmap USES_REGS)
PredEntry *pe = EnvPreg(gc_ENV[E_CP]);
op_numbers op = Yap_op_from_opcode(ENV_ToOp(gc_ENV[E_CP]));
#if defined(ANALYST) || defined(DEBUG)
fprintf(Yap_stderr,"ENV %p-%p(%d) %s\n", gc_ENV, pvbmap, size-EnvSizeInCells, Yap_op_names[op]);
fprintf(GLOBAL_stderr,"ENV %p-%p(%d) %s\n", gc_ENV, pvbmap, size-EnvSizeInCells, Yap_op_names[op]);
#else
fprintf(Yap_stderr,"ENV %p-%p(%d) %d\n", gc_ENV, pvbmap, size-EnvSizeInCells, (int)op);
fprintf(GLOBAL_stderr,"ENV %p-%p(%d) %d\n", gc_ENV, pvbmap, size-EnvSizeInCells, (int)op);
#endif
if (pe->ArityOfPE)
fprintf(Yap_stderr," %s/%d\n", RepAtom(NameOfFunctor(pe->FunctorOfPred))->StrOfAE, pe->ArityOfPE);
fprintf(GLOBAL_stderr," %s/%d\n", RepAtom(NameOfFunctor(pe->FunctorOfPred))->StrOfAE, pe->ArityOfPE);
else
fprintf(Yap_stderr," %s\n", RepAtom((Atom)(pe->FunctorOfPred))->StrOfAE);
fprintf(GLOBAL_stderr," %s\n", RepAtom((Atom)(pe->FunctorOfPred))->StrOfAE);
}
#endif
gc_ENV = (CELL_PTR) gc_ENV[E_E]; /* link to prev
@ -1899,19 +1899,19 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose
PredEntry *pe = Yap_PredForChoicePt(gc_B);
#if defined(ANALYST) || defined(DEBUG)
if (pe == NULL) {
fprintf(Yap_stderr,"%% marked %ld (%s)\n", LOCAL_total_marked, Yap_op_names[opnum]);
fprintf(GLOBAL_stderr,"%% marked %ld (%s)\n", LOCAL_total_marked, Yap_op_names[opnum]);
} else if (pe->ArityOfPE) {
fprintf(Yap_stderr,"%% %s/%d marked %ld (%s)\n", RepAtom(NameOfFunctor(pe->FunctorOfPred))->StrOfAE, pe->ArityOfPE, LOCAL_total_marked, Yap_op_names[opnum]);
fprintf(GLOBAL_stderr,"%% %s/%d marked %ld (%s)\n", RepAtom(NameOfFunctor(pe->FunctorOfPred))->StrOfAE, pe->ArityOfPE, LOCAL_total_marked, Yap_op_names[opnum]);
} else {
fprintf(Yap_stderr,"%% %s marked %ld (%s)\n", RepAtom((Atom)(pe->FunctorOfPred))->StrOfAE, LOCAL_total_marked, Yap_op_names[opnum]);
fprintf(GLOBAL_stderr,"%% %s marked %ld (%s)\n", RepAtom((Atom)(pe->FunctorOfPred))->StrOfAE, LOCAL_total_marked, Yap_op_names[opnum]);
}
#else
if (pe == NULL) {
fprintf(Yap_stderr,"%% marked %ld (%u)\n", LOCAL_total_marked, (unsigned int)opnum);
fprintf(GLOBAL_stderr,"%% marked %ld (%u)\n", LOCAL_total_marked, (unsigned int)opnum);
} else if (pe->ArityOfPE) {
fprintf(Yap_stderr,"%% %s/%d marked %ld (%u)\n", RepAtom(NameOfFunctor(pe->FunctorOfPred))->StrOfAE, pe->ArityOfPE, LOCAL_total_marked, (unsigned int)opnum);
fprintf(GLOBAL_stderr,"%% %s/%d marked %ld (%u)\n", RepAtom(NameOfFunctor(pe->FunctorOfPred))->StrOfAE, pe->ArityOfPE, LOCAL_total_marked, (unsigned int)opnum);
} else {
fprintf(Yap_stderr,"%% %s marked %ld (%u)\n", RepAtom((Atom)(pe->FunctorOfPred))->StrOfAE, LOCAL_total_marked, (unsigned int)opnum);
fprintf(GLOBAL_stderr,"%% %s marked %ld (%u)\n", RepAtom((Atom)(pe->FunctorOfPred))->StrOfAE, LOCAL_total_marked, (unsigned int)opnum);
}
#endif
}
@ -2205,7 +2205,7 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose
nargs = rtp->u.Otapl.s;
break;
default:
fprintf(Yap_stderr, "OOPS in GC: Unexpected opcode: %d\n", opnum);
fprintf(GLOBAL_stderr, "OOPS in GC: Unexpected opcode: %d\n", opnum);
nargs = 0;
#else
default:
@ -2644,27 +2644,27 @@ sweep_trail(choiceptr gc_B, tr_fr_ptr old_TR USES_REGS)
LOCAL_new_TR = dest;
if (is_gc_verbose()) {
if (old_TR != (tr_fr_ptr)LOCAL_TrailBase)
fprintf(Yap_stderr,
fprintf(GLOBAL_stderr,
"%% Trail: discarded %d (%ld%%) cells out of %ld\n",
LOCAL_discard_trail_entries,
(unsigned long int)(LOCAL_discard_trail_entries*100/(old_TR-(tr_fr_ptr)LOCAL_TrailBase)),
(unsigned long int)(old_TR-(tr_fr_ptr)LOCAL_TrailBase));
#ifdef DEBUG
if (hp_entrs > 0)
fprintf(Yap_stderr,
fprintf(GLOBAL_stderr,
"%% Trail: unmarked %ld dbentries (%ld%%) out of %ld\n",
(long int)hp_not_in_use,
(long int)(hp_not_in_use*100/hp_entrs),
(long int)hp_entrs);
if (hp_in_use_erased > 0 && hp_erased > 0)
fprintf(Yap_stderr,
fprintf(GLOBAL_stderr,
"%% Trail: deleted %ld dbentries (%ld%%) out of %ld\n",
(long int)hp_erased,
(long int)(hp_erased*100/(hp_erased+hp_in_use_erased)),
(long int)(hp_erased+hp_in_use_erased));
#endif
if (OldHeapUsed) {
fprintf(Yap_stderr,
fprintf(GLOBAL_stderr,
"%% Heap: recovered %ld bytes (%ld%%) out of %ld\n",
(unsigned long int)(OldHeapUsed-HeapUsed),
(unsigned long int)((OldHeapUsed-HeapUsed)/(OldHeapUsed/100)),
@ -2832,7 +2832,7 @@ sweep_choicepoints(choiceptr gc_B USES_REGS)
restart_cp:
/*
* fprintf(Yap_stderr,"sweeping cps: %x, %x, %x\n",
* fprintf(GLOBAL_stderr,"sweeping cps: %x, %x, %x\n",
* *gc_B,CP_Extra(gc_B),CP_Nargs(gc_B));
*/
/* any choice point */
@ -3279,12 +3279,12 @@ compact_heap( USES_REGS1 )
#ifdef DEBUG
if (dest != start_from-1)
fprintf(Yap_stderr,"%% Bad Dest (%lu): %p should be %p\n",
fprintf(GLOBAL_stderr,"%% Bad Dest (%lu): %p should be %p\n",
(unsigned long int)LOCAL_GcCalls,
dest,
start_from-1);
if (LOCAL_total_marked != found_marked)
fprintf(Yap_stderr,"%% Upward (%lu): %lu total against %lu found\n",
fprintf(GLOBAL_stderr,"%% Upward (%lu): %lu total against %lu found\n",
(unsigned long int)LOCAL_GcCalls,
(unsigned long int)LOCAL_total_marked,
(unsigned long int)found_marked);
@ -3343,7 +3343,7 @@ compact_heap( USES_REGS1 )
}
#ifdef DEBUG
if (LOCAL_total_marked != found_marked)
fprintf(Yap_stderr,"%% Downward (%lu): %lu total against %lu found\n",
fprintf(GLOBAL_stderr,"%% Downward (%lu): %lu total against %lu found\n",
(unsigned long int)LOCAL_GcCalls,
(unsigned long int)LOCAL_total_marked,
(unsigned long int)found_marked);
@ -3452,12 +3452,12 @@ icompact_heap( USES_REGS1 )
#ifdef DEBUG
if (dest != H0-1)
fprintf(Yap_stderr,"%% Bad Dest (%lu): %p should be %p\n",
fprintf(GLOBAL_stderr,"%% Bad Dest (%lu): %p should be %p\n",
(unsigned long int)LOCAL_GcCalls,
dest,
H0-1);
if (LOCAL_total_marked != found_marked)
fprintf(Yap_stderr,"%% Upward (%lu): %lu total against %lu found\n",
fprintf(GLOBAL_stderr,"%% Upward (%lu): %lu total against %lu found\n",
(unsigned long int)LOCAL_GcCalls,
(unsigned long int)LOCAL_total_marked,
(unsigned long int)found_marked);
@ -3515,12 +3515,12 @@ icompact_heap( USES_REGS1 )
}
#ifdef DEBUG
if (H0+LOCAL_total_marked != dest)
fprintf(Yap_stderr,"%% Downward (%lu): %p total against %p found\n",
fprintf(GLOBAL_stderr,"%% Downward (%lu): %p total against %p found\n",
(unsigned long int)LOCAL_GcCalls,
H0+LOCAL_total_marked,
dest);
if (LOCAL_total_marked != found_marked)
fprintf(Yap_stderr,"%% Downward (%lu): %lu total against %lu found\n",
fprintf(GLOBAL_stderr,"%% Downward (%lu): %lu total against %lu found\n",
(unsigned long int)LOCAL_GcCalls,
(unsigned long int)LOCAL_total_marked,
(unsigned long int)found_marked);
@ -3643,12 +3643,12 @@ compaction_phase(tr_fr_ptr old_TR, CELL *current_env, yamop *curp USES_REGS)
-LOCAL_total_smarked
#endif
!= LOCAL_iptop-(CELL_PTR *)H && LOCAL_iptop < (CELL_PTR *)ASP -1024)
fprintf(Yap_stderr,"%% Oops on LOCAL_iptop-H (%ld) vs %ld\n", (unsigned long int)(LOCAL_iptop-(CELL_PTR *)H), LOCAL_total_marked);
fprintf(GLOBAL_stderr,"%% Oops on LOCAL_iptop-H (%ld) vs %ld\n", (unsigned long int)(LOCAL_iptop-(CELL_PTR *)H), LOCAL_total_marked);
*/
#endif
#if DEBUGX
int effectiveness = (((H-H0)-LOCAL_total_marked)*100)/(H-H0);
fprintf(Yap_stderr,"%% using pointers (%d)\n", effectiveness);
fprintf(GLOBAL_stderr,"%% using pointers (%d)\n", effectiveness);
#endif
if (CurrentH0) {
H0 = CurrentH0;
@ -3719,15 +3719,15 @@ do_gc(Int predarity, CELL *current_env, yamop *nextop USES_REGS)
if (Yap_GetValue(AtomGcTrace) != TermNil)
gc_trace = 1;
if (gc_trace) {
fprintf(Yap_stderr, "%% gc\n");
fprintf(GLOBAL_stderr, "%% gc\n");
} else if (gc_verbose) {
#if defined(YAPOR) || defined(THREADS)
fprintf(Yap_stderr, "%% Worker Id %d:\n", worker_id);
fprintf(GLOBAL_stderr, "%% Worker Id %d:\n", worker_id);
#endif
fprintf(Yap_stderr, "%% Start of garbage collection %lu:\n", (unsigned long int)LOCAL_GcCalls);
fprintf(Yap_stderr, "%% Global: %8ld cells (%p-%p)\n", (long int)heap_cells,H0,H);
fprintf(Yap_stderr, "%% Local:%8ld cells (%p-%p)\n", (unsigned long int)(LCL0-ASP),LCL0,ASP);
fprintf(Yap_stderr, "%% Trail:%8ld cells (%p-%p)\n",
fprintf(GLOBAL_stderr, "%% Start of garbage collection %lu:\n", (unsigned long int)LOCAL_GcCalls);
fprintf(GLOBAL_stderr, "%% Global: %8ld cells (%p-%p)\n", (long int)heap_cells,H0,H);
fprintf(GLOBAL_stderr, "%% Local:%8ld cells (%p-%p)\n", (unsigned long int)(LCL0-ASP),LCL0,ASP);
fprintf(GLOBAL_stderr, "%% Trail:%8ld cells (%p-%p)\n",
(unsigned long int)(TR-(tr_fr_ptr)LOCAL_TrailBase),LOCAL_TrailBase,TR);
}
#if !USE_SYSTEM_MALLOC
@ -3826,21 +3826,21 @@ do_gc(Int predarity, CELL *current_env, yamop *nextop USES_REGS)
} else
effectiveness = 0;
if (gc_verbose) {
fprintf(Yap_stderr, "%% Mark: Marked %ld cells of %ld (efficiency: %ld%%) in %g sec\n",
fprintf(GLOBAL_stderr, "%% Mark: Marked %ld cells of %ld (efficiency: %ld%%) in %g sec\n",
(long int)tot, (long int)heap_cells, (long int)effectiveness, (double)(m_time-time_start)/1000);
if (LOCAL_HGEN-H0)
fprintf(Yap_stderr,"%% previous generation has size " UInt_FORMAT ", with " UInt_FORMAT " (" UInt_FORMAT "%%) unmarked\n", (UInt)(LOCAL_HGEN-H0), (UInt)((LOCAL_HGEN-H0)-LOCAL_total_oldies), (UInt)(100*((LOCAL_HGEN-H0)-LOCAL_total_oldies)/(LOCAL_HGEN-H0)));
fprintf(GLOBAL_stderr,"%% previous generation has size " UInt_FORMAT ", with " UInt_FORMAT " (" UInt_FORMAT "%%) unmarked\n", (UInt)(LOCAL_HGEN-H0), (UInt)((LOCAL_HGEN-H0)-LOCAL_total_oldies), (UInt)(100*((LOCAL_HGEN-H0)-LOCAL_total_oldies)/(LOCAL_HGEN-H0)));
#ifdef INSTRUMENT_GC
{
int i;
for (i=0; i<16; i++) {
if (chain[i]) {
fprintf(Yap_stderr, "%% chain[%d]=%lu\n", i, chain[i]);
fprintf(GLOBAL_stderr, "%% chain[%d]=%lu\n", i, chain[i]);
}
}
put_type_info((unsigned long int)tot);
fprintf(Yap_stderr,"%% %lu/%ld before and %lu/%ld after\n", old_vars, (unsigned long int)(B->cp_h-H0), new_vars, (unsigned long int)(H-B->cp_h));
fprintf(Yap_stderr,"%% %ld choicepoints\n", num_bs);
fprintf(GLOBAL_stderr,"%% %lu/%ld before and %lu/%ld after\n", old_vars, (unsigned long int)(B->cp_h-H0), new_vars, (unsigned long int)(H-B->cp_h));
fprintf(GLOBAL_stderr,"%% %ld choicepoints\n", num_bs);
}
#endif
}
@ -3849,7 +3849,7 @@ do_gc(Int predarity, CELL *current_env, yamop *nextop USES_REGS)
TR = old_TR;
pop_registers(predarity, nextop PASS_REGS);
TR = LOCAL_new_TR;
/* fprintf(Yap_stderr,"NEW LOCAL_HGEN %ld (%ld)\n", H-H0, LOCAL_HGEN-H0);*/
/* fprintf(GLOBAL_stderr,"NEW LOCAL_HGEN %ld (%ld)\n", H-H0, LOCAL_HGEN-H0);*/
{
Term t = MkVarTerm();
Yap_UpdateTimedVar(LOCAL_GcGeneration, t);
@ -3857,14 +3857,14 @@ do_gc(Int predarity, CELL *current_env, yamop *nextop USES_REGS)
Yap_UpdateTimedVar(LOCAL_GcPhase, MkIntegerTerm(LOCAL_GcCurrentPhase));
c_time = Yap_cputime();
if (gc_verbose) {
fprintf(Yap_stderr, "%% Compress: took %g sec\n", (double)(c_time-time_start)/1000);
fprintf(GLOBAL_stderr, "%% Compress: took %g sec\n", (double)(c_time-time_start)/1000);
}
gc_time += (c_time-time_start);
LOCAL_TotGcTime += gc_time;
LOCAL_TotGcRecovered += heap_cells-tot;
if (gc_verbose) {
fprintf(Yap_stderr, "%% GC %lu took %g sec, total of %g sec doing GC so far.\n", (unsigned long int)LOCAL_GcCalls, (double)gc_time/1000, (double)LOCAL_TotGcTime/1000);
fprintf(Yap_stderr, "%% Left %ld cells free in stacks.\n",
fprintf(GLOBAL_stderr, "%% GC %lu took %g sec, total of %g sec doing GC so far.\n", (unsigned long int)LOCAL_GcCalls, (double)gc_time/1000, (double)LOCAL_TotGcTime/1000);
fprintf(GLOBAL_stderr, "%% Left %ld cells free in stacks.\n",
(unsigned long int)(ASP-H));
}
check_global();
@ -3874,7 +3874,8 @@ do_gc(Int predarity, CELL *current_env, yamop *nextop USES_REGS)
static int
is_gc_verbose(void)
{
if (Yap_PrologMode == BootMode)
CACHE_REGS
if (LOCAL_PrologMode == BootMode)
return FALSE;
#ifdef INSTRUMENT_GC
/* always give info when we are debugging gc */
@ -3894,7 +3895,8 @@ Yap_is_gc_verbose(void)
static int
is_gc_very_verbose(void)
{
if (Yap_PrologMode == BootMode)
CACHE_REGS
if (LOCAL_PrologMode == BootMode)
return FALSE;
return Yap_GetValue(AtomGcVeryVerbose) != TermNil;
}
@ -3947,7 +3949,7 @@ call_gc(UInt gc_lim, Int predarity, CELL *current_env, yamop *nextop USES_REGS)
if (gc_margin < gc_lim)
gc_margin = gc_lim;
LOCAL_HGEN = VarOfTerm(Yap_ReadTimedVar(LOCAL_GcGeneration));
if (gc_on && !(Yap_PrologMode & InErrorMode) &&
if (gc_on && !(LOCAL_PrologMode & InErrorMode) &&
/* make sure there is a point in collecting the heap */
(ASP-H0)*sizeof(CELL) > gc_lim &&
H-LOCAL_HGEN > (LCL0-ASP)/2) {
@ -3979,10 +3981,10 @@ call_gc(UInt gc_lim, Int predarity, CELL *current_env, yamop *nextop USES_REGS)
static void
LeaveGCMode( USES_REGS1 )
{
if (Yap_PrologMode & GCMode)
Yap_PrologMode &= ~GCMode;
if (Yap_PrologMode & AbortMode) {
Yap_PrologMode &= ~AbortMode;
if (LOCAL_PrologMode & GCMode)
LOCAL_PrologMode &= ~GCMode;
if (LOCAL_PrologMode & AbortMode) {
LOCAL_PrologMode &= ~AbortMode;
Yap_Error(PURE_ABORT, TermNil, "");
P = FAILCODE;
}
@ -3993,11 +3995,11 @@ Yap_gc(Int predarity, CELL *current_env, yamop *nextop)
{
CACHE_REGS
int res;
Yap_PrologMode |= GCMode;
LOCAL_PrologMode |= GCMode;
res=call_gc(4096, predarity, current_env, nextop PASS_REGS);
LeaveGCMode( PASS_REGS1 );
if (Yap_PrologMode & GCMode)
Yap_PrologMode &= ~GCMode;
if (LOCAL_PrologMode & GCMode)
LOCAL_PrologMode &= ~GCMode;
return res;
}
@ -4008,7 +4010,7 @@ Yap_gcl(UInt gc_lim, Int predarity, CELL *current_env, yamop *nextop)
int res;
UInt min = CalculateStackGap()*sizeof(CELL);
Yap_PrologMode |= GCMode;
LOCAL_PrologMode |= GCMode;
if (gc_lim < min)
gc_lim = min;
res = call_gc(gc_lim, predarity, current_env, nextop PASS_REGS);
@ -4021,7 +4023,7 @@ static Int
p_gc( USES_REGS1 )
{
int res;
Yap_PrologMode |= GCMode;
LOCAL_PrologMode |= GCMode;
if (P->opc == Yap_opcode(_execute_cpred))
res = do_gc(0, ENV, CP PASS_REGS) >= 0;
else

10
C/index.c
View File

@ -3449,7 +3449,7 @@ Yap_PredIsIndexable(PredEntry *ap, UInt NSlots, yamop *next_pc)
return FAILCODE;
}
#ifdef DEBUG
if (Yap_Option['i' - 'a' + 1]) {
if (GLOBAL_Option['i' - 'a' + 1]) {
Yap_ShowCode(&cint);
}
#endif
@ -4572,7 +4572,7 @@ ExpandIndex(PredEntry *ap, int ExtraArgs, yamop *nextop USES_REGS) {
expand_clauses = NULL;
}
#ifdef DEBUG
if (Yap_Option['i' - 'a' + 1]) {
if (GLOBAL_Option['i' - 'a' + 1]) {
Term tmod = ap->ModuleOfPred;
if (!tmod) tmod = TermProlog;
#if THREADS
@ -4634,7 +4634,7 @@ ExpandIndex(PredEntry *ap, int ExtraArgs, yamop *nextop USES_REGS) {
return FAILCODE;
}
#ifdef DEBUG
if (Yap_Option['i' - 'a' + 1]) {
if (GLOBAL_Option['i' - 'a' + 1]) {
Yap_ShowCode(&cint);
}
#endif
@ -6046,7 +6046,7 @@ Yap_AddClauseToIndex(PredEntry *ap, yamop *beg, int first) {
LOCAL_Error_Size = 0;
LOCAL_ErrorMessage = NULL;
#ifdef DEBUG
if (Yap_Option['i' - 'a' + 1]) {
if (GLOBAL_Option['i' - 'a' + 1]) {
Term tmod = ap->ModuleOfPred;
if (!tmod) tmod = TermProlog;
Yap_DebugPutc(LOCAL_c_error_stream,'+');
@ -6530,7 +6530,7 @@ Yap_RemoveClauseFromIndex(PredEntry *ap, yamop *beg) {
return;
}
#ifdef DEBUG
if (Yap_Option['i' - 'a' + 1]) {
if (GLOBAL_Option['i' - 'a' + 1]) {
Term tmod = ap->ModuleOfPred;
if (!tmod) tmod = TermProlog;

67
C/init.c
View File

@ -55,7 +55,6 @@ static char SccsId[] = "%W% %G%";
#define LOGFILE "logfile"
int Yap_output_msg = FALSE;
#ifdef MACC
STATIC_PROTO(void InTTYLine, (char *));
@ -82,45 +81,6 @@ static void InitWorker(int wid);
/************* variables related to memory allocation ***************/
ADDR Yap_HeapBase;
#if defined(THREADS)
pthread_t Yap_master_thread;
#endif /* THREADS */
/******** whether Yap is responsible for signal handling******************/
int Yap_PrologShouldHandleInterrupts;
/********* readline support *****/
#if HAVE_LIBREADLINE
char *_line = (char *) NULL;
#endif
/********* Prolog State ********************************************/
Int Yap_PrologMode = BootMode;
int Yap_CritLocks = 0;
/********* streams ********************************************/
YP_FILE *Yap_stdout;
YP_FILE *Yap_stderr;
/************** Access to yap initial arguments ***************************/
char **Yap_argv;
int Yap_argc;
/************** Extensions to Terms ***************************************/
#ifdef COROUTINING
/* array with the ops for your favourite extensions */
ext_op attas[attvars_ext+1];
#endif
/************** declarations local to init.c ************************/
static char *optypes[] =
{"", "xfx", "xfy", "yfx", "xf", "yf", "fx", "fy"};
@ -133,10 +93,6 @@ int Yap_page_size;
void **Yap_ABSMI_OPCODES;
#endif
#if USE_SOCKET
int Yap_sockets_io=0;
#endif
#if DEBUG
#if COROUTINING
int Yap_Portray_delays = FALSE;
@ -242,7 +198,7 @@ static void
SetOp(int p, int type, char *at, Term m)
{
#ifdef DEBUG
if (Yap_Option[5])
if (GLOBAL_Option[5])
fprintf(stderr,"[setop %d %s %s]\n", p, optypes[type], at);
#endif
OpDec(p, optypes[type], Yap_LookupAtom(at), m);
@ -384,8 +340,8 @@ InitDebug(void)
int i;
for (i = 1; i < 20; ++i)
Yap_Option[i] = 0;
if (Yap_output_msg) {
GLOBAL_Option[i] = 0;
if (GLOBAL_output_msg) {
char ch;
#if HAVE_ISATTY
@ -400,10 +356,10 @@ InitDebug(void)
fprintf(stderr,"m Machine\t p parser\n");
while ((ch = YP_putchar(YP_getchar())) != '\n')
if (ch >= 'a' && ch <= 'z')
Yap_Option[ch - 'a' + 1] = 1;
if (Yap_Option['l' - 96]) {
Yap_logfile = fopen(LOGFILE, "w");
if (Yap_logfile == NULL) {
GLOBAL_Option[ch - 'a' + 1] = 1;
if (GLOBAL_Option['l' - 96]) {
GLOBAL_logfile = fopen(LOGFILE, "w");
if (GLOBAL_logfile == NULL) {
fprintf(stderr,"can not open %s\n", LOGFILE);
getchar();
exit(0);
@ -1292,8 +1248,9 @@ Yap_InitWorkspace(UInt Heap, UInt Stack, UInt Trail, UInt Atts, UInt max_table_s
return;
pthread_key_create(&Yap_yaamregs_key, NULL);
pthread_setspecific(Yap_yaamregs_key, (const void *)&Yap_standard_regs);
LOCAL = REMOTE(0);
Yap_master_thread = pthread_self();
//printf(" -> -> %p \n", &Yap_REGS);
//LOCAL = REMOTE(0);
GLOBAL_master_thread = pthread_self();
#else
/* In this case we need to initialise the abstract registers */
Yap_regp = &Yap_standard_regs;
@ -1304,6 +1261,7 @@ Yap_InitWorkspace(UInt Heap, UInt Stack, UInt Trail, UInt Atts, UInt max_table_s
#ifdef THREADS
Yap_regp = ((REGSTORE *)pthread_getspecific(Yap_yaamregs_key));
LOCAL = REMOTE(0);
#endif /* THREADS */
if (Heap < MinHeapSpace)
Heap = MinHeapSpace;
@ -1398,11 +1356,12 @@ run_halt_hooks(int code)
void
Yap_exit (int value)
{
CACHE_REGS
#if defined(YAPOR_COPY) || defined(YAPOR_COW) || defined(YAPOR_SBA)
Yap_unmap_optyap_memory();
#endif
if (! (Yap_PrologMode & BootMode) ) {
if (! (LOCAL_PrologMode & BootMode) ) {
#ifdef LOW_PROF
remove("PROFPREDS");
remove("PROFILING");

12
C/iopreds.c
View File

@ -183,17 +183,17 @@ Yap_DebugGetc()
}
if ((ch = *lp++) == 0)
ch = '\n', eolflg = 1;
if (Yap_Option['l' - 96])
putc(ch, Yap_logfile);
if (GLOBAL_Option['l' - 96])
putc(ch, GLOBAL_logfile);
return (ch);
}
int
Yap_DebugPutc(int sno, wchar_t ch)
{
if (Yap_Option['l' - 96])
(void) putc(ch, Yap_logfile);
return (putc(ch, Yap_stderr));
if (GLOBAL_Option['l' - 96])
(void) putc(ch, GLOBAL_logfile);
return (putc(ch, GLOBAL_stderr));
}
void
@ -1103,8 +1103,6 @@ Yap_InitBackIO (void)
void
Yap_InitIOPreds(void)
{
Yap_stdout = stdout;
Yap_stderr = stderr;
if (!Stream)
Stream = (StreamDesc *)Yap_AllocCodeSpace(sizeof(StreamDesc)*MaxStreams);
/* here the Input/Output predicates */

30
C/load_aout.c
View File

@ -18,7 +18,7 @@
#include "Foreign.h"
#ifdef A_OUT
this code is no being maintained anymore
#include <stdio.h>
#if STDC_HEADERS
#include <stdlib.h>
@ -43,7 +43,7 @@
#endif
#include <a.out.h>
static char YapExecutable[YAP_FILE_MAX];
#define oktox(n) \
(0==stat(n,&stbuf)&&(stbuf.st_mode&S_IFMT)==S_IFREG&&0==access(n,X_OK))
@ -64,10 +64,10 @@ Yap_FindExecutable(char *name)
cp = (char *)getenv("PATH");
if (cp == NULL)
cp = ".:/usr/ucb:/bin:/usr/bin:/usr/local/bin";
if (*Yap_argv[0] == '/') {
if (oktox(Yap_argv[0])) {
strcpy(LOCAL_FileNameBuf, Yap_argv[0]);
Yap_TrueFileName(LOCAL_FileNameBuf, YapExecutable, TRUE);
if (*GLOBAL_argv[0] == '/') {
if (oktox(GLOBAL_argv[0])) {
strcpy(LOCAL_FileNameBuf, GLOBAL_argv[0]);
Yap_TrueFileName(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE);
return;
}
}
@ -82,21 +82,21 @@ Yap_FindExecutable(char *name)
for (cp2 = LOCAL_FileNameBuf; (*cp) != 0 && (*cp) != ':';)
*cp2++ = *cp++;
*cp2++ = '/';
strcpy(cp2, Yap_argv[0]);
strcpy(cp2, GLOBAL_argv[0]);
if (*cp)
cp++;
if (!oktox(LOCAL_FileNameBuf))
continue;
Yap_TrueFileName(LOCAL_FileNameBuf, YapExecutable, TRUE);
Yap_TrueFileName(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE);
return;
}
/* one last try for dual systems */
strcpy(LOCAL_FileNameBuf, Yap_argv[0]);
Yap_TrueFileName(LOCAL_FileNameBuf, YapExecutable, TRUE);
if (oktox(YapExecutable))
strcpy(LOCAL_FileNameBuf, GLOBAL_argv[0]);
Yap_TrueFileName(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE);
if (oktox(GLOBAL_Executable))
return;
else
Yap_Error(SYSTEM_ERROR,MkAtomTerm(Yap_LookupAtom(YapExecutable)),
Yap_Error(SYSTEM_ERROR,MkAtomTerm(Yap_LookupAtom(GLOBAL_Executable)),
"cannot find file being executed");
}
@ -174,12 +174,12 @@ LoadForeign(StringList ofiles,
/* prepare the magic */
if (strlen(o_files) + strlen(l_files) + strlen(proc_name) +
strlen(YapExecutable) > 2*MAXPATHLEN) {
strlen(GLOBAL_Executable) > 2*MAXPATHLEN) {
strcpy(LOCAL_ErrorSay, " too many parameters in load_foreign/3 ");
return LOAD_FAILLED;
}
sprintf(command, "/usr/bin/ld -N -A %s -o %s -u _%s %s %s -lc",
YapExecutable,
GLOBAL_Executable,
tfile, proc_name, o_files, l_files);
/* now, do the magic */
if (system(command) != 0) {
@ -209,7 +209,7 @@ LoadForeign(StringList ofiles,
}
/* now, a new incantation to load the new foreign code */
sprintf(command, "/usr/bin/ld -N -A %s -T %lx -o %s -u _%s %s %s -lc",
YapExecutable,
GLOBAL_Executable,
(unsigned long) FCodeBase,
tfile, proc_name, o_files, l_files);
/* and do it */

28
C/load_coff.c
View File

@ -19,7 +19,7 @@
#include "Foreign.h"
#ifdef COFF
this code is no being maintained anymore
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
@ -45,8 +45,6 @@
#define N_TXTOFF(x) (sizeof(struct filehdr)+(x).f_opthdr+(x).f_nscns*sizeof(struct scnhdr))
static char YapExecutable[YAP_FILE_MAX];
/*
* YAP_FindExecutable(argv[0]) should be called on yap initialization to
@ -62,10 +60,10 @@ Yap_FindExecutable(char *name)
cp = (char *)getenv("PATH");
if (cp == NULL)
cp = ".:/usr/ucb:/bin:/usr/bin:/usr/local/bin";
if (*Yap_argv[0] == '/') {
if (oktox(Yap_argv[0])) {
strcpy(LOCAL_FileNameBuf, Yap_argv[0]);
Yap_TrueFileName(LOCAL_FileNameBuf, YapExecutable, TRUE);
if (*GLOBAL_argv[0] == '/') {
if (oktox(GLOBAL_argv[0])) {
strcpy(LOCAL_FileNameBuf, GLOBAL_argv[0]);
Yap_TrueFileName(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE);
return;
}
}
@ -80,21 +78,21 @@ Yap_FindExecutable(char *name)
for (cp2 = LOCAL_FileNameBuf; (*cp) != 0 && (*cp) != ':';)
*cp2++ = *cp++;
*cp2++ = '/';
strcpy(cp2, Yap_argv[0]);
strcpy(cp2, GLOBAL_argv[0]);
if (*cp)
cp++;
if (!oktox(LOCAL_FileNameBuf))
continue;
Yap_TrueFileName(LOCAL_FileNameBuf, YapExecutable, TRUE);
Yap_TrueFileName(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE);
return;
}
/* one last try for dual systems */
strcpy(LOCAL_FileNameBuf, Yap_argv[0]);
Yap_TrueFileName(LOCAL_FileNameBuf, YapExecutable, TRUE);
if (oktox(YapExecutable))
strcpy(LOCAL_FileNameBuf, GLOBAL_argv[0]);
Yap_TrueFileName(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE);
if (oktox(GLOBAL_Executable))
return;
else
Yap_Error(SYSTEM_ERROR,MkAtomTerm(Yap_LookupAtom(YapExecutable)),
Yap_Error(SYSTEM_ERROR,MkAtomTerm(Yap_LookupAtom(GLOBAL_Executable)),
"cannot find file being executed");
}
@ -175,12 +173,12 @@ LoadForeign(StringList ofiles,
/* prepare the magic */
if (strlen(o_files) + strlen(l_files) + strlen(proc_name) +
strlen(YapExecutable) > 2*MAXPATHLEN) {
strlen(GLOBAL_Executable) > 2*MAXPATHLEN) {
strcpy(LOCAL_ErrorSay, " too many parameters in load_foreign/3 ");
return LOAD_FAILLED;
}
sprintf(command, "/usr/bin/ld -N -A %s -o %s %s %s -lc",
YapExecutable,
GLOBAL_Executable,
tfile, o_files, l_files);
/* now, do the magic */
if (system(command) != 0) {

9
C/load_dld.c
View File

@ -20,8 +20,7 @@
#include <malloc.h>
#include <stdio.h>
static char YapExecutable[YAP_FILE_MAX];
this code is no being maintained anymore
/*
* YAP_FindExecutable(argv[0]) should be called on yap initialization to
@ -33,9 +32,9 @@ Yap_FindExecutable(char *name)
/* use dld_find_executable */
char *res;
if(name != NULL && (res=dld_find_executable(name))) {
strcpy(YapExecutable,res);
strcpy(GLOBAL_Executable,res);
} else {
strcpy(YapExecutable,"./yap");
strcpy(GLOBAL_Executable,"./yap");
}
}
@ -71,7 +70,7 @@ LoadForeign(StringList ofiles, StringList libs,
int error;
if(firstTime) {
error = dld_init(YapExecutable);
error = dld_init(GLOBAL_Executable);
if(error) {
strcpy(LOCAL_ErrorSay,dld_strerror(error));
return LOAD_FAILLED;

6
C/load_dyld.c
View File

@ -28,13 +28,13 @@
*/
#import <mach-o/dyld.h>
static int dl_errno;
static char *
mydlerror(void)
{
char *errString;
switch(dl_errno) {
switch(LOCAL_dl_errno) {
default:
case NSObjectFileImageFailure:
case NSObjectFileImageFormat:
@ -76,7 +76,7 @@ mydlopen(char *path)
NSModule handle = NULL;
dyld_result = NSCreateObjectFileImageFromFile(path, &ofile);
if (dyld_result != NSObjectFileImageSuccess) {
dl_errno = dyld_result;
LOCAL_dl_errno = dyld_result;
} else {
/* NSLinkModule will cause the run to abort on any link error's */
/* not very friendly but the error recovery functionality is limited */

4
C/load_foreign.c
View File

@ -225,10 +225,10 @@ p_open_shared_objects( USES_REGS1 ) {
void
Yap_InitLoadForeign( void )
{
if (Yap_argv == NULL)
if (GLOBAL_argv == NULL)
Yap_FindExecutable("yap");
else
Yap_FindExecutable(Yap_argv[0]);
Yap_FindExecutable(GLOBAL_argv[0]);
Yap_InitCPred("$load_foreign_files", 3, p_load_foreign, SafePredFlag|SyncPredFlag|HiddenPredFlag);
Yap_InitCPred("$open_shared_objects", 0, p_open_shared_objects, SafePredFlag|HiddenPredFlag);
Yap_InitCPred("$open_shared_object", 3, p_open_shared_object, SyncPredFlag|HiddenPredFlag);

6
C/parser.c
View File

@ -122,8 +122,8 @@ Yap_LookupVar(char *var) /* lookup variable in variables table */
VarEntry *p;
#ifdef DEBUG
if (Yap_Option[4])
fprintf(Yap_stderr,"[LookupVar %s]", var);
if (GLOBAL_Option[4])
fprintf(GLOBAL_stderr,"[LookupVar %s]", var);
#endif
if (var[0] != '_' || var[1] != '\0') {
VarEntry **op = &LOCAL_VarTable;
@ -690,7 +690,7 @@ ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS)
break;
}
#ifdef DEBUG
if (Yap_Option['p' - 'a' + 1]) {
if (GLOBAL_Option['p' - 'a' + 1]) {
Yap_DebugPutc(LOCAL_c_error_stream,'[');
Yap_DebugPlWrite(t);
Yap_DebugPutc(LOCAL_c_error_stream,']');

17
C/save.c
View File

@ -227,7 +227,7 @@ static int splfild = 0;
#ifdef DEBUG_RESTORE4
static FILE *errout;
#else
#define errout Yap_stderr
#define errout GLOBAL_stderr
#endif
#endif /* DEBUG */
@ -1337,7 +1337,7 @@ ShowEntries(pp)
PropEntry *pp;
{
while (!EndOfPAEntr(pp)) {
fprintf(Yap_stderr,"Estou a ver a prop %x em %x\n", pp->KindOfPE, pp);
fprintf(GLOBAL_stderr,"Estou a ver a prop %x em %x\n", pp->KindOfPE, pp);
pp = RepProp(pp->NextOfPE);
}
}
@ -1352,7 +1352,7 @@ ShowAtoms()
AtomEntry *at;
at = RepAtom(HashPtr->Entry);
do {
fprintf(Yap_stderr,"Passei ao %s em %x\n", at->StrOfAE, at);
fprintf(GLOBAL_stderr,"Passei ao %s em %x\n", at->StrOfAE, at);
ShowEntries(RepProp(at->PropsOfAE));
} while (!EndOfPAEntr(at = RepAtom(at->NextOfAE)));
}
@ -1364,7 +1364,7 @@ ShowAtoms()
AtomEntry *at;
at = RepAtom(HashPtr->Entry);
do {
fprintf(Yap_stderr,"Passei ao %s em %x\n", at->StrOfAE, at);
fprintf(GLOBAL_stderr,"Passei ao %s em %x\n", at->StrOfAE, at);
ShowEntries(RepProp(at->PropsOfAE));
} while (!EndOfPAEntr(at = RepAtom(at->NextOfAE)));
}
@ -1383,7 +1383,7 @@ commit_to_saved_state(char *s, CELL *Astate, CELL *ATrail, CELL *AStack, CELL *A
if ((mode = check_header(Astate,ATrail,AStack,AHeap PASS_REGS)) == FAIL_RESTORE)
return(FAIL_RESTORE);
Yap_PrologMode = BootMode;
LOCAL_PrologMode = BootMode;
if (Yap_HeapBase) {
extern void Scleanup(void);
if (!yap_flags[HALT_AFTER_CONSULT_FLAG] && !yap_flags[QUIET_MODE_FLAG]) {
@ -1397,7 +1397,7 @@ commit_to_saved_state(char *s, CELL *Astate, CELL *ATrail, CELL *AStack, CELL *A
/*
* This should be another file, like the log file
*/
errout = Yap_stderr;
errout = GLOBAL_stderr;
#endif
return mode;
}
@ -1448,7 +1448,7 @@ OpenRestore(char *inpf, char *YapLibDir, CELL *Astate, CELL *ATrail, CELL *AStac
if (inpf[0] != '/') {
#if __simplescalar__
/* does not implement getcwd */
strncpy(LOCAL_FileNameBuf,yap_pwd,YAP_FILENAME_MAX);
strncpy(LOCAL_FileNameBuf,GLOBAL_pwd,YAP_FILENAME_MAX);
#elif HAVE_GETCWD
if (getcwd (LOCAL_FileNameBuf, YAP_FILENAME_MAX) == NULL)
LOCAL_FileNameBuf[0] = '\0';
@ -1558,11 +1558,12 @@ OpenRestore(char *inpf, char *YapLibDir, CELL *Astate, CELL *ATrail, CELL *AStac
static void
CloseRestore(void)
{
CACHE_REGS
#ifdef DEBUG_RESTORE3
ShowAtoms();
#endif
close_file();
Yap_PrologMode = UserMode;
LOCAL_PrologMode = UserMode;
}
#if !defined(_WIN32)

4
C/scanner.c
View File

@ -1245,12 +1245,12 @@ Yap_tokenizer(IOSTREAM *inp_stream, Term *tposp)
default:
#ifdef DEBUG
fprintf(Yap_stderr, "\n++++ token: wrong char type %c %d\n", ch, chtype(ch));
fprintf(GLOBAL_stderr, "\n++++ token: wrong char type %c %d\n", ch, chtype(ch));
#endif
t->Tok = Ord(kind = eot_tok);
}
#ifdef DEBUG
if(Yap_Option[2]) fprintf(Yap_stderr,"[Token %d %ld]",Ord(kind),(unsigned long int)t->TokInfo);
if(GLOBAL_Option[2]) fprintf(GLOBAL_stderr,"[Token %d %ld]",Ord(kind),(unsigned long int)t->TokInfo);
#endif
if (LOCAL_ErrorMessage) {
/* insert an error token to inform the system of what happened */

38
C/stdpreds.c
View File

@ -3135,7 +3135,7 @@ p_debug( USES_REGS1 )
int i = IntOfTerm(Deref(ARG1));
if (i >= 'a' && i <= 'z')
Yap_Option[i - 96] = !Yap_Option[i - 96];
GLOBAL_Option[i - 96] = !GLOBAL_Option[i - 96];
return (1);
}
#endif
@ -3329,21 +3329,21 @@ Yap_show_statistics(void)
#endif
frag = (100.0*(heap_space_taken-HeapUsed))/heap_space_taken;
fprintf(Yap_stderr, "Code Space: %ld (%ld bytes needed, %ld bytes used, fragmentation %.3f%%).\n",
fprintf(GLOBAL_stderr, "Code Space: %ld (%ld bytes needed, %ld bytes used, fragmentation %.3f%%).\n",
(unsigned long int)(Unsigned (H0) - Unsigned (Yap_HeapBase)),
(unsigned long int)(Unsigned(HeapTop)-Unsigned(Yap_HeapBase)),
(unsigned long int)(HeapUsed),
frag);
fprintf(Yap_stderr, "Stack Space: %ld (%ld for Global, %ld for local).\n",
fprintf(GLOBAL_stderr, "Stack Space: %ld (%ld for Global, %ld for local).\n",
(unsigned long int)(sizeof(CELL)*(LCL0-H0)),
(unsigned long int)(sizeof(CELL)*(H-H0)),
(unsigned long int)(sizeof(CELL)*(LCL0-ASP)));
fprintf(Yap_stderr, "Trail Space: %ld (%ld used).\n",
fprintf(GLOBAL_stderr, "Trail Space: %ld (%ld used).\n",
(unsigned long int)(sizeof(tr_fr_ptr)*(Unsigned(LOCAL_TrailTop)-Unsigned(LOCAL_TrailBase))),
(unsigned long int)(sizeof(tr_fr_ptr)*(Unsigned(TR)-Unsigned(LOCAL_TrailBase))));
fprintf(Yap_stderr, "Runtime: %lds.\n", (unsigned long int)(runtime ( PASS_REGS1 )));
fprintf(Yap_stderr, "Cputime: %lds.\n", (unsigned long int)(Yap_cputime ()));
fprintf(Yap_stderr, "Walltime: %lds.\n", (unsigned long int)(Yap_walltime ()));
fprintf(GLOBAL_stderr, "Runtime: %lds.\n", (unsigned long int)(runtime ( PASS_REGS1 )));
fprintf(GLOBAL_stderr, "Cputime: %lds.\n", (unsigned long int)(Yap_cputime ()));
fprintf(GLOBAL_stderr, "Walltime: %lds.\n", (unsigned long int)(Yap_walltime ()));
}
static Int
@ -3623,8 +3623,8 @@ mk_argc_list( USES_REGS1 )
{
int i =0;
Term t = TermNil;
while (i < Yap_argc) {
char *arg = Yap_argv[i];
while (i < GLOBAL_argc) {
char *arg = GLOBAL_argv[i];
/* check for -L -- */
if (arg[0] == '-' && arg[1] == 'L') {
arg += 2;
@ -3633,15 +3633,15 @@ mk_argc_list( USES_REGS1 )
if (*arg == '-' && arg[1] == '-' && arg[2] == '\0') {
/* we found the separator */
int j;
for (j = Yap_argc-1; j > i+1; --j) {
t = MkPairTerm(MkAtomTerm(Yap_LookupAtom(Yap_argv[j])),t);
for (j = GLOBAL_argc-1; j > i+1; --j) {
t = MkPairTerm(MkAtomTerm(Yap_LookupAtom(GLOBAL_argv[j])),t);
}
return t;
} else if (Yap_argv[i+1] && Yap_argv[i+1][0] == '-' && Yap_argv[i+1][1] == '-' && Yap_argv[i+1][2] == '\0') {
} else if (GLOBAL_argv[i+1] && GLOBAL_argv[i+1][0] == '-' && GLOBAL_argv[i+1][1] == '-' && GLOBAL_argv[i+1][2] == '\0') {
/* we found the separator */
int j;
for (j = Yap_argc-1; j > i+2; --j) {
t = MkPairTerm(MkAtomTerm(Yap_LookupAtom(Yap_argv[j])),t);
for (j = GLOBAL_argc-1; j > i+2; --j) {
t = MkPairTerm(MkAtomTerm(Yap_LookupAtom(GLOBAL_argv[j])),t);
}
return t;
}
@ -3649,8 +3649,8 @@ mk_argc_list( USES_REGS1 )
if (arg[0] == '-' && arg[1] == '-' && arg[2] == '\0') {
/* we found the separator */
int j;
for (j = Yap_argc-1; j > i; --j) {
t = MkPairTerm(MkAtomTerm(Yap_LookupAtom(Yap_argv[j])),t);
for (j = GLOBAL_argc-1; j > i; --j) {
t = MkPairTerm(MkAtomTerm(Yap_LookupAtom(GLOBAL_argv[j])),t);
}
return(t);
}
@ -3670,7 +3670,7 @@ static Int
p_executable( USES_REGS1 )
{
Yap_TrueFileName (Yap_argv[0], LOCAL_FileNameBuf, FALSE);
Yap_TrueFileName (GLOBAL_argv[0], LOCAL_FileNameBuf, FALSE);
return Yap_unify(MkAtomTerm(Yap_LookupAtom(LOCAL_FileNameBuf)),ARG1);
}
@ -3904,9 +3904,9 @@ p_system_mode( USES_REGS1 )
{
Int i = IntegerOfTerm(Deref(ARG1));
if (i == 0)
Yap_PrologMode &= ~SystemMode;
LOCAL_PrologMode &= ~SystemMode;
else
Yap_PrologMode |= SystemMode;
LOCAL_PrologMode |= SystemMode;
return TRUE;
}

90
C/sysbits.c
View File

@ -88,7 +88,7 @@ static char SccsId[] = "%W% %G%";
#include <readline/readline.h>
#endif
STATIC_PROTO (void InitPageSize, (void));
STATIC_PROTO (void InitTime, (void));
STATIC_PROTO (void InitWTime, (void));
STATIC_PROTO (Int p_sh, ( USES_REGS1 ));
@ -107,9 +107,6 @@ STATIC_PROTO (int chdir, (char *));
/* #define signal skel_signal */
#endif /* MACYAP */
#if __simplescalar__
char yap_pwd[YAP_FILENAME_MAX];
#endif
STD_PROTO (void exit, (int));
@ -287,8 +284,8 @@ p_dir_sp ( USES_REGS1 )
}
static void
InitPageSize(void)
void
Yap_InitPageSize(void)
{
#ifdef _WIN32
SYSTEM_INFO si;
@ -1211,6 +1208,7 @@ HandleSIGSEGV(int sig, siginfo_t *sip, ucontext_t *uap)
static void
HandleMatherr(int sig, siginfo_t *sip, ucontext_t *uap)
{
CACHE_REGS
yap_error_number error_no;
/* reset the registers so that we don't have trash in abstract machine */
@ -1308,6 +1306,7 @@ STATIC_PROTO (void my_signal, (int, void (*)(int)));
static RETSIGTYPE
HandleMatherr(int sig)
{
CACHE_REGS
#if HAVE_FETESTEXCEPT
/* This should work in Linux, but it doesn't seem to. */
@ -1315,19 +1314,19 @@ HandleMatherr(int sig)
int raised = fetestexcept(FE_ALL_EXCEPT);
if (raised & FE_OVERFLOW) {
Yap_matherror = EVALUATION_ERROR_FLOAT_OVERFLOW;
LOCAL_matherror = EVALUATION_ERROR_FLOAT_OVERFLOW;
} else if (raised & (FE_INVALID|FE_INEXACT)) {
Yap_matherror = EVALUATION_ERROR_UNDEFINED;
LOCAL_matherror = EVALUATION_ERROR_UNDEFINED;
} else if (raised & FE_DIVBYZERO) {
Yap_matherror = EVALUATION_ERROR_ZERO_DIVISOR;
LOCAL_matherror = EVALUATION_ERROR_ZERO_DIVISOR;
} else if (raised & FE_UNDERFLOW) {
Yap_matherror = EVALUATION_ERROR_FLOAT_UNDERFLOW;
LOCAL_matherror = EVALUATION_ERROR_FLOAT_UNDERFLOW;
} else
#endif
Yap_matherror = EVALUATION_ERROR_UNDEFINED;
LOCAL_matherror = EVALUATION_ERROR_UNDEFINED;
/* something very bad happened on the way to the forum */
set_fpu_exceptions(FALSE);
Yap_Error(Yap_matherror, TermNil, "");
Yap_Error(LOCAL_matherror , TermNil, "");
}
#if HAVE_SIGSEGV && !defined(THREADS)
@ -1376,7 +1375,7 @@ SearchForTrailFault(siginfo_t *siginfo)
static RETSIGTYPE
HandleSIGSEGV(int sig, siginfo_t *siginfo, void *context)
{
if (Yap_PrologMode & ExtendStackMode) {
if (LOCAL_PrologMode & ExtendStackMode) {
Yap_Error(FATAL_ERROR, TermNil, "OS memory allocation crashed at address %p, bailing out\n",LOCAL_TrailTop);
}
SearchForTrailFault(siginfo);
@ -1445,19 +1444,19 @@ HandleMatherr(int sig)
int raised = fetestexcept(FE_ALL_EXCEPT);
if (raised & FE_OVERFLOW) {
Yap_matherror = EVALUATION_ERROR_FLOAT_OVERFLOW;
LOCAL_matherror = EVALUATION_ERROR_FLOAT_OVERFLOW;
} else if (raised & (FE_INVALID|FE_INEXACT)) {
Yap_matherror = EVALUATION_ERROR_UNDEFINED;
LOCAL_matherror = EVALUATION_ERROR_UNDEFINED;
} else if (raised & FE_DIVBYZERO) {
Yap_matherror = EVALUATION_ERROR_ZERO_DIVISOR;
LOCAL_matherror = EVALUATION_ERROR_ZERO_DIVISOR;
} else if (raised & FE_UNDERFLOW) {
Yap_matherror = EVALUATION_ERROR_FLOAT_UNDERFLOW;
LOCAL_matherror = EVALUATION_ERROR_FLOAT_UNDERFLOW;
} else
#endif
Yap_matherror = EVALUATION_ERROR_UNDEFINED;
LOCAL_matherror = EVALUATION_ERROR_UNDEFINED;
/* something very bad happened on the way to the forum */
set_fpu_exceptions(FALSE);
Yap_Error(Yap_matherror, TermNil, "");
Yap_Error(LOCAL_matherror , TermNil, "");
}
static void
@ -1493,7 +1492,7 @@ SearchForTrailFault(void)
static RETSIGTYPE
HandleSIGSEGV(int sig)
{
if (Yap_PrologMode & ExtendStackMode) {
if (LOCAL_PrologMode & ExtendStackMode) {
CACHE_REGS
Yap_Error(FATAL_ERROR, TermNil, "OS memory allocation crashed at address %p, bailing out\n",LOCAL_TrailTop);
}
@ -1554,71 +1553,71 @@ void (*handler)(int);
static int
InteractSIGINT(int ch) {
CACHE_REGS
Yap_PrologMode |= AsyncIntMode;
LOCAL_PrologMode |= AsyncIntMode;
switch (ch) {
case 'a':
/* abort computation */
if (Yap_PrologMode & (GCMode|ConsoleGetcMode|GrowStackMode|GrowHeapMode)) {
Yap_PrologMode |= AbortMode;
if (LOCAL_PrologMode & (GCMode|ConsoleGetcMode|GrowStackMode|GrowHeapMode)) {
LOCAL_PrologMode |= AbortMode;
} else {
Yap_Error(PURE_ABORT, TermNil, "abort from console");
/* in case someone mangles the P register */
}
Yap_PrologMode &= ~AsyncIntMode;
LOCAL_PrologMode &= ~AsyncIntMode;
siglongjmp(LOCAL_RestartEnv,1);
return -1;
case 'b':
/* continue */
Yap_signal (YAP_BREAK_SIGNAL);
Yap_PrologMode &= ~AsyncIntMode;
LOCAL_PrologMode &= ~AsyncIntMode;
return 1;
case 'c':
/* continue */
return 1;
case 'd':
Yap_signal (YAP_DEBUG_SIGNAL);
Yap_PrologMode &= ~AsyncIntMode;
LOCAL_PrologMode &= ~AsyncIntMode;
/* enter debug mode */
return 1;
case 'e':
/* exit */
Yap_PrologMode &= ~AsyncIntMode;
LOCAL_PrologMode &= ~AsyncIntMode;
Yap_exit(0);
return -1;
case 'g':
/* exit */
Yap_signal (YAP_STACK_DUMP_SIGNAL);
Yap_PrologMode &= ~AsyncIntMode;
LOCAL_PrologMode &= ~AsyncIntMode;
return -1;
case 't':
/* start tracing */
Yap_signal (YAP_TRACE_SIGNAL);
Yap_PrologMode &= ~AsyncIntMode;
LOCAL_PrologMode &= ~AsyncIntMode;
return 1;
#ifdef LOW_LEVEL_TRACER
case 'T':
toggle_low_level_trace();
Yap_PrologMode &= ~AsyncIntMode;
LOCAL_PrologMode &= ~AsyncIntMode;
return 1;
#endif
case 's':
/* show some statistics */
Yap_signal (YAP_STATISTICS_SIGNAL);
Yap_PrologMode &= ~AsyncIntMode;
LOCAL_PrologMode &= ~AsyncIntMode;
return 1;
case EOF:
Yap_PrologMode &= ~AsyncIntMode;
LOCAL_PrologMode &= ~AsyncIntMode;
return(0);
break;
case 'h':
case '?':
default:
/* show an helpful message */
fprintf(Yap_stderr, "Please press one of:\n");
fprintf(Yap_stderr, " a for abort\n c for continue\n d for debug\n");
fprintf(Yap_stderr, " e for exit\n g for stack dump\n s for statistics\n t for trace\n");
fprintf(Yap_stderr, " b for break\n");
Yap_PrologMode &= ~AsyncIntMode;
fprintf(GLOBAL_stderr, "Please press one of:\n");
fprintf(GLOBAL_stderr, " a for abort\n c for continue\n d for debug\n");
fprintf(GLOBAL_stderr, " e for exit\n g for stack dump\n s for statistics\n t for trace\n");
fprintf(GLOBAL_stderr, " b for break\n");
LOCAL_PrologMode &= ~AsyncIntMode;
return(0);
}
}
@ -1666,7 +1665,7 @@ HandleSIGINT (int sig)
my_signal(SIGINT, HandleSIGINT);
/* do this before we act */
#if HAVE_ISATTY
if (!isatty(0) && !Yap_sockets_io) {
if (!isatty(0)) {
Yap_Error(INTERRUPT_ERROR,MkIntTerm(SIGINT),NULL);
return;
}
@ -1674,8 +1673,8 @@ HandleSIGINT (int sig)
if (LOCAL_InterruptsDisabled) {
return;
}
if (Yap_PrologMode & (CritMode|ConsoleGetcMode)) {
Yap_PrologMode |= InterruptMode;
if (LOCAL_PrologMode & (CritMode|ConsoleGetcMode)) {
LOCAL_PrologMode |= InterruptMode;
}
#ifdef HAVE_SETBUF
/* make sure we are not waiting for the end of line */
@ -1777,7 +1776,7 @@ ReceiveSignal (int s)
break;
#endif /* defined(SIGHUP) */
default:
fprintf(Yap_stderr, "\n[ Unexpected signal ]\n");
fprintf(GLOBAL_stderr, "\n[ Unexpected signal ]\n");
exit (EXIT_FAILURE);
}
}
@ -1793,7 +1792,7 @@ MSCHandleSignal(DWORD dwCtrlType) {
case CTRL_C_EVENT:
case CTRL_BREAK_EVENT:
Yap_signal(YAP_ALARM_SIGNAL);
Yap_PrologMode |= InterruptMode;
LOCAL_PrologMode |= InterruptMode;
return(TRUE);
default:
return(FALSE);
@ -1805,7 +1804,7 @@ MSCHandleSignal(DWORD dwCtrlType) {
static void
InitSignals (void)
{
if (Yap_PrologShouldHandleInterrupts) {
if (GLOBAL_PrologShouldHandleInterrupts) {
#if !defined(LIGHT) && !_MSC_VER && !defined(__MINGW32__) && !defined(LIGHT)
my_signal (SIGQUIT, ReceiveSignal);
my_signal (SIGKILL, ReceiveSignal);
@ -1878,7 +1877,7 @@ int Yap_getcwd(const char *buf, int len)
CACHE_REGS
#if __simplescalar__
/* does not implement getcwd */
strncpy(Yap_buf,yap_pwd,len);
strncpy(Yap_buf,GLOBAL_pwd,len);
#elif HAVE_GETCWD
if (getcwd ((char *)buf, len) == NULL) {
#if HAVE_STRERROR
@ -2730,10 +2729,9 @@ Yap_InitSysbits (void)
#if __simplescalar__
{
char *pwd = getenv("PWD");
strncpy(yap_pwd,pwd,YAP_FILENAME_MAX);
strncpy(GLOBAL_pwd,pwd,YAP_FILENAME_MAX);
}
#endif
InitPageSize();
InitWTime ();
InitRandom ();
/* let the caller control signals as it sees fit */

4
C/threads.c
View File

@ -405,7 +405,7 @@ Yap_thread_create_engine(thread_attr *ops)
ops->sysize = 0;
ops->egoal = t;
}
if (pthread_self() != Yap_master_thread) {
if (pthread_self() != GLOBAL_master_thread) {
/* we are worker_id 0 for now, lock master thread so that no one messes with us */
pthread_setspecific(Yap_yaamregs_key, (const void *)&Yap_standard_regs);
pthread_mutex_lock(&(REMOTE_ThreadHandle(0).tlock));
@ -416,7 +416,7 @@ Yap_thread_create_engine(thread_attr *ops)
REMOTE_ThreadHandle(new_id).id = new_id;
REMOTE_ThreadHandle(new_id).ref_count = 0;
setup_engine(new_id, FALSE);
if (pthread_self() != Yap_master_thread) {
if (pthread_self() != GLOBAL_master_thread) {
pthread_setspecific(Yap_yaamregs_key, NULL);
pthread_mutex_unlock(&(REMOTE_ThreadHandle(0).tlock));
}

28
C/tracer.c
View File

@ -28,12 +28,12 @@
STATIC_PROTO(int TracePutchar, (int, int));
STATIC_PROTO(void send_tracer_message, (char *, char *, Int, char *, CELL *));
static int do_trace_primitives = TRUE;
static int
TracePutchar(int sno, int ch)
{
return(putc(ch, Yap_stderr)); /* use standard error stream, which is supposed to be 2*/
return(putc(ch, GLOBAL_stderr)); /* use standard error stream, which is supposed to be 2*/
}
static void
@ -42,24 +42,24 @@ send_tracer_message(char *start, char *name, Int arity, char *mname, CELL *args)
CACHE_REGS
if (name == NULL) {
#ifdef YAPOR
fprintf(Yap_stderr, "(%d)%s", worker_id, start);
fprintf(GLOBAL_stderr, "(%d)%s", worker_id, start);
#else
fprintf(Yap_stderr, "%s", start);
fprintf(GLOBAL_stderr, "%s", start);
#endif
} else {
int i;
if (arity) {
if (args)
fprintf(Yap_stderr, "%s %s:%s(", start, mname, name);
fprintf(GLOBAL_stderr, "%s %s:%s(", start, mname, name);
else
fprintf(Yap_stderr, "%s %s:%s/%lu", start, mname, name, (unsigned long int)arity);
fprintf(GLOBAL_stderr, "%s %s:%s/%lu", start, mname, name, (unsigned long int)arity);
} else {
fprintf(Yap_stderr, "%s %s:%s", start, mname, name);
fprintf(GLOBAL_stderr, "%s %s:%s", start, mname, name);
}
if (args) {
for (i= 0; i < arity; i++) {
if (i > 0) fprintf(Yap_stderr, ",");
if (i > 0) fprintf(GLOBAL_stderr, ",");
#if DEBUG
#if COROUTINING
Yap_Portray_delays = TRUE;
@ -73,11 +73,11 @@ send_tracer_message(char *start, char *name, Int arity, char *mname, CELL *args)
#endif
}
if (arity) {
fprintf(Yap_stderr, ")");
fprintf(GLOBAL_stderr, ")");
}
}
}
fprintf(Yap_stderr, "\n");
fprintf(GLOBAL_stderr, "\n");
}
#if defined(__GNUC__)
@ -293,16 +293,16 @@ low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args)
printf("\n");
}
#endif
fprintf(Yap_stderr,"%lld ",vsc_count);
fprintf(GLOBAL_stderr,"%lld ",vsc_count);
#if defined(THREADS) || defined(YAPOR)
fprintf(Yap_stderr,"(%d)", worker_id);
fprintf(GLOBAL_stderr,"(%d)", worker_id);
#endif
/* check_trail_consistency(); */
if (pred == NULL) {
UNLOCK(Yap_heap_regs->low_level_trace_lock);
return;
}
if (pred->ModuleOfPred == 0 && !do_trace_primitives) {
if (pred->ModuleOfPred == 0 && !LOCAL_do_trace_primitives) {
UNLOCK(Yap_heap_regs->low_level_trace_lock);
return;
}
@ -425,7 +425,7 @@ static Int p_start_low_level_trace2( USES_REGS1 )
static Int p_stop_low_level_trace( USES_REGS1 )
{
Yap_do_low_level_trace = FALSE;
do_trace_primitives = TRUE;
LOCAL_do_trace_primitives = TRUE;
return(TRUE);
}

4
C/utilpreds.c
View File

@ -244,7 +244,7 @@ copy_complex_term(CELL *pt0, CELL *pt0_end, int share, int newattvs, CELL *ptf,
CELL new;
bp = to_visit;
if (!attas[ExtFromCell(ptd0)].copy_term_op(ptd0, &bp, ptf PASS_REGS)) {
if (!GLOBAL_attas[ExtFromCell(ptd0)].copy_term_op(ptd0, &bp, ptf PASS_REGS)) {
goto overflow;
}
to_visit = bp;
@ -1400,7 +1400,7 @@ export_complex_term(Term tf, CELL *pt0, CELL *pt0_end, char * buf, size_t len0,
CELL new;
bp = to_visit;
if (!attas[ExtFromCell(ptd0)].copy_term_op(ptd0, &bp, ptf PASS_REGS)) {
if (!GLOBAL_attas[ExtFromCell(ptd0)].copy_term_op(ptd0, &bp, ptf PASS_REGS)) {
goto overflow;
}
to_visit = bp;

1
H/Regs.h
View File

@ -208,7 +208,6 @@ extern REGSTORE Yap_REGS;
#define MinTrailGap (sizeof(CELL)*1024)
#define MinHeapGap (sizeof(CELL)*4096)
#define MinStackGap (sizeof(CELL)*8*1024)
extern int Yap_stack_overflows;
#define ENV Yap_REGS.ENV_ /* current environment */

3
H/TermExt.h
View File

@ -136,8 +136,7 @@ typedef enum
exts;
/* array with the ops for your favourite extensions */
extern ext_op attas[attvars_ext + 1];
#endif

211
H/Yap.h
View File

@ -109,8 +109,8 @@
#ifdef __MINGW32__
#ifndef _WIN32
#define _WIN32 1
#endif
#endif
#endif /* _WIN32 */
#endif /* __MINGW32__ */
#if HAVE_GCC
#define MIN_ARRAY 0
@ -118,13 +118,13 @@
#else
#define MIN_ARRAY 1
#define DUMMY_FILLER_FOR_ABS_TYPE int dummy;
#endif
#endif /* HAVE_GCC */
#ifndef ADTDEFS_C
#define EXTERN static
#else
#define EXTERN
#endif
#endif /* ADTDEFS_C */
/* truth-values */
#define TRUE 1
@ -144,10 +144,10 @@
#if USE_PTHREAD_LOCKING
#ifndef _XOPEN_SOURCE
#define _XOPEN_SOURCE 600
#endif
#endif
#endif /* !_XOPEN_SOURCE */
#endif /* USE_PTHREAD_LOCKING */
#include <pthread.h>
#endif
#endif /* THREADS */
#if SIZEOF_INT_P==4
@ -242,16 +242,13 @@ typedef unsigned long int YAP_ULONG_LONG;
#define LOW_PROF 1
#endif
#ifdef DEBUG
extern char Yap_Option[20];
#endif
/* #define FORCE_SECOND_QUADRANT 1 */
#if defined(FORCE_SECOND_QUADRANT)
#define IN_SECOND_QUADRANT 1
#define MMAP_ADDR 0x42000000
#endif
#endif /* FORCE_SECOND_QUADRANT */
#if !defined(IN_SECOND_QUADRANT)
#if defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(mips) || defined(__APPLE__) || defined(__DragonFly__)
@ -269,10 +266,10 @@ extern char Yap_Option[20];
#define MMAP_ADDR 0x20000000
#else
#define MMAP_ADDR 0x10000000
#endif
#endif /* YAPOR && __alpha */
#elif __svr4__ || defined(__SVR4)
#define MMAP_ADDR 0x02000000
#endif
#endif /* __linux__ || __FreeBSD__ || __NetBSD__ || mips || __APPLE__ || __DragonFly__ */
#endif /* !IN_SECOND_QUADRANT */
/* #define RANDOMIZE_START_ADDRESS 1 */
@ -280,15 +277,15 @@ extern char Yap_Option[20];
#ifdef USE_SYSTEM_MALLOC
#define HEAP_INIT_BASE 0L
#define AtomBase NULL
#else
#else /* !USE_SYSTEM_MALLOC */
#if defined(MMAP_ADDR) && (defined(USE_MMAP) || USE_SHMAT) && !defined(__simplescalar__) && !defined(RANDOMIZE_START_ADDRESS)
#define HEAP_INIT_BASE (MMAP_ADDR)
#define AtomBase ((char *)MMAP_ADDR)
#else
#else /*! (MMAP_ADDR && (USE_MMAP || USE_SHMAT) && !__simplescalar__ && !RANDOMIZE_START_ADDRESS) */
#define HEAP_INIT_BASE ((CELL)Yap_HeapBase)
#define AtomBase (Yap_HeapBase)
#endif
#endif
#endif /* MMAP_ADDR && (USE_MMAP || USE_SHMAT) && !__simplescalar__ && !RANDOMIZE_START_ADDRESS */
#endif /* USE_SYSTEM_MALLOC */
@ -308,7 +305,9 @@ extern char Yap_Option[20];
#define M1 ((CELL)(1024*1024))
#define M2 ((CELL)(2048*1024))
/* basic data types */
/*************************************************************************************************
basic data types
*************************************************************************************************/
typedef UInt CELL;
typedef UShort BITS16;
@ -329,7 +328,9 @@ typedef unsigned char *CODEADDR;
#define CellSize sizeof(CELL)
#define SmallSize sizeof(SMALLUNSGN)
/* type casting macros */
/*************************************************************************************************
type casting macros
*************************************************************************************************/
#define Addr(V) ((ADDR) (V))
#define Unsigned(V) ((CELL) (V))
@ -344,7 +345,9 @@ typedef unsigned char *CODEADDR;
#define DisplPtr(V) ((DISPREG *)(V))
#define TermPtr(V) ((Term *) (V))
/* Abstract Type Definitions for YAPProlog */
/*************************************************************************************************
Abstract Type Definitions for YAPProlog
*************************************************************************************************/
typedef CELL Term;
@ -383,7 +386,9 @@ typedef pthread_rwlock_t rwlock_t;
#include <locks_pthread.h>
#endif
/********************** use an auxiliary function for ranges ************/
/*************************************************************************************************
use an auxiliary function for ranges
*************************************************************************************************/
#ifdef __GNUC__
#define IN_BETWEEN(MIN,X,MAX) (Unsigned((Int)(X)-(Int)(MIN)) <= \
@ -397,19 +402,25 @@ typedef pthread_rwlock_t rwlock_t;
#define OUTSIDE(MIN,X,MAX) ((void *)(X) < (void *)(MIN) || (void *)(X) > (void *)(MAX))
#endif
/* ************************* Atoms *************************************/
/*************************************************************************************************
Atoms
*************************************************************************************************/
#include "Atoms.h"
/* ************************* Coroutining **********************************/
/*************************************************************************************************
Coroutining
*************************************************************************************************/
#ifdef COROUTINING
/* Support for co-routining */
#include "corout.h"
#endif
/********* abstract machine registers **********************************/
/*************************************************************************************************
abstract machine registers
*************************************************************************************************/
#include "amidefs.h"
@ -424,7 +435,9 @@ typedef pthread_rwlock_t rwlock_t;
#endif
#endif
/************ variables concerned with Error Handling *************/
/*************************************************************************************************
variables concerned with Error Handling
*************************************************************************************************/
#include <setjmp.h>
@ -437,7 +450,6 @@ typedef pthread_rwlock_t rwlock_t;
/* Support for arrays */
#include "arrays.h"
/************ variables concerned with Error Handling *************/
/* Types of Errors */
typedef enum
@ -615,7 +627,9 @@ typedef enum
#define NUMBER_OF_YAP_FLAGS LAST_FLAG
/************************ prototypes **********************************/
/*************************************************************************************************
prototypes
*************************************************************************************************/
#include "Yapproto.h"
@ -733,7 +747,9 @@ typedef enum
#define TermSize sizeof(Term)
/************* variables related to memory allocation *******************/
/*************************************************************************************************
variables related to memory allocation
*************************************************************************************************/
/* must be before TermExt.h */
extern ADDR Yap_HeapBase;
@ -743,22 +759,17 @@ extern ADDR Yap_HeapBase;
#define MAX_ERROR_MSG_SIZE YAP_FILENAME_MAX
#ifdef THREADS
/* This is the guy who actually started the system, and who has the correct registers */
extern pthread_t Yap_master_thread;
#endif /* THREADS */
#ifdef DEBUG
/************** Debugging Support ***************************/
extern int Yap_output_msg;
#endif
/********** ??? ***********/
/*************************************************************************************************
???
*************************************************************************************************/
#define MkVarTerm() MkVarTerm__( PASS_REGS1 )
#define MkPairTerm(A,B) MkPairTerm__( A, B PASS_REGS )
/* applies to unbound variables */
/*************************************************************************************************
applies to unbound variables
*************************************************************************************************/
inline EXTERN Term *VarOfTerm (Term t);
@ -1002,8 +1013,10 @@ IntegerOfTerm (Term t)
/*************************************************************************************************
variables concerned with atoms table
*************************************************************************************************/
/*************** variables concerned with atoms table *******************/
#define MaxHash 3333
#define MaxWideHash (MaxHash/10+1)
@ -1011,14 +1024,17 @@ IntegerOfTerm (Term t)
#define DO_EVERYTHING 1
#define DO_ONLY_CODE 2
/********* common instructions codes*************************/
/*************************************************************************************************
common instructions codes
*************************************************************************************************/
#define MAX_PROMPT 256
#if USE_THREADED_CODE
/************ reverse lookup of instructions *****************/
/*************************************************************************************************
reverse lookup of instructions
*************************************************************************************************/
typedef struct opcode_tab_entry
{
OPCODE opc;
@ -1027,9 +1043,9 @@ typedef struct opcode_tab_entry
#endif
/********* Prolog may be in several modes *******************************/
/*************************************************************************************************
Prolog may be in several modes
*************************************************************************************************/
typedef enum
{
@ -1054,29 +1070,13 @@ typedef enum
InReadlineMode = 0x40000 /* YAP has just been interrupted from the outside */
} prolog_exec_mode;
extern Int Yap_PrologMode;
extern int Yap_CritLocks;
/*************************************************************************************************
Access to yap initial arguments
number of modules
*************************************************************************************************/
extern char **Yap_argv;
extern int Yap_argc;
/*************************************************************************************************
whether Yap is responsible for signal handling
*************************************************************************************************/
extern int Yap_PrologShouldHandleInterrupts;
/******************* number of modules ****************************/
#define DefaultMaxModules 256
/*************************************************************************************************
Critical sections
*************************************************************************************************/
@ -1087,20 +1087,20 @@ extern int Yap_PrologShouldHandleInterrupts;
LOCK(GLOBAL_locks_heap_access); \
GLOBAL_locks_who_locked_heap = worker_id; \
} \
Yap_PrologMode |= CritMode; \
Yap_CritLocks++; \
LOCAL_PrologMode |= CritMode; \
LOCAL_CritLocks++; \
}
#define YAPLeaveCriticalSection() \
{ \
Yap_CritLocks--; \
if (!Yap_CritLocks) { \
Yap_PrologMode &= ~CritMode; \
if (Yap_PrologMode & InterruptMode) { \
Yap_PrologMode &= ~InterruptMode; \
LOCAL_CritLocks--; \
if (!LOCAL_CritLocks) { \
LOCAL_PrologMode &= ~CritMode; \
if (LOCAL_PrologMode & InterruptMode) { \
LOCAL_PrologMode &= ~InterruptMode; \
Yap_ProcessSIGINT(); \
} \
if (Yap_PrologMode & AbortMode) { \
Yap_PrologMode &= ~AbortMode; \
if (LOCAL_PrologMode & AbortMode) { \
LOCAL_PrologMode &= ~AbortMode; \
Yap_Error(PURE_ABORT, 0, ""); \
} \
GLOBAL_locks_who_locked_heap = MAX_WORKERS; \
@ -1111,17 +1111,17 @@ extern int Yap_PrologShouldHandleInterrupts;
#define YAPEnterCriticalSection() \
{ \
/* LOCK(BGL); */ \
Yap_PrologMode |= CritMode; \
LOCAL_PrologMode |= CritMode; \
}
#define YAPLeaveCriticalSection() \
{ \
Yap_PrologMode &= ~CritMode; \
if (Yap_PrologMode & InterruptMode) { \
Yap_PrologMode &= ~InterruptMode; \
LOCAL_PrologMode &= ~CritMode; \
if (LOCAL_PrologMode & InterruptMode) { \
LOCAL_PrologMode &= ~InterruptMode; \
Yap_ProcessSIGINT(); \
} \
if (Yap_PrologMode & AbortMode) { \
Yap_PrologMode &= ~AbortMode; \
if (LOCAL_PrologMode & AbortMode) { \
LOCAL_PrologMode &= ~AbortMode; \
Yap_Error(PURE_ABORT, 0, ""); \
} \
/* UNLOCK(BGL); */ \
@ -1129,20 +1129,20 @@ extern int Yap_PrologShouldHandleInterrupts;
#else
#define YAPEnterCriticalSection() \
{ \
Yap_PrologMode |= CritMode; \
Yap_CritLocks++; \
LOCAL_PrologMode |= CritMode; \
LOCAL_CritLocks++; \
}
#define YAPLeaveCriticalSection() \
{ \
Yap_CritLocks--; \
if (!Yap_CritLocks) { \
Yap_PrologMode &= ~CritMode; \
if (Yap_PrologMode & InterruptMode) { \
Yap_PrologMode &= ~InterruptMode; \
LOCAL_CritLocks--; \
if (!LOCAL_CritLocks) { \
LOCAL_PrologMode &= ~CritMode; \
if (LOCAL_PrologMode & InterruptMode) { \
LOCAL_PrologMode &= ~InterruptMode; \
Yap_ProcessSIGINT(); \
} \
if (Yap_PrologMode & AbortMode) { \
Yap_PrologMode &= ~AbortMode; \
if (LOCAL_PrologMode & AbortMode) { \
LOCAL_PrologMode &= ~AbortMode; \
Yap_Error(PURE_ABORT, 0, ""); \
} \
} \
@ -1153,7 +1153,10 @@ extern int Yap_PrologShouldHandleInterrupts;
#define AT_BOOT 0
#define AT_RESTORE 1
/********* mutable variables ******************/
/*************************************************************************************************
mutable variables
*************************************************************************************************/
/* I assume that the size of this structure is a multiple of the size
of CELL!!! */
@ -1164,7 +1167,9 @@ typedef struct TIMED_MAVAR
} timed_var;
/********* execution mode ***********************/
/*************************************************************************************************
execution mode
*************************************************************************************************/
typedef enum
{
@ -1175,7 +1180,10 @@ typedef enum
COMPILE_ALL /* compile all predicates */
} yap_exec_mode;
/********* slots ***********************/
/*************************************************************************************************
slots
*************************************************************************************************/
static inline void
@ -1257,7 +1265,9 @@ typedef struct scratch_block_struct {
/* scanner types */
#include "ScannerTypes.h"
/******************** OPTYAP includes ********************/
/*************************************************************************************************
OPTYAP includes
*************************************************************************************************/
#if defined(YAPOR) || defined(TABLING)
#include "opt.structs.h"
@ -1269,7 +1279,10 @@ typedef struct scratch_block_struct {
#include "or.sba_unify.h"
#endif /* YAPOR_SBA */
/******************** GLOBAL and LOCAL variables ********************/
/*************************************************************************************************
GLOBAL and LOCAL variables
*************************************************************************************************/
#if defined(YAPOR_COPY) || defined(YAPOR_COW) || defined(YAPOR_SBA)
extern struct global_data *Yap_global;
@ -1290,12 +1303,16 @@ extern struct worker_local Yap_local;
#define REMOTE(wid) (&Yap_local)
#endif
#define YP_FILE FILE
#include "hglobals.h"
#include "dglobals.h"
#include "hlocals.h"
#include "dlocals.h"
/*************** unification routines ***********************************/
/*************************************************************************************************
unification routines
*************************************************************************************************/
#ifdef YAPOR_SBA
#include "or.sba_amiops.h"
@ -1303,7 +1320,11 @@ extern struct worker_local Yap_local;
#include "amiops.h"
#endif /* YAPOR_SBA */
/*************** High level macros to access arguments ******************/
/*************************************************************************************************
High level macros to access arguments
*************************************************************************************************/
inline EXTERN Term ArgOfTerm (int i, Term t);

1
H/Yapproto.h
View File

@ -328,6 +328,7 @@ void STD_PROTO(Yap_undo_signal,(yap_signals));
int STD_PROTO(Yap_IsOpMaxPrio,(Atom));
/* sysbits.c */
void STD_PROTO(Yap_InitPageSize, (void));
void STD_PROTO(Yap_set_fpu_exceptions,(int));
UInt STD_PROTO(Yap_cputime,(void));
Int STD_PROTO(Yap_walltime,(void));

6
H/amidefs.h
View File

@ -1095,12 +1095,8 @@ extern void **Yap_ABSMI_OPCODES;
#define absmadr(i) ((OPCODE)(i))
#endif
/* used to find out how many instructions of each kind are executed */
#ifdef ANALYST
extern YAP_ULONG_LONG Yap_opcount[_std_top + 1];
extern YAP_ULONG_LONG Yap_2opcount[_std_top + 1][_std_top + 1];
#endif /* ANALYST */
#if DEPTH_LIMIT
/*

55
H/dglobals.h
View File

@ -53,3 +53,58 @@
#define GLOBAL_optyap_data Yap_global->optyap_data_
#endif /* YAPOR || TABLING */
#define GLOBAL_PrologShouldHandleInterrupts Yap_global->PrologShouldHandleInterrupts_
#if defined(THREADS)
#define GLOBAL_master_thread Yap_global->master_thread_
#endif /* THREADS */
#define GLOBAL_stdout Yap_global->stdout_
#define GLOBAL_stderr Yap_global->stderr_
#define GLOBAL_argv Yap_global->argv_
#define GLOBAL_argc Yap_global->argc_
#ifdef COROUTINING
#define GLOBAL_attas Yap_global->attas_
#endif
#define GLOBAL_agc_calls Yap_global->agc_calls_
#define GLOBAL_agc_collected Yap_global->agc_collected_
#define GLOBAL_tot_agc_time Yap_global->tot_agc_time_
#define GLOBAL_tot_agc_recovered Yap_global->tot_agc_recovered_
#if HAVE_MMAP
#define GLOBAL_mmap_arrays Yap_global->mmap_arrays_
#endif
#ifdef DEBUG
#define GLOBAL_Option Yap_global->Option_
#define GLOBAL_logfile Yap_global->logfile_
#define GLOBAL_output_msg Yap_global->output_msg_
#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)
#define GLOBAL_Executable Yap_global->Executable_
#endif
#if __simplescalar__
#define GLOBAL_pwd Yap_global->pwd_
#endif

50
H/dlocals.h
View File

@ -267,3 +267,53 @@
#define LOCAL_FileNameBuf2 LOCAL->FileNameBuf2_
#define REMOTE_FileNameBuf2(wid) REMOTE(wid)->FileNameBuf2_
#define LOCAL_PrologMode LOCAL->PrologMode_
#define REMOTE_PrologMode(wid) REMOTE(wid)->PrologMode_
#define LOCAL_CritLocks LOCAL->CritLocks_
#define REMOTE_CritLocks(wid) REMOTE(wid)->CritLocks_
#ifdef ANALYST
#define LOCAL_opcount LOCAL->opcount_
#define REMOTE_opcount(wid) REMOTE(wid)->opcount_
#define LOCAL_2opcount LOCAL->2opcount_
#define REMOTE_2opcount(wid) REMOTE(wid)->2opcount_
#endif /* ANALYST */
#define LOCAL_s_dbg LOCAL->s_dbg_
#define REMOTE_s_dbg(wid) REMOTE(wid)->s_dbg_
#define LOCAL_matherror LOCAL->matherror_
#define REMOTE_matherror(wid) REMOTE(wid)->matherror_
#define LOCAL_heap_overflows LOCAL->heap_overflows_
#define REMOTE_heap_overflows(wid) REMOTE(wid)->heap_overflows_
#define LOCAL_total_heap_overflow_time LOCAL->total_heap_overflow_time_
#define REMOTE_total_heap_overflow_time(wid) REMOTE(wid)->total_heap_overflow_time_
#define LOCAL_stack_overflows LOCAL->stack_overflows_
#define REMOTE_stack_overflows(wid) REMOTE(wid)->stack_overflows_
#define LOCAL_total_stack_overflow_time LOCAL->total_stack_overflow_time_
#define REMOTE_total_stack_overflow_time(wid) REMOTE(wid)->total_stack_overflow_time_
#define LOCAL_delay_overflows LOCAL->delay_overflows_
#define REMOTE_delay_overflows(wid) REMOTE(wid)->delay_overflows_
#define LOCAL_total_delay_overflow_time LOCAL->total_delay_overflow_time_
#define REMOTE_total_delay_overflow_time(wid) REMOTE(wid)->total_delay_overflow_time_
#define LOCAL_trail_overflows LOCAL->trail_overflows_
#define REMOTE_trail_overflows(wid) REMOTE(wid)->trail_overflows_
#define LOCAL_total_trail_overflow_time LOCAL->total_trail_overflow_time_
#define REMOTE_total_trail_overflow_time(wid) REMOTE(wid)->total_trail_overflow_time_
#define LOCAL_atom_table_overflows LOCAL->atom_table_overflows_
#define REMOTE_atom_table_overflows(wid) REMOTE(wid)->atom_table_overflows_
#define LOCAL_total_atom_table_overflow_time LOCAL->total_atom_table_overflow_time_
#define REMOTE_total_atom_table_overflow_time(wid) REMOTE(wid)->total_atom_table_overflow_time_
#ifdef LOAD_DYLD
#define LOCAL_dl_errno LOCAL->dl_errno_
#define REMOTE_dl_errno(wid) REMOTE(wid)->dl_errno_
#endif
#ifdef LOW_LEVEL_TRACER
#define LOCAL_do_trace_primitives LOCAL->do_trace_primitives_
#define REMOTE_do_trace_primitives(wid) REMOTE(wid)->do_trace_primitives_
#endif

2
H/eval.h
View File

@ -161,8 +161,6 @@ Functor STD_PROTO(EvalArg,(Term));
#define FL(X) ((double)(X))
#endif
extern yap_error_number Yap_matherror;
void STD_PROTO(Yap_InitConstExps,(void));
void STD_PROTO(Yap_InitUnaryExps,(void));
void STD_PROTO(Yap_InitBinaryExps,(void));

55
H/hglobals.h
View File

@ -52,4 +52,59 @@ typedef struct global_data {
#if defined(YAPOR) || defined(TABLING)
struct global_optyap_data optyap_data_;
#endif /* YAPOR || TABLING */
int PrologShouldHandleInterrupts_;
#if defined(THREADS)
pthread_t master_thread_;
#endif /* THREADS */
YP_FILE* stdout_;
YP_FILE* stderr_;
char** argv_;
int argc_;
#ifdef COROUTINING
ext_op attas_[attvars_ext+1];
#endif
int agc_calls_;
YAP_ULONG_LONG agc_collected_;
Int tot_agc_time_;
Int tot_agc_recovered_;
#if HAVE_MMAP
struct MMAP_ARRAY_BLOCK* mmap_arrays_;
#endif
#ifdef DEBUG
char Option_[20];
YP_FILE* logfile_;
int output_msg_;
#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)
char Executable_[YAP_FILENAME_MAX];
#endif
#if __simplescalar__
char pwd_[YAP_FILENAME_MAX];
#endif
} w_shared;

32
H/hlocals.h
View File

@ -150,4 +150,36 @@ typedef struct worker_local {
sigjmp_buf RestartEnv_;
char FileNameBuf_[YAP_FILENAME_MAX];
char FileNameBuf2_[YAP_FILENAME_MAX];
Int PrologMode_;
int CritLocks_;
#ifdef ANALYST
YAP_ULONG_LONG opcount_[_std_top+1];
YAP_ULONG_LONG 2opcount[_std_top+1][_std_top+1]_;
#endif /* ANALYST */
struct db_globs* s_dbg_;
yap_error_number matherror_;
int heap_overflows_;
Int total_heap_overflow_time_;
int stack_overflows_;
Int total_stack_overflow_time_;
int delay_overflows_;
Int total_delay_overflow_time_;
int trail_overflows_;
Int total_trail_overflow_time_;
int atom_table_overflows_;
Int total_atom_table_overflow_time_;
#ifdef LOAD_DYLD
static dl_errno_;
#endif
#ifdef LOW_LEVEL_TRACER
int do_trace_primitives_;
#endif
} w_local;

55
H/iglobals.h
View File

@ -52,4 +52,59 @@ static void InitGlobal(void) {
#if defined(YAPOR) || defined(TABLING)
#endif /* YAPOR || TABLING */
#if defined(THREADS)
#endif /* THREADS */
GLOBAL_stdout = stdout;
GLOBAL_stderr = stderr;
#ifdef COROUTINING
#endif
GLOBAL_tot_agc_time = 0;
GLOBAL_tot_agc_recovered = 0;
#if HAVE_MMAP
GLOBAL_mmap_arrays = NULL;
#endif
#ifdef DEBUG
GLOBAL_output_msg = FALSE;
#endif
GLOBAL_DIRNAME = NULL;
#if defined(COFF) || defined(A_OUT)
#endif
#if __simplescalar__
#endif
}

32
H/ilocals.h
View File

@ -150,4 +150,36 @@ static void InitWorker(int wid) {
REMOTE_PrologMode(wid) = BootMode;
REMOTE_CritLocks(wid) = 0;
#ifdef ANALYST
#endif /* ANALYST */
REMOTE_matherror(wid) = YAP_NO_ERROR;
REMOTE_heap_overflows(wid) = 0;
REMOTE_total_heap_overflow_time(wid) = 0;
REMOTE_stack_overflows(wid) = 0;
REMOTE_total_stack_overflow_time(wid) = 0;
REMOTE_delay_overflows(wid) = 0;
REMOTE_total_delay_overflow_time(wid) = 0;
REMOTE_trail_overflows(wid) = 0;
REMOTE_total_trail_overflow_time(wid) = 0;
REMOTE_atom_table_overflows(wid) = 0;
REMOTE_total_atom_table_overflow_time(wid) = 0;
#ifdef LOAD_DYLD
REMOTE_dl_errno(wid) = 0;
#endif
#ifdef LOW_LEVEL_TRACER
REMOTE_do_trace_primitives(wid) = TRUE;
#endif
}

55
H/rglobals.h
View File

@ -52,4 +52,59 @@ static void RestoreGlobal(void) {
#if defined(YAPOR) || defined(TABLING)
#endif /* YAPOR || TABLING */
#if defined(THREADS)
#endif /* THREADS */
#ifdef COROUTINING
#endif
#if HAVE_MMAP
#endif
#ifdef DEBUG
#endif
#if defined(COFF) || defined(A_OUT)
#endif
#if __simplescalar__
#endif
}

32
H/rlocals.h
View File

@ -150,4 +150,36 @@ static void RestoreWorker(int wid USES_REGS) {
#ifdef ANALYST
#endif /* ANALYST */
#ifdef LOAD_DYLD
#endif
#ifdef LOW_LEVEL_TRACER
#endif
}

9
H/yapio.h
View File

@ -65,8 +65,6 @@
#endif
#define YP_FILE FILE
extern YP_FILE *Yap_stdout;
extern YP_FILE *Yap_stderr;
int STD_PROTO(YP_putc,(int, int));
@ -387,11 +385,4 @@ WideHashFunction(wchar_t *CHP)
#define CONTINUE_ON_PARSER_ERROR 2
#define EXCEPTION_ON_PARSER_ERROR 3
#ifdef DEBUG
extern YP_FILE *Yap_logfile;
#endif
#if USE_SOCKET
extern int Yap_sockets_io;
#endif

1
OPTYap/opt.memory.c
View File

@ -73,7 +73,6 @@ void Yap_init_yapor_global_local_memory(void) {
Yap_local = (struct worker_local *)(MMAP_ADDR - ExtraArea);
Yap_global = (struct global_data *)(MMAP_ADDR - sizeof(struct global_data));
#ifdef MMAP_MEMORY_MAPPING_SCHEME
//open_mapfile(ExtraArea);
char mapfile[20];

156
OPTYap/opt.preds.c
View File

@ -388,12 +388,12 @@ static Int p_show_tabled_predicates( USES_REGS1 ) {
tab_ent_ptr tab_ent;
tab_ent = GLOBAL_root_tab_ent;
fprintf(Yap_stdout, "Tabled predicates\n");
fprintf(GLOBAL_stdout, "Tabled predicates\n");
if (tab_ent == NULL)
fprintf(Yap_stdout, " NONE\n");
fprintf(GLOBAL_stdout, " NONE\n");
else
while(tab_ent) {
fprintf(Yap_stdout, " %s/%d\n", AtomName(TabEnt_atom(tab_ent)), TabEnt_arity(tab_ent));
fprintf(GLOBAL_stdout, " %s/%d\n", AtomName(TabEnt_atom(tab_ent)), TabEnt_arity(tab_ent));
tab_ent = TabEnt_next(tab_ent);
}
return (TRUE);
@ -456,35 +456,35 @@ static Int p_show_statistics_tabling( USES_REGS1 ) {
long total_bytes = 0, aux_bytes;
aux_bytes = 0;
fprintf(Yap_stdout, "Execution data structures\n");
fprintf(GLOBAL_stdout, "Execution data structures\n");
aux_bytes += show_statistics_table_entries();
aux_bytes += show_statistics_subgoal_frames();
aux_bytes += show_statistics_dependency_frames();
fprintf(Yap_stdout, " Memory in use (I): %10ld bytes\n\n", aux_bytes);
fprintf(GLOBAL_stdout, " Memory in use (I): %10ld bytes\n\n", aux_bytes);
total_bytes += aux_bytes;
aux_bytes = 0;
fprintf(Yap_stdout, "Local trie data structures\n");
fprintf(GLOBAL_stdout, "Local trie data structures\n");
aux_bytes += show_statistics_subgoal_trie_nodes();
aux_bytes += show_statistics_answer_trie_nodes();
aux_bytes += show_statistics_subgoal_trie_hashes();
aux_bytes += show_statistics_answer_trie_hashes();
fprintf(Yap_stdout, " Memory in use (II): %10ld bytes\n\n", aux_bytes);
fprintf(GLOBAL_stdout, " Memory in use (II): %10ld bytes\n\n", aux_bytes);
total_bytes += aux_bytes;
aux_bytes = 0;
fprintf(Yap_stdout, "Global trie data structures\n");
fprintf(GLOBAL_stdout, "Global trie data structures\n");
aux_bytes += show_statistics_global_trie_nodes();
aux_bytes += show_statistics_global_trie_hashes();
fprintf(Yap_stdout, " Memory in use (III): %10ld bytes\n\n", aux_bytes);
fprintf(GLOBAL_stdout, " Memory in use (III): %10ld bytes\n\n", aux_bytes);
total_bytes += aux_bytes;
#ifdef USE_PAGES_MALLOC
fprintf(Yap_stdout, "Total memory in use (I+II+III): %10ld bytes (%ld pages in use)\n",
fprintf(GLOBAL_stdout, "Total memory in use (I+II+III): %10ld bytes (%ld pages in use)\n",
total_bytes, Pg_str_in_use(GLOBAL_pages_void));
fprintf(Yap_stdout, "Total memory allocated: %10ld bytes (%ld pages in total)\n",
fprintf(GLOBAL_stdout, "Total memory allocated: %10ld bytes (%ld pages in total)\n",
Pg_pg_alloc(GLOBAL_pages_void) * Yap_page_size, Pg_pg_alloc(GLOBAL_pages_void));
#else
fprintf(Yap_stdout, "Total memory in use (I+II+III): %10ld bytes\n", total_bytes);
fprintf(GLOBAL_stdout, "Total memory in use (I+II+III): %10ld bytes\n", total_bytes);
#endif /* USE_PAGES_MALLOC */
fflush(Yap_stdout);
fflush(GLOBAL_stdout);
return (TRUE);
}
@ -523,8 +523,6 @@ static Int p_yapor_on( USES_REGS1 ) {
static Int p_start_yapor( USES_REGS1 ) {
printf("------------ start yap or --------------------------\n");
#ifdef TIMESTAMP_CHECK
GLOBAL_timestamp = 0;
#endif /* TIMESTAMP_CHECK */
@ -642,32 +640,32 @@ static Int p_performance( USES_REGS1 ) {
return(FALSE);
if (GLOBAL_number_goals) {
fprintf(Yap_stdout, "[\n Best execution times:\n");
fprintf(GLOBAL_stdout, "[\n Best execution times:\n");
for (i = 1; i <= GLOBAL_number_goals; i++) {
fprintf(Yap_stdout, " %d. time: %f seconds", i, GLOBAL_best_times(i));
fprintf(GLOBAL_stdout, " %d. time: %f seconds", i, GLOBAL_best_times(i));
if (one_worker_execution_time != 0)
fprintf(Yap_stdout, " --> speedup %f (%6.2f %% )\n",
fprintf(GLOBAL_stdout, " --> speedup %f (%6.2f %% )\n",
one_worker_execution_time / GLOBAL_best_times(i),
one_worker_execution_time / GLOBAL_best_times(i) / GLOBAL_number_workers* 100 );
else fprintf(Yap_stdout, "\n");
else fprintf(GLOBAL_stdout, "\n");
}
fprintf(Yap_stdout, " Average : %f seconds",
fprintf(GLOBAL_stdout, " Average : %f seconds",
GLOBAL_best_times(0) / GLOBAL_number_goals);
if (one_worker_execution_time != 0)
fprintf(Yap_stdout, " --> speedup %f (%6.2f %% )",
fprintf(GLOBAL_stdout, " --> speedup %f (%6.2f %% )",
one_worker_execution_time * GLOBAL_number_goals / GLOBAL_best_times(0),
one_worker_execution_time * GLOBAL_number_goals / GLOBAL_best_times(0) / GLOBAL_number_workers* 100 );
if (GLOBAL_number_goals >= 3) {
fprintf(Yap_stdout, "\n Average (best three): %f seconds",
fprintf(GLOBAL_stdout, "\n Average (best three): %f seconds",
(GLOBAL_best_times(1) + GLOBAL_best_times(2) + GLOBAL_best_times(3)) / 3);
if (one_worker_execution_time != 0)
fprintf(Yap_stdout, " --> speedup %f (%6.2f %% ) ]\n\n",
fprintf(GLOBAL_stdout, " --> speedup %f (%6.2f %% ) ]\n\n",
one_worker_execution_time * 3 / (GLOBAL_best_times(1) + GLOBAL_best_times(2) + GLOBAL_best_times(3)),
one_worker_execution_time * 3 / (GLOBAL_best_times(1) + GLOBAL_best_times(2) + GLOBAL_best_times(3)) / GLOBAL_number_workers* 100 );
else fprintf(Yap_stdout, "\n]\n\n");
} else fprintf(Yap_stdout, "\n]\n\n");
else fprintf(GLOBAL_stdout, "\n]\n\n");
} else fprintf(GLOBAL_stdout, "\n]\n\n");
return (TRUE);
}
return (FALSE);
@ -705,23 +703,23 @@ static Int p_show_statistics_or( USES_REGS1 ) {
long total_bytes = 0, aux_bytes;
aux_bytes = 0;
fprintf(Yap_stdout, "Execution data structures\n");
fprintf(GLOBAL_stdout, "Execution data structures\n");
aux_bytes += show_statistics_or_frames();
fprintf(Yap_stdout, " Memory in use (I): %10ld bytes\n\n", aux_bytes);
fprintf(GLOBAL_stdout, " Memory in use (I): %10ld bytes\n\n", aux_bytes);
total_bytes += aux_bytes;
aux_bytes = 0;
fprintf(Yap_stdout, "Cut support data structures\n");
fprintf(GLOBAL_stdout, "Cut support data structures\n");
aux_bytes += show_statistics_query_goal_solution_frames();
aux_bytes += show_statistics_query_goal_answer_frames();
fprintf(Yap_stdout, " Memory in use (II): %10ld bytes\n\n", aux_bytes);
fprintf(GLOBAL_stdout, " Memory in use (II): %10ld bytes\n\n", aux_bytes);
total_bytes += aux_bytes;
#ifdef USE_PAGES_MALLOC
fprintf(Yap_stdout, "Total memory in use (I+II+III): %10ld bytes (%ld pages in use)\n",
fprintf(GLOBAL_stdout, "Total memory in use (I+II+III): %10ld bytes (%ld pages in use)\n",
total_bytes, Pg_str_in_use(GLOBAL_pages_void));
fprintf(Yap_stdout, "Total memory allocated: %10ld bytes (%ld pages in total)\n",
fprintf(GLOBAL_stdout, "Total memory allocated: %10ld bytes (%ld pages in total)\n",
Pg_pg_alloc(GLOBAL_pages_void) * Yap_page_size, Pg_pg_alloc(GLOBAL_pages_void));
#else
fprintf(Yap_stdout, "Total memory in use (I+II+III): %10ld bytes\n", total_bytes);
fprintf(GLOBAL_stdout, "Total memory in use (I+II+III): %10ld bytes\n", total_bytes);
#endif /* USE_PAGES_MALLOC */
return (TRUE);
@ -739,45 +737,45 @@ static Int p_show_statistics_opt( USES_REGS1 ) {
long total_bytes = 0, aux_bytes;
aux_bytes = 0;
fprintf(Yap_stdout, "Execution data structures\n");
fprintf(GLOBAL_stdout, "Execution data structures\n");
aux_bytes += show_statistics_table_entries();
aux_bytes += show_statistics_subgoal_frames();
aux_bytes += show_statistics_dependency_frames();
aux_bytes += show_statistics_or_frames();
aux_bytes += show_statistics_suspension_frames();
fprintf(Yap_stdout, " Memory in use (I): %10ld bytes\n\n", aux_bytes);
fprintf(GLOBAL_stdout, " Memory in use (I): %10ld bytes\n\n", aux_bytes);
total_bytes += aux_bytes;
aux_bytes = 0;
fprintf(Yap_stdout, "Local trie data structures\n");
fprintf(GLOBAL_stdout, "Local trie data structures\n");
aux_bytes += show_statistics_subgoal_trie_nodes();
aux_bytes += show_statistics_answer_trie_nodes();
aux_bytes += show_statistics_subgoal_trie_hashes();
aux_bytes += show_statistics_answer_trie_hashes();
fprintf(Yap_stdout, " Memory in use (II): %10ld bytes\n\n", aux_bytes);
fprintf(GLOBAL_stdout, " Memory in use (II): %10ld bytes\n\n", aux_bytes);
total_bytes += aux_bytes;
aux_bytes = 0;
fprintf(Yap_stdout, "Global trie data structures\n");
fprintf(GLOBAL_stdout, "Global trie data structures\n");
aux_bytes += show_statistics_global_trie_nodes();
aux_bytes += show_statistics_global_trie_hashes();
fprintf(Yap_stdout, " Memory in use (III): %10ld bytes\n\n", aux_bytes);
fprintf(GLOBAL_stdout, " Memory in use (III): %10ld bytes\n\n", aux_bytes);
total_bytes += aux_bytes;
aux_bytes = 0;
fprintf(Yap_stdout, "Cut support data structures\n");
fprintf(GLOBAL_stdout, "Cut support data structures\n");
aux_bytes += show_statistics_query_goal_solution_frames();
aux_bytes += show_statistics_query_goal_answer_frames();
#ifdef TABLING_INNER_CUTS
aux_bytes += show_statistics_table_subgoal_solution_frames();
aux_bytes += show_statistics_table_subgoal_answer_frames();
#endif /* TABLING_INNER_CUTS */
fprintf(Yap_stdout, " Memory in use (IV): %10ld bytes\n\n", aux_bytes);
fprintf(GLOBAL_stdout, " Memory in use (IV): %10ld bytes\n\n", aux_bytes);
total_bytes += aux_bytes;
#ifdef USE_PAGES_MALLOC
fprintf(Yap_stdout, "Total memory in use (I+II+III+IV): %10ld bytes (%ld pages in use)\n",
fprintf(GLOBAL_stdout, "Total memory in use (I+II+III+IV): %10ld bytes (%ld pages in use)\n",
total_bytes, Pg_str_in_use(GLOBAL_pages_void));
fprintf(Yap_stdout, "Total memory allocated: %10ld bytes (%ld pages in total)\n",
fprintf(GLOBAL_stdout, "Total memory allocated: %10ld bytes (%ld pages in total)\n",
Pg_pg_alloc(GLOBAL_pages_void) * Yap_page_size, Pg_pg_alloc(GLOBAL_pages_void));
#else
fprintf(Yap_stdout, "Total memory in use (I+II+III+IV): %10ld bytes\n", total_bytes);
fprintf(GLOBAL_stdout, "Total memory in use (I+II+III+IV): %10ld bytes\n", total_bytes);
#endif /* USE_PAGES_MALLOC */
return (TRUE);
@ -947,19 +945,19 @@ static inline void show_answers(void) {
}
switch(GLOBAL_answers) {
case YES_ANSWER:
fprintf(Yap_stderr, "[ yes");
fprintf(GLOBAL_stderr, "[ yes");
break;
case NO_ANSWER:
fprintf(Yap_stderr, "[ no");
fprintf(GLOBAL_stderr, "[ no");
break;
case 1:
fprintf(Yap_stderr, "[ 1 answer found");
fprintf(GLOBAL_stderr, "[ 1 answer found");
break;
default:
fprintf(Yap_stderr, "[ %d answers found", GLOBAL_answers);
fprintf(GLOBAL_stderr, "[ %d answers found", GLOBAL_answers);
break;
}
fprintf(Yap_stderr, " (in %f seconds) ]\n\n", GLOBAL_execution_time);
fprintf(GLOBAL_stderr, " (in %f seconds) ]\n\n", GLOBAL_execution_time);
if (GLOBAL_performance_mode == PERFORMANCE_ON) {
for (i = GLOBAL_number_goals; i > 0; i--) {
@ -1019,7 +1017,7 @@ static inline void answer_to_stdout(char *answer) {
else break;
}
output[length_output] = 0;
fprintf(Yap_stderr, " %s\n", output);
fprintf(GLOBAL_stderr, " %s\n", output);
return;
}
#endif /* YAPOR */
@ -1044,10 +1042,10 @@ static inline long show_statistics_table_entries(void) {
}
TABLING_ERROR_CHECKING(statistics_table_entries, Pg_str_free(GLOBAL_pages_tab_ent) != cont);
#endif /* DEBUG_TABLING */
fprintf(Yap_stdout, " Table entries: %10ld bytes (%ld pages and %ld structs in use)\n",
fprintf(GLOBAL_stdout, " Table entries: %10ld bytes (%ld pages and %ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_tab_ent) * sizeof(struct table_entry), Pg_pg_alloc(GLOBAL_pages_tab_ent), Pg_str_in_use(GLOBAL_pages_tab_ent));
#else
fprintf(Yap_stdout, " Table entries: %10ld bytes (%ld structs in use)\n",
fprintf(GLOBAL_stdout, " Table entries: %10ld bytes (%ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_tab_ent) * sizeof(struct table_entry), Pg_str_in_use(GLOBAL_pages_tab_ent));
#endif /* USE_PAGES_MALLOC */
return Pg_str_in_use(GLOBAL_pages_tab_ent) * sizeof(struct table_entry);
@ -1072,10 +1070,10 @@ static inline long show_statistics_subgoal_frames(void) {
}
TABLING_ERROR_CHECKING(statistics_subgoal_frames, Pg_str_free(GLOBAL_pages_sg_fr) != cont);
#endif /* DEBUG_TABLING */
fprintf(Yap_stdout, " Subgoal frames: %10ld bytes (%ld pages and %ld structs in use)\n",
fprintf(GLOBAL_stdout, " Subgoal frames: %10ld bytes (%ld pages and %ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_sg_fr) * sizeof(struct subgoal_frame), Pg_pg_alloc(GLOBAL_pages_sg_fr), Pg_str_in_use(GLOBAL_pages_sg_fr));
#else
fprintf(Yap_stdout, " Subgoal frames: %10ld bytes (%ld structs in use)\n",
fprintf(GLOBAL_stdout, " Subgoal frames: %10ld bytes (%ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_sg_fr) * sizeof(struct subgoal_frame), Pg_str_in_use(GLOBAL_pages_sg_fr));
#endif /* USE_PAGES_MALLOC */
return Pg_str_in_use(GLOBAL_pages_sg_fr) * sizeof(struct subgoal_frame);
@ -1100,10 +1098,10 @@ static inline long show_statistics_dependency_frames(void) {
}
TABLING_ERROR_CHECKING(statistics_dependency_frames, Pg_str_free(GLOBAL_pages_dep_fr) != cont);
#endif /* DEBUG_TABLING */
fprintf(Yap_stdout, " Dependency frames: %10ld bytes (%ld pages and %ld structs in use)\n",
fprintf(GLOBAL_stdout, " Dependency frames: %10ld bytes (%ld pages and %ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_dep_fr) * sizeof(struct dependency_frame), Pg_pg_alloc(GLOBAL_pages_dep_fr), Pg_str_in_use(GLOBAL_pages_dep_fr));
#else
fprintf(Yap_stdout, " Dependency frames: %10ld bytes (%ld structs in use)\n",
fprintf(GLOBAL_stdout, " Dependency frames: %10ld bytes (%ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_dep_fr) * sizeof(struct dependency_frame), Pg_str_in_use(GLOBAL_pages_dep_fr));
#endif /* USE_PAGES_MALLOC */
return Pg_str_in_use(GLOBAL_pages_dep_fr) * sizeof(struct dependency_frame);
@ -1128,10 +1126,10 @@ static inline long show_statistics_subgoal_trie_nodes(void) {
}
TABLING_ERROR_CHECKING(statistics_subgoal_trie_nodes, Pg_str_free(GLOBAL_pages_sg_node) != cont);
#endif /* DEBUG_TABLING */
fprintf(Yap_stdout, " Subgoal trie nodes: %10ld bytes (%ld pages and %ld structs in use)\n",
fprintf(GLOBAL_stdout, " Subgoal trie nodes: %10ld bytes (%ld pages and %ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_sg_node) * sizeof(struct subgoal_trie_node), Pg_pg_alloc(GLOBAL_pages_sg_node), Pg_str_in_use(GLOBAL_pages_sg_node));
#else
fprintf(Yap_stdout, " Subgoal trie nodes: %10ld bytes (%ld structs in use)\n",
fprintf(GLOBAL_stdout, " Subgoal trie nodes: %10ld bytes (%ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_sg_node) * sizeof(struct subgoal_trie_node), Pg_str_in_use(GLOBAL_pages_sg_node));
#endif /* USE_PAGES_MALLOC */
return Pg_str_in_use(GLOBAL_pages_sg_node) * sizeof(struct subgoal_trie_node);
@ -1156,10 +1154,10 @@ static inline long show_statistics_answer_trie_nodes(void) {
}
TABLING_ERROR_CHECKING(statistics_answer_trie_nodes, Pg_str_free(GLOBAL_pages_ans_node) != cont);
#endif /* DEBUG_TABLING */
fprintf(Yap_stdout, " Answer trie nodes: %10ld bytes (%ld pages and %ld structs in use)\n",
fprintf(GLOBAL_stdout, " Answer trie nodes: %10ld bytes (%ld pages and %ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_ans_node) * sizeof(struct answer_trie_node), Pg_pg_alloc(GLOBAL_pages_ans_node), Pg_str_in_use(GLOBAL_pages_ans_node));
#else
fprintf(Yap_stdout, " Answer trie nodes: %10ld bytes (%ld structs in use)\n",
fprintf(GLOBAL_stdout, " Answer trie nodes: %10ld bytes (%ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_ans_node) * sizeof(struct answer_trie_node), Pg_str_in_use(GLOBAL_pages_ans_node));
#endif /* USE_PAGES_MALLOC */
return Pg_str_in_use(GLOBAL_pages_ans_node) * sizeof(struct answer_trie_node);
@ -1184,10 +1182,10 @@ static inline long show_statistics_subgoal_trie_hashes(void) {
}
TABLING_ERROR_CHECKING(statistics_subgoal_trie_hashes, Pg_str_free(GLOBAL_pages_sg_hash) != cont);
#endif /* DEBUG_TABLING */
fprintf(Yap_stdout, " Subgoal trie hashes: %10ld bytes (%ld pages and %ld structs in use)\n",
fprintf(GLOBAL_stdout, " Subgoal trie hashes: %10ld bytes (%ld pages and %ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_sg_hash) * sizeof(struct subgoal_trie_hash), Pg_pg_alloc(GLOBAL_pages_sg_hash), Pg_str_in_use(GLOBAL_pages_sg_hash));
#else
fprintf(Yap_stdout, " Subgoal trie hashes: %10ld bytes (%ld structs in use)\n",
fprintf(GLOBAL_stdout, " Subgoal trie hashes: %10ld bytes (%ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_sg_hash) * sizeof(struct subgoal_trie_hash), Pg_str_in_use(GLOBAL_pages_sg_hash));
#endif /* USE_PAGES_MALLOC */
return Pg_str_in_use(GLOBAL_pages_sg_hash) * sizeof(struct subgoal_trie_hash);
@ -1212,10 +1210,10 @@ static inline long show_statistics_answer_trie_hashes(void) {
}
TABLING_ERROR_CHECKING(statistics_answer_trie_hashes, Pg_str_free(GLOBAL_pages_ans_hash) != cont);
#endif /* DEBUG_TABLING */
fprintf(Yap_stdout, " Answer trie hashes: %10ld bytes (%ld pages and %ld structs in use)\n",
fprintf(GLOBAL_stdout, " Answer trie hashes: %10ld bytes (%ld pages and %ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_ans_hash) * sizeof(struct answer_trie_hash), Pg_pg_alloc(GLOBAL_pages_ans_hash), Pg_str_in_use(GLOBAL_pages_ans_hash));
#else
fprintf(Yap_stdout, " Answer trie hashes: %10ld bytes (%ld structs in use)\n",
fprintf(GLOBAL_stdout, " Answer trie hashes: %10ld bytes (%ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_ans_hash) * sizeof(struct answer_trie_hash), Pg_str_in_use(GLOBAL_pages_ans_hash));
#endif /* USE_PAGES_MALLOC */
return Pg_str_in_use(GLOBAL_pages_ans_hash) * sizeof(struct answer_trie_hash);
@ -1240,10 +1238,10 @@ static inline long show_statistics_global_trie_nodes(void) {
}
TABLING_ERROR_CHECKING(statistics_global_trie_nodes, Pg_str_free(GLOBAL_pages_gt_node) != cont);
#endif /* DEBUG_TABLING */
fprintf(Yap_stdout, " Global trie nodes: %10ld bytes (%ld pages and %ld structs in use)\n",
fprintf(GLOBAL_stdout, " Global trie nodes: %10ld bytes (%ld pages and %ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_gt_node) * sizeof(struct global_trie_node), Pg_pg_alloc(GLOBAL_pages_gt_node), Pg_str_in_use(GLOBAL_pages_gt_node));
#else
fprintf(Yap_stdout, " Global trie nodes: %10ld bytes (%ld structs in use)\n",
fprintf(GLOBAL_stdout, " Global trie nodes: %10ld bytes (%ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_gt_node) * sizeof(struct global_trie_node), Pg_str_in_use(GLOBAL_pages_gt_node));
#endif /* USE_PAGES_MALLOC */
return Pg_str_in_use(GLOBAL_pages_gt_node) * sizeof(struct global_trie_node);
@ -1268,10 +1266,10 @@ static inline long show_statistics_global_trie_hashes(void) {
}
TABLING_ERROR_CHECKING(statistics_global_trie_hashes, Pg_str_free(GLOBAL_pages_gt_hash) != cont);
#endif /* DEBUG_TABLING */
fprintf(Yap_stdout, " Global trie hashes: %10ld bytes (%ld pages and %ld structs in use)\n",
fprintf(GLOBAL_stdout, " Global trie hashes: %10ld bytes (%ld pages and %ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_gt_hash) * sizeof(struct global_trie_hash), Pg_pg_alloc(GLOBAL_pages_gt_hash), Pg_str_in_use(GLOBAL_pages_gt_hash));
#else
fprintf(Yap_stdout, " Global trie hashes: %10ld bytes (%ld structs in use)\n",
fprintf(GLOBAL_stdout, " Global trie hashes: %10ld bytes (%ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_gt_hash) * sizeof(struct global_trie_hash), Pg_str_in_use(GLOBAL_pages_gt_hash));
#endif /* USE_PAGES_MALLOC */
return Pg_str_in_use(GLOBAL_pages_gt_hash) * sizeof(struct global_trie_hash);
@ -1298,10 +1296,10 @@ static inline long show_statistics_or_frames(void) {
}
YAPOR_ERROR_CHECKING(statistics_or_frames, Pg_str_free(GLOBAL_pages_or_fr ) != cont);
#endif /* DEBUG_YAPOR */
fprintf(Yap_stdout, " Or-frames: %10ld bytes (%ld pages and %ld structs in use)\n",
fprintf(GLOBAL_stdout, " Or-frames: %10ld bytes (%ld pages and %ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_or_fr ) * sizeof(struct or_frame), Pg_pg_alloc(GLOBAL_pages_or_fr ), Pg_str_in_use(GLOBAL_pages_or_fr ));
#else
fprintf(Yap_stdout, " Or-frames: %10ld bytes (%ld structs in use)\n",
fprintf(GLOBAL_stdout, " Or-frames: %10ld bytes (%ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_or_fr ) * sizeof(struct or_frame), Pg_str_in_use(GLOBAL_pages_or_fr ));
#endif /* USE_PAGES_MALLOC */
return Pg_str_in_use(GLOBAL_pages_or_fr ) * sizeof(struct or_frame);
@ -1326,10 +1324,10 @@ static inline long show_statistics_query_goal_solution_frames(void) {
}
YAPOR_ERROR_CHECKING(statistics_query_goal_solution_frames, Pg_str_free(GLOBAL_pages_qg_sol_fr ) != cont);
#endif /* DEBUG_YAPOR */
fprintf(Yap_stdout, " Query goal solution frames: %10ld bytes (%ld pages and %ld structs in use)\n",
fprintf(GLOBAL_stdout, " Query goal solution frames: %10ld bytes (%ld pages and %ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_qg_sol_fr ) * sizeof(struct query_goal_solution_frame), Pg_pg_alloc(GLOBAL_pages_qg_sol_fr ), Pg_str_in_use(GLOBAL_pages_qg_sol_fr ));
#else
fprintf(Yap_stdout, " Query goal solution frames: %10ld bytes (%ld structs in use)\n",
fprintf(GLOBAL_stdout, " Query goal solution frames: %10ld bytes (%ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_qg_sol_fr ) * sizeof(struct query_goal_solution_frame), Pg_str_in_use(GLOBAL_pages_qg_sol_fr ));
#endif /* USE_PAGES_MALLOC */
return Pg_str_in_use(GLOBAL_pages_qg_sol_fr ) * sizeof(struct query_goal_solution_frame);
@ -1354,10 +1352,10 @@ static inline long show_statistics_query_goal_answer_frames(void) {
}
YAPOR_ERROR_CHECKING(statistics_query_goal_answer_frames, Pg_str_free(GLOBAL_pages_qg_ans_fr) != cont);
#endif /* DEBUG_YAPOR */
fprintf(Yap_stdout, " Query goal answer frames: %10ld bytes (%ld pages and %ld structs in use)\n",
fprintf(GLOBAL_stdout, " Query goal answer frames: %10ld bytes (%ld pages and %ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_qg_ans_fr) * sizeof(struct query_goal_answer_frame), Pg_pg_alloc(GLOBAL_pages_qg_ans_fr), Pg_str_in_use(GLOBAL_pages_qg_ans_fr));
#else
fprintf(Yap_stdout, " Query goal answer frames: %10ld bytes (%ld structs in use)\n",
fprintf(GLOBAL_stdout, " Query goal answer frames: %10ld bytes (%ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_qg_ans_fr) * sizeof(struct query_goal_answer_frame), Pg_str_in_use(GLOBAL_pages_qg_ans_fr));
#endif /* USE_PAGES_MALLOC */
return Pg_str_in_use(GLOBAL_pages_qg_ans_fr) * sizeof(struct query_goal_answer_frame);
@ -1384,10 +1382,10 @@ static inline long show_statistics_suspension_frames(void) {
}
OPTYAP_ERROR_CHECKING(statistics_suspension_frames, Pg_str_free(GLOBAL_pages_susp_fr) != cont);
#endif /* DEBUG_OPTYAP */
fprintf(Yap_stdout, " Suspension frames: %10ld bytes (%ld pages and %ld structs in use)\n",
fprintf(GLOBAL_stdout, " Suspension frames: %10ld bytes (%ld pages and %ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_susp_fr) * sizeof(struct suspension_frame), Pg_pg_alloc(GLOBAL_pages_susp_fr), Pg_str_in_use(GLOBAL_pages_susp_fr));
#else
fprintf(Yap_stdout, " Suspension frames: %10ld bytes (%ld structs in use)\n",
fprintf(GLOBAL_stdout, " Suspension frames: %10ld bytes (%ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_susp_fr) * sizeof(struct suspension_frame), Pg_str_in_use(GLOBAL_pages_susp_fr));
#endif /* USE_PAGES_MALLOC */
return Pg_str_in_use(GLOBAL_pages_susp_fr) * sizeof(struct suspension_frame);
@ -1413,10 +1411,10 @@ static inline long show_statistics_table_subgoal_solution_frames(void) {
}
OPTYAP_ERROR_CHECKING(statistics_table_subgoal_solution_frames, Pg_str_free(GLOBAL_pages_tg_sol_fr) != cont);
#endif /* DEBUG_OPTYAP */
fprintf(Yap_stdout, " Table subgoal solution frames: %10ld bytes (%ld pages and %ld structs in use)\n",
fprintf(GLOBAL_stdout, " Table subgoal solution frames: %10ld bytes (%ld pages and %ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_tg_sol_fr) * sizeof(struct table_subgoal_solution_frame), Pg_pg_alloc(GLOBAL_pages_tg_sol_fr), Pg_str_in_use(GLOBAL_pages_tg_sol_fr));
#else
fprintf(Yap_stdout, " Table subgoal solution frames: %10ld bytes (%ld structs in use)\n",
fprintf(GLOBAL_stdout, " Table subgoal solution frames: %10ld bytes (%ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_tg_sol_fr) * sizeof(struct table_subgoal_solution_frame), Pg_str_in_use(GLOBAL_pages_tg_sol_fr));
#endif /* USE_PAGES_MALLOC */
return Pg_str_in_use(GLOBAL_pages_tg_sol_fr) * sizeof(struct table_subgoal_solution_frame);
@ -1441,10 +1439,10 @@ static inline long show_statistics_table_subgoal_answer_frames(void) {
}
OPTYAP_ERROR_CHECKING(statistics_table_subgoal_answer_frames, Pg_str_free(GLOBAL_pages_tg_ans_fr) != cont);
#endif /* DEBUG_OPTYAP */
fprintf(Yap_stdout, " Table subgoal answer frames: %10ld bytes (%ld pages and %ld structs in use)\n",
fprintf(GLOBAL_stdout, " Table subgoal answer frames: %10ld bytes (%ld pages and %ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_tg_ans_fr) * sizeof(struct table_subgoal_answer_frame), Pg_pg_alloc(GLOBAL_pages_tg_ans_fr), Pg_str_in_use(GLOBAL_pages_tg_ans_fr));
#else
fprintf(Yap_stdout, " Table subgoal answer frames: %10ld bytes (%ld structs in use)\n",
fprintf(GLOBAL_stdout, " Table subgoal answer frames: %10ld bytes (%ld structs in use)\n",
Pg_str_in_use(GLOBAL_pages_tg_ans_fr) * sizeof(struct table_subgoal_answer_frame), Pg_str_in_use(GLOBAL_pages_tg_ans_fr));
#endif /* USE_PAGES_MALLOC */
return Pg_str_in_use(GLOBAL_pages_tg_ans_fr) * sizeof(struct table_subgoal_answer_frame);

1
OPTYap/or.cut.c
View File

@ -40,7 +40,6 @@ void prune_shared_branch(choiceptr prune_cp) {
#ifdef TABLING_INNER_CUTS
tg_sol_fr_ptr tg_solutions, aux_tg_solutions;
#endif /* TABLING_INNER_CUTS */
printf(" ---- worker_id %d -----\n", worker_id);
leftmost_or_fr = CUT_leftmost_or_frame();
leftmost_cp = GetOrFr_node(leftmost_or_fr);
qg_solutions = NULL;

2
OPTYap/or.sba_unify.h
View File

@ -69,7 +69,7 @@ EXTERN inline Int unify_constant(register Term a, register Term cons)
return(IsLongIntTerm(cons) && LongIntOfTerm(a) == LongIntOfTerm(cons));
#ifdef TERM_EXTENSIONS
} else if (IsAttachFunc(fun)) {
return(attas[ExtFromFunctor(fun)].bind_op(SBIND,a,cons));
return(GLOBAL_attas[ExtFromFunctor(fun)].bind_op(SBIND,a,cons));
#endif /* TERM_EXTENSIONS */
} else
return(FALSE);

1
OPTYap/or.scheduler.c
View File

@ -217,7 +217,6 @@ int get_work(void) {
counter = 0;
BITMAP_difference(stable_busy, OrFr_members(LOCAL_top_or_fr), GLOBAL_bm_idle_workers);
while (1) {
//printf(" ******** worker_id %d **********\n", worker_id);
while (BITMAP_subset(GLOBAL_bm_idle_workers, OrFr_members(LOCAL_top_or_fr)) &&
Get_LOCAL_top_cp() != Get_GLOBAL_root_cp()) {
/* no busy workers here and below */

38
OPTYap/tab.tries.c
View File

@ -110,7 +110,7 @@ static struct trie_statistics{
#define SHOW_TABLE_ARITY_ARRAY_SIZE 10000
#define SHOW_TABLE_STRUCTURE(MESG, ARGS...) \
if (TrStat_show == SHOW_MODE_STRUCTURE) \
fprintf(Yap_stdout, MESG, ##ARGS)
fprintf(GLOBAL_stdout, MESG, ##ARGS)
#define CHECK_DECREMENT_GLOBAL_TRIE_REFERENCE(REF,MODE) \
if (MODE == TRAVERSE_MODE_NORMAL && IsVarTerm(REF) && REF > VarIndexOfTableTerm(MAX_TABLE_VARS)) { \
@ -1313,9 +1313,9 @@ void show_table(tab_ent_ptr tab_ent, int show_mode) {
#endif /* TABLING_INNER_CUTS */
TrStat_ans_nodes = 0;
TrStat_gt_refs = 0;
fprintf(Yap_stdout, "Table statistics for predicate '%s/%d'\n", AtomName(TabEnt_atom(tab_ent)), TabEnt_arity(tab_ent));
fprintf(GLOBAL_stdout, "Table statistics for predicate '%s/%d'\n", AtomName(TabEnt_atom(tab_ent)), TabEnt_arity(tab_ent));
} else { /* SHOW_MODE_STRUCTURE */
fprintf(Yap_stdout, "Table structure for predicate '%s/%d'\n", AtomName(TabEnt_atom(tab_ent)), TabEnt_arity(tab_ent));
fprintf(GLOBAL_stdout, "Table structure for predicate '%s/%d'\n", AtomName(TabEnt_atom(tab_ent)), TabEnt_arity(tab_ent));
}
sg_node = TrNode_child(TabEnt_subgoal_trie(tab_ent));
if (sg_node) {
@ -1349,21 +1349,21 @@ void show_table(tab_ent_ptr tab_ent, int show_mode) {
} else
SHOW_TABLE_STRUCTURE(" EMPTY\n");
if (show_mode == SHOW_MODE_STATISTICS) {
fprintf(Yap_stdout, " Subgoal trie structure\n");
fprintf(Yap_stdout, " Subgoals: %ld (%ld incomplete)\n", TrStat_subgoals, TrStat_sg_incomplete);
fprintf(Yap_stdout, " Subgoal trie nodes: %ld\n", TrStat_sg_nodes);
fprintf(Yap_stdout, " Answer trie structure(s)\n");
fprintf(GLOBAL_stdout, " Subgoal trie structure\n");
fprintf(GLOBAL_stdout, " Subgoals: %ld (%ld incomplete)\n", TrStat_subgoals, TrStat_sg_incomplete);
fprintf(GLOBAL_stdout, " Subgoal trie nodes: %ld\n", TrStat_sg_nodes);
fprintf(GLOBAL_stdout, " Answer trie structure(s)\n");
#ifdef TABLING_INNER_CUTS
fprintf(Yap_stdout, " Answers: %ld (%ld pruned)\n", TrStat_answers, TrStat_answers_pruned);
fprintf(GLOBAL_stdout, " Answers: %ld (%ld pruned)\n", TrStat_answers, TrStat_answers_pruned);
#else
fprintf(Yap_stdout, " Answers: %ld\n", TrStat_answers);
fprintf(GLOBAL_stdout, " Answers: %ld\n", TrStat_answers);
#endif /* TABLING_INNER_CUTS */
fprintf(Yap_stdout, " Answers 'TRUE': %ld\n", TrStat_answers_true);
fprintf(Yap_stdout, " Answers 'NO': %ld\n", TrStat_answers_no);
fprintf(Yap_stdout, " Answer trie nodes: %ld\n", TrStat_ans_nodes);
fprintf(Yap_stdout, " Global trie references: %ld\n", TrStat_gt_refs);
fprintf(GLOBAL_stdout, " Answers 'TRUE': %ld\n", TrStat_answers_true);
fprintf(GLOBAL_stdout, " Answers 'NO': %ld\n", TrStat_answers_no);
fprintf(GLOBAL_stdout, " Answer trie nodes: %ld\n", TrStat_ans_nodes);
fprintf(GLOBAL_stdout, " Global trie references: %ld\n", TrStat_gt_refs);
}
fflush(Yap_stdout);
fflush(GLOBAL_stdout);
return;
}
@ -1374,9 +1374,9 @@ void show_global_trie(int show_mode) {
TrStat_gt_terms = 0;
TrStat_gt_nodes = 1;
TrStat_gt_refs = 0;
fprintf(Yap_stdout, "Global trie statistics\n");
fprintf(GLOBAL_stdout, "Global trie statistics\n");
} else { /* SHOW_MODE_STRUCTURE */
fprintf(Yap_stdout, "Global trie structure\n");
fprintf(GLOBAL_stdout, "Global trie structure\n");
}
if (TrNode_child(GLOBAL_root_gt)) {
char *str = (char *) malloc(sizeof(char) * SHOW_TABLE_STR_ARRAY_SIZE);
@ -1388,9 +1388,9 @@ void show_global_trie(int show_mode) {
} else
SHOW_TABLE_STRUCTURE(" EMPTY\n");
if (show_mode == SHOW_MODE_STATISTICS) {
fprintf(Yap_stdout, " Terms: %ld\n", TrStat_gt_terms);
fprintf(Yap_stdout, " Global trie nodes: %ld\n", TrStat_gt_nodes);
fprintf(Yap_stdout, " Global trie auto references: %ld\n", TrStat_gt_refs);
fprintf(GLOBAL_stdout, " Terms: %ld\n", TrStat_gt_terms);
fprintf(GLOBAL_stdout, " Global trie nodes: %ld\n", TrStat_gt_nodes);
fprintf(GLOBAL_stdout, " Global trie auto references: %ld\n", TrStat_gt_refs);
}
return;
}

22
console/yap.c
View File

@ -259,28 +259,6 @@ parse_yap_arguments(int argc, char *argv[], YAP_init_args *iap)
if (!strcmp("dump-runtime-variables",p))
return dump_runtime_variables();
#endif /* YAPOR_COPY || YAPOR_COW || YAPOR_SBA || YAPOR_THREADS */
#ifdef USE_SOCKET
case 'c': /* running as client */
{
char *host, *p1;
long port;
char *ptr;
host = *++argv;
argc--;
if (host == NULL || host[0] == '-')
YAP_Error(0,0L,"sockets must receive host to connect to");
p1 = *++argv;
argc--;
if (p1 == NULL || p1[0] == '-')
YAP_Error(0,0L,"sockets must receive port to connect to");
port = strtol(p1, &ptr, 10);
if (ptr == NULL || ptr[0] != '\0')
YAP_Error(0,0L,"port argument to socket must be a number");
YAP_InitSocks(host,port);
}
break;
#endif
case 'F':
/* just ignore for now */
argc--;

4
library/dialect/swi/fli/swi.c
View File

@ -2741,9 +2741,9 @@ PL_query(int query)
{
switch(query) {
case PL_QUERY_ARGC:
return (intptr_t)Yap_argc;
return (intptr_t)GLOBAL_argc;
case PL_QUERY_ARGV:
return (intptr_t)Yap_argv;
return (intptr_t)GLOBAL_argv;
case PL_QUERY_USER_CPU:
return (intptr_t)Yap_cputime();
case PL_QUERY_VERSION:

11
library/lammpi/yap_mpi.c
View File

@ -75,8 +75,7 @@ typedef struct broadcast_req BroadcastRequest;
* Auxiliary data
********************************************************************/
static int mpi_status;
extern char **Yap_argv;
extern int Yap_argc;
extern int GLOBAL_argc;
#define HASHSIZE 1777
static hashtable requests=NULL;
@ -261,8 +260,8 @@ static int mpi_error(int errcode){
static int
mpi_init(void){
int thread_level;
// MPI_Init(&Yap_argc, &Yap_argv);
MPI_Init_thread(&Yap_argc, &Yap_argv,MPI_THREAD_SINGLE,&thread_level);
// MPI_Init(&GLOBAL_argc, &GLOBAL_argv);
MPI_Init_thread(&GLOBAL_argc, &GLOBAL_argv,MPI_THREAD_SINGLE,&thread_level);
#ifdef DEBUG
write_msg(__FUNCTION__,__FILE__,__LINE__,"Thread level: %d\n",thread_level);
#endif
@ -300,11 +299,11 @@ rcv_msg_thread(char *handle_pred) {
static int
mpi_init_rcv_thread(void){
int thread_level;
// MPI_Init(&Yap_argc, &Yap_argv);
// MPI_Init(&GLOBAL_argc, &GLOBAL_argv);
pthread_t thread;
char *arg="handle_msg";
MPI_Init_thread(&Yap_argc, &Yap_argv,MPI_THREAD_SINGLE,&thread_level);
MPI_Init_thread(&GLOBAL_argc, &GLOBAL_argv,MPI_THREAD_SINGLE,&thread_level);
if(pthread_create(&thread,NULL,(void*)&rcv_msg_thread,arg)) {
return (FALSE);
}

14
library/mpi/mpi.c
View File

@ -491,21 +491,21 @@ Yap_InitMPI(void)
{
int i,j;
mpi_argv = malloc( Yap_argc * sizeof(char *) );
mpi_argv[0] = strdup( Yap_argv[0] );
mpi_argv = malloc( GLOBAL_argc * sizeof(char *) );
mpi_argv[0] = strdup( GLOBAL_argv[0] );
bufsize = RECV_BUF_SIZE;
buf = malloc(bufsize * sizeof(char));
for( i=1; i<Yap_argc; ++i ) {
if( !strcmp(Yap_argv[i], "--") ) { ++i; break; }
for( i=1; i<GLOBAL_argc; ++i ) {
if( !strcmp(GLOBAL_argv[i], "--") ) { ++i; break; }
}
for( j=1; i<Yap_argc; ++i, ++j ) {
mpi_argv[j] = strdup( Yap_argv[i] );
for( j=1; i<GLOBAL_argc; ++i, ++j ) {
mpi_argv[j] = strdup( GLOBAL_argv[i] );
}
mpi_argc = j;
mpi_argv[0] = strdup( Yap_argv[0] );
mpi_argv[0] = strdup( GLOBAL_argv[0] );
Yap_InitCPred( "mpi_open", 3, p_mpi_open, SafePredFlag|SyncPredFlag );
Yap_InitCPred( "mpi_close", 0, p_mpi_close, SafePredFlag|SyncPredFlag );

72
misc/GLOBALS
View File

@ -58,5 +58,77 @@ lockvar BGL MkLock
struct global_optyap_data optyap_data void
#endif /* YAPOR || TABLING */
// whether Yap is responsible for signal handling
int PrologShouldHandleInterrupts void
/* This is the guy who actually started the system, and who has the correct registers */
#if defined(THREADS)
pthread_t master_thread void
#endif /* THREADS */
// streams
YP_FILE* stdout =stdout
YP_FILE* stderr =stderr
// access to yap initial arguments
char** argv void
int argc void
// extensions to Terms
#ifdef COROUTINING
/* array with the ops for your favourite extensions */
ext_op attas[attvars_ext+1] void
#endif
// agc.c
int agc_calls void
YAP_ULONG_LONG agc_collected void
/* total time spent in GC */
Int tot_agc_time =0
/* number of heap objects in all garbage collections */
Int tot_agc_recovered =0
//arrays.c
#if HAVE_MMAP
struct MMAP_ARRAY_BLOCK* mmap_arrays =NULL
#endif
#ifdef DEBUG
//computils.c
char Option[20] void
YP_FILE* logfile void
//init.c
int output_msg =FALSE
#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)
// loada_coff.c && load_aout.c
char Executable[YAP_FILENAME_MAX] void
#endif
#if __simplescalar__
char pwd[YAP_FILENAME_MAX] void
#endif
//udi.c
//struct udi_control_block RtreeCmd void
END_GLOBAL_DATA

41
misc/LOCALS
View File

@ -168,6 +168,47 @@ sigjmp_buf RestartEnv void
char FileNameBuf[YAP_FILENAME_MAX] void
char FileNameBuf2[YAP_FILENAME_MAX] void
// Prolog State
Int PrologMode =BootMode
int CritLocks =0
//analyst.c
/* used to find out how many instructions of each kind are executed */
#ifdef ANALYST
YAP_ULONG_LONG opcount[_std_top+1] void
YAP_ULONG_LONG 2opcount[_std_top+1][_std_top+1] void
#endif /* ANALYST */
//dbase.c
struct db_globs* s_dbg void
//eval.c
yap_error_number matherror =YAP_NO_ERROR
//grow.c
int heap_overflows =0
Int total_heap_overflow_time =0
int stack_overflows =0
Int total_stack_overflow_time =0
int delay_overflows =0
Int total_delay_overflow_time =0
int trail_overflows =0
Int total_trail_overflow_time =0
int atom_table_overflows =0
Int total_atom_table_overflow_time =0
//load_dyld
#ifdef LOAD_DYLD
static dl_errno =0
#endif
//tracer.c
#ifdef LOW_LEVEL_TRACER
int do_trace_primitives =TRUE
#endif
END_WORKER_LOCAL

1
packages/PLStream/pl-incl.h
View File

@ -43,6 +43,7 @@ do_startCritical(void) {
}
static inline int
do_endCritical(void) {
CACHE_REGS
YAPLeaveCriticalSection();
return 1;
}