[dev] replaced simple-embedding example with fibonacci

Author: d-leroy

src/api/MoniLogger.cc

@@ -245,6 +245,11 @@ namespace MoniLogger
         }
     }
 
+    MoniLoggerExecutionContext create_context(std::string name)
+    {
+        return MoniLoggerExecutionContext(name);
+    }
+
     void initialize_monilogger(std::vector<std::string> python_path,
         std::vector<std::string> python_scripts,
         std::string interface_module,

src/api/monilogger/include/MoniLogger.h

@@ -26,7 +26,7 @@ namespace MoniLogger
         virtual ~MoniLoggerExecutionContext() = default;
     };
 
-    MoniLoggerExecutionContext create_context(std::string name) { return MoniLoggerExecutionContext(name); }
+    MoniLoggerExecutionContext create_context(std::string name);
 
     void register_composite_event(std::string event_name, std::list<std::string> triggering_events);
 

src/bindings/cpp/examples/simple-embedding/README.md renamed to src/bindings/cpp/examples/fibonacci/README.md

@@ -1,10 +1,10 @@
-# Simple Embedding Example
+# Fibonacci Example
 
 This example illustrates how to integrate monilogger in your C++ application.
 
 In this directory:
  - Create and activate a Python venv.
  - Install pybind11: `pip install pybind11`
  - Install monilogger: `pip install ../..`
- - Run the script: `./build-and-run.sh`
-
+ - Run the build script: `./build.sh`
+ - Run the executable, _e.g._ `./build/fibonacci ./src example_moniloggers 10`

src/bindings/cpp/examples/simple-embedding/build-and-run.sh renamed to src/bindings/cpp/examples/fibonacci/build.sh

@@ -3,5 +3,3 @@
 mkdir build
 cmake -Bbuild -Ssrc
 cmake --build build
-./build/simpleembedding
-

src/bindings/cpp/examples/simple-embedding/src/CMakeLists.txt renamed to src/bindings/cpp/examples/fibonacci/src/CMakeLists.txt

@@ -6,7 +6,7 @@ set(CMAKE_CXX_COMPILER /usr/bin/g++)
 set(CMAKE_CXX_STANDARD 17)
 
 # PROJECT
-project(simpleembedding CXX)
+project(fibonacci CXX)
 
 set(CMAKE_VERBOSE_MAKEFILE FALSE)
 set(PYBIND11_PYTHON_VERSION 3.8)
@@ -16,9 +16,9 @@ set(pybind11_DIR "${Python_SITELIB}/pybind11/share/cmake/pybind11")
 find_package(pybind11 REQUIRED)
 include_directories(${pybind11_INCLUDE_DIRS} ${Python_SITELIB}/monilogger/include)
 
-# EXECUTABLE simpleembedding
-add_executable(simpleembedding SimpleEmbedding.cc)
-target_include_directories(simpleembedding PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
+# EXECUTABLE fibonacci
+add_executable(fibonacci fibonacci_main.cc fibonacci_embedding.cc fibonacci.cc)
+target_include_directories(fibonacci PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
 add_library(moniloggerlib SHARED IMPORTED)
 set_property(TARGET moniloggerlib PROPERTY IMPORTED_LOCATION ${Python_SITELIB}/monilogger/libmonilogger.so)
-target_link_libraries(simpleembedding PUBLIC pybind11::embed moniloggerlib)
+target_link_libraries(fibonacci PUBLIC pybind11::embed moniloggerlib)

src/bindings/cpp/examples/fibonacci/src/example_moniloggers.py

@@ -0,0 +1,9 @@
+from monilogger import *
+
+numbers = []
+
+@register("NewIteration")
+def log(ctx):
+    global numbers
+    numbers.append(ctx.current_number)
+    print(numbers)

src/bindings/cpp/examples/fibonacci/src/fibonacci.cc

@@ -0,0 +1,27 @@
+#include "fibonacci.h"
+#include "fibonacci_embedding.h"
+
+int fibonacci(int n)
+{
+    std::shared_ptr<FibonacciExecutionContext> ctx(new FibonacciExecutionContext("FibonacciExecutionContext"));
+
+    int u = 0;
+    int v = 1;
+    int i = 1;
+    int t = 0;
+    
+    ctx->previous_number = &u;
+    ctx->current_number = &v;
+    ctx->iteration = &i;
+
+    MoniLogger::trigger(0, ctx);
+
+    for(i = 2; i <= n; i++)
+    {
+        t = u + v;
+        u = v;
+        v = t;
+        MoniLogger::trigger(0, ctx);
+    }
+    return v;
+}

src/bindings/cpp/examples/fibonacci/src/fibonacci.h

@@ -0,0 +1,6 @@
+#ifndef __FIBONACCI_H_
+#define __FIBONACCI_H_
+
+int fibonacci(int n);
+
+#endif

src/bindings/cpp/examples/fibonacci/src/fibonacci_embedding.cc

@@ -0,0 +1,47 @@
+#include "fibonacci_embedding.h"
+
+PYBIND11_EMBEDDED_MODULE(fibonacci_interface, m) { }
+
+void initialize_embedding(std::vector<std::string> python_path, std::vector<std::string> python_scripts)
+{
+    // Name of the interface module (here, an embedded module declared above) exposing the execution context of the application.
+    std::string interface_module = "fibonacci_interface";
+
+    // Initialization function for the interface module.
+    std::function<void (pybind11::module_, pybind11::object)> interface_module_initializer =
+            [](pybind11::module_ interface_module, pybind11::object context_class) {
+        pybind11::class_<FibonacciExecutionContext, std::shared_ptr<FibonacciExecutionContext>>(interface_module, "FibonacciExecutionContext", context_class)
+            // Defining the properties exposed by the FibonacciExecutionContext.
+            .def_property_readonly("current_number", &FibonacciExecutionContext::get_current_number)
+            .def_property_readonly("previous_number", &FibonacciExecutionContext::get_previous_number)
+            .def_property_readonly("iteration", &FibonacciExecutionContext::get_iteration)
+            // Defining legible __str__ and __repr__ functions for FibonacciExecutionContext.
+            .def("__str__", [](FibonacciExecutionContext &self)
+                {
+                    std::ostringstream oss;
+                    oss << "[" << self.name << "]\n"
+                        << "  previous number: " << self.previous_number << "\n"
+                        << "  current number: " << self.current_number << "\n"
+                        << "  iteration: " << self.iteration << "\n" ;
+                    return oss.str();
+                })
+            .def("__repr__", [](FibonacciExecutionContext &self)
+                {
+                    std::ostringstream oss;
+                    oss << "[" << self.name << "]\n"
+                        << "  previous number: " << self.previous_number << "\n"
+                        << "  current number: " << self.current_number << "\n"
+                        << "  iteration: " << self.iteration << "\n" ;
+                    return oss.str();
+                });
+    };
+
+    // Define base execution events emitted by the application, to which moniloggers can register.
+    MoniLogger::register_base_events({
+        {"NewIteration", 0}
+    });
+
+    // Bootstrapping monilogger, consisting mainly of starting the Python interpreter, initializing
+    // the monilogger module, and evaluating the provided scripts.
+    MoniLogger::initialize_monilogger(python_path, python_scripts, interface_module, interface_module_initializer);
+}

src/bindings/cpp/examples/fibonacci/src/fibonacci_embedding.h

@@ -0,0 +1,21 @@
+#ifndef __FIBONACCI_EMBEDDING_H_
+#define __FIBONACCI_EMBEDDING_H_
+
+#include <MoniLogger.h>
+
+struct FibonacciExecutionContext : MoniLogger::MoniLoggerExecutionContext
+{
+	const pybind11::object get_previous_number() const { if (previous_number != nullptr) return pybind11::cast(*previous_number); else return pybind11::cast<pybind11::none>(Py_None); }
+	const pybind11::object get_current_number() const { if (current_number != nullptr) return pybind11::cast(*current_number); else return pybind11::cast<pybind11::none>(Py_None); }
+	const pybind11::object get_iteration() const { if (iteration != nullptr) return pybind11::cast(*iteration); else return pybind11::cast<pybind11::none>(Py_None); }
+	
+    int *previous_number = nullptr;
+    int *current_number = nullptr;
+    int *iteration = nullptr;
+	
+	using MoniLogger::MoniLoggerExecutionContext::MoniLoggerExecutionContext;
+};
+
+void initialize_embedding(std::vector<std::string> python_path, std::vector<std::string> python_scripts);
+
+#endif