KUKADU_SHARED_PTR<Trajectory> PoWER::updateStep() {
KUKADU_SHARED_PTR<Trajectory> lastUp = getLastUpdate();
vector<KUKADU_SHARED_PTR<Trajectory> > lastDmps = getLastRolloutParameters();
vector<double> lastRewards = getLastRolloutCost();
// add rollouts to history
for(int i = 0; i < lastRewards.size(); ++i) {
pair <double, KUKADU_SHARED_PTR<Trajectory> > p(lastRewards.at(i), lastDmps.at(i));
sampleHistory.push_back(p);
}
// sort by reward...
sort(sampleHistory.begin(), sampleHistory.end(), rewardComparator);
// ...and discard bad samples
int histSize = sampleHistory.size();
for(int i = (importanceSamplingCount - 1); i < histSize; ++i)
sampleHistory.pop_back();
double totalReward = 0.0;
for(int i = 0; i < sampleHistory.size(); ++i)
totalReward = totalReward + sampleHistory.at(i).first;
vector<vec> lastUpCoeffs = lastUp->getCoefficients();
vec newCoeffsJ(lastUpCoeffs.at(0).n_elem);
vector<vec> newCoeffs;
for(int i = 0; i < lastUp->getCoefficients().size(); ++i) {
vec v = lastUp->getCoefficients().at(i);
newCoeffs.push_back(v);
}
cout << "====================" << endl;
// for each degree of freedom
for(int i = 0; i < newCoeffs.size(); ++i) {
vec currentDegCoeffs = newCoeffs.at(i);
// go through all samples and weight rollouts
for(int j = 0; j < sampleHistory.size(); ++j) {
currentDegCoeffs += sampleHistory.at(j).first / totalReward * (sampleHistory.at(j).second->getCoefficients().at(i) - lastUpCoeffs.at(i));
}
newCoeffs[i] = currentDegCoeffs;
}
KUKADU_SHARED_PTR<Trajectory> newUp = lastUp->copy();
newUp->setCoefficients(newCoeffs);
return newUp;
}
QVariant pki_crl::column_data(dbheader *hd)
{
switch (hd->id) {
case HD_crl_signer:
if (issuer)
return QVariant(getIssuer()->getIntName());
else
return QVariant(tr("unknown"));
case HD_crl_revoked:
return QVariant(numRev());
case HD_crl_lastUpdate:
return QVariant(getLastUpdate().toSortable());
case HD_crl_nextUpdate:
return QVariant(getNextUpdate().toSortable());
case HD_crl_crlnumber:
a1int a;
if (getCrlNumber(&a))
return QVariant(a.toDec());
return QVariant();
}
return pki_x509name::column_data(hd);
}
std::vector<KUKADU_SHARED_PTR<Trajectory> > PoWER::computeRolloutParamters() {
KUKADU_SHARED_PTR<Trajectory> lastUp = getLastUpdate();
vector<vec> dmpCoeffs = lastUp->getCoefficients();
vector<KUKADU_SHARED_PTR<Trajectory> > nextCoeffs;
for(int k = 0; k < updatesPerRollout; ++k) {
vec currCoeff;
for(int i = 0; i < dmpCoeffs.size(); ++i) {
currCoeff = dmpCoeffs.at(i);
for(int j = 0; j < currCoeff.n_elem; ++j) {
kukadu_normal_distribution normal = normals.at(j);
double eps = normal(generator);
currCoeff(j) += eps;
}
dmpCoeffs[i] = currCoeff;
}
KUKADU_SHARED_PTR<Trajectory> nextUp = lastUp->copy();
nextUp->setCoefficients(dmpCoeffs);
nextCoeffs.push_back(nextUp);
}
return nextCoeffs;
}
int
OPTaccumulatorsImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
int i, limit,slimit;
InstrPtr p,q;
Module scope = cntxt->nspace;
int actions = 0;
InstrPtr *old;
Lifespan span;
(void) pci;
(void) stk; /* to fool compilers */
span = setLifespan(mb);
if( span == NULL)
return 0;
old= mb->stmt;
limit= mb->stop;
slimit= mb->ssize;
if ( newMalBlkStmt(mb,mb->stop) < 0){
GDKfree(span);
return 0;
}
for (i = 0; i < limit; i++) {
p = old[i];
if( getModuleId(p) != batcalcRef ) {
pushInstruction(mb,p);
continue;
}
OPTDEBUGaccumulators
printInstruction(cntxt->fdout, mb, 0, p, LIST_MAL_ALL);
if (p->retc==1 && p->argc == 2) {
/* unary operation, avoid clash with binary */
pushInstruction(mb,p);
continue;
}
if( getLastUpdate(span,getArg(p,0)) != i ) {
/* only consider the last update to this variable */
pushInstruction(mb,p);
continue;
}
if (p->retc==1 && p->argc == 3 && isaBatType(getArgType(mb,p,0))) {
int b1 =getEndLifespan(span,getArg(p,1))<=i && getArgType(mb,p,1) == getArgType(mb,p,0);
int b2 =getEndLifespan(span,getArg(p,2))<=i && getArgType(mb,p,2) == getArgType(mb,p,0) ;
if ( b1 == 0 && b2 == 0){
pushInstruction(mb,p);
continue;
}
/* binary/unary operation, check arguments for being candidates */
q= copyInstruction(p);
p= pushBit(mb,p, b1);
p= pushBit(mb,p, b2);
typeChecker(cntxt->fdout, scope, mb, p, TRUE);
if (mb->errors || p->typechk == TYPE_UNKNOWN) {
OPTDEBUGaccumulators{
mnstr_printf(cntxt->fdout,"# Failed typecheck");
printInstruction(cntxt->fdout, mb, 0, p, LIST_MAL_ALL);
}
/* reset instruction error buffer */
cntxt->errbuf[0]=0;
mb->errors = 0;
freeInstruction(p);
p=q; /* restore */
} else {
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);
}
/*
* 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;
}
