Moves the Mode field out of the Key. The existing yaml benchmark results can be fixed with the following script:
```
readonly FILE=$1
readonly MODE=latency # Change to uops to fix a uops benchmark.
cat $FILE | \
sed "/^\ \+mode:\ \+$MODE$/d" | \
sed "/^cpu_name.*$/i mode: $MODE"
```
Differential Revision: https://reviews.llvm.org/D47813
Authored by: Guillaume Chatelet
llvm-svn: 334079
std::vector<BenchmarkMeasure> SchedClassPoint(NumMeasurements);
// Latency case.
assert(!Clustering.getPoints().empty());
- const InstructionBenchmarkKey::ModeE Mode =
- Clustering.getPoints()[0].Key.Mode;
- if (Mode == InstructionBenchmarkKey::Latency) {
+ const InstructionBenchmark::ModeE Mode = Clustering.getPoints()[0].Mode;
+ if (Mode == InstructionBenchmark::Latency) {
if (NumMeasurements != 1) {
llvm::errs()
<< "invalid number of measurements in latency mode: expected 1, got "
std::max<double>(SchedClassPoint[0].Value, WLE->Cycles);
}
ClusterCenterPoint[0].Value = Representative[0].avg();
- } else if (Mode == InstructionBenchmarkKey::Uops) {
+ } else if (Mode == InstructionBenchmark::Uops) {
for (int I = 0, E = Representative.size(); I < E; ++I) {
// Find the pressure on ProcResIdx `Key`.
uint16_t ProcResIdx = 0;
};
template <>
-struct ScalarEnumerationTraits<exegesis::InstructionBenchmarkKey::ModeE> {
+struct ScalarEnumerationTraits<exegesis::InstructionBenchmark::ModeE> {
static void enumeration(IO &Io,
- exegesis::InstructionBenchmarkKey::ModeE &Value) {
- Io.enumCase(Value, "", exegesis::InstructionBenchmarkKey::Unknown);
- Io.enumCase(Value, "latency", exegesis::InstructionBenchmarkKey::Latency);
- Io.enumCase(Value, "uops", exegesis::InstructionBenchmarkKey::Uops);
+ exegesis::InstructionBenchmark::ModeE &Value) {
+ Io.enumCase(Value, "", exegesis::InstructionBenchmark::Unknown);
+ Io.enumCase(Value, "latency", exegesis::InstructionBenchmark::Latency);
+ Io.enumCase(Value, "uops", exegesis::InstructionBenchmark::Uops);
}
};
static void mapping(IO &Io, exegesis::InstructionBenchmarkKey &Obj) {
Io.mapRequired("opcode_name", Obj.OpcodeName);
Io.mapOptional("instructions", Obj.Instructions);
- Io.mapRequired("mode", Obj.Mode);
Io.mapOptional("config", Obj.Config);
}
};
template <> struct MappingTraits<exegesis::InstructionBenchmark> {
static void mapping(IO &Io, exegesis::InstructionBenchmark &Obj) {
+ Io.mapRequired("mode", Obj.Mode);
Io.mapRequired("key", Obj.Key);
Io.mapRequired("cpu_name", Obj.CpuName);
Io.mapRequired("llvm_triple", Obj.LLVMTriple);
// The LLVM opcode name.
std::string OpcodeName; // FIXME: Deprecated, use Instructions below.
std::vector<llvm::MCInst> Instructions;
- enum ModeE { Unknown, Latency, Uops };
- ModeE Mode;
// An opaque configuration, that can be used to separate several benchmarks of
// the same instruction under different configurations.
std::string Config;
// The result of an instruction benchmark.
struct InstructionBenchmark {
InstructionBenchmarkKey Key;
+ enum ModeE { Unknown, Latency, Uops };
+ ModeE Mode;
std::string CpuName;
std::string LLVMTriple;
int NumRepetitions = 0;
InstructionBenchmark InstrBenchmark;
InstrBenchmark.Key.OpcodeName = State.getInstrInfo().getName(Opcode);
- InstrBenchmark.Key.Mode = getMode();
+ InstrBenchmark.Mode = getMode();
InstrBenchmark.CpuName = State.getCpuName();
InstrBenchmark.LLVMTriple = State.getTriple();
InstrBenchmark.NumRepetitions = NumRepetitions;
const llvm::MCRegisterInfo &MCRegisterInfo;
private:
- virtual InstructionBenchmarkKey::ModeE getMode() const = 0;
+ virtual InstructionBenchmark::ModeE getMode() const = 0;
virtual llvm::Expected<std::vector<llvm::MCInst>>
createSnippet(RegisterAliasingTrackerCache &RATC, unsigned Opcode,
LatencyBenchmarkRunner::~LatencyBenchmarkRunner() = default;
-InstructionBenchmarkKey::ModeE LatencyBenchmarkRunner::getMode() const {
- return InstructionBenchmarkKey::Latency;
+InstructionBenchmark::ModeE LatencyBenchmarkRunner::getMode() const {
+ return InstructionBenchmark::Latency;
}
llvm::Expected<std::vector<llvm::MCInst>>
~LatencyBenchmarkRunner() override;
private:
- InstructionBenchmarkKey::ModeE getMode() const override;
+ InstructionBenchmark::ModeE getMode() const override;
llvm::Expected<std::vector<llvm::MCInst>>
createSnippet(RegisterAliasingTrackerCache &RATC, unsigned OpcodeIndex,
UopsBenchmarkRunner::~UopsBenchmarkRunner() = default;
-InstructionBenchmarkKey::ModeE UopsBenchmarkRunner::getMode() const {
- return InstructionBenchmarkKey::Uops;
+InstructionBenchmark::ModeE UopsBenchmarkRunner::getMode() const {
+ return InstructionBenchmark::Uops;
}
llvm::Expected<std::vector<llvm::MCInst>>
~UopsBenchmarkRunner() override;
private:
- InstructionBenchmarkKey::ModeE getMode() const override;
+ InstructionBenchmark::ModeE getMode() const override;
llvm::Expected<std::vector<llvm::MCInst>>
createSnippet(RegisterAliasingTrackerCache &RATC, unsigned Opcode,
ToDisk.Key.OpcodeName = "name";
ToDisk.Key.Instructions.push_back(llvm::MCInstBuilder(kInstrId));
- ToDisk.Key.Mode = InstructionBenchmarkKey::Latency;
ToDisk.Key.Config = "config";
+ ToDisk.Mode = InstructionBenchmark::Latency;
ToDisk.CpuName = "cpu_name";
ToDisk.LLVMTriple = "llvm_triple";
ToDisk.NumRepetitions = 1;
EXPECT_EQ(FromDisk.Key.OpcodeName, ToDisk.Key.OpcodeName);
EXPECT_THAT(FromDisk.Key.Instructions,
Pointwise(EqMCInst(), ToDisk.Key.Instructions));
- EXPECT_EQ(FromDisk.Key.Mode, ToDisk.Key.Mode);
EXPECT_EQ(FromDisk.Key.Config, ToDisk.Key.Config);
+ EXPECT_EQ(FromDisk.Mode, ToDisk.Mode);
EXPECT_EQ(FromDisk.CpuName, ToDisk.CpuName);
EXPECT_EQ(FromDisk.LLVMTriple, ToDisk.LLVMTriple);
EXPECT_EQ(FromDisk.NumRepetitions, ToDisk.NumRepetitions);
EXPECT_EQ(FromDisk.Key.OpcodeName, ToDisk.Key.OpcodeName);
EXPECT_THAT(FromDisk.Key.Instructions,
Pointwise(EqMCInst(), ToDisk.Key.Instructions));
- EXPECT_EQ(FromDisk.Key.Mode, ToDisk.Key.Mode);
EXPECT_EQ(FromDisk.Key.Config, ToDisk.Key.Config);
+ EXPECT_EQ(FromDisk.Mode, ToDisk.Mode);
EXPECT_EQ(FromDisk.CpuName, ToDisk.CpuName);
EXPECT_EQ(FromDisk.LLVMTriple, ToDisk.LLVMTriple);
EXPECT_EQ(FromDisk.NumRepetitions, ToDisk.NumRepetitions);