void StatsTracker::stepInstruction(ExecutionState &es) { if (OutputIStats) { if (TrackInstructionTime) { static sys::TimeValue lastNowTime(0,0),lastUserTime(0,0); if (lastUserTime.seconds()==0 && lastUserTime.nanoseconds()==0) { sys::TimeValue sys(0,0); sys::Process::GetTimeUsage(lastNowTime,lastUserTime,sys); } else { sys::TimeValue now(0,0),user(0,0),sys(0,0); sys::Process::GetTimeUsage(now,user,sys); sys::TimeValue delta = user - lastUserTime; sys::TimeValue deltaNow = now - lastNowTime; stats::instructionTime += delta.usec(); stats::instructionRealTime += deltaNow.usec(); lastUserTime = user; lastNowTime = now; } } Instruction *inst = es.pc->inst; const InstructionInfo &ii = *es.pc->info; StackFrame &sf = es.stack.back(); theStatisticManager->setIndex(ii.id); if (UseCallPaths) theStatisticManager->setContext(&sf.callPathNode->statistics); if (es.instsSinceCovNew) ++es.instsSinceCovNew; if (sf.kf->trackCoverage && instructionIsCoverable(inst)) { if (!theStatisticManager->getIndexedValue(stats::coveredInstructions, ii.id)) { // Checking for actual stoppoints avoids inconsistencies due // to line number propogation. // // FIXME: This trick no longer works, we should fix this in the line // number propogation. #if (LLVM_VERSION_MAJOR == 2 && LLVM_VERSION_MINOR < 7) if (isa<DbgStopPointInst>(inst)) #endif es.coveredLines[&ii.file].insert(ii.line); es.coveredNew = true; es.instsSinceCovNew = 1; ++stats::coveredInstructions; stats::uncoveredInstructions += (uint64_t)-1; } } } }
void StatsTracker::stepInstruction(ExecutionState &es) { if (OutputIStats) { if (TrackInstructionTime) { static sys::TimeValue lastNowTime(0, 0), lastUserTime(0, 0); if (lastUserTime.seconds() == 0 && lastUserTime.nanoseconds() == 0) { sys::TimeValue sys(0, 0); sys::Process::GetTimeUsage(lastNowTime, lastUserTime, sys); } else { sys::TimeValue now(0, 0), user(0, 0), sys(0, 0); sys::Process::GetTimeUsage(now, user, sys); sys::TimeValue delta = user - lastUserTime; sys::TimeValue deltaNow = now - lastNowTime; stats::instructionTime += delta.usec(); stats::instructionRealTime += deltaNow.usec(); lastUserTime = user; lastNowTime = now; } } Instruction *inst = es.pc()->inst; const InstructionInfo &ii = *es.pc()->info; StackFrame &sf = es.stack().back(); theStatisticManager->setIndex(ii.id); if (UseCallPaths) theStatisticManager->setContext(&sf.callPathNode->statistics); if (es.instsSinceCovNew) ++es.instsSinceCovNew; if (instructionIsCoverable(inst)) { if (!theStatisticManager->getIndexedValue( stats::locallyCoveredInstructions, ii.id)) { // Checking for actual stoppoints avoids inconsistencies due // to line number propogation. es.coveredLines[&ii.file].insert(ii.line); es.setCoveredNew(); es.instsSinceCovNew = 1; ++stats::locallyCoveredInstructions; stats::locallyUncoveredInstructions += (uint64_t) -1; if (!theStatisticManager->getIndexedValue(stats::globallyCoveredInstructions, ii.id)) { ++stats::globallyCoveredInstructions; stats::globallyUncoveredInstructions += (uint64_t) -1; } } } } }
static void printRestOfMemberHeader(raw_fd_ostream &Out, const sys::TimeValue &ModTime, unsigned UID, unsigned GID, unsigned Perms, unsigned Size) { printWithSpacePadding(Out, ModTime.toEpochTime(), 12); printWithSpacePadding(Out, UID, 6, true); printWithSpacePadding(Out, GID, 6, true); printWithSpacePadding(Out, format("%o", Perms), 8); printWithSpacePadding(Out, Size, 10); Out << "`\n"; }
StatsTracker::StatsTracker(Executor &_executor, std::string _objectFilename, bool _updateMinDistToUncovered) : executor(_executor), objectFilename(_objectFilename), statsFile(0), istatsFile(0), startWallTime(util::getWallTime()), numBranches(0), fullBranches(0), partialBranches(0), updateMinDistToUncovered(_updateMinDistToUncovered) { KModule *km = executor.kmodule; if (!sys::path::is_absolute(objectFilename)) { SmallString<128> current(objectFilename); if(sys::fs::make_absolute(current)) { bool exists = false; #if LLVM_VERSION_CODE >= LLVM_VERSION(3, 6) Twine current_twine(current.str()); //requires a twine for this. so silly if (!sys::fs::exists(current_twine)) { #elif LLVM_VERSION_CODE == LLVM_VERSION(3, 5) if (!sys::fs::exists(current.str(), exists)) { #elif LLVM_VERSION_CODE < LLVM_VERSION(3, 5) error_code ec = sys::fs::exists(current.str(), exists); if (ec == errc::success && exists) { #endif objectFilename = current.c_str(); } } } if (OutputIStats) theStatisticManager->useIndexedStats(km->infos->getMaxID()); for (std::vector<KFunction*>::iterator it = km->functions.begin(), ie = km->functions.end(); it != ie; ++it) { KFunction *kf = *it; kf->trackCoverage = 1; for (unsigned i=0; i<kf->numInstructions; ++i) { KInstruction *ki = kf->instructions[i]; if (OutputIStats) { unsigned id = ki->info->id; theStatisticManager->setIndex(id); if (kf->trackCoverage && instructionIsCoverable(ki->inst)) ++stats::uncoveredInstructions; } if (kf->trackCoverage) { if (BranchInst *bi = dyn_cast<BranchInst>(ki->inst)) if (!bi->isUnconditional()) numBranches++; } } } if (OutputStats) { statsFile = executor.interpreterHandler->openOutputFile("run.stats"); assert(statsFile && "unable to open statistics trace file"); writeStatsHeader(); writeStatsLine(); executor.addTimer(new WriteStatsTimer(this), StatsWriteInterval); if (updateMinDistToUncovered) { computeReachableUncovered(); executor.addTimer(new UpdateReachableTimer(this), UncoveredUpdateInterval); } } if (OutputIStats) { istatsFile = executor.interpreterHandler->openOutputFile("run.istats"); assert(istatsFile && "unable to open istats file"); executor.addTimer(new WriteIStatsTimer(this), IStatsWriteInterval); } } StatsTracker::~StatsTracker() { if (statsFile) delete statsFile; if (istatsFile) delete istatsFile; } void StatsTracker::done() { if (statsFile) writeStatsLine(); if (OutputIStats) writeIStats(); } void StatsTracker::stepInstruction(ExecutionState &es) { if (OutputIStats) { if (TrackInstructionTime) { static sys::TimeValue lastNowTime(0,0),lastUserTime(0,0); if (lastUserTime.seconds()==0 && lastUserTime.nanoseconds()==0) { sys::TimeValue sys(0,0); sys::Process::GetTimeUsage(lastNowTime,lastUserTime,sys); } else { sys::TimeValue now(0,0),user(0,0),sys(0,0); sys::Process::GetTimeUsage(now,user,sys); sys::TimeValue delta = user - lastUserTime; sys::TimeValue deltaNow = now - lastNowTime; stats::instructionTime += delta.usec(); stats::instructionRealTime += deltaNow.usec(); lastUserTime = user; lastNowTime = now; } } Instruction *inst = es.pc->inst; const InstructionInfo &ii = *es.pc->info; StackFrame &sf = es.stack.back(); theStatisticManager->setIndex(ii.id); if (UseCallPaths) theStatisticManager->setContext(&sf.callPathNode->statistics); if (es.instsSinceCovNew) ++es.instsSinceCovNew; if (sf.kf->trackCoverage && instructionIsCoverable(inst)) { if (!theStatisticManager->getIndexedValue(stats::coveredInstructions, ii.id)) { // Checking for actual stoppoints avoids inconsistencies due // to line number propogation. // // FIXME: This trick no longer works, we should fix this in the line // number propogation. es.coveredLines[&ii.file].insert(ii.line); es.coveredNew = true; es.instsSinceCovNew = 1; ++stats::coveredInstructions; stats::uncoveredInstructions += (uint64_t)-1; } } } } /// /* Should be called _after_ the es->pushFrame() */ void StatsTracker::framePushed(ExecutionState &es, StackFrame *parentFrame) { if (OutputIStats) { StackFrame &sf = es.stack.back(); if (UseCallPaths) { CallPathNode *parent = parentFrame ? parentFrame->callPathNode : 0; CallPathNode *cp = callPathManager.getCallPath(parent, sf.caller ? sf.caller->inst : 0, sf.kf->function); sf.callPathNode = cp; cp->count++; } if (updateMinDistToUncovered) { uint64_t minDistAtRA = 0; if (parentFrame) minDistAtRA = parentFrame->minDistToUncoveredOnReturn; sf.minDistToUncoveredOnReturn = sf.caller ? computeMinDistToUncovered(sf.caller, minDistAtRA) : 0; } } } /* Should be called _after_ the es->popFrame() */ void StatsTracker::framePopped(ExecutionState &es) { // XXX remove me? } void StatsTracker::markBranchVisited(ExecutionState *visitedTrue, ExecutionState *visitedFalse) { if (OutputIStats) { unsigned id = theStatisticManager->getIndex(); uint64_t hasTrue = theStatisticManager->getIndexedValue(stats::trueBranches, id); uint64_t hasFalse = theStatisticManager->getIndexedValue(stats::falseBranches, id); if (visitedTrue && !hasTrue) { visitedTrue->coveredNew = true; visitedTrue->instsSinceCovNew = 1; ++stats::trueBranches; if (hasFalse) { ++fullBranches; --partialBranches; } else ++partialBranches; hasTrue = 1; } if (visitedFalse && !hasFalse) { visitedFalse->coveredNew = true; visitedFalse->instsSinceCovNew = 1; ++stats::falseBranches; if (hasTrue) { ++fullBranches; --partialBranches; } else ++partialBranches; } } } void StatsTracker::writeStatsHeader() { *statsFile << "('Instructions'," << "'FullBranches'," << "'PartialBranches'," << "'NumBranches'," << "'UserTime'," << "'NumStates'," << "'MallocUsage'," << "'NumQueries'," << "'NumQueryConstructs'," << "'NumObjects'," << "'WallTime'," << "'CoveredInstructions'," << "'UncoveredInstructions'," << "'QueryTime'," << "'SolverTime'," << "'CexCacheTime'," << "'ForkTime'," << "'ResolveTime'," #ifdef DEBUG << "'ArrayHashTime'," #endif << ")\n"; statsFile->flush(); }