Subzero: Add locking to prepare 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 90 matching lines @@
   TypePool<IceType_f64, double, ConstantDouble> Doubles;
   TypePool<IceType_i1, int8_t, ConstantInteger32> Integers1;
   TypePool<IceType_i8, int8_t, ConstantInteger32> Integers8;
   TypePool<IceType_i16, int16_t, ConstantInteger32> Integers16;
   TypePool<IceType_i32, int32_t, ConstantInteger32> Integers32;
   TypePool<IceType_i64, int64_t, ConstantInteger64> Integers64;
   TypePool<IceType_i32, RelocatableTuple, ConstantRelocatable> Relocatables;
   UndefPool Undefs;
 };
 
-void CodeStats::dump(const IceString &Name, Ostream &Str) {
+void GlobalContext::CodeStats::dump(const IceString &Name, Ostream &Str) {
   if (!ALLOW_DUMP)
     return;
   Str << "|" << Name << "|Inst Count  |" << InstructionsEmitted << "\n";
   Str << "|" << Name << "|Regs Saved  |" << RegistersSaved << "\n";
   Str << "|" << Name << "|Frame Bytes |" << FrameBytes << "\n";
   Str << "|" << Name << "|Spills      |" << Spills << "\n";
   Str << "|" << Name << "|Fills       |" << Fills << "\n";
   Str << "|" << Name << "|Spills+Fills|" << Spills + Fills << "\n";
   Str << "|" << Name << "|Memory Usage|";
   if (ssize_t MemUsed = llvm::TimeRecord::getCurrentTime(false).getMemUsed())
     Str << MemUsed;
   else
     Str << "(requires '-track-memory')";
   Str << "\n";
 }
 
 GlobalContext::GlobalContext(Ostream *OsDump, Ostream *OsEmit,
                              ELFStreamer *ELFStr, VerboseMask Mask,
                              TargetArch Arch, OptLevel Opt,
                              IceString TestPrefix, const ClFlags &Flags)
-    : StrDump(OsDump), StrEmit(OsEmit), VMask(Mask),
+    : IsStrLocked(false), StrDump(OsDump), StrEmit(OsEmit), VMask(Mask),
       ConstPool(new ConstantPool()), Arch(Arch), Opt(Opt),
       TestPrefix(TestPrefix), Flags(Flags), RNG(""), ObjectWriter() {
+  // 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());
+  TLS = AllThreadContexts.back();
   // 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");
   }
   if (Flags.UseELFWriter) {
     ObjectWriter.reset(new ELFObjectWriter(*this, *ELFStr));
   }
 }
 
 // Scan a string for S[0-9A-Z]*_ patterns and replace them with
 // S<num>_ where <num> is the next base-36 value.  If a type name
@@ skipping 154 matching lines @@
     return NewName.data();
   }
 
   // Transform bar ==> Prefixbar
   //                   ^^^^^^
   return getTestPrefix() + Name;
 }
 
 GlobalContext::~GlobalContext() {
   llvm::DeleteContainerPointers(GlobalDeclarations);
+  llvm::DeleteContainerPointers(AllThreadContexts);
 }
 
+// TODO(stichnot): Consider adding thread-local caches of constant
+// pool entries to reduce contention.
+
+// All locking is done by the getConstantInt[0-9]+() target function.
 Constant *GlobalContext::getConstantInt(Type Ty, int64_t Value) {
   switch (Ty) {
   case IceType_i1:
     return getConstantInt1(Value);
   case IceType_i8:
     return getConstantInt8(Value);
   case IceType_i16:
     return getConstantInt16(Value);
   case IceType_i32:
     return getConstantInt32(Value);
   case IceType_i64:
     return getConstantInt64(Value);
   default:
     llvm_unreachable("Bad integer type for getConstant");
   }
   return nullptr;
 }
 
 Constant *GlobalContext::getConstantInt1(int8_t ConstantInt1) {
+  std::lock_guard<GlobalLockType> L(GlobalLock);
   ConstantInt1 &= INT8_C(1);
   return ConstPool->Integers1.getOrAdd(this, ConstantInt1);
 }
 
 Constant *GlobalContext::getConstantInt8(int8_t ConstantInt8) {
+  std::lock_guard<GlobalLockType> L(GlobalLock);
   return ConstPool->Integers8.getOrAdd(this, ConstantInt8);
 }
 
 Constant *GlobalContext::getConstantInt16(int16_t ConstantInt16) {
+  std::lock_guard<GlobalLockType> L(GlobalLock);
   return ConstPool->Integers16.getOrAdd(this, ConstantInt16);
 }
 
 Constant *GlobalContext::getConstantInt32(int32_t ConstantInt32) {
+  std::lock_guard<GlobalLockType> L(GlobalLock);
   return ConstPool->Integers32.getOrAdd(this, ConstantInt32);
 }
 
 Constant *GlobalContext::getConstantInt64(int64_t ConstantInt64) {
+  std::lock_guard<GlobalLockType> L(GlobalLock);
   return ConstPool->Integers64.getOrAdd(this, ConstantInt64);
 }
 
 Constant *GlobalContext::getConstantFloat(float ConstantFloat) {
+  std::lock_guard<GlobalLockType> L(GlobalLock);
   return ConstPool->Floats.getOrAdd(this, ConstantFloat);
 }
 
 Constant *GlobalContext::getConstantDouble(double ConstantDouble) {
+  std::lock_guard<GlobalLockType> L(GlobalLock);
   return ConstPool->Doubles.getOrAdd(this, ConstantDouble);
 }
 
 Constant *GlobalContext::getConstantSym(RelocOffsetT Offset,
                                         const IceString &Name,
                                         bool SuppressMangling) {
+  std::lock_guard<GlobalLockType> L(GlobalLock);
   return ConstPool->Relocatables.getOrAdd(
       this, RelocatableTuple(Offset, Name, SuppressMangling));
 }
 
 Constant *GlobalContext::getConstantUndef(Type Ty) {
+  std::lock_guard<GlobalLockType> L(GlobalLock);
   return ConstPool->Undefs.getOrAdd(this, Ty);
 }
 
+// All locking is done by the getConstant*() target function.
 Constant *GlobalContext::getConstantZero(Type Ty) {
   switch (Ty) {
   case IceType_i1:
     return getConstantInt1(0);
   case IceType_i8:
     return getConstantInt8(0);
   case IceType_i16:
     return getConstantInt16(0);
   case IceType_i32:
     return getConstantInt32(0);
@@ skipping 15 matching lines @@
     BaseOS << "Unsupported constant type: " << Ty;
     llvm_unreachable(BaseOS.str().c_str());
   } break;
   case IceType_void:
   case IceType_NUM:
     break;
   }
   llvm_unreachable("Unknown type");
 }
 
-ConstantList GlobalContext::getConstantPool(Type Ty) const {
+ConstantList GlobalContext::getConstantPool(Type Ty) {
+  std::lock_guard<GlobalLockType> L(GlobalLock);
   switch (Ty) {
   case IceType_i1:
   case IceType_i8:
   case IceType_i16:
   case IceType_i32:
     return ConstPool->Integers32.getConstantPool();
   case IceType_i64:
     return ConstPool->Integers64.getConstantPool();
   case IceType_f32:
     return ConstPool->Floats.getConstantPool();
@@ skipping 11 matching lines @@
     BaseOS << "Unsupported constant type: " << Ty;
     llvm_unreachable(BaseOS.str().c_str());
   } break;
   case IceType_void:
   case IceType_NUM:
     break;
   }
   llvm_unreachable("Unknown type");
 }
 
+// No locking because only the bitcode parser thread calls it.

[jvoung (off chromium), 2015/01/15 18:20:40]

fwiw, chrome has a "base/threading/thread_checker.h" utility which let's you
assert that certain methods are always called by only one specific thread.

[Jim Stichnoth, 2015/01/17 18:44:17]

Acknowledged.

Also, on further inspection, this method and the one below seem unnecessary
because GlobalDeclarations is never actually used.  Added a TODO for me and Karl
to investigate.

 FunctionDeclaration *
 GlobalContext::newFunctionDeclaration(const FuncSigType *Signature,
                                       unsigned CallingConv, unsigned Linkage,
                                       bool IsProto) {
   FunctionDeclaration *Func = new FunctionDeclaration(
       *Signature, static_cast<llvm::CallingConv::ID>(CallingConv),
       static_cast<llvm::GlobalValue::LinkageTypes>(Linkage), IsProto);
   GlobalDeclarations.push_back(Func);
   return Func;
 }
 
+// No locking because only the bitcode parser thread calls it.
 VariableDeclaration *GlobalContext::newVariableDeclaration() {
   VariableDeclaration *Var = new VariableDeclaration();
   GlobalDeclarations.push_back(Var);
   return Var;
 }
 
-TimerIdT GlobalContext::getTimerID(TimerStackIdT StackID,
-                                   const IceString &Name) {
-  assert(StackID < Timers.size());
-  return Timers[StackID].getTimerID(Name);
-}
-
 TimerStackIdT GlobalContext::newTimerStackID(const IceString &Name) {
   if (!ALLOW_DUMP)
     return 0;
+  std::lock_guard<GlobalLockType> L(GlobalLock);
   TimerStackIdT NewID = Timers.size();
   Timers.push_back(TimerStack(Name));
   return NewID;
 }
 
+TimerIdT GlobalContext::getTimerID(TimerStackIdT StackID,
+                                   const IceString &Name) {
+  std::lock_guard<GlobalLockType> L(GlobalLock);
+  assert(StackID < Timers.size());
+  return Timers[StackID].getTimerID(Name);
+}
+
 void GlobalContext::pushTimer(TimerIdT ID, TimerStackIdT StackID) {
+  std::lock_guard<GlobalLockType> L(GlobalLock);
   assert(StackID < Timers.size());
   Timers[StackID].push(ID);
 }
 
 void GlobalContext::popTimer(TimerIdT ID, TimerStackIdT StackID) {
+  std::lock_guard<GlobalLockType> L(GlobalLock);
   assert(StackID < Timers.size());
   Timers[StackID].pop(ID);
 }
 
 void GlobalContext::resetTimer(TimerStackIdT StackID) {
+  std::lock_guard<GlobalLockType> L(GlobalLock);
   assert(StackID < Timers.size());
   Timers[StackID].reset();
 }
 
 void GlobalContext::setTimerName(TimerStackIdT StackID,
                                  const IceString &NewName) {
+  std::lock_guard<GlobalLockType> L(GlobalLock);
   assert(StackID < Timers.size());
   Timers[StackID].setName(NewName);
 }
 
 void GlobalContext::dumpStats(const IceString &Name, bool Final) {
-  if (!ALLOW_DUMP)
+  if (!ALLOW_DUMP || !getFlags().DumpStats)
     return;
-  if (Flags.DumpStats) {
-    if (Final) {
-      StatsCumulative.dump(Name, getStrDump());
-    } else {
-      StatsFunction.dump(Name, getStrDump());
-      StatsCumulative.dump("_TOTAL_", getStrDump());
-    }
+  std::lock_guard<GlobalLockType> L(GlobalLock);
+  OstreamLocker OL(this);
+  if (Final) {
+    StatsCumulative.dump(Name, getStrDump());
+  } else {
+    TLS->StatsFunction.dump(Name, getStrDump());
+    StatsCumulative.dump("_TOTAL_", getStrDump());
   }
 }
 
 void GlobalContext::dumpTimers(TimerStackIdT StackID, bool DumpCumulative) {
   if (!ALLOW_DUMP)
     return;
   assert(Timers.size() > StackID);
+  OstreamLocker L(this);
   Timers[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);
   }
 }
 
+thread_local GlobalContext::ThreadContext *GlobalContext::TLS;
+
 } // end of namespace Ice