rotor VS sobjectizer

If your architecture fits into inter-process messaging, i.e. spawn threads which do similar or different tasks and inform each other via messages, try to use actor framework, i.e. rotor (disclaimer: I'm the author). If there is a need to expand messaging even more, i.e. across the network, you can try to use caf, which provides that facility out of the box.

What you achieved, is handlers decoupling, i.e. when one handler knows nothing about other handler, which leads to good application testability. However, with standard promise/future bases messaging, if performance matters (and it usually does, otherwise why use C++?), i doubt that your implementation overwhelms the performance of specialized actor libraries, like sobjectizer ("batteries included" actors toolbox) or rotor (DIY-like actor constructor set; disclaimer: I'm the author of it).

I have been reading the documents from Boost.fibre and Boost.Signals2 which I could use, maybe ASIO for async. I also checked ZeroMQ (this seems to be more or less "only" for networking), Copper and Rotor. If this were just a simple MCU project I would just take the FreeRTOS and would have everything I need. Now I'm just lost how to structure my code / how to realize my main loop.

I would like to present my project rotor, which is event loop friendly C++ actor micro framework with Erlang-like microframework with supervising capabilities.

rotor actor library (I'm the author) was designed to solve similar problem, which I named "actor intrusiveness", when almost every piece of code should be written in form of actor, and, the working threads, which spin actors, are out of your control.

PS. I'm the author of rotor framework )

May be actor frameworks like caf, sobjectizer or rotor is something, that you are looking for.

Message Delivery Tracing aims to debug an application built on top of SObjectizer. In essence, it logs the primary stages of the message delivery process, allowing visibility into whether there is a suitable subscriber with the corresponding event handler.

An additional rationale for structuring cooperations in hierarchies is to facilitate the sharing and propagation of dispatchers. A recent update of SObjectizer includes new functionalities that allow access to both agent and cooperation dispatchers. This enhancement was prompted by feedback provided by a user and myself.

If a stop signal arrives, it will be enqueued at the end as a demand for image_producer_callback. This means, it will be processed after the other 6 demands currently in the queue. Maybe this is not an issue but in some cases it might be. At this point, another feature of SObjectizer is to consider: agent priorities. Essentially, this feature allows for the demands to be handled in different orders based on the priorities of agents. In this context, if we assign image_producer_callback a higher priority than others, the “stop signal” would be processed before the rest of the requests.

The real solution consists in using another slick feature of SObjectizer: mutable messages.

However, this kind of filtering is inefficient and might result in a significant run-time cost. Indeed, every empty cv::Mat follows all the message handling workflow, only to be thrown out. Although we expect that empty images will be sporadic, a more idiomatic approach exists: delivery filters.

SObjectizer’s agent states are quite sophisticated and provide some utilities that might be useful for developing a working solution. First of all, image_viewer can be modeled as a two-state agent:

An alternative way is using SObjectizer’s timers.

Those who came looking for actor model examples should check out sobjectizer

In sobjectizer the ownership is held by "environment" , while in rotor each thread must held appropriate context, when actor environment is running.

May be actor frameworks like caf, sobjectizer or rotor is something, that you are looking for.