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

My first attempt to synchronize OPTYap with CVS

Browse Source 
git-svn-id: https://yap.svn.sf.net/svnroot/yap/trunk@916 b08c6af1-5177-4d33-ba66-4b1c6b8b522a
This commit is contained in:
ricroc 2003-11-05 16:12:25 +00:00
parent e2e49aecd1
commit 80be9121af
18 changed files with 176 additions and 305 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
H/amiops.h
View File

@ -395,7 +395,7 @@ Int Yap_unify(Term t0, Term t1)
pt[0] = TrailVal(TR); pt[0] = TrailVal(TR);
#else #else
pt[0] = TrailTerm(TR); pt[0] = TrailTerm(TR);
#endif #endif /* FROZEN_STACKS */
} }
#endif #endif
} }

4
OPTYap/opt.init.c
View File

@ -53,7 +53,7 @@ static void receive_signals(int s);
** Local macros ** ** Local macros **
** ---------------------- */ ** ---------------------- */
#define STRUCTS_PER_PAGE(STR_TYPE) ((PageSize - STRUCT_SIZE(struct page_header)) / STRUCT_SIZE(STR_TYPE)) #define STRUCTS_PER_PAGE(STR_TYPE) ((Yap_page_size - STRUCT_SIZE(struct page_header)) / STRUCT_SIZE(STR_TYPE))
#ifdef STATISTICS #ifdef STATISTICS
#define INIT_PAGE_STATISTICS(PG) \ #define INIT_PAGE_STATISTICS(PG) \
@ -165,7 +165,7 @@ void init_global(int n_workers, int sch_loop, int delay_load) {
void init_local(void) { void init_local(void) {
#ifdef YAPOR #ifdef YAPOR
/* local data related to or-parallelism */ /* local data related to or-parallelism */
LOCAL = REMOTE+worker_id; LOCAL = REMOTE + worker_id;
LOCAL_top_cp = B_BASE; LOCAL_top_cp = B_BASE;
LOCAL_top_or_fr = GLOBAL_root_or_fr; LOCAL_top_or_fr = GLOBAL_root_or_fr;
LOCAL_load = 0; LOCAL_load = 0;

35
OPTYap/opt.macros.h
View File

@ -2,7 +2,7 @@
** Memory management ** ** Memory management **
** --------------------------- */ ** --------------------------- */
extern int PageSize; extern int Yap_page_size;
#define H_BASE ((CELL *) Yap_GlobalBase) #define H_BASE ((CELL *) Yap_GlobalBase)
#define B_BASE ((choiceptr) Yap_LocalBase) #define B_BASE ((choiceptr) Yap_LocalBase)
@ -20,9 +20,9 @@ extern int PageSize;
#endif /* SIZEOF_INT_P */ #endif /* SIZEOF_INT_P */
#define ADJUST_SIZE(SIZE) ((SIZE + ALIGN) & ALIGNMASK) #define ADJUST_SIZE(SIZE) ((SIZE + ALIGN) & ALIGNMASK)
#define ADJUST_SIZE_TO_PAGE(SIZE) ((SIZE) - (SIZE) % PageSize + PageSize) #define ADJUST_SIZE_TO_PAGE(SIZE) ((SIZE) - (SIZE) % Yap_page_size + Yap_page_size)
#define STRUCT_SIZE(STR_TYPE) ADJUST_SIZE(sizeof(STR_TYPE)) #define STRUCT_SIZE(STR_TYPE) ADJUST_SIZE(sizeof(STR_TYPE))
#define PAGE_HEADER(STR) (pg_hd_ptr)((unsigned int)STR - (unsigned int)STR % PageSize) #define PAGE_HEADER(STR) (pg_hd_ptr)((unsigned int)STR - (unsigned int)STR % Yap_page_size)
#define STRUCT_NEXT(STR) ((STR)->next) #define STRUCT_NEXT(STR) ((STR)->next)
@ -52,20 +52,13 @@ extern int PageSize;
#define FREE_HASH_BUCKETS(BUCKET_PTR) FREE_BLOCK(BUCKET_PTR) #define FREE_HASH_BUCKETS(BUCKET_PTR) FREE_BLOCK(BUCKET_PTR)
#ifdef USE_HEAP #ifdef USE_HEAP
#define ALLOC_STRUCT(STR, STR_PAGES, STR_TYPE) \
#define alloc_memory_block(SIZE) (void *)Yap_AllocCodeSpace(SIZE) STR = (STR_TYPE *)Yap_AllocCodeSpace(sizeof(STR_TYPE))
#define free_memory_block(BLK) Yap_FreeCodeSpace((ADDR)BLK) #define ALLOC_NEXT_FREE_STRUCT(STR, STR_PAGES, STR_TYPE) \
#define reset_alloc_block_area() STR = (STR_TYPE *)Yap_AllocCodeSpace(sizeof(STR_TYPE))
#define FREE_STRUCT(STR, STR_PAGES, STR_TYPE) \
#define ALLOC_STRUCT(STR, STR_PAGES, STR_TYPE) STR = (STR_TYPE *)Yap_AllocCodeSpace(sizeof(STR_TYPE)) Yap_FreeCodeSpace((ADDR)(STR))
#define ALLOC_NEXT_FREE_STRUCT(STR, STR_PAGES, STR_TYPE) STR = (STR_TYPE *)Yap_AllocCodeSpace(sizeof(STR_TYPE))
#define FREE_STRUCT(STR, STR_PAGES, STR_TYPE) Yap_FreeCodeSpace((ADDR)(STR))
#else #else
#define ALLOC_PAGE(PG_HD) \ #define ALLOC_PAGE(PG_HD) \
LOCK(Pg_lock(GLOBAL_PAGES_void)); \ LOCK(Pg_lock(GLOBAL_PAGES_void)); \
UPDATE_STATS(Pg_requests(GLOBAL_PAGES_void), 1); \ UPDATE_STATS(Pg_requests(GLOBAL_PAGES_void), 1); \
@ -75,7 +68,7 @@ extern int PageSize;
abort_optyap("no more free alloc space (ALLOC_PAGE)"); \ abort_optyap("no more free alloc space (ALLOC_PAGE)"); \
UPDATE_STATS(Pg_str_alloc(GLOBAL_PAGES_void), 1); \ UPDATE_STATS(Pg_str_alloc(GLOBAL_PAGES_void), 1); \
PG_HD = (pg_hd_ptr)TopAllocArea; \ PG_HD = (pg_hd_ptr)TopAllocArea; \
TopAllocArea += PageSize; \ TopAllocArea += Yap_page_size \
} else { \ } else { \
PG_HD = Pg_free_pg(GLOBAL_PAGES_void); \ PG_HD = Pg_free_pg(GLOBAL_PAGES_void); \
Pg_free_pg(GLOBAL_PAGES_void) = PgHd_next(PG_HD); \ Pg_free_pg(GLOBAL_PAGES_void) = PgHd_next(PG_HD); \
@ -90,8 +83,6 @@ extern int PageSize;
Pg_free_pg(GLOBAL_PAGES_void) = PG_HD; \ Pg_free_pg(GLOBAL_PAGES_void) = PG_HD; \
UNLOCK(Pg_lock(GLOBAL_PAGES_void)) UNLOCK(Pg_lock(GLOBAL_PAGES_void))
#define ALLOC_STRUCT(STR, STR_PAGES, STR_TYPE) \ #define ALLOC_STRUCT(STR, STR_PAGES, STR_TYPE) \
{ pg_hd_ptr pg_hd; \ { pg_hd_ptr pg_hd; \
LOCK(Pg_lock(STR_PAGES)); \ LOCK(Pg_lock(STR_PAGES)); \
@ -102,7 +93,8 @@ extern int PageSize;
PgHd_str_in_use(pg_hd)++; \ PgHd_str_in_use(pg_hd)++; \
STR = (STR_TYPE *) PgHd_free_str(pg_hd); \ STR = (STR_TYPE *) PgHd_free_str(pg_hd); \
if ((PgHd_free_str(pg_hd) = (void *) STRUCT_NEXT(STR)) == NULL) \ if ((PgHd_free_str(pg_hd) = (void *) STRUCT_NEXT(STR)) == NULL) \
Pg_free_pg(STR_PAGES) = PgHd_next(pg_hd); \ if ((Pg_free_pg(STR_PAGES) = PgHd_next(pg_hd)) != NULL) \
PgHd_previous(PgHd_next(pg_hd)) = NULL; \
UNLOCK(Pg_lock(STR_PAGES)); \ UNLOCK(Pg_lock(STR_PAGES)); \
} else { \ } else { \
int i; \ int i; \
@ -192,8 +184,7 @@ extern int PageSize;
UNLOCK(Pg_lock(STR_PAGES)); \ UNLOCK(Pg_lock(STR_PAGES)); \
} \ } \
} }
#endif /* USE_HEAP */
#endif /* TEST*/
#define ALLOC_OR_FRAME(STR) ALLOC_STRUCT(STR, GLOBAL_PAGES_or_fr, struct or_frame) #define ALLOC_OR_FRAME(STR) ALLOC_STRUCT(STR, GLOBAL_PAGES_or_fr, struct or_frame)

3
OPTYap/opt.mavar.h
View File

@ -1,4 +1,3 @@
#ifdef MULTI_ASSIGNMENT_VARIABLES #ifdef MULTI_ASSIGNMENT_VARIABLES
/* /*
Set of routines to allow restoring updatable variables when we go *up* Set of routines to allow restoring updatable variables when we go *up*
@ -91,4 +90,4 @@ NEW_MAHASH(ma_h_inner_struct *top) {
return(time); return(time);
} }
#endif #endif /* MULTI_ASSIGNMENT_VARIABLES */

151
OPTYap/opt.memory.c
View File

@ -27,7 +27,7 @@
** -------------------------------------- */ ** -------------------------------------- */
#include "Yap.h" #include "Yap.h"
#if defined(YAPOR) || defined(TABLING) #ifdef YAPOR
#include "Yatom.h" #include "Yatom.h"
#include "Heap.h" #include "Heap.h"
#include "alloc.h" #include "alloc.h"
@ -42,86 +42,67 @@
#include <sys/shm.h> #include <sys/shm.h>
#include <sys/mman.h> #include <sys/mman.h>
#define KBYTES 1024 #define KBYTES 1024
#define HEAP_BLOCKS 1
#define OPT_BLOCKS 5
#define OPT_BLOCK_SIZE ADJUST_SIZE_TO_PAGE(10000 * KBYTES)
int PageSize;
#ifdef MMAP_MEMORY_MAPPING_SCHEME #ifdef MMAP_MEMORY_MAPPING_SCHEME
int fd_mapfile; int fd_mapfile;
#else /* SHM_MEMORY_MAPPING_SCHEME */ #else /* SHM_MEMORY_MAPPING_SCHEME */
int shm_mapid[MAX_WORKERS + HEAP_BLOCKS + OPT_BLOCKS]; int shm_mapid[MAX_WORKERS + 1];
#endif /* MEMORY_MAPPING_SCHEME */ #endif /* MEMORY_MAPPING_SCHEME */
/* --------------------------- ** /* --------------------------- **
** Global functions ** ** Global functions **
** --------------------------- */ ** --------------------------- */
long global_data_size(void) {
return ADJUST_SIZE(sizeof(struct global_data));
}
long local_data_size(void) {
return ADJUST_SIZE(sizeof(struct local_data));
}
#ifdef SHM_MEMORY_MAPPING_SCHEME #ifdef SHM_MEMORY_MAPPING_SCHEME
void shm_map_memory(int id, int size, void *shmaddr) { void shm_map_memory(int id, int size, void *shmaddr) {
#define SHMMAX 0x2000000 /* as in <asm/shmparam.h> */ #define SHMMAX 0x2000000 /* as in <asm/shmparam.h> */
if (size > SHMMAX) if (size > SHMMAX)
abort_optyap("maximum size for a shm segment exceeded in function shm_map_memory"); abort_optyap("maximum size for a shm segment exceeded in function shm_map_memory");
if ((shm_mapid[id] = shmget(IPC_PRIVATE, size, SHM_R|SHM_W)) == -1) if ((shm_mapid[id] = shmget(IPC_PRIVATE, size, SHM_R|SHM_W)) == -1)
abort_optyap("shmget error in function shm_map_memory %s", strerror(errno)); abort_optyap("shmget error in function shm_map_memory: %s", strerror(errno));
if (shmat(shm_mapid[id], shmaddr, 0) == (void *) -1) if (shmat(shm_mapid[id], shmaddr, 0) == (void *) -1)
abort_optyap("shmat error in function shm_map_memory %s", strerror(errno)); abort_optyap("shmat error in function shm_map_memory: %s", strerror(errno));
return; return;
} }
#else /* MMAP_MEMORY_MAPPING_SCHEME */ #else /* MMAP_MEMORY_MAPPING_SCHEME */
static void
open_mapfile(long TotalArea) { open_mapfile(long TotalArea) {
char mapfile[20]; char mapfile[20];
strcpy(mapfile,"/tmp/mapfile"); strcpy(mapfile,"/tmp/mapfile");
itos(getpid(), &mapfile[12]); itos(getpid(), &mapfile[12]);
if ((fd_mapfile = open(mapfile, O_RDWR|O_CREAT|O_TRUNC, 0666)) < 0) if ((fd_mapfile = open(mapfile, O_RDWR|O_CREAT|O_TRUNC, 0666)) < 0)
abort_optyap("open error in function open_mapfile %s", strerror(errno)); abort_optyap("open error in function open_mapfile: %s", strerror(errno));
if (lseek(fd_mapfile, TotalArea, SEEK_SET) < 0) if (lseek(fd_mapfile, TotalArea, SEEK_SET) < 0)
abort_optyap("lseek error in function map_memory: %s", strerror(errno)); abort_optyap("lseek error in function open_mapfile: %s", strerror(errno));
if (write(fd_mapfile, "", 1) < 0) if (write(fd_mapfile, "", 1) < 0)
abort_optyap("write error in function map_memory: %s", strerror(errno)); abort_optyap("write error in function open_mapfile: %s", strerror(errno));
return; return;
} }
static void
close_mapfile(void) { close_mapfile(void) {
if (close(fd_mapfile) < 0) if (close(fd_mapfile) < 0)
abort_optyap("close error in function open_mapfile %s", strerror(errno)); abort_optyap("close error in function close_mapfile: %s", strerror(errno));
} }
#endif /* MMAP_MEMORY_MAPPING_SCHEME */ #endif /* MMAP_MEMORY_MAPPING_SCHEME */
void map_memory(long HeapArea, long GlobalLocalArea, long TrailAuxArea, int n_workers) { void map_memory(long HeapArea, long GlobalLocalArea, long TrailAuxArea, int n_workers) {
#ifndef ACOW
#ifdef YAPOR
int i;
#endif /* YAPOR */
long WorkerArea;
long TotalArea;
#else
#if MMAP_MEMORY_MAPPING_SCHEME
long TotalArea;
#endif
#endif
void *mmap_addr = (void *)MMAP_ADDR; void *mmap_addr = (void *)MMAP_ADDR;
#ifdef ACOW #ifdef ACOW
int private_fd_mapfile; int private_fd_mapfile;
#endif /* ACOW */ #if MMAP_MEMORY_MAPPING_SCHEME
long TotalArea;
#endif /* MMAP_MEMORY_MAPPING_SCHEME */
#else /* ENV_COPY || SBA */
int i;
long WorkerArea;
long TotalArea;
#endif /* YAPOR_MODEL */
/* Initial Allocation */ /* initial allocation - model independent */
/* model indepndent */
PageSize = sysconf(_SC_PAGESIZE);
HeapArea = ADJUST_SIZE_TO_PAGE(HeapArea * KBYTES); HeapArea = ADJUST_SIZE_TO_PAGE(HeapArea * KBYTES);
GlobalLocalArea = ADJUST_SIZE(GlobalLocalArea * KBYTES); GlobalLocalArea = ADJUST_SIZE(GlobalLocalArea * KBYTES);
TrailAuxArea = ADJUST_SIZE(TrailAuxArea * KBYTES); TrailAuxArea = ADJUST_SIZE(TrailAuxArea * KBYTES);
@ -129,41 +110,37 @@ void map_memory(long HeapArea, long GlobalLocalArea, long TrailAuxArea, int n_wo
/* we'll need this later */ /* we'll need this later */
Yap_GlobalBase = mmap_addr + HeapArea; Yap_GlobalBase = mmap_addr + HeapArea;
/* model dependent */ /* shared memory allocation - model dependent */
/* shared memory allocation */
#ifdef ACOW #ifdef ACOW
/* acow just needs one stack */ /* acow just needs one stack */
#ifdef MMAP_MEMORY_MAPPING_SCHEME #ifdef MMAP_MEMORY_MAPPING_SCHEME
/* I need this for MMAP to know what it must allocate */ /* I need this for MMAP to know what it must allocate */
TotalArea = HeapArea; TotalArea = HeapArea;
#endif #endif /* MMAP_MEMORY_MAPPING_SCHEME */
#else #else /* ENV_COPY || SBA */
/* the others need n stacks */ /* the others need n stacks */
WorkerArea = ADJUST_SIZE_TO_PAGE(GlobalLocalArea + TrailAuxArea); WorkerArea = ADJUST_SIZE_TO_PAGE(GlobalLocalArea + TrailAuxArea);
TotalArea = HeapArea + WorkerArea * n_workers; TotalArea = HeapArea + WorkerArea * n_workers;
#endif /* ACOW */ #endif /* YAPOR_MODEL */
/* step 2: mmap heap area */ /* mmap heap area */
#ifdef MMAP_MEMORY_MAPPING_SCHEME #ifdef MMAP_MEMORY_MAPPING_SCHEME
/* map total area in a single go */ /* map total area in a single go */
open_mapfile(TotalArea); open_mapfile(TotalArea);
if ((mmap_addr = mmap((void *) MMAP_ADDR, (size_t) TotalArea, PROT_READ|PROT_WRITE, if ((mmap_addr = mmap((void *) MMAP_ADDR, (size_t) TotalArea, PROT_READ|PROT_WRITE,
MAP_SHARED|MAP_FIXED, fd_mapfile, 0)) == (void *) -1) MAP_SHARED|MAP_FIXED, fd_mapfile, 0)) == (void *) -1)
abort_optyap("mmap error in function map_memory: %s", strerror(errno)); abort_optyap("mmap error in function map_memory: %s", strerror(errno));
#endif /* MEMORY_MAPPING_SCHEME */ #else /* SHM_MEMORY_MAPPING_SCHEME */
/* Most systems are limited regarding what we can allocate */ /* Most systems are limited regarding what we can allocate */
#ifdef SHM_MEMORY_MAPPING_SCHEME
#ifdef ACOW #ifdef ACOW
/* single shared segment in ACOW */ /* single shared segment in ACOW */
shm_map_memory(0, HeapArea, mmap_addr); shm_map_memory(0, HeapArea, mmap_addr);
#else #else /* ENV_COPY || SBA */
/* place as segment n otherwise (0..n-1 reserved for stacks */ /* place as segment n otherwise (0..n-1 reserved for worker areas */
shm_map_memory(n_workers, HeapArea, mmap_addr); shm_map_memory(n_workers, HeapArea, mmap_addr);
#endif #endif /* YAPOR_MODEL */
#endif #endif /* MEMORY_MAPPING_SCHEME */
#ifdef YAPOR
#ifdef ACOW #ifdef ACOW
/* just allocate local space for stacks */ /* just allocate local space for stacks */
if ((private_fd_mapfile = open("/dev/zero", O_RDWR)) < 0) if ((private_fd_mapfile = open("/dev/zero", O_RDWR)) < 0)
@ -172,7 +149,7 @@ void map_memory(long HeapArea, long GlobalLocalArea, long TrailAuxArea, int n_wo
MAP_PRIVATE|MAP_FIXED, private_fd_mapfile, 0) == (void *) -1) MAP_PRIVATE|MAP_FIXED, private_fd_mapfile, 0) == (void *) -1)
abort_optyap("mmap error in function map_memory: %s", strerror(errno)); abort_optyap("mmap error in function map_memory: %s", strerror(errno));
close(private_fd_mapfile); close(private_fd_mapfile);
#else /* ENV_COPY or SBA */ #else /* ENV_COPY || SBA */
for (i = 0; i < n_workers; i++) { for (i = 0; i < n_workers; i++) {
/* initialize worker vars */ /* initialize worker vars */
worker_area(i) = Yap_GlobalBase + i * WorkerArea; worker_area(i) = Yap_GlobalBase + i * WorkerArea;
@ -182,14 +159,7 @@ void map_memory(long HeapArea, long GlobalLocalArea, long TrailAuxArea, int n_wo
shm_map_memory(i, WorkerArea, worker_area(i)); shm_map_memory(i, WorkerArea, worker_area(i));
#endif /* SHM_MEMORY_MAPPING_SCHEME */ #endif /* SHM_MEMORY_MAPPING_SCHEME */
} }
#endif /* ACOW */ #endif /* YAPOR_MODEL */
#else /* TABLING */
#ifdef SHM_MEMORY_MAPPING_SCHEME
/* mapping worker area */
shm_map_memory(0, WorkerArea, mmap_addr + HeapArea);
#endif /* SHM_MEMORY_MAPPING_SCHEME */
#endif /* YAPOR */
#ifdef SBA #ifdef SBA
/* alloc space for the sparse binding array */ /* alloc space for the sparse binding array */
@ -226,8 +196,6 @@ void unmap_memory (void) {
#else /* MMAP_MEMORY_MAPPING_SCHEME */ #else /* MMAP_MEMORY_MAPPING_SCHEME */
char MapFile[20]; char MapFile[20];
#endif /* MEMORY_MAPPING_SCHEME */ #endif /* MEMORY_MAPPING_SCHEME */
#ifdef YAPOR
{ {
int proc; int proc;
for (proc = 0; proc < number_workers; proc++) { for (proc = 0; proc < number_workers; proc++) {
@ -247,18 +215,13 @@ void unmap_memory (void) {
} }
#endif /* ACOW */ #endif /* ACOW */
} }
#endif /* YAPOR */
#ifdef SHM_MEMORY_MAPPING_SCHEME #ifdef SHM_MEMORY_MAPPING_SCHEME
#ifdef YAPOR
#ifdef ACOW #ifdef ACOW
i = 0; i = 0;
#else #else
for (i = 0; i < number_workers + 1; i++) for (i = 0; i < number_workers + 1; i++)
#endif #endif /* ACOW */
#else /* TABLING */
for (i = 0; i < 1 + 2; i++)
#endif /* YAPOR */
{ {
if (shmctl(shm_mapid[i], IPC_RMID, 0) == 0) if (shmctl(shm_mapid[i], IPC_RMID, 0) == 0)
INFORMATION_MESSAGE("Removing shared memory segment %d", shm_mapid[i]); INFORMATION_MESSAGE("Removing shared memory segment %d", shm_mapid[i]);
@ -266,15 +229,11 @@ void unmap_memory (void) {
} }
#else /* MMAP_MEMORY_MAPPING_SCHEME */ #else /* MMAP_MEMORY_MAPPING_SCHEME */
strcpy(MapFile,"/tmp/mapfile"); strcpy(MapFile,"/tmp/mapfile");
#ifdef YAPOR
#ifdef ACOW #ifdef ACOW
itos(GLOBAL_master_worker, &MapFile[12]); itos(GLOBAL_master_worker, &MapFile[12]);
#else /* ENV_COPY || SBA */ #else /* ENV_COPY || SBA */
itos(worker_pid(0), &MapFile[12]); itos(worker_pid(0), &MapFile[12]);
#endif #endif
#else /* TABLING */
itos(getpid(), &MapFile[12]);
#endif /* YAPOR */
if (remove(MapFile) == 0) if (remove(MapFile) == 0)
INFORMATION_MESSAGE("Removing mapfile \"%s\"", MapFile); INFORMATION_MESSAGE("Removing mapfile \"%s\"", MapFile);
else INFORMATION_MESSAGE("Can't remove mapfile \"%s\"", MapFile); else INFORMATION_MESSAGE("Can't remove mapfile \"%s\"", MapFile);
@ -283,7 +242,6 @@ void unmap_memory (void) {
} }
#ifdef YAPOR
void remap_memory(void) { void remap_memory(void) {
#ifdef ACOW #ifdef ACOW
/* do nothing */ /* do nothing */
@ -334,44 +292,3 @@ void remap_memory(void) {
#endif /* ENV_COPY */ #endif /* ENV_COPY */
} }
#endif /* YAPOR */ #endif /* YAPOR */
#ifdef DEAD_CODE
This code is pretty much dead, the idea is to allocate large memory
blocks from the Heap.
void *alloc_memory_block(int size) {
void *block;
LOCK(Pg_lock(GLOBAL_PAGES_void));
#if USE_HEAP_FOR_ALLOC_MEMORY_BLOCKS
block = (void *) AllocCodeSpace(size);
#else
if (size > TopAllocBlockArea - TopAllocArea)
abort_optyap("no more free alloc space (alloc_memory_block)");
TopAllocBlockArea -= size;
block = TopAllocBlockArea;
#endif /* USE_HEAP_FOR_ALLOC_MEMORY_BLOCKS */
UNLOCK(Pg_lock(GLOBAL_PAGES_void));
return block;
}
void free_memory_block(void *block) {
#if USE_HEAP_FOR_ALLOC_MEMORY_BLOCKS
LOCK(Pg_lock(GLOBAL_PAGES_void));
Yap_FreeCodeSpace((char *) block);
UNLOCK(Pg_lock(GLOBAL_PAGES_void));
#endif /* USE_HEAP_FOR_ALLOC_MEMORY_BLOCKS */
}
void reset_alloc_block_area(void) {
#if USE_HEAP_FOR_ALLOC_MEMORY_BLOCKS
TopAllocBlockArea = BaseAllocArea+OPT_CHUNK_SIZE;
#endif /* USE_HEAP_FOR_ALLOC_MEMORY_BLOCKS */
}
#endif /* USE_HEAP */
#endif /* YAPOR || TABLING */

14
OPTYap/opt.misc.c
View File

@ -6,6 +6,7 @@
#if defined(YAPOR) || defined(TABLING) #if defined(YAPOR) || defined(TABLING)
#include <stdarg.h> #include <stdarg.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include "Yatom.h" #include "Yatom.h"
#include "yapio.h" #include "yapio.h"
#if HAVE_UNISTD_H #if HAVE_UNISTD_H
@ -21,10 +22,8 @@
** Global variables are defined here ** ** Global variables are defined here **
** ------------------------------------------- */ ** ------------------------------------------- */
struct global_data *GLOBAL;
struct local_data *LOCAL; struct local_data *LOCAL;
#ifdef YAPOR #ifdef YAPOR
struct local_data *REMOTE[MAX_WORKERS];
struct worker WORKER; struct worker WORKER;
#endif /* YAPOR */ #endif /* YAPOR */
@ -48,7 +47,7 @@ void abort_optyap(const char *msg, ...) {
#ifdef YAPOR #ifdef YAPOR
unmap_memory(); unmap_memory();
#endif #endif /* YAPOR */
exit (1); exit (1);
} }
@ -77,16 +76,7 @@ void information_message(const char *mesg,...) {
fprintf(stderr, " ]\n"); fprintf(stderr, " ]\n");
return; return;
} }
/* ------------------------- **
** Local functions **
** ------------------------- */
int tabling_putchar(int sno, int ch) {
return(putc(ch, stderr));
}
#endif /* TABLING_DEBUG */
#ifdef YAPOR
#if defined(YAPOR_ERRORS) || defined(TABLING_ERRORS) #if defined(YAPOR_ERRORS) || defined(TABLING_ERRORS)
void error_message(const char *mesg, ...) { void error_message(const char *mesg, ...) {

179
OPTYap/opt.preds.c
View File

@ -35,12 +35,12 @@ static qg_ans_fr_ptr actual_answer;
** Local functions declaration ** ** Local functions declaration **
** ------------------------------------- */ ** ------------------------------------- */
static int p_default_sequential(void);
#ifdef YAPOR #ifdef YAPOR
static realtime current_time(void); static realtime current_time(void);
static int yapor_on(void); static int yapor_on(void);
static int start_yapor(void); static int start_yapor(void);
static int p_sequential(void); static int p_sequential(void);
static int p_default_sequential(void);
static int p_execution_mode(void); static int p_execution_mode(void);
static int p_performance(void); static int p_performance(void);
static int p_parallel_new_answer(void); static int p_parallel_new_answer(void);
@ -69,27 +69,27 @@ static int p_debug_prolog(void);
** -------------------------- */ ** -------------------------- */
void Yap_init_optyap_preds(void) { void Yap_init_optyap_preds(void) {
Yap_InitCPred("$default_sequential", 1, p_default_sequential, SafePredFlag);
#ifdef YAPOR #ifdef YAPOR
Yap_InitCPred("$yapor_on", 0, yapor_on, SafePredFlag); Yap_InitCPred("$yapor_on", 0, yapor_on, SafePredFlag|SyncPredFlag);
Yap_InitCPred("$start_yapor", 0, start_yapor, SafePredFlag); Yap_InitCPred("$start_yapor", 0, start_yapor, SafePredFlag|SyncPredFlag);
Yap_InitCPred("$sequential", 1, p_sequential, SafePredFlag); Yap_InitCPred("$sequential", 1, p_sequential, SafePredFlag|SyncPredFlag);
Yap_InitCPred("execution_mode", 1, p_execution_mode, SafePredFlag); Yap_InitCPred("$default_sequential", 1, p_default_sequential, SafePredFlag|SyncPredFlag);
Yap_InitCPred("performance", 1, p_performance, SafePredFlag); Yap_InitCPred("execution_mode", 1, p_execution_mode, SafePredFlag|SyncPredFlag);
Yap_InitCPred("$parallel_new_answer", 1, p_parallel_new_answer, SafePredFlag); Yap_InitCPred("performance", 1, p_performance, SafePredFlag|SyncPredFlag);
Yap_InitCPred("$parallel_yes_answer", 0, p_parallel_yes_answer, SafePredFlag); Yap_InitCPred("$parallel_new_answer", 1, p_parallel_new_answer, SafePredFlag|SyncPredFlag);
Yap_InitCPred("$parallel_yes_answer", 0, p_parallel_yes_answer, SafePredFlag|SyncPredFlag);
#endif /* YAPOR */ #endif /* YAPOR */
#ifdef TABLING #ifdef TABLING
Yap_InitCPred("$do_table", 2, p_table, SafePredFlag); Yap_InitCPred("$do_table", 2, p_table, SafePredFlag|SyncPredFlag);
Yap_InitCPred("$do_abolish_trie", 2, p_abolish_trie, SafePredFlag); Yap_InitCPred("$do_abolish_trie", 2, p_abolish_trie, SafePredFlag|SyncPredFlag);
Yap_InitCPred("$show_trie", 3, p_show_trie, SafePredFlag); Yap_InitCPred("$show_trie", 3, p_show_trie, SafePredFlag|SyncPredFlag);
Yap_InitCPred("$resume_trie", 2, p_resume_trie, SafePredFlag); Yap_InitCPred("$resume_trie", 2, p_resume_trie, SafePredFlag|SyncPredFlag);
#endif /* TABLING */ #endif /* TABLING */
#ifdef STATISTICS #ifdef STATISTICS
Yap_InitCPred("show_frames", 0, p_show_frames, SafePredFlag); Yap_InitCPred("show_frames", 0, p_show_frames, SafePredFlag|SyncPredFlag);
#endif /* STATISTICS */ #endif /* STATISTICS */
#if defined(YAPOR_ERRORS) || defined(TABLING_ERRORS) #if defined(YAPOR_ERRORS) || defined(TABLING_ERRORS)
Yap_InitCPred("debug_prolog", 1, p_debug_prolog, SafePredFlag); Yap_InitCPred("debug_prolog", 1, p_debug_prolog, SafePredFlag|SyncPredFlag);
#endif /* YAPOR_ERRORS || TABLING_ERRORS */ #endif /* YAPOR_ERRORS || TABLING_ERRORS */
} }
@ -108,39 +108,6 @@ void finish_yapor(void) {
** Local functions ** ** Local functions **
** ------------------------- */ ** ------------------------- */
static
int p_default_sequential(void) {
#ifdef YAPOR
Term t;
t = Deref(ARG1);
if (IsVarTerm(t)) {
Term ta;
if (SEQUENTIAL_IS_DEFAULT)
ta = MkAtomTerm(Yap_LookupAtom("on"));
else
ta = MkAtomTerm(Yap_LookupAtom("off"));
Bind((CELL *)t, ta);
return(TRUE);
}
if (IsAtomTerm(t)) {
char *s;
s = RepAtom(AtomOfTerm(t))->StrOfAE;
if (strcmp(s, "on") == 0) {
SEQUENTIAL_IS_DEFAULT = TRUE;
return(TRUE);
}
if (strcmp(s,"off") == 0) {
SEQUENTIAL_IS_DEFAULT = FALSE;
return(TRUE);
}
}
return(FALSE);
#else
return(TRUE);
#endif
}
#ifdef YAPOR #ifdef YAPOR
static static
realtime current_time(void) { realtime current_time(void) {
@ -182,32 +149,26 @@ int start_yapor(void) {
} }
static static
int p_sequential(void) { int p_sequential(void) {
Term t, tmod; Term t, tmod;
Atom at;
int arity;
PredEntry *pe;
SMALLUNSGN mod; SMALLUNSGN mod;
PredEntry *pe;
t = Deref(ARG1);
tmod = Deref(ARG2); tmod = Deref(ARG2);
if (IsVarTerm(tmod) || !IsAtomTerm(tmod)) { if (IsVarTerm(tmod) || !IsAtomTerm(tmod)) {
return(FALSE); return(FALSE);
} else {
mod = Yap_LookupModule(tmod);
} }
mod = Yap_LookupModule(tmod); t = Deref(ARG1);
if (IsAtomTerm(t)) { if (IsAtomTerm(t)) {
at = AtomOfTerm(t); Atom at = AtomOfTerm(t);
arity = 0;
pe = RepPredProp(PredPropByAtom(at, mod)); pe = RepPredProp(PredPropByAtom(at, mod));
} else if (IsApplTerm(t)) { } else if (IsApplTerm(t)) {
Functor func = FunctorOfTerm(t); Functor func = FunctorOfTerm(t);
at = NameOfFunctor(func);
arity = ArityOfFunctor(func);
pe = RepPredProp(PredPropByFunc(func, mod)); pe = RepPredProp(PredPropByFunc(func, mod));
} else { } else {
abort_optyap("unknown term in function p_sequential");
return(FALSE); return(FALSE);
} }
pe->PredFlags |= SequentialPredFlag; pe->PredFlags |= SequentialPredFlag;
@ -215,6 +176,35 @@ int p_sequential(void) {
} }
static
int p_default_sequential(void) {
Term t;
t = Deref(ARG1);
if (IsVarTerm(t)) {
Term ta;
if (SEQUENTIAL_IS_DEFAULT)
ta = MkAtomTerm(Yap_LookupAtom("on"));
else
ta = MkAtomTerm(Yap_LookupAtom("off"));
Bind((CELL *)t, ta);
return(TRUE);
}
if (IsAtomTerm(t)) {
char *s;
s = RepAtom(AtomOfTerm(t))->StrOfAE;
if (strcmp(s, "on") == 0) {
SEQUENTIAL_IS_DEFAULT = TRUE;
return(TRUE);
}
if (strcmp(s,"off") == 0) {
SEQUENTIAL_IS_DEFAULT = FALSE;
return(TRUE);
}
}
return(FALSE);
}
static static
int p_execution_mode(void) { int p_execution_mode(void) {
Term t; Term t;
@ -457,33 +447,32 @@ void answer_to_stdout(char *answer) {
#ifdef TABLING #ifdef TABLING
static static
int p_table(void) { int p_table(void) {
Term t, t2; Term t, tmod;
SMALLUNSGN mod;
PredEntry *pe; PredEntry *pe;
tab_ent_ptr te; tab_ent_ptr te;
sg_node_ptr sg_node; sg_node_ptr sg_node;
SMALLUNSGN mod;
t = Deref(ARG1); tmod = Deref(ARG2);
t2 = Deref(ARG2); if (IsVarTerm(tmod) || !IsAtomTerm(tmod)) {
if (IsVarTerm(t2) || !IsAtomTerm(t2)) {
return (FALSE); return (FALSE);
} else { } else {
mod = Yap_LookupModule(t2); mod = Yap_LookupModule(tmod);
} }
t = Deref(ARG1);
if (IsAtomTerm(t)) { if (IsAtomTerm(t)) {
Atom at = AtomOfTerm(t); Atom at = AtomOfTerm(t);
pe = RepPredProp(PredPropByAtom(at, mod)); pe = RepPredProp(PredPropByAtom(at, mod));
} else if (IsApplTerm(t)) { } else if (IsApplTerm(t)) {
Functor func = FunctorOfTerm(t); Functor func = FunctorOfTerm(t);
pe = RepPredProp(PredPropByFunc(func, mod)); pe = RepPredProp(PredPropByFunc(func, mod));
} else } else {
return (FALSE); return (FALSE);
}
pe->PredFlags |= TabledPredFlag; pe->PredFlags |= TabledPredFlag;
new_subgoal_trie_node(sg_node, 0, NULL, NULL, NULL); new_subgoal_trie_node(sg_node, 0, NULL, NULL, NULL);
new_table_entry(te, sg_node); new_table_entry(te, sg_node);
pe->TableOfPred = te; pe->TableOfPred = te;
return (TRUE); return (TRUE);
} }
@ -497,13 +486,13 @@ int p_abolish_trie(void) {
sg_node_ptr sg_node; sg_node_ptr sg_node;
UInt arity; UInt arity;
t = Deref(ARG1);
tmod = Deref(ARG2); tmod = Deref(ARG2);
if (IsVarTerm(tmod) || !IsAtomTerm(tmod)) { if (IsVarTerm(tmod) || !IsAtomTerm(tmod)) {
return (FALSE); return (FALSE);
} else { } else {
mod = Yap_LookupModule(tmod); mod = Yap_LookupModule(tmod);
} }
t = Deref(ARG1);
if (IsAtomTerm(t)) { if (IsAtomTerm(t)) {
Atom at = AtomOfTerm(t); Atom at = AtomOfTerm(t);
tab_ent = RepPredProp(PredPropByAtom(at, mod))->TableOfPred; tab_ent = RepPredProp(PredPropByAtom(at, mod))->TableOfPred;
@ -512,9 +501,9 @@ int p_abolish_trie(void) {
Functor func = FunctorOfTerm(t); Functor func = FunctorOfTerm(t);
tab_ent = RepPredProp(PredPropByFunc(func, mod))->TableOfPred; tab_ent = RepPredProp(PredPropByFunc(func, mod))->TableOfPred;
arity = ArityOfFunctor(func); arity = ArityOfFunctor(func);
} else } else {
return (FALSE); return (FALSE);
}
hash = TabEnt_hash_chain(tab_ent); hash = TabEnt_hash_chain(tab_ent);
TabEnt_hash_chain(tab_ent) = NULL; TabEnt_hash_chain(tab_ent) = NULL;
free_subgoal_hash_chain(hash); free_subgoal_hash_chain(hash);
@ -523,7 +512,6 @@ int p_abolish_trie(void) {
TrNode_child(TabEnt_subgoal_trie(tab_ent)) = NULL; TrNode_child(TabEnt_subgoal_trie(tab_ent)) = NULL;
free_subgoal_trie_branch(sg_node, arity); free_subgoal_trie_branch(sg_node, arity);
} }
return (TRUE); return (TRUE);
} }
@ -531,30 +519,30 @@ int p_abolish_trie(void) {
static static
int p_show_trie(void) { int p_show_trie(void) {
Term t1, t2, tmod; Term t1, t2, tmod;
PredEntry *pe;
SMALLUNSGN mod; SMALLUNSGN mod;
PredEntry *pe;
Atom at; Atom at;
UInt arity; UInt arity;
t1 = Deref(ARG1);
tmod = Deref(ARG2); tmod = Deref(ARG2);
if (IsVarTerm(tmod) || !IsAtomTerm(tmod)) { if (IsVarTerm(tmod) || !IsAtomTerm(tmod)) {
return (FALSE); return (FALSE);
} else { } else {
mod = Yap_LookupModule(tmod); mod = Yap_LookupModule(tmod);
} }
t1 = Deref(ARG1);
if (IsAtomTerm(t1)) { if (IsAtomTerm(t1)) {
at = AtomOfTerm(t1); at = AtomOfTerm(t1);
arity = 0;
pe = RepPredProp(PredPropByAtom(at, mod)); pe = RepPredProp(PredPropByAtom(at, mod));
arity = 0;
} else if (IsApplTerm(t1)) { } else if (IsApplTerm(t1)) {
Functor func = FunctorOfTerm(t1); Functor func = FunctorOfTerm(t1);
at = NameOfFunctor(func); at = NameOfFunctor(func);
arity = ArityOfFunctor(func);
pe = RepPredProp(PredPropByFunc(func, mod)); pe = RepPredProp(PredPropByFunc(func, mod));
} else arity = ArityOfFunctor(func);
} else {
return (FALSE); return (FALSE);
}
t2 = Deref(ARG3); t2 = Deref(ARG3);
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
Term ta = MkAtomTerm(Yap_LookupAtom("stdout")); Term ta = MkAtomTerm(Yap_LookupAtom("stdout"));
@ -567,39 +555,40 @@ int p_show_trie(void) {
abort_optyap("fopen error in function p_show_trie"); abort_optyap("fopen error in function p_show_trie");
traverse_trie(file, TrNode_child(TabEnt_subgoal_trie(pe->TableOfPred)), arity, at, TRUE); traverse_trie(file, TrNode_child(TabEnt_subgoal_trie(pe->TableOfPred)), arity, at, TRUE);
fclose(file); fclose(file);
} else } else {
return(FALSE); return(FALSE);
}
return (TRUE); return (TRUE);
} }
static static
int p_resume_trie(void) { int p_resume_trie(void) {
Term t1; Term t, tmod;
SMALLUNSGN mod;
PredEntry *pe;
Atom at; Atom at;
int arity; int arity;
PredEntry *pe;
Term tmod = Deref(ARG2);
SMALLUNSGN mod;
if (IsVarTerm(tmod) || !IsAtomTerm(tmod)) { tmod = Deref(ARG2);
if (IsVarTerm(tmod) || !IsAtomTerm(tmod)) {
return (FALSE); return (FALSE);
} else { } else {
mod = Yap_LookupModule(tmod); mod = Yap_LookupModule(tmod);
} }
t1 = Deref(ARG1); t = Deref(ARG1);
if (IsAtomTerm(t1)) { if (IsAtomTerm(t)) {
at = AtomOfTerm(t1); at = AtomOfTerm(t);
arity = 0;
pe = RepPredProp(PredPropByAtom(at, mod)); pe = RepPredProp(PredPropByAtom(at, mod));
} else if (IsApplTerm(t1)) { arity = 0;
Functor func = FunctorOfTerm(t1); } else if (IsApplTerm(t)) {
Functor func = FunctorOfTerm(t);
at = NameOfFunctor(func); at = NameOfFunctor(func);
arity = ArityOfFunctor(func);
pe = RepPredProp(PredPropByFunc(func, mod)); pe = RepPredProp(PredPropByFunc(func, mod));
} else arity = ArityOfFunctor(func);
} else {
return(FALSE); return(FALSE);
}
traverse_trie(stdout, TrNode_child(TabEnt_subgoal_trie(pe->TableOfPred)), arity, at, FALSE); traverse_trie(stdout, TrNode_child(TabEnt_subgoal_trie(pe->TableOfPred)), arity, at, FALSE);
return (TRUE); return (TRUE);
} }
@ -862,7 +851,7 @@ int p_show_frames(void) {
} }
fprintf(stdout, " %s[%ld] Pages: In Use %ld - Free %ld (%ld Accesses)\n]\n\n", fprintf(stdout, " %s[%ld] Pages: In Use %ld - Free %ld (%ld Accesses)\n]\n\n",
(Pg_str_alloc(GLOBAL_PAGES_void) - Pg_str_in_use(GLOBAL_PAGES_void) == cont && (Pg_str_alloc(GLOBAL_PAGES_void) - Pg_str_in_use(GLOBAL_PAGES_void) == cont &&
TopAllocArea - BaseAllocArea == PageSize * Pg_str_alloc(GLOBAL_PAGES_void) && TopAllocArea - BaseAllocArea == Yap_page_size * Pg_str_alloc(GLOBAL_PAGES_void) &&
Pg_str_in_use(GLOBAL_PAGES_void) == pages) ? " ": "*", Pg_str_in_use(GLOBAL_PAGES_void) == pages) ? " ": "*",
Pg_str_alloc(GLOBAL_PAGES_void), Pg_str_alloc(GLOBAL_PAGES_void),
Pg_str_in_use(GLOBAL_PAGES_void), cont, Pg_requests(GLOBAL_PAGES_void)); Pg_str_in_use(GLOBAL_PAGES_void), cont, Pg_requests(GLOBAL_PAGES_void));

10
OPTYap/opt.proto.h
View File

@ -6,17 +6,15 @@
** opt.memory.c ** ** opt.memory.c **
** -------------- */ ** -------------- */
long global_data_size(void); #ifdef YAPOR
long local_data_size(void);
#ifdef SHM_MEMORY_MAPPING_SCHEME #ifdef SHM_MEMORY_MAPPING_SCHEME
void shm_map_memory(int id, int size, void *shmaddr); void shm_map_memory(int id, int size, void *shmaddr);
#else /* MMAP_MEMORY_MAPPING_SCHEME */ #else /* MMAP_MEMORY_MAPPING_SCHEME */
void open_mapfile(long); void open_mapfile(long);
#endif /* MEMORY_MAPPING_SCHEME */
void close_mapfile(void); void close_mapfile(void);
#endif /* MEMORY_MAPPING_SCHEME */
void map_memory(long HeapArea, long GlobalLocalArea, long TrailAuxArea, int n_workers); void map_memory(long HeapArea, long GlobalLocalArea, long TrailAuxArea, int n_workers);
void unmap_memory(void); void unmap_memory(void);
#ifdef YAPOR
void remap_memory(void); void remap_memory(void);
#endif /* YAPOR */ #endif /* YAPOR */
@ -50,7 +48,6 @@ void init_signals(void);
** opt.preds.c ** ** opt.preds.c **
** ------------- */ ** ------------- */
void init_optyap_preds(void);
#ifdef YAPOR #ifdef YAPOR
void finish_yapor(void); void finish_yapor(void);
#endif /* YAPOR */ #endif /* YAPOR */
@ -74,9 +71,6 @@ void private_completion(sg_fr_ptr sg_fr);
void free_subgoal_trie_branch(sg_node_ptr node, int missing_nodes); void free_subgoal_trie_branch(sg_node_ptr node, int missing_nodes);
void free_answer_trie(sg_fr_ptr sg_fr); void free_answer_trie(sg_fr_ptr sg_fr);
void update_answer_trie(sg_fr_ptr sg_fr); void update_answer_trie(sg_fr_ptr sg_fr);
void show_trie(FILE *stream, sg_node_ptr sg_node, int pred_arity, Atom pred_atom);
int show_subgoal_trie(FILE *stream, sg_node_ptr sg_node, char *str, int str_index, int *arity);
int show_answer_trie(FILE *stream, ans_node_ptr ans_node, char *str, int str_index, int *arity, int var_index);
void traverse_trie(FILE *stream, sg_node_ptr sg_node, int pred_arity, Atom pred_atom, int show); void traverse_trie(FILE *stream, sg_node_ptr sg_node, int pred_arity, Atom pred_atom, int show);
#endif /* TABLING */ #endif /* TABLING */

6
OPTYap/opt.structs.h
View File

@ -4,7 +4,11 @@
typedef double realtime; typedef double realtime;
typedef unsigned long bitmap; typedef unsigned long bitmap;
#define MAX_WORKERS (sizeof(bitmap) * 8 - 1) #ifdef YAPOR
#define MAX_WORKERS (sizeof(bitmap) * 8)
#else
#define MAX_WORKERS 1
#endif /* YAPOR */

2
OPTYap/or.cowengine.c
View File

@ -84,7 +84,7 @@ int p_share_work(void) {
share_private_nodes(worker_q); share_private_nodes(worker_q);
if ((son = fork()) == 0) { if ((son = fork()) == 0) {
worker_id = worker_q; /* child becomes requesting worker */ worker_id = worker_q; /* child becomes requesting worker */
LOCAL = REMOTE+worker_id; LOCAL = REMOTE + worker_id;
LOCAL_reply_signal = ready; LOCAL_reply_signal = ready;
PUT_IN_REQUESTABLE(worker_id); PUT_IN_REQUESTABLE(worker_id);
PUT_BUSY(worker_id); PUT_BUSY(worker_id);

8
OPTYap/or.engine.c
View File

@ -92,6 +92,7 @@ void make_root_choice_point(void) {
LOCAL_top_cp_on_stack = LOCAL_top_cp; LOCAL_top_cp_on_stack = LOCAL_top_cp;
adjust_freeze_registers(); adjust_freeze_registers();
#endif /* TABLING */ #endif /* TABLING */
return;
} }
@ -189,7 +190,6 @@ int q_share_work(int worker_p) {
/* unbind variables */ /* unbind variables */
aux_tr = LOCAL_top_cp->cp_tr; aux_tr = LOCAL_top_cp->cp_tr;
printf("%d: Starting variable unbinding %p---%p\n", worker_id, TR, aux_tr);
#ifdef TABLING_ERRORS #ifdef TABLING_ERRORS
if (TR < aux_tr) if (TR < aux_tr)
TABLING_ERROR_MESSAGE("TR < aux_tr (q_share_work)"); TABLING_ERROR_MESSAGE("TR < aux_tr (q_share_work)");
@ -217,9 +217,8 @@ int q_share_work(int worker_p) {
} else if (IsApplTerm(aux_cell)) { } else if (IsApplTerm(aux_cell)) {
CELL *aux_ptr = RepAppl(aux_cell); CELL *aux_ptr = RepAppl(aux_cell);
Term aux_val = TrailTerm(--aux_tr); Term aux_val = TrailTerm(--aux_tr);
*aux_ptr = aux_val; *aux_ptr = aux_val;
#endif #endif /* MULTI_ASSIGNMENT_VARIABLES */
} }
} }
@ -322,7 +321,6 @@ sync_with_p:
#ifdef MULTI_ASSIGNMENT_VARIABLES #ifdef MULTI_ASSIGNMENT_VARIABLES
} else if (IsApplTerm(aux_cell)) { } else if (IsApplTerm(aux_cell)) {
CELL *cell_ptr = RepAppl(aux_cell); CELL *cell_ptr = RepAppl(aux_cell);
if (((CELL *)aux_cell < LOCAL_top_cp->cp_h || if (((CELL *)aux_cell < LOCAL_top_cp->cp_h ||
EQUAL_OR_YOUNGER_CP(LOCAL_top_cp, (choiceptr)aux_cell)) && EQUAL_OR_YOUNGER_CP(LOCAL_top_cp, (choiceptr)aux_cell)) &&
!lookup_ma_var(cell_ptr)) { !lookup_ma_var(cell_ptr)) {
@ -335,7 +333,7 @@ sync_with_p:
} }
/* skip the old value */ /* skip the old value */
aux_tr--; aux_tr--;
#endif #endif /* MULTI_ASSIGNMENT_VARIABLES */
} }
} }

1
OPTYap/or.macros.h
View File

@ -259,7 +259,6 @@ void PUT_OUT_REQUESTABLE(int p) {
return; return;
} }
extern int vsc_op;
static inline static inline
void SCH_update_local_or_tops(void) { void SCH_update_local_or_tops(void) {

11
OPTYap/or.sbaengine.c
View File

@ -43,7 +43,6 @@ reset_trail(tr_fr_ptr tr_top, tr_fr_ptr trp)
#ifdef MULTI_ASSIGNMENT_VARIABLES #ifdef MULTI_ASSIGNMENT_VARIABLES
} else { } else {
CELL *aux_ptr = RepAppl(aux_cell); CELL *aux_ptr = RepAppl(aux_cell);
trp--; trp--;
if (Unsigned((Int)(aux_ptr)-(Int)(H_FZ)) > if (Unsigned((Int)(aux_ptr)-(Int)(H_FZ)) >
Unsigned((Int)(B_FZ)-(Int)(H_FZ))) { Unsigned((Int)(B_FZ)-(Int)(H_FZ))) {
@ -51,7 +50,7 @@ reset_trail(tr_fr_ptr tr_top, tr_fr_ptr trp)
} else { } else {
*aux_ptr = TrailTerm(trp); *aux_ptr = TrailTerm(trp);
} }
#endif #endif /* MULTI_ASSIGNMENT_VARIABLES */
} }
} }
} }
@ -185,7 +184,6 @@ int q_share_work(int worker_p) {
#ifdef MULTI_ASSIGNMENT_VARIABLES #ifdef MULTI_ASSIGNMENT_VARIABLES
} else if (IsApplTerm(aux_cell)) { } else if (IsApplTerm(aux_cell)) {
CELL *cell_ptr = RepAppl(aux_cell); CELL *cell_ptr = RepAppl(aux_cell);
if (!lookup_ma_var(cell_ptr)) { if (!lookup_ma_var(cell_ptr)) {
/* first time we found the variable, let's put the new value */ /* first time we found the variable, let's put the new value */
CELL *ptr = STACK_TO_SBA(cell_ptr); CELL *ptr = STACK_TO_SBA(cell_ptr);
@ -194,7 +192,7 @@ int q_share_work(int worker_p) {
/* skip the old value */ /* skip the old value */
aux_tr--; aux_tr--;
} }
#endif #endif /* MULTI_ASSIGNMENT_VARIABLES */
} }
/* update registers and return */ /* update registers and return */
@ -296,7 +294,6 @@ void share_private_nodes(int worker_q) {
#ifdef MULTI_ASSIGNMENT_VARIABLES #ifdef MULTI_ASSIGNMENT_VARIABLES
} else { } else {
CELL *cell_ptr = RepAppl(aux_cell); CELL *cell_ptr = RepAppl(aux_cell);
/* first do as a for a standard cell */ /* first do as a for a standard cell */
if ((cell_ptr < B->cp_h || cell_ptr > (CELL *)B) && !(cell_ptr < H_FZ || (choiceptr)cell_ptr > B_FZ)) { if ((cell_ptr < B->cp_h || cell_ptr > (CELL *)B) && !(cell_ptr < H_FZ || (choiceptr)cell_ptr > B_FZ)) {
CELL *ptr = STACK_TO_SBA(cell_ptr); CELL *ptr = STACK_TO_SBA(cell_ptr);
@ -308,7 +305,7 @@ void share_private_nodes(int worker_q) {
} }
/* but we also need to skip the old value */ /* but we also need to skip the old value */
tr_ptr--; tr_ptr--;
#endif #endif /* MULTI_ASSIGNMENT_VARIABLES */
} }
} }
} }
@ -328,5 +325,3 @@ void share_private_nodes(int worker_q) {
} }
#endif /* SBA */ #endif /* SBA */

3
OPTYap/or.scheduler.c
View File

@ -213,7 +213,8 @@ int get_work(void) {
} }
} }
if (LOCAL_top_cp == GLOBAL_root_cp) { if (LOCAL_top_cp == GLOBAL_root_cp) {
PUT_IN_ROOT_NODE(worker_id); if (! BITMAP_member(GLOBAL_bm_root_cp_workers, worker_id))
PUT_IN_ROOT_NODE(worker_id);
if (BITMAP_same(GLOBAL_bm_idle_workers, GLOBAL_bm_root_cp_workers) && if (BITMAP_same(GLOBAL_bm_idle_workers, GLOBAL_bm_root_cp_workers) &&
BITMAP_same(GLOBAL_bm_idle_workers, GLOBAL_bm_present_workers)) { BITMAP_same(GLOBAL_bm_idle_workers, GLOBAL_bm_present_workers)) {
/* All workers are idle in root choicepoint. Execution /* All workers are idle in root choicepoint. Execution

18
OPTYap/tab.insts.i
View File

@ -429,7 +429,7 @@
CELL *aux_args; CELL *aux_args;
CELL *aux_subs; CELL *aux_subs;
sg_fr_ptr aux_sg_fr = LOCAL_top_sg_fr; aux_sg_fr = LOCAL_top_sg_fr;
while (aux_sg_fr && aux_sg_fr != sg_fr) while (aux_sg_fr && aux_sg_fr != sg_fr)
aux_sg_fr = SgFr_next(aux_sg_fr); aux_sg_fr = SgFr_next(aux_sg_fr);
if (aux_sg_fr == NULL) if (aux_sg_fr == NULL)
@ -927,7 +927,7 @@
BOp(table_completion, ld); BOp(table_completion, ld);
#ifdef YAPOR #ifdef YAPOR
if (SCH_top_shared_cp(B)) { if (SCH_top_shared_cp(B)) {
SCH_new_alternative(PREG, GEN_CP_NULL_ALT); SCH_new_alternative(PREG, GEN_CP_NULL_ALT);
@ -1169,9 +1169,9 @@
/* unconsumed answer */ /* unconsumed answer */
UNLOCK_OR_FRAME(LOCAL_top_or_fr); UNLOCK_OR_FRAME(LOCAL_top_or_fr);
if (ans_node == NULL) { if (ans_node == NULL) {
ans_node = DepFr_last_ans(dep_fr) = SgFr_first_answer(DepFr_sg_fr(dep_fr)); ans_node = DepFr_last_ans(LOCAL_top_dep_fr) = SgFr_first_answer(DepFr_sg_fr(LOCAL_top_dep_fr));
} else { } else {
ans_node = DepFr_last_ans(dep_fr) = TrNode_child(ans_node); ans_node = DepFr_last_ans(LOCAL_top_dep_fr) = TrNode_child(ans_node);
} }
UNLOCK(DepFr_lock(LOCAL_top_dep_fr)); UNLOCK(DepFr_lock(LOCAL_top_dep_fr));
consume_answer_and_procceed(LOCAL_top_dep_fr, ans_node); consume_answer_and_procceed(LOCAL_top_dep_fr, ans_node);
@ -1225,10 +1225,10 @@
goto fail; goto fail;
#else /* TABLING_LOCAL_SCHEDULING */ #else /* TABLING_LOCAL_SCHEDULING */
/* subgoal completed */ /* subgoal completed */
LOCK_SG_FRAME(sg_fr); LOCK(SgFr_lock(sg_fr));
if (SgFr_state(sg_fr) == complete) if (SgFr_state(sg_fr) == complete)
update_answer_trie(sg_fr); update_answer_trie(sg_fr);
UNLOCK_SG_FRAME(sg_fr); UNLOCK(SgFr_lock(sg_fr));
if (SgFr_first_answer(sg_fr) == NULL) { if (SgFr_first_answer(sg_fr) == NULL) {
/* no answers --> fail */ /* no answers --> fail */
B = B->cp_b; B = B->cp_b;
@ -1248,14 +1248,14 @@
/* yes answer --> procceed */ /* yes answer --> procceed */
PREG = (yamop *) CPREG; PREG = (yamop *) CPREG;
PREFETCH_OP(PREG); PREFETCH_OP(PREG);
Y = ENV; YENV = ENV;
GONext(); GONext();
} else { } else {
/* answers -> load first answer */ /* answers -> load first answer */
PREG = (yamop *) TrNode_child(SgFr_answer_trie(sg_fr)); PREG = (yamop *) TrNode_child(SgFr_answer_trie(sg_fr));
PREFETCH_OP(PREG); PREFETCH_OP(PREG);
*--Y = 0; /* vars_arity */ *--YENV = 0; /* vars_arity */
*--Y = 0; /* heap_arity */ *--YENV = 0; /* heap_arity */
GONext(); GONext();
} }
#endif /* TABLING_SCHEDULING */ #endif /* TABLING_SCHEDULING */

23
OPTYap/tab.macros.h
View File

@ -33,10 +33,7 @@ STD_PROTO(static inline void CUT_validate_tg_answers, (tg_sol_fr_ptr));
STD_PROTO(static inline void CUT_join_tg_solutions, (tg_sol_fr_ptr *, tg_sol_fr_ptr)); STD_PROTO(static inline void CUT_join_tg_solutions, (tg_sol_fr_ptr *, tg_sol_fr_ptr));
STD_PROTO(static inline void CUT_join_solution_frame_tg_answers, (tg_sol_fr_ptr)); STD_PROTO(static inline void CUT_join_solution_frame_tg_answers, (tg_sol_fr_ptr));
STD_PROTO(static inline void CUT_join_solution_frames_tg_answers, (tg_sol_fr_ptr)); STD_PROTO(static inline void CUT_join_solution_frames_tg_answers, (tg_sol_fr_ptr));
/*printf*/
STD_PROTO(static inline void CUT_free_tg_solution_frame, (tg_sol_fr_ptr)); STD_PROTO(static inline void CUT_free_tg_solution_frame, (tg_sol_fr_ptr));
/*STD_PROTO(static inline int CUT_free_tg_solution_frame, (tg_sol_fr_ptr));*/
/*printf*/
STD_PROTO(static inline void CUT_free_tg_solution_frames, (tg_sol_fr_ptr)); STD_PROTO(static inline void CUT_free_tg_solution_frames, (tg_sol_fr_ptr));
STD_PROTO(static inline tg_sol_fr_ptr CUT_prune_tg_solution_frames, (tg_sol_fr_ptr, int)); STD_PROTO(static inline tg_sol_fr_ptr CUT_prune_tg_solution_frames, (tg_sol_fr_ptr, int));
#endif /* TABLING_INNER_CUTS */ #endif /* TABLING_INNER_CUTS */
@ -89,7 +86,7 @@ STD_PROTO(static inline tg_sol_fr_ptr CUT_prune_tg_solution_frames, (tg_sol_fr_p
#else #else
#define STACK_PUSH(ITEM, STACK, STACK_TOP, STACK_BASE) \ #define STACK_PUSH(ITEM, STACK, STACK_TOP, STACK_BASE) \
*--(STACK) = (CELL)(ITEM); \ *--(STACK) = (CELL)(ITEM); \
if ((STACK) <= STACK_TOP+1024) { \ if ((STACK) <= STACK_TOP + 1024) { \
CELL *NEW_STACK; \ CELL *NEW_STACK; \
UInt diff; \ UInt diff; \
char *OldTrailTop = (char *)Yap_TrailTop; \ char *OldTrailTop = (char *)Yap_TrailTop; \
@ -149,8 +146,7 @@ STD_PROTO(static inline tg_sol_fr_ptr CUT_prune_tg_solution_frames, (tg_sol_fr_p
#else #else
#define find_dependency_node(SG_FR, LEADER_CP, DEP_ON_STACK) \ #define find_dependency_node(SG_FR, LEADER_CP, DEP_ON_STACK) \
LEADER_CP = SgFr_gen_cp(SG_FR); \ LEADER_CP = SgFr_gen_cp(SG_FR); \
DEP_ON_STACK = TRUE; DEP_ON_STACK = TRUE
#define find_leader_node(LEADER_CP, DEP_ON_STACK) \ #define find_leader_node(LEADER_CP, DEP_ON_STACK) \
{ dep_fr_ptr chain_dep_fr = LOCAL_top_dep_fr; \ { dep_fr_ptr chain_dep_fr = LOCAL_top_dep_fr; \
while (YOUNGER_CP(DepFr_cons_cp(chain_dep_fr), LEADER_CP)) { \ while (YOUNGER_CP(DepFr_cons_cp(chain_dep_fr), LEADER_CP)) { \
@ -171,7 +167,6 @@ STD_PROTO(static inline tg_sol_fr_ptr CUT_prune_tg_solution_frames, (tg_sol_fr_p
#define GEN_CP_NULL_ALT ANSWER_RESOLUTION #define GEN_CP_NULL_ALT ANSWER_RESOLUTION
#define GEN_CP_SG_FR(GCP) DepFr_sg_fr(GEN_CP(GCP)->gcp_dep_fr) #define GEN_CP_SG_FR(GCP) DepFr_sg_fr(GEN_CP(GCP)->gcp_dep_fr)
#endif /* TABLING_SCHEDULING */ #endif /* TABLING_SCHEDULING */
#define SgFr_init_scheduling_fields(SG_FR, ARITY) SgFr_arity(SG_FR) = ARITY
#ifdef YAPOR #ifdef YAPOR
@ -202,7 +197,7 @@ STD_PROTO(static inline tg_sol_fr_ptr CUT_prune_tg_solution_frames, (tg_sol_fr_p
TabEnt_hash_chain(TAB_ENT) = HASH TabEnt_hash_chain(TAB_ENT) = HASH
#define AnsHash_init_next_field(HASH, SG_FR) \ #define AnsHash_init_next_field(HASH, SG_FR) \
Hash_next(HASH) = SgFr_hash_chain(SG_FR); \ Hash_next(HASH) = SgFr_hash_chain(SG_FR); \
SgFr_hash_chain(SG_Fr) = HASH SgFr_hash_chain(SG_FR) = HASH
#else #else
#define TabEnt_init_lock_field(TAB_ENT) #define TabEnt_init_lock_field(TAB_ENT)
#define SgHash_init_next_field(HASH, TAB_ENT) \ #define SgHash_init_next_field(HASH, TAB_ENT) \
@ -255,7 +250,7 @@ STD_PROTO(static inline tg_sol_fr_ptr CUT_prune_tg_solution_frames, (tg_sol_fr_p
SgFr_last_answer(SG_FR) = NULL; \ SgFr_last_answer(SG_FR) = NULL; \
SgFr_hash_chain(SG_FR) = NULL; \ SgFr_hash_chain(SG_FR) = NULL; \
SgFr_state(SG_FR) = resolving; \ SgFr_state(SG_FR) = resolving; \
SgFr_init_scheduling_fields(SG_FR, ARITY); \ SgFr_arity(SG_FR) = ARITY; \
SgFr_next(SG_FR) = NEXT; \ SgFr_next(SG_FR) = NEXT; \
} }
@ -348,8 +343,8 @@ void mark_as_completed(sg_fr_ptr sg_fr) {
hash = SgFr_hash_chain(sg_fr); hash = SgFr_hash_chain(sg_fr);
SgFr_hash_chain(sg_fr) = NULL; SgFr_hash_chain(sg_fr) = NULL;
SgFr_state(sg_fr) = complete; SgFr_state(sg_fr) = complete;
UNLOCK(SgFr_lock(sg_fr));
free_answer_hash_chain(hash); free_answer_hash_chain(hash);
UNLOCK(SgFr_lock(sg_fr));
return; return;
} }
@ -383,9 +378,8 @@ void unbind_variables(tr_fr_ptr unbind_tr, tr_fr_ptr end_tr) {
} else { } else {
Term aux_val = TrailTerm(--unbind_tr); Term aux_val = TrailTerm(--unbind_tr);
CELL *aux_ptr = RepAppl(ref); CELL *aux_ptr = RepAppl(ref);
*aux_ptr = aux_val; *aux_ptr = aux_val;
#endif #endif /* MULTI_ASSIGNMENT_VARIABLES */
} }
} }
return; return;
@ -421,18 +415,19 @@ void rebind_variables(tr_fr_ptr rebind_tr, tr_fr_ptr end_tr) {
#ifdef MULTI_ASSIGNMENT_VARIABLES #ifdef MULTI_ASSIGNMENT_VARIABLES
} else { } else {
CELL *cell_ptr = RepAppl(ref); CELL *cell_ptr = RepAppl(ref);
if (!lookup_ma_var(cell_ptr)) { if (!lookup_ma_var(cell_ptr)) {
/* first time we found the variable, let's put the new value */ /* first time we found the variable, let's put the new value */
*cell_ptr = TrailVal(rebind_tr); *cell_ptr = TrailVal(rebind_tr);
} }
/* skip the old value */ /* skip the old value */
rebind_tr--; rebind_tr--;
#endif #endif /* MULTI_ASSIGNMENT_VARIABLES */
} }
} }
return;
} }
static inline static inline
void restore_bindings(tr_fr_ptr unbind_tr, tr_fr_ptr rebind_tr) { void restore_bindings(tr_fr_ptr unbind_tr, tr_fr_ptr rebind_tr) {
CELL ref; CELL ref;

1
OPTYap/tab.structs.h
View File

@ -112,7 +112,6 @@ typedef struct subgoal_frame {
complete = 1, complete = 1,
executable = 2 executable = 2
} state_flag; } state_flag;
/* vsc: needed by garbage collector to find where substitution frame for table_completion is */
int subgoal_arity; int subgoal_arity;
struct subgoal_frame *next; struct subgoal_frame *next;
} *sg_fr_ptr; } *sg_fr_ptr;

10
OPTYap/tab.tries.c
View File

@ -665,7 +665,7 @@ sg_node_ptr subgoal_search(tab_ent_ptr tab_ent, OPREG arity, CELL **Yaddr) {
#else #else
stack_terms_top = (CELL *)TR; stack_terms_top = (CELL *)TR;
stack_terms_base = stack_terms = (CELL *)Yap_TrailTop; stack_terms_base = stack_terms = (CELL *)Yap_TrailTop;
#endif #endif /* YAPOR */
current_sg_node = TabEnt_subgoal_trie(tab_ent); current_sg_node = TabEnt_subgoal_trie(tab_ent);
for (i = 1; i <= arity; i++) { for (i = 1; i <= arity; i++) {
@ -730,12 +730,12 @@ ans_node_ptr answer_search(sg_fr_ptr sg_fr, CELL *subs_ptr) {
subs_arity = *subs_ptr; subs_arity = *subs_ptr;
stack_vars = AuxSp; stack_vars = AuxSp;
#ifdef YAPOR #ifdef YAPOR
stack_terms_top = (CELL *)TrailTop; stack_terms_top = (CELL *)Yap_TrailTop;
stack_terms_base = stack_terms = stack_vars - MAX_TABLE_VARS; stack_terms_base = stack_terms = stack_vars - MAX_TABLE_VARS;
#else #else
stack_terms_top = (CELL *)TR; stack_terms_top = (CELL *)TR;
stack_terms_base = stack_terms = (CELL *)Yap_TrailTop; stack_terms_base = stack_terms = (CELL *)Yap_TrailTop;
#endif #endif /* YAPOR */
current_ans_node = SgFr_answer_trie(sg_fr); current_ans_node = SgFr_answer_trie(sg_fr);
for (i = subs_arity; i >= 1; i--) { for (i = subs_arity; i >= 1; i--) {
@ -801,12 +801,12 @@ void load_answer_trie(ans_node_ptr ans_node, CELL *subs_ptr) {
CELL *stack_vars, *stack_terms, *stack_refs, *stack_refs_base, *stack_top; CELL *stack_vars, *stack_terms, *stack_refs, *stack_refs_base, *stack_top;
ans_node_ptr aux_parent_node; ans_node_ptr aux_parent_node;
#ifdef YAPOR #ifdef YAPOR
stack_top = (CELL *)TrailTop; stack_top = (CELL *)Yap_TrailTop;
stack_vars = stack_terms = AuxSp - MAX_TABLE_VARS; stack_vars = stack_terms = AuxSp - MAX_TABLE_VARS;
#else #else
stack_top = (CELL *)TR; stack_top = (CELL *)TR;
stack_vars = stack_terms = ((CELL *)Yap_TrailTop)-MAX_TABLE_VARS; stack_vars = stack_terms = ((CELL *)Yap_TrailTop)-MAX_TABLE_VARS;
#endif #endif /* YAPOR */
/* load the new answer from the answer trie to the stack_terms */ /* load the new answer from the answer trie to the stack_terms */
aux_parent_node = UNTAG_ANSWER_LEAF_NODE(TrNode_parent(ans_node)); aux_parent_node = UNTAG_ANSWER_LEAF_NODE(TrNode_parent(ans_node));