File 2892-Improve-response-handling-for-asynchronous... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 2892-Improve-response-handling-for-asynchronous-erpc-requ.patch of Package erlang (Revision f4c798e4a89b3576e3438788d38e337f)

Currently displaying revision f4c798e4a89b3576e3438788d38e337f , Show latest

From cb67a70aca04319e83e91b1459ddb2042e49c979 Mon Sep 17 00:00:00 2001
From: Rickard Green <rickard@erlang.org>
Date: Sat, 19 Mar 2022 23:38:52 +0100
Subject: [PATCH 2/2] Improve response handling for asynchronous 'erpc'
 requests

receive_response/3, wait_response/3, and check_response/3 in 'erpc'
can now take a collection of request identifiers as argument and handle
any responses corresponding a request identifier in the collection.
---
 lib/kernel/doc/src/erpc.xml    | 701 +++++++++++++++++++++++++++------
 lib/kernel/src/erpc.erl        | 347 ++++++++++++++--
 lib/kernel/test/erpc_SUITE.erl | 332 +++++++++++++++-
 3 files changed, 1222 insertions(+), 158 deletions(-)

diff --git a/lib/kernel/doc/src/erpc.xml b/lib/kernel/doc/src/erpc.xml
index 26d1ec4aad..ecb3949eb9 100644
--- a/lib/kernel/doc/src/erpc.xml
+++ b/lib/kernel/doc/src/erpc.xml
@@ -64,12 +64,55 @@
 <name name="request_id"/>
 <desc>
 
-	 An opaque type of call request identifiers. For more
-	 information see
+	 An opaque request identifier. For more information see
 <seemfa marker="#send_request/4"><c>send_request/4</c></seemfa>.
 	
 </desc>
 </datatype>
+ <datatype>
+ <name name="request_id_collection"/>
+ <desc>
+ 
+	 An opaque collection of request identifiers
+ (<seetype marker="#request_id"><c>request_id()</c></seetype>)
+ where each request identifier can be associated with a label
+ chosen by the user. For more information see
+ <seemfa marker="#reqids_new/0"><c>reqids_new/0</c></seemfa>.
+	
+ </desc>
+ </datatype>
+ <datatype>
+ <name name="timeout_time"/>
+ <desc>
+ <taglist>
+ <tag><c>0..4294967295</c></tag>
+ <item>
+ Timeout relative to current time in milliseconds.
+ </item>
+ <tag><c>infinity</c></tag>
+ <item>
+ Infinite timeout. That is, the operation will never time out.
+ </item>
+ <tag><c>{abs, Timeout}</c></tag>
+ <item>
+ An absolute
+ <seemfa marker="erts:erlang#monotonic_time/1">Erlang monotonic time</seemfa>
+ timeout in milliseconds. That is, the operation will time out when
+ <seemfa marker="erts:erlang#monotonic_time/1"><c>erlang:monotonic_time(millisecond)</c></seemfa>
+ returns a value larger than or equal to <c>Timeout</c>. <c>Timeout</c>
+ is not allowed to identify a time further into the future than <c>4294967295</c>
+ milliseconds. Identifying the timeout using an absolute timeout value
+ is especially handy when you have a deadline for responses corresponding
+ to a complete collection of requests
+ (<seetype marker="#request_id_collection"><c>request_id_collection()</c></seetype>)
+,
+ since you do not have to recalculate the relative time until the deadline
+ over and over again.
+	 </item>
+ </taglist>
+ </desc>
+ </datatype>
+
 </datatypes>
 
 <funcs>
@@ -81,8 +124,9 @@
 <desc>
 	
 	 The same as calling
-	 <seemfa marker="#call/5"><c>erpc:call(<anno>Node</anno>,erlang,apply,[<anno>Fun</anno>,[]],<anno>Timeout</anno>)</c></seemfa>.
-	 May raise all the same exceptions as <c>erpc:call/5</c>
+	 <seemfa marker="#call/5"><c>erpc:call(<anno>Node</anno>,
+ erlang, apply, [<anno>Fun</anno>,[]], <anno>Timeout</anno>)</c></seemfa>.
+	 May raise all the same exceptions as <c>call/5</c>
 	 plus an <c>{erpc, badarg}</c> <c>error</c>
 	 exception if <c><anno>Fun</anno></c> is not a fun of
 	 zero arity.
@@ -104,9 +148,8 @@
 	 Evaluates <c>apply(<anno>Module</anno>, <anno>Function</anno>,
 <anno>Args</anno>)</c> on node <c><anno>Node</anno></c> and returns
 the corresponding value <c><anno>Result</anno></c>.
-	 <c><anno>Timeout</anno></c> is an integer representing
-	 the timeout in milliseconds or the atom <c>infinity</c>
-	 which prevents the operation from ever timing out.
+ <c><anno>Timeout</anno></c> sets an upper time limit
+ for the <c>call</c> operation to complete.
 	
 	The call <c>erpc:call(<anno>Node</anno>, <anno>Module</anno>,
 	<anno>Function</anno>, <anno>Args</anno>)</c> is equivalent
@@ -118,7 +161,7 @@
 	 exceptions, the operation did not time out, and no failures
 	 occurred. In all other cases an exception is raised. The
 	 following exceptions, listed by exception class, can
-	 currently be raised by <c>erpc:call()</c>:
+	 currently be raised by <c>call()</c>:
 	
 	<taglist>
 	 <tag><c>throw</c></tag>
@@ -158,7 +201,7 @@
 	 
 	 <tag><c>{exception, ErrorReason, StackTrace}</c></tag>
 	 <item>
-	 A runtime error occurred which raised and error
+	 A runtime error occurred which raised an error
 	 exception while applying the function,
 	 and the applied function did not catch the
 	 exception. The error reason <c>ErrorReason</c>
@@ -186,9 +229,8 @@
 		 <item><c><anno>Args</anno></c> is not a list.
 		 Note that the list is not verified to be
 		 a proper list at the client side.</item>
-		 <item><c><anno>Timeout</anno></c> is not the
-		 atom <c>infinity</c> or an integer in valid
-		 range.</item>
+		 <item><c><anno>Timeout</anno></c> is
+ invalid.</item>
 		</list>
 	 </item>
 	 
@@ -256,7 +298,7 @@
 	 The same as calling
 	 <seemfa marker="#cast/4"><c>erpc:cast(<anno>Node</anno>,erlang,apply,[<anno>Fun</anno>,[]])</c></seemfa>.
 	
-	<c>erpc:cast/2</c> fails with an <c>{erpc, badarg}</c>
+	<c>cast/2</c> fails with an <c>{erpc, badarg}</c>
 	<c>error</c> exception if:
 	<list>
 	 <item><c><anno>Node</anno></c> is not an atom.</item>
@@ -273,11 +315,11 @@
 	 Evaluates <c>apply(<anno>Module</anno>, <anno>Function</anno>,
 <anno>Args</anno>)</c> on node
 <c><anno>Node</anno></c>. No response is delivered to the
-	 calling process. <c>erpc:cast()</c> returns immediately
+	 calling process. <c>cast()</c> returns immediately
 	 after the cast request has been sent. Any failures beside
 	 bad arguments are silently ignored.
 	
-	<c>erpc:cast/4</c> fails with an <c>{erpc, badarg}</c>
+	<c>cast/4</c> fails with an <c>{erpc, badarg}</c>
 	<c>error</c> exception if:
 	<list>
 	 <item><c><anno>Node</anno></c> is not an atom.</item>
@@ -305,13 +347,13 @@
 	
 	 Check if a message is a response to a <c>call</c> request
 	 previously made by the calling process using
-	 <seemfa marker="#send_request/4"><c>erpc:send_request/4</c></seemfa>.
+	 <seemfa marker="#send_request/4"><c>send_request/4</c></seemfa>.
 	 <c><anno>RequestId</anno></c> should be the value returned
-	 from the previously made <c>erpc:send_request()</c> call,
+	 from the previously made <c>send_request/4</c> call,
 	 and the corresponding response should not already have been
-	 received and handled to completion by <c>erpc:check_response()</c>,
-	 <seemfa marker="#receive_response/2"><c>erpc:receive_response()</c></seemfa>, or
-	 <seemfa marker="#wait_response/2"><c>erpc:wait_response()</c></seemfa>.
+	 received and handled to completion by <c>check_response/2</c>,
+	 <seemfa marker="#receive_response/2"><c>receive_response/2</c></seemfa>, or
+	 <seemfa marker="#wait_response/2"><c>wait_response/2</c></seemfa>.
 	 <c><anno>Message</anno></c> is the message to check.
 	
 	
@@ -323,9 +365,9 @@
 	 corresponds to the value returned from the applied function
 	 or an exception is raised. The exceptions that can be raised
 	 corresponds to the same exceptions as can be raised by
-	 <seemfa marker="#call/4"><c>erpc:call/4</c></seemfa>.
+	 <seemfa marker="#call/4"><c>call/4</c></seemfa>.
 	 That is, no <c>{erpc, timeout}</c> <c>error</c> exception
-	 can be raised. <c>erpc:check_response()</c> will fail with
+	 can be raised. <c>check_response()</c> will fail with
 	 an <c>{erpc, badarg}</c> exception if/when an invalid
 	 <c><anno>RequestId</anno></c> is detected.
 	
@@ -340,6 +382,80 @@
 </desc>
 </func>
 
+ <func>
+ <name name="check_response" arity="3" since="OTP 25.0"/>
+ <fsummary>Check if a message is a response corresponding to a
+ previously sent call request.</fsummary>
+ <desc>
+ 
+	 Check if a message is a response to a <c>call</c> request corresponding
+ to a request identifier saved in <c><anno>RequestIdCollection</anno></c>.
+ All request identifiers of <c><anno>RequestIdCollection</anno></c> must
+ correspond to requests that have been made using
+	 <seemfa marker="#send_request/4"><c>send_request/4</c></seemfa> or
+	 <seemfa marker="#send_request/6"><c>send_request/6</c></seemfa>,
+ and all requests must have been made by the process calling this
+ function.
+	
+ 
+ <c><anno>Label</anno></c> is the label associated with the request
+ identifier of the request that the response corresponds to.
+ A request identifier is associated with a label when
+ <seemfa marker="#reqids_add/3">adding a request identifier</seemfa>
+ in a <seetype marker="#request_id_collection">request identifier
+ collection</seetype>, or when sending the request using
+ <seemfa marker="#send_request/6"><c>send_request/6</c></seemfa>.
+ 
+ 
+ Compared to
+ <seemfa marker="#check_response/2"><c>check_response/2</c></seemfa>,
+ the returned result associated with a specific request identifier
+ or an exception associated with a specific request identifier will
+ be wrapped in a 3-tuple. The first element of this tuple equals the
+ value that would have been produced by <c>check_response/2</c>,
+ the second element equals the <c><anno>Label</anno></c> associated
+ with the specific request identifier, and the third element
+ <c><anno>NewRequestIdCollection</anno></c> is a possibly modified
+ request identifier collection. The <c>error</c> exception <c>{erpc,
+ badarg}</c> is not associated with any specific request identifier,
+ and will hence not be wrapped.
+ 
+ 
+ If <c><anno>RequestIdCollection</anno></c> is empty, the atom
+ <c>no_request</c> will be returned. If <c><anno>Message</anno></c>
+ does not correspond to any of the request identifiers in
+ <c><anno>RequestIdCollection</anno></c>, the atom
+ <c>no_response</c> is returned.
+ 
+ 
+ If <c><anno>Delete</anno></c> equals <c>true</c>, the association
+ with <c><anno>Label</anno></c> will have been deleted from
+ <c><anno>RequestIdCollection</anno></c> in the resulting
+ <c><anno>NewRequestIdCollection</anno></c>. If
+ <c><anno>Delete</anno></c> equals <c>false</c>,
+ <c><anno>NewRequestIdCollection</anno></c> will equal
+ <c><anno>RequestIdCollection</anno></c>. Note that deleting an
+ association is not for free and that a collection containing
+ already handled requests can still be used by subsequent calls to
+ <c>check_response/3</c>,
+ 	 <seemfa marker="#receive_response/3"><c>receive_response/3</c></seemfa>,
+ and
+	 <seemfa marker="#wait_response/3"><c>wait_response/3</c></seemfa>.
+ However, without deleting handled associations, the above calls will
+ not be able to detect when there are no more outstanding requests to
+ handle, so you will have to keep track of this some other way than
+ relying on a <c>no_request</c> return. Note that if you pass a
+ collection only containing associations of already handled or
+ abandoned requests to <c>check_response/3</c>, it will always
+ return <c>no_response</c>.
+ 
+ 
+ Note that a response might have been consumed uppon an <c>{erpc,
+ badarg}</c> exception and if so, will be lost for ever.
+ 
+ </desc>
+ </func>
+
 <func>
 <name name="multicall" arity="2" since="OTP 23.0"/>
 <name name="multicall" arity="3" since="OTP 23.0"/>
@@ -347,8 +463,9 @@
 <desc>
 	
 	 The same as calling
-	 <seemfa marker="#multicall/5"><c>erpc:multicall(<anno>Nodes</anno>,erlang,apply,[<anno>Fun</anno>,[]],<anno>Timeout</anno>)</c></seemfa>.
-	 May raise all the same exceptions as <c>erpc:multicall/5</c>
+	 <seemfa marker="#multicall/5"><c>erpc:multicall(<anno>Nodes</anno>,
+ erlang, apply, [<anno>Fun</anno>,[]], <anno>Timeout</anno>)</c></seemfa>.
+	 May raise all the same exceptions as <c>multicall/5</c>
 	 plus an <c>{erpc, badarg}</c> <c>error</c>
 	 exception if <c><anno>Fun</anno></c> is not a fun of
 	 zero arity.
@@ -372,15 +489,13 @@
 	 Performs multiple <c>call</c> operations in parallel
 	 on multiple nodes. That is, evaluates
 	 <c>apply(<anno>Module</anno>, <anno>Function</anno>,
- <anno>Args</anno>)</c> on the nodes
-	 <c><anno>Nodes</anno></c> in parallel.
-	 <c><anno>Timeout</anno></c> is an integer representing
-	 the timeout in milliseconds or the atom <c>infinity</c>
-	 which prevents the operation from ever timing out.
-	 The result is returned as a list where
-	 the result from each node is placed at the same position
-	 as the node name is placed in <c><anno>Nodes</anno></c>.
-	 Each item in the resulting list is formatted as either:
+ <anno>Args</anno>)</c> on the nodes <c><anno>Nodes</anno></c>
+ in parallel. <c><anno>Timeout</anno></c> sets an upper time
+ limit for all <c>call</c> operations to complete. The result
+ is returned as a list where the result from each node is placed
+ at the same position as the node name is placed in
+ <c><anno>Nodes</anno></c>. Each item in the resulting list is
+ formatted as either:
 	
 	<taglist>
 	 <tag><c>{ok, Result}</c></tag>
@@ -394,11 +509,11 @@
 	 raised an exception of class <c>Class</c> with
 	 exception reason <c>ExceptionReason</c>. These
 	 correspond to the exceptions that
-	 <seemfa marker="#call/5"><c>erpc:call/5</c></seemfa>
+	 <seemfa marker="#call/5"><c>call/5</c></seemfa>
 	 can raise.
 	 </item>
 	</taglist>
-	<c>erpc:multicall/5</c> fails with an <c>{erpc, badarg}</c>
+	<c>multicall/5</c> fails with an <c>{erpc, badarg}</c>
 	<c>error</c> exception if:
 	<list>
 	 <item><c><anno>Nodes</anno></c> is not a proper list of
@@ -416,8 +531,12 @@
 	 to the call <c>erpc:multicall(<anno>Nodes</anno>, <anno>Module</anno>,
 	 <anno>Function</anno>, <anno>Args</anno>, infinity)</c>. These
 	 calls are also equivalent to calling <c>my_multicall(Nodes, Module,
-	 Function, Args)</c> if one disregard performance and failure
-	 behavior:
+	 Function, Args)</c> below if one disregard performance and failure
+	 behavior. <c>multicall()</c> can utilize a selective receive
+ optimization which removes the need to scan the message queue from
+ the beginning in order to find a matching message. The
+	 <c>send_request()/receive_response()</c> combination can,
+ however, not utilize this optimization.
 	
 	<pre>
 my_multicall(Nodes, Module, Function, Args) ->
@@ -436,12 +555,6 @@ my_multicall(Nodes, Module, Function, Args) ->
 ReqIds).
 </pre>
 
- 
-	 The <c><anno>Timeout</anno></c> value in milliseconds
-	 sets an upper time limit for all <c>call</c> operations
-	 to complete.
-	
-
 	
 	 If an <c>erpc</c> operation fails, but it is unknown if
 	 the function is/will be applied (that is, a timeout,
@@ -473,7 +586,7 @@ my_multicall(Nodes, Module, Function, Args) ->
 	 The same as calling
 	 <seemfa marker="#multicast/4"><c>erpc:multicast(<anno>Nodes</anno>,erlang,apply,[<anno>Fun</anno>,[]])</c></seemfa>.
 	
-	<c>erpc:multicast/2</c> fails with an <c>{erpc, badarg}</c>
+	<c>multicast/2</c> fails with an <c>{erpc, badarg}</c>
 	<c>error</c> exception if:
 	<list>
 	 <item><c><anno>Nodes</anno></c> is not a proper list of atoms.</item>
@@ -490,11 +603,11 @@ my_multicall(Nodes, Module, Function, Args) ->
 	 Evaluates <c>apply(<anno>Module</anno>, <anno>Function</anno>,
 <anno>Args</anno>)</c> on the nodes
 <c><anno>Nodes</anno></c>. No response is delivered to the
-	 calling process. <c>erpc:multicast()</c> returns immediately
+	 calling process. <c>multicast()</c> returns immediately
 	 after the cast requests have been sent. Any failures beside
 	 bad arguments are silently ignored.
 	
-	<c>erpc:multicast/4</c> fails with an <c>{erpc, badarg}</c>
+	<c>multicast/4</c> fails with an <c>{erpc, badarg}</c>
 	<c>error</c> exception if:
 	<list>
 	 <item><c><anno>Nodes</anno></c> is not a proper list of
@@ -515,9 +628,21 @@ my_multicall(Nodes, Module, Function, Args) ->
 	</note>
 </desc>
 </func>
- 
+
 <func>
 <name name="receive_response" arity="1" since="OTP 23.0"/>
+ <fsummary>Receive a call response corresponding to a
+ previously sent call request.</fsummary>
+ <desc>
+ 
+ The same as calling
+ <seemfa marker="#receive_response/2"><c>erpc:receive_response(<anno>RequestId</anno>,
+ infinity)</c></seemfa>.
+ 
+ </desc>
+ </func>
+
+ <func>
 <name name="receive_response" arity="2" since="OTP 23.0"/>
 <fsummary>Receive a call response corresponding to a
 previously sent call request.</fsummary>
@@ -525,34 +650,41 @@ my_multicall(Nodes, Module, Function, Args) ->
 	
 	 Receive a response to a <c>call</c> request previously
 	 made by the calling process using
-	 <seemfa marker="#send_request/4"><c>erpc:send_request/4</c></seemfa>.
+	 <seemfa marker="#send_request/4"><c>send_request/4</c></seemfa>.
 	 <c><anno>RequestId</anno></c> should be the value returned from
-	 the previously made <c>erpc:send_request()</c> call, and
+	 the previously made <c>send_request/4</c> call, and
 	 the corresponding response should not already have been received
-	 and handled to completion by
-	 <seemfa marker="#check_response/2"><c>erpc:check_response()</c></seemfa>,
-	 <c>erpc:receive_response()</c>, or
-	 <seemfa marker="#wait_response/2"><c>erpc:wait_response()</c></seemfa>.
-	 <c><anno>Timeout</anno></c> is an integer representing
-	 the timeout in milliseconds or the atom <c>infinity</c>
-	 which prevents the operation from ever timing out. The <c>call</c>
-	 operation is completed once the <c>erpc:receive_response()</c> call
-	 returns or raise an exception.
-	
-	
-	 The call <c>erpc:receive_response(<anno>RequestId</anno>)</c> is
-	 equivalent to the call
-	 <c>erpc:receive_response(<anno>RequestId</anno>, infinity)</c>.
+	 and handled to completion by <c>receive_response()</c>,
+	 <seemfa marker="#check_response/2"><c>check_response/4</c></seemfa>,
+ or
+	 <seemfa marker="#wait_response/2"><c>wait_response/4</c></seemfa>.
+ 
+ 
+ <c><anno>Timeout</anno></c> sets an upper time limit on how
+ long to wait for a response. If the operation times out, the request
+ identified by <c><anno>RequestId</anno></c> will be abandoned, then an
+ <c>{erpc, timeout}</c> <c>error</c> exception will be raised. That is,
+ no response corresponding to the request will ever be received after a
+ timeout. If a response is received, the <c>call</c> operation is
+ completed and either the result is returned or an exception is raised. The
+ exceptions that can be raised corresponds to the same exceptions as can
+ be raised by <seemfa marker="#call/5"><c>call/5</c></seemfa>.
+	 <c>receive_response/2</c> will fail with an <c>{erpc, badarg}</c>
+	 exception if/when an invalid <c><anno>RequestId</anno></c> is detected
+	 or if an invalid <c><anno>Timeout</anno></c> is passed.
 	
+
 	
 	 A call to the function
 	 <c>my_call(Node, Module, Function, Args, Timeout)</c>
 	 below is equivalent to the call
 	 <seemfa marker="#call/5"><c>erpc:call(Node, Module, Function, Args,
-	 Timeout)</c></seemfa> if one disregards performance. <c>erpc:call()</c>
-	 can utilize a message queue optimization which removes the need to scan
-	 the whole message queue which the combination
-	 <c>erpc:send_request()/erpc:receive_response()</c> cannot.
+	 Timeout)</c></seemfa> if one disregards performance. <c>call()</c>
+	 can utilize a selective receive optimization which removes
+ the need to scan the message queue from the beginning in
+ order to find a matching message. The
+	 <c>send_request()/receive_response()</c> combination can,
+ however, not utilize this optimization.
 	
 	<pre>
 my_call(Node, Module, Function, Args, Timeout) ->
@@ -568,15 +700,157 @@ my_call(Node, Module, Function, Args, Timeout) ->
 	 communicates with the calling process, such communication
 	 may, of course, reach the calling process.
 
-	
-	
-	 <c>erpc:receive_response()</c> will return or raise exceptions the
-	 same way as <seemfa marker="#call/5"><c>erpc:call/5</c></seemfa>
-	 does with the exception of <c>{erpc, badarg}</c>. An
-	 <c>{erpc, badarg}</c> exception will be raised if/when an invalid
-	 <c><anno>RequestId</anno></c> is detected or if an invalid
-	 <c><anno>Timeout</anno></c> is passed.
+ </desc>
+ </func>
+
+ <func>
+ <name name="receive_response" arity="3" since="OTP 25.0"/>
+ <fsummary>Receive a call response corresponding to a
+ previously sent call request.</fsummary>
+ <desc>
+ 
+	 Receive a response to a <c>call</c> request corresponding to a request
+ identifier saved in <c><anno>RequestIdCollection</anno></c>. All
+ request identifiers of <c><anno>RequestIdCollection</anno></c> must
+ correspond to requests that have been made using
+	 <seemfa marker="#send_request/4"><c>send_request/4</c></seemfa> or
+	 <seemfa marker="#send_request/6"><c>send_request/6</c></seemfa>,
+ and all requests must have been made by the process calling this
+ function.
 	
+ 
+ <c><anno>Label</anno></c> is the label associated with the request
+ identifier of the request that the response corresponds to.
+ A request identifier is associated with a label when
+ <seemfa marker="#reqids_add/3">adding a request identifier</seemfa>
+ in a <seetype marker="#request_id_collection">request identifier
+ collection</seetype>, or when sending the request using
+ <seemfa marker="#send_request/6"><c>send_request/6</c></seemfa>.
+ 
+ 
+ Compared to
+ <seemfa marker="#receive_response/2"><c>receive_response/2</c></seemfa>,
+ the returned result associated with a specific request identifier
+ or an exception associated with a specific request identifier will
+ be wrapped in a 3-tuple. The first element of this tuple equals the
+ value that would have been produced by <c>receive_response/2</c>,
+ the second element equals the <c><anno>Label</anno></c> associated
+ with the specific request identifier, and the third element
+ <c><anno>NewRequestIdCollection</anno></c> is a possibly modified
+ request identifier collection. The <c>error</c> exceptions <c>{erpc,
+ badarg}</c> and <c>{erpc, timeout}</c> are not associated with any
+ specific request identifiers, and will hence not be wrapped.
+ 
+ 
+ If <c><anno>RequestIdCollection</anno></c> is empty, the atom
+ <c>no_request</c> will be returned.
+ 
+ 
+ If the operation times out, all requests identified by
+ <c><anno>RequestIdCollection</anno></c> will be abandoned, then an
+ <c>{erpc, timeout}</c> <c>error</c> exception will be raised. That is,
+ no responses corresponding to any of the request identifiers in
+ <c><anno>RequestIdCollection</anno></c> will ever be received after a
+ timeout. The difference between <c>receive_response/3</c> and
+ <seemfa marker="#wait_response/3"><c>wait_response/3</c></seemfa>
+ is that <c>receive_response/3</c> abandons the requests at timeout
+ so that any potential future responses are ignored, while
+ <c>wait_response/3</c> does not.
+	
+ 
+ If <c><anno>Delete</anno></c> equals <c>true</c>, the association
+ with <c><anno>Label</anno></c> will have been deleted from
+ <c><anno>RequestIdCollection</anno></c> in the resulting
+ <c><anno>NewRequestIdCollection</anno></c>. If
+ <c><anno>Delete</anno></c> equals <c>false</c>,
+ <c><anno>NewRequestIdCollection</anno></c> will equal
+ <c><anno>RequestIdCollection</anno></c>. Note that deleting an
+ association is not for free and that a collection containing
+ already handled requests can still be used by subsequent calls to
+ <c>receive_response/3</c>,
+ 	 <seemfa marker="#check_response/3"><c>check_response/3</c></seemfa>,
+ and
+	 <seemfa marker="#wait_response/3"><c>wait_response/3</c></seemfa>.
+ However, without deleting handled associations, the above calls will
+ not be able to detect when there are no more outstanding requests to
+ handle, so you will have to keep track of this some other way than
+ relying on a <c>no_request</c> return. Note that if you pass a
+ collection only containing associations of already handled or
+ abandoned requests to <c>receive_response/3</c>, it will always block
+ until a timeout determined by <c><anno>Timeout</anno></c> is
+ triggered.
+ 
+ 
+ Note that a response might have been consumed uppon an <c>{erpc,
+ badarg}</c> exception and if so, will be lost for ever.
+ 
+ </desc>
+ </func>
+ 
+ <func>
+ <name name="reqids_add" arity="3" since="OTP 25.0"/>
+ <fsummary>Save a request identifier.</fsummary>
+ <desc>
+	
+ Saves <c><anno>RequestId</anno></c> and associates a
+ <c><anno>Label</anno></c> with the request identifier by adding this
+ information to <c><anno>RequestIdCollection</anno></c> and returning
+ the resulting request identifier collection.
+ 
+ </desc>
+ </func>
+
+ <func>
+ <name name="reqids_new" arity="0" since="OTP 25.0"/>
+ <fsummary>Create a new empty request identifier collection.</fsummary>
+ <desc>
+	
+ Returns a new empty request identifier collection. A 
+ request identifier collection can be utilized in order
+ the handle multiple outstanding requests.
+ 
+ 
+ Request identifiers of requests made by
+	 <seemfa marker="#send_request/4"><c>send_request/4</c></seemfa>
+ can be saved in a request identifier collection using 
+	 <seemfa marker="#reqids_add/3"><c>reqids_add/3</c></seemfa>.
+ Such a collection of request identifiers can later be used in
+ order to get one response corresponding to a request in the
+ collection by passing the collection as argument to
+ <seemfa marker="#check_response/3"><c>check_response/3</c></seemfa>,
+	 <seemfa marker="#receive_response/3"><c>receive_response/3</c></seemfa>,
+ and
+	 <seemfa marker="#wait_response/3"><c>wait_response/3</c></seemfa>.
+ 
+ 
+ <seemfa marker="#reqids_size/1"><c>reqids_size/1</c></seemfa>
+ can be used to determine the amount of request identifiers in a
+ request identifier collection.
+ 
+ </desc>
+ </func>
+
+ <func>
+ <name name="reqids_size" arity="1" since="OTP 25.0"/>
+ <fsummary>Get size of a request identifier collection.</fsummary>
+ <desc>
+	
+ Returns the amount of request identifiers saved in
+ <c><anno>RequestIdCollection</anno></c>.
+ 
+ </desc>
+ </func>
+
+ <func>
+ <name name="reqids_to_list" arity="1" since="OTP 25.0"/>
+ <fsummary>Get a list a request identifier/label associations in a collection.</fsummary>
+ <desc>
+	
+ Returns a list of <c>{<anno>RequestId</anno>, <anno>Label</anno>}</c>
+ tuples which corresponds to all request identifiers with their
+ associated labels present in the <c><anno>RequestIdCollection</anno></c>
+ collection.
+ 
 </desc>
 </func>
 
@@ -586,10 +860,10 @@ my_call(Node, Module, Function, Args, Timeout) ->
 <desc>
 	
 	 The same as calling
-	 <seemfa marker="#send_request/4"><c>erpc:send_request(<anno>Node</anno>,erlang,apply,[<anno>Fun</anno>,[]])</c></seemfa>.
+	 <seemfa marker="#send_request/4"><c>erpc:send_request(<anno>Node</anno>,
+ erlang, apply, [<anno>Fun</anno>, []])</c></seemfa>.
 	
-	<c>erpc:send_request/2</c> fails with an <c>{erpc, badarg}</c>
-	<c>error</c> exception if:
+	Fails with an <c>{erpc, badarg}</c> <c>error</c> exception if:
 	<list>
 	 <item><c><anno>Node</anno></c> is not an atom.</item>
 	 <item><c><anno>Fun</anno></c> is not a fun of
@@ -606,34 +880,158 @@ my_call(Node, Module, Function, Args, Timeout) ->
 </func>
 
 <func>
- <name name="send_request" arity="4" since="OTP 23.0"/>
+ <name name="send_request" arity="4" clause_i="1" since="OTP 23.0"/>
 <fsummary>Send a request to evaluate a function call on a node.</fsummary>
 <desc>
 	
 	 Send an asynchronous <c>call</c> request to the node
-	 <c><anno>Node</anno></c>. <c>erpc:send_request()</c>
+	 <c><anno>Node</anno></c>. <c>send_request/4</c>
 	 returns a request identifier that later is to be passed
-	 as argument to either
-	 <seemfa marker="#receive_response/1"><c>erpc:receive_response()</c></seemfa>,
-	 <seemfa marker="#wait_response/1"><c>erpc:wait_response()</c></seemfa>,
+	 to either
+	 <seemfa marker="#receive_response/2"><c>receive_response/2</c></seemfa>,
+	 <seemfa marker="#wait_response/2"><c>wait_response/2</c></seemfa>,
+	 or,
+	 <seemfa marker="#check_response/2"><c>check_response/2</c></seemfa>
+	 in order to get the response of the call request. Besides passing
+ the request identifier directly to these functions, it can also be
+ added in a request identifier collection using 
+	 <seemfa marker="#reqids_add/3"><c>reqids_add/3</c></seemfa>.
+ Such a collection of request identifiers can later be used in
+ order to get one response corresponding to a request in the
+ collection by passing the collection as argument to
+	 <seemfa marker="#receive_response/3"><c>receive_response/3</c></seemfa>,
+	 <seemfa marker="#wait_response/3"><c>wait_response/3</c></seemfa>,
 	 or,
-	 <seemfa marker="#check_response/2"><c>erpc:check_response()</c></seemfa>
-	 in order to get the response of the call request.
+	 <seemfa marker="#check_response/3"><c>check_response/3</c></seemfa>.
+ If you are about to save the request identifier in a request identifier
+ collection, you may want to consider using
+ <seemfa marker="#send_request/6"><c>send_request/6</c></seemfa>
+ instead.
+ 
+ 
+	 A call to the function
+	 <c>my_call(Node, Module, Function, Args, Timeout)</c>
+	 below is equivalent to the call
+	 <seemfa marker="#call/5"><c>erpc:call(Node, Module, Function, Args,
+	 Timeout)</c></seemfa> if one disregards performance. <c>call()</c>
+	 can utilize a selective receive optimization which removes
+ the need to scan the message queue from the beginning in
+ order to find a matching message. The
+	 <c>send_request()/receive_response()</c> combination can,
+ however, not utilize this optimization.
 	
-	<c>erpc:send_request()</c> fails with an <c>{erpc, badarg}</c>
-	<c>error</c> exception if:
+	<pre>
+my_call(Node, Module, Function, Args, Timeout) ->
+ RequestId = erpc:send_request(Node, Module, Function, Args),
+ <seemfa marker="#receive_response/2">erpc:receive_response(RequestId, Timeout)</seemfa>.
+</pre>
+	Fails with an <c>{erpc, badarg}</c> <c>error</c> exception if:
+	<list>
+	 <item><c><anno>Node</anno></c> is not an atom.</item>
+	 <item><c><anno>Module</anno></c> is not an atom.</item>
+	 <item><c><anno>Function</anno></c> is not an atom.</item>
+	 <item><c><anno>Args</anno></c> is not a list. Note that the
+	 list is not verified to be a proper list at the client side.</item>
+	</list>
+	<note>
+	 
+	 You cannot make any assumptions about the
+	 process that will perform the <c>apply()</c>. It may
+	 be a server, or a freshly spawned process.
+	 
+	</note>
+ </desc>
+ </func>
+
+ <func>
+ <name name="send_request" arity="4" clause_i="2" since="OTP 25.0"/>
+ <fsummary>Send a request to evaluate a function call on a node.</fsummary>
+ <desc>
+	
+	 The same as calling
+	 <seemfa marker="#send_request/6"><c>erpc:send_request(<anno>Node</anno>,
+ erlang, apply, [<anno>Fun</anno>,[]]), <anno>Label</anno>,
+ <anno>RequestIdCollection</anno>)</c></seemfa>.
+	
+	Fails with an <c>{erpc, badarg}</c> <c>error</c> exception if:
+	<list>
+	 <item><c><anno>Node</anno></c> is not an atom.</item>
+	 <item><c><anno>Fun</anno></c> is not a fun of zero arity.</item>
+	 <item><c><anno>RequestIdCollection</anno></c> is detected not to
+ be request identifier collection.</item>
+	</list>
+	<note>
+	 
+	 You cannot make any assumptions about the
+	 process that will perform the <c>apply()</c>. It may
+	 be a server, or a freshly spawned process.
+	 
+	</note>
+ </desc>
+ </func>
+
+ <func>
+ <name name="send_request" arity="6" since="OTP 25.0"/>
+ <fsummary>Send a request to evaluate a function call on a node.</fsummary>
+ <desc>
+	
+	 Send an asynchronous <c>call</c> request to the node
+	 <c><anno>Node</anno></c>. The <c><anno>Label</anno></c> will be
+ associated with the request identifier of the operation and
+ added to the returned request identifier collection
+ <c><anno>NewRequestIdCollection</anno></c>. The collection can
+ later be used in order to get one response corresponding to a
+ request in the collection by passing the collection as argument to
+	 <seemfa marker="#receive_response/3"><c>receive_response/3</c></seemfa>,
+	 <seemfa marker="#wait_response/3"><c>wait_response/3</c></seemfa>,
+	 or,
+	 <seemfa marker="#check_response/3"><c>check_response/3</c></seemfa>.
+ 
+
+ 
+ The same as calling
+ <seemfa marker="#reqids_add/3"><c>erpc:reqids_add</c></seemfa>(<seemfa
+ marker="#send_request/4"><c>erpc:send_request</c></seemfa><c>(<anno>Node</anno>,
+ <anno>Module</anno>, <anno>Function</anno>, <anno>Args</anno>),
+ <anno>Label</anno>, <anno>RequestIdCollection</anno>)</c>, but
+ calling <c>send_request/6</c> is slightly more efficient.
+ 
+
+	Fails with an <c>{erpc, badarg}</c> <c>error</c> exception if:
 	<list>
 	 <item><c><anno>Node</anno></c> is not an atom.</item>
 	 <item><c><anno>Module</anno></c> is not an atom.</item>
 	 <item><c><anno>Function</anno></c> is not an atom.</item>
 	 <item><c><anno>Args</anno></c> is not a list. Note that the
 	 list is not verified to be a proper list at the client side.</item>
+	 <item><c><anno>RequestIdCollection</anno></c> is detected not to
+ be request identifier collection.</item>
 	</list>
+	<note>
+	 
+	 You cannot make any assumptions about the
+	 process that will perform the <c>apply()</c>. It may
+	 be a server, or a freshly spawned process.
+	 
+	</note>
+ </desc>
+ </func>
+
+ <func>
+ <name name="wait_response" arity="1" clause_i="1" since="OTP 23.0"/>
+ <fsummary>Poll for a call response corresponding to a previously
+ sent call request.</fsummary>
+ <desc>
+ 
+ The same as calling
+ <seemfa marker="#wait_response/2"><c>erpc:wait_response(<anno>RequestId</anno>,
+ 0)</c></seemfa>. That is, poll for a response message to a <c>call</c>
+ request previously made by the calling process.
+ 
 </desc>
 </func>
 
 <func>
- <name name="wait_response" arity="1" since="OTP 23.0"/>
 <name name="wait_response" arity="2" since="OTP 23.0"/>
 <fsummary>Wait or poll for a call response corresponding to a previously
 sent call request.</fsummary>
@@ -641,40 +1039,30 @@ my_call(Node, Module, Function, Args, Timeout) ->
 	
 	 Wait or poll for a response message to a <c>call</c> request
 	 previously made by the calling process using
-	 <seemfa marker="#send_request/4"><c>erpc:send_request/4</c></seemfa>.
+	 <seemfa marker="#send_request/4"><c>send_request/4</c></seemfa>.
 	 <c><anno>RequestId</anno></c> should be the value returned from
-	 the previously made <c>erpc:send_request()</c> call, and the
+	 the previously made <c>send_request()</c> call, and the
 	 corresponding response should not already have been received and handled
 	 to completion by
-	 <seemfa marker="#check_response/2"><c>erpc:check_response()</c></seemfa>,
-	 <seemfa marker="#receive_response/2"><c>erpc:receive_response()</c></seemfa>,
-	 or <c>erpc:wait_response()</c>. <c><anno>WaitTime</anno></c> equals the
-	 time to wait in milliseconds (or the atom <c>infinity</c>) during the wait.
-	 <c><anno>WaitTime</anno></c> is an integer representing time to wait
-	 in milliseconds or the atom <c>infinity</c> which will cause
-	 <c>wait_response/2</c> to wait for a response until it appears
-	 regardless of how long time that is.
+	 <seemfa marker="#check_response/2"><c>check_response/2</c></seemfa>,
+	 <seemfa marker="#receive_response/2"><c>receive_response/2</c></seemfa>,
+	 or <c>wait_response()</c>.
 	
 	
-	 The call <c>erpc:wait_response(<anno>RequestId</anno>)</c> is equivalent
-	 to the call <c>erpc:wait_response(<anno>RequestId</anno>, 0)</c>. That is,
-	 poll for a response message to a <c>call</c> request previously made by
-	 the calling process.
-	
-	
-	 If no response is received before <c><anno>WaitTime</anno></c> milliseconds,
-	 the atom <c>no_response</c> is returned. It is valid to continue waiting
-	 for a response as many times as needed up until a response has
-	 been received and completed by <c>erpc:check_response()</c>,
-	 <c>erpc:receive_response()</c>, or <c>erpc:wait_response()</c>. If a
-	 response is received, the <c>call</c> operation is completed and either
-	 the result is returned as <c>{response, Result}</c> where <c>Result</c>
-	 corresponds to the value returned from the applied function or an
-	 exception is raised. The exceptions that can be raised corresponds to the
-	 same exceptions as can be raised by
-	 <seemfa marker="#call/4"><c>erpc:call/4</c></seemfa>.
+ <c><anno>WaitTime</anno></c> sets an upper time limit on how long to wait
+ for a response. If no response is received before the
+ <c><anno>WaitTime</anno></c> timeout has triggered, the atom
+ <c>no_response</c> is returned. It is valid to continue waiting for a
+ response as many times as needed up until a response has been received
+ and completed by <c>check_response()</c>, <c>receive_response()</c>, or
+ <c>wait_response()</c>. If a response is received, the <c>call</c>
+ operation is completed and either the result is returned as
+ <c>{response, Result}</c> where <c>Result</c> corresponds to the value
+ returned from the applied function or an exception is raised. The
+ exceptions that can be raised corresponds to the same exceptions as can
+ be raised by <seemfa marker="#call/4"><c>call/4</c></seemfa>.
 	 That is, no <c>{erpc, timeout}</c> <c>error</c> exception can be raised.
-	 <c>erpc:wait_response()</c> will fail with an <c>{erpc, badarg}</c>
+	 <c>wait_response/2</c> will fail with an <c>{erpc, badarg}</c>
 	 exception if/when an invalid <c><anno>RequestId</anno></c> is detected
 	 or if an invalid <c><anno>WaitTime</anno></c> is passed.
 	
@@ -690,6 +1078,87 @@ my_call(Node, Module, Function, Args, Timeout) ->
 </desc>
 </func>
 
+ <func>
+ <name name="wait_response" arity="3" since="OTP 25.0"/>
+ <fsummary>Wait or poll for a call response corresponding to a previously
+ sent call request.</fsummary>
+ <desc>
+ 
+	 Wait or poll for a response to a <c>call</c> request corresponding
+ to a request identifier saved in <c><anno>RequestIdCollection</anno></c>. All
+ request identifiers of <c><anno>RequestIdCollection</anno></c> must
+ correspond to requests that have been made using
+	 <seemfa marker="#send_request/4"><c>send_request/4</c></seemfa> or
+	 <seemfa marker="#send_request/6"><c>send_request/6</c></seemfa>,
+ and all requests must have been made by the process calling this
+ function.
+	
+ 
+ <c><anno>Label</anno></c> is the label associated with the request
+ identifier of the request that the response corresponds to.
+ A request identifier is associated with a label when
+ <seemfa marker="#reqids_add/3">adding a request identifier</seemfa>
+ in a <seetype marker="#request_id_collection">request identifier
+ collection</seetype>, or when sending the request using
+ <seemfa marker="#send_request/6"><c>send_request/6</c></seemfa>.
+ 
+ 
+ Compared to
+ <seemfa marker="#wait_response/2"><c>wait_response/2</c></seemfa>,
+ the returned result associated with a specific request identifier
+ or an exception associated with a specific request identifier will
+ be wrapped in a 3-tuple. The first element of this tuple equals the
+ value that would have been produced by <c>wait_response/2</c>,
+ the second element equals the <c><anno>Label</anno></c> associated
+ with the specific request identifier, and the third element
+ <c><anno>NewRequestIdCollection</anno></c> is a possibly modified
+ request identifier collection. The <c>error</c> exception <c>{erpc,
+ badarg}</c> is not associated with any specific request identifier,
+ and will hence not be wrapped.
+ 
+ 
+ If <c><anno>RequestIdCollection</anno></c> is empty, <c>no_request</c>
+ will be returned. If no response is received before the
+ <c><anno>WaitTime</anno></c> timeout has triggered, the atom
+ <c>no_response</c> is returned. It is valid to continue waiting for a
+ response as many times as needed up until a response has been received
+ and completed by <c>check_response()</c>, <c>receive_response()</c>,
+ or <c>wait_response()</c>. The difference between
+ <seemfa marker="#receive_response/3"><c>receive_response/3</c></seemfa>
+	 and <c>wait_response/3</c> is that <c>receive_response/3</c>
+	 abandons requests at timeout so that any potential future
+	 responses are ignored, while <c>wait_response/3</c> does not.
+ 
+ 
+ If <c><anno>Delete</anno></c> equals <c>true</c>, the association
+ with <c><anno>Label</anno></c> will have been deleted from
+ <c><anno>RequestIdCollection</anno></c> in the resulting
+ <c><anno>NewRequestIdCollection</anno></c>. If
+ <c><anno>Delete</anno></c> equals <c>false</c>,
+ <c><anno>NewRequestIdCollection</anno></c> will equal
+ <c><anno>RequestIdCollection</anno></c>. Note that deleting an
+ association is not for free and that a collection containing
+ already handled requests can still be used by subsequent calls to
+ <c>wait_response/3</c>,
+ 	 <seemfa marker="#check_response/3"><c>check_response/3</c></seemfa>,
+ and
+	 <seemfa marker="#receive_response/3"><c>receive_response/3</c></seemfa>.
+ However, without deleting handled associations, the above calls will
+ not be able to detect when there are no more outstanding requests to
+ handle, so you will have to keep track of this some other way than
+ relying on a <c>no_request</c> return. Note that if you pass a
+ collection only containing associations of already handled or
+ abandoned requests to <c>wait_response/3</c>, it will always block
+ until a timeout determined by <c><anno>WaitTime</anno></c> is
+ triggered and then return <c>no_response</c>.
+ 
+ 
+ Note that a response might have been consumed uppon an <c>{erpc,
+ badarg}</c> exception and if so, will be lost for ever.
+ 
+ </desc>
+ </func>
+ 
 </funcs>
 </erlref>
 
diff --git a/lib/kernel/src/erpc.erl b/lib/kernel/src/erpc.erl
index c93b0f7ca8..be5d2b1942 100644
--- a/lib/kernel/src/erpc.erl
+++ b/lib/kernel/src/erpc.erl
@@ -32,19 +32,27 @@
 	 cast/4,
 send_request/2,
 send_request/4,
+ send_request/6,
 receive_response/1,
 receive_response/2,
+ receive_response/3,
 wait_response/1,
 wait_response/2,
+ wait_response/3,
 check_response/2,
+ check_response/3,
 multicall/2,
 multicall/3,
 multicall/4,
 	 multicall/5,
 multicast/2,
-	 multicast/4]).
+	 multicast/4,
+ reqids_new/0,
+ reqids_size/1,
+ reqids_add/3,
+ reqids_to_list/1]).
 
--export_type([request_id/0]).
+-export_type([request_id/0, request_id_collection/0, timeout_time/0]).
 
 %% Internal exports (also used by the 'rpc' module)
 
@@ -57,14 +65,15 @@
 
 %%------------------------------------------------------------------------
 
--compile({inline,[{result,4}]}). %% Nicer error stack trace...
+%% Nicer error stack trace...
+-compile({inline,[{result,4},{collection_result,6},{timeout_value,1}]}).
 
 -define(MAX_INT_TIMEOUT, 4294967295).
--define(TIMEOUT_TYPE, 0..?MAX_INT_TIMEOUT | 'infinity').
 -define(IS_VALID_TMO_INT(TI_), (is_integer(TI_)
 andalso (0 =< TI_)
 andalso (TI_ =< ?MAX_INT_TIMEOUT))).
--define(IS_VALID_TMO(T_), ((T_ == infinity) orelse ?IS_VALID_TMO_INT(T_))).
+
+-type timeout_time() :: 0..?MAX_INT_TIMEOUT | 'infinity' | {abs, integer()}.
 
 %%------------------------------------------------------------------------
 %% Exported API
@@ -81,7 +90,7 @@ call(N, Fun) ->
 -spec call(Node, Fun, Timeout) -> Result when
 Node :: node(),
 Fun :: function(),
- Timeout :: ?TIMEOUT_TYPE,
+ Timeout :: timeout_time(),
 Result :: term().
 
 call(N, Fun, Timeout) when is_function(Fun, 0) ->
@@ -106,7 +115,7 @@ call(N, M, F, A) ->
 Module :: atom(),
 Function :: atom(),
 Args :: [term()],
- Timeout :: ?TIMEOUT_TYPE,
+ Timeout :: timeout_time(),
 Result :: term().
 
 call(N, M, F, A, infinity) when node() =:= N, %% Optimize local call
@@ -131,8 +140,8 @@ call(N, M, F, A, infinity) when node() =:= N, %% Optimize local call
 call(N, M, F, A, T) when is_atom(N),
 is_atom(M),
 is_atom(F),
- is_list(A),
- ?IS_VALID_TMO(T) ->
+ is_list(A) ->
+ Timeout = timeout_value(T),
 Res = make_ref(),
 ReqId = spawn_request(N, ?MODULE, execute_call, [Res, M, F, A],
 [{reply, error_only}, monitor]),
@@ -141,7 +150,7 @@ call(N, M, F, A, T) when is_atom(N),
 result(spawn_reply, ReqId, Res, Reason);
 {'DOWN', ReqId, process, _Pid, Reason} ->
 result(down, ReqId, Res, Reason)
- after T ->
+ after Timeout ->
 result(timeout, ReqId, Res, undefined)
 end;
 call(_N, _M, _F, _A, _T) ->
@@ -149,24 +158,34 @@ call(_N, _M, _F, _A, _T) ->
 
 %% Asynchronous call
 
--opaque request_id() :: {reference(), reference()}.
+-opaque request_id() :: nonempty_improper_list(reference(), reference()).
+-opaque request_id_collection() :: #{ reference() => [reference() | term()] }.
 
 -spec send_request(Node, Fun) -> RequestId when
 Node :: node(),
 Fun :: function(),
 RequestId :: request_id().
 
-send_request(N, F) when is_function(F, 0) ->
+send_request(N, F) when is_atom(N), is_function(F, 0) ->
 send_request(N, erlang, apply, [F, []]);
 send_request(_N, _F) ->
 error({?MODULE, badarg}).
 
+-dialyzer({no_improper_lists, send_request/4}).
+
 -spec send_request(Node, Module, Function, Args) -> RequestId when
 Node :: node(),
 Module :: atom(),
 Function :: atom(),
 Args :: [term()],
- RequestId :: request_id().
+ RequestId :: request_id();
+ (Node, Fun, Label, RequestIdCollection) ->
+ NewRequestIdCollection when
+ Node :: node(),
+ Fun :: function(),
+ Label :: term(),
+ RequestIdCollection :: request_id_collection(),
+ NewRequestIdCollection :: request_id_collection().
 
 send_request(N, M, F, A) when is_atom(N),
 is_atom(M),
@@ -175,16 +194,43 @@ send_request(N, M, F, A) when is_atom(N),
 Res = make_ref(),
 ReqId = spawn_request(N, ?MODULE, execute_call, [Res, M, F, A],
 [{reply, error_only}, monitor]),
- {Res, ReqId};
-send_request(_N, _M, _F, _A) ->
+ [Res|ReqId];
+send_request(N, F, L, C) when is_atom(N), is_function(F, 0), is_map(C) ->
+ send_request(N, erlang, apply, [F, []], L, C);
+send_request(_, _, _, _) ->
+ error({?MODULE, badarg}).
+
+-dialyzer({no_improper_lists, send_request/6}).
+
+-spec send_request(Node, Module, Function, Args,
+ Label, RequestIdCollection) ->
+ NewRequestIdCollection when
+ Node :: node(),
+ Module :: atom(),
+ Function :: atom(),
+ Args :: [term()],
+ Label :: term(),
+ RequestIdCollection :: request_id_collection(),
+ NewRequestIdCollection :: request_id_collection().
+
+send_request(N, M, F, A, L, C) when is_atom(N),
+ is_atom(M),
+ is_atom(F),
+ is_list(A),
+ is_map(C) ->
+ Res = make_ref(),
+ ReqId = spawn_request(N, ?MODULE, execute_call, [Res, M, F, A],
+ [{reply, error_only}, monitor]),
+ maps:put(ReqId, [Res|L], C);
+send_request(_N, _M, _F, _A, _L, _C) ->
 error({?MODULE, badarg}).
 
 -spec receive_response(RequestId) -> Result when
 RequestId :: request_id(),
 Result :: term().
 
-receive_response({Res, ReqId} = RId) when is_reference(Res),
- is_reference(ReqId) ->
+receive_response([Res|ReqId] = RId) when is_reference(Res),
+ is_reference(ReqId) ->
 receive_response(RId, infinity);
 receive_response(_) ->
 error({?MODULE, badarg}).
@@ -193,53 +239,118 @@ receive_response(_) ->
 
 -spec receive_response(RequestId, Timeout) -> Result when
 RequestId :: request_id(),
- Timeout :: ?TIMEOUT_TYPE,
+ Timeout :: timeout_time(),
 Result :: term().
 
-receive_response({Res, ReqId}, Tmo) when is_reference(Res),
- is_reference(ReqId),
- ?IS_VALID_TMO(Tmo) ->
+receive_response([Res|ReqId], Tmo) when is_reference(Res),
+ is_reference(ReqId) ->
+ Timeout = timeout_value(Tmo),
 receive
 {spawn_reply, ReqId, error, Reason} ->
 result(spawn_reply, ReqId, Res, Reason);
 {'DOWN', ReqId, process, _Pid, Reason} ->
 result(down, ReqId, Res, Reason)
- after Tmo ->
+ after Timeout ->
 result(timeout, ReqId, Res, undefined)
 end;
 receive_response(_, _) ->
 error({?MODULE, badarg}).
 
--spec wait_response(RequestId) -> {'response', Result} | 'no_response' when
+-dialyzer([{nowarn_function, receive_response/3}, no_return]).
+
+-spec receive_response(RequestIdCollection, Timeout, Delete) ->
+ {Result, Label, NewRequestIdCollection} | 'no_request' when
+ RequestIdCollection :: request_id_collection(),
+ Timeout :: timeout_time(),
+ Delete :: boolean(),
+ Result :: term(),
+ Label :: term(),
+ NewRequestIdCollection :: request_id_collection().
+
+receive_response(ReqIdCol, WT, Del) when map_size(ReqIdCol) == 0,
+ is_boolean(Del) ->
+ _ = timeout_value(WT),
+ no_request;
+receive_response(ReqIdCol, Tmo, Del) when is_map(ReqIdCol),
+ is_boolean(Del) ->
+ Timeout = timeout_value(Tmo),
+ receive
+ {spawn_reply, ReqId, error, Reason}
+ when is_map_key(ReqId, ReqIdCol), is_reference(ReqId) ->
+ collection_result(spawn_reply, ReqId, Reason, ReqIdCol, false, Del);
+ {'DOWN', ReqId, process, _Pid, Reason}
+ when is_map_key(ReqId, ReqIdCol), is_reference(ReqId) ->
+ collection_result(down, ReqId, Reason, ReqIdCol, false, Del)
+ after Timeout ->
+ collection_result(timeout, ok, ok, ReqIdCol, false, Del)
+ end;
+receive_response(_, _, _) ->
+ error({?MODULE, badarg}).
+
+-spec wait_response(RequestId) ->
+ {'response', Result} | 'no_response' when
 RequestId :: request_id(),
 Result :: term().
 
-wait_response({Res, ReqId} = RId) when is_reference(Res),
- is_reference(ReqId) ->
- wait_response(RId, 0).
+wait_response([Res|ReqId] = RId) when is_reference(Res),
+ is_reference(ReqId) ->
+ wait_response(RId, 0);
+wait_response(_) ->
+ error({?MODULE, badarg}).
 
 -dialyzer([{nowarn_function, wait_response/2}, no_return]).
 
 -spec wait_response(RequestId, WaitTime) ->
 {'response', Result} | 'no_response' when
 RequestId :: request_id(),
- WaitTime :: ?TIMEOUT_TYPE,
+ WaitTime :: timeout_time(),
 Result :: term().
 
-wait_response({Res, ReqId}, WT) when is_reference(Res),
- is_reference(ReqId),
- ?IS_VALID_TMO(WT) ->
+wait_response([Res|ReqId], WT) when is_reference(Res),
+ is_reference(ReqId) ->
+ Timeout = timeout_value(WT),
 receive
 {spawn_reply, ReqId, error, Reason} ->
 result(spawn_reply, ReqId, Res, Reason);
 {'DOWN', ReqId, process, _Pid, Reason} ->
 {response, result(down, ReqId, Res, Reason)}
- after WT ->
+ after Timeout ->
 no_response
 end;
 wait_response(_, _) ->
 error({?MODULE, badarg}).
 
+-spec wait_response(RequestIdCollection, WaitTime, Delete) ->
+ {{'response', Result}, Label, NewRequestIdCollection} |
+ 'no_response' |
+ 'no_request' when
+ RequestIdCollection :: request_id_collection(),
+ WaitTime :: timeout_time(),
+ Delete :: boolean(),
+ Label :: term(),
+ NewRequestIdCollection :: request_id_collection(),
+ Result :: term().
+
+wait_response(ReqIdCol, WT, Del) when map_size(ReqIdCol) == 0,
+ is_boolean(Del) ->
+ _ = timeout_value(WT),
+ no_request;
+wait_response(ReqIdCol, WT, Del) when is_map(ReqIdCol),
+ is_boolean(Del) ->
+ Timeout = timeout_value(WT),
+ receive
+ {spawn_reply, ReqId, error, Reason}
+ when is_map_key(ReqId, ReqIdCol), is_reference(ReqId) ->
+ collection_result(spawn_reply, ReqId, Reason, ReqIdCol, true, Del);
+ {'DOWN', ReqId, process, _Pid, Reason}
+ when is_map_key(ReqId, ReqIdCol), is_reference(ReqId) ->
+ collection_result(down, ReqId, Reason, ReqIdCol, true, Del)
+ after Timeout ->
+ no_response
+ end;
+wait_response(_, _, _) ->
+ error({?MODULE, badarg}).
+
 -dialyzer([{nowarn_function, check_response/2}, no_return]).
 
 -spec check_response(Message, RequestId) ->
@@ -247,21 +358,106 @@ wait_response(_, _) ->
 Message :: term(),
 RequestId :: request_id(),
 Result :: term().
-
+ 
 check_response({spawn_reply, ReqId, error, Reason},
- {Res, ReqId}) when is_reference(Res),
- is_reference(ReqId) ->
+ [Res|ReqId]) when is_reference(Res),
+ is_reference(ReqId) ->
 result(spawn_reply, ReqId, Res, Reason);
 check_response({'DOWN', ReqId, process, _Pid, Reason},
- {Res, ReqId}) when is_reference(Res),
- is_reference(ReqId) ->
+ [Res|ReqId]) when is_reference(Res),
+ is_reference(ReqId) ->
 {response, result(down, ReqId, Res, Reason)};
-check_response(_Msg, {Res, ReqId}) when is_reference(Res),
- is_reference(ReqId) ->
+check_response(_Msg, [Res|ReqId]) when is_reference(Res),
+ is_reference(ReqId) ->
 no_response;
 check_response(_, _) ->
 error({?MODULE, badarg}).
 
+-spec check_response(Message, RequestIdCollection, Delete) ->
+ {{'response', Result}, Label, NewRequestIdCollection} |
+ 'no_response' |
+ 'no_request' when
+ Message :: term(),
+ RequestIdCollection :: request_id_collection(),
+ Delete :: boolean(),
+ Result :: term(),
+ Label :: term(),
+ NewRequestIdCollection :: request_id_collection().
+
+check_response(_Msg, ReqIdCol, Del) when map_size(ReqIdCol) == 0,
+ is_boolean(Del) ->
+ no_request;
+check_response({spawn_reply, ReqId, error, Reason},
+ ReqIdCol, Del) when is_reference(ReqId),
+ is_map_key(ReqId, ReqIdCol),
+ is_boolean(Del) ->
+ collection_result(spawn_reply, ReqId, Reason, ReqIdCol, true, Del);
+check_response({'DOWN', ReqId, process, _Pid, Reason},
+ ReqIdCol, Del) when is_reference(ReqId),
+ is_map_key(ReqId, ReqIdCol),
+ is_boolean(Del) ->
+ collection_result(down, ReqId, Reason, ReqIdCol, true, Del);
+check_response(_Msg, ReqIdCol, Del) when is_map(ReqIdCol),
+ is_boolean(Del) ->
+ no_response;
+check_response(_, _, _) ->
+ error({?MODULE, badarg}).
+
+-spec reqids_new() ->
+ NewRequestIdCollection::request_id_collection().
+
+reqids_new() ->
+ maps:new().
+
+-spec reqids_size(RequestIdCollection::request_id_collection()) ->
+ non_neg_integer().
+reqids_size(ReqIdCollection) ->
+ try
+ maps:size(ReqIdCollection)
+ catch
+ _:_ ->
+ error({?MODULE, badarg})
+ end.
+
+-dialyzer({no_improper_lists, reqids_add/3}).
+
+-spec reqids_add(RequestId::request_id(), Label::term(),
+ RequestIdCollection::request_id_collection()) ->
+ NewRequestIdCollection::request_id_collection().
+
+reqids_add([_|ReqId], _, ReqIdCollection) when is_reference(ReqId),
+ is_map_key(ReqId,
+ ReqIdCollection) ->
+ error({?MODULE, badarg});
+reqids_add([Res|ReqId], Label, ReqIdCollection) when is_reference(Res),
+ is_reference(ReqId),
+ is_map(ReqIdCollection) ->
+ maps:put(ReqId, [Res|Label], ReqIdCollection);
+reqids_add(_, _, _) ->
+ error({?MODULE, badarg}).
+
+-dialyzer({no_improper_lists, reqids_to_list/1}).
+
+-spec reqids_to_list(RequestIdCollection::request_id_collection()) ->
+ [{RequestId::request_id(), Label::term()}].
+
+reqids_to_list(ReqIdCollection) when is_map(ReqIdCollection) ->
+ try
+ maps:fold(fun (ReqId, [Res|Label], Acc) when is_reference(ReqId),
+ is_reference(Res) ->
+ [{[Res|ReqId], Label}|Acc];
+ (_, _, _) ->
+ throw(badarg)
+ end,
+ [],
+ ReqIdCollection)
+ catch
+ throw:badarg ->
+ error({?MODULE, badarg})
+ end;
+reqids_to_list(_) ->
+ error({?MODULE, badarg}).
+
 -type stack_item() ::
 {Module :: atom(),
 Function :: atom(),
@@ -288,7 +484,7 @@ multicall(Ns, Fun) ->
 -spec multicall(Nodes, Fun, Timeout) -> Result when
 Nodes :: [atom()],
 Fun :: function(),
- Timeout :: ?TIMEOUT_TYPE,
+ Timeout :: timeout_time(),
 Result :: term().
 
 multicall(Ns, Fun, Timeout) when is_function(Fun, 0) ->
@@ -311,7 +507,7 @@ multicall(Ns, M, F, A) ->
 Module :: atom(),
 Function :: atom(),
 Args :: [term()],
- Timeout :: ?TIMEOUT_TYPE,
+ Timeout :: timeout_time(),
 Result :: [{ok, ReturnValue :: term()} | caught_call_exception()].
 
 multicall(Ns, M, F, A, T) ->
@@ -320,7 +516,8 @@ multicall(Ns, M, F, A, T) ->
 true = is_atom(F),
 true = is_list(A),
 Tag = make_ref(),
- SendState = mcall_send_requests(Tag, Ns, M, F, A, T),
+ Timeout = timeout_value(T),
+ SendState = mcall_send_requests(Tag, Ns, M, F, A, Timeout),
 mcall_receive_replies(Tag, SendState)
 catch
 error:NotIErr when NotIErr /= internal_error ->
@@ -531,6 +728,74 @@ result(timeout, ReqId, Res, _Reason) ->
 end
 end.
 
+collection_result(timeout, _, _, ReqIdCollection, _, _) ->
+ Abandon = fun (ReqId, [Res|_Label]) when is_reference(ReqId),
+ is_reference(Res) ->
+ case call_abandon(ReqId) of
+ true ->
+ ok;
+ false ->
+ %% Spawn error or DOWN has arrived if
+ %% ReqId corresponds to an outstanding
+ %% request; fetch and drop it...
+ receive
+ {spawn_reply, ReqId, error, _} ->
+ ok;
+ {'DOWN', ReqId, process, _, _} ->
+ ok
+ after
+ 0 ->
+ ok %% Already handled...
+ end
+ end;
+ (_, _) ->
+ %% Invalid request id collection...
+ throw(badarg)
+ end,
+ try
+ maps:foreach(Abandon, ReqIdCollection)
+ catch
+ throw:badarg -> error({?MODULE, badarg})
+ end,
+ error({?MODULE, timeout});
+collection_result(Type, ReqId, ResultReason, ReqIdCol, WrapResponse, Delete) ->
+ ReqIdInfo = case Delete of
+ true -> maps:take(ReqId, ReqIdCol);
+ false -> {maps:get(ReqId, ReqIdCol), ReqIdCol}
+ end,
+ case ReqIdInfo of
+ {[Res|Label], NewReqIdCol} when is_reference(Res) ->
+ try
+ Result = result(Type, ReqId, Res, ResultReason),
+ Response = if WrapResponse -> {response, Result};
+ true -> Result
+ end,
+ {Response, Label, NewReqIdCol}
+ catch
+ Class:Reason ->
+ erlang:Class({Reason, Label, NewReqIdCol})
+ end;
+ _ ->
+ %% Invalid request id collection...
+ error({?MODULE, badarg})
+ end.
+
+timeout_value(infinity) ->
+ infinity;
+timeout_value(Timeout) when ?IS_VALID_TMO_INT(Timeout) ->
+ Timeout;
+timeout_value({abs, Timeout}) when is_integer(Timeout) ->
+ case Timeout - erlang:monotonic_time(millisecond) of
+ TMO when TMO < 0 ->
+ 0;
+ TMO when TMO > ?MAX_INT_TIMEOUT ->
+ error({?MODULE, badarg});
+ TMO ->
+ TMO
+ end;
+timeout_value(_) ->
+ error({?MODULE, badarg}).
+
 deadline(infinity) ->
 infinity;
 deadline(?MAX_INT_TIMEOUT) ->
diff --git a/lib/kernel/test/erpc_SUITE.erl b/lib/kernel/test/erpc_SUITE.erl
index 9d295eefef..265131b20c 100644
--- a/lib/kernel/test/erpc_SUITE.erl
+++ b/lib/kernel/test/erpc_SUITE.erl
@@ -29,6 +29,9 @@
 send_request_wait_reqtmo/1,
 send_request_check_reqtmo/1,
 send_request_against_old_node/1,
+ send_request_receive_reqid_collection/1,
+ send_request_wait_reqid_collection/1,
+ send_request_check_reqid_collection/1,
 multicall/1, multicall_reqtmo/1,
 multicall_recv_opt/1,
 multicall_recv_opt2/1,
@@ -56,7 +59,7 @@ suite() ->
 [{ct_hooks,[ts_install_cth]},
 {timetrap,{minutes,2}}].
 
-all() -> 
+all() ->
 [call,
 call_reqtmo,
 call_against_old_node,
@@ -69,6 +72,9 @@ all() ->
 send_request_wait_reqtmo,
 send_request_check_reqtmo,
 send_request_against_old_node,
+ send_request_receive_reqid_collection,
+ send_request_wait_reqid_collection,
+ send_request_check_reqid_collection,
 multicall,
 multicall_reqtmo,
 multicall_recv_opt,
@@ -937,6 +943,327 @@ send_request_against_ei_node(Config) when is_list(Config) ->
 	 {skipped, "No OTP 22 available"}
 end.
 
+send_request_receive_reqid_collection(Config) when is_list(Config) ->
+ {ok, _P, N} = ?CT_PEER(#{connection => 0}),
+ send_request_receive_reqid_collection_success(N),
+ send_request_receive_reqid_collection_timeout(N),
+ send_request_receive_reqid_collection_error(N),
+ ok.
+
+send_request_receive_reqid_collection_success(N) ->
+
+ ReqId0 = erpc:send_request(N, fun () -> 0 end),
+
+ ReqIdC0 = erpc:reqids_new(),
+
+ ReqId1 = erpc:send_request(N, fun () -> receive after 400 -> 400 end end),
+ ReqIdC1 = erpc:reqids_add(ReqId1, req1, ReqIdC0),
+ 1 = erpc:reqids_size(ReqIdC1),
+
+ ReqIdC2 = erpc:send_request(N, fun () -> receive after 1 -> 1 end end, req2, ReqIdC1),
+ 2 = erpc:reqids_size(ReqIdC2),
+
+ ReqIdC3 = erpc:send_request(N, fun () -> receive after 200 -> 200 end end, req3, ReqIdC2),
+ 3 = erpc:reqids_size(ReqIdC3),
+ 
+ {1, req2, ReqIdC4} = erpc:receive_response(ReqIdC3, infinity, true),
+ 2 = erpc:reqids_size(ReqIdC4),
+
+ {200, req3, ReqIdC5} = erpc:receive_response(ReqIdC4, 7654, true),
+ 1 = erpc:reqids_size(ReqIdC5),
+
+ {400, req1, ReqIdC6} = erpc:receive_response(ReqIdC5, 5000, true),
+ 0 = erpc:reqids_size(ReqIdC6),
+
+ no_request = erpc:receive_response(ReqIdC6, 5000, true),
+
+ 0 = erpc:receive_response(ReqId0),
+
+ ok.
+
+send_request_receive_reqid_collection_timeout(N) ->
+
+ ReqId0 = erpc:send_request(N, fun () -> 0 end),
+
+ ReqIdC0 = erpc:reqids_new(),
+
+ ReqId1 = erpc:send_request(N, fun () -> receive after 1000 -> 1000 end end),
+ ReqIdC1 = erpc:reqids_add(ReqId1, req1, ReqIdC0),
+
+ ReqIdC2 = erpc:send_request(N, fun () -> receive after 1 -> 1 end end, req2, ReqIdC1),
+
+ ReqId3 = erpc:send_request(N, fun () -> receive after 500 -> 500 end end),
+ ReqIdC3 = erpc:reqids_add(ReqId3, req3, ReqIdC2),
+
+ Deadline = erlang:monotonic_time(millisecond) + 100,
+ 
+ {1, req2, ReqIdC4} = erpc:receive_response(ReqIdC3, {abs, Deadline}, true),
+ 2 = erpc:reqids_size(ReqIdC4),
+
+ try not_valid = erpc:receive_response(ReqIdC4, {abs, Deadline}, true)
+ catch error:{erpc, timeout} -> ok
+ end,
+
+ Abandoned = lists:sort([{ReqId1, req1}, {ReqId3, req3}]),
+ Abandoned = lists:sort(erpc:reqids_to_list(ReqIdC4)),
+
+ %% Make sure requests were abandoned...
+ try not_valid = erpc:receive_response(ReqIdC4, {abs, Deadline+1000}, false)
+ catch error:{erpc, timeout} -> ok
+ end,
+
+ 0 = erpc:receive_response(ReqId0, infinity),
+
+ ok.
+ 
+send_request_receive_reqid_collection_error(N) ->
+
+ ReqId0 = erpc:send_request(N, fun () -> 0 end),
+
+ ReqIdC0 = erpc:reqids_new(),
+
+ ReqId1 = erpc:send_request(N, fun () -> receive after 600 -> 600 end end),
+ ReqIdC1 = erpc:reqids_add(ReqId1, req1, ReqIdC0),
+ try
+ nope = erpc:reqids_add(ReqId1, req2, ReqIdC1)
+ catch
+ error:{erpc, badarg} -> ok
+ end,
+
+ ReqIdC2 = erpc:send_request(N, fun () -> receive after 800 -> erlang:halt() end end, req2, ReqIdC1),
+ ReqIdC3 = erpc:send_request(N, fun () -> receive after 200 -> error(errored) end end, req3, ReqIdC2),
+ ReqIdC4 = erpc:send_request(N, fun () -> exit(exited) end, req4, ReqIdC3),
+ ReqIdC5 = erpc:send_request(N, fun () -> receive after 400 -> throw(thrown) end end, req5, ReqIdC4),
+
+ 5 = erpc:reqids_size(ReqIdC5),
+
+ ReqIdC6 = try not_valid = erpc:receive_response(ReqIdC5, infinity, true)
+ catch exit:{{exception, exited}, req4, RIC6} -> RIC6
+ end,
+
+ 4 = erpc:reqids_size(ReqIdC6),
+
+ try not_valid = erpc:receive_response(ReqIdC6, 2000, false)
+ catch error:{{exception, errored, _Stk}, req3, _} -> ok
+ end,
+
+ try not_valid = erpc:receive_response(ReqIdC6, infinity, false)
+ catch throw:{thrown, req5, _} -> ok
+ end,
+ 
+ {600, req1, ReqIdC6} = erpc:receive_response(ReqIdC6, infinity, false),
+
+ try not_valid = erpc:receive_response(ReqIdC6, 5000, false)
+ catch error:{{erpc, noconnection}, req2, ReqIdC6} -> ok
+ end,
+
+ 0 = erpc:receive_response(ReqId0),
+
+ ok.
+
+send_request_wait_reqid_collection(Config) when is_list(Config) ->
+ {ok, _P, N} = ?CT_PEER(#{connection => 0}),
+ send_request_wait_reqid_collection_success(N),
+ send_request_wait_reqid_collection_timeout(N),
+ send_request_wait_reqid_collection_error(N),
+ ok.
+
+send_request_wait_reqid_collection_success(N) ->
+
+ ReqId0 = erpc:send_request(N, fun () -> 0 end),
+
+ ReqIdC0 = erpc:reqids_new(),
+
+ ReqId1 = erpc:send_request(N, fun () -> receive after 400 -> 400 end end),
+ ReqIdC1 = erpc:reqids_add(ReqId1, req1, ReqIdC0),
+ 1 = erpc:reqids_size(ReqIdC1),
+
+ ReqIdC2 = erpc:send_request(N, fun () -> receive after 1 -> 1 end end, req2, ReqIdC1),
+ 2 = erpc:reqids_size(ReqIdC2),
+
+ ReqIdC3 = erpc:send_request(N, fun () -> receive after 200 -> 200 end end, req3, ReqIdC2),
+ 3 = erpc:reqids_size(ReqIdC3),
+ 
+ {{response, 1}, req2, ReqIdC4} = erpc:wait_response(ReqIdC3, infinity, true),
+ 2 = erpc:reqids_size(ReqIdC4),
+
+ {{response, 200}, req3, ReqIdC5} = erpc:wait_response(ReqIdC4, 7654, true),
+ 1 = erpc:reqids_size(ReqIdC5),
+
+ {{response, 400}, req1, ReqIdC6} = erpc:wait_response(ReqIdC5, 5000, true),
+ 0 = erpc:reqids_size(ReqIdC6),
+
+ no_request = erpc:wait_response(ReqIdC6, 5000, true),
+
+ {response, 0} = erpc:wait_response(ReqId0),
+
+ ok.
+
+send_request_wait_reqid_collection_timeout(N) ->
+
+ ReqId0 = erpc:send_request(N, fun () -> 0 end),
+
+ ReqIdC0 = erpc:reqids_new(),
+
+ ReqIdC0 = erpc:reqids_new(),
+
+ ReqId1 = erpc:send_request(N, fun () -> receive after 1000 -> 1000 end end),
+ ReqIdC1 = erpc:reqids_add(ReqId1, req1, ReqIdC0),
+
+ ReqIdC2 = erpc:send_request(N, fun () -> receive after 1 -> 1 end end, req2, ReqIdC1),
+
+ ReqId3 = erpc:send_request(N, fun () -> receive after 500 -> 500 end end),
+ ReqIdC3 = erpc:reqids_add(ReqId3, req3, ReqIdC2),
+
+ Deadline = erlang:monotonic_time(millisecond) + 100,
+ 
+ {{response, 1}, req2, ReqIdC4} = erpc:wait_response(ReqIdC3, {abs, Deadline}, true),
+ 2 = erpc:reqids_size(ReqIdC4),
+
+ no_response = erpc:wait_response(ReqIdC4, {abs, Deadline}, true),
+
+ Unhandled = lists:sort([{ReqId1, req1}, {ReqId3, req3}]),
+ Unhandled = lists:sort(erpc:reqids_to_list(ReqIdC4)),
+
+ %% Make sure requests were not abandoned...
+ {{response, 500}, req3, ReqIdC4} = erpc:wait_response(ReqIdC4, {abs, Deadline+1500}, false),
+ {{response, 1000}, req1, ReqIdC4} = erpc:wait_response(ReqIdC4, {abs, Deadline+1500}, false),
+
+ {response, 0} = erpc:wait_response(ReqId0, infinity),
+
+ ok.
+ 
+send_request_wait_reqid_collection_error(N) ->
+
+ ReqId0 = erpc:send_request(N, fun () -> 0 end),
+
+ ReqIdC0 = erpc:reqids_new(),
+
+ ReqId1 = erpc:send_request(N, fun () -> receive after 600 -> 600 end end),
+ ReqIdC1 = erpc:reqids_add(ReqId1, req1, ReqIdC0),
+ try
+ nope = erpc:reqids_add(ReqId1, req2, ReqIdC1)
+ catch
+ error:{erpc, badarg} -> ok
+ end,
+
+ ReqIdC2 = erpc:send_request(N, fun () -> receive after 800 -> erlang:halt() end end, req2, ReqIdC1),
+ ReqIdC3 = erpc:send_request(N, fun () -> receive after 200 -> error(errored) end end, req3, ReqIdC2),
+ ReqIdC4 = erpc:send_request(N, fun () -> exit(exited) end, req4, ReqIdC3),
+ ReqIdC5 = erpc:send_request(N, fun () -> receive after 400 -> throw(thrown) end end, req5, ReqIdC4),
+
+ 5 = erpc:reqids_size(ReqIdC5),
+
+ ReqIdC6 = try not_valid = erpc:wait_response(ReqIdC5, infinity, true)
+ catch exit:{{exception, exited}, req4, RIC6} -> RIC6
+ end,
+
+ 4 = erpc:reqids_size(ReqIdC6),
+
+ try not_valid = erpc:wait_response(ReqIdC6, 2000, false)
+ catch error:{{exception, errored, _Stk}, req3, _} -> ok
+ end,
+
+ try not_valid = erpc:wait_response(ReqIdC6, infinity, false)
+ catch throw:{thrown, req5, _} -> ok
+ end,
+ 
+ {{response, 600}, req1, ReqIdC6} = erpc:wait_response(ReqIdC6, infinity, false),
+
+ try not_valid = erpc:wait_response(ReqIdC6, 5000, false)
+ catch error:{{erpc, noconnection}, req2, ReqIdC6} -> ok
+ end,
+
+ {response, 0} = erpc:wait_response(ReqId0),
+
+ ok.
+
+send_request_check_reqid_collection(Config) when is_list(Config) ->
+ {ok, _P, N} = ?CT_PEER(#{connection => 0}),
+ send_request_check_reqid_collection_success(N),
+ send_request_check_reqid_collection_error(N),
+ ok.
+
+send_request_check_reqid_collection_success(N) ->
+
+ ReqId0 = erpc:send_request(N, fun () -> 0 end),
+
+ ReqIdC0 = erpc:reqids_new(),
+
+ ReqIdC1 = erpc:send_request(N, fun () -> receive after 600 -> 600 end end, req1, ReqIdC0),
+ 1 = erpc:reqids_size(ReqIdC1),
+
+ ReqId2 = erpc:send_request(N, fun () -> receive after 200 -> 200 end end),
+ ReqIdC2 = erpc:reqids_add(ReqId2, req2, ReqIdC1),
+ 2 = erpc:reqids_size(ReqIdC2),
+
+ ReqIdC3 = erpc:send_request(N, fun () -> receive after 400 -> 400 end end, req3, ReqIdC2),
+ 3 = erpc:reqids_size(ReqIdC3),
+
+ Msg0 = next_msg(),
+
+ no_response = erpc:check_response(Msg0, ReqIdC3, true),
+ 
+ {{response, 200}, req2, ReqIdC4} = erpc:check_response(next_msg(), ReqIdC3, true),
+ 2 = erpc:reqids_size(ReqIdC4),
+
+ {{response, 400}, req3, ReqIdC5} = erpc:check_response(next_msg(), ReqIdC4, true),
+ 1 = erpc:reqids_size(ReqIdC5),
+
+ {{response, 600}, req1, ReqIdC6} = erpc:check_response(next_msg(), ReqIdC5, true),
+ 0 = erpc:reqids_size(ReqIdC6),
+
+ no_request = erpc:check_response(Msg0, ReqIdC6, true),
+
+ {response, 0} = erpc:check_response(Msg0, ReqId0),
+
+ ok.
+ 
+send_request_check_reqid_collection_error(N) ->
+
+ ReqId0 = erpc:send_request(N, fun () -> 0 end),
+
+ ReqIdC0 = erpc:reqids_new(),
+
+ ReqId1 = erpc:send_request(N, fun () -> receive after 600 -> 600 end end),
+ ReqIdC1 = erpc:reqids_add(ReqId1, req1, ReqIdC0),
+
+ ReqIdC2 = erpc:send_request(N, fun () -> receive after 800 -> erlang:halt() end end, req2, ReqIdC1),
+
+ ReqIdC3 = erpc:send_request(N, fun () -> receive after 200 -> error(errored) end end, req3, ReqIdC2),
+
+ ReqIdC4 = erpc:send_request(N, fun () -> exit(exited) end, req4, ReqIdC3),
+
+ ReqIdC5 = erpc:send_request(N, fun () -> receive after 400 -> throw(thrown) end end, req5, ReqIdC4),
+
+ 5 = erpc:reqids_size(ReqIdC5),
+
+ Msg0 = next_msg(),
+
+ no_response = erpc:check_response(Msg0, ReqIdC5, true),
+
+ ReqIdC6 = try not_valid = erpc:check_response(next_msg(), ReqIdC5, true)
+ catch exit:{{exception, exited}, req4, RIC6} -> RIC6
+ end,
+ 
+ try not_valid = erpc:check_response(next_msg(), ReqIdC6, false)
+ catch error:{{exception, errored, _Stk}, req3, ReqIdC6} -> ok
+ end,
+
+ try not_valid = erpc:check_response(next_msg(), ReqIdC6, false)
+ catch throw:{thrown, req5, ReqIdC6} -> ok
+ end,
+ 
+ {{response, 600}, req1, ReqIdC6} = erpc:check_response(next_msg(), ReqIdC6, false),
+
+ try not_valid = erpc:check_response(next_msg(), ReqIdC6, false)
+ catch error:{{erpc, noconnection}, req2, ReqIdC6} -> ok
+ end,
+
+ {response, 0} = erpc:check_response(Msg0, ReqId0),
+
+ ok.
+
 multicall(Config) ->
 {ok, Node1} = start_peer_node(Config),
 {ok, Node2} = start_peer_node(Config),
@@ -1743,6 +2070,9 @@ f2() ->
 timer:sleep(500),
 halt().
 
+next_msg() ->
+ receive M -> M end.
+
 flush_msgq() ->
 flush_msgq(0).
 flush_msgq(N) ->
-- 
2.34.1

Places

File 2892-Improve-response-handling-for-asynchronous-erpc-requ.patch of Package erlang (Revision f4c798e4a89b3576e3438788d38e337f)

Places