/// Destructor.
~StateContainer() {
// Destroy the allocated states.
for(StateMap::iterator it = _states.begin(); it != _states.end(); ++it) {
destroyState(it->second);
it->second = 0;
}
// Clear the map.
_states.clear();
}
bool CCameraController::SetStateFloat(const StateMap& sm,
const std::string& name, float& var)
{
StateMap::const_iterator it = sm.find(name);
if (it != sm.end()) {
const float value = it->second;
var = value;
return true;
}
return false;
}
void* MCJITHelper::identityGeneratorForOpenOSR(Function* F1, Instruction* OSRSrc, void* extra, void* profDataAddr) {
MCJITHelper* TheHelper = (MCJITHelper*) extra;
bool verbose = TheHelper->verbose;
assert(OSRSrc->getParent()->getParent() == F1 && "MCJIT messed up the objects");
if (verbose) {
std::cerr << "Value for F1 is " << F1 << std::endl;
std::cerr << "Value for OSRSrc is " << OSRSrc << std::endl;
std::cerr << "Value for extra is " << extra << std::endl;
std::cerr << "Value for profDataAddr is " << profDataAddr << std::endl;
}
std::pair<Function*, StateMap*> identityPair = StateMap::generateIdentityMapping(F1);
Function* F2 = identityPair.first;
StateMap* M = identityPair.second;
Instruction* OSRSrcInF2 = cast<Instruction>(M->getCorrespondingOneToOneValue(OSRSrc));
if (OSRLibrary::removeOSRPoint(*OSRSrcInF2) && verbose) {
std::cerr << "OSR point removed after cloning F1" << std::endl;
}
Instruction* LPad = M->getLandingPad(OSRSrc);
LivenessAnalysis LA(F1);
std::vector<Value*>* valuesToPass = OSRLibrary::getLiveValsVecAtInstr(OSRSrc, LA);
std::string OSRDestFunName = (F2->getName().str()).append("OSRCont");
Function* OSRDestFun = OSRLibrary::genContinuationFunc(TheHelper->Context,
*F1, *F2, *OSRSrc, *LPad, *valuesToPass, *M, &OSRDestFunName, verbose);
delete valuesToPass;
delete F2;
delete M;
// put the generated code into a module
std::string modForJITName = "OpenOSRClone";
modForJITName.append(OSRDestFunName);
std::unique_ptr<Module> modForJIT = llvm::make_unique<Module>(modForJITName, TheHelper->Context);
Module* modForJIT_ptr = modForJIT.get();
modForJIT_ptr->getFunctionList().push_back(OSRDestFun);
verifyFunction(*OSRDestFun, &outs());
// remove dead code
FunctionPassManager FPM(modForJIT_ptr);
FPM.add(createCFGSimplificationPass());
FPM.doInitialization();
FPM.run(*OSRDestFun);
// compile code
TheHelper->addModule(std::move(modForJIT));
return (void*)TheHelper->JIT->getFunctionAddress(OSRDestFunName);
}
/**
* Returns the state with the given ID.
* If the state doesn't exist, creates a new one and loads it. It will be
* unloaded when this class is destroyed.
**/
inline State *getState(StateId id) {
// Try to find the state. If it isn't found, create a new state with
// it.
StateMap::iterator it = _states.find(id);
if(it == _states.end()) {
// Create a new state.
return createState(id);
}
else {
// Return the existing state.
return it->second;
}
}
stateMaskVec_t const mkStateMasks(string const & obsStr, StateMaskMap const & stateMaskMap, StateMap const & metaNucMap)
{
vector<string> obsVec = stringToVectorOfStrings(obsStr);
stateMaskVec_t stateMasks(obsStr.size(), NULL);
for (unsigned i = 0; i < obsStr.size(); i++)
stateMasks[i] = & stateMaskMap.metaState2StateMask( metaNucMap.symbol2State(obsVec[i]) );
return stateMasks;
}
bool processStateMachineNode(AnimNode::Pointer node, const QJsonObject& jsonObj, const QString& nodeId, const QUrl& jsonUrl) {
auto smNode = std::static_pointer_cast<AnimStateMachine>(node);
assert(smNode);
READ_STRING(currentState, jsonObj, nodeId, jsonUrl, false);
auto statesValue = jsonObj.value("states");
if (!statesValue.isArray()) {
qCCritical(animation) << "AnimNodeLoader, bad array \"states\" in stateMachine node, id =" << nodeId;
return false;
}
// build a map for all children by name.
std::map<QString, int> childMap;
buildChildMap(childMap, node);
// first pass parse all the states and build up the state and transition map.
using StringPair = std::pair<QString, QString>;
using TransitionMap = std::multimap<AnimStateMachine::State::Pointer, StringPair>;
TransitionMap transitionMap;
using StateMap = std::map<QString, AnimStateMachine::State::Pointer>;
StateMap stateMap;
auto statesArray = statesValue.toArray();
for (const auto& stateValue : statesArray) {
if (!stateValue.isObject()) {
qCCritical(animation) << "AnimNodeLoader, bad state object in \"states\", id =" << nodeId;
return false;
}
auto stateObj = stateValue.toObject();
READ_STRING(id, stateObj, nodeId, jsonUrl, false);
READ_FLOAT(interpTarget, stateObj, nodeId, jsonUrl, false);
READ_FLOAT(interpDuration, stateObj, nodeId, jsonUrl, false);
READ_OPTIONAL_STRING(interpType, stateObj);
READ_OPTIONAL_STRING(interpTargetVar, stateObj);
READ_OPTIONAL_STRING(interpDurationVar, stateObj);
READ_OPTIONAL_STRING(interpTypeVar, stateObj);
auto iter = childMap.find(id);
if (iter == childMap.end()) {
qCCritical(animation) << "AnimNodeLoader, could not find stateMachine child (state) with nodeId =" << nodeId << "stateId =" << id;
return false;
}
AnimStateMachine::InterpType interpTypeEnum = AnimStateMachine::InterpType::SnapshotPrev; // default value
if (!interpType.isEmpty()) {
interpTypeEnum = stringToInterpType(interpType);
if (interpTypeEnum == AnimStateMachine::InterpType::NumTypes) {
qCCritical(animation) << "AnimNodeLoader, bad interpType on stateMachine state, nodeId = " << nodeId << "stateId =" << id;
return false;
}
}
auto statePtr = std::make_shared<AnimStateMachine::State>(id, iter->second, interpTarget, interpDuration, interpTypeEnum);
assert(statePtr);
if (!interpTargetVar.isEmpty()) {
statePtr->setInterpTargetVar(interpTargetVar);
}
if (!interpDurationVar.isEmpty()) {
statePtr->setInterpDurationVar(interpDurationVar);
}
if (!interpTypeVar.isEmpty()) {
statePtr->setInterpTypeVar(interpTypeVar);
}
smNode->addState(statePtr);
stateMap.insert(StateMap::value_type(statePtr->getID(), statePtr));
auto transitionsValue = stateObj.value("transitions");
if (!transitionsValue.isArray()) {
qCritical(animation) << "AnimNodeLoader, bad array \"transitions\" in stateMachine node, stateId =" << id << "nodeId =" << nodeId;
return false;
}
auto transitionsArray = transitionsValue.toArray();
for (const auto& transitionValue : transitionsArray) {
if (!transitionValue.isObject()) {
qCritical(animation) << "AnimNodeLoader, bad transition object in \"transtions\", stateId =" << id << "nodeId =" << nodeId;
return false;
}
auto transitionObj = transitionValue.toObject();
READ_STRING(var, transitionObj, nodeId, jsonUrl, false);
READ_STRING(state, transitionObj, nodeId, jsonUrl, false);
transitionMap.insert(TransitionMap::value_type(statePtr, StringPair(var, state)));
}
}
// second pass: now iterate thru all transitions and add them to the appropriate states.
for (auto& transition : transitionMap) {
AnimStateMachine::State::Pointer srcState = transition.first;
auto iter = stateMap.find(transition.second.second);
if (iter != stateMap.end()) {
srcState->addTransition(AnimStateMachine::State::Transition(transition.second.first, iter->second));
} else {
qCCritical(animation) << "AnimNodeLoader, bad state machine transtion from srcState =" << srcState->_id << "dstState =" << transition.second.second << "nodeId =" << nodeId;
return false;
}
}
auto iter = stateMap.find(currentState);
if (iter == stateMap.end()) {
qCCritical(animation) << "AnimNodeLoader, bad currentState =" << currentState << "could not find child node" << "id =" << nodeId;
}
smNode->setCurrentState(iter->second);
return true;
}
int runMany() {
StateMap threads;
{
string orig = getParam( "host" );
bool showPorts = false;
if ( orig == "" )
orig = "localhost";
if ( orig.find( ":" ) != string::npos || hasParam( "port" ) )
showPorts = true;
StringSplitter ss( orig.c_str() , "," );
while ( ss.more() ) {
string host = ss.next();
if ( showPorts && host.find( ":" ) == string::npos) {
// port supplied, but not for this host. use default.
if ( hasParam( "port" ) )
host += ":" + _params["port"].as<string>();
else
host += ":27017";
}
_add( threads , host );
}
}
sleepsecs(1);
int row = 0;
bool discover = hasParam( "discover" );
int maxLockedDbWidth = 0;
while ( 1 ) {
sleepsecs( (int)ceil(_statUtil.getSeconds()) );
// collect data
vector<Row> rows;
for ( map<string,shared_ptr<ServerState> >::iterator i=threads.begin(); i!=threads.end(); ++i ) {
scoped_lock lk( i->second->lock );
if ( i->second->error.size() ) {
rows.push_back( Row( i->first , i->second->error ) );
}
else if ( i->second->prev.isEmpty() || i->second->now.isEmpty() ) {
rows.push_back( Row( i->first ) );
}
else {
BSONObj out = _statUtil.doRow( i->second->prev , i->second->now );
rows.push_back( Row( i->first , out ) );
}
if ( discover && ! i->second->now.isEmpty() ) {
if ( _discover( threads , i->first , i->second ) )
break;
}
}
// compute some stats
unsigned longestHost = 0;
BSONObj biggest;
for ( unsigned i=0; i<rows.size(); i++ ) {
if ( rows[i].host.size() > longestHost )
longestHost = rows[i].host.size();
if ( rows[i].data.nFields() > biggest.nFields() )
biggest = rows[i].data;
// adjust width up as longer 'locked db' values appear
setMaxLockedDbWidth( &rows[i].data, &maxLockedDbWidth );
}
{
// check for any headers not in biggest
// TODO: we put any new headers at end,
// ideally we would interleave
set<string> seen;
BSONObjBuilder b;
{
// iterate biggest
BSONObjIterator i( biggest );
while ( i.more() ) {
BSONElement e = i.next();
seen.insert( e.fieldName() );
b.append( e );
}
}
// now do the rest
for ( unsigned j=0; j<rows.size(); j++ ) {
BSONObjIterator i( rows[j].data );
while ( i.more() ) {
BSONElement e = i.next();
if ( seen.count( e.fieldName() ) )
continue;
seen.insert( e.fieldName() );
b.append( e );
}
}
biggest = b.obj();
}
// display data
cout << endl;
// header
if ( row++ % 5 == 0 && ! biggest.isEmpty() ) {
cout << setw( longestHost ) << "" << "\t";
printHeaders( biggest );
}
// rows
for ( unsigned i=0; i<rows.size(); i++ ) {
cout << setw( longestHost ) << rows[i].host << "\t";
if ( rows[i].err.size() )
cout << rows[i].err << endl;
else if ( rows[i].data.isEmpty() )
cout << "no data" << endl;
else
printData( rows[i].data , biggest );
}
}
return 0;
}
GTRRateMatrix::GTRRateMatrix(StateMap const & staMap, vector_t const & rateParameters, vector_t const & equiFreqs)
: BaseTRRateMatrix(rateParameters, equiFreqs, "GTR"), staMap_(staMap)
{
assert( (staMap.stateCount() * ( staMap.stateCount() - 1) ) / 2 == rateParameterCount_);
assert(staMap.stateCount() == equiFreqCount_);
}
GTRRateMatrix::GTRRateMatrix(StateMap const & staMap)
: BaseTRRateMatrix( (staMap.stateCount() * ( staMap.stateCount() - 1) ) / 2, staMap.stateCount(), "GTR"), staMap_(staMap)
{}
void normalizeRM(matrix_t & Q, StateMap const & staMap)
{
normalizeRM(Q, staMap, staMap.symbolSize() );
}
void PrintFibres(P &out,const TopCompress &compress,const BottomCompress &bottom,const StateMap &map)
{
Printf(out,"#;\n",Title("Fibres"));
bottom.applyForStates( [&] (State state)
{
auto range=map.getFibre(state);
Printf(out,"\n#;:#;) <-",state.getIndex(),state.getPropIndex());
if( !range )
{
Putobj(out," empty\n");
}
else
{
PrintFibre(out,compress,range);
}
}
);
{
auto range=map.getNullFibre();
if( +range )
{
Printf(out,"\nNULL <-");
PrintFibre(out,compress,range);
}
}
Printf(out,"\n#;\n",TextDivider());
ulen count=0;
bottom.applyForStates( [&] (State state)
{
auto range=map.getFibre(state);
if( range.len>1 && HasMultipleProps(range) )
{
Printf(out,"\n#;) MP fibre size #;\n",state.getIndex(),range.len);
count++;
}
}
);
{
auto range=map.getNullFibre();
if( range.len>1 && HasMultipleProps(range) )
{
Printf(out,"\nNULL MP fibre size #;\n",range.len);
count++;
}
}
Printf(out,"\nMP fibres = #;\n",count);
Printf(out,"\n#;\n",TextDivider());
}
void* MCJITHelper::dynamicInlinerForOpenOSR(Function* F1, Instruction* OSRSrc, void* extra, void* profDataAddr) {
DynamicInlinerInfo* inlineInfo = (DynamicInlinerInfo*) extra;
MCJITHelper* TheHelper = inlineInfo->TheHelper;
bool verbose = TheHelper->verbose;
assert(OSRSrc->getParent()->getParent() == F1 && "MCJIT messed up the objects");
if (verbose) {
std::cerr << "Value for F1 is " << F1 << std::endl;
std::cerr << "Value for OSRSrc is " << OSRSrc << std::endl;
std::cerr << "Value for extra is " << extra << std::endl;
std::cerr << "Value for profDataAddr is " << profDataAddr << std::endl;
}
std::pair<Function*, StateMap*> identityPair = StateMap::generateIdentityMapping(F1);
Function* F2 = identityPair.first;
StateMap* M = identityPair.second;
Value* valToInlineInF2 = M->getCorrespondingOneToOneValue(inlineInfo->valToInline);
Instruction* OSRSrcInF2 = cast<Instruction>(M->getCorrespondingOneToOneValue(OSRSrc));
assert (OSRSrcInF2 != nullptr && "TODO cannot find corresponding OSRSrc in temporary F2");
if (OSRLibrary::removeOSRPoint(*OSRSrcInF2) && verbose) {
std::cerr << "OSR point removed after cloning F1" << std::endl;
}
Instruction* LPad = M->getLandingPad(OSRSrc);
StateMap* M_F2toOSRContFun;
LivenessAnalysis LA(F1);
std::vector<Value*>* valuesToPass = OSRLibrary::getLiveValsVecAtInstr(OSRSrc, LA);
std::string OSRDestFunName = (F2->getName().str()).append("OSRCont");
Function* OSRContFun = OSRLibrary::genContinuationFunc(TheHelper->Context,
*F1, *F2, *OSRSrc, *LPad, *valuesToPass, *M, &OSRDestFunName, verbose, &M_F2toOSRContFun);
Value* valToInline = M_F2toOSRContFun->getCorrespondingOneToOneValue(valToInlineInF2);
assert (valToInline != nullptr && "broken state map for continuation function");
delete valuesToPass;
delete F2;
delete M;
delete M_F2toOSRContFun;
// create a module for generated code
std::string modForJITName = "OpenOSRDynInline";
modForJITName.append(OSRDestFunName);
std::unique_ptr<Module> modForJIT = llvm::make_unique<Module>(modForJITName, TheHelper->Context);
Module* modForJIT_ptr = modForJIT.get();
// determine which function is called
uint64_t calledFun = (uint64_t)profDataAddr;
std::cerr << "Address of invoked function: " << calledFun << std::endl;
Function* funToInline = nullptr;
for (AddrSymPair &pair: TheHelper->CompiledFunAddrTable) {
if (pair.first == calledFun) {
std::string &FunName = pair.second;
funToInline = TheHelper->getFunction(FunName);
break;
}
}
Function* myFunToInline = nullptr;
if (funToInline == nullptr) {
std::cerr << "Sorry, I could not determine which function was called!" << std::endl;
} else {
std::cerr << "Function being inlined: " << funToInline->getName().str() << std::endl;
ValueToValueMapTy VMap;
myFunToInline = CloneFunction(funToInline, VMap, false, nullptr);
myFunToInline->addFnAttr(Attribute::AlwaysInline);
myFunToInline->setLinkage(Function::LinkageTypes::PrivateLinkage);
modForJIT_ptr->getFunctionList().push_back(myFunToInline);
OSRLibrary::fixUsesOfFunctionsAndGlobals(funToInline, myFunToInline);
for (Value::use_iterator UI = valToInline->use_begin(),
UE = valToInline->use_end(); UI != UE; ) {
Use &U = *(UI++);
if (CallInst* CI = dyn_cast<CallInst>(U.getUser())) {
if (CI->getParent()->getParent() != OSRContFun) continue;
if (verbose) {
raw_os_ostream errStream(std::cerr);
std::cerr << "Updating instruction ";
CI->print(errStream);
std::cerr << std::endl;
}
U.set(myFunToInline);
}
}
}
modForJIT_ptr->getFunctionList().push_back(OSRContFun);
verifyFunction(*OSRContFun, &outs());
// remove dead code & inline when possible
FunctionPassManager FPM(modForJIT_ptr);
FPM.add(createCFGSimplificationPass());
FPM.doInitialization();
FPM.run(*OSRContFun);
if (funToInline != nullptr) {
PassManager PM;
PM.add(llvm::createAlwaysInlinerPass());
PM.run(*modForJIT_ptr);
}
// compile code
TheHelper->addModule(std::move(modForJIT));
return (void*)TheHelper->JIT->getFunctionAddress(OSRDestFunName);
}
string const varVecToObsStr(vector<unsigned> const & varVec, StateMap const & metaNucMap)
{
string obsStr;
BOOST_FOREACH(unsigned state, varVec) {
obsStr += metaNucMap.state2Symbol(state);
}
/**
* Creates a new state. Make sure the state doesn't exist when calling this
* function!
* This function also inserts the state into the _states map.
* @param id The id of the new state.
**/
State *createState(StateId id) {
State *state = stateFactory(id);
state->load();
_states.insert(StateMapPair(id, state));
return state;
}
