gdk.h

这个是内存数据库中的一个管理工具

gdk_export bat BBPlimit;
gdk_export bat BBP_free;
gdk_export int BBP_dirty;	/* BBP table dirty? */
gdk_export BBPrec *BBP;

/* fast defines without checks; internal use only  */
#define BBP_cache(i)    BBP[ABS(i)].b[(i)<0]
#define BBP_logical(i)  BBP[ABS(i)].nme[(i)<0]
#define BBP_next(i)     BBP[ABS(i)].next[(i)<0]
#define BBP_physical(i) BBP[ABS(i)].path
#define BBP_desc(i)	BBP[ABS(i)].cache
#define BBP_refs(i)     BBP[ABS(i)].refs
#define BBP_lrefs(i)    BBP[ABS(i)].lrefs
#define BBP_lastused(i) BBP[ABS(i)].lastused
#define BBP_status(i)   BBP[ABS(i)].status

/* macros that nicely check parameters */
#define BBPdirty(x)	 (BBP_dirty=(x))
#define BBPcacheid(b)	 ((b)->batCacheid)
#define BBPstatus(i)	 (BBPcheck((i),"BBPstatus")?BBP_status(i):-1)
#define BBPcurstamp()	 BBP_curstamp
#define BBPrefs(i)	 (BBPcheck((i),"BBPrefs")?BBP_refs(i):-1)
#define BBPcache(i)	 (BBPcheck((i),"BBPcache")?BBP_cache(i):(BAT*) NULL)
#define BBPname(i)	 (BBPcheck((i),"BBPname")?((i) > 0 || BBP_logical(i))?BBP_logical(i):BBP_logical(-(i)):"")
#define BBPvalid(i)      (BBP_logical(i) != NULL && *BBP_logical(i) != '.')
#define BATgetId(b)	 BBPname((b)->batCacheid)
#define BBPfix(i)	 BBPincref(i, FALSE)
#define BBPunfix(i)	 BBPdecref(i, FALSE)

#define BBPRENAME_ALREADY	-1
#define BBPRENAME_ILLEGAL	-2
#define BBPRENAME_LONG		-3

gdk_export void BBPlock(str s);

gdk_export void BBPhot(bat b);
gdk_export void BBPcold(bat b);
gdk_export void BBPtrim(size_t memdelta, size_t vmdelta);
gdk_export void BBPunlock(str s);

gdk_export str BBPlogical(bat b, str buf);
gdk_export str BBPphysical(bat b, str buf);
gdk_export int BBP_curstamp;
gdk_export BATstore *BBPgetdesc(bat i);
gdk_export BAT *BBPquickdesc(bat b, int delaccess);


typedef struct {
	/* simple attributes */
	char name[IDLENGTH];
	int storage;		/* stored as another type? */
	short linear;		/* atom can be ordered linearly */
	short size;		/* fixed size of atom */
	short align;		/* alignment condition for values */
	short deleting;		/* set if unloading */
	int varsized;		/* variable-size or fixed-sized */

	/* automatically generated fields */
	ptr atomNull;		/* global nil value */

	/* generic (fixed + varsized atom) ADT functions */
	int (*atomFromStr) (str s, int *len, ptr *dst);
	int (*atomToStr) (str *s, int *len, ptr src);
	void *(*atomRead) (ptr a, stream *s, size_t cnt);
	int (*atomWrite) (ptr a, stream *s, size_t cnt);
	int (*atomCmp) (ptr v1, ptr v2);
	hash_t (*atomHash) (ptr v);
	/* optional functions */
	void (*atomConvert) (ptr v, int direction);
	int (*atomFix) (ptr atom);
	int (*atomUnfix) (ptr atom);

	/* varsized atom-only ADT functions */
	var_t (*atomPut) (Heap *, var_t *off, ptr src);
	void (*atomDel) (Heap *, var_t *atom);
	int (*atomLen) (ptr atom);
	void (*atomHeap) (Heap *, size_t);
	/* optional functions */
	void (*atomHeapConvert) (Heap *, int direction);
	int (*atomHeapCheck) (Heap *, HeapRepair *);
} atomDesc;

gdk_export atomDesc BATatoms[];
gdk_export int GDKatomcnt;

gdk_export void ATOMdelete(int id);
gdk_export void ATOMproperty(char *nme, char *property, GDKfcn fcn);
gdk_export int ATOMindex(char *nme);
gdk_export int ATOMisdescendant(int id, int parentid);
gdk_export int ATOMdump(void);

gdk_export int ATOMheap(int id, Heap *hp, size_t cap);
gdk_export str ATOMname(int id);
gdk_export int ATOMlen(int id, ptr v);
gdk_export ptr ATOMnil(int id);
gdk_export int ATOMcmp(int id, ptr v_1, ptr v_2);
gdk_export int ATOMprint(int id, ptr val, stream *fd);
gdk_export int ATOMformat(int id, ptr val, char **buf);

gdk_export ptr ATOMdup(int id, ptr val);


gdk_export int OIDinit(void);
gdk_export oid OIDrand(void);
gdk_export oid OIDbase(oid base);
gdk_export oid OIDseed(oid seed);
gdk_export oid OIDnew(size_t inc);
gdk_export oid OIDread(str buf);
gdk_export int OIDwrite(stream *fp);
gdk_export int OIDdirty(void);


gdk_export BAT *BAThash(BAT *b, size_t masksize);
gdk_export BAT *BAThashsplit(BAT *b, size_t n, int unary);
gdk_export BAT *BATrangesplit(BAT *b, size_t n, int unary);
gdk_export BAT *BAThashjoin(BAT *l, BAT *r, size_t estimate);

/* low level functions */
gdk_export BUN SORTfnd(BAT *b, ptr v);
gdk_export BUN SORTfndfirst(BAT *b, ptr v);
gdk_export BUN SORTfndlast(BAT *b, ptr v);

#define BATprepareHash(X) (((X)->hhash == NULL) && !BAThash(X, 0))


#define GDK_HISTO_MAX_BIT             ((int) (sizeof(size_t)<<3))

/* we prefer to use vm_alloc routines on size > GDKmmap */
gdk_export void GDKvminc(size_t len);
gdk_export void *GDKmmap(char *path, int mode, off_t off, size_t len);
gdk_export int GDKmunmap(void *addr, size_t len);

gdk_export ptr GDK_mem_start;	/* sbrk(0) at start of the program */
gdk_export size_t GDK_mem_bigsize; /* size after which we use VM rather than heap */
gdk_export size_t GDK_mem_maxsize; /* max allowed size of committed memory */
gdk_export size_t GDK_vm_minsize; /* smallest size allowed for a vm block */
gdk_export size_t GDK_vm_maxsize; /* max allowed size of reserverd vm */

gdk_export size_t GDKmem_inuse(void); /* RAM/swapmem that MonetDB is really using now */
gdk_export size_t GDKmem_cursize(void);	/* RAM/swapmem that MonetDB has claimed from OS */
gdk_export size_t GDKvm_cursize(void); /* current MonetDB VM address space usage */
gdk_export size_t GDKvm_heapsize(void);
gdk_export size_t GDKmem_heapsize(void);
gdk_export size_t GDKmem_heapinuse(void);

gdk_export void *GDKmalloc(size_t size);
gdk_export void *GDKzalloc(size_t size);
gdk_export void *GDKmallocmax(size_t size, size_t * maxsize, int emergency);
gdk_export void *GDKrealloc(void *pold, size_t size);
gdk_export void *GDKreallocmax(void *pold, size_t size, size_t * maxsize, int emergency);
gdk_export void GDKfree(void *blk);
gdk_export str GDKstrdup(const char *s);

gdk_export void *GDKvmalloc(size_t size, size_t * maxsize, int emergency);
gdk_export void *GDKvmrealloc(void *pold, size_t oldsize, size_t newsize, size_t oldmax, size_t * maxsize, int emergency);
gdk_export void GDKvmfree(void *blk, size_t size, size_t maxsize);


#define GDKMAXERRLEN	10240
#define GDKWARNING	"!WARNING: "
#define GDKERROR	"!ERROR: "
#define GDKMESSAGE	"!OS: "
#define GDKFATAL	"!FATAL: "

/* Data Distilleries uses ICU for internationalization of some MonetDB error messages */
#ifdef MONET_ICU_I18N
gdk_export void GDKvsnprintf(char *buf, int maxlen, const char *format, va_list ap);
#else
#define GDKvsnprintf(buf, maxlen, format, ap) vsnprintf(buf, maxlen, format, ap)
#endif

gdk_export void GDKaddbuf(const char *msg);
gdk_export int GDKwarning(const char *format, ...);
gdk_export int GDKerror(const char *format, ...);
gdk_export int GDKsyserror(const char *format, ...);
gdk_export int GDKfatal(const char *format, ...);
gdk_export int GDKerrorCount(void);


#define BBPLOCKMASK     7

#include "gdk_delta.h"
#include "gdk_search.h"
#include "gdk_atoms.h"
#include "gdk_bbp.h"
#include "gdk_desc.h"
#include "gdk_utils.h"
#include "gdk_bat.h"

#ifdef NATIVE_WIN32
#define unlink _unlink
#ifdef _MSC_VER
#define fileno _fileno
#endif
#define fdopen _fdopen
#define putenv _putenv
#define strdup _strdup
#endif

gdk_export MT_Lock GDKthreadLock;
gdk_export MT_Lock GDKswapLock[BBPLOCKMASK + 1];
gdk_export MT_Lock GDKhashLock[BBPLOCKMASK + 1];
gdk_export MT_Lock GDKunloadLock;
gdk_export MT_Cond GDKunloadCond;
gdk_export MT_Lock GDKcacheLock;
gdk_export MT_Lock GDKtrimLock;
gdk_export MT_Lock GDKtmLock;

#define CHECKDEBUG      if (GDKdebug&2)
#define MEMDEBUG        if (GDKdebug&4)
#define PROPDEBUG       if (GDKdebug&8)
#define IODEBUG         if (GDKdebug&16)
#define BATDEBUG        if (GDKdebug&32)
#define PARSEDEBUG      if (GDKdebug&64)
#define PARDEBUG        if (GDKdebug&128)
#define TRGDEBUG        if (GDKdebug&256)
#define TMDEBUG         if (GDKdebug&512)
#define TEMDEBUG        if (GDKdebug&1024)
#define DLDEBUG	        if (GDKdebug&2048)
#define PERFDEBUG	if (GDKdebug&4096)
#define DELTADEBUG	if (GDKdebug&8192)
#define LOADDEBUG	if (GDKdebug&16384)
#define YACCDEBUG	if (GDKdebug&32768)
/*
#define ?tcpip?		if (GDKdebug&65536)
#define ?monet_multiplex?	if (GDKdebug&131072)
#define ?ddbench?	if (GDKdebug&262144)
#define ?ddbench?	if (GDKdebug&524288)
#define ?ddbench?	if (GDKdebug&1048576)
*/
#define ALGODEBUG	if (GDKdebug&2097152)
#define ESTIDEBUG	if (GDKdebug&4194304)
#define XPROPDEBUG      if (GDKdebug&8388608)

#define JOINPROPCHK     if (!(GDKdebug&16777216))
#define DEADBEEFCHK     if (!(GDKdebug&33554432))

gdk_export int GDKnrofthreads;
gdk_export int GDKembedded;
gdk_export int GDKprotected;
gdk_export void GDKprotect(void);




#define gdk_set_lock(X,Y)    if(GDKprotected ) MT_set_lock(X,Y)
#define gdk_unset_lock(X,Y)  if(GDKprotected ) MT_unset_lock(X,Y)
#define gdk_up_sema(X,Y)     if(GDKprotected ) MT_up_sema(X,Y)
#define gdk_down_sema(X,Y)   if(GDKprotected ) MT_down_sema(X,Y)
#define gdk_signal_cond(X,Y) if(GDKprotected ) MT_signal_cond(X,Y)
#define gdk_wait_cond(X,Y,Z) if(GDKprotected ) MT_wait_cond(X,Y,Z)




#define THREADS	64
#define THREADDATA	16

typedef struct threadStruct {
	int tid;		/* logical ID by MonetDB; val == index into this array + 1 (0 is invalid) */
	MT_Id pid;		/* physical thread id (pointer-sized) from the OS thread library */
	str name;
	ptr data[THREADDATA];
	size_t sp;
	void (*cleanup) (ptr thr);
} ThreadRec, *Thread;


gdk_export ThreadRec GDKthreads[THREADS];

gdk_export int THRgettid(void);
gdk_export Thread THRget(int tid);
gdk_export Thread THRnew(MT_Id pid, str name);
gdk_export void THRdel(Thread t);
gdk_export int THRinit(void);
gdk_export int THRexit(str nme);
gdk_export int THRcnt(void);
gdk_export void THRsetdata(int, ptr);
gdk_export void *THRgetdata(int);
gdk_export int THRhighwater(void);
gdk_export int THRprintf(stream *s, const char *format, ...);

gdk_export void *THRdata[16];

#define GDKstdout	((stream*)THRdata[0])
#define GDKstdin	((stream*)THRdata[1])

#define GDKout	        ((stream*)THRgetdata(0))
#define GDKin	        ((stream*)THRgetdata(1))
#define GDKerrbuf	((char*)THRgetdata(2))
#define GDKsetbuf(x)	THRsetdata(2,(ptr)(x))
#define GDKerr	        GDKout

#define THRget_errbuf(t)	((char*)t->data[2])
#define THRset_errbuf(t,b)	(t->data[2] = b)

#ifndef GDK_NOLINK
#ifdef __cplusplus
extern "C" {
#endif

static INLINE bat
BBPcheck(REGISTER bat x, REGISTER const char *y)
{
	if (x && x != bat_nil) {
		REGISTER bat z = ABS(x);

		if (z >= BBPsize || BBP[z].nme[0] == NULL) {
			GDKwarning("%s: range error %d\n", y, x);
		} else {
			return z;
		}
	}
	return 0;
}

static INLINE BAT *
BATdescriptor(REGISTER bat i)
{
	REGISTER BAT *b = NULL;

	if (BBPcheck(i, "BATdescriptor")) {
		BBPfix(i);
		b = BBP_cache(i);
		if (b == NULL)
			b = BBPdescriptor(i);
	}
	return b;
}

static INLINE ptr
BUNhpos(REGISTER BAT *b, REGISTER BUN p)
{
	oid *ip = &b->void_seq1;

	*ip = b->hseqbase;
	if (*ip != oid_nil) {
		*ip += BUNgetpos(b, p);
	}
	return (ptr) ip;
}

static INLINE ptr
BUNtpos(REGISTER BAT *b, REGISTER BUN p)
{
	oid *ip = &b->void_seq2;

	*ip = b->tseqbase;
	if (*ip != oid_nil) {
		*ip += BUNgetpos(b, p);
	}
	return (ptr) ip;
}

static INLINE BAT *
BATmirror(REGISTER BAT *b)
{
	return BBP_cache(-(b)->batCacheid);
}

#ifdef __cplusplus
}
#endif
#endif



gdk_export int TMcommit(void);
gdk_export int TMabort(void);
gdk_export int TMsubcommit(BAT* bl);



gdk_export BAT *BATcommit(BAT *b);
gdk_export BAT *BATfakeCommit(BAT *b);
gdk_export BAT *BATundo(BAT *b);
gdk_export BAT *BATalpha(BAT *b);
gdk_export BAT *BATdelta(BAT *b);
gdk_export BAT *BATprev(BAT *b);





gdk_export int ALIGNsynced(BAT *b1, BAT *b2);
gdk_export int ALIGNrelated(BAT *b1, BAT *b2);

gdk_export BAT *BATpropcheck(BAT *b, int mode);

#define BATPROPS_QUICK  0	/* only derive easy (non-resource consuming) properties */
#define BATPROPS_ALL    1	/* derive all possible properties; no matter what cost (key=hash) */
#define BATPROPS_CHECK  3	/* BATPROPS_ALL, but start from scratch and report illegally set properties */

gdk_export BAT *VIEWcreate(BAT *b);
gdk_export BAT *VIEWcreate_(BAT *b, int stable);
gdk_export BAT *VIEWhead(BAT *b);
gdk_export BAT *VIEWhead_(BAT *b, int mode);
gdk_export BAT *VIEWcombine(BAT *b);
gdk_export BAT *VIEWreset(BAT *b);
gdk_export BAT *BATmaterialize(BAT *b, size_t size);
gdk_export BAT *BATmaterializeh(BAT *b, size_t size);
gdk_export BAT *BATmaterializet(BAT *b, size_t size);
gdk_export void VIEWdestroy(BAT *b);
gdk_export void VIEWbounds(BAT *view, size_t l, size_t h);
gdk_export void VIEWunlink(BAT *b);

/* low level functions */
gdk_export int ALIGNundo(BAT *b);
gdk_export int ALIGNcommit(BAT *b);
gdk_export int ALIGNsetH(BAT *b1, BAT *b2);

#define ALIGNset(x,y)	{ALIGNsetH(x,y);ALIGNsetT(x,y);}
#define ALIGNsetT(x,y)	ALIGNsetH(BATmirror(x),BATmirror(y))
#define ALIGNins(x,y,f)	{if (!(f)) VIEWchk(x,y,BAT_READ);(x)->halign=(x)->talign=0; }
#define ALIGNdel(x,y,f)	{if (!(f)) VIEWchk(x,y,BAT_READ|BAT_APPEND);(x)->halign=(x)->talign=0; }
#define ALIGNinp(x,y,f) {if (!(f)) VIEWchk(x,y,BAT_READ|BAT_APPEND);(x)->talign=0; }
#define ALIGNapp(x,y,f) {if (!(f)) VIEWchk(x,y,BAT_READ);(x)->talign=0; }

#define BATrestricted(b) (VIEWparent(b)?BBP_cache(VIEWparent(b))->batRestricted:(b)->batRestricted)