gdk.h

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

	/* bunheap data */
	Heap buns;		/* space for the buns. */
	/* delta status administration */
	BUN deleted;		/* start of deleted elements */
	BUN first;		/* to store next deletion */
	BUN inserted;		/* start of inserted elements */
	size_t count;		/* tuple count */
} BUNrec;

typedef struct PROPrec {
	int 	  id;
	ValRecord v;
	struct PROPrec *next;	/* simple chain of properties */
} PROPrec;

typedef struct {
	str   id;		/* label for head/tail column */
	Heap *vheap;		/* space for the head/tail column. */
	chr heapdirty;		/* specific heap dirty marker */
	bit sorted;		/* 0=false, 1=true; */
	bit dense;		/* 0=false, 1=true; */
	oid align;		/* OID for sync alignment */
	size_t nosorted_rev;	/* position that proves sorted_rev==FALSE */
	size_t nokey[2];	/* positions that prove key ==FALSE */
	size_t nosorted;	/* position that proves sorted==FALSE */
	size_t nodense;		/* position that proves dense==FALSE */
	PROPrec *props;		/* list of dynamic properties stored in the bat descriptor */
} COLrec;

#define GDKLIBRARY_OLD  050415  /* 64-bits BAT with old hash function */
#define GDKLIBRARY      061021  /* 64-bits BAT */

typedef struct BAT {
	/* static bat properties */
	sht GDKversion;		/* FIRST! */
	bat batCacheid;		/* index into BBP */
	Dimensions dims;	/* BAT dimensions */
	Heap *batBuns;		/* pointer to U->buns */

	/* static column properties */
	Hash *hhash;		/* head hash table */
	Hash *thash;		/* tail hash table */

	/* dynamic column properties */
	COLrec *H;		/* column info */
	COLrec *T;		/* column info */

	/* dynamic bat properties */
	BATrec *P;		/* cache and sort info */
	BUNrec *U;		/* cache and sort info */

	/* void hack fields */
	int void_tid;		/* thread that reads this bat */
	int void_cnt;		/* nr of reads */
	oid void_seq1;
	oid void_seq2;
} BAT;



typedef struct {
	BAT B;			/* storage for BAT descriptor */
	COLrec H;		/* storage for head column */
	COLrec T;		/* storage for tail column */
	BATrec P;		/* storage for BATrec */
	BUNrec U;		/* storage for BUNrec */
} BATstore;

typedef int (*GDKfcn) ();

/* macros's to hide complexity of BAT structure */
#define batPersistence	P->persistence
#define batCopiedtodisk	P->copiedtodisk
#define batSet		P->set
#define batDirtyflushed	P->dirtyflushed
#define batDirty	P->dirty
#define batConvert	P->convert
#define batDirtyflushed P->dirtyflushed
#define batDirtydesc	P->descdirty
#define batDirtybuns	P->bunsdirty
#define hheapdirty	H->heapdirty
#define theapdirty	T->heapdirty
#define batFirst	U->first
#define batInserted	U->inserted
#define batDeleted	U->deleted
#define batCount	U->count
#define batParentid	P->parentid
#define batLview	P->lview
#define batStamp	P->stamp
#define batSharecnt	P->sharecnt
#define batRestricted	P->restricted
#define batLastused	P->lastused
#define creator_tid	P->tid
#define batElmsize	dims.bunwidth
#define batElmshift	dims.bunshift
#define htype		dims.headtype
#define ttype		dims.tailtype
#define hloc		dims.headloc
#define tloc		dims.tailloc
#define hkey		dims.headkey
#define tkey		dims.tailkey
#define hvarsized	dims.headvarsized
#define tvarsized	dims.tailvarsized
#define hseqbase	dims.hseq
#define tseqbase	dims.tseq
#define hsorted		H->sorted
#define tsorted		T->sorted
#define hdense		H->dense
#define tdense		T->dense
#define hheap		H->vheap
#define theap		T->vheap
#define hident		H->id
#define tident		T->id
#define halign		H->align
#define talign		T->align

#define batMapdirty	P->map_dirty
#define batMapbuns	P->map_buns
#define batMaphheap	P->map_hheap
#define batMaptheap	P->map_theap


gdk_export int HEAPalloc(Heap *h, size_t nitems, size_t itemsize);
gdk_export int HEAPfree(Heap *h);
gdk_export int HEAPextend(Heap *h, size_t size);
gdk_export int HEAPload(Heap *h, str nme, str ext, int trunc);
gdk_export int HEAPsave(Heap *h, str nme, str ext);
gdk_export int HEAPcopy(Heap *dst, Heap *src);
gdk_export int HEAPwarm(Heap *h);
gdk_export size_t HEAPsubcopy(Heap *dst, Heap *src, size_t size, size_t offset);
gdk_export int HEAPdelete(Heap *h, str o, str ext);
gdk_export size_t HEAPvmsize(Heap *h);
gdk_export size_t HEAPmemsize(Heap *h);




/* structure used by HEAP_check functions */
typedef struct {
	size_t minpos;		/* minimum block byte-index */
	size_t maxpos;		/* maximum block byte-index */
	int alignment;		/* block index alignment */
	size_t *validmask;	/* bitmap with all valid byte-indices
				 * first bit corresponds with 'minpos';
				 * 2nd bit with 'minpos+alignment', etc
				 */
} HeapRepair;

gdk_export void HEAP_initialize(Heap *heap, /* nbytes -- Initial size of the heap. */
				size_t nbytes, /* alignment -- for objects on the heap. */
				size_t nprivate, /* nprivate -- Size of private space */
				int alignment /* alignment restriction for allocated chunks */
	);

gdk_export void HEAP_initialize_compact(Heap *heap, /* nbytes -- Initial size of the heap. */
					size_t nbytes, /* alignment -- for objects on the heap. */
					size_t nprivate, /* nprivate -- Size of private space */
					int alignment, /* alignment restriction for allocated chunks */
					int (*sizefcn) (ptr) /* BATatoms[].atomLen function */
	);

gdk_export var_t HEAP_malloc(Heap *heap, size_t nbytes);
gdk_export void HEAP_free(Heap *heap, var_t block);
gdk_export size_t HEAP_private(Heap *h);
gdk_export void HEAP_checkformat(Heap *h);
gdk_export int HEAP_check(Heap *h, HeapRepair *hr);
gdk_export void HEAP_init(Heap *heap, int tpe);
gdk_export int HEAP_mmappable(Heap *heap);

#define HEAP_index(HEAP,INDEX,TYPE)	((TYPE *)((char *) (HEAP)->base + (INDEX)))





#define BATDELETE	-9999

gdk_export BAT *BATnew(int hdtype, int tltype, size_t capacity);
gdk_export BAT *BATclone(BAT *b, size_t capacity);
gdk_export BAT *BATextend(BAT *b, size_t newcap);

/* internal */
gdk_export BAT *BATnewstorage(int ht, int tt, size_t cap);
gdk_export BAT *BATcreatedesc(int ht, int tt, int heapnames);
gdk_export int BATfree(BAT *b);
gdk_export void BATdestroy(BAT *b);
gdk_export int BATelmshift(BAT *b);
gdk_export void BATsetdims(BAT *b);


#define bunfastins_nocheck(b, p, h, t, s) {				\
		(b)->batBuns->free += s;				\
		(b)->batCount ++;				        \
		ATOMput((b)->htype, (b)->hheap, BUNhloc(b, p), h);	\
		ATOMput((b)->ttype, (b)->theap, BUNtloc(b, p), t);	\
	}

#define bunfastins(b, h, t) {						\
		REGISTER BUN _p = BUNlast(b);				\
		REGISTER size_t _bunsize = BUNsize(b);			\
		if ((b)->batBuns->free + _bunsize > (b)->batBuns->size) { \
			if (BATextend((b), BATgrows(b)) == NULL) goto bunins_failed; \
			_p = BUNlast(b);				\
		}							\
		bunfastins_nocheck(b, _p, h, t, _bunsize);		\
	}

gdk_export BAT *BUNfastins(BAT *b, ptr left, ptr right);
gdk_export BAT *BUNins(BAT *b, ptr left, ptr right, bit force);
gdk_export BAT *BUNappend(BAT *b, ptr right, bit force);
gdk_export BAT *BATins(BAT *b, BAT *c, bit force);
gdk_export BAT *BATappend(BAT *b, BAT *c, bit force);
gdk_export BAT *BUNdel(BAT *b, ptr left, ptr right, bit force);
gdk_export BAT *BUNdelHead(BAT *b, ptr left, bit force);
gdk_export BUN BUNdelete(BAT *b, BUN p, bit force);
gdk_export BAT *BATdel(BAT *b, BAT *c, bit force);
gdk_export BAT *BATdelHead(BAT *b, BAT *c, bit force);

gdk_export BAT *BUNreplace(BAT *b, ptr left, ptr right, bit force);
gdk_export BAT *BUNinplace(BAT *b, BUN p, ptr left, ptr right, bit force);
gdk_export BAT *BATreplace(BAT *b, BAT *n, bit force);

gdk_export BUN BUNlocate(BAT *b, ptr left, ptr right);
gdk_export BUN BUNfnd(BAT *b, ptr left);

#define BUNfndVOID(p,b,v) {                                                             \
    ssize_t result = ((ssize_t) BUNfirst(b)) + BUNsize(b)*(*(oid*)(v) - (b)->hseqbase); \
    ssize_t check = (((*(oid*) (v) == oid_nil) ^ ((b)->hseqbase == oid_nil)) |          \
                    (*(oid*) v < (b)->hseqbase) |                                       \
                    (*(oid*) v >= (b)->hseqbase + (b)->batCount));                      \
    p = (BUN) (result&(check-1)); /* and with 0xFF...FF or 0x00..00 */                  \
}
#if SIZEOF_OID == SIZEOF_INT
#define BUNfndOID(p,b,v)			\
	if (BAThdense(b)) {			\
		BUNfndVOID(p,b,v);		\
	} else {				\
		HASHfnd_int(p,b,(int*)v);	\
	}
#else
#define BUNfndOID(p,b,v)			\
	if (BAThdense(b)) {			\
		BUNfndVOID(p,b,v);		\
	} else {				\
		HASHfnd_lng(p,b,(lng*)v);	\
	}
#endif
#define BUNfndSTD(p,b,v) ((p) = BUNfnd(b,v))

#define BAThtype(b)	((b)->htype == TYPE_void && (b)->hseqbase == oid_nil ?\
				TYPE_void : ATOMtype((b)->htype))
#define BATttype(b)	((b)->ttype == TYPE_void && (b)->tseqbase == oid_nil ?\
				TYPE_void : ATOMtype((b)->ttype))
#define BAThstore(b)	(BAThdense(b) ? TYPE_void : (b)->htype)
#define BATtstore(b)	(BATtdense(b) ? TYPE_void : (b)->ttype)
#define Bunbase(b)	((b)->batBuns->base)
#define Hbase(b)	((b)->hheap->base)
#define Tbase(b)	((b)->theap->base)

#define BUNhead(b,p)	((b)->hvarsized ? BUNhvar(b,p) : BUNhloc(b,p))
#define BUNtail(b,p)	((b)->tvarsized ? BUNtvar(b,p) : BUNtloc(b,p))

#define BUNsize(b)	((b)->dims.bunwidth)
#define BUNptr(b,i)	((BUN) ((char *) Bunbase(b) + (i) * BUNsize(b)))
#define BUNindex(b,p)	((size_t) ((b)->batElmshift < 0 ? \
				   (((char*)(p)-(char*)Bunbase(b))/BUNsize(b)) : \
				   (((char*)(p)-(char*)Bunbase(b)) >> (b)->batElmshift)))

#define BUNhloc(b,p)	((BUN) (((char *) (p)) + (b)->hloc))
#define BUNtloc(b,p)	((BUN) (((char *) (p)) + (b)->tloc))
#define BUNhvar(b,p)	((b)->htype?(BUN)((char *) Hbase(b)+*(var_t*)BUNhloc(b,p)):(BUN)BUNhpos(b,p))
#define BUNtvar(b,p)	((b)->ttype?(BUN)((char *) Tbase(b)+*(var_t*)BUNtloc(b,p)):(BUN)BUNtpos(b,p))

#define BUNfirst(b)	((BUN) (b)->batFirst)
#define BUNlast(b)	((BUN) ((char *) Bunbase(b) + (b)->batBuns->free))
#define BUNnext(b,p)	((BUN) ((char *) (p) + BUNsize(b)))
#define BUNprev(b,p)	((BUN) ((char *) (p) - BUNsize(b)))

#define BUNgetpos(b,p)	(((b)->batElmshift < 0)?\
				((p-BUNfirst(b)) / BUNsize(b)):\
				((p-BUNfirst(b)) >> (b)->batElmshift))


gdk_export str BATrename(BAT *b, str nme);
gdk_export size_t BATcount(BAT *b);
gdk_export size_t BATcount_no_nil(BAT *b);
gdk_export size_t BATbuncount(BAT *b);
gdk_export size_t BATguess(BAT *b);
gdk_export size_t BATgrows(BAT *b);
gdk_export BAT *BATkey(BAT *b, int onoff);
gdk_export BAT *BATset(BAT *b, int onoff);
gdk_export BAT *BATmode(BAT *b, int onoff);
gdk_export BAT *BATroles(BAT *b, str hnme, str tnme);
gdk_export BAT *BATcol_name(BAT *b, str tnme);
gdk_export int BATname(BAT *b, str nme);
gdk_export BAT *BATseqbase(BAT *b, oid o);
gdk_export BAT *BATsetaccess(BAT *b, int mode);
gdk_export int BATgetaccess(BAT *b);
gdk_export int BATcheckmodes(BAT *b, int persistent, int unloadable);


#define BATdirty(b)	((b)->batCopiedtodisk == 0 || (b)->batDirty ||	\
			(b)->batDirtydesc || (b)->batDirtybuns ||	\
			(b)->hheapdirty || (b)->theapdirty)

#define PERSISTENT	4096
#define SESSION		2048
#define TRANSIENT	1024

#define BAT_WRITE		0	/* all kinds of access allowed */
#define BAT_READ		1	/* only read-access allowed */
#define BAT_APPEND		2	/* only reads and appends allowed */

#define BATversion(b)	(b)->GDKversion
#define BATcapacity(b)	((size_t) (((b)->batElmshift<0)?		\
				   (((b)->batBuns->size)/BUNsize(b)):	\
				   (((b)->batBuns->size) >> (b)->batElmshift)))


gdk_export BAT *BATclear(BAT *b);
gdk_export BAT *BATcopy(BAT *b, int ht, int tt, int writeable);
gdk_export BAT *BATmark(BAT *b, oid base);
gdk_export BAT *BATnumber(BAT *b);
gdk_export BAT *BATgroup(BAT *b, int start, int incr, int grpsize);


/* Heap storage modes */
#define STORE_MEM	0	/* load into GDKmalloced memory */
#define STORE_MMAP	1	/* mmap() into virtual memory */
#define STORE_PRIV	2	/* BAT copy of copy-on-write mmap */
#define STORE_UNSET	((char)-1)/* no mode specified */

gdk_export size_t    GDK_mem_pagebits; /* page size for non-linear mmaps */
#define REMAP_PAGE_BITS    GDK_mem_pagebits
#define REMAP_PAGE_SIZE    (1 << REMAP_PAGE_BITS)
#define REMAP_PAGE_MASK    (REMAP_PAGE_SIZE - 1)
#define REMAP_PAGE_MAXBITS (REMAP_PAGE_BITS+3)
#define REMAP_PAGE_MAXSIZE (1<<REMAP_PAGE_MAXBITS) /* max page bytesize of unary BUN heap (8-byte atom) */

/* Buffer management advise for heaps */
#define BUF_NORMAL	0	/* No further special treatment */
#define BUF_RANDOM	1	/* Expect random page references */
#define BUF_SEQUENTIAL	2	/* Expect sequential page references */
#define BUF_WILLNEED	3	/* Will need these pages */
#define BUF_DONTNEED	4	/* Don't need these pages */

gdk_export BAT *BATload(str nme);
gdk_export BAT *BATload_intern(bat bid);
gdk_export BAT *BATsave(BAT *b);
gdk_export int BATmmap(BAT *b, int bn, int hh, int th );
gdk_export int BATmmap_pin(BAT *b);
gdk_export int BATmmap_unpin(BAT *b);
gdk_export int BATmadvise(BAT *b, int bn, int hh, int th );
gdk_export int BATdelete(BAT *b);
gdk_export size_t BATvmsize(BAT *b, int dirty);
gdk_export size_t BATmemsize(BAT *b, int dirty);

gdk_export int GDKfdlocate(str nme, str mode, str ext);
gdk_export FILE *GDKfilelocate(str nme, str mode, str ext);
gdk_export void GDKfilepath(str path, str nme, str mode, str ext);
gdk_export int GDKcreatedir(str nme);
gdk_export int GDKremovedir(str nme);

gdk_export char *GDKload(str nme, str ext, size_t size, size_t chunk, int mode);
gdk_export int GDKsave(str nme, str ext, void *buf, size_t size, int mode);
gdk_export int GDKunlink(str dir, str nme, str extension);
gdk_export int GDKmove(str dir1, str nme1, str ext1, str dir2, str nme2, str ext2);


gdk_export int BATprint(BAT *b);
gdk_export int BATprintf(stream *f, BAT *b);
gdk_export int BATmultiprintf(stream *f, int argc, BAT *argv[], int printoid, int order, int printorderby);


#define GDK_SORTED_REV	128	/* reversely sorted */
#define GDK_SORTED	65	/* 65 = (32 bits radix_clustered)<<1 + 1 */

gdk_export BAT *BATsort(BAT *b);
gdk_export BAT *BATsort_rev(BAT *b);
gdk_export BAT *BATorder(BAT *b);
gdk_export BAT *BATorder_rev(BAT *b);
gdk_export BAT *BATrevert(BAT *b);
gdk_export int BATordered(BAT *b);
gdk_export int BATordered_rev(BAT *b);
gdk_export BAT *BATssort(BAT *b);
gdk_export BAT *BATssort_rev(BAT *b);
gdk_export BAT *BATsorder(BAT *b);
gdk_export BAT *BATsorder_rev(BAT *b);

gdk_export void GDKqsort(void *a, void *base, size_t n, int width, int tpe, int loc);
gdk_export void GDKqsort_rev(void *a, void *base, size_t n, int width, int tpe, int loc);
gdk_export int GDKssort(void *a, void *base, size_t n, int width, int tpe, int loc);
gdk_export int GDKssort_rev(void *a, void *base, size_t n, int width, int tpe, int loc);

#define BAThordered(b)	(((b)->htype == TYPE_void)?GDK_SORTED:(b)->hsorted)
#define BATtordered(b)	(((b)->ttype == TYPE_void)?GDK_SORTED:(b)->tsorted)
#define BAThdense(b)	(BAThvoid(b) && (b)->hseqbase != oid_nil)
#define BATtdense(b)	(BATtvoid(b) && (b)->tseqbase != oid_nil)
#define BAThvoid(b)	(((b)->hdense&(b)->hsorted&1) || (b)->htype==TYPE_void)
#define BATtvoid(b)	(((b)->tdense&(b)->tsorted&1) || (b)->ttype==TYPE_void)
#define BAThkey(b)	(b->hkey != FALSE || BAThdense(b))
#define BATtkey(b)	(b->tkey != FALSE || BATtdense(b))

#define BATsetcount(b,cnt)	((b)->batCount = (cnt),(b)->batDirtydesc = TRUE)


typedef struct {
	BAT *b[2];		/* if loaded: BAT* handle + reverse */
	str nme[2];		/* logical name + reverse */
	str bak[2];		/* logical name + reverse backups */
	bat next[2];		/* next BBP slot in link list */
	BATstore *cache;	/* cached header info */
	str path;		/* dir + basename for storage */
	int refs;		/* in-memory references on which the loaded status of a BAT relies */
	int lrefs;		/* logical references on which the existence of a BAT relies */
	int lastused;		/* BBP LRU stamp */
	volatile int status;	/* status mask used for spin locking */
} BBPrec;

gdk_export bat BBPmaxsize;