int
OPTevaluateImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
InstrPtr p;
int i, k, limit, *alias, barrier;
MalStkPtr env = NULL;
int profiler;
str msg;
int debugstate = cntxt->itrace, actions = 0, constantblock = 0;
int *assigned, setonce;
cntxt->itrace = 0;
(void)stk;
(void)pci;
if (varGetProp(mb, getArg(mb->stmt[0], 0), inlineProp) != NULL)
return 0;
(void)cntxt;
OPTDEBUGevaluate mnstr_printf(cntxt->fdout, "Constant expression optimizer started\n");
assigned = (int*) GDKzalloc(sizeof(int) * mb->vtop);
if (assigned == NULL)
return 0;
alias = (int*)GDKzalloc(mb->vsize * sizeof(int) * 2); /* we introduce more */
if (alias == NULL){
GDKfree(assigned);
return 0;
}
// arguments are implicitly assigned by context
p = getInstrPtr(mb, 0);
for ( k =p->retc; k < p->argc; k++)
assigned[getArg(p,k)]++;
limit = mb->stop;
for (i = 1; i < limit; i++) {
p = getInstrPtr(mb, i);
// The double count emerging from a barrier exit is ignored.
if (! blockExit(p) || (blockExit(p) && p->retc != p->argc))
for ( k =0; k < p->retc; k++)
assigned[getArg(p,k)]++;
}
for (i = 1; i < limit; i++) {
p = getInstrPtr(mb, i);
for (k = p->retc; k < p->argc; k++)
if (alias[getArg(p, k)])
getArg(p, k) = alias[getArg(p, k)];
// to avoid management of duplicate assignments over multiple blocks
// we limit ourselfs to evaluation of the first assignment only.
setonce = assigned[getArg(p,0)] == 1;
OPTDEBUGevaluate printInstruction(cntxt->fdout, mb, 0, p, LIST_MAL_ALL);
constantblock += blockStart(p) && OPTallConstant(cntxt,mb,p);
/* be aware that you only assign once to a variable */
if (setonce && p->retc == 1 && OPTallConstant(cntxt, mb, p) && !isUnsafeFunction(p)) {
barrier = p->barrier;
p->barrier = 0;
profiler = malProfileMode; /* we don't trace it */
malProfileMode = 0;
if ( env == NULL) {
env = prepareMALstack(mb, 2 * mb->vsize );
env->keepAlive = TRUE;
}
msg = reenterMAL(cntxt, mb, i, i + 1, env);
malProfileMode= profiler;
p->barrier = barrier;
OPTDEBUGevaluate {
mnstr_printf(cntxt->fdout, "#retc var %s\n", getVarName(mb, getArg(p, 0)));
mnstr_printf(cntxt->fdout, "#result:%s\n", msg == MAL_SUCCEED ? "ok" : msg);
}
if (msg == MAL_SUCCEED) {
int nvar;
ValRecord cst;
actions++;
cst.vtype = 0;
VALcopy(&cst, &env->stk[getArg(p, 0)]);
/* You may not overwrite constants. They may be used by
* other instructions */
nvar = getArg(p, 1) = defConstant(mb, getArgType(mb, p, 0), &cst);
if (nvar >= env->stktop) {
VALcopy(&env->stk[getArg(p, 1)], &getVarConstant(mb, getArg(p, 1)));
env->stktop = getArg(p, 1) + 1;
}
alias[getArg(p, 0)] = getArg(p, 1);
p->argc = 2;
p->token = ASSIGNsymbol;
clrFunction(p);
p->barrier = barrier;
/* freeze the type */
setVarFixed(mb,getArg(p,1));
setVarUDFtype(mb,getArg(p,1));
OPTDEBUGevaluate {
mnstr_printf(cntxt->fdout, "Evaluated new constant=%d -> %d:%s\n",
getArg(p, 0), getArg(p, 1), getTypeName(getArgType(mb, p, 1)));
}
} else {
int
inlineMALblock(MalBlkPtr mb, int pc, MalBlkPtr mc)
{
int i, k, l, n;
InstrPtr *ns, p,q;
int *nv, *np = NULL;
p = getInstrPtr(mb, pc);
q = getInstrPtr(mc, 0);
ns = GDKzalloc((l = (mb->ssize + mc->ssize + p->retc - 3)) * sizeof(InstrPtr));
if (ns == NULL)
return -1;
if ( mc->ptop > 0){
np = (int*) GDKmalloc(mc->ptop * sizeof(int));
if (np == 0){
GDKfree(ns);
return -1;
}
}
nv = (int*) GDKmalloc(mc->vtop * sizeof(int));
if (nv == 0){
GDKfree(ns);
if( np)
GDKfree(np);
return -1;
}
/* add all properties of the new block to the target environment */
for (n = 0; n < mc->ptop; n++) {
int propid = newProperty(mb);
if (propid < 0) {
assert(0);
return -1;
}
np[n] = propid;
mb->prps[propid].idx = mc->prps[n].idx;
mb->prps[propid].op = mc->prps[n].op;
mb->prps[propid].var = mc->prps[n].var; /* fixed later */
}
/* add all variables of the new block to the target environment */
for (n = 0; n < mc->vtop; n++) {
VarPtr ov, v;
if (isExceptionVariable(mc->var[n]->name)) {
nv[n] = newVariable(mb,GDKstrdup(mc->var[n]->name),TYPE_str);
if (isVarUDFtype(mc,n))
setVarUDFtype(mb,nv[n]);
if (isVarUsed(mc,n))
setVarUsed(mb,nv[n]);
} else if (isVarTypedef(mc,n)) {
nv[n] = newTypeVariable(mb,getVarType(mc,n));
} else if (isVarConstant(mc,n)) {
nv[n] = cpyConstant(mb,getVar(mc,n));
} else {
nv[n] = newTmpVariable(mb, getVarType(mc, n));
if (isVarUDFtype(mc,n))
setVarUDFtype(mb,nv[n]);
if (isVarUsed(mc,n))
setVarUsed(mb,nv[n]);
}
/* remap the properties */
ov = getVar(mc, n);
v = getVar(mb, nv[n]);
if (ov->propc > v->maxprop) {
int size = sizeof(VarRecord);
VarPtr vnew = (VarPtr) GDKzalloc(size + ov->propc * sizeof(int));
memcpy((char*) vnew, (char*) v, size);
vnew->maxprop = ov->propc;
mb->var[nv[n]] = vnew;
GDKfree(v);
v = getVar(mb, nv[n]);
}
for (i = 0; i < ov->propc; i++)
v->prps[i] = np[ov->prps[i]];
v->propc = ov->propc;
}
/* change the property variables to the new context */
for (n = 0; n < mc->ptop; n++) {
if (mc->prps[n].var)
mb->prps[np[n]].var = nv[mc->prps[n].var];
assert( mb->prps[np[n]].var >= 0);
}
/* use an alias mapping to keep track of the actual arguments */
for (n = p->retc; n < p->argc; n++)
nv[getArg(q,n)] = getArg(p, n);
k = 0;
/* find the return statement of the inline function */
for (i = 1; i < mc->stop - 1; i++) {
q = mc->stmt[i];
if( q->barrier== RETURNsymbol || q->barrier== YIELDsymbol){
/* add the mapping of the return variables */
for(n=0; n<p->retc; n++)
nv[getArg(q,n)] = getArg(p,n);
}
}
/* copy the stable part */
for (i = 0; i < pc; i++)
ns[k++] = mb->stmt[i];
for (i = 1; i < mc->stop - 1; i++) {
q = mc->stmt[i];
if( q->token == ENDsymbol)
break;
/* copy the instruction and fix variable references */
ns[k] = copyInstruction(q);
for (n = 0; n < q->argc; n++)
getArg(ns[k], n) = nv[getArg(q, n)];
if (q->barrier == RETURNsymbol || q->barrier == YIELDsymbol) {
for(n=0; n<q->retc; n++)
clrVarFixed(mb,getArg(ns[k],n)); /* for typing */
setModuleId(ns[k],getModuleId(q));
setFunctionId(ns[k],getFunctionId(q));
ns[k]->barrier = 0;
ns[k]->token = ASSIGNsymbol;
}
k++;
}
/* copy the remainder of the stable part */
freeInstruction(p);
for (i = pc + 1; i < mb->stop; i++){
ns[k++] = mb->stmt[i];
}
/* remove any free instruction */
for(; i<mb->ssize; i++)
if( mb->stmt[i]){
freeInstruction(mb->stmt[i]);
mb->stmt[i]= 0;
}
GDKfree(mb->stmt);
mb->stmt = ns;
mb->ssize = l;
mb->stop = k;
GDKfree(np);
GDKfree(nv);
return pc;
}
str
OPTevaluateImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
InstrPtr p;
int i, k, limit, *alias = 0, barrier;
MalStkPtr env = NULL;
int profiler;
int debugstate = cntxt->itrace, actions = 0, constantblock = 0;
int *assigned = 0, use;
char buf[256];
lng usec = GDKusec();
str msg = MAL_SUCCEED;
(void)stk;
(void)pci;
if ( mb->inlineProp )
return MAL_SUCCEED;
cntxt->itrace = 0;
#ifdef DEBUG_OPT_EVALUATE
fprintf(stderr, "Constant expression optimizer started\n");
#endif
assigned = (int*) GDKzalloc(sizeof(int) * mb->vtop);
if (assigned == NULL)
throw(MAL,"optimzier.evaluate", SQLSTATE(HY001) MAL_MALLOC_FAIL);
alias = (int*)GDKzalloc(mb->vsize * sizeof(int) * 2); /* we introduce more */
if (alias == NULL){
GDKfree(assigned);
throw(MAL,"optimzier.evaluate", SQLSTATE(HY001) MAL_MALLOC_FAIL);
}
// arguments are implicitly assigned by context
p = getInstrPtr(mb, 0);
for ( k =p->retc; k < p->argc; k++)
assigned[getArg(p,k)]++;
limit = mb->stop;
for (i = 1; i < limit; i++) {
p = getInstrPtr(mb, i);
// The double count emerging from a barrier exit is ignored.
if (! blockExit(p) || (blockExit(p) && p->retc != p->argc))
for ( k =0; k < p->retc; k++)
if ( p->retc != p->argc || p->token != ASSIGNsymbol )
assigned[getArg(p,k)]++;
}
for (i = 1; i < limit && cntxt->mode != FINISHCLIENT; i++) {
p = getInstrPtr(mb, i);
// to avoid management of duplicate assignments over multiple blocks
// we limit ourselves to evaluation of the first assignment only.
use = assigned[getArg(p,0)] == 1 && !(p->argc == p->retc && blockExit(p));
for (k = p->retc; k < p->argc; k++)
if (alias[getArg(p, k)])
getArg(p, k) = alias[getArg(p, k)];
#ifdef DEBUG_OPT_EVALUATE
fprintInstruction(stderr , mb, 0, p, LIST_MAL_ALL);
#endif
/* be aware that you only assign once to a variable */
if (use && p->retc == 1 && OPTallConstant(cntxt, mb, p) && !isUnsafeFunction(p)) {
barrier = p->barrier;
p->barrier = 0;
profiler = malProfileMode; /* we don't trace it */
malProfileMode = 0;
if ( env == NULL) {
env = prepareMALstack(mb, 2 * mb->vsize);
if (!env) {
msg = createException(MAL,"optimizer.evaluate", SQLSTATE(HY001) MAL_MALLOC_FAIL);
goto wrapup;
}
env->keepAlive = TRUE;
}
msg = reenterMAL(cntxt, mb, i, i + 1, env);
malProfileMode= profiler;
p->barrier = barrier;
#ifdef DEBUG_OPT_EVALUATE
fprintf(stderr, "#retc var %s\n", getVarName(mb, getArg(p, 0)));
fprintf(stderr, "#result:%s\n", msg == MAL_SUCCEED ? "ok" : msg);
#endif
if (msg == MAL_SUCCEED) {
int nvar;
ValRecord cst;
actions++;
cst.vtype = 0;
VALcopy(&cst, &env->stk[getArg(p, 0)]);
/* You may not overwrite constants. They may be used by
* other instructions */
nvar = getArg(p, 1) = defConstant(mb, getArgType(mb, p, 0), &cst);
if (nvar >= env->stktop) {
VALcopy(&env->stk[getArg(p, 1)], &getVarConstant(mb, getArg(p, 1)));
env->stktop = getArg(p, 1) + 1;
}
alias[getArg(p, 0)] = getArg(p, 1);
p->argc = 2;
p->token = ASSIGNsymbol;
clrFunction(p);
p->barrier = barrier;
/* freeze the type */
setVarFixed(mb,getArg(p,1));
setVarUDFtype(mb,getArg(p,1));
#ifdef DEBUG_OPT_EVALUATE
{str tpename;
fprintf(stderr, "Evaluated new constant=%d -> %d:%s\n",
getArg(p, 0), getArg(p, 1), tpename = getTypeName(getArgType(mb, p, 1)));
GDKfree(tpename);
}
#endif
} else {
/* if there is an error, we should postpone message handling,
as the actual error (eg. division by zero ) may not happen) */
#ifdef DEBUG_OPT_EVALUATE
fprintf(stderr, "Evaluated %s\n", msg);
#endif
freeException(msg);
msg= MAL_SUCCEED;
mb->errors = 0;
}
}
constantblock += blockStart(p) && OPTallConstant(cntxt, mb, p); /* default */
}
// produces errors in SQL when enabled
if ( constantblock)
msg = OPTremoveUnusedBlocks(cntxt, mb);
cntxt->itrace = debugstate;
/* Defense line against incorrect plans */
/* Plan is unaffected */
chkTypes(cntxt->usermodule, mb, FALSE);
chkFlow(mb);
chkDeclarations(mb);
/* keep all actions taken as a post block comment */
usec = GDKusec()- usec;
snprintf(buf,256,"%-20s actions=%2d time=" LLFMT " usec","evaluate",actions,usec);
newComment(mb,buf);
if( actions >= 0)
addtoMalBlkHistory(mb);
wrapup:
if ( env) freeStack(env);
if(assigned) GDKfree(assigned);
if(alias) GDKfree(alias);
return msg;
}
/*
* Keeping variables around beyond their end-of-life-span
* can be marked with the proper 'keep'.
*/
int
OPTgarbageCollectorImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
int i, j, k, n = 0, limit, vlimit, depth=0, slimit;
InstrPtr p, q, *old;
int actions = 0;
Lifespan span;
(void) pci;
(void) cntxt;
(void) stk;
if (varGetProp(mb, getArg(mb->stmt[0], 0), inlineProp) != NULL)
return 0;
span = setLifespan(mb);
if ( span == NULL)
return 0;
old= mb->stmt;
limit = mb->stop;
slimit = mb->ssize;
vlimit = mb->vtop;
if ( newMalBlkStmt(mb,mb->ssize) < 0) {
GDKfree(span);
return 0;
}
p = NULL;
for (i = 0; i < limit; i++) {
p = old[i];
p->gc &= ~GARBAGECONTROL;
if ( p->barrier == RETURNsymbol){
pushInstruction(mb, p);
continue;
}
if (blockStart(p) )
depth++;
if ( p->token == ENDsymbol)
break;
pushInstruction(mb, p);
n = mb->stop-1;
for (j = 0; j < p->argc; j++) {
if (getEndLifespan(span,getArg(p,j)) == i && isaBatType(getArgType(mb, p, j)) ){
mb->var[getArg(p,j)]->eolife = n;
p->gc |= GARBAGECONTROL;
}
}
if (blockExit(p) ){
/* force garbage collection of all within upper block */
depth--;
for (k = 0; k < vlimit; k++) {
if (getBeginLifespan(span,k) > 0 &&
getEndLifespan(span,k) == i &&
isaBatType(getVarType(mb,k)) &&
varGetProp(mb, k, keepProp) == NULL){
q= newAssignment(mb);
getArg(q,0) = k;
setVarUDFtype(mb,k);
setVarFixed(mb,k);
q= pushNil(mb,q, getVarType(mb,k));
q->gc |= GARBAGECONTROL;
mb->var[k]->eolife = mb->stop-1;
actions++;
}
}
}
}
assert(p);
assert( p->token == ENDsymbol);
pushInstruction(mb, p);
for (i++; i < limit; i++)
pushInstruction(mb, old[i]);
for (; i < slimit; i++)
if (old[i])
freeInstruction(old[i]);
getInstrPtr(mb,0)->gc |= GARBAGECONTROL;
GDKfree(old);
OPTDEBUGgarbageCollector{
int k;
mnstr_printf(cntxt->fdout, "#Garbage collected BAT variables \n");
for ( k =0; k < vlimit; k++)
mnstr_printf(cntxt->fdout,"%10s eolife %3d begin %3d lastupd %3d end %3d\n",
getVarName(mb,k), mb->var[k]->eolife,
getBeginLifespan(span,k), getLastUpdate(span,k), getEndLifespan(span,k));
mnstr_printf(cntxt->fdout, "End of GCoptimizer\n");
}
GDKfree(span);
return actions+1;
}
