Refactor, GIL management

Author: kordejong

source/framework/python/source/algorithm/miscellaneous_operation/uniform-2.cpp

@@ -12,7 +12,21 @@ using namespace pybind11::literals;
 namespace lue::framework {
     namespace {
 
-        // Step 3: Call the algorithm
+        // Step 4: Release the GIL and call the algorithm
+        template<typename Element, Rank rank>
+        auto uniform(
+            StaticShape<rank> const& array_shape,
+            StaticShape<rank> const& partition_shape,
+            Element const& min_value,
+            Element const& max_value) -> PartitionedArray<Element, rank>
+        {
+            pybind11::gil_scoped_release release{};
+
+            return value_policies::uniform(array_shape, partition_shape, min_value, max_value);
+        }
+
+
+        // Step 3: Convert between Python and C++ types
         template<typename Element, Rank rank>
         auto uniform(
             StaticShape<rank> const& array_shape,
@@ -24,12 +38,11 @@ namespace lue::framework {
 
             if constexpr (arithmetic_element_supported<Element>)
             {
-                result = pybind11::cast(
-                    value_policies::uniform(
-                        array_shape,
-                        partition_shape,
-                        pybind11::cast<Element>(min_value),
-                        pybind11::cast<Element>(max_value)));
+                result = pybind11::cast(value_policies::uniform(
+                    array_shape,
+                    partition_shape,
+                    pybind11::cast<Element>(min_value),
+                    pybind11::cast<Element>(max_value)));
             }
 
             return result;
@@ -143,11 +156,10 @@ namespace lue::framework {
 
                 if (dynamic_array_shape.size() != dynamic_partition_shape.size())
                 {
-                    throw std::runtime_error(
-                        std::format(
-                            "Rank of array shape and partition shape must be equal ({} != {})",
-                            dynamic_array_shape.size(),
-                            dynamic_partition_shape.size()));
+                    throw std::runtime_error(std::format(
+                        "Rank of array shape and partition shape must be equal ({} != {})",
+                        dynamic_array_shape.size(),
+                        dynamic_partition_shape.size()));
                 }
             }
 

source/framework/python/source/command_line.cpp

@@ -7,24 +7,23 @@ namespace lue {
 
     CommandLine::CommandLine()
     {
-        // The goal here is (only) to set _argc/_argv for the
-        // HPX runtime to use
-
-        pybind11::gil_scoped_acquire acquire;
-
-        pybind11::object sys{pybind11::module_::import("sys")};
-        pybind11::list argv_py{sys.attr("argv")};
+        // The goal here is (only) to set _argc/_argv for the HPX runtime to use
+        {
+            pybind11::gil_scoped_acquire acquire{};
+            pybind11::object sys{pybind11::module_::import("sys")};
+            pybind11::list argv_py{sys.attr("argv")};
 
-        _argc = static_cast<int>(argv_py.size());
+            _argc = static_cast<int>(argv_py.size());
 
-        _argument_strings.resize(_argc);
-        _argument_pointers.resize(_argument_strings.size() + 1);
+            _argument_strings.resize(_argc);
+            _argument_pointers.resize(_argument_strings.size() + 1);
 
-        for (int i = 0; i < _argc; ++i)
-        {
-            pybind11::str arg_py{argv_py[i]};
-            _argument_strings[i] = arg_py;
-            _argument_pointers[i] = _argument_strings[i].data();
+            for (int i = 0; i < _argc; ++i)
+            {
+                pybind11::str arg_py{argv_py[i]};
+                _argument_strings[i] = arg_py;
+                _argument_pointers[i] = _argument_strings[i].data();
+            }
         }
 
         lue_assert(_argument_pointers.size() == static_cast<std::size_t>(_argc + 1));

source/framework/python/source/command_line.hpp

@@ -1,7 +1,4 @@
 #pragma once
-#include "lue/py/configure.hpp"
-#include <functional>
-#include <memory>
 #include <string>
 #include <vector>
 

source/framework/python/source/hpx_runtime.cpp

@@ -1,5 +1,4 @@
 #include "hpx_runtime.hpp"
-#include "ostream.hpp"
 #include <hpx/hpx_start.hpp>
 #include <pybind11/pybind11.h>
 
@@ -18,8 +17,7 @@ namespace lue {
 
         hpx::init_params params{};
         params.cfg = _configuration;
-        params.mode = hpx::runtime_mode::default_;
-        // params.mode = hpx::runtime_mode::console;
+        params.mode = hpx::runtime_mode::console;
 
         if (!hpx::start(start_function, _command_line.argc(), _command_line.argv(), params))
         {
@@ -55,7 +53,7 @@ namespace lue {
 
 
     // Main HPX thread, does nothing but wait for the application to exit
-    int HPXRuntime::hpx_main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[])
+    auto HPXRuntime::hpx_main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[]) -> int
     {
         // Store a pointer to the runtime here.
         _runtime = hpx::get_runtime_ptr();
@@ -68,14 +66,6 @@ namespace lue {
 
         _startup_condition_variable.notify_one();
 
-        // Redirect all console output to Python's stdout
-        std::unique_ptr<phylanx::bindings::scoped_ostream_redirect> stream;
-
-        {
-            pybind11::gil_scoped_acquire acquire;
-            stream = std::unique_ptr<phylanx::bindings::scoped_ostream_redirect>{};
-        }
-
         // Now, wait for destructor to be called.
         {
             std::unique_lock<hpx::spinlock> lock(_mutex);
@@ -85,11 +75,6 @@ namespace lue {
             }
         }
 
-        {
-            pybind11::gil_scoped_acquire acquire;
-            stream.reset();
-        }
-
         // Tell the runtime it's OK to exit
         return hpx::finalize();
     }

source/framework/python/source/hpx_runtime.hpp

@@ -13,11 +13,19 @@ namespace lue {
 
             HPXRuntime(std::vector<std::string> const& configuration);
 
+            HPXRuntime(HPXRuntime const& other) = delete;
+
+            HPXRuntime(HPXRuntime&& other) = delete;
+
             ~HPXRuntime();
 
+            auto operator=(HPXRuntime const& other) -> HPXRuntime& = delete;
+
+            auto operator=(HPXRuntime&& other) -> HPXRuntime& = delete;
+
         protected:
 
-            int hpx_main(int argc, char* argv[]);
+            auto hpx_main(int argc, char* argv[]) -> int;
 
         private:
 

source/framework/python/source/ostream.hpp

@@ -7,6 +7,8 @@
 #include <pybind11/numpy.h>
 #include <pybind11/stl.h>
 
+#include <hpx/algorithm.hpp>
+
 
 namespace lue::framework {
     namespace {
@@ -16,11 +18,10 @@ namespace lue::framework {
 
         void start_hpx_runtime(std::vector<std::string> const& configuration)
         {
-            // Iff the pointer to the runtime is not pointing to an instance,
-            // instantiate one. This will start the HPX runtime.
+            // Iff the pointer to the runtime is not pointing to an instance, instantiate one. This will
+            // start the HPX runtime.
             if (runtime == nullptr)
             {
-                pybind11::gil_scoped_release release;
                 runtime = new HPXRuntime{configuration};
             }
         }
@@ -34,7 +35,6 @@ namespace lue::framework {
             {
                 HPXRuntime* r = runtime;
                 runtime = nullptr;
-                pybind11::gil_scoped_release release;
                 delete r;
             }
         }
@@ -108,11 +108,12 @@ namespace lue::framework {
 
         gdal::register_gdal_drivers();
 
-        submodule.def("start_hpx_runtime", &start_hpx_runtime);
-
-        submodule.def("stop_hpx_runtime", &stop_hpx_runtime);
-
-        submodule.def("on_root_locality", &on_root_locality);
+        submodule.def(
+            "start_hpx_runtime", &start_hpx_runtime, pybind11::call_guard<pybind11::gil_scoped_release>());
+        submodule.def(
+            "stop_hpx_runtime", &stop_hpx_runtime, pybind11::call_guard<pybind11::gil_scoped_release>());
+        submodule.def(
+            "on_root_locality", &on_root_locality, pybind11::call_guard<pybind11::gil_scoped_release>());
 
         bind_hpx(submodule);