Subzero: Improve the use of timers.

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs -------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 258 matching lines @@
   // free.
   GlobalContext::TlsInit();
   Cfg::TlsInit();
   // Create a new ThreadContext for the current thread.  No need to
   // lock AllThreadContexts at this point since no other threads have
   // access yet to this GlobalContext object.
   ThreadContext *MyTLS = new ThreadContext();
   AllThreadContexts.push_back(MyTLS);
   ICE_TLS_SET_FIELD(TLS, MyTLS);
   // Pre-register built-in stack names.
-  if (BuildDefs::dump()) {
+  if (BuildDefs::timers()) {
     // TODO(stichnot): There needs to be a strong relationship between
     // the newTimerStackID() return values and TSK_Default/TSK_Funcs.
     newTimerStackID("Total across all functions");
     newTimerStackID("Per-function summary");
   }
   Timers.initInto(MyTLS->Timers);
   switch (Flags.getOutFileType()) {
   case FT_Elf:
     ObjectWriter.reset(new ELFObjectWriter(*this, *ELFStr));
     break;
@@ skipping 510 matching lines @@
 
 JumpTableData &
 GlobalContext::addJumpTable(const IceString &FuncName, SizeT Id,
                             const JumpTableData::TargetList &TargetList) {
   auto JumpTableList = getJumpTableList();
   JumpTableList->emplace_back(FuncName, Id, TargetList);
   return JumpTableList->back();
 }
 
 TimerStackIdT GlobalContext::newTimerStackID(const IceString &Name) {
-  if (!BuildDefs::dump())
+  if (!BuildDefs::timers())
     return 0;
   auto Timers = getTimers();
   TimerStackIdT NewID = Timers->size();
   Timers->push_back(TimerStack(Name));
   return NewID;
 }
 
 TimerIdT GlobalContext::getTimerID(TimerStackIdT StackID,
                                    const IceString &Name) {
   auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
@@ skipping 25 matching lines @@
   assert(StackID < Timers->size());
   Timers->at(StackID).setName(NewName);
 }
 
 // Note: optQueueBlockingPush and optQueueBlockingPop use unique_ptr at the
 // interface to take and transfer ownership, but they internally store the raw
 // Cfg pointer in the work queue. This allows e.g. future queue optimizations
 // such as the use of atomics to modify queue elements.
 void GlobalContext::optQueueBlockingPush(std::unique_ptr<Cfg> Func) {
   assert(Func);
-  OptQ.blockingPush(Func.release());
+  {
+    TimerMarker _(TimerStack::TT_qTransPush, this);
+    OptQ.blockingPush(Func.release());
+  }
   if (getFlags().isSequential())
     translateFunctions();
 }
 
 std::unique_ptr<Cfg> GlobalContext::optQueueBlockingPop() {
+  TimerMarker _(TimerStack::TT_qTransPop, this);
   return std::unique_ptr<Cfg>(OptQ.blockingPop());
 }
 
 void GlobalContext::emitQueueBlockingPush(EmitterWorkItem *Item) {
   assert(Item);
-  EmitQ.blockingPush(Item);
+  {
+    TimerMarker _(TimerStack::TT_qEmitPush, this);
+    EmitQ.blockingPush(Item);
+  }
   if (getFlags().isSequential())
     emitItems();
 }
 
 EmitterWorkItem *GlobalContext::emitQueueBlockingPop() {
+  TimerMarker _(TimerStack::TT_qEmitPop, this);
   return EmitQ.blockingPop();
 }
 
 void GlobalContext::dumpStats(const IceString &Name, bool Final) {
   if (!getFlags().getDumpStats())
     return;
   if (Final) {
     getStatsCumulative()->dump(Name, this);
   } else {
     ICE_TLS_GET_FIELD(TLS)->StatsFunction.dump(Name, this);
   }
 }
 
 void GlobalContext::dumpTimers(TimerStackIdT StackID, bool DumpCumulative) {
-  if (!BuildDefs::dump())
+  if (!BuildDefs::timers())
     return;
   auto Timers = getTimers();
   assert(Timers->size() > StackID);
   OstreamLocker L(this);
   Timers->at(StackID).dump(getStrDump(), DumpCumulative);
 }
 
 ClFlags GlobalContext::Flags;
 ClFlagsExtra GlobalContext::ExtraFlags;
 
+TimerIdT TimerMarker::getTimerIdFromFuncName(GlobalContext *Ctx,
+                                             const IceString &FuncName) {
+  if (!BuildDefs::timers())
+    return 0;
+  if (!Ctx->getFlags().getTimeEachFunction())
+    return 0;
+  return Ctx->getTimerID(GlobalContext::TSK_Funcs, FuncName);
+}
+
 void TimerMarker::push() {
   switch (StackID) {
   case GlobalContext::TSK_Default:
     Active = Ctx->getFlags().getSubzeroTimingEnabled();
     break;
   case GlobalContext::TSK_Funcs:
     Active = Ctx->getFlags().getTimeEachFunction();
     break;
   default:
     break;
   }
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 void TimerMarker::pushCfg(const Cfg *Func) {
   Ctx = Func->getContext();
   Active =
       Func->getFocusedTiming() || Ctx->getFlags().getSubzeroTimingEnabled();
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice