Isolate interrupt requests to single thread

src/util/Interrupt.cpp

@@ -17,7 +17,7 @@
 
 namespace {
 /* Could these be portably stored in thread-specific space ? */
-bool requested = false;
+thread_local bool requested = false;
 
 geos::util::Interrupt::Callback* callback = nullptr;
 }

tests/unit/capi/GEOSInterruptTest.cpp

@@ -9,6 +9,7 @@
 #include <cstdio>
 #include <cstdlib>
 #include <memory>
+#include <thread>
 
 namespace tut {
 //
@@ -18,6 +19,7 @@ namespace tut {
 // Common data used in test cases.
 struct test_capiinterrupt_data {
     static int numcalls;
+    static int numcalls2;
     static GEOSInterruptCallback* nextcb;
 
     static void
@@ -56,9 +58,19 @@ struct test_capiinterrupt_data {
         }
     }
 
+    static void
+    countCalls2()
+    {
+        ++numcalls2;
+        if(nextcb) {
+            (*nextcb)();
+        }
+    }
+
 };
 
 int test_capiinterrupt_data::numcalls = 0;
+int test_capiinterrupt_data::numcalls2 = 0;
 GEOSInterruptCallback* test_capiinterrupt_data::nextcb = nullptr;
 
 typedef test_group<test_capiinterrupt_data> group;
@@ -221,5 +233,43 @@ void object::test<5>
 }
 
 
+// Test callback is thread-local
+template<>
+template<>
+void object::test<6>
+()
+{
+    numcalls = 0;
+    numcalls2 = 0;
+    nextcb = nullptr;
+
+    initGEOS(notice, notice);
+
+    auto buffer = [](GEOSInterruptCallback* cb) {
+        GEOSGeometry* geom1 = GEOSGeomFromWKT("LINESTRING (0 0, 1 0)");
+
+        GEOS_interruptRegisterCallback(cb);
+
+        GEOSGeometry* geom2 = GEOSBuffer(geom1, 1, 8);
+        GEOSGeom_destroy(geom2);
+        GEOSGeom_destroy(geom1);
+
+        GEOS_interruptRegisterCallback(nullptr);
+    };
+
+    std::thread t1(buffer, countCalls);
+    std::thread t2(buffer, countCalls2);
+
+    t1.join();
+    t2.join();
+
+    ensure("numcalls > 0", numcalls > 0);
+    ensure("numcalls2 > 0", numcalls2 > 0);
+    ensure_equals(numcalls, numcalls2);
+
+    finishGEOS();
+}
+
+
 } // namespace tut
 

tests/unit/util/InterruptTest.cpp

@@ -0,0 +1,102 @@
+// tut
+#include <tut/tut.hpp>
+// geos
+#include <geos/util/Interrupt.h>
+// std
+#include <chrono>
+#include <thread>
+
+using geos::util::Interrupt;
+
+namespace tut {
+//
+// Test Group
+//
+
+// Common data used in test cases.
+struct test_interrupt_data {
+    static void workForever() {
+        try {
+            std::cerr << "Started " << std::this_thread::get_id() << "." << std::endl;
+            while (true) {
+                std::this_thread::sleep_for(std::chrono::milliseconds(10));
+                GEOS_CHECK_FOR_INTERRUPTS();
+            }
+        } catch (const std::exception&) {
+            std::cerr << "Interrupted " << std::this_thread::get_id() << "." << std::endl;
+            return;
+        }
+    }
+
+    static void interruptNow() {
+        Interrupt::request();
+    }
+
+    static std::map<std::thread::id, bool>* toInterrupt;
+
+    static void interruptIfRequested() {
+        if (toInterrupt == nullptr) {
+            return;
+        }
+
+        auto it = toInterrupt->find(std::this_thread::get_id());
+        if (it != toInterrupt->end() && it->second) {
+            it->second = false;
+            Interrupt::request();
+        }
+    }
+};
+
+std::map<std::thread::id, bool>* test_interrupt_data::toInterrupt = nullptr;
+
+typedef test_group<test_interrupt_data> group;
+typedef group::object object;
+
+group test_interrupt_group("geos::util::Interrupt");
+
+//
+// Test Cases
+//
+
+
+// Interrupt worker thread via global request from from main thead
+// No longer works, because Interrupt::request now interrupts only the thread that calls it.
+#if 0
+template<>
+template<>
+void object::test<1>
+()
+{
+    std::thread t(workForever);
+    Interrupt::request();
+
+    t.join();
+}
+#endif
+
+// Interrupt worker thread via global requset from worker thread using a callback
+template<>
+template<>
+void object::test<2>
+()
+{
+    Interrupt::registerCallback(interruptIfRequested);
+
+    std::thread t1(workForever);
+    std::thread t2(workForever);
+
+    std::map<std::thread::id, bool> shouldInterrupt;
+    shouldInterrupt[t1.get_id()] = false;
+    shouldInterrupt[t2.get_id()] = false;
+    toInterrupt = &shouldInterrupt;
+
+    shouldInterrupt[t2.get_id()] = true;
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    shouldInterrupt[t1.get_id()] = true;
+
+    t1.join();
+    t2.join();
+}
+
+} // namespace tut
+