Added support for releasing GVL - resolves #81

Co-authored-by: Zai Thottakath <zaithottakath@gmail.com>
Assisted-by: aider (gpt-5.2) <aider@aider.chat>

Author: ankane

CHANGELOG.md

@@ -1,5 +1,6 @@
 ## 0.18.0 (unreleased)
 
+- Added support for releasing GVL
 - Added `stop_search` method to `CpSolverSolutionCallback`
 - Fixed error with `apply_locks` and `set_allowed_vehicles_for_index` methods
 - Dropped support for Ruby < 3.3

ext/or-tools/constraint.cpp

@@ -1,3 +1,6 @@
+#include <atomic>
+#include <mutex>
+#include <queue>
 #include <string>
 #include <vector>
 
@@ -426,29 +429,87 @@ void init_constraint(Rice::Module& m) {
       "_solve",
       [](Object self, CpModelBuilder& model, SatParameters& parameters, Object callback) {
         Model m;
+        m.Add(NewSatParameters(parameters));
 
-        if (!callback.is_nil()) {
-          // use a single worker since Ruby code cannot be run in a non-Ruby thread
-          parameters.set_num_search_workers(1);
+        std::atomic<bool> done{false};
+        std::queue<CpSolverResponse> queue;
+        std::mutex queue_lock;
+        Rice::Object ruby_thread;
+        std::optional<Rice::Exception> exception;
 
-          m.Add(NewFeasibleSolutionObserver(
-            [&](const CpSolverResponse& r) {
-              if (!ruby_native_thread_p()) {
-                throw std::runtime_error{"Non-Ruby thread"};
+        // TODO release GVL when not calling Ruby
+        auto ruby_observer = [&]() {
+          try {
+            while (true) {
+              if (done.load()) {
+                std::lock_guard<std::mutex> guard(queue_lock);
+                if (queue.empty()) {
+                  break;
+                }
               }
 
-              callback.call("response=", r);
-              callback.call("on_solution_callback");
+              while (true) {
+                CpSolverResponse r;
+                {
+                  std::lock_guard<std::mutex> guard(queue_lock);
+                  if (queue.empty()) {
+                    break;
+                  }
+                  r = queue.front();
+                  queue.pop();
+                }
+
+                callback.call("response=", r);
+                callback.call("on_solution_callback");
 
-              if (callback.attr_get("@stopped")) {
-                StopSearch(&m);
+                if (callback.attr_get("@stopped")) {
+                  StopSearch(&m);
+                  return Qnil;
+                }
               }
+
+              rb_thread_schedule();
+            }
+          } catch (const Rice::Exception& e) {
+            exception = e;
+            StopSearch(&m);
+          } catch (const std::exception& e) {
+            exception = Rice::Exception(rb_eRuntimeError, e.what());
+            StopSearch(&m);
+          }
+          return Qnil;
+        };
+
+        auto ruby_wrapper = [](void* arg) {
+          return (*static_cast<decltype(ruby_observer)*>(arg))();
+        };
+
+        if (!callback.is_nil()) {
+          ruby_thread = rb_thread_create(ruby_wrapper, &ruby_observer);
+
+          m.Add(NewFeasibleSolutionObserver(
+            [&](const CpSolverResponse& r) {
+              std::lock_guard<std::mutex> guard(queue_lock);
+              queue.push(r);
             })
           );
         }
 
-        m.Add(NewSatParameters(parameters));
-        return SolveCpModel(model.Build(), &m);
+        CpSolverResponse r;
+        Rice::detail::no_gvl([&]() {
+          r = SolveCpModel(model.Build(), &m);
+          done = true;
+        });
+
+        if (!callback.is_nil()) {
+          ruby_thread.call("value");
+        }
+
+        if (exception.has_value()) {
+          throw exception.value();
+        }
+
+        return r;
       })
     .define_method(
       "_solution_integer_value",

test/constraint_test.rb

@@ -61,6 +61,12 @@ def on_solution_callback
   end
 end
 
+class ExceptionCallback < ORTools::CpSolverSolutionCallback
+  def on_solution_callback
+    raise "Error!"
+  end
+end
+
 class ConstraintTest < Minitest::Test
   # https://developers.google.com/optimization/cp/cp_solver
   def test_cp_sat_solver
@@ -174,6 +180,12 @@ def test_cryptoarithmetic
     stop_callback = StopSearchCallback.new
     status = solver.solve(model, stop_callback)
     assert_equal 3, stop_callback.solution_count
+
+    exception_callback = ExceptionCallback.new
+    error = assert_raises(RuntimeError) do
+      solver.solve(model, exception_callback)
+    end
+    assert_equal "Error!", error.message
   end
 
   # https://developers.google.com/optimization/cp/queens