[llvm-exegesis] Add predefined floating point values so we can test impact of special values on latency.

[gchatelet]

Summary

This will be useful to generate many configurations and test instruction regimes (NaN, Inf, subnormal, normal).

[lebedev.ri]

I suppose that will help de-flake the latency measurements? (i *think* i have only seen the fp ops being flaky)

[gchatelet]

In D51858#1228977, @lebedev.ri wrote:

I suppose that will help de-flake the latency measurements? (i *think* i have only seen the fp ops being flaky)

Yes indeed. For instance SSE/AVX operations may have different regimes depending on their inputs.

[RKSimon]

Are these the only values you're going to test? For instance many fdiv units have fast paths for some (+/-)pow2 divisors.

[gchatelet]

In D51858#1230113, @RKSimon wrote:

Are these the only values you're going to test? For instance many fdiv units have fast paths for some (+/-)pow2 divisors.

I intend to add more as we see fit, but TWO sounds like a useful addition already.

[gchatelet]

• Add TWO as a predefined floating point value.

[courbet]

tools/llvm-exegesis/lib/RegisterValue.cpp

2

missing header

7

getFloatValue

tools/llvm-exegesis/lib/RegisterValue.h

36

style: getFloatValueAsInteger

36

I would call this bitcastFloatValue or something like this.

[RKSimon]

In D51858#1230338, @gchatelet wrote:

• Add TWO as a predefined floating point value.

Cheers - no more comments.

[gchatelet]

• Address courbet's comments

tools/llvm-exegesis/lib/CMakeLists.txt

add_library(LLVMExegesis
   BenchmarkResult.cpp
   BenchmarkRunner.cpp
   Clustering.cpp
   Latency.cpp
   LlvmState.cpp
   MCInstrDescView.cpp
   PerfHelper.cpp
   RegisterAliasing.cpp
+  RegisterValue.cpp
   Target.cpp
   Uops.cpp
   )
 
 llvm_update_compile_flags(LLVMExegesis)
 llvm_map_components_to_libnames(libs
   Analysis
   CodeGen

tools/llvm-exegesis/lib/RegisterValue.h

+//===-- RegisterValue.h -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+///
+/// Defines a Target independent value for a Register. This is useful to explore
+/// the influence of the instruction input values on its execution time.
+///
+//===----------------------------------------------------------------------===//
+
+#include <llvm/ADT/APFloat.h>
+
+namespace exegesis {
+
+enum class PredefinedValues {
+  POS_ZERO,       // Positive zero
+  NEG_ZERO,       // Negative zero
+  ONE,            // 1.0
+  INF,            // Infinity
+  QNAN,           // Quiet NaN
+  ULP,            // One Unit in the last place
+  SMALLEST = ULP, // The minimum subnormal number
+  SMALLEST_NORM,  // The minimum normal number
+  LARGEST,        // The maximum normal number
+  ONE_PLUS_ULP,   // The value just after 1.0
+};
+
+llvm::APInt GetFloatValueAsInteger(const llvm::fltSemantics &FltSemantics,
+                                   PredefinedValues Value);
+
+} // namespace exegesis

tools/llvm-exegesis/lib/RegisterValue.cpp

+#include "RegisterValue.h"
+#include "llvm/ADT/APFloat.h"
+
+namespace exegesis {
+
+static llvm::APFloat GetFloatValue(const llvm::fltSemantics &FltSemantics,
+                                   PredefinedValues Value) {
+  switch (Value) {
+  case PredefinedValues::POS_ZERO:
+    return llvm::APFloat::getZero(FltSemantics);
+  case PredefinedValues::NEG_ZERO:
+    return llvm::APFloat::getZero(FltSemantics, true);
+  case PredefinedValues::ONE:
+    return llvm::APFloat(FltSemantics, "1");
+  case PredefinedValues::INF:
+    return llvm::APFloat::getInf(FltSemantics);
+  case PredefinedValues::QNAN:
+    return llvm::APFloat::getQNaN(FltSemantics);
+  case PredefinedValues::SMALLEST_NORM:
+    return llvm::APFloat::getSmallestNormalized(FltSemantics);
+  case PredefinedValues::LARGEST:
+    return llvm::APFloat::getLargest(FltSemantics);
+  case PredefinedValues::ULP:
+    return llvm::APFloat::getSmallest(FltSemantics);
+  case PredefinedValues::ONE_PLUS_ULP:
+    auto Output = GetFloatValue(FltSemantics, PredefinedValues::ONE);
+    Output.next(false);
+    return Output;
+  }
+}
+
+llvm::APInt GetFloatValueAsInteger(const llvm::fltSemantics &FltSemantics,
+                                   PredefinedValues Value) {
+  return GetFloatValue(FltSemantics, Value).bitcastToAPInt();
+}
+
+} // namespace exegesis

unittests/tools/llvm-exegesis/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   Symbolize
   )
 
 add_llvm_unittest(LLVMExegesisTests
   BenchmarkResultTest.cpp
   BenchmarkRunnerTest.cpp
   ClusteringTest.cpp
   PerfHelperTest.cpp
+  RegisterValueTest.cpp
   )
 target_link_libraries(LLVMExegesisTests PRIVATE LLVMExegesis)
 
 if(LLVM_TARGETS_TO_BUILD MATCHES "X86")
   add_subdirectory(X86)
 endif()
 if(LLVM_TARGETS_TO_BUILD MATCHES "ARM")
   add_subdirectory(ARM)
 endif()
 if(LLVM_TARGETS_TO_BUILD MATCHES "AArch64")
   add_subdirectory(AArch64)
 endif()

unittests/tools/llvm-exegesis/RegisterValueTest.cpp

+//===-- RegisterValueTest.cpp -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "RegisterValue.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace exegesis {
+
+namespace {
+
+#define CHECK(EXPECTED, ACTUAL)                                                \
+  EXPECT_EQ(llvm::APInt(SizeInBits, EXPECTED, 16),                             \
+            GetFloatValueAsInteger(Semantic, PredefinedValues::ACTUAL))
+
+TEST(RegisterValueTest, Half) {
+  const size_t SizeInBits = 16;
+  const auto &Semantic = llvm::APFloatBase::IEEEhalf();
+  CHECK("0000", POS_ZERO);
+  CHECK("8000", NEG_ZERO);
+  CHECK("3C00", ONE);
+  CHECK("7C00", INF);
+  CHECK("7E00", QNAN);
+  CHECK("7BFF", LARGEST);
+  CHECK("0400", SMALLEST_NORM);
+  CHECK("0001", SMALLEST);
+  CHECK("0001", ULP);
+  CHECK("3C01", ONE_PLUS_ULP);
+}
+
+TEST(RegisterValueTest, Single) {
+  const size_t SizeInBits = 32;
+  const auto &Semantic = llvm::APFloatBase::IEEEsingle();
+  CHECK("00000000", POS_ZERO);
+  CHECK("80000000", NEG_ZERO);
+  CHECK("3F800000", ONE);
+  CHECK("7F800000", INF);
+  CHECK("7FC00000", QNAN);
+  CHECK("7F7FFFFF", LARGEST);
+  CHECK("00800000", SMALLEST_NORM);
+  CHECK("00000001", SMALLEST);
+  CHECK("00000001", ULP);
+  CHECK("3F800001", ONE_PLUS_ULP);
+}
+
+TEST(RegisterValueTest, Double) {
+  const size_t SizeInBits = 64;
+  const auto &Semantic = llvm::APFloatBase::IEEEdouble();
+  CHECK("0000000000000000", POS_ZERO);
+  CHECK("8000000000000000", NEG_ZERO);
+  CHECK("3FF0000000000000", ONE);
+  CHECK("7FF0000000000000", INF);
+  CHECK("7FF8000000000000", QNAN);
+  CHECK("7FEFFFFFFFFFFFFF", LARGEST);
+  CHECK("0010000000000000", SMALLEST_NORM);
+  CHECK("0000000000000001", SMALLEST);
+  CHECK("0000000000000001", ULP);
+  CHECK("3FF0000000000001", ONE_PLUS_ULP);
+}
+
+} // namespace
+} // namespace exegesis