How to easily intercept messages sent to ALL objects ?

Hi folks. I want to intercept (and do something) for all objects. I know few approaches, for example:

hi Mariano,

I tried something similar, but I haven't found a satisfactory solution.

1) using method wrappers (implementing  run: aSelector with: arguments in: aReceiver) I can wrap all compiled methods of all classes  and there I have the receiver.

You can wrap most of the compiled methods in the system. Not all of them, so you will have find out which one you can safely wrap.

Wrapping and unwrapping all classes takes a bit of times (1-2 seconds on my machine).

I therefore used MessageTally to find out what I exactly need to wrap. This is not perfect (MessageTally uses a sampling profiling after all). But it is fine for now.

2) become all objects to some kind of hacky object that stores the original object and that redefines the doesNotUnderstand:

If you succeed, let me know.

Cheers,
Alexandre

--
_,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:
Alexandre Bergel  http://www.bergel.eu
^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;.

_______________________________________________
Pharo-project mailing list
[hidden email]
http://lists.gforge.inria.fr/cgi-bin/mailman/listinfo/pharo-project

On Mar 25, 2010, at 5:50 PM, Mariano Martinez Peck wrote:

> Hi folks. I want to intercept (and do something) for all objects. I know few approaches, for example:
>
> 1) using method wrappers (implementing  run: aSelector with: arguments in: aReceiver) I can wrap all compiled methods of all classes  and there I have the receiver.
>
> 2) become all objects to some kind of hacky object that stores the original object and that redefines the doesNotUnderstand:
>
> But in 1) I need to change all CompiledMehtod of all classes.
> in 2) I have to become all the objects to another object
>
> Then my question is, is there an easier way to intercept all messages send to all objects from the image side (not going to vm) and with a lower cost ?

No.

So the MOP (meta object protocol), the "reflective API" of Smalltalk does not allow for "reifying" message receive.

Historically, after Reflection was discovered and people started to generalize it, of cource they added that. For example, there is CODA:

       http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.108.6885&rep=rep1&type=pdf

which made the whole "message send" explicit and interceptable.

This means it is decomposed into Send, Receive, Lookup, Apply. Very nice. Very general. One can override Lookup when one wants to do
e.g. Multiple inheritance. Or Apply, when the language of the method is not smalltalk. Or Receive, if you want to hook into "does an object get
a message?". Futures, non-blocking messages. All easy to be done.

But: it's slow. Dog slow. So people started to think about: how to speed up? Sadly the idea of optimizing at runtime (partially evaluating the MOP)
has seen not much work. What was done is "partial reflection": only reifiy those opereation at exactly those spots that one is interested in.
This was done in MetaClassTalk (it checks if the MetaClass overrides message sending, else it uses normal bytecodes) and to the extreme in Reflex.

Now if you want to change reflective behavior *per object* the other important thing is that you need to be able to define changed behavior at
the level of Objects vs. Classes. CLOS style MOPS like MetaClassTalk allow *only* for a per-Class-change.

Enter Eric Tanter's Relex. Reflex generalized the MOP idea to not be bound to classes/metaclasses but you can select *per instruction* what to reify.
And that reification is only done when needed, keeping the code you are not interested in fast.
(Reflex is what happens when you bring the lessons of AOP back into MOPs. That is, the good parts of AOP).

               http://portal.acm.org/citation.cfm?id=949309

Of course, message receive is not easy to achive other than reifying method-execute on all methods+doesNotUnderstand.
This can be made a bit more efficient for all the objects of the class you are not interested in by using Object-specific Behavior
(the anonymous subclass trick). Phillippe did that in TreeNurse...
But all in all, this is more of a hack.

Now for message receive, one could imagine a partial reification scheme: a tag bit on the object header, if it is there, the VM calls a receive
method instead of the method that would originally be called. So you would pay, in all casses, one bit-check on message send *and* you need
space to put this flag. Would anyone want to pay that?

In general, I would like to experiment with a MOP that can reify message receive in a meaningful *and efficient* way. But the current VM can't do it.
In addition, there is always the problem that reflection leads to loops (your code will use the code it will used on).

       http://scg.unibe.ch/archive/papers/Denk08bMetaContextLNBIP.pdf

Wich needs to be solved, too, if you ever want to be able to use reflection on everything (even the things you implement reflectively).

Alternatively, one could use a proxy. Now if you don't use a subclass of ProtoObject, but something with VM support int the Style of Adrian Lienhard's
Aliases:

               http://scg.unibe.ch/archive/papers/Lien08bBackInTimeDebugging.pdf

or the Handle (we need a better word!!!) stuff that JB is working on, maybe this would not be too bad. The Alias is *hidden*, you can put it (eventually,
after all engineering done) on any object (even Integers)... and than, after you swap out something, you need a proxy anyway for the "outpointer".

> And if going to vm, how ?

The OOPSLA paper of 2008 on tolerating memory leaks has scheme where they use the GC of Jikes. So compared to LOOM, they have a modern
GC without an object table, and it seems much simpler.

       Marcus

--
Marcus Denker  -- http://www.marcusdenker.de
INRIA Lille -- Nord Europe. Team RMoD.


_______________________________________________
Pharo-project mailing list
[hidden email]
http://lists.gforge.inria.fr/cgi-bin/mailman/listinfo/pharo-project