void Timer::stopTimer() {
Time += TimeRecord::getCurrentTime(false);
if (ActiveTimers->back() == this) {
ActiveTimers->pop_back();
} else {
std::vector<Timer*>::iterator I =
std::find(ActiveTimers->begin(), ActiveTimers->end(), this);
assert(I != ActiveTimers->end() && "stop but no startTimer?");
ActiveTimers->erase(I);
}
}
GenericValue Interpreter::callExternalFunction(Function *F,
ArrayRef<GenericValue> ArgVals) {
TheInterpreter = this;
unique_lock<sys::Mutex> Guard(*FunctionsLock);
// Do a lookup to see if the function is in our cache... this should just be a
// deferred annotation!
std::map<const Function *, ExFunc>::iterator FI = ExportedFunctions->find(F);
if (ExFunc Fn = (FI == ExportedFunctions->end()) ? lookupFunction(F)
: FI->second) {
Guard.unlock();
return Fn(F->getFunctionType(), ArgVals);
}
#ifdef USE_LIBFFI
std::map<const Function *, RawFunc>::iterator RF = RawFunctions->find(F);
RawFunc RawFn;
if (RF == RawFunctions->end()) {
RawFn = (RawFunc)(intptr_t)
sys::DynamicLibrary::SearchForAddressOfSymbol(F->getName());
if (!RawFn)
RawFn = (RawFunc)(intptr_t)getPointerToGlobalIfAvailable(F);
if (RawFn != 0)
RawFunctions->insert(std::make_pair(F, RawFn)); // Cache for later
} else {
RawFn = RF->second;
}
Guard.unlock();
GenericValue Result;
if (RawFn != 0 && ffiInvoke(RawFn, F, ArgVals, getDataLayout(), Result))
return Result;
#endif // USE_LIBFFI
if (F->getName() == "__main")
errs() << "Tried to execute an unknown external function: "
<< *F->getType() << " __main\n";
else
report_fatal_error("Tried to execute an unknown external function: " +
F->getName());
#ifndef USE_LIBFFI
errs() << "Recompiling LLVM with --enable-libffi might help.\n";
#endif
return GenericValue();
}
AnnotationID AnnotationManager::getID(const std::string &Name) { // Name -> ID
IDMapType::iterator I = IDMap->find(Name);
if (I == IDMap->end()) {
(*IDMap)[Name] = IDCounter++; // Add a new element
return IDCounter-1;
}
return I->second;
}
static Timer &getNamedRegionTimer(const std::string &Name) {
sys::SmartScopedLock<true> L(*TimerLock);
Name2Timer::iterator I = NamedTimers->find(Name);
if (I != NamedTimers->end())
return I->second;
return NamedTimers->insert(I, std::make_pair(Name, Timer(Name)))->second;
}
/// addPeakMemoryMeasurement - This method should be called whenever memory
/// usage needs to be checked. It adds a peak memory measurement to the
/// currently active timers, which will be printed when the timer group prints
///
void Timer::addPeakMemoryMeasurement() {
sys::SmartScopedLock<true> L(*TimerLock);
size_t MemUsed = getMemUsage();
for (std::vector<Timer*>::iterator I = ActiveTimers->begin(),
E = ActiveTimers->end(); I != E; ++I)
(*I)->PeakMem = std::max((*I)->PeakMem, MemUsed-(*I)->PeakMemBase);
}
void Timer::stopTimer() {
sys::SmartScopedLock<true> L(*TimerLock);
TimeRecord TR = getTimeRecord(false);
Elapsed += TR.Elapsed;
UserTime += TR.UserTime;
SystemTime += TR.SystemTime;
MemUsed += TR.MemUsed;
if (ActiveTimers->back() == this) {
ActiveTimers->pop_back();
} else {
std::vector<Timer*>::iterator I =
std::find(ActiveTimers->begin(), ActiveTimers->end(), this);
assert(I != ActiveTimers->end() && "stop but no startTimer?");
ActiveTimers->erase(I);
}
}
/// addPeakMemoryMeasurement - This method should be called whenever memory
/// usage needs to be checked. It adds a peak memory measurement to the
/// currently active timers, which will be printed when the timer group prints
///
void Timer::addPeakMemoryMeasurement() {
size_t MemUsed = getMemUsage();
for (std::vector<Timer*>::iterator I = ActiveTimers->begin(),
E = ActiveTimers->end(); I != E; ++I) {
(*I)->Lock.acquire();
(*I)->PeakMem = std::max((*I)->PeakMem, MemUsed-(*I)->PeakMemBase);
(*I)->Lock.release();
}
}
static Timer &getNamedRegionTimer(const std::string &Name,
const std::string &GroupName) {
sys::SmartScopedLock<true> L(*TimerLock);
Name2Pair::iterator I = NamedGroupedTimers->find(GroupName);
if (I == NamedGroupedTimers->end()) {
TimerGroup TG(GroupName);
std::pair<TimerGroup, Name2Timer> Pair(TG, Name2Timer());
I = NamedGroupedTimers->insert(I, std::make_pair(GroupName, Pair));
}
Name2Timer::iterator J = I->second.second.find(Name);
if (J == I->second.second.end())
J = I->second.second.insert(J,
std::make_pair(Name,
Timer(Name,
I->second.first)));
return J->second;
}
GenericValue Interpreter::callExternalFunction(Function *F,
const std::vector<GenericValue> &ArgVals) {
TheInterpreter = this;
// Do a lookup to see if the function is in our cache... this should just be a
// deferred annotation!
std::map<const Function *, ExFunc>::iterator FI = Functions->find(F);
ExFunc Fn = (FI == Functions->end()) ? lookupFunction(F) : FI->second;
if (Fn == 0) {
cerr << "Tried to execute an unknown external function: "
<< F->getType()->getDescription() << " " << F->getName() << "\n";
if (F->getName() == "__main")
return GenericValue();
abort();
}
// TODO: FIXME when types are not const!
GenericValue Result = Fn(const_cast<FunctionType*>(F->getFunctionType()),
ArgVals);
return Result;
}