Subzero: Fix timers for multithreaded translation.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines aspects of the compilation that persist across
@@ skipping 125 matching lines @@
            /*Sequential=*/(Flags.NumTranslationThreads == 0)) {
   // Make sure thread_local fields are properly initialized before any
   // accesses are made.  Do this here instead of at the start of
   // main() so that all clients (e.g. unit tests) can benefit for
   // 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.
-  AllThreadContexts.push_back(new ThreadContext());
-  ICE_TLS_SET_FIELD(TLS, AllThreadContexts.back());
+  ThreadContext *MyTLS = new ThreadContext();
+  AllThreadContexts.push_back(MyTLS);
+  ICE_TLS_SET_FIELD(TLS, MyTLS);
   // Pre-register built-in stack names.
   if (ALLOW_DUMP) {
     // 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);
   if (Flags.UseELFWriter) {
     ObjectWriter.reset(new ELFObjectWriter(*this, *ELFStr));
   }
 }
 
 void GlobalContext::translateFunctions() {
   while (Cfg *Func = cfgQueueBlockingPop()) {
     // Reset per-function stats being accumulated in TLS.
     resetStats();
     // Install Func in TLS for Cfg-specific container allocators.
@@ skipping 331 matching lines @@
   if (!ALLOW_DUMP)
     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 = getTimers();
+  auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
   assert(StackID < Timers->size());
   return Timers->at(StackID).getTimerID(Name);
 }
 
 void GlobalContext::pushTimer(TimerIdT ID, TimerStackIdT StackID) {
-  // TODO(stichnot): Timers are completely broken for multithreading; fix.
-  if (getFlags().NumTranslationThreads)
-    llvm::report_fatal_error("Timers and multithreading are currently broken");
-  auto Timers = getTimers();
+  auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
   assert(StackID < Timers->size());
   Timers->at(StackID).push(ID);
 }
 
 void GlobalContext::popTimer(TimerIdT ID, TimerStackIdT StackID) {
-  // TODO(stichnot): Timers are completely broken for multithreading; fix.
-  if (getFlags().NumTranslationThreads)
-    llvm::report_fatal_error("Timers and multithreading are currently broken");
-  auto Timers = getTimers();
+  auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
   assert(StackID < Timers->size());
   Timers->at(StackID).pop(ID);
 }
 
 void GlobalContext::resetTimer(TimerStackIdT StackID) {
-  auto Timers = getTimers();
+  auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
   assert(StackID < Timers->size());
   Timers->at(StackID).reset();
 }
 
 void GlobalContext::setTimerName(TimerStackIdT StackID,
                                  const IceString &NewName) {
-  auto Timers = getTimers();
+  auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
   assert(StackID < Timers->size());
   Timers->at(StackID).setName(NewName);
 }
 
 void GlobalContext::dumpStats(const IceString &Name, bool Final) {
   if (!ALLOW_DUMP || !getFlags().DumpStats)
     return;
   OstreamLocker OL(this);
   if (Final) {
     getStatsCumulative()->dump(Name, getStrDump());
   } else {
     ICE_TLS_GET_FIELD(TLS)->StatsFunction.dump(Name, getStrDump());
     getStatsCumulative()->dump("_TOTAL_", getStrDump());
   }
 }
 
 void GlobalContext::dumpTimers(TimerStackIdT StackID, bool DumpCumulative) {
   if (!ALLOW_DUMP)
     return;
   auto Timers = getTimers();
   assert(Timers->size() > StackID);
   OstreamLocker L(this);
   Timers->at(StackID).dump(getStrDump(), DumpCumulative);
 }
 
-TimerMarker::TimerMarker(TimerIdT ID, const Cfg *Func)
-    : ID(ID), Ctx(Func->getContext()), Active(false) {
-  if (ALLOW_DUMP) {
-    Active = Func->getFocusedTiming() || Ctx->getFlags().SubzeroTimingEnabled;
-    if (Active)
-      Ctx->pushTimer(ID);
+void TimerMarker::push() {
+  switch (StackID) {
+  case GlobalContext::TSK_Default:
+    Active = Ctx->getFlags().SubzeroTimingEnabled;
+    break;
+  case GlobalContext::TSK_Funcs:
+    Active = Ctx->getFlags().TimeEachFunction;
+    break;
+  default:
+    break;
   }
+  if (Active)
+    Ctx->pushTimer(ID, StackID);
+}
+
+void TimerMarker::pushCfg(const Cfg *Func) {
+  Ctx = Func->getContext();
+  Active = Func->getFocusedTiming() || Ctx->getFlags().SubzeroTimingEnabled;
+  if (Active)
+    Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice