Skip to content

Commit 5b51c97

Browse files
d-leroyd-leroy
committed
[dev] Improved registration of base events
1 parent 0519fc0 commit 5b51c97

File tree

9 files changed

+96
-116
lines changed

9 files changed

+96
-116
lines changed

‎src/api/MoniLogger.cc‎

Lines changed: 32 additions & 87 deletions
Original file line numberDiff line numberDiff line change
@@ -10,20 +10,20 @@ namespace MoniLogger
1010
std::map<std::string, std::list<py::function>> event_to_moniloggers;
1111
std::map<std::string, std::list<py::function>> pending_moniloggers;
1212
std::map<std::string, size_t> base_events;
13-
std::map<std::string, std::list<std::string>> composite_events;
13+
std::map<std::string, std::list<std::string>> complex_events;
1414
std::shared_ptr<py::scoped_interpreter> guard;
1515

1616
bool is_event_registered(std::string event_name)
1717
{
1818
auto base_event = base_events.find(event_name);
19-
auto composite_event = composite_events.find(event_name);
20-
return composite_event != composite_events.end() || base_event != base_events.end();
19+
auto complex_event = complex_events.find(event_name);
20+
return complex_event != complex_events.end() || base_event != base_events.end();
2121
}
2222

2323
std::vector<size_t> get_event_ids(std::string event_name)
2424
{
25-
auto triggering_events = composite_events.find(event_name);
26-
if (triggering_events != composite_events.end())
25+
auto triggering_events = complex_events.find(event_name);
26+
if (triggering_events != complex_events.end())
2727
{
2828
std::vector<size_t> result;
2929
for (auto triggering_event_name : triggering_events->second)
@@ -48,54 +48,7 @@ namespace MoniLogger
4848
}
4949
}
5050

51-
// /**
52-
// * @brief Registers the event if it was not registered already.
53-
// * @throws std::invalid_argument If the event is registered as a composite event.
54-
// *
55-
// * @param event_name name of the base event to register.
56-
// * @return size_t id already associated to the event, whether the event was
57-
// * already registered or not.
58-
// */
59-
// size_t register_base_event(std::string event_name)
60-
// {
61-
// if (composite_events.find(event_name) == composite_events.end())
62-
// {
63-
// auto id = base_events.find(event_name);
64-
// if (id == base_events.end())
65-
// {
66-
// size_t event_id;
67-
// // If the event is not yet registered
68-
// if (available_event_ids.empty())
69-
// {
70-
// // If no event id is available, compute a fresh one
71-
// event_id = = base_events.size()
72-
// base_events[event_name] = event_id;
73-
// // Add the corresponding list of moniloggers
74-
// registered_moniloggers.emplace_back(std::list<py::function>());
75-
76-
// } else {
77-
// // Otherwise, use the oldest available id
78-
// event_id = available_event_ids.pop_front();
79-
// base_events[event_name] = event_id;
80-
// // Clear the corresponding list of moniloggers (just in case...)
81-
// registered_moniloggers[id].clear();
82-
// }
83-
// return id;
84-
// }
85-
// } else {
86-
// throw std::invalid_argument(event_name + "is already registered as a composite event.");
87-
// }
88-
// }
89-
90-
/**
91-
* @brief Registers the event as a composite event triggered by the provided list of events.
92-
* @throws std::invalid_argument If the event to register already exists, or if any of the
93-
* listed triggering events does not exist.
94-
*
95-
* @param event_name name of the composite event to register.
96-
* @param triggering_events events (base or composite) triggering the composite event to register.
97-
*/
98-
void register_composite_event(std::string event_name, std::list<std::string> triggering_events)
51+
void register_complex_event(std::string event_name, std::list<std::string> triggering_events)
9952
{
10053
if (is_event_registered(event_name))
10154
{
@@ -114,7 +67,7 @@ namespace MoniLogger
11467
throw std::invalid_argument("No event named " + triggering_event + " was found.");
11568
}
11669
}
117-
composite_events[event_name] = std::list<std::string>(triggering_events);
70+
complex_events[event_name] = std::list<std::string>(triggering_events);
11871

11972
for (auto monilogger : pending_moniloggers[event_name])
12073
{
@@ -124,38 +77,36 @@ namespace MoniLogger
12477
}
12578
}
12679

127-
void register_composite_events(std::map<std::string, std::list<std::string>> composite_events)
80+
void register_complex_events(std::map<std::string, std::list<std::string>> complex_events)
12881
{
129-
for (auto execution_event : composite_events)
82+
for (auto execution_event : complex_events)
13083
{
131-
register_composite_event(execution_event.first, execution_event.second);
84+
register_complex_event(execution_event.first, execution_event.second);
13285
}
13386
}
13487

135-
void register_base_events(std::map<std::string, size_t> events)
88+
size_t register_base_event(std::string event_name)
13689
{
137-
size_t size(0);
138-
for (auto it = events.begin(); it != events.end(); ++it)
139-
{
140-
size = std::max(size, it->second);
141-
}
142-
size++;
143-
144-
registered_moniloggers.reserve(size);
145-
for (size_t i = 0; i < size; i++)
90+
const auto i = base_events.find(event_name);
91+
if (i == base_events.end())
14692
{
147-
registered_moniloggers.emplace_back(std::list<py::function>());
148-
}
149-
150-
base_events = std::map<std::string, size_t>(events);
151-
152-
for (auto const& [event_name, val] : base_events)
153-
{
154-
for (auto monilogger : pending_moniloggers[event_name])
93+
const auto j = complex_events.find(event_name);
94+
if (j != complex_events.end())
15595
{
156-
register_monilogger(event_name, monilogger);
96+
throw std::invalid_argument("Event " + event_name + " is already registered as a complex event.");
97+
} else {
98+
const size_t result = base_events.size();
99+
base_events[event_name] = result;
100+
registered_moniloggers.emplace_back();
101+
for (auto monilogger : pending_moniloggers[event_name])
102+
{
103+
registered_moniloggers[result].push_back(std::move(monilogger));
104+
}
105+
pending_moniloggers.erase(event_name);
106+
return result;
157107
}
158-
pending_moniloggers.erase(event_name);
108+
} else {
109+
return i->second;
159110
}
160111
}
161112

@@ -169,13 +120,6 @@ namespace MoniLogger
169120
return result;
170121
}
171122

172-
void clear_events()
173-
{
174-
base_events.clear();
175-
composite_events.clear();
176-
registered_moniloggers.clear();
177-
}
178-
179123
void register_monilogger(std::string event_name, py::function monilogger)
180124
{
181125
// Retrieve each base event triggering this event.
@@ -184,18 +128,19 @@ namespace MoniLogger
184128
{
185129
// If no base event exists yet, the event name has not been declared yet,
186130
// add the monilogger to the list of pending moniloggers for that event.
187-
pending_moniloggers[event_name].emplace_back(monilogger);
131+
pending_moniloggers[event_name].push_back(std::move(monilogger));
188132
} else {
189133
std::list<py::function> event_moniloggers = event_to_moniloggers[event_name];
190134
// Make sure a monilogger can only be registered once.
191135
if (std::find(event_moniloggers.begin(), event_moniloggers.end(), monilogger) == event_moniloggers.end())
192136
{
193137
// Add the monilogger to the list of registered moniloggers for this event name.
194-
event_to_moniloggers[event_name].emplace_back(monilogger);
138+
event_to_moniloggers[event_name].push_back(std::move(monilogger));
195139
for (auto id : ids)
196140
{
197141
// Add the monilogger to the list of registered moniloggers for each base event.
198-
registered_moniloggers[id].push_back(monilogger);
142+
// TODO: add to pending moniloggers if the base event does not exist yet.
143+
registered_moniloggers[id].push_back(std::move(monilogger));
199144
}
200145
}
201146

‎src/api/monilogger/include/MoniLogger.h‎

Lines changed: 19 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -28,16 +28,28 @@ namespace MoniLogger
2828

2929
MoniLoggerExecutionContext create_context(std::string name);
3030

31-
void register_composite_event(std::string event_name, std::list<std::string> triggering_events);
32-
33-
void register_composite_events(std::map<std::string, std::list<std::string>> composite_events);
34-
35-
void register_base_events(std::map<std::string, size_t> events);
31+
/**
32+
* @brief Registers the event as a complex event triggered by the provided list of events.
33+
* @throws std::invalid_argument If the event to register already exists, or if any of the
34+
* listed triggering events does not exist.
35+
*
36+
* @param event_name name of the complex event to register.
37+
* @param triggering_events events (base or complex) triggering the complex event to register.
38+
*/
39+
void register_complex_event(std::string event_name, std::list<std::string> triggering_events);
40+
41+
void register_complex_events(std::map<std::string, std::list<std::string>> complex_events);
42+
43+
/**
44+
* @brief Registers the event as a base event.
45+
* @throws std::invalid_argument If the event to register already exists.
46+
*
47+
* @param event_name name of the base event to register.
48+
*/
49+
size_t register_base_event(std::string event_name);
3650

3751
std::list<std::string> get_base_events();
3852

39-
void clear_events();
40-
4153
__attribute__((visibility("default")))
4254
void register_monilogger(std::string event_name, py::function monilogger);
4355

‎src/api/monilogger/monilogger.py‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -25,4 +25,4 @@ def define_event(event, triggering_events):
2525
event_name = event
2626
else:
2727
event_name = event.__qualname__
28-
mnlg.define_composite_event(event_name, triggering_events)
28+
mnlg.register_complex_event(event_name, triggering_events)

‎src/api/monilogger_module.cc‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -8,8 +8,8 @@ PYBIND11_MODULE(_monilogger, m) {
88
.def_property_readonly("name", &MoniLogger::MoniLoggerExecutionContext::get_name);
99
m.def("register", &MoniLogger::register_monilogger);
1010
m.def("stop", &MoniLogger::unregister_monilogger);
11-
m.def("define_composite_event", &MoniLogger::register_composite_event);
12-
m.def("define_base_events", &MoniLogger::register_base_events);
11+
m.def("register_complex_event", &MoniLogger::register_complex_event);
12+
m.def("register_base_event", &MoniLogger::register_base_event);
1313
m.def("get_base_events", &MoniLogger::get_base_events);
1414
m.def("emit_event", [](std::string event_name, std::shared_ptr<MoniLogger::MoniLoggerExecutionContext> scope)
1515
{

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

Lines changed: 11 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2,8 +2,17 @@
22

33
numbers = []
44

5-
@register("NewIteration")
5+
@register("Initialize")
6+
def log(ctx):
7+
print("Computing fibonacci number for n = " + str(ctx.n))
8+
9+
@register("Iterate")
610
def log(ctx):
711
global numbers
812
numbers.append(ctx.current_number)
9-
print(numbers)
13+
print("Computed fibonacci number " + str(ctx.current_number) + " for n = " + str(ctx.iteration))
14+
15+
@register("Finalize")
16+
def log(ctx):
17+
global numbers
18+
print("Fibonacci sequence for n = " + str(ctx.n) + " is " + str(numbers))

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

Lines changed: 14 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -3,25 +3,31 @@
33

44
int fibonacci(int n)
55
{
6-
std::shared_ptr<FibonacciExecutionContext> ctx(new FibonacciExecutionContext("FibonacciExecutionContext"));
6+
auto events = MoniLogger::get_base_events();
77

8-
int u = 0;
9-
int v = 1;
10-
int i = 1;
11-
int t = 0;
8+
std::shared_ptr<FibonacciExecutionContext> ctx(new FibonacciExecutionContext(n, "FibonacciExecutionContext"));
9+
10+
MoniLogger::trigger(INITIALIZE, ctx);
11+
12+
int u(0), v(0), i(0), t(0);
1213

1314
ctx->previous_number = &u;
1415
ctx->current_number = &v;
1516
ctx->iteration = &i;
1617

17-
MoniLogger::trigger(0, ctx);
18+
MoniLogger::trigger(ITERATE, ctx);
19+
20+
v = 1;
1821

19-
for(i = 2; i <= n; i++)
22+
for(i = 1; i <= n; i++)
2023
{
2124
t = u + v;
2225
u = v;
2326
v = t;
24-
MoniLogger::trigger(0, ctx);
27+
MoniLogger::trigger(ITERATE, ctx);
2528
}
29+
30+
MoniLogger::trigger(FINALIZE, ctx);
31+
2632
return v;
2733
}

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

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@ void initialize_embedding(std::vector<std::string> python_path, std::vector<std:
1212
[](pybind11::module_ interface_module, pybind11::object context_class) {
1313
pybind11::class_<FibonacciExecutionContext, std::shared_ptr<FibonacciExecutionContext>>(interface_module, "FibonacciExecutionContext", context_class)
1414
// Defining the properties exposed by the FibonacciExecutionContext.
15+
.def_property_readonly("n", &FibonacciExecutionContext::get_n)
1516
.def_property_readonly("current_number", &FibonacciExecutionContext::get_current_number)
1617
.def_property_readonly("previous_number", &FibonacciExecutionContext::get_previous_number)
1718
.def_property_readonly("iteration", &FibonacciExecutionContext::get_iteration)
@@ -37,11 +38,11 @@ void initialize_embedding(std::vector<std::string> python_path, std::vector<std:
3738
};
3839

3940
// Define base execution events emitted by the application, to which moniloggers can register.
40-
MoniLogger::register_base_events({
41-
{"NewIteration", 0}
42-
});
41+
MoniLogger::register_base_event(INITIALIZE);
42+
MoniLogger::register_base_event(ITERATE);
43+
MoniLogger::register_base_event(FINALIZE);
4344

44-
// Bootstrapping monilogger, consisting mainly of starting the Python interpreter, initializing
45+
// Bootstrapping monilogger, consisting of starting the Python interpreter, initializing
4546
// the monilogger module, and evaluating the provided scripts.
4647
MoniLogger::initialize_monilogger(python_path, python_scripts, interface_module, interface_module_initializer);
4748
}

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

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3,17 +3,23 @@
33

44
#include <MoniLogger.h>
55

6+
#define INITIALIZE "Initialize"
7+
#define ITERATE "Iterate"
8+
#define FINALIZE "Finalize"
9+
610
struct FibonacciExecutionContext : MoniLogger::MoniLoggerExecutionContext
711
{
12+
const pybind11::object get_n() const { return pybind11::cast(n); }
813
const pybind11::object get_previous_number() const { if (previous_number != nullptr) return pybind11::cast(*previous_number); else return pybind11::cast<pybind11::none>(Py_None); }
914
const pybind11::object get_current_number() const { if (current_number != nullptr) return pybind11::cast(*current_number); else return pybind11::cast<pybind11::none>(Py_None); }
1015
const pybind11::object get_iteration() const { if (iteration != nullptr) return pybind11::cast(*iteration); else return pybind11::cast<pybind11::none>(Py_None); }
11-
16+
17+
int n;
1218
int *previous_number = nullptr;
1319
int *current_number = nullptr;
1420
int *iteration = nullptr;
1521

16-
using MoniLogger::MoniLoggerExecutionContext::MoniLoggerExecutionContext;
22+
FibonacciExecutionContext(int n, std::string name) : MoniLoggerExecutionContext(name), n(n) {}
1723
};
1824

1925
void initialize_embedding(std::vector<std::string> python_path, std::vector<std::string> python_scripts);

‎tests/tests.py‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -15,13 +15,13 @@ def test_undefined_event(self):
1515
def test_monilogger(ctx):
1616
self.result = self.result + 1
1717

18-
mnlg.define_base_events({"MyEvent":0})
18+
mnlg.register_base_event("MyEvent")
1919
mnlg.emit_event("MyEvent", mnlg.MoniLoggerExecutionContext())
2020

2121
self.assertEqual(self.result, 1)
2222

2323
def test_class_event(self):
24-
mnlg.define_base_events({"MyOtherEvent":0})
24+
mnlg.register_base_event("MyOtherEvent")
2525

2626
@monilogger.register(MyOtherEvent)
2727
def test_monilogger(ctx):
@@ -32,7 +32,8 @@ def test_monilogger(ctx):
3232
self.assertEqual(self.result, 1)
3333

3434
def test_composite_event(self):
35-
mnlg.define_base_events({"MyEvent":0, "MyOtherEvent":1})
35+
mnlg.register_base_event("MyEvent")
36+
mnlg.register_base_event("MyOtherEvent")
3637
monilogger.define_event("MyCompositeEvent", ["MyEvent", "MyOtherEvent"])
3738

3839
@monilogger.register("MyCompositeEvent")

0 commit comments

Comments
 (0)