From b5969cf31c8b33a2095b9212a334acae927bc2a6 Mon Sep 17 00:00:00 2001 From: Jaroslav Tulach Date: Sun, 9 Jun 2024 14:46:41 +0200 Subject: [PATCH] Sort rational numbers and primes first benchmarks (#10142) Investigating #6361 - can we speed callback from `java.util.TimSort.sort` to Enso by using `CallTarget`? --- test/Benchmarks/src/Vector/Distinct.enso | 4 +- test/Benchmarks/src/Vector/Sort.enso | 55 ++++++++++++++++++++---- test/Benchmarks/src/Vector/Utils.enso | 45 ++++++++++++++++++- 3 files changed, 93 insertions(+), 11 deletions(-) diff --git a/test/Benchmarks/src/Vector/Distinct.enso b/test/Benchmarks/src/Vector/Distinct.enso index fdca3567b5d1..d6cf1077eda3 100644 --- a/test/Benchmarks/src/Vector/Distinct.enso +++ b/test/Benchmarks/src/Vector/Distinct.enso @@ -35,11 +35,11 @@ collect_benches = Bench.build builder-> data = Data.create builder.group "Vector_Distinct" options group_builder-> - group_builder.specify "Random_Integer_Vector_Distinct" <| + group_builder.specify "Random_Integer_Vector_Distinct_v2" <| data.random_vec.distinct group_builder.specify "Uniform_Integer_Vector_Distinct" <| data.uniform_vec.distinct - group_builder.specify "Random_Text_Vector_Distinct" <| + group_builder.specify "Random_Text_Vector_Distinct_v2" <| data.random_text_vec.distinct group_builder.specify "Uniform_Text_Vector_Distinct" <| data.uniform_text_vec.distinct diff --git a/test/Benchmarks/src/Vector/Sort.enso b/test/Benchmarks/src/Vector/Sort.enso index a9af7102b5ff..7119d55a0c3b 100644 --- a/test/Benchmarks/src/Vector/Sort.enso +++ b/test/Benchmarks/src/Vector/Sort.enso @@ -51,17 +51,30 @@ type Int identity self = self +type Int_Comparator + compare a:Int b:Int = Ordering.compare a.v b.v + hash i:Int = 3721 + Default_Comparator.hash_builtin i.v + +Comparable.from(_:Int) = Int_Comparator + + # The Benchmarks ============================================================== -options = Bench.options . set_warmup (Bench.phase_conf 1 4) . set_measure (Bench.phase_conf 1 3) +options = Bench.options . set_warmup (Bench.phase_conf 3 4) . set_measure (Bench.phase_conf 3 1) type Data - Value ~sorted_vec ~partially_sorted_vec ~random_vec ~random_vec_wrapped + Value ~sorted_vec ~partially_sorted_vec ~random_vec ~random_vec_wrapped ~rational_vec ~integer_vec create vec_size = - Data.Value (Data.make_sorted_vec vec_size) (make_partially_sorted_vec vec_size) (Data.make_random_vec vec_size) ((Data.make_random_vec vec_size).map (v -> Int.Value v)) + f1 s = Data.make_sorted_vec s + f2 s = make_partially_sorted_vec s + f3 s = Data.make_random_vec s + f4 s = (Data.make_random_vec s).map (v -> Int.Value v) + f5 s = Utils.make_random_rational_vec s + f6 s = f5 s . map (x-> x.to_float . floor + 2) + Data.Value (f1 vec_size) (f2 vec_size) (f3 vec_size) (f4 vec_size) (f5 vec_size) (f6 vec_size) make_sorted_vec vec_size = make_sorted_ascending_vec vec_size @@ -89,13 +102,13 @@ collect_benches = Bench.build builder-> group_builder.specify "Sorted_Runs_Descending" <| data.partially_sorted_vec.sort Sort_Direction.Descending - group_builder.specify "Random_Elements_Ascending" <| + group_builder.specify "Random_Elements_Ascending_v2" <| data.random_vec.sort - group_builder.specify "Random_Elements_Descending" <| + group_builder.specify "Random_Elements_Descending_v2" <| data.random_vec.sort Sort_Direction.Descending - group_builder.specify "Sorting_with_a_Custom_Projection" <| + group_builder.specify "Sorting_with_a_Custom_Projection_v2" <| data.random_vec.sort on=projection group_builder.specify "Sorting_with_an_identity_function" <| @@ -104,8 +117,34 @@ collect_benches = Bench.build builder-> group_builder.specify "Sorting_with_an_unresolved_identity_function" <| data.random_vec_wrapped.sort on=(.identity) - group_builder.specify "Sorting_with_the_Default_Ordered_Comparator" <| + group_builder.specify "Sorting_with_the_Default_Ordered_Comparator_v2" <| data.random_vec.sort by=comparator + group_builder.specify "Sorting_Prime_Numbers_First" <| + is_prime p -> Boolean = + test n = if n*n > p then True else + if p % n == 0 then False else + @Tail_Call test n+1 + + test 2 + + prime_first a:Integer b:Integer -> Ordering = + prime_a = is_prime a + prime_b = is_prime b + + if prime_a == prime_b then Ordering.compare a b else + if prime_a then Ordering.Less else + Ordering.Greater + + data.integer_vec.sort by=prime_first + + group_builder.specify "Sort_Rational_Vector" <| + data.rational_vec.sort + + group_builder.specify "Sort_Rational_Vector_by_comparator" <| + data.rational_vec.sort by=(a-> b-> b.compare a) + + group_builder.specify "Sort_Rational_Vector_by_converting_to_float" <| + data.rational_vec.sort on=(.to_float) -main = collect_benches . run_main +main filter=Nothing = collect_benches . run_main filter diff --git a/test/Benchmarks/src/Vector/Utils.enso b/test/Benchmarks/src/Vector/Utils.enso index 5580c1074b0e..3668b251cdc9 100644 --- a/test/Benchmarks/src/Vector/Utils.enso +++ b/test/Benchmarks/src/Vector/Utils.enso @@ -5,4 +5,47 @@ polyglot java import java.util.Random as Java_Random make_random_vec : Integer -> Vector make_random_vec n = random_gen = Java_Random.new n - Vector.fill n random_gen.nextDouble + Vector.new n (_-> random_gen.nextDouble) + +make_random_rational_vec n = + random_gen = Java_Random.new n + Vector.new n _-> + p = random_gen.nextInt 100 + q = 1 + random_gen.nextInt 99 + Rational.new p q + +type Rational + private Fraction p:Integer q:Integer + + new p:Integer q:Integer=1 = + if q == 0 then Error.throw "Denominator cannot be zero" else + Rational.Fraction p q + + compare self that:Rational -> Ordering = Ordering.compare self.p*that.q that.p*self.q + + normalize self = if self.p == 0 then Rational.new 0 1 else + gcd a b = case Ordering.compare a b of + Ordering.Greater -> @Tail_Call gcd (a.rem b) b + Ordering.Less -> @Tail_Call gcd a (b.rem a) + Ordering.Equal -> a + + d = gcd self.p self.q + + Rational.new self.p/d self.q/d + + to_float self = self.p / self.q + + to_text self = self.p.to_text+"/"+self.q.to_text + +Float.from (that : Rational) = that.to_float + +type Rational_Comparator + compare (a:Rational) (b:Rational) = Ordering.compare a.p*b.q b.p*a.q + hash (v:Rational) = + n = v.normalize + n.p*37 + n.q*51 + + +Comparable.from (_ : Rational) = Rational_Comparator + +main = Standard.Base.Runtime.Debug.breakpoint