[llvm-exegesis] Save target state before running the benchmark.

[courbet]

Summary

Some benchmarked instructions might set target state. Preserve this
state. See PR26418.

[gchatelet]

Can you reformat to fix Lint errors as well.

llvm/tools/llvm-exegesis/lib/Target.h

178

I find PreservedState a bit unclear. Maybe SavedState or SnapshotState is more explicit? No strong opinion though.

[courbet]

Thanks, PTAL.

[courbet]

Address review comments

[courbet]

This was eventually landed as rG8383fddc4fa9b4e61954e5ac93b00719a39d2291

[anna]

Just recording here (previous discussion was here D90742) :
our internal buildbots at Azul has failed because of an older assembler. We’ve taken in all commits/reverts/relands w.r.t this change upto Nov 4th. I have reverted the change rG8383fddc4fa9 downstream and confirmed the build passes.

The specific failure is:
/tmp/cc2lBtEi.s: Assembler messages:
/tmp/cc2lBtEi.s:541: Error: no such instruction: `fxsave64 16(%rax)'
/tmp/cc2lBtEi.s:566: Error: no such instruction: `fxrstor64 16(%rdi)'
/tmp/cc2lBtEi.s:592: Error: no such instruction: `fxrstor64 16(%rdi)'
make[2]: *** [tools/llvm-exegesis/lib/X86/CMakeFiles/LLVMExegesisX86.dir/Target.cpp.o] Error 1

We use the GNU assembler and it is configured for 64 bit machines. Here's the details from one of the machines:

as --version
GNU assembler version 2.20.51.0.2-5.47.el6_9.1 20100205
Copyright 2009 Free Software Foundation, Inc.
This program is free software; you may redistribute it under the terms of
the GNU General Public License version 3 or later.
This program has absolutely no warranty.
This assembler was configured for a target of `x86_64-redhat-linux'

[MaskRay]

In D90592#2391790, @anna wrote:

Just recording here (previous discussion was here D90742) :
our internal buildbots at Azul has failed because of an older assembler. We’ve taken in all commits/reverts/relands w.r.t this change upto Nov 4th. I have reverted the change rG8383fddc4fa9 downstream and confirmed the build passes.

The specific failure is:
/tmp/cc2lBtEi.s: Assembler messages:
/tmp/cc2lBtEi.s:541: Error: no such instruction: `fxsave64 16(%rax)'
/tmp/cc2lBtEi.s:566: Error: no such instruction: `fxrstor64 16(%rdi)'
/tmp/cc2lBtEi.s:592: Error: no such instruction: `fxrstor64 16(%rdi)'
make[2]: *** [tools/llvm-exegesis/lib/X86/CMakeFiles/LLVMExegesisX86.dir/Target.cpp.o] Error 1

We use the GNU assembler and it is configured for 64 bit machines. Here's the details from one of the machines:

as --version
GNU assembler version 2.20.51.0.2-5.47.el6_9.1 20100205
Copyright 2009 Free Software Foundation, Inc.
This program is free software; you may redistribute it under the terms of
the GNU General Public License version 3 or later.
This program has absolutely no warranty.
This assembler was configured for a target of `x86_64-redhat-linux'

This does look too old now (2009). For GCC, llvm-project currently requires at least 5.1 (2015). I'll not expect GCC 5.1 to ship a binutils from 2009:)

In addition, if you use -fintegrated-as, you don't need to worry about the version of GNU as.

llvm/test/tools/llvm-exegesis/X86/uops-FLDENVm.s

+# RUN: llvm-exegesis -mode=uops -opcode-name=FLDENVm,FLDL2E -repetition-mode=duplicate | FileCheck %s
+
+CHECK:      mode:            uops
+CHECK-NEXT: key:
+CHECK-NEXT:   instructions:
+CHECK-NEXT:     FLDENVm

llvm/tools/llvm-exegesis/lib/BenchmarkRunner.cpp

private:
   runAndSample(const char *Counters) const override {
     // We sum counts when there are several counters for a single ProcRes
     // (e.g. P23 on SandyBridge).
     llvm::SmallVector<int64_t, 4> CounterValues;
     int Reserved = 0;
     SmallVector<StringRef, 2> CounterNames;
     StringRef(Counters).split(CounterNames, '+');
     char *const ScratchPtr = Scratch->ptr();
+    const ExegesisTarget &ET = State.getExegesisTarget();
     for (auto &CounterName : CounterNames) {
       CounterName = CounterName.trim();
-      auto CounterOrError =
-          State.getExegesisTarget().createCounter(CounterName, State);
+      auto CounterOrError = ET.createCounter(CounterName, State);
 
       if (!CounterOrError)
         return CounterOrError.takeError();
 
       pfm::Counter *Counter = CounterOrError.get().get();
       if (Reserved == 0) {
         Reserved = Counter->numValues();
         CounterValues.reserve(Reserved);
       } else if (Reserved != Counter->numValues())
         // It'd be wrong to accumulate vectors of different sizes.
         return make_error<Failure>(
             llvm::Twine("Inconsistent number of values for counter ")
                 .concat(CounterName)
                 .concat(std::to_string(Counter->numValues()))
                 .concat(" vs expected of ")
                 .concat(std::to_string(Reserved)));
       Scratch->clear();
       {
+        auto PS = ET.withSavedState();
         CrashRecoveryContext CRC;
         CrashRecoveryContext::Enable();
         const bool Crashed = !CRC.RunSafely([this, Counter, ScratchPtr]() {
           Counter->start();
           this->Function(ScratchPtr);
           Counter->stop();
         });
         CrashRecoveryContext::Disable();
+        PS.reset();
         if (Crashed) {
           std::string Msg = "snippet crashed while running";
 #ifdef LLVM_ON_UNIX
           // See "Exit Status for Commands":
           // https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xcu_chap02.html
           constexpr const int kSigOffset = 128;
           if (const char *const SigName = strsignal(CRC.RetCode - kSigOffset)) {
             Msg += ": ";

llvm/tools/llvm-exegesis/lib/Target.h

public:
   static void registerTarget(ExegesisTarget *T);
 
   virtual ~ExegesisTarget();
 
   // Returns the Pfm counters for the given CPU (or the default if no pfm
   // counters are defined for this CPU).
   const PfmCountersInfo &getPfmCounters(StringRef CpuName) const;
 
+  // Saves the CPU state that needs to be preserved when running a benchmark,
+  // and returns and RAII object that restores the state on destruction.
+  // By default no state is preserved.
+  struct SavedState {
+    virtual ~SavedState();
+  };
+  virtual std::unique_ptr<SavedState> withSavedState() const {
+    return std::make_unique<SavedState>();
+  }
+
 private:
   virtual bool matchesArch(Triple::ArchType Arch) const = 0;
 
   // Targets can implement their own snippet generators/benchmarks runners by
   // implementing these.
   std::unique_ptr<SnippetGenerator> virtual createSerialSnippetGenerator(
       const LLVMState &State, const SnippetGenerator::Options &Opts) const;
   std::unique_ptr<SnippetGenerator> virtual createParallelSnippetGenerator(

llvm/tools/llvm-exegesis/lib/Target.cpp

if (Found == CpuPfmCounters.end() || StringRef(Found->CpuName) != CpuName) {
     } else {
       return PfmCountersInfo::Default; // No default for the target.
     }
   }
   assert(Found->PCI && "Missing counters");
   return *Found->PCI;
 }
 
+ExegesisTarget::SavedState::~SavedState() {} // anchor.
+
 namespace {
 
 // Default implementation.
 class ExegesisDefaultTarget : public ExegesisTarget {
 public:
   ExegesisDefaultTarget() : ExegesisTarget({}) {}
 
 private:

llvm/tools/llvm-exegesis/lib/X86/Target.cpp

 #include "X86RegisterInfo.h"
 #include "X86Subtarget.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/MC/MCInstBuilder.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 
+#include <immintrin.h>
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace llvm {
 namespace exegesis {
 
 static cl::OptionCategory
add(fillStackSpace(
         X86::MOV8mi, ByteOffset,
         WideConstant.extractBits(8, ByteOffset * 8).getZExtValue()));
 }
 
 #include "X86GenExegesis.inc"
 
 namespace {
 
+class X86SavedState : public ExegesisTarget::SavedState {
+public:
+  X86SavedState() { _fxsave64(FPState); }
+
+  ~X86SavedState() {
+    // Restoring the X87 state does not flush pending exceptions, make sure
+    // these exceptions are flushed now.
+#if defined(_MSC_VER)
+    _clearfp();
+#elif defined(__GNUC__)
+    asm volatile("fwait");
+#endif
+    _fxrstor64(FPState);
+  }
+
+private:
+  alignas(16) char FPState[512];
+};
+
 class ExegesisX86Target : public ExegesisTarget {
 public:
   ExegesisX86Target() : ExegesisTarget(X86CpuPfmCounters) {}
 
   Expected<std::unique_ptr<pfm::Counter>>
   createCounter(StringRef CounterName, const LLVMState &State) const override {
     // If LbrSamplingPeriod was provided, then ignore the
     // CounterName because we only have one for LBR.
#if defined(__linux__) && defined(HAVE_LIBPFM) &&                              \
     return X86LbrCounter::checkLbrSupport();
 #else
     return llvm::make_error<llvm::StringError>(
         "LBR not supported on this kernel and/or platform",
         llvm::errc::not_supported);
 #endif
   }
 
+  std::unique_ptr<SavedState> withSavedState() const override {
+    return std::make_unique<X86SavedState>();
+  }
+
   static const unsigned kUnavailableRegisters[4];
 };
 
 // We disable a few registers that cannot be encoded on instructions with a REX
 // prefix.
 const unsigned ExegesisX86Target::kUnavailableRegisters[4] = {X86::AH, X86::BH,
                                                               X86::CH, X86::DH};