Jim,
Here is an updated webrev:
http://cr.openjdk.java.net/~lbourges/marlin/marlin-s3.1/
Changes:
- enabled CHECK_NAN and CHECK_OVERFLOW to be correct for now
- renamed faster alternatives as int ceil_int(float) and float
floor_int(float) that are faster in the integer domain
- restored ceil_f / floor_f (float) methods that are strictly correct as
(float) StrictMath.ceil/floor(double)
- made FloatMath class and its methods public to be available for tests
and maybe more general use in graphics / java2d ...
It is still faster than previous FloatMath and Marlin is a bit faster too:
see results at then end !
Here are few comments on joe's proposal:
>> I could propose my implementations of float ceil/floor (float) that are
>> exactly giving the same results than (float)StrictMath.ceil/floor
(double).
>> According to my benchmarks, it is 25% faster.
>
>
> I don't think we need to limit ourselves to either StrictMath or Math. We
simply need something predictable that has properties which work for our needs.
>
I was just proposing the 2 methods float ceil/floor (float) (derived
from StrictMath) to be included the core libs if it is useful for
general use (25% faster).
Joe, are you interested by ceil_f / floor_f variants (25% faster than
StrictMath) ?
So, you can *almost* get away with
int ceil_returning_int(floor f) {
if (f > 0.0)
return - ((int)(-f))
else
return (int) f;
}
int floor_returning_int(floor f) {
if (f < 0.0)
return - ((int)(-f))
else
return (int) f;
}
I tried joe's proposal but it does not work:
Round to zero is not equivalent to ceil or floor !
In what way do Joe's techniques fail? Integer casts should be a truncate operation (is
that what you refer to as "round to zero"?) and should be the same as floor()
for non-negative numbers and -((int)(-v)) should be the same as floor for negative
numbers...
I tried and it does not work
ceil (1.2)=2
But (int)(-1.2)=-1 (round to zero).
So the result is 1 and not 2 !
That's why my variant adds/substract 1 !
But it make infinity / nan handling more painful and a bit costly.
Jim, I will next make tests:
1/ use proper and consistent ceil(coord - 0.5) as you did in openpisces (FX)
2/ use fixed point approach (longer work) to only use integer maths in
Marlin rendering loop (crossings)
=> faster (no float to int conversions ?) but also more scalable on
hyperThreading CPU ?
=> edge array will then only contain int[] and Unsafe usage is no more
necessary
Cheers,
Laurent
PS: Here are some benchmark results made on values only in the integer
domain:
JVM START: 1.8.0_60-ea [Java HotSpot(TM) 64-Bit Server VM 25.60-b18]
floats = [-2.13422758E9, -1.37992608E8, -134758.4, -131.5, -17.2, -1.9,
-0.9, -1.0E-4, -1.0E-8, -1.0E-23, -100.0, -3.0, -1.0, -0.0, 0.0, 0.0,
1.0, 3.0, 100.0, 131.5, 17.2, 1.9, 0.9, 1.0E-4, 1.0E-8, 1.0E-23,
2.13422758E9, 1.37992608E8, 134758.4]
strictMathCeil_f = [-2.13422758E9, -1.37992608E8, -134758.0, -131.0,
-17.0, -1.0, -0.0, -0.0, -0.0, -0.0, -100.0, -3.0, -1.0, -0.0, 0.0, 0.0,
1.0, 3.0, 100.0, 132.0, 18.0, 2.0, 1.0, 1.0, 1.0, 1.0, 2.13422758E9,
1.37992608E8, 134759.0]
floatMathCeil = [-2134227584, -137992608, -134758, -131, -17, -1, 0,
0, 0, 0, -100, -3, -1, 0, 0, 0, 1, 3, 100, 132, 18, 2, 1, 1, 1, 1,
2134227584, 137992608, 134759]
FloatMathCeil_f = [-2.13422758E9, -1.37992608E8, -134758.0, -131.0,
-17.0, -1.0, -0.0, -0.0, -0.0, -0.0, -100.0, -3.0, -1.0, 0.0, 0.0, 0.0,
1.0, 3.0, 100.0, 132.0, 18.0, 2.0, 1.0, 1.0, 1.0, 1.0, 2.13422758E9,
1.37992608E8, 134759.0]
strictMathFloor_f = [-2.13422758E9, -1.37992608E8, -134759.0, -132.0,
-18.0, -2.0, -1.0, -1.0, -1.0, -1.0, -100.0, -3.0, -1.0, -0.0, 0.0, 0.0,
1.0, 3.0, 100.0, 131.0, 17.0, 1.0, 0.0, 0.0, 0.0, 0.0, 2.13422758E9,
1.37992608E8, 134758.0]
floatMathFloor = [-2.13422758E9, -1.37992608E8, -134759.0, -132.0,
-18.0, -2.0, -1.0, -1.0, -1.0, -1.0, -100.0, -3.0, -1.0, 0.0, 0.0, 0.0,
1.0, 3.0, 100.0, 131.0, 17.0, 1.0, 0.0, 0.0, 0.0, 0.0, 2.13422758E9,
1.37992608E8, 134758.0]
floatMathFloor_f = [-2.13422758E9, -1.37992608E8, -134759.0, -132.0,
-18.0, -2.0, -1.0, -1.0, -1.0, -1.0, -100.0, -3.0, -1.0, 0.0, 0.0, 0.0,
1.0, 3.0, 100.0, 131.0, 17.0, 1.0, 0.0, 0.0, 0.0, 0.0, 2.13422758E9,
1.37992608E8, 134758.0]
- Benchmarks ---
# Calib: run duration: 5 000 ms
4 threads, Tavg = 3,03 ns/op (σ = 0,02 ns/op), Total ops =
6616663415 [ 3,07 (1633532581), 3,02 (1656839291), 3,01
(1662195896), 3,01 (1664095647)]
#
#-------------------------------------------------------------
*# StrictMathCeil_f*: run duration: 5 000 ms
**float = *(float) StrictMath.ceil(f)
*
1 threads, Tavg = 112,46 ns/op (σ = 0,00 ns/op), Total
ops = 44462614 [ 112,46 (44462614)]
2 threads, Tavg = 112,53 ns/op (σ = 0,20 ns/op), Total ops =
88864503 [ 112,74 (44351706), 112,33 (44512797)]
3 threads, Tavg = 112,75 ns/op (σ = 0,31 ns/op), Total
ops = 133042189 [ 112,67 (44379882), 112,42 (44478562), 113,17
(44183745)]
* 4 threads, Tavg = 113,61 ns/op (σ = 1,18 ns/op),*
Total ops = 176004512 [ 115,63 (43242922), 113,27 (44144214),
112,59 (44409190), 113,01 (44208186)]
#
#-------------------------------------------------------------
*# FloatMathCeil_f:* run duration: 5 000 ms
*float = FloatMath.ceil_f(f)
*
1 threads, Tavg = 85,42 ns/op (σ = 0,00 ns/op), Total
ops = 58534818 [ 85,42 (58534818)]
2 threads, Tavg = 85,56 ns/op (σ = 0,18 ns/op), Total ops =
116880361 [ 85,74 (58318655), 85,38 (58561706)]
3 threads, Tavg = 85,49 ns/op (σ = 0,11 ns/op), Total
ops = 175469910 [ 85,64 (58386401), 85,42 (58535723), 85,40
(58547786)]
* 4 threads, Tavg = 86,10 ns/op (σ = 0,86 ns/op),
*Total ops = 232739544 [ 87,59 (57200792), 85,61
(58519538), 85,47 (58617544), 85,79 (58401670)]
#
#-------------------------------------------------------------
*# FloatMathCeil:* run duration: 5 000 ms
*int = FloatMath.ceil(f)*
1 threads, Tavg = 56,72 ns/op (σ = 0,00 ns/op), Total
ops = 88153017 [ 56,72 (88153017)]
2 threads, Tavg = 56,90 ns/op (σ = 0,16 ns/op), Total ops =
175737994 [ 57,06 (87626873), 56,75 (88111121)]
3 threads, Tavg = 56,82 ns/op (σ = 0,15 ns/op), Total
ops = 264003134 [ 57,02 (87684429), 56,76 (88087214), 56,67
(88231491)]
* 4 threads, Tavg = 57,16 ns/op (σ = 0,57 ns/op),*
Total ops = 350060098 [ 58,12 (86072473), 56,74
(88161260), 56,68 (88251450), 57,12 (87574915)]
#
#-------------------------------------------------------------
*# StrictMathFloor_f:* run duration: 5 000 ms
*float = (float) StrictMath.floor(f)*
1 threads, Tavg = 108,69 ns/op (σ = 0,00 ns/op), Total
ops = 46005419 [ 108,69 (46005419)]
2 threads, Tavg = 108,87 ns/op (σ = 0,25 ns/op), Total ops =
91856264 [ 109,11 (45824174), 108,62 (46032090)]
3 threads, Tavg = 108,66 ns/op (σ = 0,01 ns/op), Total
ops = 138046291 [ 108,65 (46019660), 108,68 (46008068), 108,65
(46018563)]
* 4 threads, Tavg = 109,99 ns/op (σ = 1,00 ns/op),*
Total ops = 182162538 [ 111,63 (44870853), 109,77 (45631259),
108,90 (45994047), 109,69 (45666379)]
#
#-------------------------------------------------------------
*# FloatMathFloor_f: *run duration: 5 000 ms
*float = FloatMath.floor_f(f)*
1 threads, Tavg = 79,60 ns/op (σ = 0,00 ns/op), Total
ops = 62816917 [ 79,60 (62816917)]
2 threads, Tavg = 79,44 ns/op (σ = 0,15 ns/op), Total ops =
125890579 [ 79,58 (62827873), 79,29 (63062706)]
3 threads, Tavg = 79,38 ns/op (σ = 0,15 ns/op), Total
ops = 188968096 [ 79,59 (62823628), 79,23 (63107367), 79,32
(63037101)]
* 4 threads, Tavg = 79,88 ns/op (σ = 0,83 ns/op),*
Total ops = 250828233 [ 81,31 (61604026), 79,60
(62930953), 79,32 (63149634), 79,33 (63143620)]
#
#-------------------------------------------------------------
*# FloatMathFloor:* run duration: 5 000 ms
*float = FloatMath.floor(f)*
1 threads, Tavg = 70,20 ns/op (σ = 0,00 ns/op), Total
ops = 71226367 [ 70,20 (71226367)]
2 threads, Tavg = 70,35 ns/op (σ = 0,16 ns/op), Total ops =
142141053 [ 70,51 (70910131), 70,20 (71230922)]
3 threads, Tavg = 70,26 ns/op (σ = 0,08 ns/op), Total
ops = 213504247 [ 70,20 (71225449), 70,38 (71046834), 70,19
(71231964)]
* 4 threads, Tavg = 70,67 ns/op (σ = 0,60 ns/op),
*Total ops = 283376128 [ 70,24 (71279973), 70,58
(70931050), 70,20 (71320272), 71,68 (69844833)]
#
