[squeak-dev] New Window VM (Closures, FT2Plugin, Large Cursors)

On Sat, 07 Mar 2009 17:10:13 +0100, Andreas Raab wrote:

Klaus D. Witzel wrote:

A closure image (for those interested):
http://squeakvm.org/win32/release/Squeak-3.10.2-Closures.zip

Note that I consider this an "alpha" version since there is a goodly bit of new and untested stuff in it. I'm in particular interested in finding people to test large cursor support and the FT2Plugin.

Feedback is highly welcome.

 I can't see why but the 3.11.1 VM refuses to open Squeak-3.10.2-Closures.image :( windoze (vista) pops up a small window with Squeak! in title bar and message text "Could not open image file". FWIW the .image file has 15.367 KB.

That's very odd. I just tried a clean download and it works fine for me here. The image size should be 15,735,052 bytes. Can you download the image again and see if you still have that problem?

Did that, now it opens and shows "This is a closure-converted image. You will not be able to run this image with pre-3.11 VMs. etc" thanks again.

Can someone else confirm or deny whether that image works for them?

Cheers,
  - Andreas

--
"If at first, the idea is not absurd, then there is no hope for it". Albert Einstein

On Sat, 07 Mar 2009 18:51:01 +0100, Eliot Miranda wrote:

Hi Klaus,

Hi Eliot,

great job, native closures-support was overdue and is appreciated by the Squeakers.

multiply := Array new: 4.
1 to: 4 do: [:i |
       multiply at: i put: [:x | x * i].
].

And you would rightfully assume that this is equivalent to the version above, just more concise. But now try again:

(multiply at: 3) value: 5.

The answer will, surprisingly, not be 15 in current Squeak.

But with closures, the blocks would behave as expected. They are said to "close over" the state that the bound variables (i in this case) had at the time the block was created.

So basically, you can use blocks as you always have, but they will behave as you might have assumed they would.

On 08.03.2009, at 18:13, Rob Rothwell wrote:

On Sun, Mar 8, 2009 at 12:38 PM, Bert Freudenberg <[hidden email]> wrote:

multiply := Array new: 4.
1 to: 4 do: [:i |
      multiply at: i put: [:x | x * i].
].

And you would rightfully assume that this is equivalent to the version above, just more concise. But now try again:

(multiply at: 3) value: 5.

The answer will, surprisingly, not be 15 in current Squeak.

You are right!  25, in fact...

But with closures, the blocks would behave as expected. They are said to "close over" the state that the bound variables (i in this case) had at the time the block was created.

So...VW does this "right," I guess, since I get 15 in VW NC 7.6?

Yes, it has block closures.

So basically, you can use blocks as you always have, but they will behave as you might have assumed they would.

So the recent VM work discussed handles this?  I will have to give that a try!

Thanks for the explanation!  The next question, of course, is WHY does it get 25 and not 15... ;)

Because instead of "closing over" the current value of i when the block is created, all the blocks share the same reference to i, which is actually another temporary variable of the method, instead of being local to the block. So when the block is evaluated later, the last value of i is used.

Now you might still expect that last value of i to be 4, but actually "1 to: 4 do:" is expanded by the compiler to a while loop like "i := 1. [i <= 4] whileTrue: [i := i + 1]", so it actually is 5 after the loop terminates.

And all this is avoided by having real closures, the i would indeed be local to the block and not a shared temp.

- Bert -

That is the bug Eliot was referring to earlier. The loop variable in optimized to:do: loops wasn't handled correctly. Try this instead:

       multiply := Array new: 4.
       (1 to: 4) do: [:i |
               multiply at: i put: [:x | x * i].
       ].

Note the parens around "1 to: 4" which prevents the block from being optimized.

Cheers,
 - Andreas


Rob Rothwell wrote:

Ok...thanks...this is making sense!

So...should I get the "right answer" with the new VM and the 3.10.2-Closures image?

Because...I still get 25!

Rob

On Sun, Mar 8, 2009 at 2:01 PM, Bert Freudenberg <[hidden email] <mailto:[hidden email]>> wrote:

   On 08.03.2009, at 18:13, Rob Rothwell wrote:

       On Sun, Mar 8, 2009 at 12:38 PM, Bert Freudenberg

       <[hidden email] <mailto:[hidden email]>> wrote:

           multiply := Array new: 4.
           1 to: 4 do: [:i |
                 multiply at: i put: [:x | x * i].
           ].

           And you would rightfully assume that this is equivalent to
           the version above, just more concise. But now try again:

           (multiply at: 3) value: 5.

           The answer will, surprisingly, not be 15 in current Squeak.


       You are right!  25, in fact...

           But with closures, the blocks would behave as expected. They
           are said to "close over" the state that the bound variables
           (i in this case) had at the time the block was created.


       So...VW does this "right," I guess, since I get 15 in VW NC 7.6?


   Yes, it has block closures.


           So basically, you can use blocks as you always have, but
           they will behave as you might have assumed they would.

       So the recent VM work discussed handles this?  I will have to
       give that a try!

       Thanks for the explanation!  The next question, of course, is
       WHY does it get 25 and not 15... ;)



   Because instead of "closing over" the current value of i when the
   block is created, all the blocks share the same reference to i,
   which is actually another temporary variable of the method, instead
   of being local to the block. So when the block is evaluated later,
   the last value of i is used.

   Now you might still expect that last value of i to be 4, but
   actually "1 to: 4 do:" is expanded by the compiler to a while loop
   like "i := 1. [i <= 4] whileTrue: [i := i + 1]", so it actually is 5
   after the loop terminates.

   And all this is avoided by having real closures, the i would indeed
   be local to the block and not a shared temp.

   - Bert -

------------------------------------------------------------------------

So basically, you can use blocks as you always have, but they will behave as you might have assumed they would.

On Sun, Mar 8, 2009 at 12:38 PM, Bert Freudenberg <[hidden email]> wrote:

multiply := Array new: 4.
1 to: 4 do: [:i |
       multiply at: i put: [:x | x * i].
].

And you would rightfully assume that this is equivalent to the version above, just more concise. But now try again:

(multiply at: 3) value: 5.

The answer will, surprisingly, not be 15 in current Squeak.

You are right!  25, in fact...
 

But with closures, the blocks would behave as expected. They are said to "close over" the state that the bound variables (i in this case) had at the time the block was created.

So...VW does this "right," I guess, since I get 15 in VW NC 7.6? 

So basically, you can use blocks as you always have, but they will behave as you might have assumed they would.

So the recent VM work discussed handles this?  I will have to give that a try!

Thanks for the explanation!  The next question, of course, is WHY does it get 25 and not 15... ;)

Rob