[llvm-exegesis][NFC] Improve parsing of the YAML files

[gchatelet]

Summary

sscanf turns out to be slow for reading floating points.

[courbet]

tools/llvm-exegesis/lib/BenchmarkResult.cpp

90 ↗

(On Diff #168234)

what about adding an overload for consumeUnsignedInteger(uint64_t) and delegating to a template<typename T> consumeUnsignedInteger(T) in the cpp file ?

[RKSimon]

It looks like you're reading/writing hex integer values now - weren't they regular decimals before hand?

[gchatelet]

In D52866#1254835, @RKSimon wrote:

It looks like you're reading/writing hex integer values now - weren't they regular decimals before hand?

Nope they were hex before as well.
I tested the analysis on an YAML file written with a previous version, it should be a NFC.

[gchatelet]

• Address comments

llvm/trunk/tools/llvm-exegesis/lib/BenchmarkResult.cpp

 //===-- BenchmarkResult.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "BenchmarkResult.h"
 #include "BenchmarkRunner.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/bit.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ObjectYAML/YAML.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
-static constexpr const char kIntegerFormat[] = "i_0x%" PRId64 "x";
-static constexpr const char kDoubleFormat[] = "f_%la";
+static constexpr const char kIntegerPrefix[] = "i_0x";
+static constexpr const char kDoublePrefix[] = "f_";
 static constexpr const char kInvalidOperand[] = "INVALID";
 
 // A mutable struct holding an LLVMState that can be passed through the
 // serialization process to encode/decode registers and instructions.
 struct YamlContext {
   YamlContext(const exegesis::LLVMState &State)
       : State(&State), ErrorStream(LastError) {}
 
unsigned getRegNo(llvm::StringRef RegName) {
     for (unsigned E = RegInfo.getNumRegs(), I = 0; I < E; ++I)
       if (RegInfo.getName(I) == RegName)
         return I;
     ErrorStream << "No register with name " << RegName;
     return 0;
   }
 
 private:
+  void serializeIntegerOperand(llvm::raw_ostream &OS, int64_t Value) {
+    OS << kIntegerPrefix;
+    OS.write_hex(llvm::bit_cast<uint64_t>(Value));
+  }
+
+  bool tryDeserializeIntegerOperand(llvm::StringRef String, int64_t &Value) {
+    if (!String.consume_front(kIntegerPrefix))
+      return false;
+    return !String.consumeInteger(16, Value);
+  }
+
+  void serializeFPOperand(llvm::raw_ostream &OS, double Value) {
+    OS << kDoublePrefix << llvm::format("%la", Value);
+  }
+
+  bool tryDeserializeFPOperand(llvm::StringRef String, double &Value) {
+    if (!String.consume_front(kDoublePrefix))
+      return false;
+    char *EndPointer = nullptr;
+    Value = strtod(String.begin(), &EndPointer);
+    return EndPointer == String.end();
+  }
+
   void serializeMCOperand(const llvm::MCOperand &MCOperand,
                           llvm::raw_ostream &OS) {
     if (MCOperand.isReg()) {
       OS << getRegName(MCOperand.getReg());
     } else if (MCOperand.isImm()) {
-      OS << llvm::format(kIntegerFormat, MCOperand.getImm());
+      serializeIntegerOperand(OS, MCOperand.getImm());
     } else if (MCOperand.isFPImm()) {
-      OS << llvm::format(kDoubleFormat, MCOperand.getFPImm());
+      serializeFPOperand(OS, MCOperand.getFPImm());
     } else {
       OS << kInvalidOperand;
     }
   }
 
   llvm::MCOperand deserializeMCOperand(llvm::StringRef String) {
     assert(!String.empty());
     int64_t IntValue = 0;
     double DoubleValue = 0;
-    if (String[0] == kIntegerFormat[0] &&
-        sscanf(String.data(), kIntegerFormat, &IntValue) == 1)
+    if (tryDeserializeIntegerOperand(String, IntValue))
       return llvm::MCOperand::createImm(IntValue);
-    if (String[0] == kDoubleFormat[0] &&
-        sscanf(String.data(), kDoubleFormat, &DoubleValue) == 1)
+    if (tryDeserializeFPOperand(String, DoubleValue))
       return llvm::MCOperand::createFPImm(DoubleValue);
     if (unsigned RegNo = getRegNo(String))
       return llvm::MCOperand::createReg(RegNo);
     if (String != kInvalidOperand)
       ErrorStream << "Unknown Operand: '" << String << "'";
     return {};
   }