Posted by
Levente Uzonyi-2 on
Oct 12, 2011; 9:22pm
URL: https://forum.world.st/About-and-tp3898409p3899784.html
On Wed, 12 Oct 2011, Mariano Martinez Peck wrote:
> On Wed, Oct 12, 2011 at 5:38 PM, Levente Uzonyi <
[hidden email]> wrote:
>
>> On Wed, 12 Oct 2011, Clara Allende wrote:
>>
>> Hi guys,
>>>
>>> I'm wondering, why?
>>>
>>> ProtoObject>> ~~ anObject
>>> "Answer whether the receiver and the argument are not the same object
>>> (do not have the same object pointer)."
>>>
>>> self == anObject
>>> ifTrue: [^ false]
>>> ifFalse: [^ true]
>>>
>>>
> Hi Carla. I can think about two things. The first one, is the one Levente
> said, performance.
> If you analyze the bycode of this method, you will see that it is extremely
> fast because:
>
> 1) #== has an special associated bytecode, that is, them VM maps such
> bytecode to an specific primitive and it is directly executed. It means that
> the method #== is really never sent.
> 2) ifTrue:ifFalse: is also optimized (inlined) by the compiler. Again, it
> method is never executed and instead the compiler replace a message send
> bytecode with jump ones.
>
> Another possible reason (it may not be the case, but in another places it
> is), is to prevent VM interruption for check other processes. In summary,
> the VM checks whether it should execute another process of the queue after a
> method execution. As you know, some parts of the scheduling process is done
> at the image side. And from there we lack a way to say to the VM, "please
> execute this method without checking others processes". Hence, in a few yet
> very specific places of PRocess, Scheduler, Semaphore, etc, #== is used as a
> mean of executing something WITHOUT being interrupted. I can imagine that it
> may happen the same with #~~. So if you implement such method with a #not,
> you will indeed send a message, proving a possibilty to be interrupted.
I don't see how this would be a reason. When you send #~~, then you
explicitly allow a suspension point, so not using #not won't avoid
suspension points.
>
> Another reasons, similar to the previous one, is that sometimes #== is also
> used as a way to avoid executing method. So..there are some methods (I don't
> remember if #allInstancesDo: or #allObjectsDo:) will loop forever because
#allInstancesDo: uses primitives to avoid the problem. #allObjectsDo: uses
a custom marker object, so creating new objects won't cause infinite loop
(because gc doesn't change the order of any two objects).
> the loop condition would be creating objects (remember that method execution
> creates objects such as MethodContext).
Contexts object are not created until requested and these loops don't
need contexts. Some old methods interating through all/some objects use 0
as the marker object. These may have problems with objects created during
their loops.
Levente
> So...again, I think it may happen the same with #~~.
>
> That being said, I agree that the method deserve a GOOD comment explaining
> the reasons of such optimization.
>
> Cheers
>
>
>
>> Instead of:
>>> ProtoObject>> ~~ anObject
>>> "Answer whether the receiver and the argument are not the same object
>>> (do not have the same object pointer)."
>>>
>>> ^(self == anObject) not
>>>
>>> And why?
>>> Object >> ~= anObject
>>> "Answer whether the receiver and the argument do not represent the
>>> same object."
>>>
>>> ^self = anObject == false
>>>
>>> Instead of
>>> Object>> ~= anObject
>>> "Answer whether the receiver and the argument do not represent the
>>> same object."
>>>
>>> ^(self = anObject) not.
>>>
>>> Is there any particular reason for this that I'm missing?
>>>
>>
>> Performance.
>>
>>
>> Levente
>>
>> Thanks in advance!
>>> --
>>>
>>> "*Most good programmers do programming not because they expect to get paid
>>> or get adulation by the public, but because it is fun to program.*"
>>>
>>> Linus Torvalds
>>>
>>>
>>
>
>
> --
> Mariano
>
http://marianopeck.wordpress.com>