[llvm] 8f4f26b - [MLGO] ML Regalloc Priority Advisor
Eric Wang via llvm-commits
llvm-commits at lists.llvm.org
Thu Sep 29 14:56:11 PDT 2022
Author: Eric Wang
Date: 2022-09-29T16:55:15-05:00
New Revision: 8f4f26ba5bd04f7b335836021e5e63b4236c0305
URL: https://github.com/llvm/llvm-project/commit/8f4f26ba5bd04f7b335836021e5e63b4236c0305
DIFF: https://github.com/llvm/llvm-project/commit/8f4f26ba5bd04f7b335836021e5e63b4236c0305.diff
LOG: [MLGO] ML Regalloc Priority Advisor
The bulk of the implementation is common between 'release' mode (==AOT-ed
model) and 'development' mode (for training), the main difference is
that in development mode, we may also log features (for training logs),
inject scoring information and then produce the log file.
Differential Revision: https://reviews.llvm.org/D133616
Added:
llvm/lib/Analysis/models/gen-regalloc-priority-test-model.py
llvm/lib/CodeGen/MLRegallocPriorityAdvisor.cpp
llvm/test/CodeGen/MLRegalloc/Inputs/reference-prio-log-noml.txt
llvm/test/CodeGen/MLRegalloc/dev-mode-prio-logging.ll
Modified:
llvm/lib/CodeGen/CMakeLists.txt
llvm/lib/CodeGen/RegAllocPriorityAdvisor.cpp
Removed:
################################################################################
diff --git a/llvm/lib/Analysis/models/gen-regalloc-priority-test-model.py b/llvm/lib/Analysis/models/gen-regalloc-priority-test-model.py
new file mode 100644
index 0000000000000..81de2c70565a8
--- /dev/null
+++ b/llvm/lib/Analysis/models/gen-regalloc-priority-test-model.py
@@ -0,0 +1,95 @@
+"""Generate a mock model for LLVM tests for Register Allocation.
+The generated model is not a neural net - it is just a tf.function with the
+correct input and output parameters.
+"""
+## By construction, the mock model will always output the first liverange that can be evicted.
+
+import os
+import sys
+import tensorflow as tf
+POLICY_DECISION_LABEL = 'priority'
+POLICY_OUTPUT_SPEC = """
+[
+ {
+ "logging_name": "priority",
+ "tensor_spec": {
+ "name": "StatefulPartitionedCall",
+ "port": 0,
+ "type": "float",
+ "shape": [
+ 1
+ ]
+ }
+ }
+]
+"""
+PER_LIVEINTERVAL_INT64_FEATURE_LIST = [
+ 'li_size', 'stage'
+]
+PER_LIVEINTERVAL_FLOAT32_FEATURE_LIST = ['weight'
+]
+PER_LIVEINTERVAL_FEATURE_LIST = PER_LIVEINTERVAL_FLOAT32_FEATURE_LIST + \
+ PER_LIVEINTERVAL_INT64_FEATURE_LIST
+CONTEXT_FEATURE_LIST = ('discount', 'reward', 'step_type')
+
+
+def get_input_signature():
+ """Returns (time_step_spec, action_spec) for LLVM register allocation."""
+ inputs = dict(
+ (key, tf.TensorSpec(dtype=tf.int64, shape=(), name=key))
+ for key in PER_LIVEINTERVAL_INT64_FEATURE_LIST)
+ inputs.update(
+ dict((key,
+ tf.TensorSpec(dtype=tf.float32, shape=(), name=key))
+ for key in PER_LIVEINTERVAL_FLOAT32_FEATURE_LIST))
+ inputs.update(
+ dict((key, tf.TensorSpec(dtype=tf.float32, shape=(), name=key))
+ for key in ['discount', 'reward']))
+ inputs.update(
+ dict((key, tf.TensorSpec(dtype=tf.int32, shape=(), name=key))
+ for key in ['step_type']))
+ return inputs
+
+
+def get_output_spec_path(path):
+ return os.path.join(path, 'output_spec.json')
+
+
+def build_mock_model(path):
+ """Build and save the mock model with the given signature."""
+ module = tf.Module()
+ # We have to set this useless variable in order for the TF C API to correctly
+ # intake it
+ module.var = tf.Variable(0, dtype=tf.float32)
+
+ def action(*inputs):
+ s1 = tf.reduce_sum([
+ tf.cast(inputs[0][key], tf.float32) for key in PER_LIVEINTERVAL_FEATURE_LIST
+ ],
+ axis=0)
+ s2 = tf.reduce_sum(
+ [tf.cast(inputs[0][key], tf.float32) for key in CONTEXT_FEATURE_LIST])
+ # Add a large number so s won't be 0.
+ s = s1 + s2
+ result = s + module.var
+ return {POLICY_DECISION_LABEL: result}
+ module.action = tf.function()(action)
+ action = {
+ 'action': module.action.get_concrete_function(get_input_signature())
+ }
+
+ tf.saved_model.save(module, path, signatures=action)
+ output_spec_path = get_output_spec_path(path)
+ with open(output_spec_path, 'w') as f:
+ print(f'Writing output spec to {output_spec_path}.')
+ f.write(POLICY_OUTPUT_SPEC)
+
+
+def main(argv):
+ assert len(argv) == 2
+ model_path = argv[1]
+ build_mock_model(model_path)
+
+
+if __name__ == '__main__':
+ main(sys.argv)
diff --git a/llvm/lib/CodeGen/CMakeLists.txt b/llvm/lib/CodeGen/CMakeLists.txt
index afa37044c81ec..ce14e1d9d545d 100644
--- a/llvm/lib/CodeGen/CMakeLists.txt
+++ b/llvm/lib/CodeGen/CMakeLists.txt
@@ -143,6 +143,7 @@ add_llvm_component_library(LLVMCodeGen
MIRSampleProfile.cpp
MIRYamlMapping.cpp
MLRegallocEvictAdvisor.cpp
+ MLRegallocPriorityAdvisor.cpp
ModuloSchedule.cpp
MultiHazardRecognizer.cpp
PatchableFunction.cpp
diff --git a/llvm/lib/CodeGen/MLRegallocPriorityAdvisor.cpp b/llvm/lib/CodeGen/MLRegallocPriorityAdvisor.cpp
new file mode 100644
index 0000000000000..cda1e4e8f5126
--- /dev/null
+++ b/llvm/lib/CodeGen/MLRegallocPriorityAdvisor.cpp
@@ -0,0 +1,335 @@
+//===- MLRegAllocPriorityAdvisor.cpp - ML priority advisor-----------------===//
+//
+// 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 ML priority advisor and reward injection pass
+//
+//===----------------------------------------------------------------------===//
+
+#include "AllocationOrder.h"
+#include "RegAllocGreedy.h"
+#include "RegAllocPriorityAdvisor.h"
+#include "llvm/Analysis/AliasAnalysis.h"
+#include "llvm/Analysis/MLModelRunner.h"
+#include "llvm/Analysis/ReleaseModeModelRunner.h"
+#include "llvm/Analysis/TensorSpec.h"
+#include "llvm/CodeGen/CalcSpillWeights.h"
+#include "llvm/CodeGen/LiveRegMatrix.h"
+#include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineLoopInfo.h"
+#include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/CodeGen/Passes.h"
+#include "llvm/CodeGen/RegisterClassInfo.h"
+#include "llvm/CodeGen/SlotIndexes.h"
+#include "llvm/CodeGen/VirtRegMap.h"
+#include "llvm/InitializePasses.h"
+#include "llvm/Pass.h"
+#include "llvm/PassRegistry.h"
+#include "llvm/Support/CommandLine.h"
+
+#if defined(LLVM_HAVE_TF_API)
+#include "llvm/Analysis/ModelUnderTrainingRunner.h"
+#include "llvm/Analysis/NoInferenceModelRunner.h"
+#include "llvm/Analysis/Utils/TrainingLogger.h"
+#endif
+
+using namespace llvm;
+
+// Options that only make sense in development mode
+#ifdef LLVM_HAVE_TF_API
+#include "RegAllocScore.h"
+#include "llvm/Analysis/Utils/TFUtils.h"
+
+static cl::opt<std::string> TrainingLog(
+ "regalloc-priority-training-log", cl::Hidden,
+ cl::desc("Training log for the register allocator priority model"));
+
+static cl::opt<std::string> ModelUnderTraining(
+ "regalloc-priority-model", cl::Hidden,
+ cl::desc("The model being trained for register allocation priority"));
+
+#endif // #ifdef LLVM_HAVE_TF_API
+
+namespace llvm {
+
+static const std::vector<int64_t> PerLiveRangeShape{1};
+
+#define RA_PRIORITY_FEATURES_LIST(M) \
+ M(int64_t, li_size, PerLiveRangeShape, "size") \
+ M(int64_t, stage, PerLiveRangeShape, "stage") \
+ M(float, weight, PerLiveRangeShape, "weight")
+
+#define DecisionName "priority"
+
+// Named features index.
+enum FeatureIDs {
+#define _FEATURE_IDX(_, name, __, ___) name,
+ RA_PRIORITY_FEATURES_LIST(_FEATURE_IDX)
+#undef _FEATURE_IDX
+ FeatureCount
+};
+
+class MLPriorityAdvisor : public RegAllocPriorityAdvisor {
+public:
+ MLPriorityAdvisor(const MachineFunction &MF, const RAGreedy &RA,
+ SlotIndexes *const Indexes, MLModelRunner *Runner);
+
+protected:
+ const RegAllocPriorityAdvisor &getDefaultAdvisor() const {
+ return static_cast<const RegAllocPriorityAdvisor &>(DefaultAdvisor);
+ }
+
+ // The assumption is that if the Runner could not be constructed, we emit-ed
+ // error, and we shouldn't be asking for it here.
+ const MLModelRunner &getRunner() const { return *Runner; }
+ float getPriorityImpl(const LiveInterval &LI) const;
+ unsigned getPriority(const LiveInterval &LI) const override;
+
+private:
+ const DefaultPriorityAdvisor DefaultAdvisor;
+ MLModelRunner *const Runner;
+};
+
+#define _DECL_FEATURES(type, name, shape, _) \
+ TensorSpec::createSpec<type>(#name, shape),
+
+static const std::vector<TensorSpec> InputFeatures{
+ {RA_PRIORITY_FEATURES_LIST(_DECL_FEATURES)},
+};
+#undef _DECL_FEATURES
+
+// ===================================
+// Release (AOT) - specifics
+// ===================================
+class ReleaseModePriorityAdvisorAnalysis final
+ : public RegAllocPriorityAdvisorAnalysis {
+public:
+ ReleaseModePriorityAdvisorAnalysis()
+ : RegAllocPriorityAdvisorAnalysis(AdvisorMode::Release) {}
+ // support for isa<> and dyn_cast.
+ static bool classof(const RegAllocPriorityAdvisorAnalysis *R) {
+ return R->getAdvisorMode() == AdvisorMode::Release;
+ }
+
+private:
+ void getAnalysisUsage(AnalysisUsage &AU) const override {
+ AU.setPreservesAll();
+ AU.addRequired<SlotIndexes>();
+ RegAllocPriorityAdvisorAnalysis::getAnalysisUsage(AU);
+ }
+
+ std::unique_ptr<RegAllocPriorityAdvisor>
+ getAdvisor(const MachineFunction &MF, const RAGreedy &RA) override {
+ if (!Runner)
+ Runner = std::make_unique<ReleaseModeModelRunner<NoopSavedModelImpl>>(
+ MF.getFunction().getContext(), InputFeatures, DecisionName);
+ return std::make_unique<MLPriorityAdvisor>(
+ MF, RA, &getAnalysis<SlotIndexes>(), Runner.get());
+ }
+ std::unique_ptr<ReleaseModeModelRunner<NoopSavedModelImpl>> Runner;
+};
+
+// ===================================
+// Development mode-specifics
+// ===================================
+//
+// Features we log
+#ifdef LLVM_HAVE_TF_API
+
+static const TensorSpec Output =
+ TensorSpec::createSpec<float>(DecisionName, {1});
+static const TensorSpec Reward = TensorSpec::createSpec<float>("reward", {1});
+
+#define _DECL_TRAIN_FEATURES(type, name, shape, _) \
+ TensorSpec::createSpec<type>(std::string("action_") + #name, shape),
+
+static const std::vector<TensorSpec> TrainingInputFeatures{
+ {RA_PRIORITY_FEATURES_LIST(_DECL_TRAIN_FEATURES)
+ TensorSpec::createSpec<float>("action_discount", {1}),
+ TensorSpec::createSpec<int32_t>("action_step_type", {1}),
+ TensorSpec::createSpec<float>("action_reward", {1})}};
+#undef _DECL_TRAIN_FEATURES
+
+class DevelopmentModePriorityAdvisor : public MLPriorityAdvisor {
+public:
+ DevelopmentModePriorityAdvisor(const MachineFunction &MF, const RAGreedy &RA,
+ SlotIndexes *const Indexes,
+ MLModelRunner *Runner, Logger *Log)
+ : MLPriorityAdvisor(MF, RA, Indexes, Runner), Log(Log) {}
+
+private:
+ unsigned getPriority(const LiveInterval &LI) const override;
+ Logger *const Log;
+};
+
+class DevelopmentModePriorityAdvisorAnalysis final
+ : public RegAllocPriorityAdvisorAnalysis {
+public:
+ DevelopmentModePriorityAdvisorAnalysis()
+ : RegAllocPriorityAdvisorAnalysis(AdvisorMode::Development) {}
+ // support for isa<> and dyn_cast.
+ static bool classof(const RegAllocPriorityAdvisorAnalysis *R) {
+ return R->getAdvisorMode() == AdvisorMode::Development;
+ }
+
+ /// get the logger for the given function, or nullptr if we didn't collect
+ /// one. This is used to inject the score by the RegAllocScoring pass.
+ Logger *getLogger(const MachineFunction &MF) const {
+ auto I = LogMap.find(MF.getName());
+ if (I == LogMap.end())
+ return nullptr;
+ return I->second.get();
+ }
+
+ void logRewardIfNeeded(const MachineFunction &MF,
+ llvm::function_ref<float()> GetReward) override {
+ if (auto *Log = this->getLogger(MF))
+ Log->logFloatFinalReward(GetReward());
+ }
+
+private:
+ void getAnalysisUsage(AnalysisUsage &AU) const override {
+ AU.setPreservesAll();
+ AU.addRequired<SlotIndexes>();
+ RegAllocPriorityAdvisorAnalysis::getAnalysisUsage(AU);
+ }
+
+ // Save all the logs (when requested).
+ bool doFinalization(Module &M) override {
+ if (TrainingLog.empty())
+ return false;
+ std::error_code EC;
+ auto OS = std::make_unique<raw_fd_ostream>(TrainingLog, EC);
+ if (EC) {
+ M.getContext().emitError(EC.message() + ":" + TrainingLog);
+ return false;
+ }
+ Logger::flushLogs(*OS, LogMap);
+ return false;
+ }
+
+ std::unique_ptr<RegAllocPriorityAdvisor>
+ getAdvisor(const MachineFunction &MF, const RAGreedy &RA) override {
+
+ LLVMContext &Ctx = MF.getFunction().getContext();
+ if (ModelUnderTraining.empty() && TrainingLog.empty()) {
+ Ctx.emitError("Regalloc development mode should be requested with at "
+ "least logging enabled and/or a training model");
+ return nullptr;
+ }
+ if (!Runner) {
+ if (ModelUnderTraining.empty())
+ Runner = std::make_unique<NoInferenceModelRunner>(Ctx, InputFeatures);
+ else
+ Runner = ModelUnderTrainingRunner::createAndEnsureValid(
+ Ctx, ModelUnderTraining, DecisionName, TrainingInputFeatures);
+ if (!Runner) {
+ Ctx.emitError("Regalloc: could not set up the model runner");
+ return nullptr;
+ }
+ }
+
+ Logger *Log = nullptr;
+ if (!TrainingLog.empty()) {
+ std::vector<LoggedFeatureSpec> LFS;
+ for (const auto &FS : InputFeatures)
+ LFS.push_back({FS, None});
+ if (auto *MUTR = dyn_cast<ModelUnderTrainingRunner>(Runner.get()))
+ if (MUTR->outputLoggedFeatureSpecs().size() > 1)
+ append_range(LFS, drop_begin(MUTR->outputLoggedFeatureSpecs()));
+ // We always log the output; in particular, if we're not evaluating, we
+ // don't have an output spec json file. That's why we handle the
+ // 'normal' output separately.
+ LFS.push_back({Output, None});
+ auto I = LogMap.insert(std::make_pair(
+ MF.getFunction().getName(),
+ std::make_unique<Logger>(LFS, Reward, /*IncludeReward*/ true)));
+ assert(I.second);
+ Log = I.first->second.get();
+ }
+
+ return std::make_unique<DevelopmentModePriorityAdvisor>(
+ MF, RA, &getAnalysis<SlotIndexes>(), Runner.get(), Log);
+ }
+
+ std::unique_ptr<MLModelRunner> Runner;
+ StringMap<std::unique_ptr<Logger>> LogMap;
+};
+#endif //#ifdef LLVM_HAVE_TF_API
+
+} // namespace llvm
+
+RegAllocPriorityAdvisorAnalysis *llvm::createReleaseModePriorityAdvisor() {
+ return new ReleaseModePriorityAdvisorAnalysis();
+}
+
+MLPriorityAdvisor::MLPriorityAdvisor(const MachineFunction &MF,
+ const RAGreedy &RA,
+ SlotIndexes *const Indexes,
+ MLModelRunner *Runner)
+ : RegAllocPriorityAdvisor(MF, RA, Indexes), DefaultAdvisor(MF, RA, Indexes),
+ Runner(std::move(Runner)) {
+ assert(this->Runner);
+}
+
+float MLPriorityAdvisor::getPriorityImpl(const LiveInterval &LI) const {
+ const unsigned Size = LI.getSize();
+ LiveRangeStage Stage = RA.getExtraInfo().getStage(LI);
+
+ *Runner->getTensor<int64_t>(0) = static_cast<int64_t>(Size);
+ *Runner->getTensor<int64_t>(1) = static_cast<int64_t>(Stage);
+ *Runner->getTensor<float>(2) = static_cast<float>(LI.weight());
+
+ return Runner->evaluate<float>();
+}
+
+unsigned MLPriorityAdvisor::getPriority(const LiveInterval &LI) const {
+ return static_cast<unsigned>(getPriorityImpl(LI));
+}
+
+#ifdef LLVM_HAVE_TF_API
+RegAllocPriorityAdvisorAnalysis *llvm::createDevelopmentModePriorityAdvisor() {
+ return new DevelopmentModePriorityAdvisorAnalysis();
+}
+
+unsigned
+DevelopmentModePriorityAdvisor::getPriority(const LiveInterval &LI) const {
+ double Prio = 0;
+
+ if (isa<ModelUnderTrainingRunner>(getRunner())) {
+ Prio = MLPriorityAdvisor::getPriorityImpl(LI);
+ } else {
+ Prio = getDefaultAdvisor().getPriority(LI);
+ }
+
+ if (TrainingLog.empty())
+ return Prio;
+
+ size_t CurrentFeature = 0;
+ for (; CurrentFeature < InputFeatures.size(); ++CurrentFeature) {
+ Log->logSpecifiedTensorValue(
+ CurrentFeature, reinterpret_cast<const char *>(
+ getRunner().getTensorUntyped(CurrentFeature)));
+ }
+
+ if (auto *MUTR = dyn_cast<ModelUnderTrainingRunner>(&getRunner())) {
+ for (size_t I = 1; I < MUTR->outputLoggedFeatureSpecs().size();
+ ++I, ++CurrentFeature)
+ Log->logSpecifiedTensorValue(
+ CurrentFeature,
+ reinterpret_cast<const char *>(
+ MUTR->lastEvaluationResult()->getUntypedTensorValue(I)));
+ }
+
+ float Ret = static_cast<float>(Prio);
+ Log->logFloatValue(CurrentFeature, &Ret);
+
+ return static_cast<unsigned>(Prio);
+}
+
+#endif // #ifdef LLVM_HAVE_TF_API
diff --git a/llvm/lib/CodeGen/RegAllocPriorityAdvisor.cpp b/llvm/lib/CodeGen/RegAllocPriorityAdvisor.cpp
index 5ace3ddba8769..88fd47e600983 100644
--- a/llvm/lib/CodeGen/RegAllocPriorityAdvisor.cpp
+++ b/llvm/lib/CodeGen/RegAllocPriorityAdvisor.cpp
@@ -76,10 +76,14 @@ template <> Pass *llvm::callDefaultCtor<RegAllocPriorityAdvisorAnalysis>() {
Ret = new DefaultPriorityAdvisorAnalysis(/*NotAsRequested*/ false);
break;
case RegAllocPriorityAdvisorAnalysis::AdvisorMode::Development:
- // TODO: add implementation
+#if defined(LLVM_HAVE_TF_API)
+ Ret = createDevelopmentModePriorityAdvisor();
+#endif
break;
case RegAllocPriorityAdvisorAnalysis::AdvisorMode::Release:
- // TODO: add implementation
+#if defined(LLVM_HAVE_TF_AOT_REGALLOCPRIORITYMODEL)
+ Ret = createReleaseModePriorityAdvisor();
+#endif
break;
}
if (Ret)
diff --git a/llvm/test/CodeGen/MLRegalloc/Inputs/reference-prio-log-noml.txt b/llvm/test/CodeGen/MLRegalloc/Inputs/reference-prio-log-noml.txt
new file mode 100644
index 0000000000000..271480214546d
--- /dev/null
+++ b/llvm/test/CodeGen/MLRegalloc/Inputs/reference-prio-log-noml.txt
@@ -0,0 +1,361 @@
+fields {
+ key: "SyFgets"
+ value {
+ string_value: "feature_lists {
+ feature_list {
+ key: \"li_size\" value {
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } } } }
+ feature_list {
+ key: \"priority\" value {
+ feature { float_list { value: 2.68435814e+09 } }
+ feature { float_list { value: 2.68435814e+09 } }
+ feature { float_list { value: 2.68435866e+09 } }
+ feature { float_list { value: 2.68435789e+09 } }
+ feature { float_list { value: 3.75810074e+09 } }
+ feature { float_list { value: 3.7580969e+09 } }
+ feature { float_list { value: 2.14748518e+09 } }
+ feature { float_list { value: 2.14748493e+09 } }
+ feature { float_list { value: 2.68435814e+09 } }
+ feature { float_list { value: 2.14748493e+09 } }
+ feature { float_list { value: 2.14748493e+09 } }
+ feature { float_list { value: 2.68435456e+09 } }
+ feature { float_list { value: 2.68435456e+09 } }
+ feature { float_list { value: 2.68435763e+09 } }
+ feature { float_list { value: 2.68435456e+09 } }
+ feature { float_list { value: 2.68435456e+09 } }
+ feature { float_list { value: 2.14748467e+09 } }
+ feature { float_list { value: 2.68435456e+09 } }
+ feature { float_list { value: 2.68435456e+09 } }
+ feature { float_list { value: 2.68435456e+09 } }
+ feature { float_list { value: 2.68435763e+09 } }
+ feature { float_list { value: 2.68435763e+09 } }
+ feature { float_list { value: 2.1474839e+09 } }
+ feature { float_list { value: 2.1474839e+09 } }
+ feature { float_list { value: 2.68435456e+09 } }
+ feature { float_list { value: 2.1474839e+09 } }
+ feature { float_list { value: 3.22122547e+09 } }
+ feature { float_list { value: 2.68435456e+09 } }
+ feature { float_list { value: 2.14748365e+09 } }
+ feature { float_list { value: 2.14748493e+09 } }
+ feature { float_list { value: 2.14748493e+09 } }
+ feature { float_list { value: 2.68435814e+09 } }
+ feature { float_list { value: 2.68435456e+09 } }
+ feature { float_list { value: 2.68435584e+09 } }
+ feature { float_list { value: 2.68435482e+09 } }
+ feature { float_list { value: 2.68435482e+09 } }
+ feature { float_list { value: 2.68435763e+09 } }
+ feature { float_list { value: 2.68435584e+09 } }
+ feature { float_list { value: 2.14748365e+09 } }
+ feature { float_list { value: 3.75810074e+09 } }
+ feature { float_list { value: 2.68435814e+09 } }
+ feature { float_list { value: 3584 } }
+ feature { float_list { value: 2.68435814e+09 } }
+ feature { float_list { value: 3550 } }
+ feature { float_list { value: 2.68435814e+09 } }
+ feature { float_list { value: 3534 } }
+ feature { float_list { value: 2974 } }
+ feature { float_list { value: 2958 } }
+ feature { float_list { value: 3.75809946e+09 } }
+ feature { float_list { value: 2.68435866e+09 } }
+ feature { float_list { value: 3998 } }
+ feature { float_list { value: 3.75810074e+09 } }
+ feature { float_list { value: 4336 } }
+ feature { float_list { value: 2.6843584e+09 } }
+ feature { float_list { value: 3.75809664e+09 } }
+ feature { float_list { value: 2.68435482e+09 } }
+ feature { float_list { value: 2.68435482e+09 } }
+ feature { float_list { value: 2.68435814e+09 } }
+ feature { float_list { value: 2.68435482e+09 } }
+ feature { float_list { value: 2.68435456e+09 } }
+ feature { float_list { value: 2.68435456e+09 } }
+ feature { float_list { value: 2.68435814e+09 } }
+ feature { float_list { value: 2.14748493e+09 } }
+ feature { float_list { value: 2.68435456e+09 } }
+ feature { float_list { value: 2.68435814e+09 } }
+ feature { float_list { value: 2.14748493e+09 } }
+ feature { float_list { value: 2.68435456e+09 } }
+ feature { float_list { value: 2.68435456e+09 } }
+ feature { float_list { value: 2.68435456e+09 } } } }
+ feature_list {
+ key: \"reward\" value {
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 36.6412773 } } } }
+ feature_list {
+ key: \"stage\" value {
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } }
+ feature { int64_list { value: 0 } } } }
+ feature_list {
+ key: \"weight\" value {
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } }
+ feature { float_list { value: 0 } } } } } "
+ }
+}
diff --git a/llvm/test/CodeGen/MLRegalloc/dev-mode-prio-logging.ll b/llvm/test/CodeGen/MLRegalloc/dev-mode-prio-logging.ll
new file mode 100644
index 0000000000000..e8b05d5dfce19
--- /dev/null
+++ b/llvm/test/CodeGen/MLRegalloc/dev-mode-prio-logging.ll
@@ -0,0 +1,29 @@
+; REQUIRES: have_tf_api
+; REQUIRES: x86_64-linux
+;
+; Check that we log correctly, both with a learned policy, and the default policy
+;
+; RUN: llc -mtriple=x86_64-linux-unknown -regalloc=greedy -regalloc-enable-priority-advisor=development \
+; RUN: -regalloc-priority-training-log=%t1 -tfutils-text-log < %S/Inputs/input.ll
+; RUN: sed -i 's/ \+/ /g' %t1
+; RUN: sed -i 's/\\n key:/\n key:/g' %t1
+; RUN: sed -i 's/\\n feature/\n feature/g' %t1
+; RUN: sed -i 's/\\n/ /g' %t1
+; RUN: FileCheck --input-file %t1 %s --check-prefixes=CHECK,NOML
+; RUN:
diff %t1 %S/Inputs/reference-prio-log-noml.txt
+
+; RUN: rm -rf %t && mkdir %t
+; RUN: %python %S/../../../lib/Analysis/models/gen-regalloc-priority-test-model.py %t
+; RUN: llc -mtriple=x86_64-linux-unknown -regalloc=greedy -regalloc-enable-priority-advisor=development \
+; RUN: -regalloc-priority-training-log=%t2 -tfutils-text-log -regalloc-priority-model=%t < %S/Inputs/input.ll
+; RUN: sed -i 's/ \+/ /g' %t2
+; RUN: sed -i 's/\\n key:/\n key:/g' %t2
+; RUN: sed -i 's/\\n feature/\n feature/g' %t2
+; RUN: sed -i 's/\\n/ /g' %t2
+; RUN: FileCheck --input-file %t2 %s --check-prefixes=CHECK,ML
+
+; CHECK-NOT: nan
+; CHECK-LABEL: key: \"priority\"
+; NOML-NEXT: feature { float_list { value: 2.68435814e+09 } }
+; ML-NEXT: feature { float_list { value: 3551 } }
+; CHECK-LABEL: key: \"reward\"
More information about the llvm-commits
mailing list