statistics.c

一个内存数据库的源代码这是服务器端还有客户端

#line 195 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/statistics.mx"
#include "mal_config.h"
#include "statistics.h"
#include "algebra.h"
s_export str STATforceUpdateAll(int *ret);
s_export str STATdrop(str nme);
s_export str STATforceUpdateAll(int *ret);
s_export str STATenroll(int *ret, str *nme);
s_export str STATenrollHistogram(int *ret, str *nme);
s_export str STATupdateAll(int *ret, int forced);
s_export str STATupdate(int *ret);
s_export str STATforceUpdate(int *ret, str *nme);
s_export str STATdump(int *ret);
s_export str STATprelude(int *ret);
s_export str STATepilogue(int *ret);
s_export str STATopen(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
s_export str STATclose(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
s_export str STATdestroy(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
s_export str STATdepositStr(int *ret, str *nme);
s_export str STATdeposit(int *ret, int *bid);
s_export str STATtake(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
s_export str STATrelease(int *ret, int *bid);
s_export str STATreleaseStr(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
s_export str STATreleaseAll(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
s_export str STATdiscard(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
s_export str STATdiscard2(int *ret, int *bid);
s_export str STATtoString(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
s_export str STATnewIterator(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
s_export str STAThasMoreElements(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
s_export str STATgetHotset(int *bid);
s_export str STATgetObjects(int *bid);
s_export str STATgetHistogram(int *ret, str *nme);


BAT *STAT_id_inuse;		/* BATs information taken from the box */
BAT *STAT_id_nme;		/* mapping from BBP index */
BAT *STAT_id_expire;
BAT *STAT_id_stamp;		/* BAT last time stamp */
BAT *STAT_id_count;
BAT *STAT_id_size;
BAT *STAT_id_min_lng;
BAT *STAT_id_max_lng;
BAT *STAT_id_histogram;



#line 242 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/statistics.mx"
static int statisticsMode= TRANSIENT;

static BAT *
STAT_create(str hnme, str tnme, int ht, int tt)
{
	BAT *b;
	char buf[128];

	snprintf(buf, 128, "stat_%s_%s", hnme, tnme);
	b = BATdescriptor(BBPindex(buf));
	if (b)
		return b;

	b = BATnew(ht, tt, 256);
	if (b == NULL)
		GDKfatal("STAT_create: could not allocate.");

	BATkey(b, TRUE);
	BBPrename(b->batCacheid, buf);
	BATmode(b, statisticsMode);
#ifdef DEBUG_STATISTICS
	printf("created %s\n", buf);
#endif
	return b;
}

static void
STATcommit()
{
	BAT *b = BATnew(TYPE_void, TYPE_str, 10);
	BATseqbase(b,0);
	BUNappend(b, BBPname(STAT_id_inuse->batCacheid), FALSE);
	BUNappend(b, BBPname(STAT_id_nme->batCacheid), FALSE);
	BUNappend(b, BBPname(STAT_id_expire->batCacheid), FALSE);
	BUNappend(b, BBPname(STAT_id_stamp->batCacheid), FALSE);
	BUNappend(b, BBPname(STAT_id_count->batCacheid), FALSE);
	BUNappend(b, BBPname(STAT_id_size->batCacheid), FALSE);
	BUNappend(b, BBPname(STAT_id_min_lng->batCacheid), FALSE);
	BUNappend(b, BBPname(STAT_id_max_lng->batCacheid), FALSE);
	BUNappend(b, BBPname(STAT_id_histogram->batCacheid), FALSE);
	TMsubcommit(b);
	BBPreclaim(b);
}

static void
STATinit()
{
	if( STAT_id_inuse) 
		return;
	mal_set_lock(mal_contextLock, "statistics");
	STAT_id_inuse = STAT_create("id", "inuse", TYPE_int, TYPE_int);
	STAT_id_nme = STAT_create("id", "nme", TYPE_int, TYPE_str);
	STAT_id_expire = STAT_create("id", "expire", TYPE_int, TYPE_int);
	STAT_id_stamp = STAT_create("id", "stamp", TYPE_int, TYPE_int);
	STAT_id_count = STAT_create("id", "count", TYPE_int, TYPE_lng);
	STAT_id_size = STAT_create("id", "size", TYPE_int, TYPE_lng);
	STAT_id_min_lng = STAT_create("id", "min_lng", TYPE_int, TYPE_lng);
	STAT_id_max_lng = STAT_create("id", "max_lng", TYPE_int, TYPE_lng);
	STAT_id_histogram = STAT_create("id", "histogram", TYPE_int, TYPE_str);
	STATcommit();
	mal_unset_lock(mal_contextLock, "statistics");
}

static void
STATexit()
{
	if(STAT_id_inuse ==0) return;
	mal_set_lock(mal_contextLock, "statistics");

	BBPreclaim(STAT_id_inuse);
	BBPreclaim(STAT_id_nme);
	BBPreclaim(STAT_id_expire);
	BBPreclaim(STAT_id_stamp);
	BBPreclaim(STAT_id_count);
	BBPreclaim(STAT_id_size);
	BBPreclaim(STAT_id_min_lng);
	BBPreclaim(STAT_id_max_lng);
	BBPreclaim(STAT_id_histogram);

	STAT_id_inuse= NULL;
	STAT_id_nme= NULL;
	STAT_id_expire= NULL;
	STAT_id_stamp= NULL;
	STAT_id_count= NULL;
	STAT_id_size= NULL;
	STAT_id_min_lng= NULL;
	STAT_id_max_lng= NULL;
	STAT_id_histogram= NULL;

	TMcommit();
	mal_unset_lock(mal_contextLock, "statistics");
}

str
STATdrop(str nme)
{
	ptr p;
	int idx;

	if(STAT_id_inuse ==0) 
		throw(MAL, "statistics.drop","Statistics not initialized");
	p = BUNfnd(BATmirror(STAT_id_nme), nme);
	if (p == 0)
		throw(MAL, "statistics.drop", "BAT not enrolled");
	idx = *(int *) BUNhead(STAT_id_nme,p);
	BUNdelHead(STAT_id_nme, &idx, FALSE);
	BUNdelHead(STAT_id_expire, &idx, FALSE);
	BUNdelHead(STAT_id_stamp, &idx, FALSE);
	BUNdelHead(STAT_id_count, &idx, FALSE);
	BUNdelHead(STAT_id_size, &idx, FALSE);
	BUNdelHead(STAT_id_min_lng, &idx, FALSE);
	BUNdelHead(STAT_id_max_lng, &idx, FALSE);
	BUNdelHead(STAT_id_histogram, &idx, FALSE);
	BUNdelHead(STAT_id_inuse, &idx, FALSE);
	STATcommit();
	return MAL_SUCCEED;
}

str
STATenroll(int *ret, str *nme)
{
	return STATforceUpdate(ret, nme);
}

str
STATenrollHistogram(int *ret, str *nme)
{
	(void) ret;
	(void) nme;
	return MAL_SUCCEED;
}



#line 379 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/statistics.mx"
str
STATupdateAll(int *ret, int forced)
{
	BAT *b;
	BUN p, q;
	str name;
	int i;

	if (STAT_id_nme)
		BATloop(STAT_id_nme, p, q) {
		name = (str) BUNtail(STAT_id_nme, p);
#ifdef DEBUG_STATISTICS
		stream_printf(GDKout, "update statistics of %d\n", name);
#endif
		i = BBPindex(name);
		if (i == 0)
			continue;
		if (forced == FALSE && BUNfnd(STAT_id_inuse, &i) == 0)
			continue;
		b = BATdescriptor(i);
		if (b == 0) {
			/* BAT disappeared */
			STATdiscard2(ret, &i);
			continue;
		}
		/* check the modification time with histogram */
		/* if BBPolder(i,j) ) */  {
			STATforceUpdate(ret, &name);
		}
		}

	return MAL_SUCCEED;
}

str
STATupdate(int *ret)
{
	return STATupdateAll(ret, FALSE);
}

str
STATforceUpdateAll(int *ret)
{
	return STATupdateAll(ret, TRUE);
}



#line 429 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/statistics.mx"
str
STATforceUpdate(int *ret, str *nme)
{
	BAT *b, *h;
	char buf[PATHLENGTH];
	ptr p;
	lng cnt;
	int idx;

	(void) ret;
	if(STAT_id_inuse ==0) return MAL_SUCCEED;
	b = BATdescriptor(idx = BBPindex(*nme));
	if (b == 0)
		throw(MAL, "statistics.forceUpdate", "Could not find BAT");
	p = BUNfnd(STAT_id_nme, &idx);
	if (p)
		BUNdelete(STAT_id_nme, p, FALSE);
	BUNins(STAT_id_nme, &idx, *nme, FALSE);
	cnt = BATcount(b);
	p = BUNfnd(STAT_id_count, &idx);
	if (p)
		BUNdelete(STAT_id_count, p, FALSE);
	BUNins(STAT_id_count, &idx, &cnt, FALSE);

	cnt = BATmemsize(b, 0);
	p = BUNfnd(STAT_id_size, &idx);
	if (p)
		BUNdelete(STAT_id_size, p, FALSE);
	BUNins(STAT_id_size, &idx, &cnt, FALSE);

	p = BUNfnd(STAT_id_min_lng, &idx);
	if (p)
		BUNdelete(STAT_id_min_lng, p, FALSE);
	p = BUNfnd(STAT_id_max_lng, &idx);
	if (p)
		BUNdelete(STAT_id_max_lng, p, FALSE);

	if (b->ttype == TYPE_int) {
		int val;
		BATmin(b, &val); cnt = val;
		BUNins(STAT_id_min_lng, &idx, &cnt, FALSE);
		BATmax(b, &val); cnt = val;
		BUNins(STAT_id_max_lng, &idx, &cnt, FALSE);
	} else {
		BUNins(STAT_id_min_lng, &idx, (ptr)&lng_nil, FALSE);
		BUNins(STAT_id_max_lng, &idx, (ptr)&lng_nil, FALSE);
	}
	h = BAThistogram(b);
	if (h == 0)
		return MAL_SUCCEED;
	snprintf(buf, PATHLENGTH, "H%s", BATgetId(b));
	BBPrename(h->batCacheid, buf);
	BATmode(h, statisticsMode); 
	BBPincref(h->batCacheid, TRUE);
	BATcommit(h);

	p = BUNfnd(STAT_id_histogram, &idx);
	if (p)
		BUNdelete(STAT_id_histogram, p, FALSE);
	BUNins(STAT_id_histogram, &idx, BATgetId(h), FALSE);

	p = BUNfnd(STAT_id_inuse, &idx);
	if (p)
		BUNdelete(STAT_id_inuse, p, FALSE);
	BUNins(STAT_id_inuse, &idx, &idx, FALSE);
	STATcommit();
	return MAL_SUCCEED;
}

str
STATdump(int *ret)
{
	BAT *piv[MAXPARAMS];

	(void) ret;
	if(STAT_id_inuse ==0) return MAL_SUCCEED;
	piv[0] = STAT_id_nme;
	/* STAT_id_expire, */
	/* STAT_id_stamp, */
	piv[1] = STAT_id_count;
	piv[2] = STAT_id_size;
	piv[3] = STAT_id_min_lng;
	piv[4] = STAT_id_max_lng;
	piv[5] = STAT_id_histogram;

	BATmultiprintf(GDKout, 6 + 1, piv, 0, 1, 1);
	return MAL_SUCCEED;
}



#line 521 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/statistics.mx"
#include "mal_client.h"
#include "mal_interpreter.h"
#include "mal_authorize.h"

#define authorize(X)\
{ str tmp = NULL; rethrow("statistics." X, tmp, AUTHrequireAdmin()); }



#line 530 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/statistics.mx"
#define OpenBox(X) \
	authorize(X); \
	box= findBox("statistics"); \
	if( box ==0) \
	throw(MAL, "statistics."X,"Box is not open");

str
STATprelude(int *ret)
{
	Box box;

	box = openBox("statistics");
	if (box == 0)
		throw(MAL, "statistics.prelude", "Failed to open box");
	STATinit();
	STATupdate(ret);
	return MAL_SUCCEED;
}

str
STATepilogue(int *ret)
{
	(void)ret;
	closeBox("statistics", 0);
	STATexit();
	return MAL_SUCCEED;
}

str
STATopen(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	int ret;
	str msg=MAL_SUCCEED;

	(void) mb;
	(void) stk;
	(void) pci;		/* fool compiler */