opt_factorize.c

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

#line 92 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/optimizer/opt_factorize.mx"
#include "mal_config.h"
#include "opt_factorize.h"
#include "mal_interpreter.h"	/* for showErrors() */
#include "mal_builder.h"



#line 105 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/optimizer/opt_factorize.mx"
static int
OPTallowed(InstrPtr p)
{
	if (getModuleId(p) && strcmp(getModuleId(p), "batcalc") == 0) {
		if (isUnsafeInstruction(p))
			return 0;
	}
	return 1;
}

static int
OPTfactorizeImplementation(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	int i, k,  v, noop = 0, se;
	InstrPtr p;
	int fk = 0, sk = 0, blk = 0, blkstart = 0;
	int *varused, returnseen = 0;
	InstrPtr *first, *second;

	(void) pci;
	(void) stk;		/* to fool compilers */

	setLifespan(mb);
	varused = GDKmalloc(mb->vtop * sizeof(int));
	for (i = 0; i < mb->vtop; i++)
		varused[i] = 0;

	/* add parameters to use list */
	p = getInstrPtr(mb, 0);
	for (i = 0; i < p->argc; i++)
		varused[i] = 1;

	first = (InstrPtr *) GDKmalloc(mb->stop * sizeof(InstrPtr));
	second = (InstrPtr *) GDKmalloc(mb->stop * sizeof(InstrPtr));
	for (i = 0; i < mb->stop; i++)
		first[i] = second[i] = 0;

	first[fk++] = getInstrPtr(mb, 0);	/* to become a factory */
	for (i = 1; i < mb->stop - 1; i++) {
		p = getInstrPtr(mb, i);
		se = 0;
		for (k = 0; k < p->argc; k++)
			if (varused[p->argv[k]])
				se++;

		/* detect blocks they are moved to the second part */
		/* a more clever scheme can be designed though */
		if (p->barrier) {
			if (p->barrier == BARRIERsymbol || p->barrier == CATCHsymbol) {
				if (blkstart == 0)
					blkstart = i;
				blk++;
			} else if (p->barrier == EXITsymbol) {
				blk--;
				if (blk == 0)
					blkstart = 0;
			}
		}

		/* beware, none of the target variables may live
		   before the cut point.  */
		for (k = 0; k < p->retc; k++)
			if (getVar(mb, p->argv[k])->beginLifespan < i || !OPTallowed(p))
				se = 0;
		if (p->barrier == RETURNsymbol) {
			se = 1;
			p->barrier = YIELDsymbol;
			returnseen = 1;
		}

		if (se == 0 && blk == 0)
			first[fk++] = p;
		else {
			if (blkstart) {
				/* copy old block stuff */
				for (k = blkstart; k < i; k++)
					second[sk++] = first[k];
				fk = blkstart;
				blkstart = 0;
			}
			second[sk++] = p;
			for (k = 0; k < p->retc; k++)
				varused[p->argv[k]] = 1;
		}
	}
	second[sk++] = getInstrPtr(mb, i);
	/* detect need for factorization, assume so */
	if (noop || sk == 0) {
		GDKfree(varused);
		GDKfree(first);
		GDKfree(second);
		/* remove the FToptimizer request */
		return 1;
	}

	first[0]->token = FACTORYsymbol;

	GDKfree(mb->stmt);
	mb->stmt = (InstrPtr *) GDKmalloc((mb->stop + 4) * sizeof(InstrPtr));

	mb->stop = mb->stop + 4;

	k = 0;
	for (i = 0; i < fk; i++)
		mb->stmt[k++] = first[i];

	/* added control block */
	v = newVariable(mb, GDKstrdup("always"), TYPE_bit);
	p = newInstruction(NULL,BARRIERsymbol);
	pushReturn(mb, p, v);
	pushBit(mb,p,TRUE);
	mb->stmt[k++] = p;

	for (i = 0; i < sk - 1; i++)
		mb->stmt[k++] = second[i];

	/* finalize the factory */
	if (returnseen == 0) {
		p = newInstruction(NULL,YIELDsymbol);
		pushReturn(mb, p, findVariable(mb, getFcnName(mb)));
		mb->stmt[k++] = p;
	}
	p = newInstruction(NULL,REDOsymbol);
	pushReturn(mb, p, v);
	mb->stmt[k++] = p;

	p = newInstruction(NULL,EXITsymbol);
	pushReturn(mb, p, v);
	mb->stmt[k++] = p;

	/* add END statement */
	mb->stmt[k++] = second[i];

	mb->stop = k;

	GDKfree(varused);
	GDKfree(first);
	GDKfree(second);
	return 1;
}



#line 250 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/optimizer/opt_factorize.mx"

#line 248 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/optimizer/opt_factorize.mx"
/* #define _DEBUG_OPTIMIZER_*/
str OPTfactorize(MalBlkPtr mb, MalStkPtr stk, InstrPtr p){
	str modnme;
	str fcnnme;
	Module  scope=NULL;
	Symbol s= NULL;
	lng clk= GDKusec();
	int actions = 0;

	optimizerInit();
	if( p )
		removeInstruction(mb, p);
#ifdef _DEBUG_OPTIMIZER_
	stream_printf(GDKout,"apply factorize\n");
	printFunction(GDKout,mb,LIST_MAL_ALL);
#endif
	if( p && p->argc > 1 && getFunctionId(p) != multiplexRef){
#ifdef _DEBUG_OPTIMIZER_
		stream_printf(GDKout,"locate function factorize\n");
#endif
		if( getArgType(mb,p,1) != TYPE_str ||
			getArgType(mb,p,2) != TYPE_str ||
			!isConstant(mb,getArg(p,1)) ||
			!isConstant(mb,getArg(p,2))
		) {
			char buf[1024];
			snprintf(buf,1024, "Optimizer requires constant string arguments\n");
			throw(MAL, "optimizer.factorize",buf);
		}
		if( stk != 0){
			modnme= (str)getArgValue(stk,p,1);
			fcnnme= (str)getArgValue(stk,p,2);
		} else {
			modnme= getArgDefault(mb,p,1);
			fcnnme= getArgDefault(mb,p,2);
		}
		scope = findModule(MCgetClient()->nspace,putName(modnme,strlen(modnme)) );
		if( scope)
			s= findSymbolInModule(scope,putName(fcnnme,strlen(fcnnme)));

		if( s == NULL) {
			char buf[1024];
			snprintf(buf,1024, "Could not find %s.%s\n",modnme,fcnnme);
			throw(MAL, "optimizer.factorize",buf);
		}
#ifdef _DEBUG_OPTIMIZER_
		stream_printf(GDKout,"factorize %s %d\n",modnme,fcnnme);
#endif
		mb = s->def;
		stk= 0;
	} 
	if( mb->errors )
		return MAL_SUCCEED;
	addtoMalBlkHistory(mb);
	actions= OPTfactorizeImplementation(mb,stk,p);
#ifdef _DEBUG_OPTIMIZER_
	stream_printf(GDKout,"finished factorize %d\n",actions);
	printFunction(GDKout,mb,LIST_MAL_ALL);
#endif
    optimizerCheck(mb, "optimizer.factorize", actions, GDKusec() - clk,OPT_CHECK_ALL);
	return MAL_SUCCEED;
}


#line 250 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/optimizer/opt_factorize.mx"



#line 252 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/optimizer/opt_factorize.mx"