{"id":18,"date":"2009-01-14T12:51:37","date_gmt":"2009-01-14T20:51:37","guid":{"rendered":"http:\/\/www.mirandabanda.org\/cogblog\/?p=18"},"modified":"2018-12-10T11:41:58","modified_gmt":"2018-12-10T19:41:58","slug":"under-cover-contexts-and-the-big-frame-up","status":"publish","type":"post","link":"http:\/\/www.mirandabanda.org\/cogblog\/2009\/01\/14\/under-cover-contexts-and-the-big-frame-up\/","title":{"rendered":"Under Cover Contexts and the Big Frame-Up"},"content":{"rendered":"

Nobody expects the Smalltalk language system. Our chief weapon is polymorphism… polymorphism and objects…objects and polymorphism. Our two weapons are objects and polymorphism… and inheritance… Our three weapons are objects, and polymorphism and inheritance… and an almost fanatical devotion to contexts…
\nOur four…no…
\nAmongst our weapons… Amongst our weaponry… are such elements as objects, po…
\nI’ll come in again<\/a>.<\/p>\n

Contexts are Smalltalk’s first-class activation records. thisContext is the “reserved word” (technically, pseudo-variable) for the current activation record. Try “thisContext inspect” and see what you get. Then try “thisContext inspect. self halt” and see what you get.<\/p>\n

Contexts are fabulous weapons, even better programming building blocks, and horribly<\/em> expensive. How do I love contexts? Let me count the ways…<\/p>\n

Contexts mean Smalltalk has had edit-and-continue debugging since the 1970’s.
\nContexts allow the implemention of an exception system with no additional support from the virtual machine.
\nContexts allow the implemention of dynamic binding, co-routines, tail-recursion-elimination and backtracking<\/a> with no additional support from the virtual machine.
\nContexts enable process persistence and migration.
\nContexts allow implementation of continuations (full, delimited<\/a>\/partial or otherwise) without additional VM support (and hence the Seaside<\/a> web framework).
\nContexts are consistent<\/a> (consistent)<\/a> with the rest of the “objects all the way down” system, providing activations as first-class objects.
\nBecause they’re there.<\/p>\n

What does a context look like?
\n\"\"
\nThe method is the code to execute. The stack is of finite size, guaranteed by the bytecode compiler. The sender is the caller context, providing a simple and flexible “spaghetti stack”<\/a> scheme.<\/p>\n

But a naive implementation has to allocate a context on each send, move the receiver and arguments from the stack of the caller context to that of the callee, and assign the callee’s sender with the caller. For essentially every return the garbage collector eventually has to reclaim, and every return has to nil the sender and instruction pointer fields of, the context being returned from. Here’s the blue book<\/a> code for method activation:<\/p>\n

activateNewMethod<\/strong>
\n<\/span>|<\/span> contextSize<\/span> newContext<\/span> newReceiver<\/span> |<\/span>
\n(<\/span>self<\/span> largeContextFlagOf:<\/span> newMethod) <\/span>=<\/span> 1<\/span>
\n<\/span>ifTrue:<\/span> [<\/span>contextSize<\/span> :=<\/strong> 32<\/span> +<\/span> TempFrameStart<\/strong><\/span>]
\n<\/span>ifFalse:<\/span> [<\/span>contextSize<\/span> :=<\/strong> 12<\/span> +<\/span> TempFrameStart<\/strong><\/span>].
\n<\/span>newContext<\/span> :=<\/strong> memory
\n<\/span>instantiateClass:<\/span> ClassMethodContextPointer<\/span><\/strong>
\n<\/span>withPointers:<\/span> contextSize<\/span>.
\nmemory <\/span>storePointer:<\/span> SenderIndex<\/strong><\/span>
\n<\/span>ofObject:<\/span> newContext<\/span>
\n<\/span>withValue:<\/span> activeContext.
\n<\/span>self<\/span> storeInstructionPointerValue:<\/span> (<\/span>self<\/span> initialInstructionPointerOfMethod:<\/span> newMethod)
\n<\/span>inContext:<\/span> newContext<\/span>.
\n<\/span>self<\/span> storeStackPointerValue:<\/span> (<\/span>self<\/span> temporaryCountof:<\/span> newMethod)
\n<\/span>inContext:<\/span> newContext<\/span>.
\nmemory <\/span>storePointer:<\/span> MethodIndex<\/strong><\/span>
\n<\/span>ofObject:<\/span> newContext<\/span>
\n<\/span>withValue:<\/span> newMethod.
\n<\/span>self<\/span> transfer:<\/span> argumentCount <\/span>+<\/span> 1<\/span>
\n<\/span>fromIndex:<\/span> stackPointer <\/span>–<\/span> argumentCount
\n<\/span>ofObject:<\/span> activeContext
\n<\/span>toIndex:<\/span> ReceiverIndex<\/strong><\/span>
\n<\/span>ofObject:<\/span> newContext<\/span>.
\n<\/span>self<\/span> pop:<\/span> argumentCount <\/span>+<\/span> 1<\/span>.
\n<\/span>self<\/span> newActiveContext:<\/span> newContext<\/span><\/p>\n

If you want to stay with this scheme but make it faster then you could do worse than the current Squeak implementation:<\/p>\n

activateNewMethod<\/strong>
\n<\/span>|<\/span> newContext<\/span> methodHeader<\/span> initialIP<\/span> tempCount<\/span> nilOop<\/span> where<\/span> |<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>methodHeader<\/span> :=<\/strong> self<\/span> headerOf:<\/span> newMethod.
\n<\/span>newContext<\/span> :=<\/strong> self<\/span> allocateOrRecycleContext:<\/span> (<\/span>methodHeader<\/span> bitAnd:<\/span> LargeContextBit<\/strong><\/span>).<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>initialIP<\/span> :=<\/strong> (<\/span>(<\/span>LiteralStart<\/strong><\/span> +<\/span> (<\/span>self<\/span> literalCountOfHeader:<\/span> methodHeader<\/span>)<\/span>)<\/span> *<\/span> BytesPerWord<\/strong><\/span>) <\/span>+<\/span> 1<\/span>.
\n<\/span>tempCount<\/span> :=<\/strong> self<\/span> temporaryCountOfMethodHeader:<\/span> methodHeader<\/span>.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“Assume: newContext will be recorded as a root if necessary by the
\ncall to newActiveContext: below, so we can use unchecked stores.”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>where<\/span> :=<\/strong> newContext<\/span> +<\/span> BaseHeaderSize<\/strong><\/span>.
\n<\/span>self<\/span> longAt:<\/span> where<\/span> +<\/span> (<\/span>SenderIndex<\/strong><\/span> <<<\/span> ShiftForWord<\/strong><\/span>) <\/span>put:<\/span> activeContext.
\n<\/span>self<\/span> longAt:<\/span> where<\/span> +<\/span> (<\/span>InstructionPointerIndex<\/strong><\/span> <<<\/span> ShiftForWord<\/strong><\/span>) <\/span>put:<\/span> (<\/span>self<\/span> integerObjectOf:<\/span> initialIP<\/span>).
\n<\/span>self<\/span> longAt:<\/span> where<\/span> +<\/span> (<\/span>StackPointerIndex<\/strong><\/span> <<<\/span> ShiftForWord<\/strong><\/span>) <\/span>put:<\/span> (<\/span>self<\/span> integerObjectOf:<\/span> tempCount<\/span>).
\n<\/span>self<\/span> longAt:<\/span> where<\/span> +<\/span> (<\/span>MethodIndex<\/strong><\/span> <<<\/span> ShiftForWord<\/strong><\/span>) <\/span>put:<\/span> newMethod.
\n<\/span>self<\/span> longAt:<\/span> where<\/span> +<\/span> (<\/span>ClosureIndex<\/strong><\/span> <<<\/span> ShiftForWord<\/strong><\/span>) <\/span>put:<\/span> nilObj.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“Copy the reciever and arguments…”<\/span>
\n<\/span>0<\/span> to:<\/span> argumentCount <\/span>do:<\/span>
\n[:<\/span>i<\/span> |<\/span> self<\/span> longAt:<\/span> where<\/span> +<\/span> (<\/span>(<\/span>ReceiverIndex<\/strong><\/span>+i<\/span>)<\/span> <<<\/span> ShiftForWord<\/strong><\/span>)<\/span> put:<\/span> (<\/span>self<\/span> stackValue:<\/span> argumentCount<\/span>-i<\/span>)<\/span>].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“clear remaining temps to nil in case it has been recycled”<\/span>
\n<\/span>nilOop<\/span> :=<\/strong> nilObj.
\nargumentCount<\/span>+<\/span>1<\/span>+<\/span>ReceiverIndex<\/strong><\/span> to:<\/span> tempCount<\/span>+<\/span>ReceiverIndex<\/strong><\/span> do:<\/span>
\n[:<\/span>i<\/span> |<\/span> self<\/span> longAt:<\/span> where<\/span> +<\/span> (<\/span>i<\/span> <<<\/span> ShiftForWord<\/strong><\/span>)<\/span> put:<\/span> nilOop<\/span>].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>self<\/span> pop:<\/span> argumentCount <\/span>+<\/span> 1<\/span>.
\nreclaimableContextCount <\/span>:=<\/strong> reclaimableContextCount <\/span>+<\/span> 1<\/span>.
\n<\/span>self<\/span> newActiveContext:<\/span> newContext<\/span><\/p>\n

The variable reclaimableContextCount<\/span> counts how many contexts have been allocated that are not referenced by other objects and so may eagerly be reclaimed on return. Whenever thisContext is referenced or a block created reclaimableContextCount<\/span> gets set to zero. On return if reclaimableContextCount<\/span> is non-zero the returning context is reclaimed and reclaimableContextCount is decremented.<\/span><\/p>\n

 <\/p>\n

Again in a naive implementation p<\/span>ushing an object on the stack involves a store check. David Ungar’s Berkeley Smalltalk nilled out the stack slot when popping off an entry so that a push would only have to increase the reference count of the object pushed instead of also decrementing the count of the object overwritten. The Squeak VM uses a generational collector so there is no reference counting but it does need to make the context a root if it is old (in newActiveContext:<\/span>) to avoid the store-check on every push. It also carefully protects against access beyond the stack pointer through checks in the at: and at:put: primitives so that allocateOrRecycleContext:<\/span> does not have to initialize the stack with nils.<\/span><\/p>\n

 <\/p>\n

But these are all desperate attempts at mitigating the cost of a structure which for the most part is used in last-in, first-out (LIFO) order and only occasionally used to do the cool stuff we love it for. So here’s my evolution of <\/span>Peter Deutsch’s and Allan Schiffman’s original scheme<\/a> for having one’s cake and eating it too, for providing the illusion of ever-present contexts while only creating them when necessary. This is the fourth variant I’ve come up with, a hybrid of my earlier schemes and Peter and Allan’s, and like any hybrid it is vigourous and healthy \ud83d\ude42<\/span> What’s really different about my scheme, unlike Peter and Allan’s, is that contexts don’t get divorced when you send them a message, a cryptic comment I’ll explain presently.<\/p>\n

Stack Organization<\/h2>\n

The basic idea is to organize method activations using a stack discipline and to allow these to be accessed through contexts. The stack discipline is no different to that in conventonal language implementations. Outgoing arguments get pushed on the stack and on activation a frame is built immediately following the arguments which it references via the stack or frame pointer. On return the frame is popped off the stack and the stack pointer and frame pointer revert to referencing the caller frame; no different to stack management in e.g. Pascal or C. The wrinkle is in allowing context objects to be created and manipulated as if they were conventional contexts even though they are stand-ins for underlying stack frames.<\/span><\/p>\n

 <\/p>\n

Let’s look at some activation\/return sequences to understand it properly. Here’s a stack which has some arguments for a send pushed on it by some already active method, it is about to send + in DateAndTime <\/span>today<\/span> +<\/span> (Duration <\/span>weeks:<\/span> 1<\/span>).<\/span><\/p>\n

 <\/p>\n

\"\"
\nHere’s the DateAndTime>>+ method:<\/span><\/p>\n

 <\/p>\n

DateAndTime<\/em><\/span> methods for ansi protocol<\/em><\/span>
\n<\/span>+<\/strong> operand<\/span>
\n<\/span>“operand conforms to protocol Duration”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>|<\/span> ticks<\/span> |<\/span>
\n<\/span>ticks<\/span> :=<\/strong> self<\/span> ticks<\/span> +<\/span> (<\/span>operand<\/span> asDuration<\/span> ticks<\/span>) .<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>^<\/span> self<\/span> class<\/span> basicNew<\/span>
\n<\/span>ticks:<\/span> ticks<\/span>
\n<\/span>offset:<\/span> self<\/span> offset<\/span>;
\n<\/span>yourself<\/span><\/p>\n

When the message is sent the intetpreter looks up #+ in dateAndTime and finds the method. To build the frame for the method the interpreter pushes its current instruction pointer and frame pointer, saving them for the eventual return, then pushes the method, a flag word and a slot to hold the frame’s context if it ever needs one. Finally it pushes the receiver (again) and initializes temporaries (in this case just “ticks”) to nil.<\/span><\/p>\n

 <\/p>\n

\"\"<\/p>\n

all of which is done by the following method<\/p>\n

StackInterpreter methods for message sending<\/em>
\ninternalActivateNewMethod<\/strong>
\n<\/span>|<\/span> methodHeader<\/span> numTemps<\/span> rcvr<\/span> errorCode<\/span> |<\/span>
\n<inline: <\/span>true<\/span>><\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>methodHeader<\/span> :=<\/strong> self<\/span> headerOf:<\/span> newMethod.
\n<\/span>numTemps<\/span> :=<\/strong> self<\/span> tempCountOfMethodHeader:<\/span> methodHeader<\/span>.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>rcvr<\/span> :=<\/strong> self<\/span> internalStackValue:<\/span> argumentCount. <\/span>“could new rcvr be set at point of send?”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>self<\/span> internalPush:<\/span> localIP.
\n<\/span>self<\/span> internalPush:<\/span> localFP.
\nlocalFP <\/span>:=<\/strong> localSP.
\n<\/span>self<\/span> internalPush:<\/span> newMethod.
\nmethod <\/span>:=<\/strong> newMethod.
\n<\/span>self<\/span> internalPush:<\/span> (<\/span>self<\/span>
\n<\/span>encodeFrameFieldHasContext:<\/span> false<\/span>
\n<\/span>isBlock:<\/span> false<\/span>
\n<\/span>numArgs:<\/span> (<\/span>self<\/span> argumentCountOfMethodHeader:<\/span> methodHeader<\/span>)<\/span>).
\n<\/span>self<\/span> internalPush:<\/span> nilObj. <\/span>“FxThisContext field”<\/span>
\n<\/span>self<\/span> internalPush:<\/span> rcvr<\/span>.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“Initialize temps…”<\/span>
\nargumentCount <\/span>+<\/span> 1<\/span> to:<\/span> numTemps<\/span> do:<\/span>
\n[:<\/span>i<\/span> |<\/span> self<\/span> internalPush:<\/span> nilObj].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“-1 to account for pre-increment in fetchNextBytecode”<\/span>
\nlocalIP <\/span>:=<\/strong> self<\/span> pointerForOop:<\/span> (<\/span>self<\/span> initialPCForHeader:<\/span> methodHeader<\/span> method:<\/span> newMethod) <\/span>–<\/span> 1<\/span>
\n<\/span>
\nThe flag word, tells the interpreter three things, how many arguments the method has, whether the context field is valid or not and whether the frame is a method or block activation.<\/p>\n

Each of these fields is a single byte. The interpreter uses the args field to decide where to find a temporary variable. The bytecode set uses push\/Store\/StorePopTemporary bytecodes to access both arguments and temporaries since in a context the arguments and temporaries are adjacent. But in this stack organization the arguments are at the top of the frame and the temporaries below, so the argument count determines where to find temporaries and hence having fast access to the argument count is essential to access arguments and temporaries with acceptable speed:
\n
\n<\/span>StackInterpreter methods for frame access<\/em>
\nframeNumArgs:<\/strong> theFP<\/span>
\n<\/span>“See encodeFrameFieldHasContext:numArgs:”<\/span>
\n<inline: <\/span>true<\/span>>
\n<var: <\/span>#theFP<\/span> type: <\/span>#’char *’<\/span>>
\n<\/span>^<\/span>stackPages <\/span>byteAt:<\/span> theFP<\/span> +<\/span> FoxFrameFlags<\/strong><\/span> +<\/span> 1<\/span><\/p>\n

 <\/p>\n

StackInterpreter methods for internal interpreter access<\/em>
\ntemporary:<\/strong> offset<\/span> in:<\/strong> theFP<\/span>
\n<\/span>“See StackInterpreter class>>initializeFrameIndices”<\/span>
\n<\/span>|<\/span> frameNumArgs<\/span> |<\/span>
\n<inline: <\/span>true<\/span>>
\n<var: <\/span>#theFP<\/span> type: <\/span>#’char *’<\/span>>
\n<\/span>^<\/span>offset<\/span> <<\/span> (<\/span>frameNumArgs<\/span> :=<\/strong> self<\/span> frameNumArgs:<\/span> theFP<\/span>)
\n<\/span>ifTrue:<\/span> [stackPages <\/span>longAt:<\/span> theFP<\/span> +<\/span> FoxCallerSavedIP<\/strong><\/span> +<\/span> (<\/span>(<\/span>frameNumArgs<\/span> –<\/span> offset<\/span>)<\/span> *<\/span> BytesPerWord<\/strong><\/span>)<\/span>]
\n<\/span>ifFalse:<\/span> [stackPages <\/span>longAt:<\/span> theFP<\/span> +<\/span> FoxReceiver<\/strong><\/span> –<\/span> BytesPerWord<\/strong><\/span> +<\/span> (<\/span>(<\/span>frameNumArgs<\/span> –<\/span> offset<\/span>)<\/span> *<\/span> BytesPerWord<\/strong><\/span>)<\/span>]<\/span>
\n<\/strong><\/span>
\n<\/span>internalPush:<\/strong> object<\/span>
\n<\/span>“In the StackInterpreter stacks grow down.”<\/span>
\nstackPages <\/span>longAtPointer:<\/span> (localSP <\/span>:=<\/strong> localSP <\/span>–<\/span> BytesPerWord<\/strong><\/span>) <\/span>put:<\/span> object<\/span><\/p>\n

 <\/p>\n

StackInterpreter methods for stack bytecodes<\/em>
\n<\/span>pushTemporaryVariable:<\/strong> temporaryIndex<\/span>
\n<\/span>self<\/span> internalPush:<\/span> (<\/span>self<\/span> temporary:<\/span> temporaryIndex<\/span> in:<\/span> localFP)<\/span><\/p>\n

 <\/p>\n

pushTemporaryVariableBytecode<\/strong>
\n<expandCases>
\n<\/span>self<\/span> fetchNextBytecode<\/span>.
\n<\/span>“this bytecode will be expanded so that refs to currentBytecode below will be constant”<\/span>
\n<\/span>self<\/span> pushTemporaryVariable:<\/span> (currentBytecode <\/span>bitAnd:<\/span> 16rF<\/span>)
\n<\/span>
\nThe receiver is pushed also, partly for reasons of efficiency and, as we’ll see later, to support blocks. Pushing the receiver after the context field allows the interpreter to find the receiver at a known offset relative to the frame pointer, avoiding having to fetch frameNumArgs for instance variable access:<\/span>
\n
\n<\/span>StackInterpreter methods for frame access<\/em>
\n<\/span>frameReceiver:<\/strong> theFP<\/span>
\n<inline: <\/span>true<\/span>>
\n<var: <\/span>#theFP<\/span> type: <\/span>#’char *’<\/span>>
\n<\/span>^<\/span>stackPages <\/span>longAt:<\/span> theFP<\/span> +<\/span> FoxReceiver
\n<\/strong><\/span>
\n<\/span>StackInterpreter methods for stack bytecodes
\n<\/em>pushReceiverVariable:<\/strong> fieldIndex<\/span>
\n<\/span>self<\/span> internalPush:<\/span> (<\/span>self<\/span> fetchPointer:<\/span> fieldIndex<\/span> ofObject:<\/span> self<\/span> receiver<\/span>)
\n<\/span>
\n<\/strong><\/span>pushReceiverVariableBytecode<\/strong>
\n<expandCases>
\n<\/span>self<\/span> fetchNextBytecode<\/span>.
\n<\/span>“this bytecode will be expanded so that refs to currentBytecode below will be constant”<\/span>
\n<\/span>self<\/span> pushReceiverVariable:<\/span> (currentBytecode <\/span>bitAnd:<\/span> 16rF<\/span>)<\/span><\/p>\n

 <\/p>\n

We arrange that stacks grow down because in the JIT they definitely will. Call, return, push and pop instructions on CISC processors (notably x86\/IA32) define that stacks grow downwards, and the JIT will reuse much of the StackInterpreter’s machinery. Whenever I talk about a frame being above another one I mean it is later, actually at a lower address, but logically above, towards the head frame and away from the base frame; the “hottest” element on the stack is still called the top of stack.<\/span><\/p>\n

 <\/p>\n

Continuing with the execution once DateAndTime>>+ has pushed self (12 January 2009) it is ready to send ticks:<\/span><\/p>\n

 <\/p>\n

\"\"<\/p>\n

The pushed 12 January 2009 becomes the receiver of the new activation of DateAndTime>>#ticks. The saved instruction pointer is the pointer to the bytecode following the send of ticks. The saved frame pointer is the frame pointer for the DateAndTime>>#+ frame, then comes the DateAndTime>>#ticks method, a flag word indicating no arguments, an invalid context field and the 12 January 2009 receiver:<\/p>\n

\"\"<\/p>\n

The ticks method will eventually compute #(2454844 0 0)<\/span><\/p>\n

 <\/p>\n

DateAndTime<\/em><\/span> methods for private<\/em><\/span>
\n<\/span>ticks<\/strong>
\n<\/span>“Private – answer an array with our instance variables. Assumed to be UTC “<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>^<\/span> Array <\/span>with:<\/span> jdn <\/span>with:<\/span> seconds <\/span>with:<\/span> nanos<\/span><\/p>\n

Its return bytecode dismantles the frame, assigning the frame pointer to the stack pointer, popping off the saved frame pointer into the frame pointer, the caller’s saved ip into the instruction pointer, removing the arguments, and pushing the result:<\/span><\/p>\n

 <\/p>\n

\"\"<\/p>\n

which is done by the following method:
\ncommonCallerReturn<\/strong>
\n<\/span>“Return to the previous context\/frame (sender for method activations, caller for block activations).”<\/span>
\n<\/span><sharedCodeNamed: <\/span>‘commonCallerReturn’<\/span><\/span> inCase: <\/span>125<\/span>> <\/span>“returnTopFromBlock”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0localIP <\/span>:=<\/strong> self<\/span> frameCallerSavedIP:<\/span> localFP.
\nlocalSP <\/span>:=<\/strong> localFP <\/span>+<\/span> (<\/span>self<\/span> frameStackedReceiverOffset:<\/span> localFP).
\nlocalFP <\/span>:=\u00c2\u00a0<\/strong>\u00c2\u00a0<\/span>self<\/span>\u00c2\u00a0frameCallerFP:<\/span>\u00c2\u00a0localFP.
\nstackPages <\/span>longAt:<\/span> localSP <\/span>put:<\/span> localReturnValue.
\n<\/span>self<\/span> fetchNextBytecode<\/span>.
\nmethod <\/span>:=<\/strong> self<\/span> frameMethod:<\/span> localFP<\/span><\/p>\n

and the bytecode after the send of #ticks in DateAndTime>>#+ pops and stores the result into the ticks temporary, leaving us where we started but with ticks holding self<\/span> ticks<\/span>. Look ma, no contexts.<\/p>\n

\"\"<\/p>\n

Context to Stack Mapping<\/h2>\n

Let’s add closures to the mix so we can see contexts related to stack frames. A closure has an explicit reference to its enclosing context, which in our new scheme has to be mapped to a stack frame. Let’s evaluate<\/p>\n

‘Hi!’ detect: [:char| ‘!?’ includes: char] ifNone: [^#unemphatic]<\/p>\n

Here’s Collection>>#detect:ifNone:<\/p>\n

Collection methods for enumerating<\/em>
\ndetect:<\/strong> aBlock<\/span> ifNone:<\/strong> exceptionBlock<\/span>
\n<\/span>“Evaluate aBlock with each of the receiver’s elements as the argument.
\nAnswer the first element for which aBlock evaluates to true. If none
\nevaluate to true, then evaluate the argument, exceptionBlock.”<\/span>
\n<\/span>self<\/span> do:<\/span> [:<\/span>each<\/span> |<\/span> (<\/span>aBlock<\/span> value:<\/span> each<\/span>)<\/span> ifTrue:<\/span> [<\/span>^<\/span> each<\/span>]<\/span>].
\n<\/span>^<\/span> exceptionBlock<\/span> value<\/span><\/p>\n

On activation of Collection>>#detect:ifNone: the top frame on the stack looks like this<\/p>\n

\"\"<\/p>\n

The <\/span>[:<\/span>each<\/span> |<\/span> (<\/span>aBlock<\/span> value:<\/span> each<\/span>)<\/span> ifTrue:<\/span> [<\/span>^<\/span> each<\/span>]<\/span>] needs an <\/span>outerContext but it is executing within the frame activation of Collection>>#<\/span>detect:ifNone:. So when the block is created we also create a context that is a <\/span>proxy<\/a> for the frame (a better reference is <\/span>here<\/a>). If the block refers to self or an instance variable it needs to get at the receiver of the outerContext and if it executes the uparrow-return it must return from the Collection>>#<\/span>detect:ifNone: frame.<\/span><\/p>\n

 <\/p>\n

\"\"<\/p>\n

 <\/p>\n

To avoid chaos we need a one-to-one relationship between frames and contexts; hence the flag in the frame which ensures we only create one context for a frame. In this implementation we say that a frame is married to a context, and there’s no polygamy allowed. Given that a context could be referenced long after its frame exits we also have to detect if a context has been <\/span>widowed<\/a>, and convert it into a stable, but returned-from context. As we’ll see frames and contexts can get divorced (although that’s fatal for the frame) and contexts can re-marry, but frames only marry once if at all; clearly contexts are female, and frames are rather frail males; no <\/span>widowers<\/a> here.<\/span><\/p>\n

To implement non-local return correctly we must be able to determine if a context is single (a normal heap context, not associated with a frame), married or widowed, and, if married, to locate its spouse frame.<\/span><\/p>\n

 <\/p>\n

At the least we need a pointer from the context to its spouse. For this we use the sender field. The sender field of a context is always either another context or nil (ignoring wilful and inevitably fatal abuse by the programmer; you <\/span>can<\/em><\/span> assign a Point, or any other object, to the sender of thisContext but it’ll end your session). So we mark married contexts by storing the frame pointer of their spouse frame with the SmallInteger tag bit set in the sender field. Frames are always word-aligned so frame pointer least significant bits are always zero. <\/span><\/p>\n

 <\/p>\n

StackInterpreter methods for frame access<\/em><\/span>
\n<\/span>isMarriedOrWidowedContext:<\/strong> aContext<\/span>
\n<\/span>^self<\/span> isIntegerObject:<\/span> (<\/span>self<\/span> fetchPointer:<\/span> SenderIndex<\/strong><\/span> ofObject:<\/span> aContext<\/span>)<\/span><\/p>\n

 <\/p>\n

ensureFrameIsMarried:<\/strong> theFP<\/span>
\n<inline: <\/span>true<\/span>>
\n<var: <\/span>#theFP<\/span> type: <\/span>#’char *’<\/span>>
\n(<\/span>self<\/span> frameHasContext:<\/span> theFP<\/span>) <\/span>ifTrue:<\/span>
\n[<\/span>^self<\/span> frameContext:<\/span> theFP<\/span>].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>^self<\/span> marryFrame:<\/span> theFP<\/span>
\n<\/span>
\n<\/span>marryFrame:<\/strong> theFP<\/span>
\n<\/span>“Marry an unmarried frame. This means creating a spouse context
\ninitialized with a subset of the frame’s state (state through the last argument)
\nthat references the frame.”<\/span>
\n<\/span>|<\/span> theContext<\/span> methodHeader<\/span> byteSize<\/span> tempCount<\/span> closureOrNil<\/span> |<\/span>
\n<inline: <\/span>false<\/span>>
\n<var: <\/span>#theFP<\/span> type: <\/span>#’char *’<\/span>>
\n<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> frameHasContext:<\/span> theFP<\/span>) <\/span>not<\/span>.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>methodHeader<\/span> :=<\/strong> self<\/span> headerOf:<\/span> (<\/span>self<\/span> frameMethod:<\/span> theFP<\/span>).<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“This phrase is merely determining how much of the stack to initialize the context with.
\nIt is a lot of work for dubious benefit. Perhaps blocks could encode their num temps in frame flags.”<\/span>
\n(<\/span>self<\/span> frameIsBlockActivation:<\/span> theFP<\/span>)
\n<\/span>ifTrue:<\/span> [<\/span>|<\/span> numBlockArgs<\/span> |<\/span>
\n<\/span>numBlockArgs<\/span> :=<\/strong> self<\/span> frameNumArgs:<\/span> theFP<\/span>.
\n<\/span>closureOrNil<\/span> :=<\/strong> self<\/span> pushedReceiverOrClosureOfFrame:<\/span> theFP<\/span>.
\n<\/span>tempCount<\/span> :=<\/strong> numBlockArgs<\/span> +<\/span>(<\/span>self<\/span> fetchWordLengthOf:<\/span> closureOrNil<\/span>)<\/span> –<\/span> ClosureFirstCopiedValueIndex<\/strong><\/span>]
\n<\/span>ifFalse:<\/span> [<\/span>closureOrNil<\/span> :=<\/strong> nilObj.
\n<\/span>tempCount<\/span> :=<\/strong> self<\/span> tempCountOfMethodHeader:<\/span> methodHeader<\/span>].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>byteSize<\/span> :=<\/strong> (<\/span>methodHeader<\/span> bitAnd:<\/span> LargeContextBit<\/strong><\/span>) <\/span>~=<\/span> 0<\/span>
\n<\/span>ifTrue:<\/span> [<\/span>LargeContextSize<\/strong><\/span>]
\n<\/span>ifFalse:<\/span> [<\/span>SmallContextSize<\/strong><\/span>].
\n<\/span>theContext<\/span> :=<\/strong> self<\/span> eeInstantiateContext:<\/span> (<\/span>self<\/span> splObj:<\/span> ClassMethodContext<\/strong><\/span>) <\/span>sizeInBytes:<\/span> byteSize<\/span>.
\n<\/span>“Mark context as married by setting its sender to the frame pointer plus SmallInteger
\ntags and the InstructionPointer to the saved fp (which ensures correct alignment
\nw.r.t. the frame when we check for validity)”<\/span>
\n<\/span>self<\/span> storePointerUnchecked:<\/span> SenderIndex<\/strong><\/span>
\n<\/span>ofObject:<\/span> theContext<\/span>
\n<\/span>withValue:<\/span> (<\/span>self<\/span> withSmallIntegerTags:<\/span> theFP<\/span>).
\n<\/span>self<\/span> storePointerUnchecked:<\/span> InstructionPointerIndex<\/strong><\/span>
\n<\/span>ofObject:<\/span> theContext<\/span>
\n<\/span>withValue:<\/span> (<\/span>self<\/span> withSmallIntegerTags:<\/span> (<\/span>self<\/span> frameCallerFP:<\/span> theFP<\/span>)<\/span>).
\n<\/span>self<\/span> storePointerUnchecked:<\/span> StackPointerIndex<\/strong><\/span>
\n<\/span>ofObject:<\/span> theContext<\/span>
\n<\/span>withValue:<\/span> (<\/span>self<\/span> integerObjectOf:<\/span> tempCount<\/span>).
\n<\/span>self<\/span> storePointerUnchecked:<\/span> MethodIndex<\/strong><\/span>
\n<\/span>ofObject:<\/span> theContext<\/span>
\n<\/span>withValue:<\/span> (<\/span>self<\/span> frameMethod:<\/span> theFP<\/span>).
\n<\/span>self<\/span> storePointerUnchecked:<\/span> ClosureIndex<\/strong><\/span> ofObject:<\/span> theContext<\/span> withValue:<\/span> closureOrNil<\/span>.
\n<\/span>self<\/span> storePointerUnchecked:<\/span> ReceiverIndex<\/strong><\/span>
\n<\/span>ofObject:<\/span> theContext<\/span>
\n<\/span>withValue:<\/span> (<\/span>self<\/span> frameReceiver:<\/span> theFP<\/span>).
\n<\/span>1<\/span> to:<\/span> tempCount<\/span> do:<\/span>
\n[:<\/span>i<\/span>|<\/span>
\n<\/span>self<\/span> storePointerUnchecked:<\/span> ReceiverIndex<\/strong><\/span> +<\/span> i<\/span>
\n<\/span>ofObject:<\/span> theContext<\/span>
\n<\/span>withValue:<\/span> (<\/span>self<\/span> temporary:<\/span> i<\/span> –<\/span> 1<\/span> in:<\/span> theFP<\/span>)<\/span>].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0stackPages <\/span>longAt:<\/span> theFP<\/span> +<\/span> FoxThisContext<\/strong><\/span> put:<\/span> theContext<\/span>.
\nstackPages <\/span>byteAt:<\/span> theFP<\/span> +<\/span> FoxFrameFlags<\/strong><\/span> +<\/span> 2<\/span> put:<\/span> 1<\/span>.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> frameHasContext:<\/span> theFP<\/span>).
\n<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> frameOfMarriedContext:<\/span> theContext<\/span>) <\/span>==<\/span> theFP<\/span>.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>^<\/span>theContext<\/span>
\n<\/span>
\nI think marryFrame: contains a bug in that it copies all temporaries into the spouse context but it needs only to copy the receiver and arguments. But that’s how the code stands today. Mea culpa.<\/span><\/p>\n

 <\/p>\n

Before we delve into the details of divorce and widowhood, and how we hide all this matrimonial activity from Smalltalk let’s finish activating the block within Collection>>#<\/span>detect:ifNone:. Collection>>#<\/span>detect:ifNone: sends do: and in this case SequenceableCollection>>#do: will activate the block:<\/span><\/p>\n

 <\/p>\n

SequenceableCollection methods for enumerating<\/em><\/span>
\n<\/span>do:<\/strong> aBlock<\/span>
\n<\/span>“Refer to the comment in Collection>>do:.”<\/span>
\n<\/span>1<\/span> to:<\/span> self<\/span> size<\/span> do:<\/span>
\n[:<\/span>index<\/span> |<\/span> aBlock<\/span> value:<\/span> (<\/span>self<\/span> at:<\/span> index<\/span>)<\/span>]<\/span><\/p>\n

The BlockClosure>>value[:value:…] primitives create a frame for the block, setting the “is block” flag, push the method and receiver in the outerContext and push any copied values.<\/span><\/p>\n

 <\/p>\n

\"\"
\n
\nIn the block activation the receiver of the value: message, the [] in <\/span>detect:ifNone: that do: pushed on the stack, is not the receiver (‘Hi’) of <\/span>detect:ifNone:. If we need to marry a block activation then we can find its closureOrNil on the stack in the same position as the receiver for normal sends. But as far as accessing self and its instance variables blocks and methods are the same; the field following the context field is always the receiver of the home method activation.<\/span><\/p>\n

 <\/p>\n

StackInterpreter methods for control primitives<\/em><\/span>
\n<\/span>activateNewClosureMethod:<\/strong> blockClosure<\/span> numArgs:<\/strong> numArgs<\/span>
\n<\/span>“Similar to activateNewMethod but for Closure and newMethod.”<\/span>
\n<\/span>|<\/span> numCopied<\/span> outerContext<\/span> theMethod<\/span> closureIP<\/span> |<\/span>
\n<inline: <\/span>true<\/span>>
\n<\/span>outerContext<\/span> :=<\/strong> self<\/span> fetchPointer:<\/span> ClosureOuterContextIndex<\/strong><\/span> ofObject:<\/span> blockClosure<\/span>.
\n<\/span>numCopied<\/span> :=<\/strong> (<\/span>self<\/span> fetchWordLengthOf:<\/span> blockClosure<\/span>) <\/span>–<\/span> ClosureFirstCopiedValueIndex<\/strong><\/span>.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>theMethod<\/span> :=<\/strong> self<\/span> fetchPointer:<\/span> MethodIndex<\/strong><\/span> ofObject:<\/span> outerContext<\/span>.
\n<\/span>self<\/span> push:<\/span> instructionPointer.
\n<\/span>self<\/span> push:<\/span> framePointer.
\nframePointer <\/span>:=<\/strong> stackPointer.
\n<\/span>self<\/span> push:<\/span> theMethod<\/span>.
\n<\/span>self<\/span> push:<\/span> (<\/span>self<\/span> encodeFrameFieldHasContext:<\/span> false<\/span> isBlock:<\/span> true<\/span> numArgs:<\/span> numArgs<\/span>).
\n<\/span>self<\/span> push:<\/span> nilObj. <\/span>“FxThisContext field”<\/span>
\n<\/span>self<\/span> push:<\/span> (<\/span>self<\/span> fetchPointer:<\/span> ReceiverIndex<\/strong><\/span> ofObject:<\/span> outerContext<\/span>).<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“Copy the copied values…”<\/span>
\n<\/span>0<\/span> to:<\/span> numCopied<\/span> –<\/span> 1<\/span> do:<\/span>
\n[:<\/span>i<\/span>|<\/span>
\n<\/span>self<\/span> push:<\/span> (<\/span>self<\/span>
\n<\/span>fetchPointer:<\/span> i<\/span> +<\/span> ClosureFirstCopiedValueIndex<\/strong><\/span>
\n<\/span>ofObject:<\/span> blockClosure<\/span>)<\/span>].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> frameIsBlockActivation:<\/span> framePointer).
\n<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> frameHasContext:<\/span> framePointer) <\/span>not<\/span>.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“The initial instructions in the block nil-out remaining temps.”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“the instruction pointer is a pointer variable equal to
\nmethod oop + ip + BaseHeaderSize
\n-1 for 0-based addressing of fetchByte
\n-1 because it gets incremented BEFORE fetching currentByte”<\/span>
\n<\/span>closureIP<\/span> :=<\/strong> self<\/span> quickFetchInteger:<\/span> ClosureStartPCIndex<\/strong><\/span> ofObject:<\/span> blockClosure<\/span>.
\ninstructionPointer <\/span>:=<\/strong> theMethod<\/span> +<\/span> closureIP<\/span> +<\/span> BaseHeaderSize<\/strong><\/span> –<\/span> 2<\/span>.
\nmethod <\/span>:=<\/strong> theMethod<\/span><\/p>\n

 <\/p>\n

Stack Pages<\/h2>\n

So far I’ve left out how the stack is shared amongst Smalltalk’s light-weight processes, and how we maintain Smalltalk’s immunity from stack overflow. In a context-based Smalltalk the only limit to the depth of a call chain is available heap memory in which to store contexts. In a blue-book Smalltalk implementation infinite recursion manifests itself as a low-space condition. Smalltalk provides light-weight processes, which are simply chains of contexts, and applications like Croquet can create thousands a second and have hundreds active at any one time. Creating a new process involves creating a process object and a context or two. In using a stack we need to both share it effectively between processes and keep process creation cheap.<\/span><\/p>\n

Pater Deutsch’s solution is to divide up the stack into pages, each page capable of holding enough contexts so that we’re not switching stack pages all the time and few enough such that moving all the frames on the page into the heap in the form of contexts so the page can be reused doesn’t take too long. As we’ll see with the JIT this does introduce some complications calling run-time routines on the C stack, but on balance it’s an excellent solution and I’m sticking with it. So the stack is in fact composed of pages of a fixed size determined statically and quantity determined at start-up. I’m currently using 1024 byte stack pages, which have room for about 20 “average” activations, which is a little tight and so will probably move to 2048 byte pages when I tune the JIT. Current;y inside Qwaq we’re using 192 stack pages.<\/p>\n

 <\/p>\n

Running on a stack page of a small size introduces three complications, stack page overflow, stack page underflow, and linking stack pages together. We handle overflow by checking a stackLimit on every frame build. So in full detail internalActivateNewMethod is as follows, with the added complications of passing any primitive error code and of checking for stack overflow, which is right at the end of the method:
\n<\/span>
\nStackInterpreter methods for message sending<\/em>
\n<\/span>internalActivateNewMethod<\/strong>
\n<\/span>|<\/span> methodHeader<\/span> numTemps<\/span> rcvr<\/span> errorCode<\/span> |<\/span>
\n<inline: <\/span>true<\/span>><\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>methodHeader<\/span> :=<\/strong> self<\/span> headerOf:<\/span> newMethod.
\n<\/span>numTemps<\/span> :=<\/strong> self<\/span> tempCountOfMethodHeader:<\/span> methodHeader<\/span>.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>rcvr<\/span> :=<\/strong> self<\/span> internalStackValue:<\/span> argumentCount. <\/span>“could new rcvr be set at point of send?”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>self<\/span> internalPush:<\/span> localIP.
\n<\/span>self<\/span> internalPush:<\/span> localFP.
\nlocalFP <\/span>:=<\/strong> localSP.
\n<\/span>self<\/span> internalPush:<\/span> newMethod.
\nmethod <\/span>:=<\/strong> newMethod.
\n<\/span>self<\/span> internalPush:<\/span> (<\/span>self<\/span>
\n<\/span>encodeFrameFieldHasContext:<\/span> false<\/span>
\n<\/span>isBlock:<\/span> false<\/span>
\n<\/span>numArgs:<\/span> (<\/span>self<\/span> argumentCountOfMethodHeader:<\/span> methodHeader<\/span>)<\/span>).
\n<\/span>self<\/span> internalPush:<\/span> nilObj. <\/span>“FxThisContext field”<\/span>
\n<\/span>self<\/span> internalPush:<\/span> rcvr<\/span>.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“Initialize temps…”<\/span>
\nargumentCount <\/span>+<\/span> 1<\/span> to:<\/span> numTemps<\/span> do:<\/span>
\n[:<\/span>i<\/span> |<\/span> self<\/span> internalPush:<\/span> nilObj].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“-1 to account for pre-increment in fetchNextBytecode”<\/span>
\nlocalIP <\/span>:=<\/strong> self<\/span> pointerForOop:<\/span> (<\/span>self<\/span> initialPCForHeader:<\/span> methodHeader<\/span> method:<\/span> newMethod) <\/span>–<\/span> 1<\/span>.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“Pass primitive error code to last temp if method receives it (indicated
\nby an initial long store temp bytecode). Protect against obsolete values
\nin primFailCode by checking that newMethod actually has a primitive?”<\/span>
\nprimFailCode <\/span>~=<\/span> 0<\/span> ifTrue:<\/span>
\n[<\/span>(<\/span>(<\/span>self<\/span> methodHeaderHasPrimitive:<\/span> methodHeader<\/span>)<\/span>
\n<\/span>and:<\/span> [<\/span>(self<\/span> byteAtPointer:<\/span> localIP <\/span>+<\/span> 1)<\/span> =<\/span> 129<\/span> “long store temp”<\/span>]<\/span>)<\/span> ifTrue:<\/span>
\n<\/span>[<\/span>errorCode<\/span> :=<\/strong> self<\/span> getErrorObjectFromPrimFailCode<\/span>.
\n<\/span>self<\/span> longAt:<\/span> localSP <\/span>put:<\/span> errorCode<\/span> “nil if primFailCode == 1, or primFailCode”<\/span>]<\/span>.
\nprimFailCode <\/span>:=<\/strong> 0<\/span>].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> frameNumArgs:<\/span> localFP) <\/span>==<\/span> argumentCount.
\n<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> frameIsBlockActivation:<\/span> localFP) <\/span>not<\/span>.
\n<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> frameHasContext:<\/span> localFP) <\/span>not<\/span>.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“Now check for stack overflow or an event (interrupt, must scavenge, etc)”<\/span>
\nlocalSP <\/span><<\/span> stackLimit <\/span>ifTrue:<\/span>
\n[<\/span>self<\/span> externalizeIPandSP<\/span>.
\n<\/span>self<\/span> stackOverflowOrEvent:<\/span> argumentCount <\/span>mayContextSwitch:<\/span> true<\/span>.
\n<\/span>self<\/span> internalizeIPandSP<\/span>]<\/span><\/p>\n

On overflow we must allocate a new stack page and continue execution there, linking the new bottom-most frame (its base frame) to the current frame. Likewise, return must deal with returning from a base frame and return from one stack frame to the next. We have a mechanism for referring to stack frames, married contexts, so to link a stack page’s base frame to the stack page beneath it we marry the top frame of the stack we’re leaving and store this in the base frame of the stack page we’re entering. We mark the new stack page’s base frame as such by giving it a null caller saved fp and use the caller saved ip field to hold the caller context, the spouse of the stack page beneath’s top frame:<\/span><\/p>\n

 <\/p>\n

\"\"<\/p>\n

 <\/p>\n

We have a linked list of StackPage objects, one for each page, that we use to keep stack pages in order of usage, along with free pages, referenced by a variable called the mostRecentlyUsedPage. Each StackPage keeps track of whether a stack page is in use (baseFP is non-null) and what part of the page is in use (from the first slot through to the headSP) and what the frames are in the page (the list from headFP chained through caller saved fp to the baseFP). The interpreter’s current stack page is called stackPage. On stack switch we load stackLimit from stackPage’s stackLimit. Peter cleverly realised that one can use the stackLimit check to cause the VM to break out of execution to process input events. The VM is set up to respond to potential input with an interrupt handler that sets the stackLimit to all ones (the highest possible address) so that the next stack overflow check will fail. We also check for stack overflow on backward branch so that we can break out of infinite loops:
\n<\/span>
\nStackInterpreter methods for jump bytecodes<\/em>
\n<\/span>longUnconditionalJump<\/strong>
\n<\/span>|<\/span> offset<\/span> |<\/span>
\n<\/span>offset<\/span> :=<\/strong> (<\/span>(<\/span>(<\/span>currentBytecode <\/span>bitAnd:<\/span> 7<\/span>)<\/span> –<\/span> 4<\/span>)<\/span> *<\/span> 256<\/span>) <\/span>+<\/span> self<\/span> fetchByte<\/span>.
\nlocalIP <\/span>:=<\/strong> localIP <\/span>+<\/span> offset<\/span>.
\n(<\/span>offset<\/span> <<\/span> 0<\/span> “backward jump means we’re in a loop; check for possible interrupts”<\/span>
\n<\/span>and:<\/span> [<\/span>localSP <\/span><<\/span> stackLimit<\/span>]<\/span>) <\/span>ifTrue:<\/span>
\n[<\/span>self<\/span> externalizeIPandSP<\/span>.
\n<\/span>self<\/span> checkForEventsMayContextSwitch:<\/span> true<\/span>.
\n<\/span>self<\/span> browserPluginReturnIfNeeded<\/span>.
\n<\/span>self<\/span> internalizeIPandSP<\/span>].
\n<\/span>self<\/span> fetchNextBytecode<\/span><\/p>\n

So stackOverflowOrEvent:mayContextSwitch: checks whether stackLimit differs from stackPage’s stack limit to see whether it should check for input and only switches to a new page if the stack pointer is below stackPage’s real stack limit.<\/span><\/p>\n

Of course on stack overflow we may find that there are no free stack pages, in which case the VM simply flushes all the frames
\non the least-recently used page to the heap in the form of contexts. First it ensures all frames on the page are married and then divorces them all, linking them through their sender fields just as if they were created by a context-only VM, and then reuses the page, mercilessly killing the frames there-on. If any other stack page had the freed stack page beneath it then that stack page’s base frame will find its saved caller context is single.<\/p>\n

So as execution proceeeds the stack zone holds the top frames of a number of recently executed processes, overflowing the contents of older stack pages to the heap as contexts. The only possible references into that page are from contexts which have all been divorced, so all references remain valid, except now they’re to single contexts instead of married ones.<\/p>\n

 <\/p>\n

When the system snapshots the image all stack frames are divorced and so the image file contains only single contexts, allowing the image file to be run by a context-only VM or started up on a VM with a different number of stack pages at different addresses. Here’s the divorce code:
\n<\/span>
\nStackInterpreter methods for image save\/restore<\/em>
\n<\/span>snapshot:<\/strong> embedded<\/span>
\n<\/span>“update state of active context”<\/span>
\n<\/span>|<\/span> activeContext<\/span> activeProc<\/span> dataSize<\/span> rcvr<\/span> setMacType<\/span> stackIndex<\/span> |<\/span>
\n<var: <\/span>#setMacType<\/span> type: <\/span>‘void *’<\/span><\/span>><\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“Need to convert all frames into contexts since the snapshot file only holds objects.”<\/span>
\n<\/span>self<\/span> push:<\/span> instructionPointer.
\n<\/span>activeContext<\/span> :=<\/strong> self<\/span> divorceAllFrames<\/span>.
\n<\/span>self<\/span> pushRemappableOop:<\/span> activeContext<\/span>.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“update state of active process”<\/span>
\n…etc…
\n<\/span>
\nStackInterpreter methods for frame access<\/em>
\n<\/span>divorceAllFrames<\/strong>
\n<\/span>|<\/span> activeContext<\/span> |<\/span>
\n<inline: <\/span>false<\/span>>
\n<var: <\/span>#aPage<\/span> type: <\/span>#’StackPage *’<\/span>>
\n<\/span>self<\/span> externalWriteBackHeadFramePointers<\/span>.
\n<\/span>activeContext<\/span> :=<\/strong> self<\/span> ensureFrameIsMarried:<\/span> framePointer.
\n<\/span>0<\/span> to:<\/span> numStackPages <\/span>–<\/span> 1<\/span> do:<\/span>
\n[:<\/span>i<\/span>|<\/span> |<\/span> aPage<\/span> |<\/span>
\n<\/span>aPage<\/span> :=<\/strong> stackPages <\/span>stackPageAt:<\/span> i<\/span>.
\n<\/span>(<\/span>stackPages <\/span>isFree:<\/span> aPage<\/span>)<\/span> ifFalse:<\/span>
\n<\/span>[<\/span>self<\/span> divorceFramesIn:<\/span> aPage<\/span>]<\/span>].
\nstackPage <\/span>:=<\/strong> 0<\/span>.
\n<\/span>^<\/span>activeContext<\/span><\/p>\n

 <\/p>\n

divorceFramesIn:<\/strong> aStackPage<\/span>
\n<\/span>|<\/span> theFP<\/span> calleeFP<\/span> theSP<\/span> theIP<\/span> calleeContext<\/span> theContext<\/span> |<\/span>
\n<inline: <\/span>false<\/span>>
\n<var: <\/span>#aStackPage<\/span> type: <\/span>#’StackPage *’<\/span>>
\n<var: <\/span>#theFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#calleeFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#theSP<\/span> type: <\/span>#’char *’<\/span>><\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0statStackPageDivorce <\/span>:=<\/strong> statStackPageDivorce <\/span>+<\/span> 1<\/span>.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>theFP<\/span> :=<\/strong> aStackPage<\/span> headFP<\/span>.
\n<\/span>theSP<\/span> :=<\/strong> aStackPage<\/span> headSP<\/span>.
\n<\/span>theIP<\/span> :=<\/strong> stackPages <\/span>longAt:<\/span> theSP<\/span>.
\n<\/span>theSP<\/span> :=<\/strong> theSP<\/span> +<\/span> BytesPerWord<\/strong><\/span>. <\/span>“theSP points at hottest item on frame’s stack”<\/span>
\n<\/span>calleeContext<\/span> :=<\/strong> nil<\/span>.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0[<\/span>theContext<\/span> :=<\/strong> self<\/span> ensureFrameIsMarried:<\/span> theFP<\/span>.
\n<\/span>self<\/span> updateStateOfSpouseContextForFrame:<\/span> theFP<\/span> WithSP:<\/span> theSP<\/span>.
\n<\/span>self<\/span> storePointerUnchecked:<\/span> InstructionPointerIndex<\/strong><\/span>
\n<\/span>ofObject:<\/span> theContext<\/span>
\n<\/span>withValue:<\/span> (<\/span>self<\/span> contextInstructionPointerForFrame:<\/span> theFP<\/span> IP:<\/span> theIP<\/span>)<\/span>.
\n<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> frameReceiver:<\/span> theFP<\/span>)<\/span>
\n<\/span>==<\/span> (<\/span>self<\/span> fetchPointer:<\/span> ReceiverIndex<\/strong><\/span> ofObject:<\/span> theContext<\/span>)<\/span>.
\n<\/span>calleeContext<\/span> ~~<\/span> nil<\/span> ifTrue:<\/span>
\n<\/span>[<\/span>self<\/span> storePointer:<\/span> SenderIndex<\/strong><\/span>
\n<\/span>ofObject:<\/span> calleeContext<\/span>
\n<\/span>withValue:<\/span> theContext<\/span>]<\/span>.
\n<\/span>calleeContext<\/span> :=<\/strong> theContext<\/span>.
\n<\/span>calleeFP<\/span> :=<\/strong> theFP<\/span>.
\n<\/span>theIP<\/span> :=<\/strong> self<\/span> frameCallerContext:<\/span> theFP<\/span>. <\/span>“a.k.a. frameCallerIP:”<\/span>
\n<\/span>theFP<\/span> :=<\/strong> self<\/span> frameCallerFP:<\/span> theFP<\/span>.
\n<\/span>theFP<\/span> ~=<\/span> 0<\/span>] <\/span>whileTrue:<\/span>
\n[<\/span>“theSP points at stacked hottest item on frame’s stack”<\/span>
\n<\/span>theSP<\/span> :=<\/strong> self<\/span> frameCallerSP:<\/span> calleeFP<\/span>].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>self<\/span> storePointer:<\/span> SenderIndex<\/strong><\/span>
\n<\/span>ofObject:<\/span> theContext<\/span>
\n<\/span>withValue:<\/span> theIP<\/span>. <\/span>“The ip of the base frame is the caller context”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“The page is now free; mark it so.”<\/span>
\n<\/span>aStackPage<\/span> baseFP:<\/span> 0<\/span><\/p>\n

 <\/p>\n

updateStateOfSpouseContextForFrame:<\/strong> theFP<\/span> WithSP:<\/strong> theSP<\/span>
\n<\/span>“Update the frame’s spouse context with the frame’s current state except for the
\nsender and instruction pointer, which are used to mark the context as married.”<\/span>
\n<\/span>|<\/span> theContext<\/span> tempIndex<\/span> pointer<\/span> |<\/span>
\n<inline: <\/span>false<\/span>>
\n<var: <\/span>#theFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#theSP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#pointer<\/span> type: <\/span>#’char *’<\/span>>
\n<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> frameHasContext:<\/span> theFP<\/span>).
\n<\/span>theContext<\/span> :=<\/strong> self<\/span> frameContext:<\/span> theFP<\/span>.
\n<\/span>tempIndex<\/span> :=<\/strong> self<\/span> frameNumArgs:<\/span> theFP<\/span>.
\n<\/span>pointer<\/span> :=<\/strong> theFP<\/span> +<\/span> FoxReceiver<\/strong><\/span> –<\/span> BytesPerWord<\/strong><\/span>.
\n[<\/span>pointer<\/span> >=<\/span> theSP<\/span>] <\/span>whileTrue:<\/span>
\n[<\/span>tempIndex<\/span> :=<\/strong> tempIndex<\/span> +<\/span> 1<\/span>.
\n<\/span>self<\/span> storePointer:<\/span> ReceiverIndex<\/strong><\/span> +<\/span> tempIndex<\/span>
\n<\/span>ofObject:<\/span> theContext<\/span>
\n<\/span>withValue:<\/span> (<\/span>stackPages <\/span>longAt:<\/span> pointer<\/span>)<\/span>.
\n<\/span>pointer<\/span> :=<\/strong> pointer<\/span> –<\/span> BytesPerWord<\/strong><\/span>].
\n<\/span>self<\/span> storePointerUnchecked:<\/span> StackPointerIndex<\/strong><\/span>
\n<\/span>ofObject:<\/span> theContext<\/span>
\n<\/span>withValue:<\/span> (<\/span>self<\/span> integerObjectOf:<\/span> tempIndex<\/span>)<\/span><\/p>\n

 <\/p>\n

Widowhood<\/h2>\n

Given that contexts are objects they have indefinite extent; they can be stored in instance variables, typically indirectly from blocks that are stored in various places) and so outlive being returned from. For example here’s one way to create a widowed context for a block activation:<\/p>\n

| container |
\ncontainer := Array new: 1.
\n#(foo) do: [:ignored| container at: 1 put: thisContext].
\ncontainer<\/p>\n

Even simpler would be
\nObject methods for examples<\/em>
\nwidowedContext<\/strong>
\n<\/span>^thisContext<\/span><\/p>\n

At various times, for example whenever accessing the instance variables of contexts, or on return, we need to check whether a context is single, married or widowed and act accordingly. A single context will have a sender that is not a SmallInteger (recall isMarriedOrWidowedContext: above). A married or widowed context however may or or may not have outlived its spouse. Since the system starts up and snapshots with only single contexts we know that all encoded frame pointers in sender fields point into stack pages. We can easily derive the StackPage object for a stack page because each stack page is a power-of-two in size and all stack pages are contiguous. Once we have the StackPage we can find out if it is in use or not, and if the context’s spouse frame is in the live portion of the stack (between baseFP and headFP). If so, we can follow the frame pointer and examine the frame’s flags and context fields. But there is no guarantee that we’re looking at the actual frame. It may have been exited and overwritten by some other frame. So we must assume that the spouse frame pointer is potentially pointing at an arbitrary position in the stack.<\/p>\n

Note that we have to keep the current stackPage’s headFP and headSP up-to-date because the interpreter of course uses its own localFP and localSP (and, sigh, framePointer and stackPointer, the former being a clever performance hack that tediously causes lots of code duplication, one that the JIT can hopefully do without). writeBackHeadFramePointers and externalWriteBackHeadFramePointers assign stackPage headFP and headSP from localFP & localSP or framePointer and stackPointer respectively (see e.g. divorceAllFrames above).<\/p>\n

Because the stack and the heap are disjoint there is no overlap of caller saved fp and other fields on the stack (saved instruction pointers are also pointers but into method bytecodes). So by storing the spouse’s caller saved fp in the married context, a match implies the spouse frame pointer is to a frame at that position. If the frame has a context context matches then we know the two are married. If they’re not, the frame must have exited, and so we widow the context by converting it into a context that has been returned from, .e. we nil its sender and instruction pointer fields. Now you can see the bug in marryFrame above. The widowed context will have a valid method, receiver and arguments (arguments being read-only in Smalltalk) but shouldn’t hold onto the temporaries that existed at the time of its creation because they could be out-of-date. Alas Qwaq is too close to a release right now for me to dare fixing this; I’m going to wait a week or two. That a widowed context doesn’t hold onyto non-argument temporaries is, I believe (and fervently hope) the only visible difference between a pure context VM and a stack VM. I think its fair to expect that volatile state does disappear on return, and not holding onto volatile state is good for garbage collection. This change in semantics has never been complained about by the VisualWorks community when I introduced this scheme to VisualWorks in 1999. The only code I’ve ever seen affected by this was an exception report generator that used to generate its report after the exception handler had squirreled away the context and returned. The fix is either to generate the report in the exception handler or copy the context chain there-in.
\n
\nWith widowhood explained we can have a look at the full glory of return.<\/span><\/p>\n

 <\/p>\n

Return<\/h2>\n

As we’ve seen, most of the time send and return are considerably less complicated than in the context VM. Send is somewhat more complicated when there’s a stack overflow. Return is somewhat more complicated when there is a base return:<\/span><\/p>\n

 <\/p>\n

StackInterpreter methods for return bytecodes<\/em><\/span>
\n<\/span>commonReturn<\/strong>
\n<\/span>“Note: Assumed to be inlined into the dispatch loop.”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>|<\/span> closure<\/span> home<\/span> unwindContextOrNilOrZero<\/span> frameToReturnTo<\/span> contextToReturnTo<\/span> theFP<\/span> callerFP<\/span> newPage<\/span> |<\/span>
\n<var: <\/span>#frameToReturnTo<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#theFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#callerFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#newPage<\/span> type: <\/span>#’StackPage *’<\/span>>
\n<var: <\/span>#thePage<\/span> type: <\/span>#’StackPage *’<\/span>>
\n<sharedCodeNamed: <\/span>‘commonReturn’<\/span><\/span> inCase: <\/span>120<\/span>><\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“If this is a method simply return to the sender\/caller.”<\/span>
\n(<\/span>self<\/span> frameIsBlockActivation:<\/span> localFP) <\/span>ifFalse:<\/span>
\n[<\/span>^self<\/span> commonCallerReturn<\/span>].<\/span><\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0… non-local return code; here be beasties …<\/span><\/p>\n

 <\/p>\n

commonCallerReturn<\/strong>
\n<\/span>“Return to the previous context\/frame (sender for method activations, caller for block activations).”<\/span>
\n<\/span>|<\/span> callersFPOrNull<\/span> |<\/span>
\n<var: <\/span>#callersFPOrNull<\/span> type: <\/span>#’char *’<\/span>>
\n<sharedCodeNamed: <\/span>‘commonCallerReturn’<\/span><\/span> inCase: <\/span>125<\/span>> <\/span>“returnTopFromBlock”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>callersFPOrNull<\/span> :=<\/strong> self<\/span> frameCallerFP:<\/span> localFP.
\n<\/span>callersFPOrNull<\/span> ==<\/span> 0<\/span> “baseFrame”<\/span> ifTrue:<\/span>
\n[<\/span>self<\/span> assert:<\/span> localFP <\/span>=<\/span> stackPage <\/span>baseFP<\/span>.
\n<\/span>^self<\/span> baseReturn<\/span>].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0localIP <\/span>:=<\/strong> self<\/span> frameCallerSavedIP:<\/span> localFP.
\nlocalSP <\/span>:=<\/strong> localFP <\/span>+<\/span> (<\/span>self<\/span> frameStackedReceiverOffset:<\/span> localFP).
\nlocalFP <\/span>:=<\/strong> callersFPOrNull<\/span>.
\nstackPages <\/span>longAt:<\/span> localSP <\/span>put:<\/span> localReturnValue.
\n<\/span>self<\/span> fetchNextBytecode<\/span>.
\nmethod <\/span>:=<\/strong> self<\/span> frameMethod:<\/span> localFP<\/span><\/p>\n

 <\/p>\n

baseReturn<\/strong>
\n<\/span>|<\/span> contextToReturnTo<\/span> isContext<\/span> theFP<\/span> theSP<\/span> thePage<\/span> |<\/span>
\n<var: <\/span>#theFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#theSP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#thePage<\/span> type: <\/span>#’StackPage *’<\/span>>
\n<\/span>contextToReturnTo<\/span> :=<\/strong> self<\/span> frameCallerContext:<\/span> localFP.
\n<\/span>isContext<\/span> :=<\/strong> self<\/span> isContext:<\/span> contextToReturnTo<\/span>.
\n(<\/span>isContext<\/span>
\n<\/span>and:<\/span> [<\/span>self<\/span> isStillMarriedContext:<\/span> contextToReturnTo<\/span>]<\/span>)
\n<\/span>ifTrue:<\/span>
\n[<\/span>theFP<\/span> :=<\/strong> self<\/span> frameOfMarriedContext:<\/span> contextToReturnTo<\/span>.
\n<\/span>thePage<\/span> :=<\/strong> stackPages <\/span>stackPageFor:<\/span> theFP<\/span>.
\n<\/span>self<\/span> assert:<\/span> theFP<\/span> ==<\/span> thePage<\/span> headFP<\/span>.
\n<\/span>theSP<\/span> :=<\/strong> thePage<\/span> headSP<\/span>]
\n<\/span>ifFalse:<\/span>
\n[<\/span>(<\/span>isContext<\/span>
\n<\/span>and:<\/span> [<\/span>self<\/span> isIntegerObject:<\/span> (self<\/span> fetchPointer:<\/span> InstructionPointerIndex<\/strong><\/span> ofObject:<\/span> contextToReturnTo<\/span>)<\/span>]<\/span>)<\/span> ifFalse:<\/span>
\n<\/span>[<\/span>^self<\/span> internalCannotReturn:<\/span> localReturnValue<\/span>]<\/span>.
\n<\/span>thePage<\/span> :=<\/strong> self<\/span> makeBaseFrameFor:<\/span> contextToReturnTo<\/span>.
\n<\/span>theFP<\/span> :=<\/strong> thePage<\/span> headFP<\/span>.
\n<\/span>theSP<\/span> :=<\/strong> thePage<\/span> headSP<\/span>].
\nstackPages <\/span>freeStackPageNoAssert:<\/span> stackPage. <\/span>“for a short time invariant is violated; assert follows”<\/span>
\n<\/span>self<\/span> setStackPageAndLimit:<\/span> thePage<\/span>.
\n<\/span>self<\/span> assert:<\/span> (stackPages <\/span>stackPageFor:<\/span> theFP<\/span>) <\/span>==<\/span> stackPage.
\nlocalSP <\/span>:=<\/strong> theSP<\/span>.
\nlocalFP <\/span>:=<\/strong> theFP<\/span>.
\nmethod <\/span>:=<\/strong> self<\/span> frameMethod:<\/span> localFP.
\nlocalIP <\/span>:=<\/strong> self<\/span> pointerForOop:<\/span> self<\/span> internalStackTop<\/span>.
\n<\/span>self<\/span> internalStackTopPut:<\/span> localReturnValue.
\n<\/span>self<\/span> fetchNextBytecode<\/span>.
\n<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> checkIsStillMarriedContext:<\/span> contextToReturnTo<\/span> currentFP:<\/span> localFP)<\/span><\/p>\n

 <\/p>\n

But non-local return is <\/span>much<\/em><\/span> more complicated. What does non-local return do in a pure context VM? It walks the context chain from a block context until it finds the block context’s home context, checking for unwnd protect contexts along the way. If it doesn’t find the home context it sends cannotReturn: and if it finds an unwnd protect it sends aboutToReturn:through: and allows the image to run unwind-protect blocks itself, otherwise it simply returns from the home context. Using the stack, things are seriously more complicated.<\/span><\/p>\n

In the StackInterpreter non-local return occurs in some block activation (a frame) and returns from the block activation’s home context, which is some distance along the block activation’s closure’s outerContext chain (its lexical chain). The home context could be single, widowed or married. If married it could be a base frame whose caller could be single, widowed or married. If single we need to marry it to have a frame to resume execution in. If the home’s caller is married its spouse frame could be the head frame on its page or some interior frame. So we could be returning within a stack page or across stack pages or across stack pages and single contexts. First we have to walk this chain looking for unwind protects and the home context, then we have to do the return, freeing intervening stack pages. Complicated.<\/span><\/p>\n

So here it is. Read the comments and hopefully it’ll make sense.<\/p>\n

 <\/p>\n

StackInterpreter methods for return bytecodes<\/em><\/span>
\n<\/span>commonReturn<\/strong>
\n<\/span>“Note: Assumed to be inlined into the dispatch loop.”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>|<\/span> closure<\/span> home<\/span> unwindContextOrNilOrZero<\/span> frameToReturnTo<\/span> contextToReturnTo<\/span> theFP<\/span> callerFP<\/span> newPage<\/span> |<\/span>
\n<var: <\/span>#frameToReturnTo<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#theFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#callerFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#newPage<\/span> type: <\/span>#’StackPage *’<\/span>>
\n<var: <\/span>#thePage<\/span> type: <\/span>#’StackPage *’<\/span>>
\n<sharedCodeNamed: <\/span>‘commonReturn’<\/span><\/span> inCase: <\/span>120<\/span>><\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“If this is a method simply return to the sender\/caller.”<\/span>
\n(<\/span>self<\/span> frameIsBlockActivation:<\/span> localFP) <\/span>ifFalse:<\/span>
\n[<\/span>^self<\/span> commonCallerReturn<\/span>].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“Since this is a block activation the closure is on the stack above any args and the frame.”<\/span>
\n<\/span>closure<\/span> :=<\/strong> self<\/span> pushedReceiverOrClosureOfFrame:<\/span> localFP.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>home<\/span> :=<\/strong> nil<\/span>.
\n<\/span>“Walk the closure’s lexical chain to find the context or frame to return from (home).”<\/span>
\n[<\/span>closure<\/span> ~~<\/span> nilObj] <\/span>whileTrue:<\/span>
\n[<\/span>home<\/span> :=<\/strong> self<\/span> fetchPointer:<\/span> ClosureOuterContextIndex<\/strong><\/span> ofObject:<\/span> closure<\/span>.
\n<\/span>closure<\/span> :=<\/strong> self<\/span> fetchPointer:<\/span> ClosureIndex<\/strong><\/span> ofObject:<\/span> home<\/span>].
\n<\/span>“home is to be returned from provided there is no unwind-protect activation between
\nthis frame and home’s sender. Search for an unwind. findUnwindThroughContext:
\nwill answer either the context for an unwind-protect activation or nilObj if the sender
\ncannot be found or 0 if no unwind is found but the sender is. We must update the
\ncurrent page’s headFrame pointers to enable the search to identify widowed contexts
\ncorrectly.”<\/span>
\n<\/span>self<\/span> writeBackHeadFramePointers<\/span>.
\n<\/span>unwindContextOrNilOrZero<\/span> :=<\/strong> self<\/span> findUnwindThroughContext:<\/span> home<\/span>.
\n<\/span>unwindContextOrNilOrZero<\/span> ==<\/span> nilObj <\/span>ifTrue:<\/span>
\n[<\/span>“error: can’t find home on chain; cannot return”<\/span>
\n<\/span>^self<\/span> internalCannotReturn:<\/span> localReturnValue].
\n<\/span>unwindContextOrNilOrZero<\/span> ~~<\/span> 0<\/span> ifTrue:<\/span>
\n[<\/span>^self<\/span> internalAboutToReturn:<\/span> localReturnValue <\/span>through:<\/span> unwindContextOrNilOrZero<\/span>].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“Now we know home is on the sender chain.
\nWe could be returning to either a context or a frame. Find out which.”<\/span>
\n<\/span>contextToReturnTo<\/span> :=<\/strong> nil<\/span>.
\n(<\/span>self<\/span> isMarriedOrWidowedContext:<\/span> home<\/span>)
\n<\/span>ifTrue:<\/span>
\n[<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> checkIsStillMarriedContext:<\/span> home<\/span> currentFP:<\/span> localFP<\/span>)<\/span>.
\n<\/span>theFP<\/span> :=<\/strong> self<\/span> frameOfMarriedContext:<\/span> home<\/span>.
\n<\/span>(<\/span>self<\/span> isBaseFrame:<\/span> theFP<\/span>)<\/span>
\n<\/span>ifTrue:<\/span>
\n<\/span>[<\/span>contextToReturnTo<\/span> :=<\/strong> self<\/span> frameCallerContext:<\/span> theFP<\/span>]<\/span>
\n<\/span>ifFalse:<\/span>
\n<\/span>[<\/span>frameToReturnTo<\/span> :=<\/strong> self<\/span> frameCallerFP:<\/span> theFP<\/span>]<\/span>]
\n<\/span>ifFalse:<\/span>
\n[<\/span>contextToReturnTo<\/span> :=<\/strong> self<\/span> fetchPointer:<\/span> SenderIndex<\/strong><\/span> ofObject:<\/span> home<\/span>.
\n<\/span>(<\/span>self<\/span> isMarriedOrWidowedContext:<\/span> contextToReturnTo<\/span>)<\/span> ifTrue:<\/span>
\n<\/span>[<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> checkIsStillMarriedContext:<\/span> contextToReturnTo<\/span> currentFP:<\/span> localFP<\/span>)<\/span>.
\n<\/span>frameToReturnTo<\/span> :=<\/strong> self<\/span> frameOfMarriedContext:<\/span> contextToReturnTo<\/span>.
\n<\/span>contextToReturnTo<\/span> :=<\/strong> nil<\/span>]<\/span>].
\n<\/span>“If returning to a context we must make a frame for it unless it is dead.”<\/span>
\n<\/span>contextToReturnTo<\/span> ~=<\/span> nil<\/span> ifTrue:<\/span>
\n[<\/span>frameToReturnTo<\/span> :=<\/strong> self<\/span> establishFrameForContextToReturnTo:<\/span> contextToReturnTo<\/span>.
\n<\/span>frameToReturnTo<\/span> ==<\/span> 0<\/span> ifTrue:<\/span>
\n<\/span>[<\/span>“error: home’s sender is dead; cannot return”<\/span>
\n<\/span>^self<\/span> internalCannotReturn:<\/span> localReturnValue<\/span>]<\/span>].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“Now we have a frame to return to. If it is on a different page we must
\nfree intervening pages and nil out intervening contexts. We must free
\nintervening stack pages because if we leave the pages to be divorced
\nthen their contexts will be divorced with intact senders and instruction
\npointers. This code is similar to primitiveTerminateTo.”<\/span>
\n<\/span>newPage<\/span> :=<\/strong> stackPages <\/span>stackPageFor:<\/span> frameToReturnTo<\/span>.
\n<\/span>newPage<\/span> ~~<\/span> stackPage <\/span>ifTrue:<\/span>
\n[<\/span>|<\/span> currentCtx<\/span> thePage<\/span> nextCntx<\/span> |<\/span>
\n<\/span>currentCtx<\/span> :=<\/strong> self<\/span> frameCallerContext:<\/span> stackPage <\/span>baseFP<\/span>.
\n<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> isContext:<\/span> currentCtx<\/span>)<\/span>.
\nstackPages <\/span>freeStackPage:<\/span> stackPage.
\n<\/span>[<\/span>(<\/span>self<\/span> isMarriedOrWidowedContext:<\/span> currentCtx<\/span>)<\/span>
\n<\/span>and:<\/span> [<\/span>(<\/span>stackPages <\/span>stackPageFor:<\/span> (<\/span>theFP<\/span> :=<\/strong> self<\/span> frameOfMarriedContext:<\/span> currentCtx<\/span>)<\/span>)<\/span> ==<\/span> newPage<\/span>]<\/span>]<\/span> whileFalse:<\/span>
\n<\/span>[<\/span>(<\/span>self<\/span> isMarriedOrWidowedContext:<\/span> currentCtx<\/span>)<\/span>
\n<\/span>ifTrue:<\/span>
\n<\/span>[<\/span>thePage<\/span> :=<\/strong> stackPages <\/span>stackPageFor:<\/span> theFP<\/span>.
\n<\/span>currentCtx<\/span> :=<\/strong> self<\/span> frameCallerContext:<\/span> thePage<\/span> baseFP<\/span>.
\n<\/span>self<\/span> freeStackPage:<\/span> thePage<\/span>]<\/span>
\n<\/span>ifFalse:<\/span>
\n<\/span>[<\/span>self<\/span> assert:<\/span> (self<\/span> isContext:<\/span> currentCtx<\/span>)<\/span>.
\n<\/span>nextCntx<\/span> :=<\/strong> self<\/span> fetchPointer:<\/span> SenderIndex<\/strong><\/span> ofObject:<\/span> currentCtx<\/span>.
\n<\/span>self<\/span> storePointerUnchecked:<\/span> SenderIndex<\/strong><\/span> ofObject:<\/span> currentCtx<\/span> withValue:<\/span> nilObj.
\n<\/span>self<\/span> storePointerUnchecked:<\/span> InstructionPointerIndex<\/strong><\/span> ofObject:<\/span> currentCtx<\/span> withValue:<\/span> nilObj.
\n<\/span>currentCtx<\/span> :=<\/strong> nextCntx<\/span>]<\/span>]<\/span>.
\n<\/span>self<\/span> setStackPageAndLimit:<\/span> newPage<\/span>.
\nlocalSP <\/span>:=<\/strong> stackPage <\/span>headSP<\/span>.
\nlocalFP <\/span>:=<\/strong> stackPage <\/span>headFP<\/span>].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“Two cases. Returning to the top frame or an interior frame.
\nThe top frame has its instruction pointer on top of stack.
\nAn interior frame has its instruction pointer in the caller frame.
\nWe need to peel back any frames on the page until we get to the correct frame.”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0localFP <\/span>==<\/span> frameToReturnTo<\/span>
\n<\/span>ifTrue:<\/span> “pop the saved IP, push the return value and continue.”<\/span>
\n[localIP <\/span>:=<\/strong> self<\/span> pointerForOop:<\/span> self<\/span> internalStackTop<\/span>]
\n<\/span>ifFalse:<\/span>
\n[<\/span>[<\/span>callerFP<\/span> :=<\/strong> localFP.
\nlocalFP <\/span>:=<\/strong> self<\/span> frameCallerFP:<\/span> localFP.
\nlocalFP <\/span>~~<\/span> frameToReturnTo<\/span>]<\/span> whileTrue<\/span>.
\nlocalIP <\/span>:=<\/strong> self<\/span> frameCallerSavedIP:<\/span> callerFP<\/span>.
\nlocalSP <\/span>:=<\/strong> (<\/span>self<\/span> frameCallerSP:<\/span> callerFP<\/span>)<\/span> –<\/span> BytesPerWord<\/strong><\/span>].
\n<\/span>self<\/span> internalStackTopPut:<\/span> localReturnValue.
\nmethod <\/span>:=<\/strong> self<\/span> frameMethod:<\/span> localFP.
\n<\/span>self<\/span> fetchNextBytecode<\/span>
\n<\/span>
\nfindUnwindThroughContext:<\/strong> homeContext<\/span>
\n<\/span>“Search for either an unwind-protect (activation of method with primitive 198)
\nor homeContext along the sender chain, which ever is found first. If homeContext
\nis not found answer nilObj, indicating cannotReturn:. If homeContext is found
\nanswer 0. If homeContext is itself an unwind-protect answer the context, not 0.”<\/span>
\n<\/span>|<\/span> ctxtOrNilOrZero<\/span> theMethod<\/span> |<\/span>
\n<\/span>self<\/span> externalizeIPandSP<\/span>.
\n<\/span>“Since nothing changes we don’t need to internalize.”<\/span>
\n<\/span>ctxtOrNilOrZero<\/span> :=<\/strong> self<\/span> findMethodWithPrimitive:<\/span> 198<\/span> FromFP:<\/span> localFP <\/span>UpToContext:<\/span> homeContext<\/span>.
\n<\/span>ctxtOrNilOrZero<\/span> =<\/span> 0<\/span> ifTrue:<\/span>
\n[<\/span>theMethod<\/span> :=<\/strong> self<\/span> fetchPointer:<\/span> MethodIndex<\/strong><\/span> ofObject:<\/span> homeContext<\/span>.
\n<\/span>(<\/span>self<\/span> primitiveIndexOf:<\/span> theMethod<\/span>)<\/span> ==<\/span> 198<\/span> ifTrue:<\/span>
\n<\/span>[<\/span>^<\/span>homeContext<\/span>]<\/span>].
\n<\/span>^<\/span>ctxtOrNilOrZero<\/span><\/p>\n

 <\/p>\n

findMethodWithPrimitive:<\/strong> primitive<\/span> FromFP:<\/strong> startFP<\/span> UpToContext:<\/strong> homeContext<\/span>
\n<\/span>“See findUnwindThroughContext:. Alas this is mutually recursive with
\nfindMethodWithPrimitive:FromContext:ThroughContext: instead of iterative.
\nWe’re doing the simplest thing that could possibly work. Niceties can wait.”<\/span>
\n<\/span>|<\/span> theFP<\/span> theFPAbove<\/span> theMethod<\/span> senderContext<\/span> |<\/span>
\n<var: <\/span>#startFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#theFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#theFPAbove<\/span> type: <\/span>#’char *’<\/span>>
\n<\/span>theFP<\/span> :=<\/strong> startFP<\/span>.
\n<\/span>theFPAbove<\/span> :=<\/strong> startFP<\/span>.
\n[<\/span>(<\/span>(<\/span>self<\/span> frameHasContext:<\/span> theFP<\/span>)<\/span>
\n<\/span>and:<\/span> [<\/span>homeContext<\/span> ==<\/span> (self<\/span> frameContext:<\/span> theFP<\/span>)<\/span>]<\/span>)<\/span> ifTrue:<\/span>
\n<\/span>[<\/span>^0<\/span>]<\/span>.
\n<\/span>theMethod<\/span> :=<\/strong> self<\/span> frameMethod:<\/span> theFP<\/span>.
\n<\/span>(<\/span>self<\/span> primitiveIndexOf:<\/span> theMethod<\/span>)<\/span> ==<\/span> primitive<\/span> ifTrue:<\/span>
\n<\/span>[<\/span>^self<\/span> ensureFrameIsMarried:<\/span> theFP<\/span>]<\/span>.
\n<\/span>theFPAbove<\/span> :=<\/strong> theFP<\/span>.
\n<\/span>theFP<\/span> :=<\/strong> self<\/span> frameCallerFP:<\/span> theFP<\/span>.
\n<\/span>theFP<\/span> ~=<\/span> 0<\/span>] <\/span>whileTrue<\/span>.
\n<\/span>senderContext<\/span> :=<\/strong> self<\/span> frameCallerContext:<\/span> theFPAbove<\/span>.
\n(<\/span>self<\/span> isContext:<\/span> senderContext<\/span>) <\/span>ifFalse:<\/span>
\n[<\/span>^<\/span>nilObj].
\n<\/span>^self<\/span>
\n<\/span>findMethodWithPrimitive:<\/span> primitive<\/span>
\n<\/span>FromContext:<\/span> senderContext<\/span>
\n<\/span>UpToContext:<\/span> homeContext<\/span><\/p>\n

 <\/p>\n

findMethodWithPrimitive:<\/strong> primitive<\/span> FromContext:<\/strong> senderContext<\/span> UpToContext:<\/strong> homeContext<\/span>
\n<\/span>“See findUnwindThroughContext:. Alas this is mutually recursive with
\nfindMethodWithPrimitive:FromFP:SP:ThroughContext: instead of iterative.
\nWe’re doing the simplest thing that could possibly work. Niceties can wait.”<\/span>
\n<\/span>|<\/span> theContext<\/span> theMethod<\/span> |<\/span>
\n<\/span>theContext<\/span> :=<\/strong> senderContext<\/span>.
\n[<\/span>self<\/span> isMarriedOrWidowedContext:<\/span> theContext<\/span>] <\/span>whileFalse:<\/span>
\n[<\/span>theContext<\/span> =<\/span> homeContext<\/span> ifTrue:<\/span> [<\/span>^0<\/span>]<\/span>.
\n<\/span>theMethod<\/span> :=<\/strong> self<\/span> fetchPointer:<\/span> MethodIndex<\/strong><\/span> ofObject:<\/span> theContext<\/span>.
\n<\/span>(<\/span>self<\/span> primitiveIndexOf:<\/span> theMethod<\/span>)<\/span> ==<\/span> primitive<\/span> ifTrue:<\/span>
\n<\/span>[<\/span>^<\/span>theContext<\/span>]<\/span>.
\n<\/span>theContext<\/span> :=<\/strong> self<\/span> fetchPointer:<\/span> SenderIndex<\/strong><\/span> ofObject:<\/span> theContext<\/span>.
\n<\/span>theContext<\/span> =<\/span> nilObj <\/span>ifTrue:<\/span>
\n<\/span>[<\/span>^<\/span>theContext<\/span>]<\/span>].
\n(<\/span>self<\/span> isWidowedContext:<\/span> theContext<\/span>) <\/span>ifTrue:<\/span>
\n[<\/span>^<\/span>nilObj].
\n<\/span>^self<\/span>
\n<\/span>findMethodWithPrimitive:<\/span> primitive<\/span>
\n<\/span>FromFP:<\/span> (<\/span>self<\/span> frameOfMarriedContext:<\/span> theContext<\/span>)
\n<\/span>UpToContext:<\/span> homeContext<\/span><\/p>\n

 <\/p>\n

Ouch. That <\/span>is<\/em><\/span> complicated, but at least it is the <\/span>most<\/em><\/span> complicated thing in the StackInterpreter. It is not finished yet. The mutual recursion between findMethodWithPrimitive:FromFP:UpToContext: and findMethodWithPrimitive:FromContext:UpToContext: could conceivably cause the runtime C stack to overflow and should be flattened into a set of loops. But when I wrote this I found it much easier to understand because I was riting it in Smalltalk. I’m not at all convinced that the code inside the VisualWorks VMs correct because, being written in C, it is not nearly as comprehensible.<\/span><\/p>\n

Those of you who know the Squeak VM well will know there’s a primitive terminateTo: that does something similar to the context nilling in non-local return. It is a little simpler than non-local return (although not much) but it is just a variation on the same theme so I’ll spare you.<\/span><\/p>\n

 <\/p>\n

Hiding Stack Frames<\/h2>\n

Still reading? Good. Now we’re ready for some fun. While we’ve organized the system around stack pages and improved performance markedly (measurements to follow) and prepared the ground for the JIT, we still have to hide these stack pages from the Smalltalk programmer. We need to arrange that whever he or she accesses a context it hides its spose and always pretends to be single, whether we read or write it. We’ve seen how return copes with this, but what about methods on context such as<\/p>\n

ContextPart methods for debugger access<\/em>
\nswapSender:<\/strong> coroutine<\/span>
\n<\/span>“Replace the receiver’s sender with coroutine and answer the receiver’s
\nprevious sender. For use in coroutining.”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>|<\/span> oldSender<\/span> |<\/span>
\n<\/span>oldSender<\/span> :=<\/strong> sender.
\nsender <\/span>:=<\/strong> coroutine<\/span>.
\n<\/span>^<\/span>oldSender<\/span><\/p>\n

The problem here is that the current valid state of the context lives in the frame and changing that state needs to either affect the frame or update the context after it has been divorced. One apparently straight-forward way to handle this is to divorce contexts whenever they are sent messages and whenever the system attempts to access a context instance variable. This is the way the VisualWorks VM handled things until I changed the scheme in 5i in 1999. Married contexts (hybrid contexts in the VisualWorks terminology) had special classes that would cause teh send machinery to trap and “stabilize” (divorce) the receiver context. The bytecode compiler marked methods that accessed instance variables which could be run by contexts and the JIT generated special code that would stabilize the receiver context before accessing an instance variable.<\/p>\n

The main problem with this approach is that any kind of state access ends up divorcing a context which hurts performance and encourages a proliferation of complex primitives in the VM which try and avoid divorce replicating code that could be written in the image. The other problem is that it is slow. Sends to contexts trap and divorce even for read access. Wen I introduced the scheme I’m using here exception handling code and non-local return roughly doubled in speed. The key in this scheme is to intercept all access to context instace variables and forward the access to the spouse if married.<\/p>\n

In the VM the only places the state of a context are accessed outside of the frame management code for send and return and stack page management are the instance variable access bytecodes and the at: at:put: instVarAt: and instVarAt:put: primitives. Instance variable access is very frequent so having to test for accessing a context on every instance variable access bytecode would hurt performance noticeably. Unlike a JIT we can’t perform the text for contextness at compile time based on the class of the method being compiled; we have to test on execution of the relevant bytecocde. But as I alluded to in Closures Part III<\/a> I added a horrible hack to the bytecode compiler to avoid testing on most instace variable accesses.<\/p>\n

The compiler allows a class to specify special node classes for handling instance variables. This is used by Tweak to access properties and by InstructionStream, the first superclass of ContextPart to introduce state, to handle context instance variables.<\/p>\n

Encoder methods for initialize-release<\/em>
\ninit:<\/strong> aClass<\/span> context:<\/strong> aContext<\/span> notifying:<\/strong> req<\/span>
\nrequestor <\/span>:=<\/strong> req<\/span>.
\nclass <\/span>:=<\/strong> aClass<\/span>.
\nnTemps <\/span>:=<\/strong> 0<\/span>.
\nsupered <\/span>:=<\/strong> false<\/span>.
\n<\/span>self<\/span> initScopeAndLiteralTables<\/span>.
\nclass <\/span>variablesAndOffsetsDo:<\/span>
\n[:<\/span>variable<\/span> “<String|CFieldDefinition>”<\/span> :<\/span>offset<\/span> “<Integer|nil>”<\/span> |<\/span>
\n<\/span>offset<\/span> isNil<\/span>
\n<\/span>ifTrue:<\/span> [<\/span>scopeTable <\/span>at:<\/span> variable<\/span> name<\/span> put:<\/span> (<\/span>FieldNode <\/span>new<\/span> fieldDefinition:<\/span> variable<\/span>)<\/span>]<\/span>
\n<\/span>ifFalse:<\/span> [<\/span>scopeTable
\n<\/span>at:<\/span> variable<\/span>
\n<\/span>put:<\/span> (<\/span>offset<\/span> >=<\/span> 0<\/span>
\n<\/span>ifTrue:<\/span> [<\/span>InstanceVariableNode <\/span>new<\/span>
\n<\/span>name:<\/span> variable<\/span> index:<\/span> offset<\/span>]<\/span>
\n<\/span>ifFalse:<\/span> [<\/span>MaybeContextInstanceVariableNode <\/span>new<\/span>
\n<\/span>name:<\/span> variable<\/span> index:<\/span> offset<\/span> negated<\/span>]<\/span>)<\/span>]<\/span>].
\n<\/span>aContext<\/span> ~~<\/span> nil<\/span> ifTrue:<\/span>
\n[<\/span>|<\/span> homeNode<\/span> |<\/span>
\n<\/span>homeNode<\/span> :=<\/strong> self<\/span> bindTemp:<\/span> self<\/span> doItInContextName<\/span>.
\n<\/span>“0th temp = aContext passed as arg”<\/span>
\n<\/span>aContext<\/span> tempNames<\/span> withIndexDo:<\/span>
\n<\/span>[<\/span>:<\/span>variable<\/span> :<\/span>index<\/span>|<\/span>
\nscopeTable
\n<\/span>at:<\/span> variable<\/span>
\n<\/span>put:<\/span> (<\/span>MessageAsTempNode <\/span>new<\/span>
\n<\/span>receiver:<\/span> homeNode<\/span>
\n<\/span>selector:<\/span> #namedTempAt:<\/span>
\n<\/span>arguments:<\/span> (<\/span>Array <\/span>with:<\/span> (<\/span>self<\/span> encodeLiteral:<\/span> index<\/span>)<\/span>)<\/span>
\n<\/span>precedence:<\/span> 3<\/span>
\n<\/span>from:<\/span> self<\/span>)<\/span>]<\/span>].
\nsourceRanges <\/span>:=<\/strong> Dictionary <\/span>new:<\/span> 32<\/span>.
\nglobalSourceRanges <\/span>:=<\/strong> OrderedCollection <\/span>new:<\/span> 32<\/span><\/p>\n

 <\/p>\n

CProtoObject class methods for compiling<\/em><\/span>
\n<\/span>variablesAndOffsetsDo:<\/strong> aBinaryBlock<\/span>
\n<\/span>“This is the interface between the compiler and a class’s instance or field names. The
\nclass should enumerate aBinaryBlock with the field definitions (with nil offsets) followed
\nby the instance variable name strings and their integer offsets (1-relative). The order is
\nimportant; names evaluated later will override the same names occurring earlier.”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>self<\/span> allFieldsReverseDo:<\/span> [:<\/span>field<\/span>|<\/span> aBinaryBlock<\/span> value:<\/span> field<\/span> value:<\/span> nil<\/span>].
\n<\/span>self<\/span> instVarNamesAndOffsetsDo:<\/span> aBinaryBlock<\/span><\/p>\n

Behavior methods for compiling<\/em>
\nvariablesAndOffsetsDo:<\/strong> aBinaryBlock<\/span>
\n<\/span>“This is the interface between the compiler and a class’s instance or field names. The
\nclass should enumerate aBinaryBlock with the field definitions (with nil offsets) followed
\nby the instance variable name strings and their integer offsets (1-relative). The order is
\nimportant; names evaluated later will override the same names occurring earlier.”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“Only need to do instance variables here. CProtoObject introduces field definitions.”<\/span>
\n<\/span>self<\/span> instVarNamesAndOffsetsDo:<\/span> aBinaryBlock<\/span><\/p>\n

 <\/p>\n

instVarNamesAndOffsetsDo:<\/strong> aBinaryBlock<\/span>
\n<\/span>“This is part of the interface between the compiler and a class’s instance or field names.
\nThe class should enumerate aBinaryBlock with the instance variable name strings and
\ntheir integer offsets. The order is important. Names evaluated later will override the
\nsame names occurring earlier.”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“Nothing to do here; ClassDescription introduces named instance variables”<\/span>
\n<\/span>^self<\/span><\/p>\n

ClassDescription methods for compiling<\/em>
\ninstVarNamesAndOffsetsDo:<\/strong> aBinaryBlock<\/span>
\n<\/span>“This is part of the interface between the compiler and a class’s instance or field names.
\nThe class should enumerate aBinaryBlock with the instance variable name strings and
\ntheir integer offsets. The order is important. Names evaluated later will override the
\nsame names occurring earlier.”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>|<\/span> superInstSize<\/span> |<\/span>
\n(<\/span>superInstSize<\/span> :=<\/strong> superclass <\/span>notNil<\/span> ifTrue:<\/span> [<\/span>superclass <\/span>instSize<\/span>]<\/span> ifFalse:<\/span> [<\/span>0<\/span>]<\/span>) <\/span>><\/span> 0<\/span> ifTrue:<\/span>
\n[superclass <\/span>instVarNamesAndOffsetsDo:<\/span> aBinaryBlock<\/span>].
\n<\/span>1<\/span> to:<\/span> self<\/span> instSize<\/span> –<\/span> superInstSize<\/span> do:<\/span>
\n[:<\/span>i<\/span>|<\/span> aBinaryBlock<\/span> value:<\/span> (<\/span>instanceVariables <\/span>at:<\/span> i<\/span>)<\/span> value:<\/span> i<\/span> +<\/span> superInstSize<\/span>]<\/span><\/p>\n

InstructionStream class methods for compiling
\n<\/em>instVarNamesAndOffsetsDo:<\/strong> aBinaryBlock<\/span>
\n<\/span>“This is part of the interface between the compiler and a class’s instance or field names.
\nWe override here to arrange that the compiler will use MaybeContextInstanceVariableNodes
\nfor instances variables of ContextPart or any of its superclasses and subclasses. The
\nconvention to make the compiler use the special nodes is to use negative indices”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>|<\/span> superInstSize<\/span> |<\/span>
\n(<\/span>self<\/span> withAllSubclasses<\/span> noneSatisfy:<\/span> [<\/span>:<\/span>class<\/span>|<\/span>class<\/span> isContextClass<\/span>]<\/span>) <\/span>ifTrue:<\/span>
\n[<\/span>^super<\/span> instVarNamesAndOffsetsDo:<\/span> aBinaryBlock<\/span>].
\n(<\/span>superInstSize<\/span> :=<\/strong> superclass <\/span>notNil<\/span> ifTrue:<\/span> [<\/span>superclass <\/span>instSize<\/span>]<\/span> ifFalse:<\/span> [<\/span>0<\/span>]<\/span>) <\/span>><\/span> 0<\/span> ifTrue:<\/span>
\n[superclass <\/span>instVarNamesAndOffsetsDo:<\/span> aBinaryBlock<\/span>].
\n<\/span>1<\/span> to:<\/span> self<\/span> instSize<\/span> –<\/span> superInstSize<\/span> do:<\/span>
\n[:<\/span>i<\/span>|<\/span> aBinaryBlock<\/span> value:<\/span> (<\/span>instanceVariables <\/span>at:<\/span> i<\/span>)<\/span> value:<\/span> (<\/span>i<\/span> +<\/span> superInstSize<\/span>)<\/span> negated<\/span>]<\/span><\/p>\n

MaybeContextInstanceVariableNode simply forces the use of the long-form instance variable bytecodes:<\/span><\/p>\n

 <\/p>\n

MaybeContextInstanceVariableNode methods for code generation (new scheme)<\/em><\/span>
\n<\/span>emitCodeForValue:<\/strong> stack<\/span> encoder:<\/strong> encoder<\/span>
\n<\/span>stack<\/span> push:<\/span> 1<\/span>.
\n<\/span>^<\/span>encoder<\/span> genPushInstVarLong:<\/span> index<\/span><\/p>\n

 <\/p>\n

emitCodeForStorePop:<\/strong> stack<\/span> encoder:<\/strong> encoder<\/span>
\n<\/span>encoder<\/span> genStorePopInstVarLong:<\/span> index.
\n<\/span>stack<\/span> pop:<\/span> 1<\/span><\/p>\n

 <\/p>\n

EncoderForV3 methods for bytecode generation
\n<\/span>genPushInstVarLong:<\/strong> instVarIndex<\/span>
\n<\/span>“See BlueBook page 596”<\/span>
\n<\/span>“See also MaybeContextInstanceVariableNode”<\/span>
\n(<\/span>instVarIndex<\/span> >=<\/span> 0<\/span> and:<\/span> [<\/span>instVarIndex<\/span> <<\/span> 256<\/span>]<\/span>) <\/span>ifTrue:<\/span>
\n[<\/span>“132 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a010000100 iiijjjjj kkkkkkkk \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(Send, Send Super, Push Receiver Variable, Push Literal Constant, Push Literal Variable, Store Receiver Variable, Store-Pop Receiver Variable, Store Literal Variable)[iii] #kkkkkkkk jjjjj”<\/span>
\nstream
\n<\/span>nextPut:<\/span> 132<\/span>;
\n<\/span>nextPut:<\/span> 64<\/span>;
\n<\/span>nextPut:<\/span> instVarIndex<\/span>.
\n<\/span>^self<\/span>].
\n<\/span>^self<\/span> outOfRangeError:<\/span> ‘index’<\/span><\/span> index:<\/span> instVarIndex<\/span> range:<\/span> 0<\/span> to:<\/span> 255<\/span><\/p>\n

 <\/p>\n

genStorePopInstVarLong:<\/strong> instVarIndex<\/span>
\n<\/span>“See BlueBook page 596”<\/span>
\n<\/span>“See also MaybeContextInstanceVariableNode”<\/span>
\n(<\/span>instVarIndex<\/span> >=<\/span> 0<\/span> and:<\/span> [<\/span>instVarIndex<\/span> <<\/span> 256<\/span>]<\/span>) <\/span>ifTrue:<\/span>
\n[<\/span>“132 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a010000100 iiijjjjj kkkkkkkk \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(Send, Send Super, Push Receiver Variable, Push Literal Constant, Push Literal Variable, Store Receiver Variable, Store-Pop Receiver Variable, Store Literal Variable)[iii] #kkkkkkkk jjjjj”<\/span>
\nstream
\n<\/span>nextPut:<\/span> 132<\/span>;
\n<\/span>nextPut:<\/span> 192<\/span>;
\n<\/span>nextPut:<\/span> instVarIndex<\/span>.
\n<\/span>^self<\/span>].
\n<\/span>^self<\/span> outOfRangeError:<\/span> ‘index’<\/span><\/span> index:<\/span> instVarIndex<\/span> range:<\/span> 0<\/span> to:<\/span> 255<\/span><\/p>\n

The doubleExtendedDoAnythingBytecode (I’m not making this up) only needs to be used for instance variables with an offset greater than 63, which is rare. Since MethodContext only has 6 instance variables we only have to check for the receiver being a contex if we’re using the doubleExtendedDoAnythingBytecode to access instance variables 0 through 5. Since the doubleExtendedDoAnythingBytecode has to do a lot of decoding before it computes the instance variable offset and the test is ony a compare of the computed index against the constant 6 the test is essentally free for all but use on actual contexts.<\/span><\/p>\n

 <\/p>\n

StackInterpreter methods for send bytecodes<\/em><\/span>
\n<\/span>doubleExtendedDoAnythingBytecode<\/strong>
\n<\/span>“Replaces the Blue Book double-extended send [132], in which the first byte was wasted on 8 bits of argument count.
\nHere we use 3 bits for the operation sub-type (opType), and the remaining 5 bits for argument count where needed.
\nThe last byte give access to 256 instVars or literals.
\nSee also secondExtendedSendBytecode”<\/span>
\n<\/span>|<\/span> byte2<\/span> byte3<\/span> opType<\/span> top<\/span> |<\/span>
\n<\/span>byte2<\/span> :=<\/strong> self<\/span> fetchByte<\/span>.
\n<\/span>byte3<\/span> :=<\/strong> self<\/span> fetchByte<\/span>.
\n<\/span>opType<\/span> :=<\/strong> byte2<\/span> >><\/span> 5<\/span>.
\n<\/span>opType<\/span> =<\/span> 0<\/span> ifTrue:<\/span>
\n[messageSelector <\/span>:=<\/strong> self<\/span> literal:<\/span> byte3<\/span>.
\nargumentCount <\/span>:=<\/strong> byte2<\/span> bitAnd:<\/span> 31<\/span>.
\n<\/span>^self<\/span> normalSend<\/span>].
\n<\/span>opType<\/span> =<\/span> 1<\/span> ifTrue:<\/span>
\n[messageSelector <\/span>:=<\/strong> self<\/span> literal:<\/span> byte3<\/span>.
\nargumentCount <\/span>:=<\/strong> byte2<\/span> bitAnd:<\/span> 31<\/span>.
\n<\/span>^self<\/span> superclassSend<\/span>].
\n<\/span>self<\/span> fetchNextBytecode<\/span>.
\n<\/span>opType<\/span> =<\/span> 2<\/span> ifTrue:<\/span> [<\/span>^self<\/span> pushMaybeContextReceiverVariable:<\/span> byte3<\/span>].
\n<\/span>opType<\/span> =<\/span> 3<\/span> ifTrue:<\/span> [<\/span>^self<\/span> pushLiteralConstant:<\/span> byte3<\/span>].
\n<\/span>opType<\/span> =<\/span> 4<\/span> ifTrue:<\/span> [<\/span>^self<\/span> pushLiteralVariable:<\/span> byte3<\/span>].
\n<\/span>top<\/span> :=<\/strong> self<\/span> internalStackTop<\/span>.
\n<\/span>opType<\/span> =<\/span> 5<\/span> ifTrue:<\/span>
\n[<\/span>^self<\/span> storeMaybeContextReceiverVariable:<\/span> byte3<\/span> withValue:<\/span> top<\/span>].
\n<\/span>opType<\/span> =<\/span> 6<\/span> ifTrue:<\/span>
\n[<\/span>self<\/span> internalPop:<\/span> 1<\/span>.
\n<\/span>^self<\/span> storeMaybeContextReceiverVariable:<\/span> byte3<\/span> withValue:<\/span> top<\/span>].
\n<\/span>opType<\/span> =<\/span> 7<\/span> ifTrue:<\/span>
\n[<\/span>^self<\/span> storePointer:<\/span> ValueIndex<\/strong><\/span> ofObject:<\/span> (<\/span>self<\/span> literal:<\/span> byte3<\/span>)<\/span> withValue:<\/span> top<\/span>]<\/span><\/p>\n

 <\/p>\n

StackInterpreter methods for stack bytecodes<\/em><\/span>
\n<\/span>pushMaybeContextReceiverVariable:<\/strong> fieldIndex<\/span>
\n<\/span>“Must trap accesses to married and widowed contexts.
\nBut don’t want to check on all inst var accesses. This
\nmethod is only used by the long-form bytecodes, evading
\nthe cost. Note that the method, closure and receiver fields
\nof married contexts are correctly initialized so they don’t
\nneed special treatment on read. Only sender, instruction
\npointer and stack pointer need to be intercepted on reads.”<\/span>
\n<\/span>|<\/span> rcvr<\/span> |<\/span>
\n<inline: <\/span>true<\/span>>
\n<\/span>rcvr<\/span> :=<\/strong> self<\/span> receiver<\/span>.
\n(<\/span>fieldIndex<\/span> <<\/span> MethodIndex<\/strong><\/span>
\n<\/span>and:<\/span> [<\/span>self<\/span> isMarriedOrWidowedContext:<\/span> rcvr<\/span>]<\/span>)
\n<\/span>ifTrue:<\/span>
\n[<\/span>self<\/span> internalPush:<\/span> (<\/span>self<\/span> instVar:<\/span> fieldIndex<\/span> ofContext:<\/span> rcvr<\/span>)<\/span>]
\n<\/span>ifFalse:<\/span>
\n[<\/span>self<\/span> internalPush:<\/span> (<\/span>self<\/span> fetchPointer:<\/span> fieldIndex<\/span> ofObject:<\/span> rcvr<\/span>)<\/span>]<\/span><\/p>\n

 <\/p>\n

storeMaybeContextReceiverVariable:<\/strong> fieldIndex<\/span> withValue:<\/strong> anObject<\/span>
\n<\/span>“Must trap accesses to married and widowed contexts.
\nBut don’t want to check on all inst var accesses. This
\nmethod is only used by the long-form bytecodes, evading the cost.”<\/span>
\n<\/span>|<\/span> rcvr<\/span> |<\/span>
\n<\/span>rcvr<\/span> :=<\/strong> self<\/span> receiver<\/span>.
\n(<\/span>fieldIndex<\/span> <=<\/span> ReceiverIndex<\/strong><\/span>
\n<\/span>and:<\/span> [<\/span>self<\/span> isMarriedOrWidowedContext:<\/span> rcvr<\/span>]<\/span>)
\n<\/span>ifTrue:<\/span>
\n[<\/span>self<\/span> instVar:<\/span> fieldIndex<\/span> ofContext:<\/span> rcvr<\/span> put:<\/span> anObject<\/span>]
\n<\/span>ifFalse:<\/span>
\n[<\/span>self<\/span> storePointer:<\/span> fieldIndex<\/span> ofObject:<\/span> rcvr<\/span> withValue:<\/span> anObject<\/span>]<\/span><\/p>\n

Reading is easy. Simply compute the relevant value, sender, pc or stackp from the spouse frame.<\/span><\/p>\n

 <\/p>\n

StackInterpreter methods for frame access<\/em><\/span>
\n<\/span>instVar:<\/strong> offset<\/span> ofContext:<\/strong> aOnceMarriedContext<\/span>
\n<\/span>“Fetch an instance avriable from a maybe married context.
\nIf the context is still married compute the value of the
\nrelevant inst var from the spouse frame’s state.”<\/span>
\n<\/span>|<\/span> spouseFP<\/span> senderFP<\/span> |<\/span>
\n<inline: <\/span>true<\/span>>
\n<var: <\/span>#spouseFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#senderFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#thePage<\/span> type: <\/span>#’StackPage *’<\/span>>
\n<var: <\/span>#theFPAbove<\/span> type: <\/span>#’char *’<\/span>>
\n<\/span>self<\/span> assert:<\/span> offset<\/span> <<\/span> MethodIndex<\/strong><\/span>.
\n<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> isMarriedOrWidowedContext:<\/span> aOnceMarriedContext<\/span>).
\n<\/span>self<\/span> writeBackHeadFramePointers<\/span>.
\n(<\/span>self<\/span> isWidowedContext:<\/span> aOnceMarriedContext<\/span>) <\/span>ifTrue:<\/span>
\n[<\/span>^self<\/span> fetchPointer:<\/span> offset<\/span> ofObject:<\/span> aOnceMarriedContext<\/span>].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>spouseFP<\/span> :=<\/strong> self<\/span> withoutSmallIntegerTags:<\/span> (<\/span>self<\/span> fetchPointer:<\/span> SenderIndex<\/strong><\/span> ofObject:<\/span> aOnceMarriedContext<\/span>).
\n<\/span>offset<\/span> =<\/span> SenderIndex<\/strong><\/span> ifTrue:<\/span>
\n[<\/span>(<\/span>self<\/span> isBaseFrame:<\/span> spouseFP<\/span>)<\/span> ifTrue:<\/span>
\n<\/span>[<\/span>^self<\/span> frameCallerContext:<\/span> spouseFP<\/span>]<\/span>.
\n<\/span>senderFP<\/span> :=<\/strong> self<\/span> frameCallerFP:<\/span> spouseFP<\/span>.
\n<\/span>^self<\/span> ensureFrameIsMarried:<\/span> senderFP<\/span>].
\n<\/span>offset<\/span> =<\/span> StackPointerIndex<\/strong><\/span> ifTrue:<\/span>
\n[<\/span>^self<\/span> integerObjectOf:<\/span> (<\/span>self<\/span> stackPointerIndexForFrame:<\/span> spouseFP<\/span>)<\/span>].
\n<\/span>offset<\/span> =<\/span> InstructionPointerIndex<\/strong><\/span> ifTrue:<\/span>
\n[<\/span>|<\/span> theIP<\/span> thePage<\/span> theFPAbove<\/span> |<\/span>
\n<\/span>spouseFP<\/span> ==<\/span> localFP
\n<\/span>ifTrue:<\/span> [<\/span>theIP<\/span> :=<\/strong> self<\/span> oopForPointer:<\/span> localIP<\/span>]<\/span>
\n<\/span>ifFalse:<\/span>
\n<\/span>[<\/span>thePage<\/span> :=<\/strong> stackPages <\/span>stackPageFor:<\/span> spouseFP<\/span>.
\n<\/span>theFPAbove<\/span> :=<\/strong> self<\/span> findFrameAbove:<\/span> spouseFP<\/span> inPage:<\/span> thePage<\/span>.
\n<\/span>theIP<\/span> :=<\/strong> theFPAbove<\/span> ==<\/span> 0<\/span>
\n<\/span>ifTrue:<\/span> [<\/span>stackPages <\/span>longAt:<\/span> thePage<\/span> headSP<\/span>]<\/span>
\n<\/span>ifFalse:<\/span>[<\/span>self<\/span> oopForPointer:<\/span> (self<\/span> frameCallerSavedIP:<\/span> theFPAbove<\/span>)<\/span>]<\/span>]<\/span>.
\n<\/span>^self<\/span> contextInstructionPointerForFrame:<\/span> spouseFP<\/span> IP:<\/span> theIP<\/span>].
\n<\/span>self<\/span> error:<\/span> ‘bad index’<\/span><\/span><\/p>\n

Writing is a different matter. The one case that’s really important for performance is assigning the sender because it is used in e.g. co-routining but also in stack unwinding and termination. It is trivial to assign the sender of a base frame as it already refers to a context, but to assign to the sender of any other frame requires ingenuity something that Peter Deutsch and Allan Schiffman have in abundance and their solution is to split the stack into two.<\/span><\/p>\n

 <\/p>\n

\"\"
\n
\nThe assignee and all frames above it are moved to another stack, making the assignee the base frame, rendering assigning the sender trivial. Likewise handlng other assignment cases is done by moving all frames above the assignee to another stack, divorcing the assignee frame and assigning to the resulting single context. Once the assignee frame is a base frame we no longer have to split its stack if its sender is assigned again. So contexts that have their sender assigned often migrate to the bottom of stack pages, allowing the StackInterpreter to keep up with a context interpreter when co-routining.<\/span><\/p>\n

 <\/p>\n

StackInterpreter methods for frame access<\/em><\/span>
\n<\/span>instVar:<\/strong> index<\/span> ofContext:<\/strong> aMarriedContext<\/span> put:<\/strong> anOop<\/span>
\n<\/span>|<\/span> theFP<\/span> |<\/span>
\n<\/span>“Assign the field of a married context. The important case to optimize is
\nassigning the sender. We could also consider optimizing assiging the IP but
\ntypically that is followed by an assignment to the stack pointer and we can’t
\nefficiently assign the stack pointer because it involves moving frames around.”<\/span>
\n<inline: <\/span>true<\/span>>
\n<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> isMarriedOrWidowedContext:<\/span> aMarriedContext<\/span>).
\n<\/span>theFP<\/span> :=<\/strong> self<\/span> frameOfMarriedContext:<\/span> aMarriedContext<\/span>.
\n<\/span>index<\/span> ==<\/span> SenderIndex<\/strong><\/span> ifTrue:<\/span>
\n[<\/span>|<\/span> thePage<\/span> onCurrentPage<\/span> |<\/span>
\n<\/span>thePage<\/span> :=<\/strong> stackPages <\/span>stackPageFor:<\/span> theFP<\/span>.
\n<\/span>self<\/span> assert:<\/span> stackPage <\/span>==<\/span> stackPages <\/span>mostRecentlyUsedPage<\/span>.
\n<\/span>(<\/span>onCurrentPage<\/span> :=<\/strong> thePage<\/span> ==<\/span> stackPage<\/span>)<\/span> ifTrue:<\/span>
\n<\/span>[<\/span>self<\/span> writeBackHeadFramePointers<\/span>]<\/span>.
\n<\/span>self<\/span> storeSenderOfFrame:<\/span> theFP<\/span> withValue:<\/span> anOop<\/span>.
\n<\/span>onCurrentPage<\/span> ifTrue:<\/span>
\n<\/span>[<\/span>localFP <\/span>:=<\/strong> stackPage <\/span>headFP<\/span>.
\nlocalSP <\/span>:=<\/strong> stackPage <\/span>headSP<\/span>]<\/span>.
\n<\/span>^self<\/span>].
\n<\/span>self<\/span> externalizeIPandSP<\/span>.
\n<\/span>self<\/span> externalDivorceFrame:<\/span> theFP<\/span> andContext:<\/span> aMarriedContext<\/span>.
\n<\/span>self<\/span> storePointer:<\/span> index<\/span> ofObject:<\/span> aMarriedContext<\/span> withValue:<\/span> anOop<\/span>.
\n<\/span>self<\/span> internalizeIPandSP<\/span><\/p>\n

 <\/p>\n

storeSenderOfFrame:<\/strong> theFP<\/span> withValue:<\/strong> anOop<\/span>
\n<\/span>“Set the sender of a frame. If the frame is a base frame then this is trivial;
\nmerely store into the FoxCallerSavedIP field. If not, then split the stack at
\nthe frame, moving the frame and those hotter than it to a new stack page.
\nIn the new stack page the frame will be the base frame and storing trivial.
\nAnswer the possibly changed location of theFP.”<\/span>
\n<\/span>|<\/span> thePage<\/span> onCurrentPage<\/span> newPage<\/span> theMovedFP<\/span> |<\/span>
\n<var: <\/span>#theFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#thePage<\/span> type: <\/span>#’StackPage *’<\/span>>
\n<var: <\/span>#newPage<\/span> type: <\/span>#’StackPage *’<\/span>>
\n<var: <\/span>#theMovedFP<\/span> type: <\/span>#’char *’<\/span>>
\n<returnTypeC: <\/span>‘char *’<\/span><\/span>>
\n(<\/span>self<\/span> isBaseFrame:<\/span> theFP<\/span>) <\/span>ifTrue:<\/span>
\n[stackPages <\/span>longAt:<\/span> theFP<\/span> +<\/span> FoxCallerSavedIP<\/strong><\/span> put:<\/span> anOop<\/span>.
\n<\/span>^<\/span>theFP<\/span>].
\n<\/span>self<\/span> ensureFrameIsMarried:<\/span> (<\/span>self<\/span> frameCallerFP:<\/span> theFP<\/span>).
\n<\/span>thePage<\/span> :=<\/strong> stackPages <\/span>stackPageFor:<\/span> theFP<\/span>.
\n<\/span>self<\/span> assert:<\/span> stackPage <\/span>==<\/span> stackPages <\/span>mostRecentlyUsedPage<\/span>.
\n<\/span>onCurrentPage<\/span> := thePage<\/span> ==<\/span> stackPage.
\n<\/span>onCurrentPage<\/span> ifFalse:<\/span>
\n[<\/span>“Make sure the frame’s page isn’t divorced when a new page is allocated.”<\/span>
\nstackPages <\/span>markStackPageNextMostRecentlyUsed:<\/span> thePage<\/span>].
\n<\/span>newPage<\/span> := self<\/span> newStackPage<\/span>.
\n<\/span>theMovedFP<\/span> := self<\/span> moveFramesIn:<\/span> thePage<\/span> through:<\/span> theFP<\/span> toPage:<\/span> newPage<\/span>.
\n<\/span>onCurrentPage<\/span> ifTrue:<\/span>
\n[<\/span>self<\/span> setStackPageAndLimit:<\/span> newPage<\/span>].
\n<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> isBaseFrame:<\/span> theMovedFP<\/span>).
\nstackPages <\/span>longAt:<\/span> theMovedFP<\/span> +<\/span> FoxCallerSavedIP<\/span> put:<\/span> anOop<\/span>.
\n<\/span>^<\/span>theMovedFP<\/span><\/p>\n

 <\/p>\n

moveFramesIn:<\/strong> oldPage<\/span> through:<\/strong> theFP<\/span> toPage:<\/strong> newPage<\/span>
\n<\/span>“Move frames from the hot end of oldPage through to theFP to newPage.
\nThis has the effect of making theFP a base frame which can be stored into.
\nAnswer theFP’s new location.”<\/span>
\n<\/span>|<\/span> newSP<\/span> newFP<\/span> stackedReceiverOffset<\/span> delta<\/span> callerFP<\/span> callerIP<\/span> fpInNewPage<\/span> offsetCallerFP<\/span> theContext<\/span> |<\/span>
\n<inline: <\/span>false<\/span>>
\n<var: <\/span>#oldPage<\/span> type: <\/span>#’StackPage *’<\/span>>
\n<var: <\/span>#theFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#newPage<\/span> type: <\/span>#’StackPage *’<\/span>>
\n<var: <\/span>#newSP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#newFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#callerFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#fpInNewPage<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#offsetCallerFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#source<\/span> type: <\/span>#’char *’<\/span>>
\n<returnTypeC: <\/span>‘char *’<\/span><\/span>>
\n<\/span>newSP<\/span> :=<\/strong> newPage<\/span> baseAddress<\/span> +<\/span> BytesPerWord<\/strong><\/span>.
\n<\/span>stackedReceiverOffset<\/span> :=<\/strong> self<\/span> frameStackedReceiverOffset:<\/span> theFP<\/span>.
\n<\/span>“First move the data. We will fix up frame pointers later.”<\/span>
\n<\/span>theFP<\/span> +<\/span> stackedReceiverOffset<\/span>
\n<\/span>to:<\/span> oldPage<\/span> headSP<\/span>
\n<\/span>by:<\/span> BytesPerWord<\/strong><\/span> negated<\/span>
\n<\/span>do:<\/span> [:<\/span>source<\/span>|<\/span>
\n<\/span>newSP<\/span> :=<\/strong> newSP<\/span> –<\/span> BytesPerWord<\/strong><\/span>.
\nstackPages <\/span>longAt:<\/span> newSP<\/span> put:<\/span> (<\/span>stackPages <\/span>longAt:<\/span> source<\/span>)<\/span>].
\n<\/span>“newSP = oldSP + delta => delta = newSP – oldSP”<\/span>
\n<\/span>delta<\/span> :=<\/strong> newSP<\/span> –<\/span> oldPage<\/span> headSP<\/span>.
\n<\/span>newFP<\/span> :=<\/strong> newPage<\/span> baseAddress<\/span> –<\/span> stackedReceiverOffset<\/span>.
\n<\/span>self<\/span> setHeadFP:<\/span> oldPage<\/span> headFP<\/span> +<\/span> delta<\/span> andSP:<\/span> newSP<\/span> inPage:<\/span> newPage<\/span>.
\n<\/span>newPage<\/span> baseFP:<\/span> newFP<\/span>.
\n<\/span>callerFP<\/span> :=<\/strong> self<\/span> frameCallerFP:<\/span> theFP<\/span>.
\n<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> isBaseFrame:<\/span> theFP<\/span>) <\/span>not<\/span>.
\n<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> frameHasContext:<\/span> callerFP<\/span>).
\n<\/span>callerIP<\/span> :=<\/strong> self<\/span> oopForPointer:<\/span> (<\/span>self<\/span> frameCallerSavedIP:<\/span> theFP<\/span>).
\nstackPages <\/span>longAt:<\/span> theFP<\/span> +<\/span> stackedReceiverOffset<\/span> put:<\/span> callerIP<\/span>.
\n<\/span>oldPage<\/span>
\n<\/span>headFP:<\/span> callerFP<\/span>;
\n<\/span>headSP:<\/span> theFP<\/span> +<\/span> stackedReceiverOffset<\/span>.
\n<\/span>“Mark the new base frame in the new page”<\/span>
\nstackPages <\/span>longAt:<\/span> newFP<\/span> +<\/span> FoxCallerSavedIP<\/strong><\/span> put:<\/span> (<\/span>self<\/span> frameContext:<\/span> callerFP<\/span>).
\nstackPages <\/span>longAt:<\/span> newFP<\/span> +<\/span> FoxSavedFP<\/strong><\/span> put:<\/span> 0<\/span>.
\n<\/span>“Now relocate frame pointers, updating married contexts to refer to their moved spouse frames.”<\/span>
\n<\/span>fpInNewPage<\/span> :=<\/strong> newPage<\/span> headFP<\/span>.
\n[<\/span>offsetCallerFP<\/span> :=<\/strong> self<\/span> frameCallerFP:<\/span> fpInNewPage<\/span>.
\n<\/span>offsetCallerFP<\/span> ~=<\/span> 0<\/span> ifTrue:<\/span>
\n<\/span>[<\/span>offsetCallerFP<\/span> :=<\/strong> offsetCallerFP<\/span> +<\/span> delta<\/span>]<\/span>.
\nstackPages <\/span>longAt:<\/span> fpInNewPage<\/span> +<\/span> FoxSavedFP<\/strong><\/span> put:<\/span> (<\/span>self<\/span> oopForPointer:<\/span> offsetCallerFP<\/span>)<\/span>.
\n<\/span>(<\/span>self<\/span> frameHasContext:<\/span> fpInNewPage<\/span>)<\/span> ifTrue:<\/span>
\n<\/span>[<\/span>theContext<\/span> :=<\/strong> self<\/span> frameContext:<\/span> fpInNewPage<\/span>.
\n<\/span>self<\/span> storePointerUnchecked:<\/span> SenderIndex<\/strong><\/span>
\n<\/span>ofObject:<\/span> theContext<\/span>
\n<\/span>withValue:<\/span> (<\/span>self<\/span> withSmallIntegerTags:<\/span> fpInNewPage<\/span>)<\/span>.
\n<\/span>self<\/span> storePointerUnchecked:<\/span> InstructionPointerIndex<\/strong><\/span>
\n<\/span>ofObject:<\/span> theContext<\/span>
\n<\/span>withValue:<\/span> (<\/span>self<\/span> withSmallIntegerTags:<\/span> offsetCallerFP<\/span>)<\/span>]<\/span>.
\n<\/span>fpInNewPage<\/span> :=<\/strong> offsetCallerFP<\/span>.
\n<\/span>fpInNewPage<\/span> ~=<\/span> 0<\/span>] <\/span>whileTrue<\/span>.
\n<\/span>^<\/span>newFP<\/span><\/p>\n

 <\/p>\n

It turns out that <\/span>moveFramesIn:through:toPage:<\/span> is useful for one more function that really helps performance, stack overflow. Consider what happens in the execution of benchFib:<\/span><\/p>\n

 <\/p>\n

Integer methods for benchmarks<\/em><\/span>
\n<\/span>benchFib<\/strong>
\n<\/span>^<\/span> self<\/span> <<\/span> 2<\/span>
\n<\/span>ifTrue:<\/span> [<\/span>1<\/span>]
\n<\/span>ifFalse:<\/span> [<\/span>(<\/span>self<\/span>–<\/span>1<\/span>)<\/span> benchFib<\/span> +<\/span> (<\/span>self<\/span>–<\/span>2<\/span>)<\/span> benchFib<\/span> +<\/span> 1<\/span>]<\/span><\/p>\n

If the initial argument is larger than the number of activations of nfib that can fit on the remaining room in the stack page a stack overflow will occur, and probably soon thereafter a base return back to the original stack. At some point the system will thrash doing overflowing sends and underflowing returns. When we first started using the StackInterpreter inside Qwaq benchFib for large N would do well but benchFib for small N would do badly and the problem was overflow\/underflow thrashing.<\/span><\/p>\n

The simple fix is to increase the number of frames moved on each successive overflow from the same page. On the first overflow we move one frame, on the second two and so on. Soon the thrashing is taken care of because the active frames end up located on the same page. So here’s stack overflow. It turns out we only need two variables to remember which page last overflowed and a count of frames to move.<\/p>\n

 <\/p>\n

StackInterpreter methods for frame access<\/em><\/span>
\n<\/span>stackOverflowOrEvent:<\/strong> numArgs<\/span> mayContextSwitch:<\/strong> mayContextSwitch<\/span>
\n<\/span>“The stackPointer is below the stackLimit. This is either because of a
\nstack overflow or the setting of stackLimit to indicate a possible interrupt.
\nCheck for interrupts and stackOverflow and deal with each appropriately.”<\/span>
\n<\/span>|<\/span> newPage<\/span> theFP<\/span> callerFP<\/span> overflowLimitAddress<\/span> overflowCount<\/span> |<\/span>
\n<var: <\/span>#newPage<\/span> type: <\/span>#’StackPage *’<\/span>>
\n<var: <\/span>#theFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#callerFP<\/span> type: <\/span>#’char *’<\/span>>
\n<var: <\/span>#overflowLimitAddress<\/span> type: <\/span>#’char *’<\/span>><\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“If the stackLimit differs from the realStackLimit then the stackLimit
\nhas been set to indicate an event or interrupt that needs servicing.”<\/span>
\nstackLimit <\/span>==<\/span> stackPage <\/span>realStackLimit<\/span>
\n<\/span>ifTrue:<\/span> [<\/span>self<\/span> externalWriteBackHeadFramePointers<\/span>]
\n<\/span>ifFalse:<\/span> [<\/span>self<\/span> checkForEventsMayContextSwitch:<\/span> mayContextSwitch<\/span>].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“After checkForInterrupts another event check may have been forced, setting both
\nstackLimit and stackPage stackLimit to all ones. So here we must check against
\nthe real stackLimit, not the effective stackLimit.”<\/span>
\nstackPointer <\/span><<\/span> stackPage <\/span>realStackLimit<\/span> ifFalse:<\/span>
\n[<\/span>^nil<\/span>].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0statStackOverflow <\/span>:=<\/strong> statStackOverflow <\/span>+<\/span> 1<\/span>.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“The stack has overflowed this page. If the system is executing some recursive algorithm,
\ne.g. fibonacci, then the system could thrash overflowing the stack if the call soon returns
\nback to the current page. To avoid thrashing, since overflow is quite slow, we can move
\nmore than one frame. The idea is to record which page has overflowed, and the first
\ntime it overflows move one frame, the second time two frames, and so on. We move no
\nmore frames than would leave the page half occupied.”<\/span>
\n<\/span>theFP<\/span> :=<\/strong> framePointer.
\nstackPage <\/span>==<\/span> overflowedPage
\n<\/span>ifTrue:<\/span>
\n[<\/span>overflowLimitAddress<\/span> :=<\/strong> stackPage <\/span>baseAddress<\/span> –<\/span> stackPages <\/span>overflowLimit<\/span>.
\n<\/span>overflowCount<\/span> :=<\/strong> extraFramesToMoveOnOverflow <\/span>:=<\/strong> extraFramesToMoveOnOverflow <\/span>+<\/span> 1<\/span>.
\n<\/span>[<\/span>(<\/span>overflowCount<\/span> :=<\/strong> overflowCount<\/span> –<\/span> 1<\/span>)<\/span> >=<\/span> 0<\/span>
\n<\/span>and:<\/span> [<\/span>(<\/span>callerFP<\/span> :=<\/strong> self<\/span> frameCallerFP:<\/span> theFP<\/span>)<\/span> <<\/span> overflowLimitAddress<\/span>
\n<\/span>and:<\/span> [<\/span>(<\/span>self<\/span> isBaseFrame:<\/span> callerFP<\/span>)<\/span> not<\/span>]<\/span>]<\/span>]<\/span> whileTrue:<\/span>
\n<\/span>[<\/span>theFP<\/span> :=<\/strong> callerFP<\/span>]<\/span>]
\n<\/span>ifFalse:<\/span>
\n[overflowedPage <\/span>:=<\/strong> stackPage.
\nextraFramesToMoveOnOverflow <\/span>:=<\/strong> 0<\/span>].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>self<\/span> ensureFrameIsMarried:<\/span> (<\/span>self<\/span> frameCallerFP:<\/span> theFP<\/span>).
\n<\/span>newPage<\/span> :=<\/strong> self<\/span> newStackPage<\/span>.
\n<\/span>self<\/span> moveFramesIn:<\/span> stackPage <\/span>through:<\/span> theFP<\/span> toPage:<\/span> newPage<\/span>.
\n<\/span>self<\/span> setStackPageAndLimit:<\/span> newPage<\/span>.
\nframePointer <\/span>:=<\/strong> stackPage <\/span>headFP<\/span>.
\nstackPointer <\/span>:=<\/strong> stackPage <\/span>headSP<\/span>.
\n<\/span>“To overflow the stack this must be a new frame”<\/span>
\n<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> frameHasContext:<\/span> framePointer) <\/span>not<\/span>.
\n<\/span>self<\/span> assert:<\/span> (<\/span>self<\/span> validInstructionPointer:<\/span> instructionPointer <\/span>inMethod:<\/span> method)<\/span><\/p>\n

 <\/p>\n

Garbage Collection<\/h2>\n

Before we can have a look at measurements I need to discuss garbage collection. There’s not much difficulty grabae collecitng references frm stack pages. The garbage collector simply has to traverse the frames on in-use pages. There is a need to void stack pages that are not reachable to stop them holding onto garbage, but this also is easy. The major problem is the Squeak VM’s habit of running the garbage collector inside an allocation when memory runs out. This is a feature it shares with a number of other garbage collectors in VMs and it is difficult to be emphatic enough when saying how horrible this is. It is incredibly difficult to live with and a huge source of bugs. Because the garbage collector can run, and hence move objects, on any allocation the VM must hold onto all unreferenced intermediate results it is using while allocating. For example, look at the start of the basic allocation routine in the standard Squeak VM:<\/p>\n

ObjectMemory methods for allocation<\/em>
\nallocate:<\/strong> byteSize<\/span> headerSize:<\/strong> hdrSize<\/span> h1:<\/strong> baseHeader<\/span> h2:<\/strong> classOop<\/span> h3:<\/strong> extendedSize<\/span> doFill:<\/strong> doFill<\/span> with:<\/strong> fillWord<\/span>
\n<\/span>“Allocate a new object of the given size and number of header words. (Note: byteSize already includes space for the base header word.) Initialize the header fields of the new object and fill the remainder of the object with the given value.
\nMay cause a GC”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>|<\/span> newObj<\/span> remappedClassOop<\/span> end<\/span> i<\/span> |<\/span>
\n<inline: <\/span>true<\/span>>
\n<var: <\/span>#i<\/span> type: <\/span>‘usqInt’<\/span><\/span>>
\n<var: <\/span>#end<\/span> type: <\/span>‘usqInt’<\/span><\/span>>
\n<\/span>“remap classOop in case GC happens during allocation”<\/span>
\n<\/span>hdrSize<\/span> ><\/span> 1<\/span> ifTrue:<\/span> [<\/span>self<\/span> pushRemappableOop:<\/span> classOop<\/span>].
\n<\/span>newObj<\/span> :=<\/strong> self<\/span> allocateChunk:<\/span> byteSize<\/span> +<\/span> (<\/span>hdrSize<\/span> –<\/span> 1<\/span> *<\/span> BytesPerWord<\/strong><\/span>).
\n<\/span>hdrSize<\/span> ><\/span> 1<\/span> ifTrue:<\/span> [<\/span>remappedClassOop<\/span> :=<\/strong> self<\/span> popRemappableOop<\/span>].
\n… etc …<\/span><\/p>\n

 <\/p>\n

Because allocateChunk might cause the GC to run the classOop might move and hence the “solution” (read “slow inconvenient hack”) is to provide a stack to hold intermediate results (<\/span>pushRemappableOop:\/popRemappableOop<\/span>) whose contents the GC updates when it runs. So where is the latent bug in the standard perform primitive?<\/span><\/p>\n

 <\/p>\n

Interpreter methods for control primitives<\/em><\/span>
\nprimitivePerform<\/strong>
\n<\/span>|<\/span> performSelector<\/span> newReceiver<\/span> selectorIndex<\/span> lookupClass<\/span> performMethod<\/span> |<\/span>
\n<\/span>performSelector<\/span> :=<\/strong> messageSelector.
\n<\/span>performMethod<\/span> :=<\/strong> newMethod.
\nmessageSelector <\/span>:=<\/strong> self<\/span> stackValue:<\/span> argumentCount <\/span>–<\/span> 1<\/span>.
\n<\/span>newReceiver<\/span> :=<\/strong> self<\/span> stackValue:<\/span> argumentCount.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“NOTE: the following lookup may fail and be converted to #doesNotUnderstand:, so we must adjust argumentCount and slide args now, so that would work.”<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“Slide arguments down over selector”<\/span>
\nargumentCount <\/span>:=<\/strong> argumentCount <\/span>–<\/span> 1<\/span>.
\n<\/span>selectorIndex<\/span> :=<\/strong> self<\/span> stackPointerIndex<\/span> –<\/span> argumentCount.
\n<\/span>self<\/span>
\n<\/span>transfer:<\/span> argumentCount
\n<\/span>fromIndex:<\/span> selectorIndex<\/span> +<\/span> 1<\/span>
\n<\/span>ofObject:<\/span> activeContext
\n<\/span>toIndex:<\/span> selectorIndex<\/span>
\n<\/span>ofObject:<\/span> activeContext.
\n<\/span>self<\/span> pop:<\/span> 1<\/span>.
\n<\/span>lookupClass<\/span> :=<\/strong> self<\/span> fetchClassOf:<\/span> newReceiver<\/span>.
\n<\/span>self<\/span> findNewMethodInClass:<\/span> lookupClass<\/span>.<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0<\/span>“Only test CompiledMethods for argument count – other objects will have to take their chances”<\/span>
\n(<\/span>self<\/span> isCompiledMethod:<\/span> newMethod)
\n<\/span>ifTrue:<\/span> [<\/span>self<\/span> success:<\/span> (<\/span>self<\/span> argumentCountOf:<\/span> newMethod<\/span>)<\/span> =<\/span> argumentCount].<\/span><\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0successFlag
\n<\/span>ifTrue:<\/span> [<\/span>self<\/span> executeNewMethodFromCache<\/span>.
\n<\/span>“Recursive xeq affects successFlag”<\/span>
\nsuccessFlag <\/span>:=<\/strong> true<\/span>]
\n<\/span>ifFalse:<\/span> [<\/span>“Slide the args back up (sigh) and re-insert the selector. “<\/span>
\n<\/span>1<\/span> to:<\/span> argumentCount <\/span>do:<\/span> [<\/span>:<\/span>i<\/span> |<\/span> self<\/span>
\n<\/span>storePointer:<\/span> argumentCount <\/span>–<\/span> i<\/span> +<\/span> 1<\/span> +<\/span> selectorIndex<\/span>
\n<\/span>ofObject:<\/span> activeContext
\n<\/span>withValue:<\/span> (<\/span>self<\/span> fetchPointer:<\/span> argumentCount <\/span>–<\/span> i<\/span> +<\/span> selectorIndex<\/span> ofObject:<\/span> activeContext<\/span>)<\/span>]<\/span>.
\n<\/span>self<\/span> unPop:<\/span> 1<\/span>.
\n<\/span>self<\/span> storePointer:<\/span> selectorIndex<\/span>
\n<\/span>ofObject:<\/span> activeContext
\n<\/span>withValue:<\/span> messageSelector.
\nargumentCount <\/span>:=<\/strong> argumentCount <\/span>+<\/span> 1<\/span>.
\nnewMethod <\/span>:=<\/strong> performMethod<\/span>.
\nmessageSelector <\/span>:=<\/strong> performSelector<\/span>]<\/span><\/p>\n

Well if the perform is not understood there will be an allocation of a Message within findNewMethodInClass:<\/span>, which may cause a GC, and if the new method doesn’t have the right number of arguments the statements
\n
\nnewMethod <\/span>:=<\/strong> performMethod<\/span>.
\nmessageSelector <\/span>:=<\/strong> performSelector<\/span><\/p>\n

may assign invalid pointers to newMethod and messageSelector. It might bite only once in a blue moon but those are the worst kind.<\/p>\n

Things are far worse in the StackInterpreter since any send, or assignment to a context instance variable, may cause an entire stack pages worth of contexts to be allocated as a stack page’s frames are divorced so that the page can be reused. It is simply intolerable to live with pushRemappableOop:\/popRemappableOop<\/span> scheme. It has to go, or at least only rear its ugly head occasionally.<\/p>\n

The change is to maintain sufficient free space such that we can at least allocate a page worth of contexts, scheduling a GC as soon as we’ve started eating into this reserve, but deferring the garbage collection until a safe point. I won’t bore you wth the details, but there’s a subclass of ObjectMemory called NewObjectMemory that coordinates this providing a set of eeInstantiate<\/span>* methods (for execution engine) that the VM uses for objects allocated in the course of execution (contexts, closures and messages for doesNotUnderstand:<\/span>). It then only runs the garbage collector in checkForEventsMayContextSwitch:<\/span>. The standard allocation primitives primitiveNew<\/span> and primitiveNewWithArg<\/span> still use the old scheme which is also provided for plugins so that they don’t have to be rewritten, but inside the interpreter the remapBuffer is shunned entirely.<\/p>\n

Proportions, Profiles and Prospects<\/h2>\n

This stack organization does make a difference all by itself. The StackInterpreter is substantially faster for activation\/return benchmarks and insubstantially slower for process switch benchmarks. Here are the results of four benchmarks comparing the StackInterpreter against the standard context Interpreter. Both are compiled using the Intel C compiler and run on my 2.16GHz Intel Core Duo MacBook Pro.<\/span><\/p>\n

 <\/p>\n

{[self nbody: 200000 to: t1]}
\ntook 5.289 seconds
\nratio: 0.69 % change: -30.95%<\/code><\/p>\n

{[self binarytrees: 15 to: t1]}
\ntook 7.583 seconds
\nratio: 0.526 % change: -47.4%<\/code><\/p>\n

{[self chameneosredux: 260000 to: t1]}
\ntook 7.095 seconds
\nratio: 0.837 % change: -16.31%<\/p>\n

 <\/p>\n

{[self threadring: 10000000]}
\ntook 8.263 seconds
\nratio: 0.948 % change: -5.22%
\ngeometric mean 0.733 average speedup -26.74%<\/code><\/p>\n

These benchmarks are taken directly from the Squeak versions on the computer language shootout<\/a> site (thanks Isaac!!).<\/p>\n

nbody is a floating-point intensive N-body simulation of the Sun, Jupiter, Saturn, Uranus and Neptune. Some of the speedup (about a third) is due to improvements in the primitive floating point code (the use of compact class indices if you must know).<\/p>\n

binarytrees is an allocation heavy binary tree creation and traversal benchmark. It benefits both from the stack organization and the GC changes.<\/p>\n

Chameneos is a symbolic computation that compares many pairs of objects in one of three states, the colours red, blue and yellow.<\/p>\n

threadring is a thread benchmark that passes a token between 503 Smalltalk processes.<\/p>\n

As you can see we get worth-while speedups for everything except threadring, and that threading is not any slower.<\/p>\n

Running Qwaq Forums<\/a>, Qwaq’s business communications solution written in Croquet, we see about a 15% improvement both in loading times and in frame rate. And we’re getting ready to release this VM to the public as I write. I’ll be putting a version for general consumption in a Monticello repository near you real soon now\u00e2\u201e\u00a2.<\/p>\n

If we compare the profiles of benchFib for the context Interpreter
\n
\n<\/span> \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\/Users\/eliot\/Qwaq\/QFCI1.2.28.app\/Contents\/MacOS\/Qwaq VM eem 12\/30\/2008 18:31<\/code><\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a039 benchFib<\/code><\/p>\n

gc prior. clear prior.
\n25.496 seconds; sampling frequency 1465 hz
\n37317 samples in the Interpreter \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(37347 samples in the entire program) 99.92% of total<\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0% of interpret (% of total) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(samples) (cumulative)
\n13.46% (13.45%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0internalActivateNewMethod \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(5023) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(13.46%)
\n12.90% (12.89%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0bytecodeDispatch \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(4815) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(26.36%)
\n6.40% ( 6.39%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0internalStoreContextRegisters \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(2387) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(32.76%)
\n5.99% ( 5.99%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0commonReturn \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(2237) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(38.75%)
\n5.54% ( 5.53%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0lookupInMethodCacheSelclass \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(2067) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(44.29%)
\n5.53% ( 5.53%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0bytecodePrimAdd \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(2065) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(49.83%)
\n5.38% ( 5.37%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0normalSend \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(2007) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(55.21%)
\n4.95% ( 4.95%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0bytecodePrimSubtract \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(1847) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(60.15%)
\n4.62% ( 4.61%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0pushReceiverBytecode \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(1723) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(64.77%)
\n4.21% ( 4.20%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0internalFetchContextRegisters \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(1570) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(68.98%)
\n3.94% ( 3.94%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0pushConstantOneBytecode \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(1471) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(72.92%)
\n3.93% ( 3.92%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0recycleContextIfPossible \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(1465) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(76.85%)
\n3.08% ( 3.08%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L1internalFetchContextRegisters \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(1151) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(79.93%)
\n2.86% ( 2.86%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0internalQuickCheckForInterrupts \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(1068) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(82.79%)
\n2.81% ( 2.81%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0pushConstantTwoBytecode \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(1049) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(85.60%)
\n2.63% ( 2.63%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0sendLiteralSelectorBytecode \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(981) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(88.23%)
\n2.33% ( 2.33%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0returnTopFromMethod \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(869) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(90.56%)
\n2.22% ( 2.21%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0internalExecuteNewMethod \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(827) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(92.78%)
\n2.07% ( 2.07%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0booleanCheat \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(774) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(94.85%)
\n1.68% ( 1.68%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0pushReceiverVariableBytecode \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(626) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(96.53%)
\n1.46% ( 1.46%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0longUnconditionalJump \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(546) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(97.99%)
\n1.17% ( 1.17%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0bytecodePrimLessThan \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(436) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(99.16%)
\n0.84% ( 0.84%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0storePointerofObjectwithValue \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(312) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(100.0%)
\n0.00% ( 0.00%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0...others... \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(1) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(100.0%)<\/code><\/p>\n

to that of the StackInterpreter<\/p>\n

\/Users\/eliot\/Qwaq\/QFSI1.2.28.app\/Contents\/MacOS\/Qwaq VM eem 1\/14\/2009 12:23
\neden size: 262,144 stack pages: 8<\/code><\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a039 benchFib<\/code><\/p>\n

gc prior. clear prior.
\n18.282 seconds; sampling frequency 1467 hz
\n26575 samples in the Interpreter \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(26824 samples in the entire program) 99.07% of total<\/p>\n

 <\/p>\n

\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0% of interpret (% of total) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(samples) (cumulative)
\n20.17% (19.99%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0bytecodeDispatch \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(5361) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(20.17%)
\n9.13% ( 9.05%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0internalActivateNewMethod \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(2427) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(29.31%)
\n8.87% ( 8.79%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0internalFindNewMethod \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(2357) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(38.17%)
\n8.58% ( 8.50%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0bytecodePrimAdd \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(2279) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(46.75%)
\n7.41% ( 7.34%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0commonCallerReturn \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(1968) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(54.16%)
\n7.35% ( 7.28%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0bytecodePrimSubtract \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(1952) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(61.50%)
\n6.20% ( 6.14%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0sendLiteralSelector0ArgsBytecode \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(1647) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(67.70%)
\n5.98% ( 5.92%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0pushReceiverBytecode \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(1588) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(73.67%)
\n4.77% ( 4.72%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0pushConstantOneBytecode \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(1267) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(78.44%)
\n4.24% ( 4.20%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0pushConstantTwoBytecode \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(1126) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(82.68%)
\n4.04% ( 4.00%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0booleanCheat \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(1074) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(86.72%)
\n3.71% ( 3.68%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0bytecodePrimLessThan \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(987) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(90.43%)
\n2.40% ( 2.38%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0pushReceiverVariableBytecode \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(638) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(92.84%)
\n2.29% ( 2.27%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0internalExecuteNewMethod \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(608) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(95.12%)
\n1.86% ( 1.84%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0longUnconditionalJump \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(493) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(96.98%)
\n1.77% ( 1.76%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0commonReturn \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(471) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(98.75%)
\n0.66% ( 0.66%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0slowPrimitiveResponse \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(176) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(99.41%)
\n0.56% ( 0.56%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0returnTopFromMethod \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(149) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(99.97%)
\n0.02% ( 0.02%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0L0baseReturn \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(6) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(100.0%)
\n0.00% ( 0.00%) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0...others... \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0 \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(1) \u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0\u00c2\u00a0(100.0%)<\/code><\/p>\n

we can see where this speedup comes. All of the context management on send and return is substantially cheaper and we see a noticeable increase in the cost of bytecode dispatch, showing that the VM has more time to do real work.<\/p>\n

But 15% improvement is nothing for a system that, at least for activation\/return benchmarks like benchFib, is some 20 times slower than VisualWorks. The overhead of bytyecode dispatch shows where we have to go next. We need to execute machine code rather than interpret bytecode. We need a JIT.<\/p>\n

The StackInterpreter is an intermediate step after closures and before the JIT to ensure steady progress and on-time delivery of a substantially faster VM. The essential point, of course, is that a stack organization suits the use of native call and return instructions whose use, along with in-line cacheing techniques, substantially improve send and return performance. As you can see in my Simulate Out Of The Bochs<\/a> post I’ve already started work on the JIT and I hope to be far more current in my blog posts about it than I’ve been on the StackInterpreter. Apologies.<\/p>\n

I’m already enjoying this year immensely. The JIT, the first I’ve ever written in Smalltalk, is a delight. I hope to blog about it soon.<\/p>\n

Thanks for reading.<\/p>\n

\t
\t\t \t\t\"\"<\/a> \t\t  <\/span> \t\tSend article as PDF<\/span> \t\t  <\/span> \t\t \t\t \t<\/form> <\/div>","protected":false},"excerpt":{"rendered":"

Nobody expects the Smalltalk language system. Our chief weapon is polymorphism… polymorphism and objects…objects and polymorphism. Our two weapons are objects and polymorphism… and inheritance… Our three weapons are objects, and polymorphism and inheritance… and an almost fanatical devotion to contexts… Our four…no… Amongst our weapons… Amongst our weaponry… are such elements as objects, po… […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[3],"tags":[],"_links":{"self":[{"href":"http:\/\/www.mirandabanda.org\/cogblog\/wp-json\/wp\/v2\/posts\/18"}],"collection":[{"href":"http:\/\/www.mirandabanda.org\/cogblog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/www.mirandabanda.org\/cogblog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/www.mirandabanda.org\/cogblog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/www.mirandabanda.org\/cogblog\/wp-json\/wp\/v2\/comments?post=18"}],"version-history":[{"count":12,"href":"http:\/\/www.mirandabanda.org\/cogblog\/wp-json\/wp\/v2\/posts\/18\/revisions"}],"predecessor-version":[{"id":389,"href":"http:\/\/www.mirandabanda.org\/cogblog\/wp-json\/wp\/v2\/posts\/18\/revisions\/389"}],"wp:attachment":[{"href":"http:\/\/www.mirandabanda.org\/cogblog\/wp-json\/wp\/v2\/media?parent=18"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.mirandabanda.org\/cogblog\/wp-json\/wp\/v2\/categories?post=18"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.mirandabanda.org\/cogblog\/wp-json\/wp\/v2\/tags?post=18"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}