code documentation and binding more TaskR methods

Author: noabauma

.gitlab-ci.yml

@@ -11,7 +11,7 @@ build:
   - source /home/hicr/.hicr-env.sh
   - echo "Building TaskR..."
   - mkdir build
-  - meson setup build -Dbuildtype=debug -Db_coverage=true -DbuildTests=true -DbuildExamples=true -DdistributedEngine=mpi -DexecutionStateType=boost,nosv -DprocessingUnitType=pthreads,nosv -DbuildInstrumentation=true -DcompileWarningsAsErrors=true
+  - meson setup build -Dbuildtype=debug -Db_coverage=true -DbuildTests=true -DbuildExamples=true -DdistributedEngine=mpi -DexecutionStateType=boost,nosv -DprocessingUnitType=pthreads,nosv -DbuildInstrumentation=true -DbuildPyTaskR=true -DcompileWarningsAsErrors=true
   - meson compile -C build
   - echo "Running tests..."
   - meson test -C build

include/pytaskr/pyruntime.hpp

@@ -47,12 +47,15 @@ enum backend_t
   threading
 };
 
+/**
+ * TaskR Runtime class python wrapper. It simplifies the user for constructing the TaskR Runtime
+ */
 class PyRuntime
 {
   public:
 
   /**
-    * 
+    * Constructor with num_workers being an interger value. If 0, initialize all.
     */
   PyRuntime(const backend_t &backend_type = backend_t::nosv, size_t num_workers = 0)
     : _backend_type(backend_type)
@@ -112,7 +115,7 @@ class PyRuntime
   }
 
   /**
-    * 
+    * Constructor with num_workers being a set of integers. The set specifies which process affinity to use (if available).
     */
   PyRuntime(const backend_t &backend_type, const std::set<int> &workersSet)
     : _backend_type(backend_type)
@@ -169,13 +172,16 @@ class PyRuntime
 
     if (!_computeResources.size()) { HICR_THROW_LOGIC("Error: non-existing compute resources provided\n"); }
 
+    // Store the number of initialized workers
     _num_workers = _computeResources.size();
 
+    // Initialize the runtime
     _runtime = std::make_unique<Runtime>(_executionStateComputeManager.get(), _processingUnitComputeManager.get(), _computeResources);
   }
 
   /**
-    * Destructor
+    * Destructor of PyRuntime
+    * 
     * Destroying topology and shutting down nOS-V if nosv backend have been used.
     */
   ~PyRuntime()

include/pytaskr/pytaskr.cpp

@@ -28,16 +28,23 @@ namespace py = pybind11;
 namespace taskr
 {
 
+/**
+ * Vector to keep track which cpp functions to register
+ */
 std::vector<FunctionRegistration> &get_registry()
 {
   static std::vector<FunctionRegistration> reg;
   return reg;
 }
 
+/**
+ * Function to store the cpp function with a given naming
+ */
 void register_function(const std::string &name, function_t fc) { get_registry().push_back({name, fc}); }
 
-// TODO: add all methods of all classes
-
+/**
+ * Pybind11 module for binding taskr stuff
+ */
 PYBIND11_MODULE(taskr, m)
 {
   m.doc() = "pybind11 plugin for TaskR";
@@ -66,25 +73,36 @@ PYBIND11_MODULE(taskr, m)
   // TaskR's Runtime class
   py::class_<Runtime>(m, "Runtime")
     .def("setTaskCallbackHandler", &Runtime::setTaskCallbackHandler)
+    .def("setServiceWorkerCallbackHandler", &Runtime::setServiceWorkerCallbackHandler)
+    .def("setTaskWorkerCallbackHandler", &Runtime::setTaskWorkerCallbackHandler)
     .def("initialize", &Runtime::initialize)
     .def("addTask", &Runtime::addTask, py::keep_alive<1, 2>()) // keep_alive as the task should be alive until runtime's destructor
     .def("resumeTask", &Runtime::resumeTask)
     .def("run", &Runtime::run, py::call_guard<py::gil_scoped_release>())
     .def("await_", &Runtime::await, py::call_guard<py::gil_scoped_release>()) // Release GIL is important otherwise non-finished tasks are getting blocked
-    .def("finalize", &Runtime::finalize);
+    .def("finalize", &Runtime::finalize)
+    .def("setFinishedTask", &Runtime::setFinishedTask)
+    .def("addService", &Runtime::addService);
 
   // TaskR's Function class
   py::class_<Function>(m, "Function").def(py::init<const function_t>());
 
   // TaskR's Task class
   py::class_<Task>(m, "Task")
+    .def(py::init<Function *, const workerId_t>(), py::arg("fc"), py::arg("workerAffinity") = -1)
     .def(py::init<const label_t, Function *, const workerId_t>(), py::arg("label"), py::arg("fc"), py::arg("workerAffinity") = -1)
     .def("getLabel", &Task::getLabel)
     .def("setLabel", &Task::setLabel)
     .def("getWorkerAffinity", &Task::getWorkerAffinity)
     .def("setWorkerAffinity", &Task::setWorkerAffinity)
     .def("addDependency", &Task::addDependency)
+    .def("getDependencyCount", &Task::getDependencyCount)
+    .def("incrementDependencyCount", &Task::incrementDependencyCount)
+    .def("decrementDependencyCount", &Task::decrementDependencyCount)
+    .def("addOutputDependency", &Task::addOutputDependency)
+    .def("getOutputDependencies", &Task::getOutputDependencies)
     .def("addPendingOperation", &Task::addPendingOperation)
+    .def("getPendingOperations", &Task::getPendingOperations)
     .def("suspend", &Task::suspend, py::call_guard<py::gil_scoped_release>());
 
   py::enum_<Task::callback_t>(m, "TaskCallback")
@@ -95,7 +113,7 @@ PYBIND11_MODULE(taskr, m)
     .export_values();
 
   // TaskR's Mutex class
-  py::class_<Mutex>(m, "Mutex").def(py::init<>()).def("lock", &Mutex::lock).def("unlock", &Mutex::unlock);
+  py::class_<Mutex>(m, "Mutex").def(py::init<>()).def("lock", &Mutex::lock).def("unlock", &Mutex::unlock).def("ownsLock", &Mutex::ownsLock).def("trylock", &Mutex::trylock);
 
   // TaskR's ConditionVariable class
   py::class_<ConditionVariable>(m, "ConditionVariable")

include/pytaskr/pytaskr.hpp

@@ -22,14 +22,23 @@
 namespace taskr
 {
 
+/**
+ * Struct with the cpp funcion and the given name
+ */
 struct FunctionRegistration
 {
   std::string name;
   function_t  fc;
 };
 
+/**
+   * Vector to keep track which cpp functions to register
+   */
 std::vector<FunctionRegistration> &get_registry();
 
+/**
+ * Function to store the cpp function with a given naming
+ */
 void register_function(const std::string &name, function_t fc);
 
 } // namespace taskr