ETS, Mnesia performance tests

tp.erl

-module(tp).
-compile(export_all).
-include_lib("stdlib/include/ms_transform.hrl").
-include("data_rec.hrl").

test_ets(Num) ->
    lists:foreach(
        fun({F,Title, Args}) when Title =:= [] ->
                apply(?MODULE, F, [Args]);
           ({F,Title, Args}) ->
                {T, ok} = timer:tc(?MODULE, F, [Args]),
                io:format("~p sec:[~p]~n", [Title, T/(1000*1000)])
        end, 
        [
            {ets_, "ets set insert", {Num, insert, ets_tab, bag}},
            %{ets_, "ets set get_select", {Num, get_select, ets_tab}},
            {ets_del, [], ets_tab}
        ]
    ).


ets_get(N) ->
    {Res, ok} = timer:tc(?MODULE, ets_, [N, get]),
    io:format("ets get [~w] records: ~p sec~n", [N, Res/1000000]).

ets_del(T) -> ets:delete(T).

ets_({N, insert, TabName, TabType}) ->
    ets:new(TabName, [TabType, named_table, {keypos,2},{keypos,3}]),
    ets_in_ins(N, TabName);
ets_({N, get_select, TabName}) ->
    MS = ets:fun2ms(
            fun({A,B,C}) when C =:= N -> 
                    B
            end
         ),
    ets_in_get(N, MS, TabName).

ets_simple_(N, get) -> ets_sim_in_get(N);
ets_simple_(N, insert) ->
    catch (ets:delete(ets_simple_tbl)),
    ets:new(ets_simple_tbl, [bag, named_table]),
    ets_sim_in_ins(N).

ets_sim_in_ins(0) -> ok;
ets_sim_in_ins(N) ->
    ets:insert(ets_simple_tbl, {N, N+100, 'DTName', N-1, "testfile1"}),
    ets_sim_in_ins(N-1).

ets_sim_in_get(0) -> ok;
ets_sim_in_get(N) ->
    V = N+100,
    [{N,V,K,J,T}] = ets:lookup(ets_simple_tbl, N),
    ets_sim_in_get(N-1).

ets_in_get(0, MS, _T) -> ok;
ets_in_get(N, MS, T) ->
    ets:select(T, MS),
    ets_in_get(N-1, MS, T).


ets_in_ins(0, _T) -> ok;
ets_in_ins(N, T) ->
    ets:insert(T, {"Test", "xxx", N}),
    ets_in_ins(N-1, T).

test_mnesia(N) ->
    lists:foreach(
        fun({F,Title, Args}) when Title =:= [] ->
                F(Args);
           ({F,Title, Args}) ->
                {T, ok} = timer:tc(?MODULE, F, [Args]),
                io:format("~p sec:[~p]~n", [Title, T/(1000*1000)])
        end, 
        [
            {mnesia_, "mnesia insert", {N, insert}},
            {mnesia_, "mnesia get ms", {N, {get, ms}}},
            {mnesia_, "mnesia get mo", {N, {get, mo}}}
            %{mnesia_, "mnesia get idx", {N, {get, idx}}}
        ]
    ).


mnesia_({N, insert}) -> 
    application:stop(mnesia),
    mnesia:create_schema([node()]),
    application:start(mnesia),
    mnesia:create_table(data_rec, 
        [{ram_copies, [node()]},
         {attributes, record_info(fields, data_rec)},
         {type, set},{index,[key1]}]),
    mnesia_ins(N);
mnesia_({N, {get, Type}}) -> 
    case Type of
        ms -> mnesia_get_ms(N);
        mo -> mnesia_get_mo(N);
        idx -> mnesia_get_idx(N)
    end.
mnesia_count() ->
%% timer:tc(mnesia, activity,[ets, fun ets:select_count/2, [data_rec, ets:fun2ms(fun(_)->true end)], mnesia]).
%% mnesia:activity was slower
    mnesia:ets(
        fun ets:select_count/2 , 
        [data_rec, ets:fun2ms(fun(_) ->true end)]
    ).

mnesia_ins(0) -> ok;
mnesia_ins(N) ->
    Rec = #data_rec{dtname="Test", key1=N, key2=N+100, data1="textfile1"},
    {atomic, Res} = mnesia:transaction(fun()-> mnesia:write(Rec) end),
    mnesia_ins(N-1).

mnesia_get_ms(0) -> ok;
mnesia_get_ms(N) ->
    MS2=ets:fun2ms(
                fun(#data_rec{dtname=_,key1=B,key2=C,data1=D}) when B =:= N -> 
                        %{{dtname,_},{key1,_},{key2,C},{data1,_}}
                        {{key2,C},{data1,D}}
                end
            ),
    mnesia:dirty_select(data_rec, MS2),
    mnesia_get_ms(N-1).

mnesia_get_idx(0) -> ok;
mnesia_get_idx(N) ->
    mnesia:dirty_index_read(data_rec, N, #data_rec.key1),
    mnesia_get_idx(N-1).

mnesia_get_mo(0) -> ok;
mnesia_get_mo(N) ->
    mnesia:dirty_index_match_object({data_rec, '_', N, '_', '_'}, #data_rec.key1),
    mnesia_get_mo(N-1).