[bolt] Use llvm::sys::RWMutex instead of std::shared_timed_mutex

[thakis]

Summary

This has the following advantages:

• std::shared_timed_mutex is macOS 10.12+ only. llvm::sys::RWMutex automatically switches to a different implementation internally when targeting older macOS versions.
• bolt only needs std::shared_mutex, not std::shared_timed_mutex. llvm::sys::RWMutex automatically uses std::shared_mutex internally where available.

std::shared_mutex and RWMutex have the same API, so no code changes
other than types and includes are needed.

[alexander-shaposhnikov]

LG

bolt/include/bolt/Core/BinaryContext.h

 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCPseudoProbe.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/RWMutex.h"
 #include "llvm/Support/raw_ostream.h"
 #include <functional>
 #include <list>
 #include <map>
 #include <set>
-#include <shared_mutex>
 #include <string>
 #include <system_error>
 #include <type_traits>
 #include <unordered_map>
 #include <vector>
 
 namespace llvm {
 class MCDisassembler;
class BinaryContext {
 
   /// Low level section registration.
   BinarySection &registerSection(BinarySection *Section);
 
   /// Store all functions in the binary, sorted by original address.
   std::map<uint64_t, BinaryFunction> BinaryFunctions;
 
   /// A mutex that is used to control parallel accesses to BinaryFunctions
-  mutable std::shared_timed_mutex BinaryFunctionsMutex;
+  mutable llvm::sys::RWMutex BinaryFunctionsMutex;
 
   /// Functions injected by BOLT
   std::vector<BinaryFunction *> InjectedBinaryFunctions;
 
   /// Jump tables for all functions mapped by address.
   std::map<uint64_t, JumpTable *> JumpTables;
 
   /// Locations of PC-relative relocations in data objects.
public:
 
   /// [MCSymbol] -> [BinaryFunction]
   ///
   /// As we fold identical functions, multiple symbols can point
   /// to the same BinaryFunction.
   std::unordered_map<const MCSymbol *, BinaryFunction *> SymbolToFunctionMap;
 
   /// A mutex that is used to control parallel accesses to SymbolToFunctionMap
-  mutable std::shared_timed_mutex SymbolToFunctionMapMutex;
+  mutable llvm::sys::RWMutex SymbolToFunctionMapMutex;
 
   /// Look up the symbol entry that contains the given \p Address (based on
   /// the start address and size for each symbol).  Returns a pointer to
   /// the BinaryData for that symbol.  If no data is found, nullptr is returned.
   const BinaryData *getBinaryDataContainingAddressImpl(uint64_t Address) const;
 
   /// Update the Parent fields in BinaryDatas after adding a new entry into
   /// \p BinaryDataMap.
public:
 
   /// A map from jump table address to insertion order.  Used for generating
   /// jump table names.
   std::map<uint64_t, size_t> JumpTableIds;
 
   std::unique_ptr<MCContext> Ctx;
 
   /// A mutex that is used to control parallel accesses to Ctx
-  mutable std::shared_timed_mutex CtxMutex;
-  std::unique_lock<std::shared_timed_mutex> scopeLock() const {
-    return std::unique_lock<std::shared_timed_mutex>(CtxMutex);
+  mutable llvm::sys::RWMutex CtxMutex;
+  std::unique_lock<llvm::sys::RWMutex> scopeLock() const {
+    return std::unique_lock<llvm::sys::RWMutex>(CtxMutex);
   }
 
   std::unique_ptr<DWARFContext> DwCtx;
 
   std::unique_ptr<Triple> TheTriple;
 
   const Target *TheTarget;
 

bolt/include/bolt/Core/BinaryFunction.h

 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/RWMutex.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <iterator>
 #include <limits>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
 #include <vector>
getFunctionEndLabel(const FragmentNum Fragment = FragmentNum::main()) const {
 
     size_t LabelIndex = Fragment.get();
     if (LabelIndex >= FunctionEndLabels.size()) {
       FunctionEndLabels.resize(LabelIndex + 1);
     }
 
     MCSymbol *&FunctionEndLabel = FunctionEndLabels[LabelIndex];
     if (!FunctionEndLabel) {
-      std::unique_lock<std::shared_timed_mutex> Lock(BC.CtxMutex);
+      std::unique_lock<llvm::sys::RWMutex> Lock(BC.CtxMutex);
       if (Fragment == FragmentNum::main())
         FunctionEndLabel = BC.Ctx->createNamedTempSymbol("func_end");
       else
         FunctionEndLabel = BC.Ctx->createNamedTempSymbol(
             formatv("func_cold_end.{0}", Fragment.get() - 1));
     }
     return FunctionEndLabel;
   }
public:
   }
 
   /// Create a basic block in the function. The new block is *NOT* inserted
   /// into the CFG. The caller must use insertBasicBlocks() to add any new
   /// blocks to the CFG.
   std::unique_ptr<BinaryBasicBlock>
   createBasicBlock(MCSymbol *Label = nullptr) {
     if (!Label) {
-      std::unique_lock<std::shared_timed_mutex> Lock(BC.CtxMutex);
+      std::unique_lock<llvm::sys::RWMutex> Lock(BC.CtxMutex);
       Label = BC.Ctx->createNamedTempSymbol("BB");
     }
     auto BB =
         std::unique_ptr<BinaryBasicBlock>(new BinaryBasicBlock(this, Label));
 
     LabelToBB[Label] = BB.get();
 
     return BB;

bolt/include/bolt/Passes/Aligner.h

 // the optimal performance.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef BOLT_PASSES_ALIGNER_H
 #define BOLT_PASSES_ALIGNER_H
 
 #include "bolt/Passes/BinaryPasses.h"
+#include "llvm/Support/RWMutex.h"
 
 namespace llvm {
 namespace bolt {
 
 class AlignerPass : public BinaryFunctionPass {
 private:
   /// Stats for usage of max bytes for basic block alignment.
   std::vector<uint32_t> AlignHistogram;
-  std::shared_timed_mutex AlignHistogramMtx;
+  llvm::sys::RWMutex AlignHistogramMtx;
 
   /// Stats: execution count of blocks that were aligned.
   std::atomic<uint64_t> AlignedBlocksCount{0};
 
   /// Assign alignment to basic blocks based on profile.
   void alignBlocks(BinaryFunction &Function, const MCCodeEmitter *Emitter);
 
 public:

bolt/include/bolt/Passes/Instrumentation.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef BOLT_PASSES_INSTRUMENTATION_H
 #define BOLT_PASSES_INSTRUMENTATION_H
 
 #include "bolt/Passes/BinaryPasses.h"
 #include "bolt/Passes/InstrumentationSummary.h"
+#include "llvm/Support/RWMutex.h"
 
 namespace llvm {
 namespace bolt {
 
 class Instrumentation : public BinaryFunctionPass {
 public:
   Instrumentation(const cl::opt<bool> &PrintPass)
       : BinaryFunctionPass(PrintPass),
private:
 
   /// Create a runtime library, pass the BinData over, and register it
   /// under \p BC.
   void setupRuntimeLibrary(BinaryContext &BC);
 
   /// strtab indices in StringTable for each function name
   std::unordered_map<const BinaryFunction *, uint32_t> FuncToStringIdx;
 
-  mutable std::shared_timed_mutex FDMutex;
+  mutable llvm::sys::RWMutex FDMutex;
 
   /// The data generated during Instrumentation pass that needs to
   /// be passed to the Instrument runtime library.
   std::unique_ptr<InstrumentationSummary> Summary;
 
   /// Statistics on counters
   uint32_t DirectCallCounters{0};
   uint32_t BranchCounters{0};

bolt/lib/Core/BinaryBasicBlock.cpp

bool BinaryBasicBlock::swapConditionalSuccessors() {
   std::swap(BranchInfo[0], BranchInfo[1]);
   return true;
 }
 
 void BinaryBasicBlock::addBranchInstruction(const BinaryBasicBlock *Successor) {
   assert(isSuccessor(Successor));
   BinaryContext &BC = Function->getBinaryContext();
   MCInst NewInst;
-  std::unique_lock<std::shared_timed_mutex> Lock(BC.CtxMutex);
+  std::unique_lock<llvm::sys::RWMutex> Lock(BC.CtxMutex);
   BC.MIB->createUncondBranch(NewInst, Successor->getLabel(), BC.Ctx.get());
   Instructions.emplace_back(std::move(NewInst));
 }
 
 void BinaryBasicBlock::addTailCallInstruction(const MCSymbol *Target) {
   BinaryContext &BC = Function->getBinaryContext();
   MCInst NewInst;
   BC.MIB->createTailCall(NewInst, Target, BC.Ctx.get());

bolt/lib/Core/BinaryContext.cpp

void BinaryContext::postProcessSymbolTable() {
   generateSymbolHashes();
 }
 
 void BinaryContext::foldFunction(BinaryFunction &ChildBF,
                                  BinaryFunction &ParentBF) {
   assert(!ChildBF.isMultiEntry() && !ParentBF.isMultiEntry() &&
          "cannot merge functions with multiple entry points");
 
-  std::unique_lock<std::shared_timed_mutex> WriteCtxLock(CtxMutex,
-                                                         std::defer_lock);
-  std::unique_lock<std::shared_timed_mutex> WriteSymbolMapLock(
+  std::unique_lock<llvm::sys::RWMutex> WriteCtxLock(CtxMutex, std::defer_lock);
+  std::unique_lock<llvm::sys::RWMutex> WriteSymbolMapLock(
       SymbolToFunctionMapMutex, std::defer_lock);
 
   const StringRef ChildName = ChildBF.getOneName();
 
   // Move symbols over and update bookkeeping info.
   for (MCSymbol *Symbol : ChildBF.getSymbols()) {
     ParentBF.getSymbols().push_back(Symbol);
     WriteSymbolMapLock.lock();
     SymbolToFunctionMap[Symbol] = &ParentBF;
     WriteSymbolMapLock.unlock();
     // NB: there's no need to update BinaryDataMap and GlobalSymbols.
   }
   ChildBF.getSymbols().clear();
 
   // Move other names the child function is known under.
   llvm::move(ChildBF.Aliases, std::back_inserter(ParentBF.Aliases));
   ChildBF.Aliases.clear();
 
   if (HasRelocations) {
     // Merge execution counts of ChildBF into those of ParentBF.
     // Without relocations, we cannot reliably merge profiles as both functions
     // continue to exist and either one can be executed.
     ChildBF.mergeProfileDataInto(ParentBF);
 
-    std::shared_lock<std::shared_timed_mutex> ReadBfsLock(BinaryFunctionsMutex,
-                                                          std::defer_lock);
-    std::unique_lock<std::shared_timed_mutex> WriteBfsLock(BinaryFunctionsMutex,
-                                                           std::defer_lock);
+    std::shared_lock<llvm::sys::RWMutex> ReadBfsLock(BinaryFunctionsMutex,
+    std::unique_lock<llvm::sys::RWMutex> WriteBfsLock(BinaryFunctionsMutex,
     // Remove ChildBF from the global set of functions in relocs mode.
     ReadBfsLock.lock();
     auto FI = BinaryFunctions.find(ChildBF.getAddress());
     ReadBfsLock.unlock();
 
     assert(FI != BinaryFunctions.end() && "function not found");
     assert(&ChildBF == &FI->second && "function mismatch");
 
if (Address == BD.getEndAddress()) {
     BinaryData *Next = getBinaryDataContainingAddress(BD.getEndAddress());
     if (Next && Next->getAddress() == BD.getEndAddress())
       setImmovable(*Next);
   }
 }
 
 BinaryFunction *BinaryContext::getFunctionForSymbol(const MCSymbol *Symbol,
                                                     uint64_t *EntryDesc) {
-  std::shared_lock<std::shared_timed_mutex> Lock(SymbolToFunctionMapMutex);
+  std::shared_lock<llvm::sys::RWMutex> Lock(SymbolToFunctionMapMutex);
   auto BFI = SymbolToFunctionMap.find(Symbol);
   if (BFI == SymbolToFunctionMap.end())
     return nullptr;
 
   BinaryFunction *BF = BFI->second;
   if (EntryDesc)
     *EntryDesc = BF->getEntryIDForSymbol(Symbol);
 

bolt/lib/Core/Exceptions.cpp

for (BinaryBasicBlock *const BB : FF) {
         if (Throws && StartRange && PreviousEH.LP == LP &&
             PreviousEH.Action == Action)
           continue;
 
         // Same symbol is used for the beginning and the end of the range.
         const MCSymbol *EHSymbol;
         MCInst EHLabel;
         {
-          std::unique_lock<std::shared_timed_mutex> Lock(BC.CtxMutex);
+          std::unique_lock<llvm::sys::RWMutex> Lock(BC.CtxMutex);
           EHSymbol = BC.Ctx->createNamedTempSymbol("EH");
           BC.MIB->createEHLabel(EHLabel, EHSymbol, BC.Ctx.get());
         }
 
         II = std::next(BB->insertPseudoInstr(II, EHLabel));
 
         // At this point we could be in one of the following states:
         //

bolt/lib/Core/ParallelUtilities.cpp

 //===- bolt/Core/ParallelUtilities.cpp - Parallel utilities ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Implementation of the class that manages parallel work on BinaryFunctions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "bolt/Core/ParallelUtilities.h"
 #include "bolt/Core/BinaryContext.h"
 #include "bolt/Core/BinaryFunction.h"
+#include "llvm/Support/RWMutex.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/Timer.h"
 #include <mutex>
-#include <shared_mutex>
 
 #define DEBUG_TYPE "par-utils"
 
 namespace opts {
 extern cl::OptionCategory BoltCategory;
 
 cl::opt<unsigned>
 ThreadCount("thread-count",

 
 void runOnEachFunctionWithUniqueAllocId(
     BinaryContext &BC, SchedulingPolicy SchedPolicy,
     WorkFuncWithAllocTy WorkFunction, PredicateTy SkipPredicate,
     std::string LogName, bool ForceSequential, unsigned TasksPerThread) {
   if (BC.getBinaryFunctions().size() == 0)
     return;
 
-  std::shared_timed_mutex MainLock;
+  llvm::sys::RWMutex MainLock;
   auto runBlock = [&](std::map<uint64_t, BinaryFunction>::iterator BlockBegin,
                       std::map<uint64_t, BinaryFunction>::iterator BlockEnd,
                       MCPlusBuilder::AllocatorIdTy AllocId) {
     Timer T(LogName, LogName);
     LLVM_DEBUG(T.startTimer());
-    std::shared_lock<std::shared_timed_mutex> Lock(MainLock);
+    std::shared_lock<llvm::sys::RWMutex> Lock(MainLock);
     for (auto It = BlockBegin; It != BlockEnd; ++It) {
       BinaryFunction &BF = It->second;
       if (SkipPredicate && SkipPredicate(BF))
         continue;
 
       WorkFunction(BF, AllocId);
     }
     LLVM_DEBUG(T.stopTimer());
   };
 
   if (opts::NoThreads || ForceSequential) {
     runBlock(BC.getBinaryFunctions().begin(), BC.getBinaryFunctions().end(), 0);
     return;
   }
   // This lock is used to postpone task execution
-  std::unique_lock<std::shared_timed_mutex> Lock(MainLock);
+  std::unique_lock<llvm::sys::RWMutex> Lock(MainLock);
 
   // Estimate the overall runtime cost using the scheduling policy
   const unsigned TotalCost = estimateTotalCost(BC, SkipPredicate, SchedPolicy);
   const unsigned BlocksCount = TasksPerThread * opts::ThreadCount;
   const unsigned BlockCost =
       TotalCost > BlocksCount ? TotalCost / BlocksCount : 1;
 
   // Divide work into blocks of equal cost

bolt/lib/Passes/Aligner.cpp

for (BinaryBasicBlock *BB : Function.getLayout().blocks()) {
     if (opts::AlignBlocksMinSize && BlockSize < opts::AlignBlocksMinSize)
       continue;
 
     BB->setAlignment(opts::BlockAlignment);
     BB->setAlignmentMaxBytes(BytesToUse);
 
     // Update stats.
     LLVM_DEBUG(
-      std::unique_lock<std::shared_timed_mutex> Lock(AlignHistogramMtx);
+      std::unique_lock<llvm::sys::RWMutex> Lock(AlignHistogramMtx);
       AlignHistogram[BytesToUse]++;
       AlignedBlocksCount += BB->getKnownExecutionCount();
     );
   }
 }
 
 void AlignerPass::runOnFunctions(BinaryContext &BC) {
   if (!BC.HasRelocations)

bolt/lib/Passes/Instrumentation.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "bolt/Passes/Instrumentation.h"
 #include "bolt/Core/ParallelUtilities.h"
 #include "bolt/RuntimeLibs/InstrumentationRuntimeLibrary.h"
 #include "bolt/Utils/Utils.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/RWMutex.h"
 #include <stack>
 
 #define DEBUG_TYPE "bolt-instrumentation"
 
 using namespace llvm;
 
 namespace opts {
 extern cl::OptionCategory BoltInstrCategory;
void Instrumentation::instrumentFunction(BinaryFunction &Function,
   if (BC.isMachO() && Function.hasName("___GLOBAL_init_65535/1"))
     return;
 
   SplitWorklistTy SplitWorklist;
   SplitInstrsTy SplitInstrs;
 
   FunctionDescription *FuncDesc = nullptr;
   {
-    std::unique_lock<std::shared_timed_mutex> L(FDMutex);
+    std::unique_lock<llvm::sys::RWMutex> L(FDMutex);
     Summary->FunctionDescriptions.emplace_back();
     FuncDesc = &Summary->FunctionDescriptions.back();
   }
 
   FuncDesc->Function = &Function;
   Function.disambiguateJumpTables(AllocId);
   Function.deleteConservativeEdges();