Performance of term_to_binary vs Bbinary_to_term

[Jacob]

Hi,

I've tried to reproduce the measurement, but according to my
measurements, there is just a factor of 2 on Erlang/OTP 22.

1> timer:tc(fun () -> bench:t2b(a, 1000000) end)
{109357,<<131,100,0,1,97>>}
2> timer:tc(fun () -> bench:b2t(<<131,100,0,1,97>>, 1000000) end).
{199488,a}


If I do not use the result of each term_to_binary call, the factor (~14)
is much closer to your measurements:

3> timer:tc(fun () -> bench:broken_t2b(a, 1000000) end).
{14404,<<>>}

Are you indeed sure, that the compiler did not optimise away the entire
call?

/Jacob

======================== bench.erl ==============================
-module(bench).

-export([t2b/2, b2t/2, broken_t2b/2]).


t2b(T, N) -> t2b(T, N, undefined).

t2b(_, 0, R) -> R;
t2b(T, N, _) -> R = term_to_binary(T), t2b(T, N-1, R).

b2t(T, N) -> b2t(T, N, undefined).

b2t(_, 0, R) -> R;
b2t(T, N, _) -> R = binary_to_term(T), b2t(T, N-1, R).

broken_t2b(T, N) -> broken_t2b(T, N, undefined).

broken_t2b(_, 0, R) -> R;
broken_t2b(T, N, R) -> _ = term_to_binary(T), broken_t2b(T, N-1, R).
=================================================================


On 06.06.21 02:07, Valentin Micic wrote:
> Hi all,
>
> I did some performance measurement recently that included conversion of
> an arbitrary erlang term to its external binary representation via
> term_to_binary/1, as well as reversing the result using binary_to_term/1.
>
> I’ve noticed that term_to_binary/1 is significantly faster than
> binary_to_term/1.
>
> Also, I’ve observed that binary_to_term/1 performance gets considerably
> worse as complexity of specified term increases, whilst term_to_binary/1
> maintains (more-less) steady performance.
>
> (cig@REDACTED)40> tconvert:run( a, 10000000 ).
>
> term_to_binary/1 RETURN VALUE:<<131,100,0,1,97>>
> REQUEST COUNT:10000000
> ELAPSED TIME (usec):97070
> TIME PER REQUEST (usec): 0.009707
> PROJECTED RATE (req/sec): *103018440*.30081384
>
> binary_to_term/1 RETURN VALUE:a
> REQUEST COUNT:10000000
> ELAPSED TIME (usec):3383483
> TIME PER REQUEST (usec): 0.3383483
> PROJECTED RATE (req/sec): *2955534*.2822765773
> ok
>
> (cig@REDACTED)41> tconvert:run( {a,<<1,2,3>>, b, [1,2,3], c, {1,2,3},
> d, #{a=>1, b=>2, c=>3}}, 10000000 ).
>
> term_to_binary/1 RETURN
> VALUE:<<131,104,8,100,0,1,97,109,0,0,0,3,1,2,3,100,0,1,
>                                
> 98,107,0,3,1,2,3,100,0,1,99,104,3,97,1,97,2,97,
>                                
> 3,100,0,1,100,116,0,0,0,3,100,0,1,97,97,1,100,
>                                 0,1,98,97,2,100,0,1,99,97,3>>
> REQUEST COUNT:10000000
> ELAPSED TIME (usec):97307
> TIME PER REQUEST (usec): 0.0097307
> PROJECTED RATE (req/sec): *102767529*.57135664
>
> binary_to_term/1 RETURN VALUE:{a,<<1,2,3>>,
>                                  b,
>                                  [1,2,3],
>                                  c,
>                                  {1,2,3},
>                                  d, 
>                                  #{a => 1,b => 2,c => 3}}
> REQUEST COUNT:10000000
> ELAPSED TIME (usec):8747426
> TIME PER REQUEST (usec): 0.8747426
> PROJECTED RATE (req/sec): *1143193*.4377038456
> ok
>
>
>
> I’ve performed testing on R21.1.
> Any thoughts?
>
> V/