File 2196-Clean-up-measure-1.patch of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 2196-Clean-up-measure-1.patch of Package erlang (Revision 58ddfd9fcf4c281c82656d8c2d2a71df)

Currently displaying revision 58ddfd9fcf4c281c82656d8c2d2a71df , Show latest

From 9a1b1d778b53b152c29b9c8b383efd8373275a97 Mon Sep 17 00:00:00 2001
From: Raimo Niskanen <raimo@erlang.org>
Date: Fri, 1 Apr 2022 15:56:56 +0200
Subject: [PATCH 06/11] Clean up measure/1

---
 lib/stdlib/test/rand_SUITE.erl | 896 +++++++++++++++------------------
 1 file changed, 412 insertions(+), 484 deletions(-)

diff --git a/lib/stdlib/test/rand_SUITE.erl b/lib/stdlib/test/rand_SUITE.erl
index a9b546a5e8..d2d729b594 100644
--- a/lib/stdlib/test/rand_SUITE.erl
+++ b/lib/stdlib/test/rand_SUITE.erl
@@ -1060,11 +1060,13 @@ crypto64_uniform_n(N, State0) ->
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 %% Not a test but measures the time characteristics of the different algorithms
-measure(Config) ->
+measure(Config) when is_list(Config) ->
     ct:timetrap({minutes,60}), %% valgrind needs a lot of time
     case ct:get_timetrap_info() of
         {_,{_,1}} -> % No scaling
-            do_measure(Config);
+            Iterations = ?LOOP div 5,
+            Effort = proplists:get_value(measure_effort, Config, 1),
+            do_measure(Iterations * Effort);
         {_,{_,Scale}} ->
             {skip,{will_not_run_in_scaled_time,Scale}}
     end.
@@ -1095,7 +1097,7 @@ measure(Config) ->
                 St
         end).
 
-do_measure(_Config) ->
+do_measure(Iterations) ->
     Algs =
         case crypto_support() of
             ok ->
@@ -1107,504 +1109,435 @@ do_measure(_Config) ->
     ct:pal("~nRNG uniform integer range 10000 performance~n",[]),
     [TMarkUniformRange10000,OverheadUniformRange1000|_] =
         measure_1(
-          fun (_) -> 10000 end,
-          fun (State, Range, Mod) ->
-                  measure_loop(
-                    fun (St0) ->
-                            ?CHECK_UNIFORM_RANGE(
-                               Mod:uniform_s(Range, St0), Range,
-                               X, St1)
-                    end,
-                    State)
-          end,
-          Algs),
+          fun (Mod, _State) ->
+                  Range = 10000,
+                  Generator = fun Mod:uniform_s/2,
+                  fun (St0) ->
+                          ?CHECK_UNIFORM_RANGE(
+                             Generator(Range, St0), Range, X, St1)
+                  end
+          end, Algs, Iterations),
     _ =
         measure_1(
-          fun (_) -> 10000 end,
-          fun (State, Range, _) ->
-                  measure_loop(
-                    fun (State0) ->
-                            State1 = rand:mcg35(State0),
-                            %% Just a 'rem' with slightly skewed distribution
-                            case (State1 rem Range) + 1 of
-                                R when is_integer(R), 0 < R, R =< Range ->
-                                    State1
-                            end
-                    end,
-                    State)
-          end,
-          mcg35_inline, TMarkUniformRange10000, OverheadUniformRange1000),
+          fun (_Mod, _State) ->
+                  Range = 10000,
+                  fun (St0) ->
+                          St1 = rand:mcg35(St0),
+                          %% Just a 'rem' with slightly skewed distribution
+                          case (St1 rem Range) + 1 of
+                              R when is_integer(R), 0 < R, R =< Range ->
+                                  St1
+                          end
+                  end
+          end, mcg35_inline, Iterations,
+          TMarkUniformRange10000, OverheadUniformRange1000),
     _ =
         measure_1(
-          fun (_) -> 10000 end,
-          fun (State, Range, _) ->
-                  measure_loop(
-                    fun (State0) ->
-                            State1 = rand:lcg35(State0),
-                            %% Just a 'rem' with slightly skewed distribution
-                            case (State1 rem Range) + 1 of
+          fun (_Mod, _State) ->
+                  Range = 10000,
+                  fun (St0) ->
+                          St1 = rand:lcg35(St0),
+                          %% Just a 'rem' with slightly skewed distribution
+                            case (St1 rem Range) + 1 of
                                 R when is_integer(R), 0 < R, R =< Range ->
-                                    State1
+                                    St1
                             end
-                    end,
-                    State)
+                  end
           end,
-          lcg35_inline, TMarkUniformRange10000, OverheadUniformRange1000),
+          lcg35_inline, Iterations,
+          TMarkUniformRange10000, OverheadUniformRange1000),
     _ =
         measure_1(
-          fun (_) -> 10000 end,
-          fun (State, Range, _) ->
-                  measure_loop(
-                    fun (State0) ->
-                            {V,State1} = rand:exsp_next(State0),
-                            %% Just a 'rem' with slightly skewed distribution
-                            case (V rem Range) + 1 of
-                                R when is_integer(R), 0 < R, R =< Range ->
-                                    State1
+          fun (_Mod, _State) ->
+                  Range = 10000,
+                  fun (St0) ->
+                          {V,St1} = rand:exsp_next(St0),
+                          %% Just a 'rem' with slightly skewed distribution
+                          case (V rem Range) + 1 of
+                              X when is_integer(X), 0 < X, X =< Range ->
+                                  St1
                             end
-                    end,
-                    State)
+                  end
           end,
-          exsp_inline, TMarkUniformRange10000, OverheadUniformRange1000),
+          exsp_inline, Iterations,
+          TMarkUniformRange10000, OverheadUniformRange1000),
     _ =
         measure_1(
-          fun (_) -> 10000 end,
-          fun (State, Range, _) ->
-                  measure_loop(
-                    fun (State0) ->
-                            %% Just a 'rem' with slightly skewed distribution
-                            case
-                                erlang:phash2(erlang:unique_integer(), Range)
-                            of
-                                R
-                                  when is_integer(R), 0 =< R, R < Range ->
-                                    State0
-                            end
-                    end,
-                    State)
+          fun (_Mod, _State) ->
+                  Range = 10000,
+                  fun (St0) ->
+                          %% Just a 'rem' with slightly skewed distribution
+                          case
+                              erlang:phash2(erlang:unique_integer(), Range)
+                          of
+                              X when is_integer(X), 0 =< X, X < Range ->
+                                  St0
+                          end
+                  end
           end,
-          unique_phash2, TMarkUniformRange10000, OverheadUniformRange1000),
+          unique_phash2, Iterations,
+          TMarkUniformRange10000, OverheadUniformRange1000),
     _ =
         measure_1(
-          fun (_) -> 10000 end,
-          fun (State, Range, _) ->
-                  measure_loop(
-                    fun (State0) ->
-                            %% Just a 'rem' with slightly skewed distribution
-                            case os:system_time(microsecond) rem Range of
-                                R
-                                  when is_integer(R), 0 =< R, R < Range ->
-                                    State0
-                            end
-                    end,
-                    State)
+          fun (_Mod, _State) ->
+                  Range = 10000,
+                  fun (St0) ->
+                          %% Just a 'rem' with slightly skewed distribution
+                          case os:system_time(microsecond) rem Range of
+                              R
+                                when is_integer(R), 0 =< R, R < Range ->
+                                  St0
+                          end
+                  end
           end,
-          system_time_rem, TMarkUniformRange10000, OverheadUniformRange1000),
+          system_time_rem, Iterations,
+          TMarkUniformRange10000, OverheadUniformRange1000),
     %%
     ct:pal("~nRNG uniform integer 32 bit performance~n",[]),
     [TMarkUniform32Bit,OverheadUniform32Bit|_] =
         measure_1(
-          fun (_) -> 1 bsl 32 end,
-          fun (State, Range, Mod) ->
-                  measure_loop(
-                    fun (St0) ->
-                            ?CHECK_UNIFORM_RANGE(
-                               Mod:uniform_s(Range, St0), Range,
-                               X, St1)
-                    end,
-                    State)
+          fun (Mod, _State) ->
+                  Range = 1 bsl 32,
+                  Generator = fun Mod:uniform_s/2,
+                  fun (St0) ->
+                          ?CHECK_UNIFORM_RANGE(
+                             Generator(Range, St0), Range, X, St1)
+                  end
           end,
-          Algs),
+          Algs, Iterations),
     _ =
         measure_1(
-          fun (_) -> 1 bsl 32 end,
-          fun (State, Range, _) ->
-                  measure_loop(
-                    fun (State0) ->
-                            case rand:lcg35(State0) bsr (35-32) of
-                                R when is_integer(R), 0 =< R, R < Range ->
-                                    R
-                            end
-                    end,
-                    State)
+          fun (_Mod, _State) ->
+                  Range = 1 bsl 32,
+                  fun (St0) ->
+                          St1 = rand:lcg35(St0),
+                          case St1 bsr (35-32) of
+                              R when is_integer(R), 0 =< R, R < Range ->
+                                  St1
+                          end
+                  end
           end,
-          lcg35_inline, TMarkUniform32Bit, OverheadUniform32Bit),
+          lcg35_inline, Iterations,
+          TMarkUniform32Bit, OverheadUniform32Bit),
     _ =
         measure_1(
-          fun (_) -> 1 bsl 32 end,
-          fun (State, Range, _) ->
-                  measure_loop(
-                    fun (State0) ->
-                            {V, State1} = rand:exsp_next(State0),
-                            case V bsr (58-32) of
-                                R when is_integer(R), 0 =< R, R < Range ->
-                                    State1
-                            end
-                    end,
-                    State)
+          fun (_Mod, _State) ->
+                  Range = 1 bsl 32,
+                  fun (St0) ->
+                          {V, St1} = rand:exsp_next(St0),
+                          case V bsr (58-32) of
+                              R when is_integer(R), 0 =< R, R < Range ->
+                                  St1
+                          end
+                  end
           end,
-          exsp_inline, TMarkUniform32Bit, OverheadUniform32Bit),
+          exsp_inline, Iterations,
+          TMarkUniform32Bit, OverheadUniform32Bit),
     _ =
         measure_1(
-          fun (_) -> 1 bsl 32 end,
-          fun (State, Range, _) ->
-                  measure_loop(
-                    fun (State0) ->
-                            case
-                                erlang:phash2(erlang:unique_integer(), Range)
-                            of
-                                R
-                                  when is_integer(R), 0 =< R, R < Range ->
-                                    State0
-                            end
-                    end,
-                    State)
+          fun (_Mod, _State) ->
+                  Range = 1 bsl 32,
+                  fun (St0) ->
+                          case
+                              erlang:phash2(erlang:unique_integer(), Range)
+                          of
+                              R
+                                when is_integer(R), 0 =< R, R < Range ->
+                                  St0
+                          end
+                  end
           end,
-          unique_phash2, TMarkUniform32Bit, OverheadUniform32Bit),
+          unique_phash2, Iterations,
+          TMarkUniform32Bit, OverheadUniform32Bit),
     _ =
         measure_1(
-          fun (_) -> 1 bsl 32 end,
-          fun (State, Range, _) ->
-                  measure_loop(
-                    fun (State0) ->
-                            case
-                                os:system_time(microsecond)
-                                band ((1 bsl 32) - 1)
-                            of
-                                R
-                                  when is_integer(R), 0 =< R, R < Range ->
-                                    State0
-                            end
-                    end,
-                    State)
+          fun (_Mod, _State) ->
+                  Range = 1 bsl 32,
+                  fun (St0) ->
+                          case
+                              os:system_time(microsecond)
+                              band ((1 bsl 32) - 1)
+                          of
+                              R when is_integer(R), 0 =< R, R < Range ->
+                                  St0
+                          end
+                  end
           end,
-          system_time_rem, TMarkUniform32Bit, OverheadUniform32Bit),
+          system_time_rem, Iterations,
+          TMarkUniform32Bit, OverheadUniform32Bit),
     %%
     ct:pal("~nRNG uniform integer half range performance~n",[]),
     _ =
         measure_1(
-          fun (State) -> half_range(State) end,
-          fun (State, Range, Mod) ->
-                  measure_loop(
-                    fun (St0) ->
-                            ?CHECK_UNIFORM_RANGE(
-                               Mod:uniform_s(Range, St0), Range,
-                               X, St1)
-                    end,
-                    State)
+          fun (Mod, State) ->
+                  Range = half_range(State),
+                  Generator = fun Mod:uniform_s/2,
+                  fun (St0) ->
+                          ?CHECK_UNIFORM_RANGE(
+                             Generator(Range, St0), Range, X, St1)
+                  end
           end,
-          Algs),
+          Algs, Iterations),
     %%
     ct:pal("~nRNG uniform integer half range + 1 performance~n",[]),
     _ =
         measure_1(
-          fun (State) -> half_range(State) + 1 end,
-          fun (State, Range, Mod) ->
-                  measure_loop(
-                    fun (St0) ->
-                            ?CHECK_UNIFORM_RANGE(
-                               Mod:uniform_s(Range, St0), Range,
-                               X, St1)
-                    end,
-                    State)
-          end,
-          Algs),
+          fun (Mod, State) ->
+                  Range = half_range(State) + 1,
+                  Generator = fun Mod:uniform_s/2,
+                  fun (St0) ->
+                          ?CHECK_UNIFORM_RANGE(
+                             Generator(Range, St0), Range, X, St1)
+                  end
+          end, Algs, Iterations),
     %%
     ct:pal("~nRNG uniform integer full range - 1 performance~n",[]),
     _ =
         measure_1(
-          fun (State) -> (half_range(State) bsl 1) - 1 end,
-          fun (State, Range, Mod) ->
-                  measure_loop(
-                    fun (St0) ->
-                            ?CHECK_UNIFORM_RANGE(
-                               Mod:uniform_s(Range, St0), Range,
-                               X, St1)
-                    end,
-                    State)
-          end,
-          Algs),
+          fun (Mod, State) ->
+                  Range = (half_range(State) bsl 1) - 1,
+                  Generator = fun Mod:uniform_s/2,
+                  fun (St0) ->
+                          ?CHECK_UNIFORM_RANGE(
+                             Generator(Range, St0), Range, X, St1)
+                  end
+          end, Algs, Iterations),
     %%
     ct:pal("~nRNG uniform integer full range performance~n",[]),
     [TMarkUniformFullRange,OverheadUniformFullRange|_] =
         measure_1(
-          fun (State) -> half_range(State) bsl 1 end,
-          fun (State, Range, Mod) ->
-                  measure_loop(
-                    fun (St0) ->
-                            ?CHECK_UNIFORM_RANGE(
-                               Mod:uniform_s(Range, St0), Range,
-                               X, St1)
-                    end,
-                    State)
-          end,
-          Algs ++ [dummy]),
+          fun (Mod, State) ->
+                  Range = half_range(State) bsl 1,
+                  Generator = fun Mod:uniform_s/2,
+                  fun (St0) ->
+                          ?CHECK_UNIFORM_RANGE(
+                             Generator(Range, St0), Range, X, St1)
+                  end
+          end, Algs ++ [dummy], Iterations),
     _ =
         measure_1(
-          fun (_) -> ((1 bsl 35) - 31) - 1 end,
-          fun (State, Range, _) ->
-                  measure_loop(
-                    fun (State0) ->
-                            case rand:mcg35(State0) of
-                                R when is_integer(R), 1 =< R, R =< Range ->
-                                    R
-                            end
-                    end,
-                    State)
+          fun (_Mod, _State) ->
+                  Range = (1 bsl 35) - 31,
+                  fun (St0) ->
+                          case rand:mcg35(St0) of
+                              R when is_integer(R), 1 =< R, R =< Range ->
+                                  R
+                          end
+                  end
           end,
-          mcg35_inline, TMarkUniformFullRange, OverheadUniformFullRange),
+          mcg35_inline, Iterations,
+          TMarkUniformFullRange, OverheadUniformFullRange),
     _ =
         measure_1(
-          fun (_) -> 1 bsl 35 end,
-          fun (State, Range, _) ->
-                  measure_loop(
-                    fun (State0) ->
-                            case rand:lcg35(State0) of
-                                R when is_integer(R), 0 =< R, R < Range ->
-                                    R
-                            end
-                    end,
-                    State)
+          fun (_Mod, _State) ->
+                  Range = 1 bsl 35,
+                  fun (St0) ->
+                          case rand:lcg35(St0) of
+                              R when is_integer(R), 0 =< R, R < Range ->
+                                  R
+                          end
+                  end
           end,
-          lcg35_inline, TMarkUniformFullRange, OverheadUniformFullRange),
+          lcg35_inline, Iterations,
+          TMarkUniformFullRange, OverheadUniformFullRange),
     _ =
         measure_1(
-          fun (_) -> 1 bsl 58 end,
-          fun (State, Range, _) ->
-                  measure_loop(
-                    fun (State0) ->
-                            {V, State1} = rand:exsp_next(State0),
-                            case V of
-                                V when is_integer(V), 0 =< V, V < Range ->
-                                    State1
-                            end
-                    end,
-                    State)
+          fun (_Mod, _State) ->
+                  Range = 1 bsl 58,
+                  fun (St0) ->
+                          {V, St1} = rand:exsp_next(St0),
+                          case V of
+                              V when is_integer(V), 0 =< V, V < Range ->
+                                  St1
+                          end
+                  end
           end,
-          exsp_inline, TMarkUniformFullRange, OverheadUniformFullRange),
+          exsp_inline, Iterations,
+          TMarkUniformFullRange, OverheadUniformFullRange),
     _ =
         measure_1(
-          fun (_) -> 1 bsl 27 end,
-          fun (State, Range, _) ->
-                  measure_loop(
-                    fun (State0) ->
-                            case erlang:phash2(erlang:unique_integer()) of
-                                R
-                                  when is_integer(R), 0 =< R, R < Range ->
-                                    State0
-                            end
-                    end,
-                    State)
+          fun (_Mod, _State) ->
+                  Range = 1 bsl 27,
+                  fun (St0) ->
+                          case erlang:phash2(erlang:unique_integer()) of
+                              X
+                                when is_integer(X), 0 =< X, X < Range ->
+                                  St0
+                          end
+                  end
           end,
-          unique_phash2, TMarkUniformFullRange, OverheadUniformFullRange),
+          unique_phash2, Iterations,
+          TMarkUniformFullRange, OverheadUniformFullRange),
     _ =
         measure_1(
-          fun (State) ->
-                  rand:seed(State),
-                  half_range(State) bsl 1
+          fun (Mod, _State) ->
+                  Range = 1 bsl 27,
+                  Generator = fun Mod:uniform/1,
+                  fun (St0) ->
+                          case Generator(Range) of
+                              X when is_integer(X), 1 =< X, X =< Range ->
+                                  St0
+                          end
+                  end
           end,
-          fun (State, Range, Mod) ->
-                  measure_loop(
-                    fun (St) ->
-                            case Mod:uniform(Range) of
-                                X when is_integer(X), 1 =< X, X =< Range ->
-                                    St
-                            end
-                    end,
-                    State)
-          end,
-          procdict, TMarkUniformFullRange, OverheadUniformFullRange),
+          procdict, Iterations,
+          TMarkUniformFullRange, OverheadUniformFullRange),
     _ =
         measure_1(
-          fun (State) ->
-                  _ = put(lcg35_procdict, State),
-                  1 bsl 35
-          end,
-          fun (State, Range, _) ->
-                  measure_loop(
-                    fun (State0) ->
-                            case
-                                put(lcg35_procdict,
-                                    rand:lcg35(get(lcg35_procdict)))
-                            of
-                                R when is_integer(R), 0 =< R, R < Range ->
-                                    State0
-                            end
-                    end,
-                    State)
+          fun (_Mod, _State) ->
+                  Range = 1 bsl 35,
+                  fun (St0) ->
+                          case
+                              put(lcg35_procdict,
+                                  rand:lcg35(get(lcg35_procdict)))
+                          of
+                              X when is_integer(X), 0 =< X, X < Range ->
+                                  St0
+                          end
+                  end
           end,
-          lcg35_procdict, TMarkUniformFullRange, OverheadUniformFullRange),
+          lcg35_procdict, Iterations,
+          TMarkUniformFullRange, OverheadUniformFullRange),
     %%
     ct:pal("~nRNG uniform integer full range + 1 performance~n",[]),
     _ =
         measure_1(
-          fun (State) -> (half_range(State) bsl 1) + 1 end,
-          fun (State, Range, Mod) ->
-                  measure_loop(
-                    fun (St0) ->
-                            ?CHECK_UNIFORM_RANGE(
-                               Mod:uniform_s(Range, St0), Range,
-                               X, St1)
-                    end,
-                    State)
-          end,
-          Algs),
+          fun (Mod, State) ->
+                  Range = (half_range(State) bsl 1) + 1,
+                  Generator = fun Mod:uniform_s/2,
+                  fun (St0) ->
+                          ?CHECK_UNIFORM_RANGE(
+                             Generator(Range, St0), Range, X, St1)
+                  end
+          end, Algs, Iterations),
     %%
     ct:pal("~nRNG uniform integer double range performance~n",[]),
     _ =
         measure_1(
-          fun (State) ->
-                  half_range(State) bsl 2
-          end,
-          fun (State, Range, Mod) ->
-                  measure_loop(
-                    fun (St0) ->
-                            ?CHECK_UNIFORM_RANGE(
-                               Mod:uniform_s(Range, St0), Range,
-                               X, St1)
-                    end,
-                    State)
-          end,
-          Algs),
+          fun (Mod, State) ->
+                  Range = half_range(State) bsl 2,
+                  Generator = fun Mod:uniform_s/2,
+                  fun (St0) ->
+                          ?CHECK_UNIFORM_RANGE(
+                             Generator(Range, St0), Range, X, St1)
+                  end
+          end, Algs, Iterations),
     %%
     ct:pal("~nRNG uniform integer double range + 1  performance~n",[]),
     _ =
         measure_1(
-          fun (State) ->
-                  (half_range(State) bsl 2) + 1
-          end,
-          fun (State, Range, Mod) ->
-                  measure_loop(
-                    fun (St0) ->
-                            ?CHECK_UNIFORM_RANGE(
-                               Mod:uniform_s(Range, St0), Range,
-                               X, St1)
-                    end,
-                    State)
-          end,
-          Algs),
+          fun (Mod, State) ->
+                  Range = (half_range(State) bsl 2) + 1,
+                  Generator = fun Mod:uniform_s/2,
+                  fun (St0) ->
+                          ?CHECK_UNIFORM_RANGE(
+                             Generator(Range, St0), Range, X, St1)
+                  end
+          end, Algs, Iterations),
     %%
     ct:pal("~nRNG uniform integer 64 bit performance~n",[]),
     _ =
         measure_1(
-          fun (_) -> 1 bsl 64 end,
-          fun (State, Range, Mod) ->
-                  measure_loop(
-                    fun (St0) ->
-                            ?CHECK_UNIFORM_RANGE(
-                               Mod:uniform_s(Range, St0), Range,
-                               X, St1)
-                    end,
-                    State)
-          end,
-          Algs),
+          fun (Mod, _State) ->
+                  Range = 1 bsl 64,
+                  Generator = fun Mod:uniform_s/2,
+                  fun (St0) ->
+                          ?CHECK_UNIFORM_RANGE(
+                             Generator(Range, St0), Range, X, St1)
+                  end
+          end, Algs, Iterations),
     %%
     ByteSize = 16, % At about 100 bytes crypto_bytes breaks even to exsss
     ct:pal("~nRNG ~w bytes performance~n",[ByteSize]),
     _ =
         measure_1(
-          fun (_) -> ByteSize end,
-          fun (State, Size, Mod) ->
-                  measure_loop(
-                    fun (St0) ->
-                            ?CHECK_BYTE_SIZE(
-                               Mod:bytes_s(Size, St0), Size,
-                               Bin, St1)
-                    end,
-                    State)
+          fun (Mod, _State) ->
+                  Generator = fun Mod:bytes_s/2,
+                  fun (St0) ->
+                          ?CHECK_BYTE_SIZE(
+                             Generator(ByteSize, St0), ByteSize, Bin, St1)
+                  end
           end,
           case crypto_support() of
               ok ->
                   Algs ++ [crypto_bytes, crypto_bytes_cached];
               _ ->
                   Algs
-          end),
+          end, Iterations),
     %%
     ct:pal("~nRNG uniform float performance~n",[]),
     [TMarkUniformFloat,OverheadUniformFloat|_] =
         measure_1(
-          fun (_) -> 0 end,
-          fun (State, _, Mod) ->
-                  measure_loop(
-                    fun (St0) ->
-                            ?CHECK_UNIFORM(Mod:uniform_s(St0), X, St)
-                    end,
-                    State)
+          fun (Mod, _State) ->
+                  Generator = fun Mod:uniform_s/1,
+                  fun (St0) ->
+                            ?CHECK_UNIFORM(Generator(St0), X, St)
+                  end
           end,
-          Algs),
+          Algs, Iterations),
     _ =
         measure_1(
-          fun (_) -> 0 end,
-          fun (State, _, _) ->
-                  measure_loop(
-                    fun (State0) ->
-                            State1 = rand:mcg35(State0),
-                            %% Too few bits for full mantissa
-                            case (State1 - 1) * (1/((1 bsl 35) - 31)) of
-                                R when is_float(R), 0.0 =< R, R < 1.0 ->
-                                    State1
-                            end
-                    end,
-                    State)
+          fun (_Mod, _State) ->
+                  fun (St0) ->
+                          St1 = rand:mcg35(St0),
+                          %% Too few bits for full mantissa
+                          case (St1 - 1) * (1/((1 bsl 35) - 31)) of
+                              R when is_float(R), 0.0 =< R, R < 1.0 ->
+                                  St1
+                          end
+                    end
           end,
-          mcg35_inline, TMarkUniformFloat, OverheadUniformFloat),
+          mcg35_inline, Iterations,
+          TMarkUniformFloat, OverheadUniformFloat),
     _ =
         measure_1(
-          fun (_) -> 0 end,
-          fun (State, _, _) ->
-                  measure_loop(
-                    fun (State0) ->
-                            State1 = rand:lcg35(State0),
-                            %% Too few bits for full mantissa
-                            case State1 * (1/(1 bsl 35)) of
-                                R when is_float(R), 0.0 =< R, R < 1.0 ->
-                                    State1
-                            end
-                    end,
-                    State)
+          fun (_Mod, _State) ->
+                  fun (St0) ->
+                          St1 = rand:lcg35(St0),
+                          %% Too few bits for full mantissa
+                          case St1 * (1/(1 bsl 35)) of
+                              R when is_float(R), 0.0 =< R, R < 1.0 ->
+                                  St1
+                          end
+                  end
           end,
-          lcg35_inline, TMarkUniformFloat, OverheadUniformFloat),
+          lcg35_inline, Iterations,
+          TMarkUniformFloat, OverheadUniformFloat),
     _ =
         measure_1(
-          fun (_) -> 0 end,
-          fun (State, _, _) ->
-                  measure_loop(
-                    fun (State0) ->
-                            {V,State1} = rand:exsp_next(State0),
-                            case V * (1/(1 bsl 58)) of
-                                R when is_float(R), 0.0 =< R, R < 1.0 ->
-                                    State1
-                            end
-                    end,
-                    State)
+          fun (_Mod, _State) ->
+                  fun (St0) ->
+                          {V,St1} = rand:exsp_next(St0),
+                          case V * (1/(1 bsl 58)) of
+                              R when is_float(R), 0.0 =< R, R < 1.0 ->
+                                  St1
+                          end
+                  end
           end,
-          exsp_inline, TMarkUniformFloat, OverheadUniformFloat),
+          exsp_inline, Iterations,
+          TMarkUniformFloat, OverheadUniformFloat),
     %%
     ct:pal("~nRNG uniform_real float performance~n",[]),
     _ =
         measure_1(
-          fun (_) -> 0 end,
-          fun (State, _, Mod) ->
-                  measure_loop(
-                    fun (St0) ->
-                            ?CHECK_UNIFORM(Mod:uniform_real_s(St0), X, St)
-                    end,
-                    State)
+          fun (Mod, _State) ->
+                  Generator = fun Mod:uniform_real_s/1,
+                  fun (St0) ->
+                          ?CHECK_UNIFORM(Generator(St0), X, St)
+                  end
           end,
-          Algs),
+          Algs, Iterations),
     %%
     ct:pal("~nRNG normal float performance~n",[]),
     [TMarkNormalFloat, OverheadNormalFloat|_] =
         measure_1(
-          fun (_) -> 0 end,
-          fun (State, _, Mod) ->
-                  measure_loop(
-                    fun (St0) ->
-                            ?CHECK_NORMAL(Mod:normal_s(St0), X, St1)
-                    end,
-                    State)
+          fun (Mod, _State) ->
+                  Generator = fun Mod:normal_s/1,
+                  fun (St0) ->
+                          ?CHECK_NORMAL(Generator(St0), X, St1)
+                  end
           end,
-          Algs),
+          Algs, Iterations),
     %% Just for fun try an implementation of the Box-Muller
     %% transformation for creating normal distribution floats
     %% to compare with our Ziggurat implementation.
@@ -1614,129 +1547,124 @@ do_measure(_Config) ->
     TwoPi = 2 * math:pi(),
     _ =
         measure_1(
-          fun (_) -> 0 end,
-          fun (State, _, Mod) ->
-                  measure_loop(
-                    fun (State0) ->
-                            {U1, State1} = Mod:uniform_real_s(State0),
-                            {U2, State2} = Mod:uniform_s(State1),
-                            R = math:sqrt(-2.0 * math:log(U1)),
-                            T = TwoPi * U2,
-                            Z0 = R * math:cos(T),
-                            Z1 = R * math:sin(T),
-                            ?CHECK_NORMAL({Z0 + Z1, State2}, X, State3)
-                    end,
-                    State)
+          fun (Mod, _State) ->
+                  fun (St0) ->
+                          {U1, St1} = Mod:uniform_real_s(St0),
+                          {U2, St2} = Mod:uniform_s(St1),
+                          R = math:sqrt(-2.0 * math:log(U1)),
+                          T = TwoPi * U2,
+                          Z0 = R * math:cos(T),
+                          Z1 = R * math:sin(T),
+                          ?CHECK_NORMAL({Z0 + Z1, St2}, X, St3)
+                  end
           end,
-          exsss, TMarkNormalFloat, OverheadNormalFloat),
+          exsss, Iterations,
+          TMarkNormalFloat, OverheadNormalFloat),
     ok.
 
--define(LOOP_MEASURE, (?LOOP div 5)).
-
-measure_loop(Fun, State) ->
-    measure_loop(Fun, State, ?LOOP_MEASURE).
-%%
-measure_loop(Fun, State, N) when 10 =< N ->
+measure_loop(State, Fun, I) when 10 =< I ->
     %% Loop unrolling to dilute benchmark overhead...
     measure_loop(
-      Fun,
       Fun(Fun(Fun(Fun(Fun(
                         Fun(Fun(Fun(Fun(Fun(
                                           State)))))))))),
-      N - 10);
-measure_loop(Fun, State, N) when 1 =< N ->
-    measure_loop(Fun, Fun(State), N-1);
+      Fun,
+      I - 10);
+measure_loop(State, Fun, I) when 1 =< I ->
+    measure_loop(Fun(State), Fun, I - 1);
 measure_loop(_, _, _) ->
     ok.
 
-measure_1(RangeFun, Fun, Algs) ->
-    WMark = measure_1(RangeFun, Fun, hd(Algs), warm_up, 0),
+measure_1(InitFun, Algs, Iterations) ->
+    WMark = measure_1(InitFun, hd(Algs), Iterations, warm_up, 0),
     Overhead =
         measure_1(
-          fun (_) -> 1 end,
-          fun (State, Range, _) ->
-                  measure_loop(
-                    fun (State0)
-                          when
-                              is_integer(State0),
-                              1 =< State0,
-                              State0 =< Range ->
-                            State0
-                    end,
-                    State)
-          end,
-          overhead, WMark, 0),
-    TMark = measure_1(RangeFun, Fun, hd(Algs), undefined, Overhead),
+          fun (_Mod, _State) ->
+                  Range = 1,
+                  fun (St0)
+                      when is_integer(St0), 1 =< St0, St0 =< Range ->
+                          St0
+                  end
+          end, overhead, Iterations, WMark, 0),
+    TMark = measure_1(InitFun, hd(Algs), Iterations, undefined, Overhead),
     [TMark,Overhead] ++
-        [measure_1(RangeFun, Fun, Alg, TMark, Overhead) || Alg <- tl(Algs)].
+        [measure_1(InitFun, Alg, Iterations, TMark, Overhead)
+         || Alg <- tl(Algs)].
 
-measure_1(RangeFun, Fun, Alg, TMark, Overhead) ->
+measure_1(InitFun, Alg, Iterations, TMark, Overhead) ->
     Parent = self(),
-    {Mod, State} =
-        case Alg of
-            overhead ->
-                {?MODULE, 1};
-            crypto64 ->
-                {rand, crypto64_seed()};
-            crypto_cache ->
-                {rand, crypto:rand_seed_alg(crypto_cache)};
-            crypto ->
-                {rand, crypto:rand_seed_s()};
-            crypto_aes ->
-                {rand,
-		 crypto:rand_seed_alg(
-		   crypto_aes, crypto:strong_rand_bytes(256))};
-            random ->
-                {random, random:seed(os:timestamp()), get(random_seed)};
-            crypto_bytes ->
-                {?MODULE, ignored_state};
-            crypto_bytes_cached ->
-                {?MODULE, <<>>};
-            unique_phash2 ->
-                {?MODULE, ignored_state};
-            system_time_rem ->
-                {?MODULE, ignored_state};
-            mcg35_inline ->
-                {_, S} = rand:seed_s(dummy),
-                {?MODULE, (S rem ((1 bsl 35)-31 - 1)) + 1};
-            lcg35_inline ->
-                {_, S} = rand:seed_s(dummy),
-                {?MODULE, S bsr (58-35)};
-            lcg35_procdict ->
-                {_, S} = rand:seed_s(dummy),
-                {?MODULE, S bsr (58-35)};
-            exsp_inline ->
-                {_, S} = rand:seed_s(exsp),
-                {?MODULE, S};
-            procdict ->
-                {rand, rand:seed_s(exsss)};
-            _ ->
-                {rand, rand:seed_s(Alg)}
+    MeasureFun =
+        fun () ->
+                {Mod, State} = measure_init(Alg),
+                IterFun = InitFun(Mod, State),
+                {T, ok} =
+                    timer:tc(
+                      fun () ->
+                              measure_loop(State, IterFun, Iterations)
+                      end),
+                Time = T - Overhead,
+                Percent =
+                    case TMark of
+                        warm_up   -> "(warm-up)";
+                        undefined -> "   100.0%";
+                        _ ->
+                            io_lib:format(
+                              "~8.1f%", [(Time * 100 + 50) / TMark])
+                    end,
+                io:format(
+                  "~.24w: ~8.1f ns ~s~n",
+                  [Alg, (Time * 1000 + 500) / Iterations, Percent]),
+                Parent ! {self(), Time},
+                ok
         end,
-    Pid = spawn_link(
-            fun() ->
-                    Range = RangeFun(State),
-                    {T, ok} = timer:tc(fun () -> Fun(State, Range, Mod) end),
-                    Time = T - Overhead,
-                    Percent =
-                        case TMark of
-                            warm_up   -> "(warm-up)";
-                            undefined -> "   100.0%";
-                            _ ->
-                                io_lib:format(
-                                  "~8.1f%", [(Time * 100 + 50) / TMark])
-                        end,
-                    io:format(
-                      "~.24w: ~8.1f ns ~s [16#~.16b]~n",
-                      [Alg, (Time * 1000 + 500) / ?LOOP_MEASURE,
-                       Percent, Range]),
-                    Parent ! {self(), Time},
-                    normal
-            end),
+    Pid = spawn_link(MeasureFun),
     receive
 	{Pid, Msg} -> Msg
     end.
 
+measure_init(Alg) ->
+    case Alg of
+        overhead ->
+            {?MODULE, 1};
+        crypto64 ->
+            {rand, crypto64_seed()};
+        crypto_cache ->
+            {rand, crypto:rand_seed_alg(crypto_cache)};
+        crypto ->
+            {rand, crypto:rand_seed_s()};
+        crypto_aes ->
+            {rand,
+             crypto:rand_seed_alg(
+               crypto_aes, crypto:strong_rand_bytes(256))};
+        random ->
+            {random, random:seed(os:timestamp()), get(random_seed)};
+        crypto_bytes ->
+            {?MODULE, undefined};
+        crypto_bytes_cached ->
+            {?MODULE, <<>>};
+        unique_phash2 ->
+            {?MODULE, undefined};
+        system_time_rem ->
+            {?MODULE, undefined};
+        mcg35_inline ->
+            {_, S} = rand:seed_s(dummy),
+            {rand, (S rem ((1 bsl 35)-31 - 1)) + 1};
+        lcg35_inline ->
+            {_, S} = rand:seed_s(dummy),
+            {rand, S bsr (58-35)};
+        lcg35_procdict ->
+            {_, S} = rand:seed_s(dummy),
+            _ = put(Alg, S bsr (58-35)),
+            {rand, undefined};
+        exsp_inline ->
+            {_, S} = rand:seed_s(exsp),
+            {rand, S};
+        procdict ->
+            {rand, rand:seed(exsss)};
+        _ ->
+            {rand, rand:seed_s(Alg)}
+    end.
+
 %% Comparison algorithm for rand:bytes_s/2 vs. crypto:strong_rand_bytes/1
 bytes_s(N, Cache) when is_binary(Cache) ->
     %% crypto_bytes_cached
@@ -1748,7 +1676,7 @@ bytes_s(N, Cache) when is_binary(Cache) ->
                 <<Part/binary, (crypto:strong_rand_bytes(N * 16))/binary>>,
             {Bytes, Rest}
     end;
-bytes_s(N, ignored_state = St) ->
+bytes_s(N, undefined = St) ->
     %% crypto_bytes
     {crypto:strong_rand_bytes(N), St}.
 
-- 
2.34.1

Places

File 2196-Clean-up-measure-1.patch of Package erlang (Revision 58ddfd9fcf4c281c82656d8c2d2a71df)

Places