Actor Framework Discussions
Communicate Between Parallel Nested Actors
Solved!
Basically the Caller, receives the message from it's nested actor (so that would typically be a concrete child of an abstract message) and then when the caller receives it, the Do.vi for that message simply sends a concrete message to the other nested actor.
So the downside to the normal strict hierarchical, is that you end up with a bunch of messages that do nothing but forward messages along the chain (of course you are not technically forwarding the messaging object but sending a new message which has the same intent).
So yes as in the last line your post you do end up with a lot of "forward this information to actor B messages"
For the logger application, I would create a parent actor that owns an enqueuer for the logger in its private data and make all your actors that need to log data inherit from that. Then you can write one method in your parent class called "log string" that takes a string and sends it to the logger.
Then you have to launch the logger first so you can get its enqueuer and everytime you launch a nested actor, you give it the enqueuer to the logger. Then each of those nested actors can call the "log string method".
The parent class can protect the logger enqueuer so that other loops can't accidentally shut it down or anything or send it some other message.
When they release the videos from GDevCon you should check out Dr. Powell's presentation on messaging. It doesn't have the AF example you are looking for, but it does have a lot of really useful information and theory about messaging paradigms including peer networks versus a tree structure. It talks about the pitfalls of breaking the tree hierarchy. Generally, I only break it as a last result and with good reason.
@CanadaGuy wrote:
I have a root actor that launches two nested actors (side by side in parallel, not cascaded). The root actor is a UI actor. The first nested actor is a logging actor, the second actor is a simulation actor. For messages from each callee to the caller actor, I'm using the abstract/child message approach so the nested actors are not dependent on the root actor.
How do I send a log message from the simulation actor to the logging actor? One method I thought would be to includes a user event in the root actor that will fire when a log message is received from the simulation actor, and forward it to the logging actor. The other thought I had was that I could initialize the logging actor first, get its enqueuer, then initialize the simulation actor with the logging enqueuer in place. Does this create some dependencies that I'm not aware of?
I would like to suggest an idea:
To avoid generating of may be unnecessary forwarding messages,
You can override the Receive Message.vi in Root Actor. You must also define a base class for all logger messages, e.g. Msg for Logger.lvclass inheriting from Message.lvclass. For the logger messages You have to change the parent class from Message.lvclass to Msg for Logger.lvclass.
In Receive Message.vi You can verify that the message is derived from Msg for Logger.lvclass and forward the message to Logger Actor. Otherwise, the parent Receive Message.vi is called and the root proceed the message by itself. I attach a sample project (LV2014). Run the Launcher.vi
@p4keal wrote:
@CanadaGuy wrote:
...
I would like to suggest an idea:
To avoid generating of may be unnecessary forwarding messages,
You can override the Receive Message.vi in Root Actor. You must also define a base class for all logger messages, e.g. Msg for Logger.lvclass inheriting from Message.lvclass. For the logger messages You have to change the parent class from Message.lvclass to Msg for Logger.lvclass.
In Receive Message.vi You can verify that the message is derived from Msg for Logger.lvclass and forward the message to Logger Actor. Otherwise, the parent Receive Message.vi is called and the root proceed the message by itself. I attach a sample project (LV2014). Run the Launcher.vi
Thanks for posting this, I enjoyed learning about modifying the default behavior of Receive Message.vi, which I hadn't thought about before.
In 2020 now, I'm trying to understand if this problem (i.e. "avoid generating of may be unnecessary forwarding messages") is still relevant. If I use an interface "log message" implemented by root, log, and all N nested actors which can generate a log event, then I need N+2 implementations of the log message interface. Is that N+2 implementations the problem of unnecessary forwarding messages?
In your implementation, you have override the Receive Message.vi in Root Actor, create a new Logger.lvclass inheriting from Message.lvclass, and then put that send log entry class within the private data of N nested actors which can generate a log event.
These methods (LabVIEW 2020 interface) and your method seem comparable in amount of code-burden, right?
