Rounding in MatrixTransform2x3

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
4 messages Options
Reply | Threaded
Open this post in threaded view
|

Rounding in MatrixTransform2x3

stlutz

While transforming points using MatrixTransform2x3 we noticed some strange rounding behavior:

"with plugin"
(MatrixTransform2x3 withOffset: 5 @ 10) localPointToGlobal: 0@0. "5@10"
(MatrixTransform2x3 withOffset: -5 @ -10) localPointToGlobal: 0@0. "-4@ -9"

"without plugin"
((MatrixTransform2x3 withOffset: 5 @ 10) transformPoint: 0@0) rounded. "5@10"
((MatrixTransform2x3 withOffset: -5 @ -10) transformPoint: 0@0) rounded. "-5@ -10"

It appears the code used to round in the plugin simply adds 0.5 and truncates the result, which does not work correctly for negative numbers.
This code can be found in Matrix2x3Plugin >> #roundAndStoreResultPoint: and Matrix2x3Plugin >> #roundAndStoreResultRect:x0:y0:x1:y1: .

----

On a kind of related note: Is there even a reason to round the resulting floats?

While the class comment of MatrixTransform2x3 notes that this behavior is intentional, glancing quickly over its uses we could not find anything taking advantage or benefiting from it. It's also not a limitation of the DisplayTransform interface, since MorphicTransform does produce floating point values. Wouldn't it be much more versatile and easier to leave rounding to users if they actually need it?


Stephan



Reply | Threaded
Open this post in threaded view
|

Re: Rounding in MatrixTransform2x3

Vanessa Freudenberg
On Tue, Jul 28, 2020 at 4:34 AM Stephan Lutz <[hidden email]> wrote:

While transforming points using MatrixTransform2x3 we noticed some strange rounding behavior:

"with plugin"
(MatrixTransform2x3 withOffset: 5 @ 10) localPointToGlobal: 0@0. "5@10"
(MatrixTransform2x3 withOffset: -5 @ -10) localPointToGlobal: 0@0. "-4@ -9"

"without plugin"
((MatrixTransform2x3 withOffset: 5 @ 10) transformPoint: 0@0) rounded. "5@10"
((MatrixTransform2x3 withOffset: -5 @ -10) transformPoint: 0@0) rounded. "-5@ -10"

It appears the code used to round in the plugin simply adds 0.5 and truncates the result, which does not work correctly for negative numbers.
This code can be found in Matrix2x3Plugin >> #roundAndStoreResultPoint: and Matrix2x3Plugin >> #roundAndStoreResultRect:x0:y0:x1:y1: .

----

On a kind of related note: Is there even a reason to round the resulting floats?

While the class comment of MatrixTransform2x3 notes that this behavior is intentional, glancing quickly over its uses we could not find anything taking advantage or benefiting from it. It's also not a limitation of the DisplayTransform interface, since MorphicTransform does produce floating point values. Wouldn't it be much more versatile and easier to leave rounding to users if they actually need it?

No. Having a float result means that the primitive would need to allocate two Float objects. Any allocation can fail due to memory exhaustion. So the primitive would have to be made to retry the allocation after running a garbage collection.

Secondly, its results are primarily used to set up a WarpBlt IIRC, for drawing rotated user objects in Etoys. WarpBlt fails if the coords are not integers. The failure code rounds the numbers and retries. Doing the rounding in the matrix primitives ensured a fast path to rendering - that's why it was done that way.

So, there are very good reasons why the plugin returns integers. And there are Squeak VMs where this still is a very reasonable behavior. It also would be a good idea to document the reasoning in the class comment of MatrixTransform2x3.

That being said, there is virtually no reason to use it when running on Cog, much less Sista, especially on 64 bits where we have immediate floats. An interesting thing would be to compare a pure Smalltalk implementation to the performance of the plugin. If you need floating point transform results, just write it in Smalltalk, would be my suggestion.

- Vanessa -


Reply | Threaded
Open this post in threaded view
|

Re: Rounding in MatrixTransform2x3

Ron Teitelbaum
>> On Tue, Jul 28, 2020 at 4:34 AM Stephan Lutz <[hidden email]>  
>>It appears the code used to round in the plugin simply adds 0.5 and truncates the result, which does not work correctly for negative numbers.
>>This code can be found in Matrix2x3Plugin >> #roundAndStoreResultPoint: and Matrix2x3Plugin >> #roundAndStoreResultRect:x0:y0:x1:y1: .  
Rounding up for negative numbers is wrong.

  (MatrixTransform2x3 withOffset: -5 @ -10) localPointToGlobal: 0@0. "-4@ -9"  

All the best,

Ron Teitelbaum



Reply | Threaded
Open this post in threaded view
|

Re: Rounding in MatrixTransform2x3

stlutz
In reply to this post by Vanessa Freudenberg

Ah, yes. I hadn't even thought about that. Probably because I've only ever used Squeak on 64bits with immediate floats ^^.

I followed your suggestion and implemented a Matrix2x3 in pure Smalltalk.
It's actually really fast and surprisingly even beats the existing implementation in quite a few cases. :D
Most notably, the plugin-supported point transformation (localPointToGlobal:) is actually slower on my machine.
Only the transformation of multiple points at a time, as done in localBoundsToGlobal: is significantly (~3x) faster using the plugin.

Below are some of the measurements I have taken in a 64bit trunk image using squeak.cog.spur_linux64x64:

"--------------------------------"
" localPointToGlobal: "
"--------------------------------"
[mat2x3Old localPointToGlobal: -10 @ 10] bench.
" '11,700,000 per second. 85.6 nanoseconds per run. 1.43971 % GC time.'"

[mat2x3Old transformPoint: -10 @ 10] bench.
" '2,330,000 per second. 429 nanoseconds per run. 0.37985 % GC time.'"

[mat2x3New localPointToGlobal: -10 @ 10] bench.
" '12,500,000 per second. 80.3 nanoseconds per run. 1.89962 % GC time.'"

[morphic localPointToGlobal: -10 @ 10] bench.
" '2,710,000 per second. 370 nanoseconds per run. 1.16 % GC time.'"

"--------------------------------"
" localBoundsToGlobal: "
"--------------------------------"
[mat2x3Old localBoundsToGlobal: rect] bench.
" '6,770,000 per second. 148 nanoseconds per run. 1.67966 % GC time.'"

[mat2x3New localBoundsToGlobal: rect] bench.
" '2,090,000 per second. 480 nanoseconds per run. 1.55969 % GC time.'"

[morphic localBoundsToGlobal: rect] bench.
" '505,000 per second. 1.98 microseconds per run. 1.95922 % GC time.'"

"--------------------------------"
" localBoundsToGlobal: (pure translation) "
"--------------------------------"
[mat2x3OldTranslation localBoundsToGlobal: rect] bench.
" '6,780,000 per second. 147 nanoseconds per run. 1.7 % GC time.'"

[mat2x3NewTranslation localBoundsToGlobal: rect] bench.
" '5,860,000 per second. 171 nanoseconds per run. 1.48 % GC time.'"

[morphicTranslation localBoundsToGlobal: rect] bench.
" '1,580,000 per second. 631 nanoseconds per run. 4.12 % GC time.'"

"--------------------------------"
"composedWithLocal:"
"--------------------------------"
[mat2x3Old composedWithLocal: mat2x3OldRotation] bench.
" '9,670,000 per second. 103 nanoseconds per run. 1.19976 % GC time.'"

[mat2x3New composedWithLocal: mat2x3NewRotation] bench.
" '6,920,000 per second. 144 nanoseconds per run. 1.4997 % GC time.'"

[morphic composedWithLocal: morphicRotation] bench.
" '11,100,000 per second. 89.8 nanoseconds per run. 1.09978 % GC time.'"

"--------------------------------"
" instance creation "
"--------------------------------"
[MatrixTransform2x3 withOffset: offset] bench.
" '3,320,000 per second. 301 nanoseconds per run. 1.91962 % GC time.'"

[Matrix2x3 withOffset: offset] bench.
" '24,800,000 per second. 40.3 nanoseconds per run. 10.63787 % GC time.'"

[MorphicTransform offset: offset] bench.
" '43,600,000 per second. 22.9 nanoseconds per run. 7.63847 % GC time.'"


There are quite a few more benchmarks in the attached file.
I have also attached a change set of the implementation I used, so you can try it out for yourselves if you'd like :)

Cheers
Stephan

On 28.07.20 19:33, Vanessa Freudenberg wrote:
On Tue, Jul 28, 2020 at 4:34 AM Stephan Lutz <[hidden email]> wrote:

While transforming points using MatrixTransform2x3 we noticed some strange rounding behavior:

"with plugin"
(MatrixTransform2x3 withOffset: 5 @ 10) localPointToGlobal: 0@0. "5@10"
(MatrixTransform2x3 withOffset: -5 @ -10) localPointToGlobal: 0@0. "-4@ -9"

"without plugin"
((MatrixTransform2x3 withOffset: 5 @ 10) transformPoint: 0@0) rounded. "5@10"
((MatrixTransform2x3 withOffset: -5 @ -10) transformPoint: 0@0) rounded. "-5@ -10"

It appears the code used to round in the plugin simply adds 0.5 and truncates the result, which does not work correctly for negative numbers.
This code can be found in Matrix2x3Plugin >> #roundAndStoreResultPoint: and Matrix2x3Plugin >> #roundAndStoreResultRect:x0:y0:x1:y1: .

----

On a kind of related note: Is there even a reason to round the resulting floats?

While the class comment of MatrixTransform2x3 notes that this behavior is intentional, glancing quickly over its uses we could not find anything taking advantage or benefiting from it. It's also not a limitation of the DisplayTransform interface, since MorphicTransform does produce floating point values. Wouldn't it be much more versatile and easier to leave rounding to users if they actually need it?

No. Having a float result means that the primitive would need to allocate two Float objects. Any allocation can fail due to memory exhaustion. So the primitive would have to be made to retry the allocation after running a garbage collection.

Secondly, its results are primarily used to set up a WarpBlt IIRC, for drawing rotated user objects in Etoys. WarpBlt fails if the coords are not integers. The failure code rounds the numbers and retries. Doing the rounding in the matrix primitives ensured a fast path to rendering - that's why it was done that way.

So, there are very good reasons why the plugin returns integers. And there are Squeak VMs where this still is a very reasonable behavior. It also would be a good idea to document the reasoning in the class comment of MatrixTransform2x3.

That being said, there is virtually no reason to use it when running on Cog, much less Sista, especially on 64 bits where we have immediate floats. An interesting thing would be to compare a pure Smalltalk implementation to the performance of the plugin. If you need floating point transform results, just write it in Smalltalk, would be my suggestion.

- Vanessa -


    



mat2x3-benchmarks.st (9K) Download Attachment
Matrix2x3.1.cs (8K) Download Attachment