WIP: C++ and python api

.github/workflows/codecov.yml

@@ -44,6 +44,7 @@ jobs:
                  -DENABLE_EXAMPLES=ON \
                  -DENABLE_BEDROCK=ON \
                  -DENABLE_MPI=ON \
+                 -DENABLE_PYTHON=ON \
                  -DCMAKE_BUILD_TYPE=Debug
         make
         make test

.github/workflows/test.yml

@@ -52,6 +52,7 @@ jobs:
                  -DENABLE_EXAMPLES=ON \
                  -DENABLE_BEDROCK=ON \
                  -DENABLE_MPI=ON \
+                 -DENABLE_PYTHON=ON \
                  -DCMAKE_BUILD_TYPE=RelWithDebInfo
         make
         make test

CMakeLists.txt

@@ -2,6 +2,8 @@
 # See COPYRIGHT in top-level directory.
 cmake_minimum_required (VERSION 3.8)
 project (flock C CXX)
+set (CMAKE_CXX_STANDARD 17)
+set (CMAKE_CXX_STANDARD_REQUIRED ON)
 enable_testing ()
 
 add_definitions (-Wextra -Wall -Wpedantic)
@@ -13,6 +15,7 @@ option (ENABLE_EXAMPLES "Build examples" OFF)
 option (ENABLE_BEDROCK  "Build bedrock module" OFF)
 option (ENABLE_COVERAGE "Build with coverage" OFF)
 option (ENABLE_MPI      "Build with MPI support" OFF)
+option (ENABLE_PYTHON   "Build with Python support" OFF)
 
 # library version set here (e.g. for shared libs).
 set (FLOCK_VERSION_MAJOR 0)
@@ -62,11 +65,21 @@ endif ()
 pkg_check_modules (margo REQUIRED IMPORTED_TARGET margo)
 # search for json-c
 pkg_check_modules (json-c REQUIRED IMPORTED_TARGET json-c)
+# search for thallium
+find_package (thallium REQUIRED)
 
 if (ENABLE_MPI)
     find_package (MPI REQUIRED)
 endif ()
 
+# search for Python
+if (ENABLE_PYTHON)
+    set (Python3_FIND_STRATEGY LOCATION)
+    find_package (Python3 COMPONENTS Interpreter Development REQUIRED)
+    find_package (pybind11 REQUIRED)
+    add_subdirectory (python)
+endif ()
+
 add_subdirectory (src)
 if (${ENABLE_TESTS})
     enable_testing ()

build.sh

@@ -1,4 +1,4 @@
 #!/bin/bash
 SCRIPT_DIR=$(dirname "$0")
-cmake .. -DENABLE_TESTS=ON -DENABLE_BEDROCK=ON -DENABLE_EXAMPLES=ON -DENABLE_MPI=ON -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
+cmake .. -DENABLE_TESTS=ON -DENABLE_BEDROCK=ON -DENABLE_EXAMPLES=ON -DENABLE_MPI=ON -DENABLE_PYTHON=ON -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
 make

include/flock/cxx/client.hpp

@@ -0,0 +1,91 @@
+/*
+ * (C) 2024 The University of Chicago
+ *
+ * See COPYRIGHT in top-level directory.
+ */
+#ifndef __FLOCK_CLIENT_HPP
+#define __FLOCK_CLIENT_HPP
+
+#include <thallium.hpp>
+#include <flock/flock-client.h>
+#include <flock/flock-group.h>
+#include <flock/cxx/exception.hpp>
+#include <flock/cxx/group.hpp>
+
+namespace flock {
+
+class Client {
+
+    public:
+
+    Client() = default;
+
+    Client(margo_instance_id mid, ABT_pool pool = ABT_POOL_NULL)
+    : m_engine{mid} {
+        auto err = flock_client_init(mid, pool, &m_client);
+        FLOCK_CONVERT_AND_THROW(err);
+    }
+
+    Client(const thallium::engine& engine, thallium::pool pool = thallium::pool())
+    : m_engine{engine} {
+        auto err = flock_client_init(engine.get_margo_instance(), pool.native_handle(), &m_client);
+        FLOCK_CONVERT_AND_THROW(err);
+    }
+
+    ~Client() {
+        if(m_client != FLOCK_CLIENT_NULL) {
+            flock_client_finalize(m_client);
+        }
+    }
+
+    Client(Client&& other)
+    : m_client(other.m_client) {
+        other.m_client = FLOCK_CLIENT_NULL;
+    }
+
+    Client(const Client&) = delete;
+
+    Client& operator=(const Client&) = delete;
+
+    Client& operator=(Client&& other) {
+        if(this == &other) return *this;
+        if(m_client != FLOCK_CLIENT_NULL) {
+            flock_client_finalize(m_client);
+        }
+        m_client = other.m_client;
+        other.m_client = FLOCK_CLIENT_NULL;
+        return *this;
+    }
+
+    GroupHandle makeGroupHandle(
+        hg_addr_t addr,
+        uint16_t provider_id,
+        uint32_t mode = 0) const {
+        flock_group_handle_t gh;
+        auto err = flock_group_handle_create(
+            m_client, addr, provider_id, mode, &gh);
+        FLOCK_CONVERT_AND_THROW(err);
+        return GroupHandle(gh, false);
+    }
+
+    auto handle() const {
+        return m_client;
+    }
+
+    operator flock_client_t() const {
+        return m_client;
+    }
+
+    auto engine() const {
+        return m_engine;
+    }
+
+    private:
+
+    thallium::engine m_engine;
+    flock_client_t m_client = FLOCK_CLIENT_NULL;
+};
+
+}
+
+#endif

include/flock/cxx/exception.hpp

@@ -0,0 +1,46 @@
+/*
+ * (C) 2024 The University of Chicago
+ *
+ * See COPYRIGHT in top-level directory.
+ */
+#ifndef __FLOCK_EXCEPTION_HPP
+#define __FLOCK_EXCEPTION_HPP
+
+#include <flock/flock-common.h>
+#include <exception>
+
+namespace flock {
+
+class Exception : public std::exception {
+
+    public:
+
+    Exception(flock_return_t code)
+    : m_code(code) {}
+
+    const char* what() const noexcept override {
+        #define X(__err__, __msg__) case __err__: return __msg__;
+        switch(m_code) {
+            FLOCK_RETURN_VALUES
+        }
+        #undef X
+        return "Unknown error";
+    }
+
+    auto code() const {
+        return m_code;
+    }
+
+    private:
+
+    flock_return_t m_code;
+};
+
+#define FLOCK_CONVERT_AND_THROW(__err__) do { \
+    if((__err__) != FLOCK_SUCCESS) {          \
+        throw ::flock::Exception((__err__));  \
+    }                                       \
+} while(0)
+
+}
+#endif