-mtune=/-mcpu= support for x86 AMD CPU's

python_bindings/src/PyEnums.cpp

@@ -82,6 +82,22 @@ void define_enums(py::module &m) {
  .value("RISCV", Target::Arch::RISCV)
  .value("WebAssembly", Target::Arch::WebAssembly);
 
+ // Please keep sorted.
+ py::enum_<Target::Processor>(m, "TargetProcessor")
+ .value("TuneAMDFam10", Target::Processor::AMDFam10)
+ .value("TuneBdVer1", Target::Processor::BdVer1)
+ .value("TuneBdVer2", Target::Processor::BdVer2)
+ .value("TuneBdVer3", Target::Processor::BdVer3)
+ .value("TuneBdVer4", Target::Processor::BdVer4)
+ .value("TuneBtVer1", Target::Processor::BtVer1)
+ .value("TuneBtVer2", Target::Processor::BtVer2)
+ .value("TuneGeneric", Target::Processor::ProcessorGeneric)
+ .value("TuneK8", Target::Processor::K8)
+ .value("TuneK8_SSE3", Target::Processor::K8_SSE3)
+ .value("TuneZnVer1", Target::Processor::ZnVer1)
+ .value("TuneZnVer2", Target::Processor::ZnVer2)
+ .value("TuneZnVer3", Target::Processor::ZnVer3);
+
  py::enum_<Target::Feature>(m, "TargetFeature")
  .value("JIT", Target::Feature::JIT)
  .value("Debug", Target::Feature::Debug)

python_bindings/src/PyTarget.cpp

@@ -24,14 +24,17 @@ void define_target(py::module &m) {
  .def(py::init<>())
  .def(py::init<const std::string &>())
  .def(py::init<Target::OS, Target::Arch, int>())
+ .def(py::init<Target::OS, Target::Arch, int, Target::Processor>())
  .def(py::init<Target::OS, Target::Arch, int, std::vector<Target::Feature>>())
+ .def(py::init<Target::OS, Target::Arch, int, Target::Processor, std::vector<Target::Feature>>())
 
  .def("__eq__", [](const Target &value, Target *value2) { return value2 && value == *value2; })
  .def("__ne__", [](const Target &value, Target *value2) { return !value2 || value != *value2; })
 
  .def_readwrite("os", &Target::os)
  .def_readwrite("arch", &Target::arch)
  .def_readwrite("bits", &Target::bits)
+ .def_readwrite("processor", &Target::processor)
 
  .def("__repr__", &target_repr)
  .def("__str__", &Target::to_string)

src/CodeGen_X86.cpp

@@ -686,6 +686,38 @@ void CodeGen_X86::visit(const Store *op) {
 }
 
 string CodeGen_X86::mcpu() const {
+ // First, check if any explicit request for tuning exists.
+ switch (target.processor) { // Please keep sorted.
+ case Target::Processor::AMDFam10:
+ return "amdfam10";
+ case Target::Processor::BdVer1:
+ return "bdver1";
+ case Target::Processor::BdVer2:
+ return "bdver2";
+ case Target::Processor::BdVer3:
+ return "bdver3";
+ case Target::Processor::BdVer4:
+ return "bdver4";
+ case Target::Processor::BtVer1:
+ return "btver1";
+ case Target::Processor::BtVer2:
+ return "btver2";
+ case Target::Processor::K8:
+ return "k8";
+ case Target::Processor::K8_SSE3:
+ return "k8-sse3";
+ case Target::Processor::ZnVer1:
+ return "znver1";
+ case Target::Processor::ZnVer2:
+ return "znver2";
+ case Target::Processor::ZnVer3:
+ return "znver3";
+
+ case Target::Processor::ProcessorGeneric:
+ break; // Detect "best" CPU from the enabled ISA's.
+ }
+
+ // And only after that, perform an ad-hoc guess for the tune given features.
  if (target.has_feature(Target::AVX512_SapphireRapids)) {
  return "sapphirerapids";
  } else if (target.has_feature(Target::AVX512_Cannonlake)) {

src/Module.cpp

@@ -615,7 +615,7 @@ void Module::compile(const std::map<OutputFileType, std::string> &output_files)
  }
  }
  debug(1) << "Module.compile(): static_library " << output_files.at(OutputFileType::static_library) << "\n";
- Target base_target(target().os, target().arch, target().bits);
+ Target base_target(target().os, target().arch, target().bits, target().processor);
  create_static_library(temp_dir.files(), base_target, output_files.at(OutputFileType::static_library));
  }
  if (contains(output_files, OutputFileType::assembly)) {
@@ -923,7 +923,7 @@ void compile_multitarget(const std::string &fn_name,
  // and add that to the result.
  if (!base_target.has_feature(Target::NoRuntime)) {
  // Start with a bare Target, set only the features we know are common to all.
- Target runtime_target(base_target.os, base_target.arch, base_target.bits);
+ Target runtime_target(base_target.os, base_target.arch, base_target.bits, base_target.processor);
  for (int i = 0; i < Target::FeatureEnd; ++i) {
  // We never want NoRuntime set here.
  if (i == Target::NoRuntime) {

src/Target.cpp

@@ -76,6 +76,7 @@ Target calculate_host_target() {
 
  bool use_64_bits = (sizeof(size_t) == 8);
  int bits = use_64_bits ? 64 : 32;
+ Target::Processor processor = Target::Processor::ProcessorGeneric;
  std::vector<Target::Feature> initial_features;
 
 #if __riscv
@@ -189,7 +190,7 @@ Target calculate_host_target() {
 #endif
 #endif
 
- return {os, arch, bits, initial_features};
+ return {os, arch, bits, processor, initial_features};
 }
 
 bool is_using_hexagon(const Target &t) {
@@ -307,6 +308,38 @@ bool lookup_arch(const std::string &tok, Target::Arch &result) {
  return false;
 }
 
+/// Important design consideration: currently, the string key is
+/// effectively identical to the LLVM CPU string, and it would be really really
+/// good to keep it that way, so the proper tune_* can be autogenerated easily
+/// from the LLVM CPU string (currently, by replacing "-" with "_",
+/// and prepending "tune_" prefix)
+///
+/// Please keep sorted.
+const std::map<std::string, Target::Processor> processor_name_map = {
+ {"tune_amdfam10", Target::Processor::AMDFam10},
+ {"tune_bdver1", Target::Processor::BdVer1},
+ {"tune_bdver2", Target::Processor::BdVer2},
+ {"tune_bdver3", Target::Processor::BdVer3},
+ {"tune_bdver4", Target::Processor::BdVer4},
+ {"tune_btver1", Target::Processor::BtVer1},
+ {"tune_btver2", Target::Processor::BtVer2},
+ {"tune_generic", Target::Processor::ProcessorGeneric},
+ {"tune_k8", Target::Processor::K8},
+ {"tune_k8_sse3", Target::Processor::K8_SSE3},
+ {"tune_znver1", Target::Processor::ZnVer1},
+ {"tune_znver2", Target::Processor::ZnVer2},
+ {"tune_znver3", Target::Processor::ZnVer3},
+};
+
+bool lookup_processor(const std::string &tok, Target::Processor &result) {
+ auto processor_iter = processor_name_map.find(tok);
+ if (processor_iter != processor_name_map.end()) {
+ result = processor_iter->second;
+ return true;
+ }
+ return false;
+}
+
 const std::map<std::string, Target::Feature> feature_name_map = {
  {"jit", Target::JIT},
  {"debug", Target::Debug},
@@ -454,7 +487,7 @@ bool merge_string(Target &t, const std::string &target) {
  }
  tokens.push_back(rest);
 
- bool os_specified = false, arch_specified = false, bits_specified = false, features_specified = false;
+ bool os_specified = false, arch_specified = false, bits_specified = false, processor_specified = false, features_specified = false;
  bool is_host = false;
 
  for (size_t i = 0; i < tokens.size(); i++) {
@@ -484,6 +517,11 @@ bool merge_string(Target &t, const std::string &target) {
  return false;
  }
  os_specified = true;
+ } else if (lookup_processor(tok, t.processor)) {
+ if (processor_specified) {
+ return false;
+ }
+ processor_specified = true;
  } else if (lookup_feature(tok, feature)) {
  t.set_feature(feature);
  features_specified = true;
@@ -541,6 +579,12 @@ void bad_target_string(const std::string &target) {
  separator = ", ";
  }
  separator = "";
+ std::string processors;
+ for (const auto &processor_entry : processor_name_map) {
+ processors += separator + processor_entry.first;
+ separator = ", ";
+ }
+ separator = "";
  // Format the features to go one feature over 70 characters per line,
  // assume the first line starts with "Features are ".
  int line_char_start = -(int)sizeof("Features are");
@@ -555,13 +599,16 @@ void bad_target_string(const std::string &target) {
  }
  }
  user_error << "Did not understand Halide target " << target << "\n"
- << "Expected format is arch-bits-os-feature1-feature2-...\n"
+ << "Expected format is arch-bits-os-processor-feature1-feature2-...\n"
  << "Where arch is: " << architectures << ".\n"
  << "bits is either 32 or 64.\n"
  << "os is: " << oses << ".\n"
+ << "processor is: " << processors << ".\n"
  << "\n"
  << "If arch, bits, or os are omitted, they default to the host.\n"
  << "\n"
+ << "If processor is omitted, it defaults to tune_generic.\n"
+ << "\n"
  << "Features are: " << features << ".\n"
  << "\n"
  << "The target can also begin with \"host\", which sets the "
@@ -628,6 +675,14 @@ std::string Target::to_string() const {
  break;
  }
  }
+ if (processor != ProcessorGeneric) {
+ for (const auto &processor_entry : processor_name_map) {
+ if (processor_entry.second == processor) {
+ result += "-" + processor_entry.first;
+ break;
+ }
+ }
+ }
  for (const auto &feature_entry : feature_name_map) {
  if (has_feature(feature_entry.second)) {
  result += "-" + feature_entry.first;
@@ -1047,7 +1102,7 @@ bool Target::get_runtime_compatible_target(const Target &other, Target &result)
  // Union of features is computed through bitwise-or, and masked away by the features we care about
  // Intersection of features is computed through bitwise-and and masked away, too.
  // We merge the bits via bitwise or.
- Target output = Target{os, arch, bits};
+ Target output = Target{os, arch, bits, processor};
  output.features = ((features | other.features) & union_mask) | ((features | other.features) & matching_mask) | ((features & other.features) & intersection_mask);
 
  // Pick tight lower bound for CUDA capability. Use fall-through to clear redundant features

src/Target.h

@@ -50,6 +50,27 @@ struct Target {
  /** The bit-width of the target machine. Must be 0 for unknown, or 32 or 64. */
  int bits = 0;
 
+ /** The specific processor to be targeted, tuned for.
+ * Corresponds to processor_name_map in Target.cpp.
+ *
+ * New entries should be added to the end. */
+ enum Processor {
+ /// Do not tune for any specific CPU. In practice, this means that halide will decide the tune CPU based on the enabled features.
+ ProcessorGeneric = 0,
+ K8, /// Tune for AMD K8 Hammer CPU (AMD Family 0Fh, launched 2003).
+ K8_SSE3, /// Tune for later versions of AMD K8 CPU, with SSE3 support.
+ AMDFam10, /// Tune for AMD K10 "Barcelona" CPU (AMD Family 10h, launched 2007).
+ BtVer1, /// Tune for AMD Bobcat CPU (AMD Family 14h, launched 2011).
+ BdVer1, /// Tune for AMD Bulldozer CPU (AMD Family 15h, launched 2011).
+ BdVer2, /// Tune for AMD Piledriver CPU (AMD Family 15h (2nd-gen), launched 2012).
+ BdVer3, /// Tune for AMD Steamroller CPU (AMD Family 15h (3nd-gen), launched 2014).
+ BdVer4, /// Tune for AMD Excavator CPU (AMD Family 15h (4th-gen), launched 2015).
+ BtVer2, /// Tune for AMD Jaguar CPU (AMD Family 16h, launched 2013).
+ ZnVer1, /// Tune for AMD Zen CPU (AMD Family 17h, launched 2017).
+ ZnVer2, /// Tune for AMD Zen 2 CPU (AMD Family 17h, launched 2019).
+ ZnVer3, /// Tune for AMD Zen 3 CPU (AMD Family 19h, launched 2020).
+ } processor = ProcessorGeneric;
+
  /** Optional features a target can have.
  * Corresponds to feature_name_map in Target.cpp.
  * See definitions in HalideRuntime.h for full information.
@@ -136,13 +157,17 @@ struct Target {
  FeatureEnd = halide_target_feature_end
  };
  Target() = default;
- Target(OS o, Arch a, int b, const std::vector<Feature> &initial_features = std::vector<Feature>())
- : os(o), arch(a), bits(b) {
+ Target(OS o, Arch a, int b, Processor p, const std::vector<Feature> &initial_features = std::vector<Feature>())
+ : os(o), arch(a), bits(b), processor(p) {
  for (const auto &f : initial_features) {
  set_feature(f);
  }
  }
 
+ Target(OS o, Arch a, int b, const std::vector<Feature> &initial_features = std::vector<Feature>())
+ : Target(o, a, b, ProcessorGeneric, initial_features) {
+ }
+
  /** Given a string of the form used in HL_TARGET
  * (e.g. "x86-64-avx"), construct the Target it specifies. Note
  * that this always starts with the result of get_host_target(),
@@ -226,6 +251,7 @@ struct Target {
  return os == other.os &&
  arch == other.arch &&
  bits == other.bits &&
+ processor == other.processor &&
  features == other.features;
  }
 
@@ -247,7 +273,7 @@ struct Target {
  /** Convert the Target into a string form that can be reconstituted
  * by merge_string(), which will always be of the form
  *
- * arch-bits-os-feature1-feature2...featureN.
+ * arch-bits-os-processor-feature1-feature2...featureN.
  *
  * Note that is guaranteed that Target(t1.to_string()) == t1,
  * but not that Target(s).to_string() == s (since there can be