uint32_t BaseCompiler::getPriority(BaseVar& var) const {
if (var.getId() == kInvalidValue)
return kInvalidValue;
VarData* vd = getVdById(var.getId());
return vd->getPriority();
}
void Context::cleanup() {
VarData** array = _contextVd.getData();
size_t length = _contextVd.getLength();
for (size_t i = 0; i < length; i++) {
VarData* vd = array[i];
vd->resetContextId();
vd->resetRegIndex();
}
_contextVd.reset(false);
_extraBlock = NULL;
}
Error X86Compiler::_newVar(Var* var, uint32_t vType, const char* name, va_list ap) {
ASMJIT_ASSERT(vType < kX86VarTypeCount);
vType = _targetVarMapping[vType];
ASMJIT_ASSERT(vType != kInvalidVar);
// The assertion won't be compiled in release build, however, we want to check
// this anyway.
if (vType == kInvalidVar) {
static_cast<X86Var*>(var)->reset();
return kErrorInvalidArgument;
}
const X86VarInfo& vInfo = _x86VarInfo[vType];
char buf[64];
// Format the name if `ap` is given.
if (ap) {
vsnprintf(buf, ASMJIT_ARRAY_SIZE(buf), name, ap);
buf[ASMJIT_ARRAY_SIZE(buf) - 1] = '\0';
name = buf;
}
VarData* vd = _newVd(vType, vInfo.getSize(), vInfo.getClass(), name);
if (vd == NULL) {
static_cast<X86Var*>(var)->reset();
return getLastError();
}
var->_init_packed_op_sz_w0_id(kOperandTypeVar, vInfo.getSize(), vInfo.getReg() << 8, vd->getId());
var->_vreg.vType = vType;
return kErrorOk;
}
Error X86Compiler::_newStack(BaseMem* mem, uint32_t size, uint32_t alignment, const char* name) {
if (size == 0)
return kErrorInvalidArgument;
if (alignment > 64)
alignment = 64;
VarData* vd = _newVd(kInvalidVar, size, kInvalidReg, name);
if (vd == NULL) {
static_cast<X86Mem*>(mem)->reset();
return getLastError();
}
vd->_isStack = true;
vd->_alignment = static_cast<uint8_t>(alignment);
static_cast<X86Mem*>(mem)->_init(kMemTypeStackIndex, vd->getId(), 0, 0);
return kErrorOk;
}
Error X86Compiler::_newVar(Var* var, uint32_t vType, const char* name) noexcept {
ASMJIT_ASSERT(vType < kX86VarTypeCount);
vType = _targetVarMapping[vType];
ASMJIT_ASSERT(vType != kInvalidVar);
// The assertion won't be compiled in release build, however, we want to check
// this anyway.
if (vType == kInvalidVar) {
static_cast<X86Var*>(var)->reset();
return kErrorInvalidArgument;
}
const VarInfo& vInfo = _x86VarInfo[vType];
VarData* vd = _newVd(vInfo, name);
if (vd == nullptr) {
static_cast<X86Var*>(var)->reset();
return getLastError();
}
var->_init_packed_op_sz_w0_id(Operand::kTypeVar, vInfo.getSize(), vInfo.getRegType() << 8, vd->getId());
var->_vreg.vType = vType;
return kErrorOk;
}
Error Context::livenessAnalysis() {
FuncNode* func = getFunc();
JumpNode* from = NULL;
Node* node = func->getEnd();
uint32_t bLen = static_cast<uint32_t>(
((_contextVd.getLength() + VarBits::kEntityBits - 1) / VarBits::kEntityBits));
LivenessTarget* ltCur = NULL;
LivenessTarget* ltUnused = NULL;
size_t varMapToVaListOffset = _varMapToVaListOffset;
// No variables.
if (bLen == 0)
return kErrorOk;
VarBits* bCur = newBits(bLen);
if (bCur == NULL)
goto _NoMemory;
// Allocate bits for code visited first time.
_OnVisit:
for (;;) {
if (node->hasLiveness()) {
if (bCur->_addBitsDelSource(node->getLiveness(), bCur, bLen))
goto _OnPatch;
else
goto _OnDone;
}
VarBits* bTmp = copyBits(bCur, bLen);
if (bTmp == NULL)
goto _NoMemory;
node->setLiveness(bTmp);
VarMap* map = node->getMap();
if (map != NULL) {
uint32_t vaCount = map->getVaCount();
VarAttr* vaList = reinterpret_cast<VarAttr*>(((uint8_t*)map) + varMapToVaListOffset);
for (uint32_t i = 0; i < vaCount; i++) {
VarAttr* va = &vaList[i];
VarData* vd = va->getVd();
uint32_t flags = va->getFlags();
uint32_t ctxId = vd->getContextId();
if ((flags & kVarAttrOutAll) && !(flags & kVarAttrInAll)) {
// Write-Only.
bTmp->setBit(ctxId);
bCur->delBit(ctxId);
}
else {
// Read-Only or Read/Write.
bTmp->setBit(ctxId);
bCur->setBit(ctxId);
}
}
}
if (node->getType() == kNodeTypeTarget)
goto _OnTarget;
if (node == func)
goto _OnDone;
ASMJIT_ASSERT(node->getPrev());
node = node->getPrev();
}
// Patch already generated liveness bits.
_OnPatch:
for (;;) {
ASMJIT_ASSERT(node->hasLiveness());
VarBits* bNode = node->getLiveness();
if (!bNode->_addBitsDelSource(bCur, bLen))
goto _OnDone;
if (node->getType() == kNodeTypeTarget)
goto _OnTarget;
if (node == func)
goto _OnDone;
node = node->getPrev();
}
_OnTarget:
if (static_cast<TargetNode*>(node)->getNumRefs() != 0) {
// Push a new LivenessTarget onto the stack if needed.
if (ltCur == NULL || ltCur->node != node) {
// Allocate a new LivenessTarget object (from pool or zone).
LivenessTarget* ltTmp = ltUnused;
if (ltTmp != NULL) {
ltUnused = ltUnused->prev;
}
else {
ltTmp = _baseZone.allocT<LivenessTarget>(
sizeof(LivenessTarget) - sizeof(VarBits) + bLen * sizeof(uintptr_t));
if (ltTmp == NULL)
goto _NoMemory;
}
// Initialize and make current - ltTmp->from will be set later on.
ltTmp->prev = ltCur;
ltTmp->node = static_cast<TargetNode*>(node);
ltCur = ltTmp;
from = static_cast<TargetNode*>(node)->getFrom();
ASMJIT_ASSERT(from != NULL);
}
else {
from = ltCur->from;
goto _OnJumpNext;
}
// Visit/Patch.
do {
ltCur->from = from;
bCur->copyBits(node->getLiveness(), bLen);
if (!from->hasLiveness()) {
node = from;
goto _OnVisit;
}
// Issue #25: Moved '_OnJumpNext' here since it's important to patch
// code again if there are more live variables than before.
_OnJumpNext:
if (bCur->delBits(from->getLiveness(), bLen)) {
node = from;
goto _OnPatch;
}
from = from->getJumpNext();
} while (from != NULL);
// Pop the current LivenessTarget from the stack.
{
LivenessTarget* ltTmp = ltCur;
ltCur = ltCur->prev;
ltTmp->prev = ltUnused;
ltUnused = ltTmp;
}
}
bCur->copyBits(node->getLiveness(), bLen);
node = node->getPrev();
if (node->isJmp() || !node->isFetched())
goto _OnDone;
if (!node->hasLiveness())
goto _OnVisit;
if (bCur->delBits(node->getLiveness(), bLen))
goto _OnPatch;
_OnDone:
if (ltCur != NULL) {
node = ltCur->node;
from = ltCur->from;
goto _OnJumpNext;
}
return kErrorOk;
_NoMemory:
return setError(kErrorNoHeapMemory);
}
void dfgEm(DfgInfo & dfgInfo, string const & varDataFile, string const & facDataFile, string const & subVarDataFile, number_t minDeltaLogLik, unsigned maxIter,
string const & logStateMapsFile, string const & logFactorPotentialsFile, string const & logVariablesFile, string const & logFactorGraphFile, string const & logFile)
{
DFG & dfg = dfgInfo.dfg; // convenient
AbstractBaseFactorSet & factorSet = dfgInfo.facSet;
unsigned iter = 0;
number_t logLik = 0;
number_t prevLogLik = 0;
number_t deltaLogLik = 0;
// setup input data structures
VarData varData(varDataFile, dfgInfo.varNames);
FacData * facDataPtr = NULL;
VarData * subVarDataPtr = NULL;
if (facDataFile.size() != 0) {
facDataPtr = new FacData(facDataFile, dfgInfo.facNames);
}
if (subVarDataFile.size() != 0) {
subVarDataPtr = new VarData(subVarDataFile, dfgInfo.subNames);
}
else if( dfgInfo.subNames.size() > 0 ){
errorAbort("DfgDataWrap.cpp::164::main There are subscribed factors but no subscribed variable file were provided");
}
// init variables
// input data variables
string idVar;
vector<symbol_t> varVec( varData.count() ); // for input data
// dfg variables
stateMaskVec_t stateMaskVec( dfgInfo.varNames.size() );
vector<matrix_t> facExpCounts; // Expectation counts
initAccFactorMarginals(facExpCounts, dfg);
vector<xmatrix_t> tmpFacMar; // workspace
dfg.initFactorMarginals(tmpFacMar);
xnumber_t normConst;
// open log file
ofstream f;
if ( logFile.size() ) {
f.open(logFile.c_str(), ios::out);
if (!f)
errorAbort("Cannot open file: " + logFile + "\n");
f << "minDeltaLogLik: " << minDeltaLogLik << endl;
f << "maxIter: " << maxIter << endl;
f << endl;
f << "iter" << "\t" << "logLik" << "\t" << "deltaLogLik" << endl;
}
while ( ( (deltaLogLik > minDeltaLogLik) or iter == 0) and iter < maxIter) {
logLik = 0;
reset(facExpCounts);
// reset varData and facData
varData.reset(varDataFile, dfgInfo.varNames);
if (facDataFile.size() != 0) {
facDataPtr->reset(facDataFile, dfgInfo.facNames);
}
if (subVarDataFile.size() != 0) {
subVarDataPtr->reset(subVarDataFile, dfgInfo.subNames);
}
unsigned lineCount = 0;
while ( varData.next(idVar, varVec) ) {
lineCount++;
resetFactorPotential(facDataPtr, idVar, lineCount, dfgInfo.dfg);
updateFactorPotentials(subVarDataPtr, idVar, lineCount, dfgInfo);
dfgInfo.stateMaskMapSet.symbols2StateMasks( stateMaskVec, varVec, varData.map() );
// //debug begin
// string facName("CpG_P_1.likelihood");
// unsigned facIdx = find(dfgInfo.facNames.begin(), dfgInfo.facNames.end(), facName) - dfgInfo.facNames.begin();
// cout << "factor name: " << facName << "; facIdx: " << facIdx << "; potential " << dfg.getFactor(facIdx).potential << endl;
// //debug end
calcFacAccMarAndNormConst(facExpCounts, tmpFacMar, normConst, stateMaskVec, dfg);
logLik += - log(normConst);
}
factorSet.submitCounts(facExpCounts);
factorSet.optimizeParameters();
dfg.resetFactorPotentials( factorSet.mkFactorVec() );
factorSet.clearCounts();
deltaLogLik = abs(prevLogLik - logLik); // set at abs(-logLik) in iter 0
if ( logFile.size() )
f << iter << "\t" << logLik << "\t" << deltaLogLik << endl;
if ( logStateMapsFile.size() )
writeDfgInfo(dfgInfo, logStateMapsFile, logFactorPotentialsFile, logVariablesFile, logFactorGraphFile);
//
// // debug
// cout << "from dfgEm:" << endl;
// cout << "iter: " << iter << endl;
// cout << "logLik: " << logLik << endl;
// cout << "prevLogLik: " << prevLogLik << endl;
// cout << "deltaLogLik: " << deltaLogLik << endl;
// cout << "minDeltaLogLik: " << minDeltaLogLik << endl;
// cout << "maxIter: " << maxIter << endl;
// cout << "( ( (deltaLogLik > minDeltaLogLik) or iter == 0) and iter < maxIter): " << ( ( (deltaLogLik > minDeltaLogLik) or iter == 0) and iter < maxIter) << endl;
//
// //debug begin
// cout << endl << "iteration #: " << iter << endl << endl;
// //debug end
prevLogLik = logLik;
iter++;
}
// clean up
if (facDataPtr != NULL)
delete facDataPtr;
}
