File 5133-erts-Optionally-include-off-heap-binaries-... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 5133-erts-Optionally-include-off-heap-binaries-into-max_h.patch of Package erlang (Revision ec256062c09e7bf85ace52340f7c6484)

Currently displaying revision ec256062c09e7bf85ace52340f7c6484 , Show latest

From 7a90b4c68badbfdd7d5a9f7550603621dab07292 Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Thu, 22 Sep 2022 15:26:31 +0200
Subject: [PATCH 3/3] erts: Optionally include off-heap binaries into
 max_heap_size

diff --git a/erts/doc/src/erl_cmd.xml b/erts/doc/src/erl_cmd.xml
index 9069061ae4..d3b00f83d8 100644
--- a/erts/doc/src/erl_cmd.xml
+++ b/erts/doc/src/erl_cmd.xml
@@ -949,6 +949,14 @@ $ <input>erl \
 <seeerl marker="erlang#process_flag_max_heap_size">
 <c>process_flag(max_heap_size, MaxHeapSize)</c></seeerl>.
 </item>
+ <tag><marker id="+hmaxib"/><c><![CDATA[+hmaxib true|false]]></c></tag>
+ <item>
+ Sets whether to include the size of shared off-heap binaries
+ in the sum compared against the maximum heap size. Defaults to
+	 <c>false</c>. For more information, see
+ <seeerl marker="erlang#process_flag_max_heap_size">
+ <c>process_flag(max_heap_size, MaxHeapSize)</c></seeerl>.
+ </item>
 <tag><marker id="+hmaxk"/><c><![CDATA[+hmaxk true|false]]></c></tag>
 <item>
 Sets whether to kill processes reaching the maximum heap size or not.
diff --git a/erts/doc/src/erlang.xml b/erts/doc/src/erlang.xml
index d409905ba3..e25976c38b 100644
--- a/erts/doc/src/erlang.xml
+++ b/erts/doc/src/erlang.xml
@@ -6468,6 +6468,26 @@ receive_replies(ReqId, N, Acc) ->
 or <seeerl marker="#system_flag_max_heap_size">
 <c>erlang:system_flag(max_heap_size, MaxHeapSize)</c></seeerl>.
 </item>
+ <tag><c>include_shared_binaries</c></tag>
+ <item>
+ 
+	 When set to <c>true</c>, off-heap binaries are included in the
+	 total sum compared against the <c>size</c> limit. Off-heap binaries
+	 are typically larger binaries that may be shared between
+	 processes. The size of a shared binary is included by all
+	 processes that are referring it. Also, the entire size of a large
+	 binary may be included even if only a smaller part of it is
+	 referred by the process.
+ 
+	 
+	 If <c>include_shared_binaries</c> is not defined in the map, the
+	 system default is used. The default system default is <c>false</c>.
+ It can be changed by either the option
+ <seecom marker="erl#+hmaxib">+hmaxib</seecom> in <c>erl(1)</c>,
+ or <seeerl marker="#system_flag_max_heap_size">
+ <c>erlang:system_flag(max_heap_size, MaxHeapSize)</c></seeerl>.
+ 
+ </item>
 </taglist>
 The heap size of a process is quite hard to predict, especially the
 amount of memory that is used during the garbage collection. When
@@ -10415,8 +10435,10 @@ Metadata = #{ pid => pid(),
 system-wide maximum heap size settings for spawned processes.
 This setting can be set using the command-line flags
 <seecom marker="erl#+hmax"><c>+hmax</c></seecom>,
- <seecom marker="erl#+hmaxk"><c>+hmaxk</c></seecom> and
- <seecom marker="erl#+hmaxel"><c>+hmaxel</c></seecom> in
+ <seecom marker="erl#+hmaxk"><c>+hmaxk</c></seecom>,
+ <seecom marker="erl#+hmaxel"><c>+hmaxel</c></seecom> and
+	 <seecom marker="erl#+hmaxib"><c>+hmaxibl</c></seecom> in
+
 <c>erl(1)</c>. It can also be changed at runtime using
 <seeerl marker="#system_flag_max_heap_size">
 <c>erlang:system_flag(max_heap_size, MaxHeapSize)</c></seeerl>.
diff --git a/erts/emulator/beam/atom.names b/erts/emulator/beam/atom.names
index 274a8e23d4..40a37fb288 100644
--- a/erts/emulator/beam/atom.names
+++ b/erts/emulator/beam/atom.names
@@ -363,6 +363,7 @@ atom ignore
 atom in
 atom in_exiting
 atom inactive
+atom include_shared_binaries
 atom incomplete
 atom inconsistent
 atom index
diff --git a/erts/emulator/beam/erl_gc.c b/erts/emulator/beam/erl_gc.c
index 2e2a028fc8..fc8065d05c 100644
--- a/erts/emulator/beam/erl_gc.c
+++ b/erts/emulator/beam/erl_gc.c
@@ -158,6 +158,7 @@ static void offset_rootset(Process *p, Sint heap_offs, Sint stack_offs,
 			 Eterm* objv, int nobj);
 static void offset_off_heap(Process* p, Sint offs, char* area, Uint area_size);
 static void offset_mqueue(Process *p, Sint offs, char* area, Uint area_size);
+static int has_reached_max_heap_size(Process *p, Uint total_heap_size);
 static int reached_max_heap_size(Process *p, Uint total_heap_size,
 Uint extra_heap_size, Uint extra_old_heap_size);
 static void init_gc_info(ErtsGCInfo *gcip);
@@ -1155,7 +1156,7 @@ erts_garbage_collect_literals(Process* p, Eterm* literals,
 new_heap_size = HEAP_END(p) - HEAP_START(p);
 old_heap_size = erts_next_heap_size(lit_size, 0);
 total_heap_size = new_heap_size + old_heap_size;
- if (MAX_HEAP_SIZE_GET(p) < total_heap_size &&
+ if (has_reached_max_heap_size(p, total_heap_size) &&
 reached_max_heap_size(p, total_heap_size,
 new_heap_size, old_heap_size)) {
 erts_set_self_exiting(p, am_killed);
@@ -1387,7 +1388,7 @@ minor_collection(Process* p, ErlHeapFragment *live_hf_end,
 extra_heap_size = next_heap_size(p, stack_size + size_before, 0);
 heap_size += extra_heap_size;
 
- if (heap_size > MAX_HEAP_SIZE_GET(p))
+ if (has_reached_max_heap_size(p, heap_size))
 if (reached_max_heap_size(p, heap_size, extra_heap_size, extra_old_heap_size))
 return -2;
 }
@@ -1836,7 +1837,7 @@ major_collection(Process* p, ErlHeapFragment *live_hf_end,
 /* Add size of new young heap */
 heap_size += new_sz;
 
- if (MAX_HEAP_SIZE_GET(p) < heap_size)
+ if (has_reached_max_heap_size(p, heap_size))
 if (reached_max_heap_size(p, heap_size, new_sz, 0))
 return -2;
 }
@@ -3679,6 +3680,16 @@ erts_process_gc_info(Process *p, Uint *sizep, Eterm **hpp,
 return res;
 }
 
+static int has_reached_max_heap_size(Process *p, Uint total_heap_size)
+{
+ Uint used = total_heap_size;
+
+ if (MAX_HEAP_SIZE_FLAGS_GET(p) & MAX_HEAP_SIZE_INCLUDE_OH_BINS) {
+ used += p->bin_old_vheap + p->off_heap.overhead;
+ }
+ return (used > MAX_HEAP_SIZE_GET(p));
+}
+
 static int
 reached_max_heap_size(Process *p, Uint total_heap_size,
 Uint extra_heap_size, Uint extra_old_heap_size)
@@ -3743,10 +3754,11 @@ erts_max_heap_size_map(ErtsHeapFactory *factory,
 Sint max_heap_size, Uint max_heap_flags)
 {
 Eterm keys[] = {
- am_error_logger, am_kill, am_size
+ am_error_logger, am_include_shared_binaries, am_kill, am_size
 };
 Eterm values[] = {
 max_heap_flags & MAX_HEAP_SIZE_LOG ? am_true : am_false,
+ max_heap_flags & MAX_HEAP_SIZE_INCLUDE_OH_BINS ? am_true : am_false,
 max_heap_flags & MAX_HEAP_SIZE_KILL ? am_true : am_false,
 make_small(max_heap_size)
 };
@@ -3767,6 +3779,7 @@ erts_max_heap_size(Eterm arg, Uint *max_heap_size, Uint *max_heap_flags)
 const Eterm *size = erts_maps_get(am_size, arg);
 const Eterm *kill = erts_maps_get(am_kill, arg);
 const Eterm *log = erts_maps_get(am_error_logger, arg);
+ const Eterm *incl_bins = erts_maps_get(am_include_shared_binaries, arg);
 if (size && is_small(*size)) {
 sz = signed_val(*size);
 } else {
@@ -3789,6 +3802,14 @@ erts_max_heap_size(Eterm arg, Uint *max_heap_size, Uint *max_heap_flags)
 else
 return 0;
 }
+ if (incl_bins) {
+ if (*incl_bins == am_true)
+ *max_heap_flags |= MAX_HEAP_SIZE_INCLUDE_OH_BINS;
+ else if (*incl_bins == am_false)
+ *max_heap_flags &= ~MAX_HEAP_SIZE_INCLUDE_OH_BINS;
+ else
+ return 0;
+ }
 } else
 return 0;
 if (sz < 0)
diff --git a/erts/emulator/beam/erl_gc.h b/erts/emulator/beam/erl_gc.h
index 262c040974..c1760562c9 100644
--- a/erts/emulator/beam/erl_gc.h
+++ b/erts/emulator/beam/erl_gc.h
@@ -160,7 +160,7 @@ typedef struct {
 Uint64 garbage_cols;
 } ErtsGCInfo;
 
-#define ERTS_MAX_HEAP_SIZE_MAP_SZ (2*3 + 1 + MAP_HEADER_FLATMAP_SZ)
+#define ERTS_MAX_HEAP_SIZE_MAP_SZ (2*4 + 1 + MAP_HEADER_FLATMAP_SZ)
 
 #define ERTS_PROCESS_GC_INFO_MAX_TERMS (11) /* number of elements in process_gc_info*/
 #define ERTS_PROCESS_GC_INFO_MAX_SIZE \
diff --git a/erts/emulator/beam/erl_init.c b/erts/emulator/beam/erl_init.c
index 577657bbb2..1de7403894 100644
--- a/erts/emulator/beam/erl_init.c
+++ b/erts/emulator/beam/erl_init.c
@@ -631,6 +631,7 @@ void erts_usage(void)
 	 H_DEFAULT_MAX_SIZE);
 erts_fprintf(stderr, "-hmaxk bool enable or disable kill at max heap size (default true)\n");
 erts_fprintf(stderr, "-hmaxel bool enable or disable error_logger report at max heap size (default true)\n");
+ erts_fprintf(stderr, "-hmaxib bool enable or disable including off-heap binaries into max heap size (default false)\n");
 erts_fprintf(stderr, "-hpds size set initial process dictionary size (default %d)\n",
 	 erts_pd_initial_size);
 erts_fprintf(stderr, "-hmqd val set default message queue data flag for processes;\n");
@@ -1580,6 +1581,8 @@ erl_start(int argc, char **argv)
 * h|max - max_heap_size
 * h|maxk - max_heap_kill
 * h|maxel - max_heap_error_logger
+ * h|maxib - map_heap_include_shared_binaries
+ *
 	 *
 	 */
 	 if (has_prefix("mbs", sub_param)) {
@@ -1642,6 +1645,17 @@ erl_start(int argc, char **argv)
 		 erts_usage();
 		}
 		VERBOSE(DEBUG_SYSTEM, ("using max heap log %d\n", H_MAX_FLAGS));
+ } else if (has_prefix("maxib", sub_param)) {
+ arg = get_arg(sub_param+5, argv[i+1], &i);
+ if (sys_strcmp(arg,"true") == 0) {
+ H_MAX_FLAGS |= MAX_HEAP_SIZE_INCLUDE_OH_BINS;
+ } else if (sys_strcmp(arg,"false") == 0) {
+ H_MAX_FLAGS &= ~MAX_HEAP_SIZE_INCLUDE_OH_BINS;
+ } else {
+ erts_fprintf(stderr, "bad max heap include bins %s\n", arg);
+ erts_usage();
+ }
+ VERBOSE(DEBUG_SYSTEM, ("using max heap log %d\n", H_MAX_FLAGS));
 	 } else if (has_prefix("max", sub_param)) {
 Sint hMaxSize;
 char *rest;
diff --git a/erts/emulator/beam/erl_process.h b/erts/emulator/beam/erl_process.h
index 36b483acf4..dbc94d8d66 100644
--- a/erts/emulator/beam/erl_process.h
+++ b/erts/emulator/beam/erl_process.h
@@ -993,14 +993,15 @@ typedef struct ErtsProcSysTaskQs_ ErtsProcSysTaskQs;
 # define MSO(p) (p)->off_heap
 # define MIN_HEAP_SIZE(p) (p)->min_heap_size
 
-# define MAX_HEAP_SIZE_GET(p) ((p)->max_heap_size >> 2)
-# define MAX_HEAP_SIZE_SET(p, sz) ((p)->max_heap_size = ((sz) << 2) | \
+# define MAX_HEAP_SIZE_GET(p) ((p)->max_heap_size >> 3)
+# define MAX_HEAP_SIZE_SET(p, sz) ((p)->max_heap_size = ((sz) << 3) | \
 MAX_HEAP_SIZE_FLAGS_GET(p))
-# define MAX_HEAP_SIZE_FLAGS_GET(p) ((p)->max_heap_size & 0x3)
+# define MAX_HEAP_SIZE_FLAGS_GET(p) ((p)->max_heap_size & 0x7)
 # define MAX_HEAP_SIZE_FLAGS_SET(p, flags) ((p)->max_heap_size = flags | \
- ((p)->max_heap_size & ~0x3))
+ ((p)->max_heap_size & ~0x7))
 # define MAX_HEAP_SIZE_KILL 1
 # define MAX_HEAP_SIZE_LOG 2
+# define MAX_HEAP_SIZE_INCLUDE_OH_BINS 4
 
 struct process {
 ErtsPTabElementCommon common; /* *Need* to be first in struct */
diff --git a/erts/emulator/test/process_SUITE.erl b/erts/emulator/test/process_SUITE.erl
index 73e0b04100..bd9fa32fbf 100644
--- a/erts/emulator/test/process_SUITE.erl
+++ b/erts/emulator/test/process_SUITE.erl
@@ -222,6 +222,7 @@ end_per_testcase(Func, Config) when is_atom(Func), is_list(Config) ->
 erlang:system_flag(max_heap_size,
 #{size => 0,
 kill => true,
+ include_shared_binaries => false,
 error_logger => true}),
 erts_test_utils:ept_check_leaked_nodes(Config).
 
@@ -527,7 +528,8 @@ t_process_info(Config) when is_list(Config) ->
 {status, running} = process_info(self(), status),
 {min_heap_size, 233} = process_info(self(), min_heap_size),
 {min_bin_vheap_size,46422} = process_info(self(), min_bin_vheap_size),
- {max_heap_size, #{ size := 0, kill := true, error_logger := true}} =
+ {max_heap_size, #{ size := 0, kill := true, error_logger := true,
+ include_shared_binaries := false}} =
 process_info(self(), max_heap_size),
 {current_function,{?MODULE,t_process_info,1}} =
 	process_info(self(), current_function),
@@ -685,8 +687,9 @@ process_info_other_msg(Config) when is_list(Config) ->
 
 {min_heap_size, 233} = process_info(Pid, min_heap_size),
 {min_bin_vheap_size, 46422} = process_info(Pid, min_bin_vheap_size),
- {max_heap_size, #{ size := 0, kill := true, error_logger := true}} =
- process_info(self(), max_heap_size),
+ {max_heap_size, #{ size := 0, kill := true, error_logger := true,
+ include_shared_binaries := false}} =
+ process_info(Pid, max_heap_size),
 
 Pid ! stop,
 ok.
@@ -1943,6 +1946,8 @@ process_flag_badarg(Config) when is_list(Config) ->
 kill => gurka }) end),
 chk_badarg(fun () -> process_flag(max_heap_size, #{ size => 233,
 error_logger => gurka }) end),
+ chk_badarg(fun () -> process_flag(max_heap_size, #{ size => 233,
+ include_shared_binaries => gurka}) end),
 chk_badarg(fun () -> process_flag(max_heap_size, #{ size => 233,
 kill => true,
 error_logger => gurka }) end),
@@ -2593,63 +2598,72 @@ spawn_opt_max_heap_size(_Config) ->
 flush()
 end,
 
+ spawn_opt_max_heap_size_do(fun oom_fun/1),
+
+ io:format("Repeat tests with refc binaries\n",[]),
+
+ spawn_opt_max_heap_size_do(fun oom_bin_fun/1),
+
+ error_logger:delete_report_handler(?MODULE),
+ ok.
+
+spawn_opt_max_heap_size_do(OomFun) ->
+ Max = 2024,
 %% Test that numerical limit works
- max_heap_size_test(1024, 1024, true, true),
+ max_heap_size_test(Max, Max, true, true, OomFun),
 
 %% Test that map limit works
- max_heap_size_test(#{ size => 1024 }, 1024, true, true),
+ max_heap_size_test(#{ size => Max }, Max, true, true, OomFun),
 
 %% Test that no kill is sent
- max_heap_size_test(#{ size => 1024, kill => false }, 1024, false, true),
+ max_heap_size_test(#{ size => Max, kill => false }, Max, false, true, OomFun),
 
 %% Test that no error_logger report is sent
- max_heap_size_test(#{ size => 1024, error_logger => false }, 1024, true, false),
+ max_heap_size_test(#{ size => Max, error_logger => false }, Max, true, false, OomFun),
 
 %% Test that system_flag works
- erlang:system_flag(max_heap_size, #{ size => 0, kill => false,
- error_logger => true}),
- max_heap_size_test(#{ size => 1024 }, 1024, false, true),
- max_heap_size_test(#{ size => 1024, kill => true }, 1024, true, true),
+ erlang:system_flag(max_heap_size, OomFun(#{ size => 0, kill => false,
+ error_logger => true})),
+ max_heap_size_test(#{ size => Max }, Max, false, true, OomFun),
+ max_heap_size_test(#{ size => Max, kill => true }, Max, true, true, OomFun),
 
- erlang:system_flag(max_heap_size, #{ size => 0, kill => true,
- error_logger => false}),
- max_heap_size_test(#{ size => 1024 }, 1024, true, false),
- max_heap_size_test(#{ size => 1024, error_logger => true }, 1024, true, true),
+ erlang:system_flag(max_heap_size, OomFun(#{ size => 0, kill => true,
+ error_logger => false})),
+ max_heap_size_test(#{ size => Max }, Max, true, false, OomFun),
+ max_heap_size_test(#{ size => Max, error_logger => true }, Max, true, true, OomFun),
 
- erlang:system_flag(max_heap_size, #{ size => 1 bsl 20, kill => true,
- error_logger => true}),
- max_heap_size_test(#{ }, 1 bsl 20, true, true),
+ erlang:system_flag(max_heap_size, OomFun(#{ size => 1 bsl 16, kill => true,
+ error_logger => true})),
+ max_heap_size_test(#{ }, 1 bsl 16, true, true, OomFun),
 
 erlang:system_flag(max_heap_size, #{ size => 0, kill => true,
 error_logger => true}),
 
 %% Test that ordinary case works as expected again
- max_heap_size_test(1024, 1024, true, true),
+ max_heap_size_test(Max, Max, true, true, OomFun),
+ ok.
 
- error_logger:delete_report_handler(?MODULE),
 
- ok.
+mhs_spawn_opt(Option) when map_get(size, Option) > 0;
+ is_integer(Option) ->
+ [{max_heap_size, Option}];
+mhs_spawn_opt(_) ->
+ [].
 
-max_heap_size_test(Option, Size, Kill, ErrorLogger)
- when map_size(Option) == 0 ->
- max_heap_size_test([], Size, Kill, ErrorLogger);
-max_heap_size_test(Option, Size, Kill, ErrorLogger)
- when is_map(Option); is_integer(Option) ->
- max_heap_size_test([{max_heap_size, Option}], Size, Kill, ErrorLogger);
-max_heap_size_test(Option, Size, Kill, ErrorLogger) ->
- OomFun = fun () -> oom_fun([]) end,
- Pid = spawn_opt(OomFun, Option),
+max_heap_size_test(Option, Size, Kill, ErrorLogger, OomFun) ->
+ SpOpt = mhs_spawn_opt(OomFun(Option)),
+ Pid = spawn_opt(fun()-> OomFun(run) end, SpOpt),
 {max_heap_size, MHSz} = erlang:process_info(Pid, max_heap_size),
- ct:log("Default: ~p~nOption: ~p~nProc: ~p~n",
- [erlang:system_info(max_heap_size), Option, MHSz]),
+ ct:log("Default: ~p~nOption: ~p~nProc: ~p~nSize = ~p~nSpOpt = ~p~n",
+ [erlang:system_info(max_heap_size), Option, MHSz, Size, SpOpt]),
 
 #{ size := Size} = MHSz,
 
 Ref = erlang:monitor(process, Pid),
 if Kill ->
 receive
- {'DOWN', Ref, process, Pid, killed} ->
- ok
+ {'DOWN', Ref, process, Pid, Reason} ->
+ killed = Reason
 end;
 true ->
 ok
@@ -2680,12 +2694,37 @@ max_heap_size_test(Option, Size, Kill, ErrorLogger) ->
 %% Make sure that there are no unexpected messages.
 receive_unexpected().
 
-oom_fun(Acc0) ->
+oom_fun(Max) when is_integer(Max) -> Max;
+oom_fun(Map) when is_map(Map)-> Map;
+oom_fun(run) ->
+ io:format("oom_fun() started\n",[]),
+ oom_run_fun([], 100).
+
+oom_run_fun(Acc0, 0) ->
+ done;
+oom_run_fun(Acc0, N) ->
 %% This is tail-recursive since the compiler is smart enough to figure
 %% out that a body-recursive variant never returns, and loops forever
 %% without keeping the list alive.
 timer:sleep(5),
- oom_fun([lists:seq(1, 1000) | Acc0]).
+ oom_run_fun([lists:seq(1, 1000) | Acc0], N-1).
+
+oom_bin_fun(Max) when is_integer(Max) -> oom_bin_fun(#{size => Max});
+oom_bin_fun(Map) when is_map(Map) -> Map#{include_shared_binaries => true};
+oom_bin_fun(run) ->
+ oom_bin_run_fun([], 10).
+
+oom_bin_run_fun(Acc0, 0) ->
+ done;
+oom_bin_run_fun(Acc0, N) ->
+ timer:sleep(5),
+ oom_bin_run_fun([build_refc_bin(160, <<>>) | Acc0], N-1).
+
+build_refc_bin(0, Acc) ->
+ Acc;
+build_refc_bin(N, Acc) ->
+ build_refc_bin(N-1, <<Acc/binary, 0:(1000*8)>>).
+
 
 receive_error_messages(Pid) ->
 receive
diff --git a/erts/etc/common/erlexec.c b/erts/etc/common/erlexec.c
index c9a662e70f..888df87e35 100644
--- a/erts/etc/common/erlexec.c
+++ b/erts/etc/common/erlexec.c
@@ -152,6 +152,7 @@ static char *plush_val_switches[] = {
 "max",
 "maxk",
 "maxel",
+ "maxib",
 "mqd",
 "",
 NULL
diff --git a/erts/preloaded/src/erlang.erl b/erts/preloaded/src/erlang.erl
index 6ac524528d..71a50ddcde 100644
--- a/erts/preloaded/src/erlang.erl
+++ b/erts/preloaded/src/erlang.erl
@@ -3093,7 +3093,8 @@ spawn_monitor(M, F, A) ->
 %% TODO change size => to := when -type maps support is finalized
 | #{ size => non_neg_integer(),
 kill => boolean(),
- error_logger => boolean() }.
+ error_logger => boolean(),
+ include_shared_binaries => boolean() }.
 
 -type spawn_opt_option() ::
 	link
-- 
2.35.3

Places

File 5133-erts-Optionally-include-off-heap-binaries-into-max_h.patch of Package erlang (Revision ec256062c09e7bf85ace52340f7c6484)

Places