How to find an actor in caf

Question

I started to play around with caf and using it to represent a graph.
Since this graph is unidirected I can create the actors that I need and link them accordingly, but now I want to find a specific actor identified by it's name.

class node_actor : public event_based_actor{
    std::string m_name;
    ...
};

int main(){
    auto entry_actor = spawn<node_actor>();
    // node_actor will spawn other actors with names
    // like this: node_actor will spawn node1
    // node1 will spwan node2
    // node2 will spwan node3 and so on

    // now I want to send a message to node2
    scoped_actor self;
    self->send(n2, 42});
    ...
}

What would be the best way to find n2?
Can this be handled by a group, broadcasting a message? E.g like this:

{
    auto g = group::get("local", "Node events");
    auto entry_actor = spawn_in_group<node_actor>(g);
    // change all nodes to call spawn_in_group

    scoped_actor self;
    self->send(g, name, 42})
}

If so wouldn't that be much overhead, because all nodes must be checked if they match the message?
Or are there other ways that I did not find in the docs yet?

Answer 1

I think the group is a good idea because it also works distributed. You can have a better scalability by announcing each spawned actor to the group instead of broadcasting the messages.

Each actor that needs a name <-> actor mapping would then subscribe to the group (before you actually spawn your nodes). Whenever you spawn a new node, you send its name along with its handle to the group and each listener adds this mapping to its local state (or ignores the message if it is only interested in a few selected names).

In case you have a lot of actors that need the name mapping and you don't want to replicate the mapping many times, you could also use a single actor instead of a group that stores a map and can be queried by others whenever they need to resolve a name.

Your third option is to use the actor registry, but this will only work locally and only if you can use atom names. If this matches your use case, then you can register new actors via detail::singletons::get_actor_registry()->put_named(key, value); and retrieve them via detail::singletons::get_actor_registry()->get_named(key);. I usually don't recommend features from the detail namespace, but this particular feature will make its way to the public API in 0.15. By the way, you can create an atom_value dynamically, but you are of course limited to 10 characters and are only allowed to use alphanumeric characters.

Hope that helps.