Slate on a message-passing machine

I sent this four days ago, but it never yet arrived

For my Master's thesis, I will probably be working on a hardware
architecture for efficiently executing object-oriented systems.
Slate is definitely the most generic of these types of systems,
and so I believe I should make the hardware directly applicable
to slate, since all other object oriented semantics are a subset
of those provided by Slate.

For an example of the kind of hardware I am talking about,
consider Jecel's Ring Network Architecture:
http://www.merlintec.com:8080/hardware/19 . According to the
example, the RNA architecture can send, lookup, and execute a
message that is installed on a single receiver without software
assistance. I wonder if this design can accommodate some, if not
all, of the multi-dispatched message sends in slate. In other
words, is there (hopefully large) a subset of slate
message-passing semantics that can be resolved without resorting
to sending extra messages?

I hazard to guess that a subset of slate does have the same
semantics as the operation natively handled by RNA, but it may
be somewhat small. This seems to be the case when there is
exactly one method with the given selector, and the receivers
all have NoRole. This could be resolved as a single-send to the
method object with the receivers as arguments. Is this correct?

To implement Slate on a single-dispatch architecture, I think
selectors would be sent a single-dispatch valueWith:With ...,
message. To resolve, I suppose one would calculate the distance