statistics.mx

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

	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;
}

@- Module initializaton
The content of this box my only be changed by the Administrator.
@c
#include "mal_client.h"
#include "mal_interpreter.h"
#include "mal_authorize.h"

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

@- Operator implementation
@c
#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 */
	if(STAT_id_inuse ==0) msg= STATprelude(&ret);
	if( msg != MAL_SUCCEED) return msg;
	authorize("open");
	if (openBox("statistics") != 0)
		return msg;
	throw(MAL, "statistics.open", "Failed to open statistics box");
}

str
STATclose(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	(void) mb;
	(void) stk;
	(void) pci;		/* fool compiler */
	authorize("close");
	if (closeBox("statistics", TRUE) == 0)
		return MAL_SUCCEED;
	throw(MAL, "statistics.close", "Failed to close box");
}

str
STATdestroy(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	Box box;

	(void) mb;
	(void) stk;
	(void) pci;		/* fool compiler */
	OpenBox("destroy");
	destroyBox("statistics");
	return MAL_SUCCEED;
}

@-
Access to a box calls for resolving the first parameter
to a named box.
@c
str
STATdepositStr(int *ret, str *nme)
{
	BAT *b;
	Box box;
	ValRecord val;
	int idx;
	str bnme;
	ptr p;

	b = BATdescriptor(idx = BBPindex(*nme));
	if (b == NULL)
		throw(MAL, "statistics.deposit", "BAT unknown");
	OpenBox("deposit");
	p= BUNfnd(BATmirror(STAT_id_nme),*nme);
	if( p) return MAL_SUCCEED;
	val.val.bval = idx;
	val.vtype = TYPE_bat;
	if (depositBox(box, *nme, &val))
		throw(MAL, "statistics.deposit", "Failed to deposit object  into box");
	bnme = BATgetId(b);
	return STATenroll(ret, &bnme);
}

str
STATdeposit(int *ret, int *bid)
{
	BAT *b;
	Box box;
	str msg;

	if ((b = BATdescriptor(*bid)) == NULL) {
		throw(MAL, "statistics.deposit", "Cannot access descriptor");
	}

	OpenBox("deposit");
	msg = BATgetId(b);
	msg = STATenroll(ret, &msg);
	BBPunfix(b->batCacheid);
	return msg;
}

str
STATtake(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	str name;
	Box box;
	ValPtr v;

	OpenBox("take");
	name = (str) getArgName(mb, pci, 1);
	v = &stk->stk[getArg(pci, 0)];
	if (takeBox(box, name, v, (int) getArgType(mb, pci, 0)))
		throw(MAL, "statistics.take", "Failed to take object from box");
	return MAL_SUCCEED;
}

str
STATrelease(int *ret, int *bid)
{
	BAT *b;
	Box box;

	(void) ret;
	OpenBox("release");
	if ((b = BATdescriptor(*bid)) == NULL) {
		throw(MAL, "statistics.release", "Cannot access descriptor");
	}
	BBPunfix(b->batCacheid);
	return MAL_SUCCEED;
}

str
STATreleaseStr(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	str name;
	Box box;

	(void) stk;		/* fool compiler */

	OpenBox("release");
	name = (str) getArgName(mb, pci, 1);
	if (releaseBox(box, name))
		throw(MAL, "statistics.release", "Failed to release object from box");
	return MAL_SUCCEED;
}

@-
We should keep track of all BATs taken from the Box, for this
can be used to upgrade the information quickly.
For example, the update functio only looks at those in use to detect
stale information. All others are only updated with a forceful update.
The release policy is not yet implemented.
@c
str
STATreleaseAll(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	Box box;

	(void) mb;
	(void) stk;
	(void) pci;		/* fool compiler */
	OpenBox("release");
	releaseAllBox(box);
	return MAL_SUCCEED;
}

str
STATdiscard(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	str name;
	Box box;

	(void) mb;		/* fool compiler */
	OpenBox("discard");
	name = (str) getArgValue(stk, pci, 1);
	return STATdrop(name);
}

str
STATdiscard2(int *ret, int *bid)
{
	BAT *b;
	Box box;
	str msg;

	(void) ret;
	OpenBox("discard");
	if ((b = BATdescriptor(*bid)) == NULL) {
		throw(MAL, "statistics.discard", "Cannot access descriptor");
	}

	msg = STATdrop(BATgetId(b));
	BBPunfix(b->batCacheid);
	return msg;
}

str
STATtoString(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	Box box;
	int i, len = 0;
	ValPtr v;
	str nme, s = 0;

	(void) mb;		/* fool compiler */
	OpenBox("toString");
	nme = (str) getArgValue(stk, pci, 1);
	i = findVariable(box->sym, nme);
	if (i < 0)
		throw(MAL, "statistics.toString", "Failed to take object from box");

	v = &box->val->stk[i];
	if (v->vtype == TYPE_str)
		s = v->val.sval;
	else
		(*BATatoms[v->vtype].atomToStr) (&s, &len, v);
	if (s == NULL)
		throw(MAL, "statistics.toString", "Illegal value");
	VALset(&stk->stk[getArg(pci, 0)], TYPE_str, s);
	return MAL_SUCCEED;
}

str
STATnewIterator(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	Box box;
	lng *cursor;
	ValPtr v;

	(void) mb;		/* fool compiler */
	OpenBox("iterator");
	cursor = (lng *) getArgValue(stk, pci, 0);
	v = &stk->stk[getArg(pci, 1)];
	nextBoxElement(box, cursor, v);
	return MAL_SUCCEED;
}

str
STAThasMoreElements(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	Box box;
	lng *cursor;
	ValPtr v;

	(void) mb;		/* fool compiler */
	OpenBox("iterator");
	cursor = (lng *) getArgValue(stk, pci, 0);
	v = &stk->stk[getArg(pci, 1)];
	nextBoxElement(box, cursor, v);
	return MAL_SUCCEED;
}

str
STATgetHotset(int *bid)
{
	BAT *b;
	Box box;

	OpenBox("getHotset");
	b = BATjoin(STAT_id_inuse, STAT_id_nme, BATcount(STAT_id_nme));
	BBPincref(*bid = b->batCacheid, TRUE);
	return MAL_SUCCEED;
}

str
STATgetObjects(int *bid)
{
	*bid = STAT_id_nme->batCacheid;
	BBPincref(*bid, TRUE);
	return MAL_SUCCEED;
}

@-
@= stat
s_export str STATget@1(lng *ret, str *nme);
str
STATget@1(lng *ret, str *nme){
	Box box;
	ptr p;
	int i;
	OpenBox("get@1");
	p= BUNfnd(BATmirror(STAT_id_nme),*nme);
	if( p == NULL)
		throw(MAL, "statistics.get@1","Object not known");
	i= *(int*) BUNhead(STAT_id_nme,p);
	p= BUNfnd(STAT_id_@2, &i );
	if( p == NULL)
		throw(MAL, "statistics.get@1","Not known");
	*ret = *(lng*)BUNtail(STAT_id_@2,p);
	return MAL_SUCCEED;
}
@c
@:stat(Count,count)@
@:stat(Size,size)@
@:stat(Min,min_lng)@
@:stat(Max,max_lng)@


str
STATgetHistogram(int *ret, str *nme)
{
	ptr p;
	int i;
	BAT *h;
	Box box;

	OpenBox("getHistogram");
	p = BUNfnd(BATmirror(STAT_id_nme), *nme);
	if (p == NULL)
		throw(MAL, "statistics.getHistogram", "BAT not known");
	i= *(int*) BUNhead(STAT_id_nme,p);
	p = BUNfnd(STAT_id_histogram, &i);
	if (p == NULL)
		throw(MAL, "statistics.getHistogram", "Histogram not known");
	i = BBPindex((str) BUNtail(STAT_id_histogram, p));
	if (i == 0)
		throw(MAL, "statistics.getHistogram", "Histogram disappeared");
	h = BATdescriptor(i);
	BBPincref(*ret = h->batCacheid, TRUE);
	return MAL_SUCCEED;
}
@}