Add Taskflow

.gitmodules

@@ -2,3 +2,6 @@
  path = testscpp/Catch2
  url = https://github.com/catchorg/Catch2.git
  branch = v2.x
+[submodule "extern/taskflow"]
+ path = extern/taskflow
+ url = https://github.com/taskflow/taskflow.git

dwave/preprocessing/include/dwave/presolve.hpp

@@ -15,11 +15,14 @@
 #pragma once
 
 #include <algorithm>
+#include <cstdint>
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "dimod/constrained_quadratic_model.h"
+#include "taskflow/core/taskflow.hpp"
+#include "taskflow/taskflow.hpp"
 
 namespace dwave {
 namespace presolve {
@@ -114,6 +117,23 @@ void Postsolver<bias_type, index_type, assignment_type>::substitute_variable(ind
  transforms_.back().offset = offset;
 }
 
+class PresolverTechniques {
+ public:
+ const static uint64_t SPIN_TO_BINARY = 1 << 0;
+ const static uint64_t REMOVE_OFFSETS = 1 << 1;
+ const static uint64_t FLIP_CONSTRAINTS = 1 << 2;
+ const static uint64_t REMOVE_SELF_LOOPS = 1 << 3;
+ const static uint64_t REMOVE_INVALID_MARKERS = 1 << 4;
+ const static uint64_t CHECK_FOR_NAN = 1 << 5;
+ const static uint64_t REMOVE_SINGLE_VAR_CONSTRAINTS = 1 << 6;
+ const static uint64_t REMOVE_ZERO_BIASES = 1 << 7;
+ const static uint64_t TIGHTEN_BOUNDS = 1 << 8;
+ const static uint64_t REMOVE_FIXED_VARS = 1 << 9;
+
+ const static uint64_t ALL = -1;
+ const static uint64_t NONE = 0;
+};
+
 template <class Bias, class Index, class Assignment>
 class Presolver {
  public:
@@ -139,7 +159,10 @@ class Presolver {
  model_type detach_model();
 
  /// Load the default presolve techniques.
- void load_default_presolvers();
+ void load_default_presolvers(uint32_t max_rounds = 100) {
+ load_presolvers(PresolverTechniques::ALL, max_rounds);
+ }
+ void load_presolvers(uint64_t presolvers = PresolverTechniques::ALL, uint32_t max_rounds = 100);
 
  /// Return a const reference to the held constrained quadratic model.
  const model_type& model() const;
@@ -148,11 +171,28 @@ class Presolver {
  const Postsolver<bias_type, index_type, assignment_type>& postsolver() const;
 
  private:
+ struct TfHelper {
+ tf::Executor executor;
+ tf::Taskflow taskflow_onetime;
+ tf::Taskflow taskflow_trivial;
+ tf::Taskflow taskflow_cleanup;
+ uint32_t loop_counter;
+ bool loop_changed;
+ bool model_feasible = true;
+
+ bool operator=(const struct TfHelper& that) { return true; }
+ };
+
+ struct TfHelper tf_helper_;
+
+ void load_taskflow_onetime();
+ void load_taskflow_trivial(int max_rounds = 100);
+ void load_taskflow_cleanup();
+
  model_type model_;
  Postsolver<bias_type, index_type, assignment_type> postsolver_;
 
- // todo: replace this with a vector of pointers or similar
- bool default_techniques_;
+ uint64_t presolvers_ = PresolverTechniques::NONE;
 
  bool detached_;
 
@@ -270,6 +310,10 @@ class Presolver {
  return false;
  }
  bool technique_remove_single_variable_constraints() {
+ if (!tf_helper_.model_feasible) {
+ return false;
+ }
+
  bool ret = false;
  size_type c = 0;
  while (c < model_.num_constraints()) {
@@ -281,20 +325,17 @@ class Presolver {
  switch (constraint.sense()) {
  case dimod::Sense::EQ:
  if (constraint.offset() != constraint.rhs()) {
- // need this exact message for Python
- throw std::logic_error("infeasible");
+ tf_helper_.model_feasible = false;
  }
  break;
  case dimod::Sense::LE:
  if (constraint.offset() > constraint.rhs()) {
- // need this exact message for Python
- throw std::logic_error("infeasible");
+ tf_helper_.model_feasible = false;
  }
  break;
  case dimod::Sense::GE:
  if (constraint.offset() < constraint.rhs()) {
- // need this exact message for Python
- throw std::logic_error("infeasible");
+ tf_helper_.model_feasible = false;
  }
  break;
  }
@@ -340,16 +381,22 @@ class Presolver {
  return ret;
  }
  bool technique_remove_zero_biases() {
- bool ret = false;
+ if (!tf_helper_.model_feasible) {
+ return false;
+ }
 
+ bool ret = false;
  ret |= remove_zero_biases(model_.objective);
  for (size_t c = 0; c < model_.num_constraints(); ++c) {
  ret |= remove_zero_biases(model_.constraint_ref(c));
  }
-
  return ret;
  }
  bool technique_tighten_bounds() {
+ if (!tf_helper_.model_feasible) {
+ return false;
+ }
+
  bool ret = false;
  bias_type lb;
  bias_type ub;
@@ -376,7 +423,11 @@ class Presolver {
  return ret;
  }
  bool technique_remove_fixed_variables() {
- bool ret = false; 
+ if (!tf_helper_.model_feasible) {
+ return false;
+ }
+
+ bool ret = false;
  size_type v = 0;
  while (v < model_.num_variables()) {
  if (model_.lower_bound(v) == model_.upper_bound(v)) {
@@ -418,54 +469,25 @@ class Presolver {
 
 template <class bias_type, class index_type, class assignment_type>
 Presolver<bias_type, index_type, assignment_type>::Presolver()
- : model_(), postsolver_(), default_techniques_(false), detached_(false) {}
+ : model_(), postsolver_(), detached_(false) {}
 
 template <class bias_type, class index_type, class assignment_type>
 Presolver<bias_type, index_type, assignment_type>::Presolver(model_type model)
- : model_(std::move(model)), postsolver_(), default_techniques_(), detached_(false) {}
+ : model_(std::move(model)), postsolver_(), detached_(false) {}
 
 template <class bias_type, class index_type, class assignment_type>
 void Presolver<bias_type, index_type, assignment_type>::apply() {
  if (detached_) throw std::logic_error("model has been detached, presolver is no longer valid");
-
- // If no techniques have been loaded, return early.
- if (!default_techniques_) return;
-
- // One time techniques ----------------------------------------------------
-
- // *-- spin-to-binary
- technique_spin_to_binary();
- // *-- remove offsets
- technique_remove_offsets();
- // *-- flip >= constraints
- technique_flip_constraints();
- // *-- remove self-loops
- technique_remove_self_loops();
-
- // Trivial techniques -----------------------------------------------------
-
- bool changes = true;
- const index_type max_num_rounds = 100; // todo: make configurable
- for (index_type num_rounds = 0; num_rounds < max_num_rounds; ++num_rounds) {
- if (!changes) break;
- changes = false;
-
- // *-- clear out 0 variables/interactions in the constraints and objective
- changes |= technique_remove_zero_biases();
- // *-- todo: check for NAN
- changes |= technique_check_for_nan();
- // *-- remove single variable constraints
- changes |= technique_remove_single_variable_constraints();
- // *-- tighten bounds based on vartype
- changes |= technique_tighten_bounds();
- // *-- remove variables that are fixed by bounds
- changes |= technique_remove_fixed_variables();
- }
-
- // Cleanup
-
- // *-- remove any invalid discrete markers
- technique_remove_invalid_markers();
+ if (presolvers_ == PresolverTechniques::NONE) return;
+
+ tf_helper_.executor.run(tf_helper_.taskflow_onetime).wait();
+ tf_helper_.executor.run(tf_helper_.taskflow_trivial).wait();
+ if (tf_helper_.model_feasible) {
+ tf_helper_.executor.run(tf_helper_.taskflow_cleanup).wait();
+ } else {
+ // need this exact message for Python
+ throw std::logic_error("infeasible");
+ }
 }
 
 template <class bias_type, class index_type, class assignment_type>
@@ -482,8 +504,117 @@ Presolver<bias_type, index_type, assignment_type>::detach_model() {
 }
 
 template <class bias_type, class index_type, class assignment_type>
-void Presolver<bias_type, index_type, assignment_type>::load_default_presolvers() {
- default_techniques_ = true;
+void Presolver<bias_type, index_type, assignment_type>::load_presolvers(uint64_t presolvers,
+ uint32_t max_rounds) {
+ presolvers_ = presolvers;
+
+ load_taskflow_onetime();
+ load_taskflow_trivial(max_rounds);
+ load_taskflow_cleanup();
+}
+
+template <class bias_type, class index_type, class assignment_type>
+void Presolver<bias_type, index_type, assignment_type>::load_taskflow_onetime() {
+ std::vector<tf::Task> tasks;
+
+ if (presolvers_ | PresolverTechniques::SPIN_TO_BINARY) {
+ auto task = tf_helper_.taskflow_onetime.emplace([&]() { technique_spin_to_binary(); });
+ task.name("spin_to_binary");
+ tasks.emplace_back(task);
+ }
+ if (presolvers_ | PresolverTechniques::REMOVE_OFFSETS) {
+ auto task = tf_helper_.taskflow_onetime.emplace([&]() { technique_remove_offsets(); });
+ task.name("remove_offsets");
+ tasks.emplace_back(task);
+ }
+ if (presolvers_ | PresolverTechniques::FLIP_CONSTRAINTS) {
+ auto task = tf_helper_.taskflow_onetime.emplace([&]() { technique_flip_constraints(); });
+ task.name("flip_constraints");
+ tasks.emplace_back(task);
+ }
+ if (presolvers_ | PresolverTechniques::REMOVE_SELF_LOOPS) {
+ auto task = tf_helper_.taskflow_onetime.emplace([&]() { technique_remove_self_loops(); });
+ task.name("remove_self_loops");
+ tasks.emplace_back(task);
+ }
+
+ for (auto i = 0; i < tasks.size() - 1; i++) {
+ tasks[i].precede(tasks[i + 1]);
+ }
+}
+
+template <class bias_type, class index_type, class assignment_type>
+void Presolver<bias_type, index_type, assignment_type>::load_taskflow_trivial(int max_rounds) {
+ auto alpha = tf_helper_.taskflow_trivial.emplace([&]() {
+ tf_helper_.loop_changed = false;
+ tf_helper_.loop_counter = 0;
+ });
+ alpha.name("initialize");
+
+ auto omega = tf_helper_.taskflow_trivial.emplace([&]() {
+ if (tf_helper_.model_feasible && tf_helper_.loop_changed &&
+ ++tf_helper_.loop_counter < max_rounds) {
+ tf_helper_.loop_changed = false;
+ return 0; // This will loop back to the first task in tasks, below
+ }
+ return 1; // This will exit the loop
+ });
+ omega.name("conditional");
+
+ std::vector<tf::Task> tasks;
+ if (presolvers_ | PresolverTechniques::REMOVE_ZERO_BIASES) {
+ auto task = tf_helper_.taskflow_trivial.emplace(
+ [&]() { tf_helper_.loop_changed |= technique_remove_zero_biases(); });
+ task.name("remove_zero_biases");
+ tasks.emplace_back(task);
+ }
+ if (presolvers_ | PresolverTechniques::CHECK_FOR_NAN) {
+ auto task = tf_helper_.taskflow_trivial.emplace(
+ [&]() { tf_helper_.loop_changed |= technique_check_for_nan(); });
+ task.name("check_for_nan");
+ tasks.emplace_back(task);
+ }
+ if (presolvers_ | PresolverTechniques::REMOVE_SINGLE_VAR_CONSTRAINTS) {
+ auto task = tf_helper_.taskflow_trivial.emplace([&]() {
+ tf_helper_.loop_changed |= technique_remove_single_variable_constraints();
+ });
+ task.name("remove_single_variable_constraints");
+ tasks.emplace_back(task);
+ }
+ if (presolvers_ | PresolverTechniques::TIGHTEN_BOUNDS) {
+ auto task = tf_helper_.taskflow_trivial.emplace(
+ [&]() { tf_helper_.loop_changed |= technique_tighten_bounds(); });
+ task.name("tighten_bounds");
+ tasks.emplace_back(task);
+ }
+ if (presolvers_ | PresolverTechniques::REMOVE_FIXED_VARS) {
+ auto task = tf_helper_.taskflow_trivial.emplace(
+ [&]() { tf_helper_.loop_changed |= technique_remove_fixed_variables(); });
+ task.name("remove_fixed_variables");
+ tasks.emplace_back(task);
+ }
+
+ if (tasks.size() > 0) {
+ alpha.precede(tasks[0]);
+
+ for (auto i = 0; i < tasks.size() - 1; i++) {
+ tasks[i].precede(tasks[i + 1]);
+ }
+
+ tasks[tasks.size() - 1].precede(omega);
+ omega.precede(tasks[0]);
+ } else {
+ alpha.precede(omega);
+ }
+}
+
+template <class bias_type, class index_type, class assignment_type>
+void Presolver<bias_type, index_type, assignment_type>::load_taskflow_cleanup() {
+ if (presolvers_ | PresolverTechniques::REMOVE_INVALID_MARKERS) {
+ auto task =
+ tf_helper_.taskflow_cleanup.emplace([&]() { technique_remove_invalid_markers(); });
+ task.name("remove_invalid_markers");
+ }
 }
 
 template <class bias_type, class index_type, class assignment_type>

setup.py

@@ -26,6 +26,7 @@
  'msvc': ['/std:c++17', '/EHsc'],
  'unix': [
  '-std=c++17', 
+ '-pthread'
  ],
 }
 
@@ -62,6 +63,7 @@ def build_extensions(self):
  include_dirs=[
  numpy.get_include(),
  dimod.get_include(),
+ 'extern/taskflow'
  ],
  install_requires=[
  'numpy>=1.20.0,<2.0.0', # keep synced with circle-ci, pyproject.toml