%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 2009-2018. All Rights Reserved.
%%
%% Licensed under the Apache License, Version 2.0 (the "License");
%% you may not use this file except in compliance with the License.
%% You may obtain a copy of the License at
%%
%% http://www.apache.org/licenses/LICENSE-2.0
%%
%% Unless required by applicable law or agreed to in writing, software
%% distributed under the License is distributed on an "AS IS" BASIS,
%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
%% See the License for the specific language governing permissions and
%% limitations under the License.
%%
%% %CopyrightEnd%
%%
%%
-module(crypto_bench_SUITE).
%% Note: This directive should only be used in test suites.
-compile(export_all).
-include_lib("common_test/include/ct_event.hrl").
-include_lib("common_test/include/ct.hrl").
suite() -> [%%{ct_hooks,[{ts_install_cth,[{nodenames,2}]}]},
{timetrap,{minutes,2}}
].
all() ->
[
{group, textblock_256}
].
groups() ->
[
{textblock_256, [], [
{group, ciphers_128},
{group, ciphers_256}
]},
{ciphers_128, [{repeat, 5}], [
block,
stream
]},
{ciphers_256, [{repeat, 5}], [
block,
stream,
chacha
]}
].
%%%----------------------------------------------------------------
%%%
init_per_suite(Config0) ->
try crypto:start() of
_ ->
[{_,_,Info}] = crypto:info_lib(),
ct:comment("~s",[Info]),
ct:pal("Crypto version: ~p~n~n~p",[Info,crypto:supports()]),
Config1 = measure_openssl_aes_cbc([128,256], Config0),
calibrate([{sec_goal,10} | Config1])
catch _:_ ->
{fail, "Crypto did not start"}
end.
end_per_suite(_Config) ->
application:stop(crypto).
%%%----------------------------------------------------------------
%%%
init_per_group(Group, Config) ->
case atom_to_list(Group) of
"ciphers_"++KeySizeStr ->
KeySize = list_to_integer(KeySizeStr),
[{key_size,KeySize} | Config];
"textblock_"++BlockSizeStr ->
BlockSize = list_to_integer(BlockSizeStr),
[{block_size,BlockSize} | Config];
_ ->
Config
end.
end_per_group(_Group, Config) ->
Config.
measure_openssl_aes_cbc(KeySizes, Config) ->
BLno_acc = [baseline(aes_cbc, KeySize, false) || KeySize <- KeySizes],
ct:pal("Non-accelerated baseline encryption time [µs/block]:~n~p", [BLno_acc]),
BLacc = [baseline(aes_cbc, KeySize, true) || KeySize <- KeySizes],
ct:pal("Possibly accelerated baseline encryption time [µs/block]:~n~p", [BLacc]),
[{acc,BLacc},
{no_acc,BLno_acc} | Config].
calibrate(Config) ->
Secs = proplists:get_value(sec_goal, Config, 10),
{_,Empty} = data(empty, 0, 0),
{Ne,Te} = run1(Secs*3000, Empty),
report(["Overhead"], Te/Ne),
[{overhead,Te/Ne} | Config].
%%%================================================================
%%%
%%%
block(Config) ->
run_cryptos([aes_cbc, aes_gcm, aes_ccm],
Config).
stream(Config) ->
run_cryptos([aes_ctr],
Config).
chacha(Config) ->
run_cryptos([chacha20, chacha20_poly1305],
Config).
%%%================================================================
%%%
%%%
run_cryptos(Cryptos, Config) ->
KeySize = proplists:get_value(key_size, Config),
BlockSize = proplists:get_value(block_size, Config),
MilliSecGoal = 1000*proplists:get_value(sec_goal,Config),
OverHead = proplists:get_value(overhead, Config, 0),
[try
TimePerOpBrutto = run(Crypto,KeySize,BlockSize,MilliSecGoal),
%% ct:pal("Brutto: ~p Overhead: ~p (~.2f %) Netto: ~p",
%% [TimePerOpBrutto, OverHead, 100*OverHead/TimePerOpBrutto,TimePerOpBrutto - OverHead]),
TimePerOpBrutto - OverHead
of
TimePerOp -> % µs
%% First, Report speed of encrypting blocks of 1000. [blocks/sec]
ReportUnit = 1000,
Label = [fmt(Crypto)," key:",KeySize," block:",BlockSize],
report(Label,
(BlockSize/ReportUnit)*1000000/TimePerOp
),
EffCrypto = case Crypto of
X -> X
end,
%% Percent of accelerated speed
case find_value([acc,{EffCrypto,KeySize},BlockSize], Config) of
undefined ->
ok;
TimePerOpBaseAcc ->
report(["Percent of acc OpenSSL "|Label],
100*TimePerOpBaseAcc/TimePerOp % Percent of base *speed*
)
end,
%% Percent of non-accelerated speed
case find_value([no_acc,{EffCrypto,KeySize},BlockSize], Config) of
undefined ->
ok;
TimePerOpBaseNoAcc ->
report(["Percent of noacc OpenSSL "|Label],
100*TimePerOpBaseNoAcc/TimePerOp % Percent of base *speed*
)
end
catch
_:_ ->
ct:pal("~p unsupported",[{Crypto,KeySize,BlockSize}])
end
|| Crypto <- Cryptos,
supported(Crypto)
].
run(Crypto, KeySize, BlockSize, MilliSecGoal) ->
{_Type, Funs} = data(Crypto, KeySize, BlockSize),
{Nc,Tc} = run1(MilliSecGoal, Funs),
Tc/Nc.
fmt(X) -> X.
find_value(KeyPath, PropList, Default) ->
try find_value(KeyPath, PropList)
of
undefined -> Default
catch
error:function_clause -> Default
end.
find_value(KeyPath, PropList) ->
lists:foldl(fun(K, L) when is_list(L) -> proplists:get_value(K,L);
(_, _) -> undefined
end, PropList, KeyPath).
%%%================================================================
%%%
%%%
funs({block, {Type, Key, IV, Block}}) ->
{fun() -> ok end,
fun(_) -> crypto:block_encrypt(Type, Key, IV, Block) end,
fun(_) -> ok end};
funs({stream, {Type, Key, IV, Block}}) ->
{fun() -> {crypto:stream_init(Type, Key, IV),ok} end,
fun({Ctx,_}) -> crypto:stream_encrypt(Ctx, Block) end,
fun(_) -> ok end}.
data(aes_cbc, KeySize, BlockSize) ->
Type = case KeySize of
128 -> aes_cbc128;
256 -> aes_cbc256
end,
Key = mk_bin(KeySize div 8),
IV = mk_bin(16),
Block = mk_bin(BlockSize),
{Type, funs({block, {Type, Key, IV, Block}})};
data(aes_gcm, KeySize, BlockSize) ->
Type = aes_gcm,
Key = mk_bin(KeySize div 8),
IV = mk_bin(12),
Block = mk_bin(BlockSize),
AAD = <<01,02,03,04>>,
{Type, funs({block, {Type, Key, IV, {AAD,Block,16}}})};
data(aes_ccm, KeySize, BlockSize) ->
Type = aes_ccm,
Key = mk_bin(KeySize div 8),
IV = mk_bin(12),
Block = mk_bin(BlockSize),
AAD = <<01,02,03,04>>,
{Type, funs({block, {Type, Key, IV, {AAD,Block,12}}})};
data(aes_ctr, KeySize, BlockSize) ->
Type = aes_ctr,
Key = mk_bin(KeySize div 8),
IV = mk_bin(16),
Block = mk_bin(BlockSize),
{Type, funs({stream, {Type, Key, IV, Block}})};
data(chacha20_poly1305, 256=KeySize, BlockSize) ->
Type = chacha20_poly1305,
Key = mk_bin(KeySize div 8),
IV = mk_bin(16),
AAD = <<01,02,03,04>>,
Block = mk_bin(BlockSize),
{Type, funs({block, {Type, Key, IV, {AAD,Block}}})};
data(chacha20, 256=KeySize, BlockSize) ->
Type = chacha20,
Key = mk_bin(KeySize div 8),
IV = mk_bin(16),
Block = mk_bin(BlockSize),
{Type, funs({stream, {Type, Key, IV, Block}})};
data(empty, 0, 0) ->
{undefined,
{fun() -> ok end,
fun(X) -> X end,
fun(_) -> ok end}}.
%%%================================================================
%%%
%%%
run1(MilliSecGoal, Funs) ->
Parent = self(),
Pid = spawn(fun() ->
{Fi,Fu,Ff} = Funs,
Ctx0 = Fi(),
erlang:garbage_collect(),
T0 = start_time(),
{N,Ctx} = loop(Fu, Ctx0, 0),
T = elapsed_time(T0),
Ff(Ctx),
Parent ! {result,N,microseconds(T)}
end),
Pid ! go,
receive
after MilliSecGoal ->
Pid ! stop
end,
receive
{result,N,MicroSecs} ->
{N,MicroSecs}
end.
loop(F, Ctx, N) ->
receive
stop ->
{N, Ctx}
after 0 ->
loop(F, F(Ctx), N+1)
end.
%%%----------------------------------------------------------------
report(LabelList, Value) ->
Label = report_chars(lists:concat(LabelList)),
ct:pal("ct_event:notify ~p: ~p", [Label, Value]),
ct_event:notify(
#event{name = benchmark_data,
data = [{name, Label},
{value,Value}]}).
report_chars(Cs) ->
[case C of
$- -> $_;
_ -> C
end || C <- Cs].
%%%----------------------------------------------------------------
supported(Algorithm) ->
lists:member(Algorithm,
[A || {_,As} <- crypto:supports(), A <- As]
).
%%%----------------------------------------------------------------
start_time() ->
erlang:system_time().
elapsed_time(StartTime) ->
erlang:system_time() - StartTime.
microseconds(Time) ->
erlang:convert_time_unit(Time, native, microsecond).
%%%----------------------------------------------------------------
%% Example output:
%% +DT:aes-128-cbc:3:16
%% +R:135704772:aes-128-cbc:2.980000
%% +DT:aes-128-cbc:3:64
%% +R:36835089:aes-128-cbc:3.000000
%% +DT:aes-128-cbc:3:256
%% +R:9398616:aes-128-cbc:3.000000
%% +DT:aes-128-cbc:3:1024
%% +R:2355683:aes-128-cbc:2.990000
%% +DT:aes-128-cbc:3:8192
%% +R:294508:aes-128-cbc:2.990000
%% +H:16:64:256:1024:8192
%% +F:22:aes-128-cbc:728616225.50:785815232.00:802015232.00:806762338.46:806892821.40
baseline(Crypto, KeySize, EVP) ->
Spec=
case {Crypto,KeySize} of
{aes_cbc, 128} -> "aes-128-cbc";
{aes_cbc, 256} -> "aes-256-cbc"
end,
{{Crypto,KeySize}, baseline(Spec, EVP)}.
baseline(Spec, EVP) ->
Cmd =
case EVP of
true -> "openssl speed -mr -evp " ++ Spec;
false-> "openssl speed -mr " ++ Spec
end,
get_base_values(string:tokens(os:cmd(Cmd),"\n"), Spec, []).
get_base_values(["+DT:"++Sdt,
"+R:"++Sr
|T], Crypto, Acc) ->
[Crypto0,_GoalSecs0,BlockSize0] = string:tokens(Sdt, ":"),
[Nblocks0,Crypto0,RealSecs0] = string:tokens(Sr, ":"),
Crypto = fix_possible_space_bug(Crypto0),
RealSecs = list_to_float(RealSecs0),
BlockSize = list_to_integer(BlockSize0),
Nblocks = list_to_integer(Nblocks0),
get_base_values(T, Crypto, [{BlockSize, 1000000*RealSecs/Nblocks} | Acc]);
get_base_values([_|T], Crypto, Acc) ->
get_base_values(T, Crypto, Acc);
get_base_values([], _, Acc) ->
lists:sort(Acc).
fix_possible_space_bug(S) -> lists:concat(lists:join("-",string:tokens(S,"- "))).
%%%----------------------------------------------------------------
mk_bin(Size) when Size =< 256 ->
list_to_binary(lists:seq(0,Size-1));
mk_bin(Size) when 1024 =< Size ->
B = mk_bin(Size div 4),
Brest = mk_bin(Size rem 4),
<<B/binary, B/binary, B/binary, B/binary, Brest/binary>>;
mk_bin(Size) when 256 < Size ->
B = mk_bin(Size div 2),
Brest = mk_bin(Size rem 2),
<<B/binary, B/binary, Brest/binary>>.
