sasl: suspend processes concurrently during release upgrades

Add sys:multi_suspend/1,2 and use it in release_handler_1 to
send suspend requests in parallel instead of one at a time.

Author: v0idpwn

lib/sasl/src/release_handler_1.erl

@@ -483,27 +483,21 @@ get_opt(Tag, EvalState, Default) ->
 %% goes for processes that didn't respond to the suspend message.
 %%-----------------------------------------------------------------
 suspend(Mod, Procs, Timeout) ->
-    lists:zf(fun({_Sup, _Name, Pid, Mods}) -> 
-		     case lists:member(Mod, Mods) of
-			 true ->
-			     case catch sys_suspend(Pid, Timeout) of
-				 ok -> {true, Pid};
-				 _ -> 
-				     % If the proc hangs, make sure to
-				     % resume it when it gets suspended!
-				     catch sys:resume(Pid),
-				     false
-			     end;
-			 false ->
-			     false
-		     end
-	     end,
-	     Procs).
-
-sys_suspend(Pid, default) ->
-    sys:suspend(Pid);
-sys_suspend(Pid, Timeout) ->
-    sys:suspend(Pid, Timeout).
+    Pids = [Pid || {_Sup, _Name, Pid, Mods} <- Procs,
+                   lists:member(Mod, Mods)],
+    Results = case Timeout of
+                  default -> sys:multi_suspend(Pids);
+                  _       -> sys:multi_suspend(Pids, Timeout)
+              end,
+    lists:filtermap(
+      fun({Pid, ok}) ->
+              {true, Pid};
+         ({Pid, _Error}) ->
+              % If the proc hangs, make sure to
+              % resume it when it gets suspended!
+              catch sys:resume(Pid),
+              false
+      end, Results).
 
 resume(Pids) ->
     lists:foreach(fun(Pid) -> catch sys:resume(Pid) end, Pids).

lib/stdlib/src/sys.erl

@@ -80,6 +80,7 @@ the process itself to format these events.
 
 %% External exports
 -export([suspend/1, suspend/2, resume/1, resume/2,
+	 multi_suspend/1, multi_suspend/2,
 	 get_status/1, get_status/2,
 	 get_state/1, get_state/2,
 	 replace_state/2, replace_state/3,
@@ -284,6 +285,29 @@ system messages, but not other messages.
       Timeout :: timeout().
 suspend(Name, Timeout) -> send_system_msg(Name, suspend, Timeout).
 
+-doc(#{equiv => multi_suspend(Names, 5000)}).
+-spec multi_suspend(Names) -> [{Name, Result}] when
+      Names :: [name()],
+      Name :: name(),
+      Result :: 'ok' | {'error', term()}.
+multi_suspend(Names) -> multi_suspend(Names, 5000).
+
+-doc """
+Suspends multiple processes concurrently.
+
+Sends suspend requests to all processes in `Names` simultaneously and
+collects the results. Returns a list of `{Name, Result}` tuples in
+the same order as `Names`, where `Result` is `ok` on success or
+`{error, Reason}` on failure.
+""".
+-spec multi_suspend(Names, Timeout) -> [{Name, Result}] when
+      Names :: [name()],
+      Name :: name(),
+      Timeout :: timeout(),
+      Result :: 'ok' | {'error', term()}.
+multi_suspend(Names, Timeout) ->
+    send_multi_system_msg(Names, suspend, Timeout).
+
 -doc(#{equiv => resume(Name, 5000)}).
 -spec resume(Name) -> 'ok' when
       Name :: name().
@@ -763,6 +787,31 @@ send_system_msg(Name, Request, Timeout) ->
             exit({Reason, mfa(Name, Request, Timeout)})
     end.
 
+send_multi_system_msg(Names, Request, Timeout) ->
+    ReqIdCol = lists:foldl(
+                 fun(Name, Acc) ->
+                         gen:send_request(Name, system, Request, Name, Acc)
+                 end, gen:reqids_new(), Names),
+    ResultMap = collect_multi_responses(ReqIdCol, Timeout, #{}),
+    [{Name, maps:get(Name, ResultMap)} || Name <- Names].
+
+collect_multi_responses(ReqIdCol, Timeout, Acc) ->
+    case gen:wait_response(ReqIdCol, Timeout, true) of
+        {{reply, Reply}, Name, NewReqIdCol} ->
+            collect_multi_responses(NewReqIdCol, Timeout,
+                                    Acc#{Name => Reply});
+        {{error, {Reason, _Ref}}, Name, NewReqIdCol} ->
+            collect_multi_responses(NewReqIdCol, Timeout,
+                                    Acc#{Name => {error, Reason}});
+        timeout ->
+            Remaining = gen:reqids_to_list(ReqIdCol),
+            lists:foldl(
+              fun({_ReqId, Name}, A) -> A#{Name => {error, timeout}} end,
+              Acc, Remaining);
+        no_request ->
+            Acc
+    end.
+
 mfa(Name, {debug, {Func, Arg2}}) ->
     {sys, Func, [Name, Arg2]};
 mfa(Name, {change_code, Mod, Vsn, Extra}) ->