Monitoring Actors

[QueueYueue]

I don't think it takes too long after deciding to do an actor based project to run into the case where you have an actor spun off without a way to kill it. You'll figure that out and get your solution working so you can pass it off to someone else and forget about it. Soon after, that someone else will come to you and say something like "yeah, those actors are cool and all, but they're really hard to debug"

 

I ran into some of these problems a while ago, so I decided to write a little tool to help with it. I decided to call it a monitored actor. Here were my design criteria:

1. I want a visual representation of when a monitored actor is spun up, and when it is shut down.
2. From the visual representation, I want to be able to: stop actor, open their actor cores, and see if they're answering messages
3. The visual representation should give you an idea of nested actor relationships.
4. Implementing a monitored actor should be identical to implementing a regular actor. (meaning no must overrides or special knowledge)
5. Monitored actors behave identically to Actors in the runtime environment.
   

It turns out that you can pretty much accomplish this by creating a child actor class, which I've called Monitored Actor. A monitored actor's Pre-launch Init will try to make sure that the actor monitor window is made aware of the spawned actor, and Stop core will notify it that the actor is now dead. The actor monitor window contains ways to message the actors and pop up their cores and such.

 

 

I think it's fairly obvious what each button does except pinging. Pinging will send a message to the actor and time how long it takes to get a response. This can be used to see if your actor is locked up. The time it takes to respond will be shown in the ping status column. if you want to periodically ping all the actors, set the "poll Frequency" to something greater than 10ms. This will spawn a process that just sends ping messages every X ms.

 

Where I didn't quite meet my criteria: If you were to spawn a new actor and Immediately (in pre-launch init) spam it with High priority messages, the Actor monitor window will not know about the spawned actor until it's worked through all the High priority messages that got their first. You probably shouldn't be doing this anyways, so don't.

 

Download it. Drop the LVLIB into your project. Change your actor's inheritance hierarchy to inherit from monitored actor instead of actor. You shouldn't have to change any of your actor's code. The monitored window will pop up when an actor is launched, and kill it's self when all actors are dead.

 

Final note: This was something I put together for my teams use. It's been working well and fairly bug free for the past few months. It wasn't something I planned on widely distributing. A co-worker went to NI week though and he said that in every presentation where actors were mentioned, someone brought up something about they being hard to debug or hard to get into the actual running actor core instance. So I decided to post this tool here to get some feedback. Maybe find some bugs, and get a nice tool to help spread the actor gospel. Let me know what you think.

Monitored Actor.zip

[drjdpowell]

Nicely done.   I made a similar tool for my actor-like framework, and I experimented with something for the Actor Framework, but I couldn't see how to do it without changing Actor.lvclass (make a child class, of course!).  Like the “ping” ability. 

[QueueYueue]

That reminds me: Design criteria #6. was "Don't change the base actor framework" 

[Aristos Queue]

QueueYueue: This is good work. Very good work. Thank you!

 

[FixedWire]

Great example QueueYueue. Interesting how the system spun up the Actor Core Name numbers unexpectedly out of sequence.