测试新增

src/testCase/DsTest/utTestDs.erl

@@ -12,7 +12,7 @@
 -define(V_NUM, [8, 16, 32, 64, 128, 256, 516, 1024, 2048, 4096, 8192, 16384]).
 %-define(DsList, [utPdDs, utArrayDs, utTupleDs, utListsDs, utMapsDs, utEtsSetDs, utEtsOrdDs, utDictDs, utGb_treesDs, utSetsDs, utGb_setsDs, utOrddictDs, utOrdsetsDs, utAtomicsDs, utPTermDs, utArrayDs1, utHashBblDs, utHashBblDs1]).
 %-define(DsList, [utPdDs, utArrayDs, utNifArrayDs, utTupleDs, utListsDs, utMapsDs, utEtsSetDs,  utArrayDs1, utHashBblDs, utHashBblDs1, utKhashDs]).
--define(DsList, [utPdDs, utArrayDs, utNifArrayDs, utNifHashbDs, utKhashDs, utEtsSetDs, utTupleDs, utMapsDs, utSetsDs, utCerlSetsDs]).
+-define(DsList, [utPdDs, utArrayDs, utEtsSetDs, utTupleDs, utMapsDs, utSetsDs, utCerlSetsDs]).
 
 -define(Cnt, 12).
 

src/testCase/DsTestSimple/utSArrayDs.erl

@@ -0,0 +1,55 @@
+-module(utSArrayDs).
+-compile([nowarn_unused_function, nowarn_unused_vars, nowarn_export_all]).
+
+-export([start/2]).
+
+start(Num, Pid) ->
+   Ds = init(Num),
+   Time1 = erlang:system_time(nanosecond),
+   NewDsI = insert(Num - 1, Ds),
+   Time2 = erlang:system_time(nanosecond),
+   NewDsR = read(Num - 1, NewDsI),
+   Time3 = erlang:system_time(nanosecond),
+   NewDsU = update(Num - 1, NewDsR),
+   Time4 = erlang:system_time(nanosecond),
+   NewDsF = for(Num - 1, NewDsU),
+   Time5 = erlang:system_time(nanosecond),
+   delete(Num - 1, NewDsF),
+   Time6 = erlang:system_time(nanosecond),
+   erlang:send(Pid, {over, self(), Time2 - Time1, Time3 - Time2, Time4 - Time3, Time5 - Time4, not_support}),
+   exit(normal).
+
+init(Num) ->
+   array:new(Num, fixed).
+
+insert(0, Ds) ->
+   array:set(0, 0, Ds);
+insert(Num, Ds) ->
+   NewDs = array:set(Num, Num, Ds),
+   insert(Num - 1, NewDs).
+
+read(0, Ds) ->
+   Value = array:get(0, Ds),
+   Ds;
+read(Num, Ds) ->
+   Value = array:get(Num, Ds),
+   read(Num - 1, Ds).
+
+update(0, Ds) ->
+   array:set(0, 1, Ds);
+update(Num, Ds) ->
+   % Key = utTestDs:makeK(Num),
+   NewDs = array:set(Num, Num + 1, Ds),
+   update(Num - 1, NewDs).
+
+for(0, Ds) ->
+   Value = array:get(0, Ds),
+   Ds;
+for(Num, Ds) ->
+   Value = array:get(Num, Ds),
+   for(Num - 1, Ds).
+
+delete(Num, Ds) ->
+   ok.
+
+

src/testCase/DsTestSimple/utSCerlSetsDs.erl

@@ -0,0 +1,52 @@
+-module(utSCerlSetsDs).
+-compile([nowarn_unused_function, nowarn_unused_vars, nowarn_export_all]).
+
+-export([start/2]).
+
+start(Num, Pid) ->
+   Ds = init(Num),
+   Time1 = erlang:system_time(nanosecond),
+   NewDsI = insert(Num, Ds),
+   Time2 = erlang:system_time(nanosecond),
+   NewDsR = read(Num, NewDsI),
+   Time3 = erlang:system_time(nanosecond),
+   NewDsU = update(Num, NewDsR),
+   Time4 = erlang:system_time(nanosecond),
+   NewDsF = for(Num, NewDsU),
+   Time5 = erlang:system_time(nanosecond),
+   delete(Num, NewDsF),
+   Time6 = erlang:system_time(nanosecond),
+   erlang:send(Pid, {over, self(), Time2 - Time1, Time3 - Time2, not_support, Time5 - Time4, Time6 - Time5}),
+   exit(normal).
+
+init(_Num) ->
+   cerl_sets:new().
+
+insert(0, Ds) ->
+   Ds;
+insert(Num, Ds) ->
+   NewDs = cerl_sets:add_element(Num, Ds),
+   insert(Num - 1, NewDs).
+
+read(0, Ds) ->
+   Ds;
+read(Num, Ds) ->
+   Value = cerl_sets:is_element(Num, Ds),
+   read(Num - 1, Ds).
+
+update(Num, Ds) ->
+   Ds.
+
+for(Num, Ds) ->
+   Fun =
+      fun(Value, Acc) ->
+         Value
+      end,
+   cerl_sets:fold(Fun, [], Ds),
+   Ds.
+
+delete(0, Ds) ->
+   ok;
+delete(Num, Ds) ->
+   NewDs = cerl_sets:del_element(Num, Ds),
+   delete(Num - 1, NewDs).

src/testCase/DsTestSimple/utSDictDs.erl

@@ -0,0 +1,57 @@
+-module(utSDictDs).
+-compile([nowarn_unused_function, nowarn_unused_vars, nowarn_export_all]).
+
+-export([start/2]).
+
+start(Num, Pid) ->
+   Ds = init(Num),
+   Time1 = erlang:system_time(nanosecond),
+   NewDsI = insert(Num, Ds),
+   Time2 = erlang:system_time(nanosecond),
+   NewDsR = read(Num, NewDsI),
+   Time3 = erlang:system_time(nanosecond),
+   NewDsU = update(Num, NewDsR),
+   Time4 = erlang:system_time(nanosecond),
+   NewDsF = for(Num, NewDsU),
+   Time5 = erlang:system_time(nanosecond),
+   delete(Num, NewDsF),
+   Time6 = erlang:system_time(nanosecond),
+   erlang:send(Pid, {over, self(), Time2 - Time1, Time3 - Time2, Time4 - Time3, Time5 - Time4, Time6 - Time5}),
+   exit(normal).
+
+init(_Num) ->
+   dict:new().
+
+insert(0, Ds) ->
+   Ds;
+insert(Num, Ds) ->
+   NewDs = dict:store(Num, Num, Ds),
+   insert(Num - 1, NewDs).
+
+read(0, Ds) ->
+   Ds;
+read(Num, Ds) ->
+   Value = dict:find(Num, Ds),
+   read(Num - 1, Ds).
+
+update(0, Ds) ->
+   Ds;
+update(Num, Ds) ->
+   NewDs = dict:store(Num, Num+1, Ds),
+   update(Num - 1, NewDs).
+
+for(Num, Ds) ->
+   Fun =
+      fun(Key, Value, Acc) ->
+         Value
+      end,
+   List = dict:fold(Fun, [], Ds),
+   Ds.
+
+delete(0, Ds) ->
+   ok;
+delete(Num, Ds) ->
+   NewDs = dict:erase(Num, Ds),
+   delete(Num - 1, NewDs).
+
+

src/testCase/DsTestSimple/utSEtsOrdDs.erl

@@ -0,0 +1,57 @@
+-module(utSEtsOrdDs).
+-compile([nowarn_unused_function, nowarn_unused_vars, nowarn_export_all]).
+
+-export([start/2]).
+
+start(Num, Pid) ->
+   Ds = init(Num),
+   Time1 = erlang:system_time(nanosecond),
+   NewDsI = insert(Num, Ds),
+   Time2 = erlang:system_time(nanosecond),
+   NewDsR = read(Num, NewDsI),
+   Time3 = erlang:system_time(nanosecond),
+   NewDsU = update(Num, NewDsR),
+   Time4 = erlang:system_time(nanosecond),
+   NewDsF = for(Num, NewDsU),
+   Time5 = erlang:system_time(nanosecond),
+   delete(Num, NewDsF),
+   Time6 = erlang:system_time(nanosecond),
+   erlang:send(Pid, {over, self(), Time2 - Time1, Time3 - Time2, Time4 - Time3, Time5 - Time4, Time6 - Time5}),
+   exit(normal).
+
+init(_Num) ->
+   ets:new(test, [ordered_set]).
+
+insert(0, Ds) ->
+   Ds;
+insert(Num, Ds) ->
+   ets:insert(Ds, {Num, Num}),
+   insert(Num - 1, Ds).
+
+read(0, Ds) ->
+   Ds;
+read(Num, Ds) ->
+   Value = ets:lookup(Ds, Num),
+   read(Num - 1, Ds).
+
+update(0, Ds) ->
+   Ds;
+update(Num, Ds) ->
+   ets:update_element(Ds, Num, {2, Num + 1}),
+   update(Num - 1, Ds).
+
+for(Num, Ds) ->
+   Fun =
+      fun({Key, Value}, Acc) ->
+         Value
+      end,
+   List = ets:foldl(Fun, [], Ds),
+   Ds.
+
+delete(0, Ds) ->
+   ok;
+delete(Num, Ds) ->
+   ets:delete(Ds, Num),
+   delete(Num - 1, Ds).
+
+

src/testCase/DsTestSimple/utSEtsSetDs.erl

@@ -0,0 +1,57 @@
+-module(utSEtsSetDs).
+-compile([nowarn_unused_function, nowarn_unused_vars, nowarn_export_all]).
+
+-export([start/2]).
+
+start(Num, Pid) ->
+   Ds = init(Num),
+   Time1 = erlang:system_time(nanosecond),
+   NewDsI = insert(Num, Ds),
+   Time2 = erlang:system_time(nanosecond),
+   NewDsR = read(Num, NewDsI),
+   Time3 = erlang:system_time(nanosecond),
+   NewDsU = update(Num, NewDsR),
+   Time4 = erlang:system_time(nanosecond),
+   NewDsF = for(Num, NewDsU),
+   Time5 = erlang:system_time(nanosecond),
+   delete(Num, NewDsF),
+   Time6 = erlang:system_time(nanosecond),
+   erlang:send(Pid, {over, self(), Time2 - Time1, Time3 - Time2, Time4 - Time3, Time5 - Time4, Time6 - Time5}),
+   exit(normal).
+
+init(_Num) ->
+   ets:new(test, [set]).
+
+insert(0, Ds) ->
+   Ds;
+insert(Num, Ds) ->
+   ets:insert(Ds, {Num, Num}),
+   insert(Num - 1, Ds).
+
+read(0, Ds) ->
+   Ds;
+read(Num, Ds) ->
+   Value = ets:lookup(Ds, Num),
+   read(Num - 1, Ds).
+
+update(0, Ds) ->
+   Ds;
+update(Num, Ds) ->
+   ets:update_element(Ds, Num, {2, Num + 1}),
+   update(Num - 1, Ds).
+
+for(Num, Ds) ->
+   Fun =
+      fun({Key, Value}, Acc) ->
+         Value
+      end,
+   List = ets:foldl(Fun, [], Ds),
+   Ds.
+
+delete(0, Ds) ->
+   ok;
+delete(Num, Ds) ->
+   ets:delete(Ds, Num),
+   delete(Num - 1, Ds).
+
+

src/testCase/DsTestSimple/utSGb_setsDs.erl

@@ -0,0 +1,54 @@
+-module(utSGb_setsDs).
+-compile([nowarn_unused_function, nowarn_unused_vars, nowarn_export_all]).
+
+-export([start/2]).
+
+start(Num, Pid) ->
+   Ds = init(Num),
+   Time1 = erlang:system_time(nanosecond),
+   NewDsI = insert(Num, Ds),
+   Time2 = erlang:system_time(nanosecond),
+   NewDsR = read(Num, NewDsI),
+   Time3 = erlang:system_time(nanosecond),
+   NewDsU = update(Num, NewDsR),
+   Time4 = erlang:system_time(nanosecond),
+   NewDsF = for(Num, NewDsU),
+   Time5 = erlang:system_time(nanosecond),
+   delete(Num, NewDsF),
+   Time6 = erlang:system_time(nanosecond),
+   erlang:send(Pid, {over, self(), Time2 - Time1, Time3 - Time2, not_support, Time5 - Time4, Time6 - Time5}),
+   exit(normal).
+
+init(_Num) ->
+   gb_sets:new().
+
+insert(0, Ds) ->
+   Ds;
+insert(Num, Ds) ->
+   NewDs = gb_sets:add_element(Num, Ds),
+   insert(Num - 1, NewDs).
+
+read(0, Ds) ->
+   Ds;
+read(Num, Ds) ->
+   Value = gb_sets:is_element(Num, Ds),
+   read(Num - 1, Ds).
+
+update(Num, Ds) ->
+   Ds.
+
+for(Num, Ds) ->
+   Fun =
+      fun(Value, Acc) ->
+         Value
+      end,
+   List = gb_sets:fold(Fun, [], Ds),
+   Ds.
+
+delete(0, Ds) ->
+   ok;
+delete(Num, Ds) ->
+   NewDs = gb_sets:del_element(Num, Ds),
+   delete(Num - 1, NewDs).
+
+

src/testCase/DsTestSimple/utSGb_treesDs.erl

@@ -0,0 +1,59 @@
+-module(utSGb_treesDs).
+-compile([nowarn_unused_function, nowarn_unused_vars, nowarn_export_all]).
+
+-export([start/2]).
+
+start(Num, Pid) ->
+   Ds = init(Num),
+   Time1 = erlang:system_time(nanosecond),
+   NewDsI = insert(Num, Ds),
+   Time2 = erlang:system_time(nanosecond),
+   NewDsR = read(Num, NewDsI),
+   Time3 = erlang:system_time(nanosecond),
+   NewDsU = update(Num, NewDsR),
+   Time4 = erlang:system_time(nanosecond),
+   NewDsF = for(Num, NewDsU),
+   Time5 = erlang:system_time(nanosecond),
+   delete(Num, NewDsF),
+   Time6 = erlang:system_time(nanosecond),
+   erlang:send(Pid, {over, self(), Time2 - Time1, Time3 - Time2, Time4 - Time3, Time5 - Time4, Time6 - Time5}),
+   exit(normal).
+
+init(_Num) ->
+   gb_trees:empty().
+
+insert(0, Ds) ->
+   Ds;
+insert(Num, Ds) ->
+   NewDs = gb_trees:enter(Num, Num, Ds),
+   insert(Num - 1, NewDs).
+
+read(0, Ds) ->
+   Ds;
+read(Num, Ds) ->
+   Value = gb_trees:lookup(Num, Ds),
+   read(Num - 1, Ds).
+
+update(0, Ds) ->
+   Ds;
+update(Num, Ds) ->
+   NewDs = gb_trees:update(Num, Num + 1, Ds),
+   update(Num - 1, NewDs).
+
+for(Num, Ds) ->
+   List = gb_trees:to_list(Ds),
+   for1(List),
+   Ds.
+
+for1([]) ->
+   ok;
+for1([H | T]) ->
+   for1(T).
+
+delete(0, Ds) ->
+   ok;
+delete(Num, Ds) ->
+   NewDs = gb_trees:delete_any(Num, Ds),
+   delete(Num - 1, NewDs).
+
+

src/testCase/DsTestSimple/utSListsDs.erl

@@ -0,0 +1,56 @@
+-module(utSListsDs).
+-compile([nowarn_unused_function, nowarn_unused_vars, nowarn_export_all]).
+
+-export([start/2]).
+
+start(Num, Pid) when Num =< 32768 ->
+   Ds = init(Num),
+   Time1 = erlang:system_time(nanosecond),
+   NewDsI = insert(Num, Ds),
+   Time2 = erlang:system_time(nanosecond),
+   NewDsR = read(Num, NewDsI),
+   Time3 = erlang:system_time(nanosecond),
+   NewDsU = update(Num, NewDsR),
+   Time4 = erlang:system_time(nanosecond),
+   NewDsF = for(NewDsU, NewDsU),
+   Time5 = erlang:system_time(nanosecond),
+   delete(Num, NewDsF),
+   Time6 = erlang:system_time(nanosecond),
+   erlang:send(Pid, {over, self(), Time2 - Time1, Time3 - Time2, Time4 - Time3, Time5 - Time4, Time6 - Time5}),
+   exit(normal);
+start(Num, Pid) ->
+   erlang:send(Pid, {over, self(), skip, skip, skip, skip, skip}),
+   exit(normal).
+
+init(_Num) ->
+   [].
+
+insert(0, Ds) ->
+   Ds;
+insert(Num, Ds) ->
+   insert(Num - 1, [{Num, Num} | Ds]).
+
+read(0, Ds) ->
+   Ds;
+read(Num, Ds) ->
+   Value = lists:keyfind(Num, 1, Ds),
+   read(Num - 1, Ds).
+
+update(0, Ds) ->
+   Ds;
+update(Num, Ds) ->
+   NewDs = lists:keyreplace(Num, 1, Ds, {Num, Num + 1}),
+   update(Num - 1, NewDs).
+
+for([], Array) ->
+   Array;
+for([H | T], Array) ->
+   for(T, Array).
+
+delete(0, _List) ->
+   ok;
+delete(Num, Ds) ->
+   NewDs = lists:keydelete(Num, 1, Ds),
+   delete(Num - 1, NewDs).
+
+

src/testCase/DsTestSimple/utSMapsDs.erl

@@ -0,0 +1,62 @@
+-module(utSMapsDs).
+-compile([nowarn_unused_function, nowarn_unused_vars, nowarn_export_all]).
+
+-export([start/2]).
+
+start(Num, Pid) ->
+   Ds = init(Num),
+   Time1 = erlang:system_time(nanosecond),
+   NewDsI = insert(Num, Ds),
+   Time2 = erlang:system_time(nanosecond),
+   NewDsR = read(Num, NewDsI),
+   Time3 = erlang:system_time(nanosecond),
+   NewDsU = update(Num, NewDsR),
+   Time4 = erlang:system_time(nanosecond),
+   NewDsF = for(Num, NewDsU),
+   Time5 = erlang:system_time(nanosecond),
+   delete(Num, NewDsF),
+   Time6 = erlang:system_time(nanosecond),
+   erlang:send(Pid, {over, self(), Time2 - Time1, Time3 - Time2, Time4 - Time3, Time5 - Time4, Time6 - Time5}),
+   exit(normal).
+
+init(_Num) ->
+   maps:new().
+
+insert(0, Ds) ->
+   Ds;
+insert(Num, Ds) ->
+   NewDs = maps:put(Num, Num, Ds),
+   insert(Num - 1, NewDs).
+
+read(0, Ds) ->
+   Ds;
+read(Num, Ds) ->
+   case Ds of
+      #{Num := Value} ->
+         Value;
+      _ ->
+         undefined
+   end,
+   read(Num - 1, Ds).
+
+update(0, Ds) ->
+   Ds;
+update(Num, Ds) ->
+   NewDs = maps:update(Num, Num + 1, Ds),
+   update(Num - 1, NewDs).
+
+for(Num, Ds) ->
+   Fun =
+      fun(Key, Value, Acc) ->
+         Value
+      end,
+   List = maps:fold(Fun, [], Ds),
+   Ds.
+
+delete(0, Ds) ->
+   ok;
+delete(Num, Ds) ->
+   NewDs = maps:remove(Num, Ds),
+   delete(Num - 1, NewDs).
+
+

src/testCase/DsTestSimple/utSOrddictDs.erl

@@ -0,0 +1,60 @@
+-module(utSOrddictDs).
+-compile([nowarn_unused_function, nowarn_unused_vars, nowarn_export_all]).
+
+-export([start/2]).
+
+start(Num, Pid) when Num =< 32768 ->
+   Ds = init(Num),
+   Time1 = erlang:system_time(nanosecond),
+   NewDsI = insert(Num, Ds),
+   Time2 = erlang:system_time(nanosecond),
+   NewDsR = read(Num, NewDsI),
+   Time3 = erlang:system_time(nanosecond),
+   NewDsU = update(Num, NewDsR),
+   Time4 = erlang:system_time(nanosecond),
+   NewDsF = for(Num, NewDsU),
+   Time5 = erlang:system_time(nanosecond),
+   delete(Num, NewDsF),
+   Time6 = erlang:system_time(nanosecond),
+   erlang:send(Pid, {over, self(), Time2 - Time1, Time3 - Time2, Time4 - Time3, Time5 - Time4, Time6 - Time5}),
+   exit(normal);
+start(Num, Pid) ->
+   erlang:send(Pid, {over, self(), skip, skip, skip, skip, skip}),
+   exit(normal).
+
+init(_Num) ->
+   orddict:new().
+
+insert(0, Ds) ->
+   Ds;
+insert(Num, Ds) ->
+   NewDs = orddict:store(Num, Num, Ds),
+   insert(Num - 1, NewDs).
+
+read(0, Ds) ->
+   Ds;
+read(Num, Ds) ->
+   Value = orddict:fetch(Num, Ds),
+   read(Num - 1, Ds).
+
+update(0, Ds) ->
+   Ds;
+update(Num, Ds) ->
+   NewDs = orddict:store(Num, Num + 1, Ds),
+   update(Num - 1, NewDs).
+
+for(Num, Ds) ->
+   Fun =
+      fun(Key, Value, Acc) ->
+         Value
+      end,
+   List = orddict:fold(Fun, [], Ds),
+   Ds.
+
+delete(0, Ds) ->
+   ok;
+delete(Num, Ds) ->
+   NewDs = orddict:erase(Num, Ds),
+   delete(Num - 1, NewDs).
+
+

src/testCase/DsTestSimple/utSOrdsetsDs.erl

@@ -0,0 +1,57 @@
+-module(utSOrdsetsDs).
+-compile([nowarn_unused_function, nowarn_unused_vars, nowarn_export_all]).
+
+-export([start/2]).
+
+start(Num, Pid) when Num =< 65536 ->
+   Ds = init(Num),
+   Time1 = erlang:system_time(nanosecond),
+   NewDsI = insert(Num, Ds),
+   Time2 = erlang:system_time(nanosecond),
+   NewDsR = read(Num, NewDsI),
+   Time3 = erlang:system_time(nanosecond),
+   NewDsU = update(Num, NewDsR),
+   Time4 = erlang:system_time(nanosecond),
+   NewDsF = for(Num, NewDsU),
+   Time5 = erlang:system_time(nanosecond),
+   delete(Num, NewDsF),
+   Time6 = erlang:system_time(nanosecond),
+   erlang:send(Pid, {over, self(), Time2 - Time1, Time3 - Time2, not_support, Time5 - Time4, Time6 - Time5}),
+   exit(normal);
+start(Num, Pid) ->
+   erlang:send(Pid, {over, self(), skip, skip, skip, skip, skip}),
+   exit(normal).
+
+init(_Num) ->
+   ordsets:new().
+
+insert(0, Ds) ->
+   Ds;
+insert(Num, Ds) ->
+   NewDs = ordsets:add_element(Num, Ds),
+   insert(Num - 1, NewDs).
+
+read(0, Ds) ->
+   Ds;
+read(Num, Ds) ->
+   Value = ordsets:is_element(Num, Ds),
+   read(Num - 1, Ds).
+
+update(Num, Ds) ->
+   Ds.
+
+for(Num, Ds) ->
+   Fun =
+      fun(Key, Acc) ->
+         Key
+      end,
+   List = ordsets:fold(Fun, [], Ds),
+   Ds.
+
+delete(0, Ds) ->
+   ok;
+delete(Num, Ds) ->
+   NewDs = ordsets:del_element(Num, Ds),
+   delete(Num - 1, NewDs).
+
+

src/testCase/DsTestSimple/utSPdDs.erl

@@ -0,0 +1,60 @@
+-module(utSPdDs).
+-compile([nowarn_unused_function, nowarn_unused_vars, nowarn_export_all]).
+
+-export([start/2]).
+
+start(Num, Pid) ->
+   Ds = init(Num),
+   Time1 = erlang:system_time(nanosecond),
+   NewDsI = insert(Num, Ds),
+   Time2 = erlang:system_time(nanosecond),
+   NewDsR = read(Num, NewDsI, undefined),
+   Time3 = erlang:system_time(nanosecond),
+   NewDsU = update(Num, NewDsR),
+   Time4 = erlang:system_time(nanosecond),
+   NewDsF = for(Num, NewDsU),
+   Time5 = erlang:system_time(nanosecond),
+   delete(Num, NewDsF),
+   Time6 = erlang:system_time(nanosecond),
+   erlang:send(Pid, {over, self(), Time2 - Time1, Time3 - Time2, Time4 - Time3, Time5 - Time4, Time6 - Time5}),
+   exit(normal).
+
+init(Num) ->
+   undefined.
+
+insert(0, Ds) ->
+   Ds;
+insert(Num, Ds) ->
+   erlang:put(Num, Num),
+   insert(Num - 1, Ds).
+
+read(0, Ds, _V) ->
+   Ds;
+read(Num, Ds, _V) ->
+   Value = erlang:get(Num),
+   read(Num - 1, Ds, Value).
+
+update(0, Ds) ->
+   Ds;
+update(Num, Ds) ->
+   erlang:put(Num, Num + 1),
+   update(Num - 1, Ds).
+
+for(Num, Ds) ->
+   Keylist = erlang:get(),
+   for1(Keylist, undefined),
+   Ds.
+
+for1([], V) ->
+   ok;
+for1([H | T], _V) ->
+   V = erlang:get(H),
+   for1(T, V).
+
+delete(0, Ds) ->
+   ok;
+delete(Num, Ds) ->
+   erlang:erase(Num),
+   delete(Num - 1, Ds).
+
+

src/testCase/DsTestSimple/utSSetsDs.erl

@@ -0,0 +1,54 @@
+-module(utSSetsDs).
+-compile([nowarn_unused_function, nowarn_unused_vars, nowarn_export_all]).
+
+-export([start/2]).
+
+start(Num, Pid) ->
+   Ds = init(Num),
+   Time1 = erlang:system_time(nanosecond),
+   NewDsI = insert(Num, Ds),
+   Time2 = erlang:system_time(nanosecond),
+   NewDsR = read(Num, NewDsI),
+   Time3 = erlang:system_time(nanosecond),
+   NewDsU = update(Num, NewDsR),
+   Time4 = erlang:system_time(nanosecond),
+   NewDsF = for(Num, NewDsU),
+   Time5 = erlang:system_time(nanosecond),
+   delete(Num, NewDsF),
+   Time6 = erlang:system_time(nanosecond),
+   erlang:send(Pid, {over, self(), Time2 - Time1, Time3 - Time2, not_support, Time5 - Time4, Time6 - Time5}),
+   exit(normal).
+
+init(_Num) ->
+   sets:new().
+
+insert(0, Ds) ->
+   Ds;
+insert(Num, Ds) ->
+   NewDs = sets:add_element(Num, Ds),
+   insert(Num - 1, NewDs).
+
+read(0, Ds) ->
+   Ds;
+read(Num, Ds) ->
+   Value = sets:is_element(Num, Ds),
+   read(Num - 1, Ds).
+
+update(Num, Ds) ->
+   Ds.
+
+for(Num, Ds) ->
+   Fun =
+      fun(Value, Acc) ->
+         Value
+      end,
+   sets:fold(Fun, [], Ds),
+   Ds.
+
+delete(0, Ds) ->
+   ok;
+delete(Num, Ds) ->
+   NewDs = sets:del_element(Num, Ds),
+   delete(Num - 1, NewDs).
+
+

src/testCase/DsTestSimple/utSTestDs.erl

@@ -0,0 +1,183 @@
+-module(utSTestDs).
+-compile([export_all, nowarn_unused_function, nowarn_unused_vars, nowarn_export_all]).
+-record(tempCnt, {
+   insert = []
+   , read = []
+   , update = []
+   , for = []
+   , delete = []
+}).
+
+%-define(V_NUM, [8, 16, 32, 64, 128, 256, 516, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 524288, 1048576]).
+-define(V_NUM, [8, 16, 32, 64, 128, 256, 516, 1024, 2048, 4096, 8192, 16384]).
+%-define(DsList, [utPdDs, utArrayDs, utTupleDs, utListsDs, utMapsDs, utEtsSetDs, utEtsOrdDs, utDictDs, utGb_treesDs, utSetsDs, utGb_setsDs, utOrddictDs, utOrdsetsDs, utAtomicsDs, utPTermDs, utArrayDs1, utHashBblDs, utHashBblDs1]).
+%-define(DsList, [utPdDs, utArrayDs, utNifArrayDs, utTupleDs, utListsDs, utMapsDs, utEtsSetDs,  utArrayDs1, utHashBblDs, utHashBblDs1, utKhashDs]).
+-define(DsList, [utSPdDs, utSTupleDs, utSMapsDs, utSArrayDs, utSEtsSetDs, utSSetsDs, utSCerlSetsDs]).
+
+-define(Cnt, 12).
+
+start() ->
+   %%erlang:process_flag(trap_exit, true),
+   erlang:erase(),
+   printLog("Ds benchmark...", []),
+
+   runDs(?DsList, ?V_NUM),
+   printLog("Ds benchmark...Over calculate the AVG~n", []),
+   runAvg(?DsList, ?V_NUM).
+
+
+runDs([Ds | T], VNumList) ->
+   printTitle(),
+   runNum(VNumList, Ds),
+   runDs(T, VNumList);
+runDs([], _VNumList) ->
+   ok.
+
+runNum([Num | T], Ds) ->
+   runCnt(?Cnt, Num, Ds),
+   runNum(T, Ds);
+runNum([], _Ds) ->
+   ok.
+
+runCnt(0, Num, Ds) ->
+   ok;
+runCnt(Cnt, Num, Ds) ->
+   runExe(Num, Ds),
+   runCnt(Cnt - 1, Num, Ds).
+
+runExe(Num, Ds) ->
+   Pid = erlang:spawn_link(Ds, start, [Num, self()]),
+   receive
+      {over, Pid, Insert, Read, Update, For, Delete} ->
+         storeStatistics(Ds, Num, Insert, Read, Update, For, Delete),
+         {_, DsName} = lists:split(2, atom_to_list(Ds)),
+         printLog("~-10.s ~8.s ~12.s ~12.s ~10.s ~12.s ~10.s ~14.s ~10.s ~12.s ~12.s ~12.s ~n",
+            [DsName, integer_to_list(Num), timeToStr(Insert), calcPer(Insert, Num), timeToStr(Read), calcPer(Read, Num), timeToStr(Update), calcPer(Update, Num), timeToStr(For), calcPer(For, Num), timeToStr(Delete), calcPer(Delete, Num)]);
+      {'EXIT', Pid, normal} ->
+         ok;
+      _ShutDown ->
+         io:format("Ds test shutDown ~p ~p ~p ~n", [Ds, Num, _ShutDown])
+   end.
+
+runAvg([Ds | T], VNumList) ->
+   printAvg(),
+   runCal(VNumList, Ds),
+   runAvg(T, VNumList);
+runAvg([], _VNumList) ->
+   ok.
+
+runCal([Num | T], Ds) ->
+   #tempCnt{insert = InsertList, read = ReadList, update = UpdateList, for = ForList, delete = DeleteList} = getStatistics(Ds, Num),
+   {_, DsName} = lists:split(2, atom_to_list(Ds)),
+   printLog("~-10.s ~8.s ~12.s ~12.s ~14.s ~12.s ~12.s~n",
+      [DsName, integer_to_list(Num), calcAvg(InsertList, Num), calcAvg(ReadList, Num), calcAvg(UpdateList, Num), calcAvg(ForList, Num), calcAvg(DeleteList, Num)]),
+   runCal(T, Ds);
+runCal([], _Ds) ->
+   ok.
+
+-define(S, 1000000000).
+-define(MS, 1000000).
+-define(US, 1000).
+-define(NS, 1).
+
+timeToStr(not_support) ->
+   <<"noSupport">>;
+timeToStr(skip) ->
+   <<"skip">>;
+timeToStr(Time) when Time > ?S ->
+   float_to_list(Time / ?S, [{decimals, 2}]) ++ "s";
+timeToStr(Time) when Time > ?MS ->
+   float_to_list(Time / ?MS, [{decimals, 2}]) ++ "ms";
+timeToStr(Time) when Time > ?US ->
+   float_to_list(Time / ?US, [{decimals, 2}]) ++ "us";
+timeToStr(Time) ->
+   integer_to_list(Time) ++ "ns".
+
+calcPer(not_support, _Num) ->
+   <<"notSupport">>;
+calcPer(skip, _Num) ->
+   <<"skip">>;
+calcPer(Time, Num) ->
+   float_to_list(Time / Num, [{decimals, 2}]) ++ "ns".
+
+calcAvg([not_support | _], Num) ->
+   <<"notSupport">>;
+calcAvg([skip | _], Num) ->
+   <<"skip">>;
+calcAvg(CntList, Num) ->
+   %% 去掉最大值与最小值 然后求平均值
+   AvgCnt = ?Cnt - 2,
+   SortList = lists:sort(CntList),
+   AvgList = lists:sublist(SortList, 2, AvgCnt),
+   float_to_list(lists:sum(AvgList) / AvgCnt / Num, [{decimals, 2}]) ++ "ns".
+
+storeStatistics(Ds, Num, Insert, Read, Update, For, Delete) ->
+   #tempCnt{insert = InsertList, read = ReadList, update = UpdateList, for = ForList, delete = DeleteList} =
+      case erlang:get({Ds, Num}) of
+         undefined ->
+            #tempCnt{};
+         TempCnt ->
+            TempCnt
+      end,
+   NewTempCnt = #tempCnt{insert = [Insert | InsertList], read = [Read | ReadList], update = [Update | UpdateList], for = [For | ForList], delete = [Delete | DeleteList]},
+   erlang:put({Ds, Num}, NewTempCnt).
+
+getStatistics(Ds, Num) ->
+   erlang:get({Ds, Num}).
+
+printTitle() ->
+   printLog("~n~-10.s ~8.s ~12.s ~12.s ~10.s ~12.s ~10.s ~14.s ~10.s ~12.s ~12.s ~12.s ~n",
+      ["DsName", "V_Num", "insert", "insert/per", "read", "read/per", "update", "update/per", "for", "for/per", "delete", "delete/per"]),
+   printLog("~s ~n", [[$= || _ <- lists:seq(1, 145)]]).
+
+printAvg() ->
+   printLog("~n~-10.s ~8.s ~12.s ~12.s ~14.s ~12.s ~12.s~n",
+      ["DsName", "V_Num", "insert/per", "read/per", "update/per", "for/per", "delete/per"]),
+   printLog("~s ~n", [[$= || _ <- lists:seq(1, 85)]]).
+
+printLog(Format, Args) ->
+   % {ok, File} = file:open("src/docs/erlang-DsBenchMark.txt", [write, append]),
+   % io:format(File, Format, Args),
+   % file:close(File).
+   io:format(Format, Args).
+
+
+makeK(N) ->
+   case N rem 4 of
+      0 ->
+         N;
+      1 ->
+         {N, <<"test-testDs">>};
+      2 ->
+         {N, test};
+      3 ->
+         [N, test]
+   end.
+
+makeV(N) ->
+   case N rem 4 of
+      0 ->
+         N;
+      1 ->
+         {N, <<"test-testDs">>};
+      2 ->
+         {N, 8787.87878, <<"test-testDs">>};
+      3 ->
+         {N, test, [list, 123, 456.789, "test"], {23231, "gggggg"}, <<"12345678901234567890">>}
+   end.
+
+makeV2(N) ->
+   case N rem 4 of
+      0 ->
+         {N, 8787.87878, <<"test-testDs">>};
+      1 ->
+         {N, test, [list, 123, 456.789, "test"], {23231, "gggggg"}, <<"12345678901234567890">>};
+      2 ->
+         N;
+      3 ->
+         {N, <<"test-testDs">>}
+   end.
+
+makeRandV() ->
+   utGenTerm:any().
+

src/testCase/DsTestSimple/utSTupleDs.erl

@@ -0,0 +1,55 @@
+-module(utSTupleDs).
+-compile([nowarn_unused_function, nowarn_unused_vars, nowarn_export_all]).
+
+-export([start/2]).
+
+start(Num, Pid) when Num =< 65536 ->
+   Ds = init(Num),
+   Time1 = erlang:system_time(nanosecond),
+   NewDsI = insert(Num, Ds),
+   Time2 = erlang:system_time(nanosecond),
+   NewDsR = read(Num, NewDsI, undefined),
+   Time3 = erlang:system_time(nanosecond),
+   NewDsU = update(Num, NewDsR),
+   Time4 = erlang:system_time(nanosecond),
+   NewDsF = for(Num, NewDsU, undefined),
+   Time5 = erlang:system_time(nanosecond),
+   delete(Num, NewDsF),
+   Time6 = erlang:system_time(nanosecond),
+   erlang:send(Pid, {over, self(), Time2 - Time1, Time3 - Time2, Time4 - Time3, Time5 - Time4, not_support}),
+   exit(normal);
+start(Num, Pid) ->
+   erlang:send(Pid, {over, self(), skip, skip, skip, skip, skip}),
+   exit(normal).
+
+init(Num) ->
+   erlang:make_tuple(Num, undefined).
+
+insert(0, Ds) ->
+   Ds;
+insert(Num, Ds) ->
+   NewDs = erlang:setelement(Num, Ds, Num),
+   insert(Num - 1, NewDs).
+
+read(0, Ds, _V) ->
+   Ds;
+read(Num, Ds, _V) ->
+   Value = erlang:element(Num, Ds),
+   read(Num - 1, Ds, Value).
+
+update(0, Ds) ->
+   Ds;
+update(Num, Ds) ->
+   NewDs = erlang:setelement(Num, Ds, Num + 1),
+   update(Num - 1, NewDs).
+
+for(0, Ds, _V) ->
+   Ds;
+for(Num, Ds, _V) ->
+   Value = erlang:element(Num, Ds),
+   for(Num - 1, Ds, Value).
+
+delete(Num, Ds) ->
+   ok.
+
+

src/testCase/utTestPerformance.erl

@@ -470,7 +470,11 @@ doPAL2([OneAction | LeftActions], CallbackForm, CycleData, Debug, IsPostpone, Is
          doPAL2(LeftActions, CallbackForm, CycleData, Debug, IsPostpone, IsHibernate, DoAfter, Timeouts, NextEvents)
    end.
 
-
+lr(0) ->
+   ok;
+lr(N) ->
+   lists:reverse([]),
+   lr(N - 1).