File 1726-ETS-write_concurrency-auto-fixes-and-remov... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 1726-ETS-write_concurrency-auto-fixes-and-remove-write_co.patch of Package erlang (Revision e3704281f725978c5a26174cd59024d0)

Currently displaying revision e3704281f725978c5a26174cd59024d0 , Show latest

From 1a8f7fb8521bad0efe7a137ed3abd9f54b96bec4 Mon Sep 17 00:00:00 2001
From: Kjell Winblad <kjellwinblad@gmail.com>
Date: Tue, 19 Oct 2021 20:27:23 +0200
Subject: [PATCH 6/8] ETS {write_concurrency, auto} fixes and remove
 {write_concurrency, N}

* make sure that ordered_set tables configured with
  {write_concurrency, auto} gives auto when ets:info(T,
  write_concurrency) is called

* Remove the possibility to explicitly set the number of locks from the
  public interface by using the option {write_concurrency, N}. For
  performance "debuging" purposes there is still a hidden way
  explicitly set the number of locks for hash tables by using the
  option {write_concurrency, {debug_hash_fixed_number_of_locks, 2048}}
---
 erts/emulator/beam/atom.names    |   3 +-
 erts/emulator/beam/erl_db.c      |  57 ++++++--
 erts/emulator/beam/erl_db_hash.c |   2 +-
 erts/emulator/beam/erl_db_util.h |   7 +-
 lib/stdlib/doc/src/ets.xml       |  42 ++----
 lib/stdlib/src/ets.erl           |   2 +-
 lib/stdlib/test/ets_SUITE.erl    | 228 ++++++++++++++++++++++---------
 7 files changed, 231 insertions(+), 110 deletions(-)

diff --git a/erts/emulator/beam/atom.names b/erts/emulator/beam/atom.names
index 8715c0c440..80548bcab1 100644
--- a/erts/emulator/beam/atom.names
+++ b/erts/emulator/beam/atom.names
@@ -734,4 +734,5 @@ atom x86
 atom yes
 atom yield
 atom nifs
-atom auto
\ No newline at end of file
+atom auto
+atom debug_hash_fixed_number_of_locks
\ No newline at end of file
diff --git a/erts/emulator/beam/erl_db.c b/erts/emulator/beam/erl_db.c
index 9cfc89c8e9..0a02c3e77b 100644
--- a/erts/emulator/beam/erl_db.c
+++ b/erts/emulator/beam/erl_db.c
@@ -2311,17 +2311,7 @@ BIF_RETTYPE ets_new_2(BIF_ALIST_2)
 		 keypos = signed_val(tp[2]);
 		}
 		else if (tp[1] == am_write_concurrency) {
- Sint number_of_locks_param;
- if (is_integer(tp[2]) &&
- term_to_Sint(tp[2], &number_of_locks_param) &&
- number_of_locks_param >= DB_WRITE_CONCURRENCY_MIN_LOCKS &&
- number_of_locks_param <= DB_WRITE_CONCURRENCY_MAX_LOCKS) {
- is_decentralized_counters = 1;
- is_fine_locked = 1;
- is_explicit_lock_granularity = 1;
- is_write_concurrency_auto = 0;
- number_of_locks = number_of_locks_param;
- } else if (tp[2] == am_auto) {
+ if (tp[2] == am_auto) {
 is_decentralized_counters = 1;
 is_write_concurrency_auto = 1;
 is_fine_locked = 1;
@@ -2340,6 +2330,23 @@ BIF_RETTYPE ets_new_2(BIF_ALIST_2)
 is_explicit_lock_granularity = 0;
 is_write_concurrency_auto = 0;
 number_of_locks = -1;
+ } else if (is_tuple(tp[2])) {
+ Eterm *stp = tuple_val(tp[2]);
+ Sint number_of_locks_param;
+ if (arityval(stp[0]) == 2 &&
+ stp[1] == am_debug_hash_fixed_number_of_locks &&
+ is_integer(stp[2]) &&
+ term_to_Sint(stp[2], &number_of_locks_param) &&
+ number_of_locks_param >= DB_WRITE_CONCURRENCY_MIN_LOCKS &&
+ number_of_locks_param <= DB_WRITE_CONCURRENCY_MAX_LOCKS) {
+
+ is_decentralized_counters = 1;
+ is_fine_locked = 1;
+ is_explicit_lock_granularity = 1;
+ is_write_concurrency_auto = 0;
+ number_of_locks = number_of_locks_param;
+
+ } else break;
 } else break;
 if (DB_LOCK_FREE(NULL))
 			is_fine_locked = 0;
@@ -2403,6 +2410,24 @@ BIF_RETTYPE ets_new_2(BIF_ALIST_2)
 status |= DB_CA_ORDERED_SET;
 status &= ~(DB_SET | DB_BAG | DB_DUPLICATE_BAG | DB_ORDERED_SET);
 status |= DB_FINE_LOCKED;
+ if (is_explicit_lock_granularity) {
+ /*
+ * The hidden debug option to explicitly set the number of locks,
+ * currently doesn't make sense for ordered_set.
+ */
+ BIF_ERROR(BIF_P, BADARG);
+ } else if (is_write_concurrency_auto) {
+ /*
+ * ordered_set tables that are configured with
+ * {write_concurrency, true} or {write_concurrency, auto}
+ * currently get the same implementation but we record
+ * that the auto option was used anyway so that
+ * ets:info(T, write_concurrency) can return auto when the
+ * table has been configured with {write_concurrency,
+ * auto}.
+ */
+ status |= DB_FINE_LOCKED_AUTO;
+ }
 }
 else if (IS_HASH_TABLE(status)) {
 	meth = &db_hash;
@@ -2419,6 +2444,9 @@ BIF_RETTYPE ets_new_2(BIF_ALIST_2)
 }
 else if (IS_TREE_TABLE(status)) {
 	meth = &db_tree;
+ if (is_explicit_lock_granularity) {
+ BIF_ERROR(BIF_P, BADARG);
+ }
 }
 else {
 	BIF_ERROR(BIF_P, BADARG);
@@ -5073,9 +5101,12 @@ static Eterm table_info(Process* p, DbTable* tb, Eterm What)
 if ((tb->common.status & DB_FINE_LOCKED) &&
 (tb->common.status & (DB_SET | DB_BAG | DB_DUPLICATE_BAG)) &&
 (tb->common.status & DB_EXPLICIT_LOCK_GRANULARITY)) {
- ret = erts_make_integer(tb->hash.nlocks, p);
+ Eterm* hp = HAlloc(p, 3);
+ ret = make_tuple(hp);
+ *hp++ = make_arityval(2);
+ *hp++ = am_debug_hash_fixed_number_of_locks;
+ *hp++ = erts_make_integer(tb->hash.nlocks, p);
 } else if ((tb->common.status & DB_FINE_LOCKED) &&
- (tb->common.status & (DB_SET | DB_BAG | DB_DUPLICATE_BAG)) &&
 (tb->common.status & DB_FINE_LOCKED_AUTO)) {
 ret = am_auto;
 } else {
diff --git a/erts/emulator/beam/erl_db_hash.c b/erts/emulator/beam/erl_db_hash.c
index 6b160eb97a..f18f2df40c 100644
--- a/erts/emulator/beam/erl_db_hash.c
+++ b/erts/emulator/beam/erl_db_hash.c
@@ -307,7 +307,7 @@ void erl_db_hash_adapt_number_of_locks(DbTable* tb) {
 db_hash_lock_array_resize_state current_state;
 DbTableHash* tbl;
 int new_number_of_locks;
- if(!(tb->common.type & DB_FINE_LOCKED_AUTO)) {
+ if(!IS_HASH_WITH_AUTO_TABLE(tb->common.type)) {
 return;
 }
 current_state = erts_atomic_read_nob(&tb->hash.lock_array_resize_state);
diff --git a/erts/emulator/beam/erl_db_util.h b/erts/emulator/beam/erl_db_util.h
index 1fdb0275c6..7945bbfd8b 100644
--- a/erts/emulator/beam/erl_db_util.h
+++ b/erts/emulator/beam/erl_db_util.h
@@ -351,8 +351,11 @@ typedef struct db_table_common {
 #define DB_CATREE_FORCE_SPLIT (1 << 31) /* erts_debug */
 #define DB_CATREE_DEBUG_RANDOM_SPLIT_JOIN (1 << 30) /* erts_debug */
 
-#define IS_HASH_TABLE(Status) (!!((Status) & \
-				 (DB_BAG | DB_SET | DB_DUPLICATE_BAG)))
+#define IS_HASH_TABLE(Status) (!!((Status) & \
+ (DB_BAG | DB_SET | DB_DUPLICATE_BAG)))
+#define IS_HASH_WITH_AUTO_TABLE(Status) \
+ (((Status) & \
+ (DB_ORDERED_SET | DB_CA_ORDERED_SET | DB_FINE_LOCKED_AUTO)) == DB_FINE_LOCKED_AUTO)
 #define IS_TREE_TABLE(Status) (!!((Status) & \
 				 DB_ORDERED_SET))
 #define IS_CATREE_TABLE(Status) (!!((Status) & \
diff --git a/lib/stdlib/doc/src/ets.xml b/lib/stdlib/doc/src/ets.xml
index 16b8739780..434133b92f 100644
--- a/lib/stdlib/doc/src/ets.xml
+++ b/lib/stdlib/doc/src/ets.xml
@@ -1264,7 +1264,7 @@ ets:select(Table, MatchSpec),</code>
 operation that
 mutates (writes to) the table obtains exclusive access,
 blocking any concurrent access of the same table until finished.
- If set to <c>true</c>, the table is optimized to concurrent
+ If set to <c>true</c>, the table is optimized for concurrent
 write access. Different objects of the same table can be mutated
 (and read) by concurrent processes. This is achieved to some
 degree at the expense of memory consumption and the performance
@@ -1272,31 +1272,10 @@ ets:select(Table, MatchSpec),</code>
 The <c>auto</c> alternative for the
 <c>write_concurrency</c> option is similar to the
 <c>true</c> option but automatically adjusts the
- synchronization granularity at runtime depending on how the
+ synchronization granularity during runtime depending on how the
 table is used. This is the recommended
 <c>write_concurrency</c> option when using Erlang/OTP 25
 and above as it performs well in most scenarios.
- Users can also explicitly set the synchronization
- granularity for tables of types <c>set</c>, <c>bag</c>,
- and <c>duplicate_bag</c> by setting the
- <c>write_concurrency</c> option to an integer in the range
- <c>[2, 32768]</c>. Currently, the number automatically
- rounds down to the nearest power of two. The likelihood of
- conflicts between operations reduces with an increased
- value. Explicitly setting the synchronization granularity
- is not recommended unless it is possible to
- do experimentation to figure out which synchronization
- granularity gives the best performance. If you are unsure
- what number to set this setting to, it is probably best to
- use <c>{write_concurrency, auto}</c> instead. One should be
- careful about combining the <c>{read_concurrency, true}</c>
- setting with explicitly setting the synchronization
- granularity as this can lead to worse performance and high
- memory utilization. It is usually not a good idea to set
- this setting to a number that is much greater than the
- number of expected items in the table, as this can lead to
- slow table traversals. The effect of this setting might
- change in future versions of Erlang/OTP.
 The <c>write_concurrency</c> option can be combined with the options
 <seeerl marker="#new_2_read_concurrency">
 <c>read_concurrency</c></seeerl> and
@@ -1319,18 +1298,21 @@ ets:select(Table, MatchSpec),</code>
 The memory consumption inflicted by both
 <c>write_concurrency</c> and <c>read_concurrency</c> is a
 constant overhead per table for <c>set</c>, <c>bag</c> and
- <c>duplicate_bag</c> when the <c>auto</c> alternative for
+ <c>duplicate_bag</c> when the <c>true</c> alternative for
 the <c>write_concurrency</c> option is not used. For
- <c>ordered_set</c> as well as <c>set</c>, <c>bag</c> and
- <c>duplicate_bag</c> with the <c>auto</c> alternative the
- memory overhead depends on the number of inserted objects
- and the amount of actual detected concurrency during
+ all tables with the <c>auto</c> alternative and <c>ordered_set</c>
+ tables with <c>true</c> alternative the
+ memory overhead depends on the amount of actual detected concurrency during
 runtime. The memory overhead can be especially large when
- both options are combined.
+ both <c>write_concurrency</c> and <c>read_concurrency</c> are combined.
 	 <note>
 Prior to stdlib-3.7 (OTP-22.0) <c>write_concurrency</c> had no
 	 effect on <c>ordered_set</c>.
 </note>
+ <note>
+ The <c>auto</c> alternative for the <c>write_concurrency</c>
+ option is only available in OTP-25.0 and above.
+ </note>
 <marker id="new_2_read_concurrency"></marker>
 </item>
 <tag><c>{read_concurrency,boolean()}</c></tag>
@@ -1363,7 +1345,7 @@ ets:select(Table, MatchSpec),</code>
 
 Performance tuning. Defaults to <c>true</c> for all
 tables with the <c>write_concurrency</c> option set
- to something else than <c>true</c> or <c>false</c>. For
+ to <c>auto</c>. For
 tables of type <c>ordered_set</c> the option also
 defaults to true when the <c>write_concurrency</c> option
 is set to <c>true</c>. The option defaults to
diff --git a/lib/stdlib/src/ets.erl b/lib/stdlib/src/ets.erl
index e25289d80f..e4d94c3bd6 100644
--- a/lib/stdlib/src/ets.erl
+++ b/lib/stdlib/src/ets.erl
@@ -309,7 +309,7 @@ member(_, _) ->
 | {heir, Pid :: pid(), HeirData} | {heir, none} | Tweaks,
 Type :: type(),
 Access :: access(),
- WriteConcurrencyAlternative :: boolean() | auto | 2..32768,
+ WriteConcurrencyAlternative :: boolean() | auto,
 Tweaks :: {write_concurrency, WriteConcurrencyAlternative}
 | {read_concurrency, boolean()}
 | {decentralized_counters, boolean()}
diff --git a/lib/stdlib/test/ets_SUITE.erl b/lib/stdlib/test/ets_SUITE.erl
index c7a4b38c51..ee2428ca80 100644
--- a/lib/stdlib/test/ets_SUITE.erl
+++ b/lib/stdlib/test/ets_SUITE.erl
@@ -588,7 +588,8 @@ t_repair_continuation_do(Opts) ->
 MS = [{'_',[],[true]}],
 MS2 = [{{{'$1','_'},'_'},[],['$1']}],
 (fun() ->
-	 T = ets_new(x,[ordered_set|Opts]),
+	 T = ets_new(x,
+ replace_dbg_hash_fixed_nr_of_locks([ordered_set|Opts])),
 	 F = fun(0,_)->ok;(N,F) -> ets:insert(T,{N,N}), F(N-1,F) end,
 	 F(1000,F),
 	 {_,C} = ets:select(T,MS,5),
@@ -600,7 +601,8 @@ t_repair_continuation_do(Opts) ->
 	 true = ets:delete(T)
 end)(),
 (fun() ->
-	 T = ets_new(x,[ordered_set|Opts]),
+	 T = ets_new(x,
+ replace_dbg_hash_fixed_nr_of_locks([ordered_set|Opts])),
 	 F = fun(0,_)->ok;(N,F) -> ets:insert(T,{N,N}), F(N-1,F) end,
 	 F(1000,F),
 	 {_,C} = ets:select(T,MS,1001),
@@ -612,7 +614,8 @@ t_repair_continuation_do(Opts) ->
 end)(),
 
 (fun() ->
-	 T = ets_new(x,[ordered_set|Opts]),
+	 T = ets_new(x,
+ replace_dbg_hash_fixed_nr_of_locks([ordered_set|Opts])),
 	 F = fun(0,_)->ok;(N,F) ->
 			 ets:insert(T,{integer_to_list(N),N}),
 			 F(N-1,F)
@@ -627,7 +630,8 @@ t_repair_continuation_do(Opts) ->
 	 true = ets:delete(T)
 end)(),
 (fun() ->
-	 T = ets_new(x,[ordered_set|Opts]),
+	 T = ets_new(x,
+ replace_dbg_hash_fixed_nr_of_locks([ordered_set|Opts])),
 	 F = fun(0,_)->ok;(N,F) ->
 			 ets:insert(T,{{integer_to_list(N),N},N}),
 			 F(N-1,F)
@@ -890,7 +894,8 @@ whitebox_1(Opts) ->
 ok.
 
 whitebox_2(Opts) ->
- T=ets_new(x,[ordered_set, {keypos,2} | Opts]),
+ T=ets_new(x,
+ replace_dbg_hash_fixed_nr_of_locks([ordered_set, {keypos,2} | Opts])),
 T2=ets_new(x,[set, {keypos,2}| Opts]),
 0 = ets:select_delete(T,[{{hej},[],[true]}]),
 0 = ets:select_delete(T,[{{hej,hopp},[],[true]}]),
@@ -1063,7 +1068,8 @@ t_delete_object_do(Opts) ->
 3999 = ets:info(T,size),
 0 = get_kept_objects(T),
 ets:delete(T),
- T1 = ets_new(x,[ordered_set | Opts]),
+ T1 = ets_new(x,
+ replace_dbg_hash_fixed_nr_of_locks([ordered_set | Opts])),
 filltabint(T1,4000),
 del_one_by_one_set(T1,1,4001),
 filltabint(T1,4000),
@@ -2247,7 +2253,8 @@ update_element_opts(Opts) ->
 
 update_element_opts(Tuple,KeyPos,UpdPos,Opts) ->
 Set = ets_new(set,[{keypos,KeyPos} | Opts]),
- OrdSet = ets_new(ordered_set,[ordered_set,{keypos,KeyPos} | Opts]),
+ OrdSet = ets_new(ordered_set,
+ replace_dbg_hash_fixed_nr_of_locks([ordered_set,{keypos,KeyPos} | Opts])),
 update_element(Set,Tuple,KeyPos,UpdPos),
 update_element(OrdSet,Tuple,KeyPos,UpdPos),
 true = ets:delete(Set),
@@ -2336,7 +2343,8 @@ update_tuple([], Tpl) ->
 
 update_element_neg(Opts) ->
 Set = ets_new(set,Opts),
- OrdSet = ets_new(ordered_set,[ordered_set | Opts]),
+ OrdSet = ets_new(ordered_set,
+ replace_dbg_hash_fixed_nr_of_locks([ordered_set | Opts])),
 update_element_neg_do(Set),
 update_element_neg_do(OrdSet),
 ets:delete(Set),
@@ -2393,7 +2401,8 @@ update_counter(Config) when is_list(Config) ->
 
 update_counter_do(Opts) ->
 Set = ets_new(set,Opts),
- OrdSet = ets_new(ordered_set,[ordered_set | Opts]),
+ OrdSet = ets_new(ordered_set,
+ replace_dbg_hash_fixed_nr_of_locks([ordered_set | Opts])),
 update_counter_for(Set),
 update_counter_for(OrdSet),
 ets:delete_all_objects(Set),
@@ -2553,7 +2562,8 @@ uc_adder(Init, {_Pos, Add, Thres, Warp}) ->
 
 update_counter_neg(Opts) ->
 Set = ets_new(set,Opts),
- OrdSet = ets_new(ordered_set,[ordered_set | Opts]),
+ OrdSet = ets_new(ordered_set,
+ replace_dbg_hash_fixed_nr_of_locks([ordered_set | Opts])),
 update_counter_neg_for(Set),
 update_counter_neg_for(OrdSet),
 ets:delete(Set),
@@ -2684,7 +2694,7 @@ update_counter_with_default_do(Opts) ->
 2 = ets:info(T1, size),
 
 %% Same with ordered set.
- T2 = ets_new(b, [ordered_set | Opts]),
+ T2 = ets_new(b, replace_dbg_hash_fixed_nr_of_locks([ordered_set | Opts])),
 3 = ets:update_counter(T2, foo, 2, {maroilles,1}),
 1 = ets:info(T2, size),
 5 = ets:update_counter(T2, foo, 2, {mimolette,1}),
@@ -2740,7 +2750,8 @@ update_counter_table_growth(_Config) ->
 update_counter_table_growth_do(Opts) ->
 Set = ets_new(b, [set | Opts]),
 [ets:update_counter(Set, N, {2, 1}, {N, 1}) || N <- lists:seq(1,10000)],
- OrderedSet = ets_new(b, [ordered_set | Opts]),
+ OrderedSet =
+ ets_new(b, replace_dbg_hash_fixed_nr_of_locks([ordered_set | Opts])),
 [ets:update_counter(OrderedSet, N, {2, 1}, {N, 1}) || N <- lists:seq(1,10000)],
 ok.
 
@@ -3511,7 +3522,8 @@ interface_equality(Config) when is_list(Config) ->
 interface_equality_do(Opts) ->
 EtsMem = etsmem(),
 Set = ets_new(set,[set | Opts]),
- OrderedSet = ets_new(ordered_set,[ordered_set | Opts]),
+ OrderedSet = ets_new(ordered_set,
+ replace_dbg_hash_fixed_nr_of_locks([ordered_set | Opts])),
 F = fun(X,T,FF) -> case X of
 0 -> true;
 _ ->
@@ -3570,7 +3582,7 @@ maybe_sort(Any) ->
 
 %% Test match, match_object and match_delete in ordered set's.
 ordered_match(Config) when is_list(Config)->
- repeat_for_opts(fun ordered_match_do/1).
+ repeat_for_opts_extra_opt(fun ordered_match_do/1, ordered_set).
 
 ordered_match_do(Opts) ->
 EtsMem = etsmem(),
@@ -3616,7 +3628,7 @@ ordered_match_do(Opts) ->
 
 %% Test basic functionality in ordered_set's.
 ordered(Config) when is_list(Config) ->
- repeat_for_opts(fun ordered_do/1).
+ repeat_for_opts_extra_opt(fun ordered_do/1, ordered_set).
 
 ordered_do(Opts) ->
 EtsMem = etsmem(),
@@ -4053,8 +4065,16 @@ delete_large_tab(Config) when is_list(Config) ->
 
 delete_large_tab_do(Config, Opts,Data) ->
 delete_large_tab_1(Config, foo_hash, Opts, Data, false),
- delete_large_tab_1(Config, foo_tree, [ordered_set | Opts], Data, false),
- delete_large_tab_1(Config, foo_tree, [stim_cat_ord_set | Opts], Data, false),
+ delete_large_tab_1(Config,
+ foo_tree,
+ replace_dbg_hash_fixed_nr_of_locks([ordered_set | Opts]),
+ Data,
+ false),
+ delete_large_tab_1(Config,
+ foo_tree,
+ replace_dbg_hash_fixed_nr_of_locks([stim_cat_ord_set | Opts]),
+ Data,
+ false),
 delete_large_tab_1(Config, foo_hash_fix, Opts, Data, true).
 
 
@@ -4143,8 +4163,14 @@ delete_large_named_table(Config) when is_list(Config) ->
 
 delete_large_named_table_do(Opts,Data) ->
 delete_large_named_table_1(foo_hash, [named_table | Opts], Data, false),
- delete_large_named_table_1(foo_tree, [ordered_set,named_table | Opts], Data, false),
- delete_large_named_table_1(foo_tree, [stim_cat_ord_set,named_table | Opts], Data, false),
+ delete_large_named_table_1(foo_tree,
+ replace_dbg_hash_fixed_nr_of_locks([ordered_set,named_table | Opts]),
+ Data,
+ false),
+ delete_large_named_table_1(foo_tree,
+ replace_dbg_hash_fixed_nr_of_locks([stim_cat_ord_set,named_table | Opts]),
+ Data,
+ false),
 delete_large_named_table_1(foo_hash, [named_table | Opts], Data, true).
 
 delete_large_named_table_1(Name, Flags, Data, Fix) ->
@@ -4889,22 +4915,44 @@ info(Config) when is_list(Config) ->
 {'EXIT',{badarg,_}} = (catch ets:info(make_ref())),
 {'EXIT',{badarg,_}} = (catch ets:info(make_ref(), type)),
 
- %% Test that one can set the synchronization granularity level for
- %% tables of type set
- T1 = ets:new(t1, [public, {write_concurrency, 1024}]),
- 1024 = ets:info(T1, write_concurrency),
- T2 = ets:new(t2, [public, {write_concurrency, 2048}]),
- 2048 = ets:info(T2, write_concurrency),
- T3 = ets:new(t3, [public, {write_concurrency, 1024}, {write_concurrency, true}]),
- true = ets:info(T3, write_concurrency),
- T4 = ets:new(t4, [private, {write_concurrency, 1024}]),
- false = ets:info(T4, write_concurrency),
- T5 = ets:new(t5, [public, {write_concurrency, auto}]),
- auto = ets:info(T5, write_concurrency),
- T6 = ets:new(t6, [private, {write_concurrency, true}]),
- false = ets:info(T6, write_concurrency),
- T7 = ets:new(t7, [private, {write_concurrency, auto}]),
- false = ets:info(T7, write_concurrency),
+ case erlang:system_info(schedulers) of
+ 1 -> %% Fine grained locking is not activated when there is only one scheduler
+ lists:foreach(
+ fun(Type) ->
+ T1 = ets:new(t1, [public, Type, {write_concurrency, auto}]),
+ false = ets:info(T1, write_concurrency),
+ T2 = ets:new(t2, [public, Type, {write_concurrency, true}]),
+ false = ets:info(T2, write_concurrency)
+ end,
+ [set, bag, duplicate_bag, ordered_set]),
+ T2 = ets:new(t2, [public, {write_concurrency, {debug_hash_fixed_number_of_locks, 2049}}]),
+ false = ets:info(T2, write_concurrency);
+ _ ->
+ %% Test that one can set the synchronization granularity level for
+ %% tables of type set
+ T1 = ets:new(t1, [public, {write_concurrency, {debug_hash_fixed_number_of_locks, 1024}}]),
+ {debug_hash_fixed_number_of_locks, 1024} = ets:info(T1, write_concurrency),
+ T2 = ets:new(t2, [public, {write_concurrency, {debug_hash_fixed_number_of_locks, 2048}}]),
+ {debug_hash_fixed_number_of_locks, 2048} = ets:info(T2, write_concurrency),
+ T3 = ets:new(t3, [public, {write_concurrency, {debug_hash_fixed_number_of_locks, 1024}}, {write_concurrency, true}]),
+ true = ets:info(T3, write_concurrency),
+ T4 = ets:new(t4, [private, {write_concurrency, {debug_hash_fixed_number_of_locks, 1024}}]),
+ false = ets:info(T4, write_concurrency),
+ %% Test the auto option
+ lists:foreach(
+ fun(Type) ->
+ T5 = ets:new(t5, [public, Type, {write_concurrency, auto}]),
+ auto = ets:info(T5, write_concurrency)
+ end,
+ [set, bag, duplicate_bag, ordered_set]),
+ T6 = ets:new(t6, [private, {write_concurrency, true}]),
+ false = ets:info(T6, write_concurrency),
+ T7 = ets:new(t7, [private, {write_concurrency, auto}]),
+ false = ets:info(T7, write_concurrency),
+ %% Test that the number of locks is rounded down to the nearest power of two
+ T8 = ets:new(t8, [public, {write_concurrency, {debug_hash_fixed_number_of_locks, 2049}}]),
+ {debug_hash_fixed_number_of_locks, 2048} = ets:info(T8, write_concurrency)
+ end,
 ok.
 
 info_do(Opts) ->
@@ -5131,18 +5179,26 @@ test_table_size_concurrency(Config) when is_list(Config) ->
 case erlang:system_info(schedulers) of
 1 -> {skip,"Only valid on smp > 1 systems"};
 _ ->
- BaseOptions = [public, {write_concurrency, true}],
- test_table_counter_concurrency(size, [set | BaseOptions]),
- test_table_counter_concurrency(size, [ordered_set | BaseOptions])
+ lists:foreach(
+ fun(WriteConcurrencyOpt) ->
+ BaseOptions = [public, {write_concurrency, WriteConcurrencyOpt}],
+ test_table_counter_concurrency(size, [set | BaseOptions]),
+ test_table_counter_concurrency(size, [ordered_set | BaseOptions])
+ end,
+ [true, auto])
 end.
 
 test_table_memory_concurrency(Config) when is_list(Config) ->
 case erlang:system_info(schedulers) of
 1 -> {skip,"Only valid on smp > 1 systems"};
 _ ->
- BaseOptions = [public, {write_concurrency, true}],
- test_table_counter_concurrency(memory, [set | BaseOptions]),
- test_table_counter_concurrency(memory, [ordered_set | BaseOptions])
+ lists:foreach(
+ fun(WriteConcurrencyOpt) ->
+ BaseOptions = [public, {write_concurrency, WriteConcurrencyOpt}],
+ test_table_counter_concurrency(memory, [set | BaseOptions]),
+ test_table_counter_concurrency(memory, [ordered_set | BaseOptions])
+ end,
+ [true, auto])
 end.
 
 %% Tests that calling the ets:delete operation on a table T with
@@ -5232,9 +5288,18 @@ test_decentralized_counters_setting(Config) when is_list(Config) ->
 do_test_decentralized_counters_setting(TableType) ->
 wait_for_memory_deallocations(),
 FlxCtrMemUsage = erts_debug:get_internal_state(flxctr_memory_usage),
+ FixOptsList =
+ fun(Opts) ->
+ case TableType of
+ ordered_set ->
+ replace_dbg_hash_fixed_nr_of_locks(Opts);
+ set ->
+ Opts
+ end
+ end,
 lists:foreach(
 fun(OptList) ->
- T1 = ets:new(t1, [public, TableType] ++ OptList ++ [TableType]),
+ T1 = ets:new(t1, FixOptsList([public, TableType] ++ OptList ++ [TableType])),
 check_decentralized_counters(T1, false, FlxCtrMemUsage),
 ets:delete(T1)
 end,
@@ -5242,21 +5307,22 @@ do_test_decentralized_counters_setting(TableType) ->
 case TableType of
 set ->
 [[{write_concurrency, true}, {decentralized_counters, false}],
- [{write_concurrency, 1024}, {write_concurrency, true}]];
+ [{write_concurrency, {debug_hash_fixed_number_of_locks, 1024}}, {write_concurrency, true}]];
 ordered_set -> []
 end),
 lists:foreach(
 fun(OptList) ->
- T1 = ets:new(t1, [public,
- TableType,
- {write_concurrency, true}] ++ OptList ++ [TableType]),
+ T1 = ets:new(t1,
+ FixOptsList([public,
+ TableType,
+ {write_concurrency, true}] ++ OptList ++ [TableType])),
 check_decentralized_counters(T1, true, FlxCtrMemUsage),
 ets:delete(T1),
 wait_for_memory_deallocations(),
 FlxCtrMemUsage = erts_debug:get_internal_state(flxctr_memory_usage)
 end,
 [[{decentralized_counters, true}],
- [{write_concurrency, 1024}],
+ [{write_concurrency, {debug_hash_fixed_number_of_locks, 1024}}],
 [{write_concurrency, auto}]]),
 ok.
 
@@ -6049,7 +6115,8 @@ xfilltabstr(Tab,N) ->
 fill_sets_int(N) ->
 fill_sets_int(N,[]).
 fill_sets_int(N,Opts) ->
- Tab1 = ets_new(xxx, [ordered_set|Opts]),
+ Tab1 = ets_new(xxx,
+ replace_dbg_hash_fixed_nr_of_locks([ordered_set|Opts])),
 filltabint(Tab1,N),
 Tab2 = ets_new(xxx, [set|Opts]),
 filltabint(Tab2,N),
@@ -6060,7 +6127,8 @@ fill_sets_int(N,Opts) ->
 [Tab1,Tab2,Tab3,Tab4].
 
 fill_sets_intup(N,Opts) ->
- Tab1 = ets_new(xxx, [ordered_set|Opts]),
+ Tab1 = ets_new(xxx,
+ replace_dbg_hash_fixed_nr_of_locks([ordered_set|Opts])),
 filltabintup(Tab1,N),
 Tab2 = ets_new(xxx, [set|Opts]),
 filltabintup(Tab2,N),
@@ -7703,7 +7771,7 @@ prefill_insert_map_loop(T, RS0, N, ObjFun, InsertMap, NrOfSchedulers) ->
 [set, public, {read_concurrency, true}],
 [set, public, {write_concurrency, true}, {read_concurrency, true}],
 [set, public, {write_concurrency, auto}, {read_concurrency, true}],
- [set, public, {write_concurrency, 16384}]
+ [set, public, {write_concurrency, {debug_hash_fixed_number_of_locks, 16384}}]
 ],
 etsmem_fun = fun() -> ok end,
 verify_etsmem_fun = fun(_) -> true end,
@@ -8072,7 +8140,7 @@ long_throughput_benchmark(Config) when is_list(Config) ->
 [ordered_set, public, {write_concurrency, true}, {read_concurrency, true}],
 [set, public, {write_concurrency, true}, {read_concurrency, true}],
 [set, public, {write_concurrency, auto}, {read_concurrency, true}],
- [set, public, {write_concurrency, 16384}]
+ [set, public, {write_concurrency, {debug_hash_fixed_number_of_locks, 16384}}]
 ],
 etsmem_fun = fun etsmem/0,
 verify_etsmem_fun = fun verify_etsmem/1,
@@ -9241,8 +9309,30 @@ make_unaligned_sub_binary(Bin0) when is_binary(Bin0) ->
 make_unaligned_sub_binary(List) ->
 make_unaligned_sub_binary(list_to_binary(List)).
 
+replace_dbg_hash_fixed_nr_of_locks(Opts) ->
+ [case X of
+ {write_concurrency, {debug_hash_fixed_number_of_locks, _}} ->
+ {write_concurrency, true};
+ _ -> X
+ end || X <- Opts].
+
 %% Repeat test function with different combination of table options
-%% 
+%%
+repeat_for_opts_extra_opt(F, Extra) ->
+ repeat_for_opts(
+ fun(Opts) ->
+ WithExtra =
+ case erlang:is_list(Extra) of
+ true -> Extra ++ Opts;
+ false ->[Extra | Opts]
+ end,
+ case is_invalid_opts_combo(WithExtra) of
+ true -> ok;
+ false -> F(WithExtra)
+ end
+ end,
+ [write_concurrency, read_concurrency, compressed]).
+
 repeat_for_opts(F) ->
 repeat_for_opts(F, [write_concurrency, read_concurrency, compressed]).
 
@@ -9303,21 +9393,35 @@ repeat_for_opts_atom2list(all_non_stim_types) -> [set,ordered_set,cat_ord_set,ba
 repeat_for_opts_atom2list(all_non_stim_set_types) -> [set,ordered_set,cat_ord_set];
 repeat_for_opts_atom2list(write_concurrency) -> [{write_concurrency,false},
 {write_concurrency,true},
- {write_concurrency,2},
- {write_concurrency,2048},
+ {write_concurrency, {debug_hash_fixed_number_of_locks, 2048}},
 {write_concurrency,auto}];
 repeat_for_opts_atom2list(read_concurrency) -> [{read_concurrency,false},{read_concurrency,true}];
 repeat_for_opts_atom2list(compressed) -> [void,compressed].
 
+is_invalid_opts_combo(Opts) ->
+ FixedNumLocksOption =
+ lists:any(
+ fun({write_concurrency, {debug_hash_fixed_number_of_locks, _}}) ->
+ true;
+ (_) ->
+ false
+ end,
+ Opts),
+ OrderedSet = lists:member(ordered_set, Opts) orelse
+ lists:member(stim_cat_ord_set, Opts) orelse
+ lists:member(cat_ord_set, Opts),
+ OrderedSet andalso FixedNumLocksOption.
+
 is_redundant_opts_combo(Opts) ->
- ((lists:member(stim_cat_ord_set, Opts) orelse
- lists:member(cat_ord_set, Opts))
- andalso
- (lists:member({write_concurrency, 2}, Opts) orelse
- lists:member({write_concurrency, 2048}, Opts) orelse
- lists:member({write_concurrency, false}, Opts) orelse
- lists:member(private, Opts) orelse
- lists:member(protected, Opts))).
+ IsRed1 =
+ ((lists:member(stim_cat_ord_set, Opts) orelse
+ lists:member(cat_ord_set, Opts))
+ andalso
+ (lists:member({write_concurrency, false}, Opts) orelse
+ lists:member(private, Opts) orelse
+ lists:member(protected, Opts))),
+ IsRed2 = is_invalid_opts_combo(Opts),
+ IsRed1 orelse IsRed2.
 
 %% Add fake table option with info about key range.
 %% Will be consumed by ets_new and used for stim_cat_ord_set.
-- 
2.31.1

Places

File 1726-ETS-write_concurrency-auto-fixes-and-remove-write_co.patch of Package erlang (Revision e3704281f725978c5a26174cd59024d0)

Places