Subzero: Basic Block Profiler.

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
 // multiple functions.
 //
 //===----------------------------------------------------------------------===//
 
 #include <ctype.h> // isdigit(), isupper()
 #include <locale>  // locale
 #include <unordered_map>
 
 #include "llvm/Support/Timer.h"
 
 #include "IceCfg.h"
+#include "IceCfgNode.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceELFObjectWriter.h"
 #include "IceGlobalContext.h"
 #include "IceGlobalInits.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 #include "IceTimerTree.h"
 #include "IceTypes.h"
 
@@ skipping 216 matching lines @@
   switch (Flags.getOutFileType()) {
   case FT_Elf:
     ObjectWriter.reset(new ELFObjectWriter(*this, *ELFStr));
     break;
   case FT_Asm:
   case FT_Iasm:
     break;
   }
 }
 
+namespace {
+void addCallToProfileSummary(Cfg *Func) {
+  auto *Context = Func->getContext();
+  auto *ProfileSummarySym = Context->getConstantExternSym("profile_summary");
+  constexpr bool HasTailCall = false;

[Jim Stichnoth, 2015/06/08 23:45:32]

We've been using "const bool ..." instead of constexpr in the rest of the code
base.  Wondering if there is any special benefit to using constexpr on a
primitive type?

[John, 2015/06/09 15:36:18]

constexpr is a compile time constant, and the compiler should be able to
propagate the value where it is used. const is a constant variable, not
necessarily a constant. Happy to change.

+  auto *Call =
+      InstCall::create(Func, 0, nullptr, ProfileSummarySym, HasTailCall);
+  Func->getEntryNode()->getInsts().push_front(Call);
+}
+} // end of namespace

[Jim Stichnoth, 2015/06/08 23:45:31]

end of anonymous namespace

[John, 2015/06/09 15:36:19]

Done.

+
 void GlobalContext::translateFunctions() {
   while (std::unique_ptr<Cfg> Func = optQueueBlockingPop()) {
     // Install Func in TLS for Cfg-specific container allocators.
     Cfg::setCurrentCfg(Func.get());
     // Reset per-function stats being accumulated in TLS.
     resetStats();
     // Set verbose level to none if the current function does NOT
     // match the -verbose-focus command-line option.
     if (!matchSymbolName(Func->getFunctionName(),
                          getFlags().getVerboseFocusOn()))
       Func->setVerbose(IceV_None);
     // Disable translation if -notranslate is specified, or if the
     // current function matches the -translate-only option.  If
     // translation is disabled, just dump the high-level IR and
     // continue.
     if (getFlags().getDisableTranslation() ||
         !matchSymbolName(Func->getFunctionName(),
                          getFlags().getTranslateOnly())) {
       Func->dump();
       Cfg::setCurrentCfg(nullptr);
       continue; // Func goes out of scope and gets deleted
     }
+
+    // ProfilerInits contains the VariableDeclarations for all the

[Jim Stichnoth, 2015/06/08 23:45:32]

Would it be reasonable to move this new code into Cfg::translate()?  in the
interest of trying to limit translateFunctions() to work queue management

I guess this would mean that Cfg needs to hold ProfileInits, but that seems in
line with other Cfg responsibilities.

[John, 2015/06/09 15:36:20]

I thought about that in the beginning, but then I decided to go with the current
design. No strong opinions. Done.

+    // profiler-related symbols. If profiling is disabled, this array
+    // will be null.
+    std::unique_ptr<VariableDeclarationList> ProfilerInits;
+    if (getFlags().getEnableBlockProfile()) {
+      ProfilerInits = Func->profileBlocks();
+      if (matchSymbolName(Func->getFunctionName(), "exit")) {

[Jim Stichnoth, 2015/06/08 23:45:32]

Does a normal return from main() lead to a call to exit() ?

[John, 2015/06/09 15:36:19]

It does, at least in the current library:

        subl    $16, %esp
        movl    %edi, (%esp)    # END=%edi
        movl    %ebx, 4(%esp)   # END=%ebx
        call    main
        addl    $16, %esp


        subl    $16, %esp
        movl    %eax, (%esp)    # END=%eax,%esp
        call    exit

        ud2
                                # LiveOut=

+        addCallToProfileSummary(Func.get());
+      }
+    }
+
     Func->translate();
     EmitterWorkItem *Item = nullptr;
     if (Func->hasError()) {
       getErrorStatus()->assign(EC_Translation);
       OstreamLocker L(this);
       getStrError() << "ICE translation error: " << Func->getFunctionName()
                     << ": " << Func->getError() << "\n";
       Item = new EmitterWorkItem(Func->getSequenceNumber());
     } else {
       Func->getAssembler<>()->setInternal(Func->getInternal());
@@ skipping 12 matching lines @@
       } break;
       case FT_Asm:
         // The Cfg has not been emitted yet, so stats are not ready
         // to be dumped.
         Item = new EmitterWorkItem(Func->getSequenceNumber(), Func.release());
         break;
       }
     }
     Cfg::setCurrentCfg(nullptr);
     assert(Item);
+    Item->setProfilerInits(std::move(ProfilerInits));
     emitQueueBlockingPush(Item);
     // The Cfg now gets deleted as Func goes out of scope.
   }
 }
 
 namespace {
 
+VariableDeclaration *blockProfileInfo(const VariableDeclarationList &Globals) {
+  auto *Var = VariableDeclaration::create();
+  Var->setAlignment(8);
+  Var->setIsConstant(true);
+  Var->setName("block_profile_info");
+  Var->setLinkage(llvm::GlobalValue::ExternalLinkage);
+  for (const auto *Global : Globals) {
+    if (Cfg::isProfileGlobal(*Global)) {
+      Var->addInitializer(new VariableDeclaration::RelocInitializer(Global, 0));

[Jim Stichnoth, 2015/06/08 23:45:32]

Can you "document" the 0, and the 8 a few lines down, by passing in a const
whatever value that is initialized to 0/8?

[John, 2015/06/09 15:36:20]

Done.

+    }
+  }
+
+  Var->addInitializer(new VariableDeclaration::ZeroInitializer(8));
+
+  return Var;
+}
+
+void addBlockProfileInfoArrayToGlobals(VariableDeclarationList *Globals) {
+  // Purposefully create the Var temp to prevent bugs in case the compilers

[Jim Stichnoth, 2015/06/08 23:45:32]

compilers ==> compiler

[John, 2015/06/09 15:36:19]

Done.

+  // reorders instructions in a way that Globals is extended before the call
+  // to profileInfoArray.
+  auto *Var = blockProfileInfo(*Globals);
+  Globals->push_back(Var);
+}
+
 void lowerGlobals(GlobalContext *Ctx,
                   std::unique_ptr<VariableDeclarationList> VariableDeclarations,
                   TargetDataLowering *DataLowering) {
   TimerMarker T(TimerStack::TT_emitGlobalInitializers, Ctx);
   const bool DumpGlobalVariables = ALLOW_DUMP && Ctx->getFlags().getVerbose() &&
                                    Ctx->getFlags().getVerboseFocusOn().empty();
   if (DumpGlobalVariables) {
     OstreamLocker L(Ctx);
     Ostream &Stream = Ctx->getStrDump();
     for (const Ice::VariableDeclaration *Global : *VariableDeclarations) {
       Global->dump(Ctx, Stream);
     }
   }
   if (Ctx->getFlags().getDisableTranslation())
     return;
+
+  // There should be no need to emit the block_profile_info array if profiling
+  // is disabled. In practice, given that szrt_profiler.o will always be embeded

[Jim Stichnoth, 2015/06/08 23:45:31]

embedded

[John, 2015/06/09 15:36:18]

Done.

+  // in the application, we need to add it. In a non-profiled build this array
+  // will only contain the nullptr terminator.
+  addBlockProfileInfoArrayToGlobals(VariableDeclarations.get());
+
   DataLowering->lowerGlobals(std::move(VariableDeclarations));
 }
 
 // Ensure Pending is large enough that Pending[Index] is valid.
 void resizePending(std::vector<EmitterWorkItem *> &Pending, uint32_t Index) {
   if (Index >= Pending.size())
     Pending.resize(Index + 1);
 }
 
+void AddAllIfNotNull(std::unique_ptr<VariableDeclarationList> src,

[Jim Stichnoth, 2015/06/08 23:45:32]

AddAllIfNotNull ==> addAllIfNotNull

[John, 2015/06/09 15:36:20]

Done.

+                     VariableDeclarationList *dst) {
+  if (src != nullptr) {
+    dst->insert(dst->end(), src->begin(), src->end());
+  }
+}
+
 } // end of anonymous namespace
 
 void GlobalContext::emitItems() {
   const bool Threaded = !getFlags().isSequential();
   // Pending is a vector containing the reassembled, ordered list of
   // work items.  When we're ready for the next item, we first check
   // whether it's in the Pending list.  If not, we take an item from
   // the work queue, and if it's not the item we're waiting for, we
   // insert it into Pending and repeat.  The work item is deleted
   // after it is processed.
+  std::unique_ptr<VariableDeclarationList> GlobalInits(
+      new VariableDeclarationList());
   std::vector<EmitterWorkItem *> Pending;
   uint32_t DesiredSequenceNumber = getFirstSequenceNumber();
   while (true) {
     resizePending(Pending, DesiredSequenceNumber);
     // See if Pending contains DesiredSequenceNumber.
     EmitterWorkItem *RawItem = Pending[DesiredSequenceNumber];
     if (RawItem == nullptr)
       RawItem = emitQueueBlockingPop();
     if (RawItem == nullptr)
-      return;
+      break;
     uint32_t ItemSeq = RawItem->getSequenceNumber();
     if (Threaded && ItemSeq != DesiredSequenceNumber) {
       resizePending(Pending, ItemSeq);
       Pending[ItemSeq] = RawItem;
       continue;
     }
 
     std::unique_ptr<EmitterWorkItem> Item(RawItem);
     ++DesiredSequenceNumber;
     switch (Item->getKind()) {
     case EmitterWorkItem::WI_Nop:
       break;
     case EmitterWorkItem::WI_GlobalInits: {
-      lowerGlobals(this, Item->getGlobalInits(),
-                   TargetDataLowering::createLowering(this).get());
+      AddAllIfNotNull(Item->getGlobalInits(), GlobalInits.get());
     } break;
     case EmitterWorkItem::WI_Asm: {
+      AddAllIfNotNull(Item->getProfilerInits(), GlobalInits.get());
       std::unique_ptr<Assembler> Asm = Item->getAsm();
       Asm->alignFunction();
       IceString MangledName = mangleName(Asm->getFunctionName());
       switch (getFlags().getOutFileType()) {
       case FT_Elf:
         getObjectWriter()->writeFunctionCode(MangledName, Asm->getInternal(),
                                              Asm.get());
         break;
       case FT_Iasm: {
         OstreamLocker L(this);
         Cfg::emitTextHeader(MangledName, this, Asm.get());
         Asm->emitIASBytes(this);
       } break;
       case FT_Asm:
         llvm::report_fatal_error("Unexpected FT_Asm");
         break;
       }
     } break;
     case EmitterWorkItem::WI_Cfg: {
       if (!ALLOW_DUMP)
         llvm::report_fatal_error("WI_Cfg work item created inappropriately");
+
+      AddAllIfNotNull(Item->getProfilerInits(), GlobalInits.get());
+
       assert(getFlags().getOutFileType() == FT_Asm);
       std::unique_ptr<Cfg> Func = Item->getCfg();
       // Unfortunately, we have to temporarily install the Cfg in TLS
       // because Variable::asType() uses the allocator to create the
       // differently-typed copy.
       Cfg::setCurrentCfg(Func.get());
       Func->emit();
       Cfg::setCurrentCfg(nullptr);
       dumpStats(Func->getFunctionName());
     } break;
     }
   }
+
+  lowerGlobals(this, std::move(GlobalInits),
+               TargetDataLowering::createLowering(this).get());
 }
 
 // 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
 // legitimately contains that pattern, then the substitution will be
 // made in error and most likely the link will fail.  In this case,
 // the test classes can be rewritten not to use that pattern, which is
 // much simpler and more reliable than implementing a full demangling
 // parser.  Another substitution-in-error may occur if a type
 // identifier ends with the pattern S[0-9A-Z]*, because an immediately
@@ skipping 406 matching lines @@
   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