/* check for updates inbetween assignment to variables newv and oldv */
static int
no_updates(InstrPtr *old, int *vars, int oldv, int newv)
{
while(newv > oldv) {
InstrPtr q = old[vars[newv]];
if (isUpdateInstruction(q))
return 0;
newv = getArg(q, 1);
}
return 1;
}
int
OPTrecyclerImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p)
{
int i, j, cnt, tp, c, actions = 0, marks = 0, delta = 0;
Lifespan span;
InstrPtr *old, q;
int limit, updstmt = 0;
char *recycled;
short app_sc = -1, in = 0;
ValRecord cst;
(void) cntxt;
(void) stk;
limit = mb->stop;
old = mb->stmt;
for (i = 1; i < limit; i++) {
p = old[i];
if (getModuleId(p) == sqlRef &&
(getFunctionId(p) == affectedRowsRef ||
getFunctionId(p) == exportOperationRef ||
getFunctionId(p) == appendRef ||
getFunctionId(p) == updateRef ||
getFunctionId(p) == deleteRef))
updstmt = 1;
}
span = setLifespan(mb);
if (span == NULL)
return 0;
/* watch out, newly created instructions may introduce new variables */
recycled = GDKzalloc(sizeof(char) * mb->vtop * 2);
if (recycled == NULL)
return 0;
if (newMalBlkStmt(mb, mb->ssize) < 0) {
GDKfree(recycled);
return 0;
}
pushInstruction(mb, old[0]);
mb->recid = recycleSeq++;
/* create a handle for recycler */
(void) newFcnCall(mb, "recycle", "prelude");
in = 1;
for (i = 1; i < limit; i++) {
p = old[i];
if (hasSideEffects(p, TRUE) || isUpdateInstruction(p) || isUnsafeFunction(p)) {
if (getModuleId(p) == recycleRef) { /*don't inline recycle instr. */
freeInstruction(p);
continue;
}
pushInstruction(mb, p);
/* update instructions are not recycled but monitored*/
if (isUpdateInstruction(p)) {
if (getModuleId(p) == batRef &&
(getArgType(mb, p, 1) == TYPE_bat
|| isaBatType(getArgType(mb, p, 1)))) {
recycled[getArg(p, 1)] = 0;
q = newFcnCall(mb, "recycle", "reset");
pushArgument(mb, q, getArg(p, 1));
actions++;
}
if (getModuleId(p) == sqlRef) {
if (getFunctionId(p) == appendRef) {
if (app_sc >= 0)
continue;
else
app_sc = getArg(p, 2);
}
VALset(&cst, TYPE_int, &delta);
c = defConstant(mb, TYPE_int, &cst);
q = newFcnCall(mb, "recycle", "reset");
pushArgument(mb, q, c);
pushArgument(mb, q, getArg(p, 2));
pushArgument(mb, q, getArg(p, 3));
if (getFunctionId(p) == updateRef)
pushArgument(mb, q, getArg(p, 4));
actions++;
}
}
/* take care of SQL catalog update instructions */
if (getModuleId(p) == sqlRef && getFunctionId(p) == catalogRef) {
tp = *(int *) getVarValue(mb, getArg(p, 1));
if (tp == 22 || tp == 25) {
delta = 2;
VALset(&cst, TYPE_int, &delta);
c = defConstant(mb, TYPE_int, &cst);
q = newFcnCall(mb, "recycle", "reset");
pushArgument(mb, q, c);
pushArgument(mb, q, getArg(p, 2));
if (tp == 25)
pushArgument(mb, q, getArg(p, 3));
actions++;
}
}
continue;
}
if (p->token == ENDsymbol || p->barrier == RETURNsymbol) {
if (in) {
/*
if (updstmt && app_sc >= 0) {
q = newFcnCall(mb, "recycle", "reset");
pushArgument(mb, q, app_sc);
pushArgument(mb, q, app_tbl);
}
*/
(void) newFcnCall(mb, "recycle", "epilogue");
in = 0;
}
pushInstruction(mb, p);
continue;
}
if (p->barrier && p->token != CMDcall) {
/* never save a barrier unless it is a command and side-effect free */
pushInstruction(mb, p);
continue;
}
/* don't change instructions in update statements */
if (updstmt) {
pushInstruction(mb, p);
continue;
}
/* skip simple assignments */
if (p->token == ASSIGNsymbol) {
pushInstruction(mb, p);
continue;
}
if (getModuleId(p) == octopusRef &&
(getFunctionId(p) == bindRef || getFunctionId(p) == bindidxRef)) {
recycled[getArg(p, 0)] = 1;
p->recycle = recycleMaxInterest;
marks++;
}
/* During base table recycling skip marking instructions other than octopus.bind */
if (baseTableMode) {
pushInstruction(mb, p);
continue;
}
/* general rule: all arguments are constants or recycled,
ignore C pointer arguments from mvc */
cnt = 0;
for (j = p->retc; j < p->argc; j++)
if (recycled[getArg(p, j)] || isVarConstant(mb, getArg(p, j))
|| ignoreVar(mb, getArg(p, j)))
cnt++;
if (cnt == p->argc - p->retc) {
OPTDEBUGrecycle {
mnstr_printf(cntxt->fdout, "#recycle instruction\n");
printInstruction(cntxt->fdout, mb, 0, p, LIST_MAL_ALL);
}
marks++;
p->recycle = recycleMaxInterest; /* this instruction is to be monitored */
for (j = 0; j < p->retc; j++)
if (getLastUpdate(span, getArg(p, j)) == i)
recycled[getArg(p, j)] = 1;
}
/*
* The expected gain is largest if we can re-use selections
* on the base tables in SQL. These, however, are marked as
* uselect() calls, which only produce the oid head.
* For cheap types we preselect using select() and re-map uselect() back
* over this temporary.
* For the time being for all possible selects encountered
* are marked for re-use.
*/
/* take care of semantic driven recyling */
/* for selections check the bat argument only
the range is often template parameter*/
if ((getFunctionId(p) == selectRef ||
getFunctionId(p) == antiuselectRef ||
getFunctionId(p) == likeselectRef ||
getFunctionId(p) == likeRef ||
getFunctionId(p) == thetaselectRef) &&
recycled[getArg(p, 1)])
{
p->recycle = recycleMaxInterest;
marks++;
if (getLastUpdate(span, getArg(p, 0)) == i)
recycled[getArg(p, 0)] = 1;
}
if ((getFunctionId(p) == uselectRef || getFunctionId(p) == thetauselectRef)
&& recycled[getArg(p, 1)])
{
if (!ATOMvarsized(getGDKType(getArgType(mb, p, 2)))) {
q = copyInstruction(p);
getArg(q, 0) = newTmpVariable(mb, TYPE_any);
if (getFunctionId(p) == uselectRef)
setFunctionId(q, selectRef);
else
setFunctionId(q, thetaselectRef);
q->recycle = recycleMaxInterest;
marks++;
recycled[getArg(q, 0)] = 1;
pushInstruction(mb, q);
getArg(p, 1) = getArg(q, 0);
setFunctionId(p, projectRef);
p->argc = 2;
}
p->recycle = recycleMaxInterest;
marks++;
if (getLastUpdate(span, getArg(p, 0)) == i)
recycled[getArg(p, 0)] = 1;
}
if (getModuleId(p) == pcreRef) {
if ((getFunctionId(p) == selectRef && recycled[getArg(p, 2)]) ||
(getFunctionId(p) == uselectRef && recycled[getArg(p, 2)])) {
p->recycle = recycleMaxInterest;
marks++;
if (getLastUpdate(span, getArg(p, 0)) == i)
recycled[getArg(p, 0)] = 1;
} else if (getFunctionId(p) == likeuselectRef && recycled[getArg(p, 1)]) {
q = copyInstruction(p);
getArg(q, 0) = newTmpVariable(mb, TYPE_any);
setFunctionId(q, likeselectRef);
q->recycle = recycleMaxInterest;
recycled[getArg(q, 0)] = 1;
pushInstruction(mb, q);
getArg(p, 1) = getArg(q, 0);
setFunctionId(p, projectRef);
setModuleId(p, algebraRef);
p->argc = 2;
p->recycle = recycleMaxInterest;
marks += 2;
if (getLastUpdate(span, getArg(p, 0)) == i)
recycled[getArg(p, 0)] = 1;
}
}
/*
* The sql.bind instructions should be handled carefully
* The delete and update BATs should not be recycled,
* because they may lead to view dependencies that later interferes
* with the transaction commits.
*/
/* enable recycling of delta-bats
if (getModuleId(p) == sqlRef &&
(((getFunctionId(p) == bindRef || getFunctionId(p) == putName("bind_idxbat", 11)) &&
getVarConstant(mb, getArg(p, 5)).val.ival != 0) ||
getFunctionId(p) == binddbatRef)) {
recycled[getArg(p, 0)] = 0;
p->recycle = REC_NO_INTEREST;
}
*/
/*
* The sql.bind instructions should be handled carefully
* The delete and update BATs should not be recycled,
* because they may lead to view dependencies that later interferes
* with the transaction commits.
*/
/* enable recycling of delta-bats
if (getModuleId(p)== sqlRef &&
(((getFunctionId(p)==bindRef || getFunctionId(p) == putName("bind_idxbat",11)) &&
getVarConstant(mb, getArg(p,5)).val.ival != 0) ||
getFunctionId(p)== binddbatRef) ) {
recycled[getArg(p,0)]=0;
p->recycle = REC_NO_INTEREST;
}
*/
pushInstruction(mb, p);
}
int
OPTstrengthReductionImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
int i, j = 0, k, se= FALSE;
InstrPtr p;
int bk, ik, blk, blkbegin, blkexit, actions = 0;
InstrPtr *before, *within, *old = mb->stmt;
Lifespan span;
(void) cntxt;
(void) pci;
(void) stk; /* to fool compilers */
before = (InstrPtr *) GDKmalloc((mb->ssize + 1) * sizeof(InstrPtr));
within = (InstrPtr *) GDKmalloc((mb->ssize + 1) * sizeof(InstrPtr));
if (before== NULL || within == NULL){
if(before) GDKfree(before);
if(within) GDKfree(within);
return 0;
}
bk = 0;
ik = 0;
blk = 0;
blkexit= blkbegin = 0;
for (i = 0; i < mb->stop; i++)
before[i] = within[i] = 0;
before[bk++] = getInstrPtr(mb, 0);
span =setLifespan(mb);
if( span == NULL)
return 0;
for (i = 1; i < mb->stop - 1; i++) {
p = getInstrPtr(mb, i);
if (blockStart(p)) {
if (blkbegin == 0){
if( isLoopBarrier(mb,i) ){
blkbegin = i;
blkexit = getBlockExit(mb,i);
}
OPTDEBUGstrengthReduction
mnstr_printf(cntxt->fdout, "#check block %d-%d\n", blkbegin, blkexit);
}
within[ik++] = p;
blk++;
continue;
}
if (blockExit(p)) {
blk--;
if (blk == 0)
blkexit= blkbegin = 0;
/* move the saved instruction into place */
OPTDEBUGstrengthReduction
mnstr_printf(cntxt->fdout, "#combine both %d %d\n", bk, ik);
for (k = 0; k < ik; k++)
before[bk++] = within[k];
ik = 0;
before[bk++] = p;
continue;
}
/*
* @-
* Strength reduction is only relevant inside a block;
*/
if( blkexit == 0) {
within[ik++] = p;
continue;
}
/*
* @-
* Flow control statements may not be moved around
*/
if ( p->barrier != 0){
within[ik++] = p;
continue;
}
/*
* @-
* Limit strength reduction to the type modules and the batcalc, batstr, batcolor
* and sql.bind.
*/
if(getModuleId(p) && !isNewSource(p) ) {
within[ik++] = p;
continue;
}
/*
* @-
* Search the prospective new block and make sure that
* none of the arguments is assigned a value.
*/
for (j = ik-1; j > 0; j--) {
InstrPtr q = within[j];
for (k = 0; k < q->retc; k++)
if (SRoverwritten(p, getArg(q, k))) {
se = TRUE;
OPTDEBUGstrengthReduction
mnstr_printf(cntxt->fdout, "variable is set in loop %d\n", getArg(p, k));
goto noreduction;
}
}
/*
* @-
* Make sure the variables are not declared before the loop and used
* after the loop, because then you may not simple move an expression.
*/
for (k = 0; k < p->retc; k++)
if ( getBeginLifespan(span, getArg(p, k))<= blkbegin ||
getEndLifespan(span, getArg(p, k))> blkexit) {
se = TRUE;
OPTDEBUGstrengthReduction
mnstr_printf(cntxt->fdout, "variable %d may not be moved %d-%d\n",
getArg(p, k),getBeginLifespan(span, getArg(p, k)), getEndLifespan(span, getArg(p, k)));
goto noreduction;
}
noreduction:
OPTDEBUGstrengthReduction{
mnstr_printf(cntxt->fdout,"move %d to stack %s\n", i, (se ?"within":"before"));
printInstruction(cntxt->fdout, mb, 0, p, LIST_MAL_ALL);
}
if (blkexit && se == FALSE && !hasSideEffects(p, TRUE) && !isUpdateInstruction(p) )
before[bk++] = p;
else
within[ik++] = p;
}
actions += ik;
for (k = 0; k < ik; k++)
before[bk++] = within[k];
before[bk++] = getInstrPtr(mb, i);
GDKfree(mb->stmt);
mb->stmt = (InstrPtr *) GDKzalloc((mb->ssize) * sizeof(InstrPtr));
if ( mb->stmt == NULL){
GDKfree(span);
GDKfree(before);
GDKfree(within);
mb->stmt = old;
return 0;
}
mb->stop = 0;
OPTDEBUGstrengthReduction
mnstr_printf(cntxt->fdout,"stop= %d bk=%d\n",mb->stop,bk);
for (i = 0; i < bk; i++)
if( before[i])
pushInstruction(mb, before[i]);
GDKfree(span);
GDKfree(before);
GDKfree(within);
return actions;
}
int
OPTrecyclerImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
int i, j, cnt, cand, actions = 1, marks = 0;
InstrPtr *old, q,p;
int limit;
char *recycled;
(void) cntxt;
(void) stk;
(void) pci;
limit = mb->stop;
old = mb->stmt;
/* watch out, newly created instructions may introduce new variables */
recycled = GDKzalloc(sizeof(char) * mb->vtop * 2);
if (recycled == NULL)
return 0;
if (newMalBlkStmt(mb, mb->ssize) < 0) {
GDKfree(recycled);
return 0;
}
pushInstruction(mb, old[0]);
for (i = 1; i < limit; i++) {
p = old[i];
if (p->token == ENDsymbol )
break;
/* the first non-dataflow barrier breaks the recycler code*/
if (blockStart(p) && !(getFunctionId(p) && getFunctionId(p) == dataflowRef) )
break;
if ( isUpdateInstruction(p) || hasSideEffects(p,TRUE)){
/* update instructions are not recycled but monitored*/
pushInstruction(mb, p);
if (isUpdateInstruction(p)) {
if (getModuleId(p) == batRef && isaBatType(getArgType(mb, p, 1))) {
q = newFcnCall(mb, "recycle", "reset");
pushArgument(mb, q, getArg(p, 1));
actions++;
}
if (getModuleId(p) == sqlRef) {
q= copyInstruction(p);
getModuleId(q) = recycleRef;
actions++;
}
}
continue;
}
// Not all instruction may be recycled. In particular, we should avoid
// MAL function with implicit/recursive side effects.
// This can not always be detected easily. Likewise, we ignore cheap operations
// Therefore, we use a safe subset to start with
if ( ! (getModuleId(p) == sqlRef || getModuleId(p)== batRef ||
getModuleId(p) == algebraRef || getModuleId(p)==batcalcRef ||
getModuleId(p)== aggrRef || getModuleId(p)== groupRef ||
getModuleId(p)== batstrRef || getModuleId(p)== batmmathRef ||
getModuleId(p)== arrayRef || getModuleId(p)== batmtimeRef ||
getModuleId(p)== batcalcRef || getModuleId(p)== pcreRef ||
getModuleId(p)== mtimeRef || getModuleId(p) == calcRef ||
getModuleId(p)== dateRef || getModuleId(p) == timestampRef ||
getModuleId(p)== matRef )
){
pushInstruction(mb,p);
continue;
}
/* general rule: all arguments should be constants or recycled*/
cnt = 0;
for (j = p->retc; j < p->argc; j++)
if (recycled[getArg(p, j)] || isVarConstant(mb, getArg(p, j)) || isFunctionArgument(mb,getArg(p,j)) )
cnt++;
cand = 0;
for (j =0; j< p->retc; j++)
if (recycled[getArg(p, j)] ==0)
cand++;
if (cnt == p->argc - p->retc && cand == p->retc) {
marks++;
p->recycle = RECYCLING; /* this instruction is to be monitored */
for (j = 0; j < p->retc; j++)
recycled[getArg(p, j)] = 1;
}
pushInstruction(mb, p);
}
for (; i < limit; i++)
pushInstruction(mb, old[i]);
GDKfree(old);
GDKfree(recycled);
mb->recycle = marks > 0;
OPTDEBUGrecycle {
mnstr_printf(cntxt->fdout, "#recycle optimizer: ");
printFunction(cntxt->fdout,mb, 0, LIST_MAL_ALL);
}
return actions + marks;
}
