Fix MRP baseTimeout calculation for LIT (#37696) (#38062)

yunhanw-google · restyled-commits · bzbarsky-apple · web-flow · commit 5fd234d4f14e · 2025-03-20T10:42:41.000-04:00
* Fix MRP baseTimeout calculation when it is possible the other end fall asleep

* use min(SAI, SII) for mrp timeout when clock runs into idle

* Restyled by clang-format

* update mrp calculation

-- Use 15 seconds to determine whether device is in LIT mode, then if
yes, set the timeout base as SAI if GetRemoteMRPConfig().mIdleRetransTimeout.count() &gt; sitIcdSlowPollMaximum.count()

* Address comments

* address comments

* Restyled by whitespace

* address comments

* Restyled by whitespace

* Restyled by clang-format

* Update src/transport/UnauthenticatedSessionTable.h



* Update src/transport/Session.h



* Update src/protocols/secure_channel/CASESession.cpp



* Update src/transport/SecureSession.h



* Update src/protocols/secure_channel/CASESession.cpp



* Update src/app/ReadClient.cpp



* Update src/messaging/ReliableMessageProtocolConfig.cpp



* Update src/messaging/ReliableMessageProtocolConfig.h



* address comments

* address comments

* update true isFirstMessageOnExchange for all ComputeRoundTripTimeout caller

* Restyled by whitespace

* Restyled by clang-format

* fix compilation error

* address comments

* cleanup

* add parameter isFirstMessageOnExchange in GetMessageReceiptTimeout

* Restyled by clang-format

---------

Co-authored-by: Restyled.io &lt;commits@restyled.io&gt;
Co-authored-by: Boris Zbarsky &lt;bzbarsky@apple.com&gt;
diff --git a/src/app/CommandSender.cpp b/src/app/CommandSender.cpp
@@ -125,7 +125,8 @@ CHIP_ERROR CommandSender::SendCommandRequestInternal(const SessionHandle & sessi
     mExchangeCtx.Grab(exchange);
     VerifyOrReturnError(!mExchangeCtx->IsGroupExchangeContext(), CHIP_ERROR_INVALID_MESSAGE_TYPE);
 
-    mExchangeCtx->SetResponseTimeout(timeout.ValueOr(session->ComputeRoundTripTimeout(app::kExpectedIMProcessingTime)));
+    mExchangeCtx->SetResponseTimeout(
+        timeout.ValueOr(session->ComputeRoundTripTimeout(app::kExpectedIMProcessingTime, true /*isFirstMessageOnExchange*/)));
 
     if (mTimedInvokeTimeoutMs.HasValue())
     {
diff --git a/src/app/ReadClient.cpp b/src/app/ReadClient.cpp
@@ -987,12 +987,15 @@ CHIP_ERROR ReadClient::ComputeLivenessCheckTimerTimeout(System::Clock::Timeout *
     // So recompute the round-trip timeout directly.  Assume MRP, since in practice that is likely what is happening.
     auto & peerMRPConfig = mReadPrepareParams.mSessionHolder->GetRemoteMRPConfig();
     // Peer will assume we are idle (hence we pass kZero to GetMessageReceiptTimeout()), but will assume we treat it as active
-    // for the response, so to match the retransmission timeout computation for the message back to the peeer, we should treat
-    // it as active.
-    auto roundTripTimeout = mReadPrepareParams.mSessionHolder->GetMessageReceiptTimeout(System::Clock::kZero) +
+    // for the response, so to match the retransmission timeout computation for the message back to the peer, we should treat
+    // it as active and handling non-initial message, isFirstMessageOnExchange needs to be set as false for
+    // GetRetransmissionTimeout.
+    auto roundTripTimeout =
+        mReadPrepareParams.mSessionHolder->GetMessageReceiptTimeout(System::Clock::kZero, true /*isFirstMessageOnExchange*/) +
         kExpectedIMProcessingTime +
         GetRetransmissionTimeout(peerMRPConfig.mActiveRetransTimeout, peerMRPConfig.mIdleRetransTimeout,
-                                 System::SystemClock().GetMonotonicTimestamp(), peerMRPConfig.mActiveThresholdTime);
+                                 System::SystemClock().GetMonotonicTimestamp(), peerMRPConfig.mActiveThresholdTime,
+                                 false /*isFirstMessageOnExchange*/);
     *aTimeout = System::Clock::Seconds16(mMaxInterval) + roundTripTimeout;
     return CHIP_NO_ERROR;
 }
diff --git a/src/app/TimedHandler.cpp b/src/app/TimedHandler.cpp
@@ -127,8 +127,9 @@ CHIP_ERROR TimedHandler::HandleTimedRequestAction(Messaging::ExchangeContext * a
     // will send nothing and the other side will have to time out to realize
     // it's missed its window).
     auto delay = System::Clock::Milliseconds32(timeoutMs);
-    aExchangeContext->SetResponseTimeout(
-        std::max(delay, aExchangeContext->GetSessionHandle()->ComputeRoundTripTimeout(app::kExpectedIMProcessingTime)));
+    aExchangeContext->SetResponseTimeout(std::max(delay,
+                                                  aExchangeContext->GetSessionHandle()->ComputeRoundTripTimeout(
+                                                      app::kExpectedIMProcessingTime, false /*isFirstMessageOnExchange*/)));
     ReturnErrorOnFailure(StatusResponse::Send(Status::Success, aExchangeContext, /* aExpectResponse = */ true));
 
     // Now just wait for the client.
diff --git a/src/controller/AutoCommissioner.cpp b/src/controller/AutoCommissioner.cpp
@@ -651,7 +651,7 @@ Optional<System::Clock::Timeout> AutoCommissioner::GetCommandTimeout(DeviceProxy
     auto sessionHandle = device->GetSecureSession();
     if (sessionHandle.HasValue())
     {
-        timeout = sessionHandle.Value()->ComputeRoundTripTimeout(timeout);
+        timeout = sessionHandle.Value()->ComputeRoundTripTimeout(timeout, true /*isFirstMessageOnExchange*/);
     }
 
     // Enforce the spec minimal timeout.  Maybe this enforcement should live in
diff --git a/src/controller/python/chip/utils/DeviceProxyUtils.cpp b/src/controller/python/chip/utils/DeviceProxyUtils.cpp
@@ -71,7 +71,7 @@ uint32_t pychip_DeviceProxy_ComputeRoundTripTimeout(DeviceProxy * device, uint32
 
     return deviceProxy->GetSecureSession()
         .Value()
-        ->ComputeRoundTripTimeout(System::Clock::Milliseconds32(upperLayerProcessingTimeoutMs))
+        ->ComputeRoundTripTimeout(System::Clock::Milliseconds32(upperLayerProcessingTimeoutMs), true /*isFirstMessageOnExchange*/)
         .count();
 }
 
diff --git a/src/controller/tests/TestWriteChunking.cpp b/src/controller/tests/TestWriteChunking.cpp
@@ -566,9 +566,10 @@ void TestWriteChunking::RunTest(Instructions instructions)
     err = writeClient->SendWriteRequest(sessionHandle);
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    GetIOContext().DriveIOUntil(sessionHandle->ComputeRoundTripTimeout(app::kExpectedIMProcessingTime) +
-                                    System::Clock::Seconds16(1),
-                                [&]() { return GetExchangeManager().GetNumActiveExchanges() == 0; });
+    GetIOContext().DriveIOUntil(
+        sessionHandle->ComputeRoundTripTimeout(app::kExpectedIMProcessingTime, true /*isFirstMessageOnExchange*/) +
+            System::Clock::Seconds16(1),
+        [&]() { return GetExchangeManager().GetNumActiveExchanges() == 0; });
 
     EXPECT_EQ(onGoingPath, app::ConcreteAttributePath());
     EXPECT_EQ(status.size(), instructions.expectedStatus.size());
diff --git a/src/controller/tests/data_model/TestRead.cpp b/src/controller/tests/data_model/TestRead.cpp
@@ -4783,10 +4783,10 @@ System::Clock::Timeout TestRead::ComputeSubscriptionTimeout(System::Clock::Secon
     // Add 1000ms of slack to our max interval to make sure we hit the
     // subscription liveness timer.  100ms was tried in the past and is not
     // sufficient: our process can easily lose the timeslice for 100ms.
-    const auto & ourMrpConfig = GetDefaultMRPConfig();
-    auto publisherTransmissionTimeout =
-        GetRetransmissionTimeout(ourMrpConfig.mActiveRetransTimeout, ourMrpConfig.mIdleRetransTimeout,
-                                 System::SystemClock().GetMonotonicTimestamp(), ourMrpConfig.mActiveThresholdTime);
+    const auto & ourMrpConfig         = GetDefaultMRPConfig();
+    auto publisherTransmissionTimeout = GetRetransmissionTimeout(
+        ourMrpConfig.mActiveRetransTimeout, ourMrpConfig.mIdleRetransTimeout, System::SystemClock().GetMonotonicTimestamp(),
+        ourMrpConfig.mActiveThresholdTime, true /* isFirstMessageOnExchange */);
 
     return publisherTransmissionTimeout + aMaxInterval + System::Clock::Milliseconds32(1000);
 }
diff --git a/src/darwin/Framework/CHIP/MTRBaseDevice.mm b/src/darwin/Framework/CHIP/MTRBaseDevice.mm
@@ -1475,7 +1475,7 @@ - (void)_invokeCommandWithEndpointID:(NSNumber *)endpointID
                 // Clamp to a number of seconds that will not overflow 32-bit
                 // int when converted to ms.
                 auto serverTimeoutInSeconds = System::Clock::Seconds16(serverSideProcessingTimeout.unsignedShortValue);
-                invokeTimeout.SetValue(session->ComputeRoundTripTimeout(serverTimeoutInSeconds));
+                invokeTimeout.SetValue(session->ComputeRoundTripTimeout(serverTimeoutInSeconds, true /*isFirstMessageOnExchange*/));
             }
             ReturnErrorOnFailure(commandSender->SendCommandRequest(session, invokeTimeout));
 
diff --git a/src/messaging/ExchangeContext.cpp b/src/messaging/ExchangeContext.cpp
@@ -77,7 +77,7 @@ void ExchangeContext::SetResponseExpected(bool inResponseExpected)
 
 void ExchangeContext::UseSuggestedResponseTimeout(Timeout applicationProcessingTimeout)
 {
-    SetResponseTimeout(mSession->ComputeRoundTripTimeout(applicationProcessingTimeout));
+    SetResponseTimeout(mSession->ComputeRoundTripTimeout(applicationProcessingTimeout, !HasReceivedAtLeastOneMessage()));
 }
 
 void ExchangeContext::SetResponseTimeout(Timeout timeout)
diff --git a/src/messaging/ReliableMessageProtocolConfig.cpp b/src/messaging/ReliableMessageProtocolConfig.cpp
@@ -126,7 +126,8 @@ Optional<ReliableMessageProtocolConfig> GetLocalMRPConfig()
 }
 
 System::Clock::Timeout GetRetransmissionTimeout(System::Clock::Timeout activeInterval, System::Clock::Timeout idleInterval,
-                                                System::Clock::Timeout lastActivityTime, System::Clock::Timeout activityThreshold)
+                                                System::Clock::Timeout lastActivityTime, System::Clock::Timeout activityThreshold,
+                                                bool isFirstMessageOnExchange)
 {
     auto timeSinceLastActivity = (System::SystemClock().GetMonotonicTimestamp() - lastActivityTime);
 
@@ -135,7 +136,14 @@ System::Clock::Timeout GetRetransmissionTimeout(System::Clock::Timeout activeInt
     System::Clock::Timestamp timeout(0);
     for (uint8_t i = 0; i < CHIP_CONFIG_RMP_DEFAULT_MAX_RETRANS + 1; i++)
     {
-        auto baseInterval = ((timeSinceLastActivity + timeout) < activityThreshold) ? activeInterval : idleInterval;
+        auto baseInterval = activeInterval;
+        // If we are calculating the timeout for the initial message, we never know whether the peer is active or not, choose
+        // active/idle interval from PeerActiveMode of session per 4.11.2.1. Retransmissions.
+        // If we are calculating the timeout for response message, we know the peer is active, always choose active interval.
+        if (isFirstMessageOnExchange)
+        {
+            baseInterval = ((timeSinceLastActivity + timeout) < activityThreshold) ? activeInterval : idleInterval;
+        }
         timeout += Messaging::ReliableMessageMgr::GetBackoff(baseInterval, i, /* computeMaxPossible */ true);
     }
 
diff --git a/src/messaging/ReliableMessageProtocolConfig.h b/src/messaging/ReliableMessageProtocolConfig.h
@@ -257,11 +257,12 @@ Optional<ReliableMessageProtocolConfig> GetLocalMRPConfig();
  * @param[in] idleInterval      The idle interval to use for the backoff calculation.
  * @param[in] lastActivityTime  The last time some activity has been recorded.
  * @param[in] activityThreshold The activity threshold for a node to be considered active.
- *
+ * @param[in] isFirstMessageOnExchange Indicates whether this is for the initial message on an exchange.
  * @return The maximum transmission time
  */
 System::Clock::Timeout GetRetransmissionTimeout(System::Clock::Timeout activeInterval, System::Clock::Timeout idleInterval,
-                                                System::Clock::Timeout lastActivityTime, System::Clock::Timeout activityThreshold);
+                                                System::Clock::Timeout lastActivityTime, System::Clock::Timeout activityThreshold,
+                                                bool isFirstMessageOnExchange);
 
 #if CONFIG_BUILD_FOR_HOST_UNIT_TEST
 
diff --git a/src/protocols/secure_channel/CASESession.cpp b/src/protocols/secure_channel/CASESession.cpp
@@ -2426,34 +2426,37 @@ CHIP_ERROR CASESession::OnMessageReceived(ExchangeContext * ec, const PayloadHea
 
 namespace {
 System::Clock::Timeout ComputeRoundTripTimeout(ExchangeContext::Timeout serverProcessingTime,
-                                               const ReliableMessageProtocolConfig & remoteMrpConfig)
+                                               const ReliableMessageProtocolConfig & remoteMrpConfig, bool isFirstMessageOnExchange)
 {
     // TODO: This is duplicating logic from Session::ComputeRoundTripTimeout.  Unfortunately, it's called by
     // consumers who do not have a session.
     const auto & maybeLocalMRPConfig = GetLocalMRPConfig();
     const auto & defaultMRRPConfig   = GetDefaultMRPConfig();
     const auto & localMRPConfig      = maybeLocalMRPConfig.ValueOr(defaultMRRPConfig);
     return GetRetransmissionTimeout(remoteMrpConfig.mActiveRetransTimeout, remoteMrpConfig.mIdleRetransTimeout,
-                                    // Assume peer is idle, as a worst-case assumption (probably true for
-                                    // Sigma1, since that will be our initial message on the session, but less
-                                    // so for Sigma2).
-                                    System::Clock::kZero, remoteMrpConfig.mActiveThresholdTime) +
+                                    // The activity time only matters when isFirstMessageOnExchange is false,
+                                    // which only happens for Sigma1.  In that case, assume peer is idle,
+                                    // as a worst-case assumption, and pass System::Clock::kZero.
+                                    System::Clock::kZero, remoteMrpConfig.mActiveThresholdTime, isFirstMessageOnExchange) +
         serverProcessingTime +
         GetRetransmissionTimeout(localMRPConfig.mActiveRetransTimeout, localMRPConfig.mIdleRetransTimeout,
-                                 // Peer will assume we are active, since it's
-                                 // responding to our message.
-                                 System::SystemClock().GetMonotonicTimestamp(), localMRPConfig.mActiveThresholdTime);
+                                 // Peer will be responding to our message, so isFirstMessageOnExchange should be false
+                                 // and the timestamp does not matter.
+                                 System::SystemClock().GetMonotonicTimestamp(), localMRPConfig.mActiveThresholdTime,
+                                 false /*isFirstMessageOnExchange*/);
 }
 } // anonymous namespace
 
 System::Clock::Timeout CASESession::ComputeSigma1ResponseTimeout(const ReliableMessageProtocolConfig & remoteMrpConfig)
 {
-    return ComputeRoundTripTimeout(kExpectedSigma1ProcessingTime, remoteMrpConfig);
+    // Sigma1 is the first message on the exchange.
+    return ComputeRoundTripTimeout(kExpectedSigma1ProcessingTime, remoteMrpConfig, true /*isFirstMessageOnExchange*/);
 }
 
 System::Clock::Timeout CASESession::ComputeSigma2ResponseTimeout(const ReliableMessageProtocolConfig & remoteMrpConfig)
 {
-    return ComputeRoundTripTimeout(kExpectedHighProcessingTime, remoteMrpConfig);
+    // Sigma2 is never the first message on the exchange.
+    return ComputeRoundTripTimeout(kExpectedHighProcessingTime, remoteMrpConfig, false /*isFirstMessageOnExchange*/);
 }
 
 bool CASESession::InvokeBackgroundWorkWatchdog()
diff --git a/src/transport/GroupSession.h b/src/transport/GroupSession.h
@@ -69,13 +69,14 @@ class IncomingGroupSession : public Session, public ReferenceCounted<IncomingGro
 
     System::Clock::Timestamp GetMRPBaseTimeout() const override { return System::Clock::kZero; }
 
-    System::Clock::Milliseconds32 GetAckTimeout() const override
+    System::Clock::Milliseconds32 GetAckTimeout(bool isFirstMessageOnExchange) const override
     {
         VerifyOrDie(false);
         return System::Clock::Timeout();
     }
 
-    System::Clock::Milliseconds32 GetMessageReceiptTimeout(System::Clock::Timestamp ourLastActivity) const override
+    System::Clock::Milliseconds32 GetMessageReceiptTimeout(System::Clock::Timestamp ourLastActivity,
+                                                           bool isFirstMessageOnExchange) const override
     {
         // There are no timeouts for group sessions.
         VerifyOrDie(false);
@@ -128,13 +129,14 @@ class OutgoingGroupSession : public Session, public ReferenceCounted<OutgoingGro
 
     System::Clock::Timestamp GetMRPBaseTimeout() const override { return System::Clock::kZero; }
 
-    System::Clock::Milliseconds32 GetAckTimeout() const override
+    System::Clock::Milliseconds32 GetAckTimeout(bool isFirstMessageOnExchange) const override
     {
         VerifyOrDie(false);
         return System::Clock::Timeout();
     }
 
-    System::Clock::Milliseconds32 GetMessageReceiptTimeout(System::Clock::Timestamp ourLastActivity) const override
+    System::Clock::Milliseconds32 GetMessageReceiptTimeout(System::Clock::Timestamp ourLastActivity,
+                                                           bool isFirstMessageOnExchange) const override
     {
         // There are no timeouts for group sessions.
         VerifyOrDie(false);
diff --git a/src/transport/SecureSession.h b/src/transport/SecureSession.h
@@ -162,14 +162,15 @@ class SecureSession : public Session, public ReferenceCounted<SecureSession, Sec
 
     bool AllowsLargePayload() const override { return GetPeerAddress().GetTransportType() == Transport::Type::kTcp; }
 
-    System::Clock::Milliseconds32 GetAckTimeout() const override
+    System::Clock::Milliseconds32 GetAckTimeout(bool isFirstMessageOnExchange) const override
     {
         switch (mPeerAddress.GetTransportType())
         {
         case Transport::Type::kUdp: {
             const ReliableMessageProtocolConfig & remoteMRPConfig = mRemoteSessionParams.GetMRPConfig();
             return GetRetransmissionTimeout(remoteMRPConfig.mActiveRetransTimeout, remoteMRPConfig.mIdleRetransTimeout,
-                                            GetLastPeerActivityTime(), remoteMRPConfig.mActiveThresholdTime);
+                                            GetLastPeerActivityTime(), remoteMRPConfig.mActiveThresholdTime,
+                                            isFirstMessageOnExchange);
         }
         case Transport::Type::kTcp:
             return System::Clock::Seconds16(30);
@@ -181,7 +182,8 @@ class SecureSession : public Session, public ReferenceCounted<SecureSession, Sec
         return System::Clock::Timeout();
     }
 
-    System::Clock::Milliseconds32 GetMessageReceiptTimeout(System::Clock::Timestamp ourLastActivity) const override
+    System::Clock::Milliseconds32 GetMessageReceiptTimeout(System::Clock::Timestamp ourLastActivity,
+                                                           bool isFirstMessageOnExchange) const override
     {
         switch (mPeerAddress.GetTransportType())
         {
@@ -190,7 +192,7 @@ class SecureSession : public Session, public ReferenceCounted<SecureSession, Sec
             const auto & defaultMRRPConfig   = GetDefaultMRPConfig();
             const auto & localMRPConfig      = maybeLocalMRPConfig.ValueOr(defaultMRRPConfig);
             return GetRetransmissionTimeout(localMRPConfig.mActiveRetransTimeout, localMRPConfig.mIdleRetransTimeout,
-                                            ourLastActivity, localMRPConfig.mActiveThresholdTime);
+                                            ourLastActivity, localMRPConfig.mActiveThresholdTime, isFirstMessageOnExchange);
         }
         case Transport::Type::kTcp:
             return System::Clock::Seconds16(30);
diff --git a/src/transport/Session.cpp b/src/transport/Session.cpp
@@ -64,16 +64,18 @@ const OutgoingGroupSession * Session::AsConstOutgoingGroupSession() const
     return static_cast<const OutgoingGroupSession *>(this);
 }
 
-System::Clock::Timeout Session::ComputeRoundTripTimeout(System::Clock::Timeout upperlayerProcessingTimeout)
+System::Clock::Timeout Session::ComputeRoundTripTimeout(System::Clock::Timeout upperlayerProcessingTimeout,
+                                                        bool isFirstMessageOnExchange)
 {
     if (IsGroupSession())
     {
         return System::Clock::kZero;
     }
 
-    // Treat us as active for purposes of GetMessageReceiptTimeout(), since the
-    // other side would be responding to our message.
-    return GetAckTimeout() + upperlayerProcessingTimeout + GetMessageReceiptTimeout(System::SystemClock().GetMonotonicTimestamp());
+    // Treat us as active for purposes of GetMessageReceiptTimeout(), pass false into GetMessageReceiptTimeout to
+    // indicate we are processing non-initial message since the other side would be responding to our message.
+    return GetAckTimeout(isFirstMessageOnExchange) + upperlayerProcessingTimeout +
+        GetMessageReceiptTimeout(System::SystemClock().GetMonotonicTimestamp(), false /*isFirstMessageOnExchange*/);
 }
 
 uint16_t Session::SessionIdForLogging() const
diff --git a/src/transport/Session.h b/src/transport/Session.h
diff --git a/src/transport/UnauthenticatedSessionTable.h b/src/transport/UnauthenticatedSessionTable.h

Original file line number	Diff line number	Diff line change
`@@ -125,7 +125,8 @@ CHIP_ERROR CommandSender::SendCommandRequestInternal(const SessionHandle & sessi`
`125`	`125`	`mExchangeCtx.Grab(exchange);`
`126`	`126`	`VerifyOrReturnError(!mExchangeCtx->IsGroupExchangeContext(), CHIP_ERROR_INVALID_MESSAGE_TYPE);`
`127`	`127`
`128`		`- mExchangeCtx->SetResponseTimeout(timeout.ValueOr(session->ComputeRoundTripTimeout(app::kExpectedIMProcessingTime)));`
	`128`	`+ mExchangeCtx->SetResponseTimeout(`
	`129`	`+ timeout.ValueOr(session->ComputeRoundTripTimeout(app::kExpectedIMProcessingTime, true /isFirstMessageOnExchange/)));`
`129`	`130`
`130`	`131`	`if (mTimedInvokeTimeoutMs.HasValue())`
`131`	`132`	`{`
Original file line number	Diff line number	Diff line change
`@@ -651,7 +651,7 @@ Optional<System::Clock::Timeout> AutoCommissioner::GetCommandTimeout(DeviceProxy`
`651`	`651`	`auto sessionHandle = device->GetSecureSession();`
`652`	`652`	`if (sessionHandle.HasValue())`
`653`	`653`	`{`
`654`		`- timeout = sessionHandle.Value()->ComputeRoundTripTimeout(timeout);`
	`654`	`+ timeout = sessionHandle.Value()->ComputeRoundTripTimeout(timeout, true /isFirstMessageOnExchange/);`
`655`	`655`	`}`
`656`	`656`
`657`	`657`	`// Enforce the spec minimal timeout. Maybe this enforcement should live in`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ uint32_t pychip_DeviceProxy_ComputeRoundTripTimeout(DeviceProxy * device, uint32`
`71`	`71`
`72`	`72`	`return deviceProxy->GetSecureSession()`
`73`	`73`	`.Value()`
`74`		`- ->ComputeRoundTripTimeout(System::Clock::Milliseconds32(upperLayerProcessingTimeoutMs))`
	`74`	`+ ->ComputeRoundTripTimeout(System::Clock::Milliseconds32(upperLayerProcessingTimeoutMs), true /isFirstMessageOnExchange/)`
`75`	`75`	`.count();`
`76`	`76`	`}`
`77`	`77`
Original file line number	Diff line number	Diff line change
`@@ -1475,7 +1475,7 @@ - (void)_invokeCommandWithEndpointID:(NSNumber *)endpointID`
`1475`	`1475`	`// Clamp to a number of seconds that will not overflow 32-bit`
`1476`	`1476`	`// int when converted to ms.`
`1477`	`1477`	`auto serverTimeoutInSeconds = System::Clock::Seconds16(serverSideProcessingTimeout.unsignedShortValue);`
`1478`		`- invokeTimeout.SetValue(session->ComputeRoundTripTimeout(serverTimeoutInSeconds));`
	`1478`	`+ invokeTimeout.SetValue(session->ComputeRoundTripTimeout(serverTimeoutInSeconds, true /isFirstMessageOnExchange/));`
`1479`	`1479`	`}`
`1480`	`1480`	`ReturnErrorOnFailure(commandSender->SendCommandRequest(session, invokeTimeout));`
`1481`	`1481`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ void ExchangeContext::SetResponseExpected(bool inResponseExpected)`
`77`	`77`
`78`	`78`	`void ExchangeContext::UseSuggestedResponseTimeout(Timeout applicationProcessingTimeout)`
`79`	`79`	`{`
`80`		`- SetResponseTimeout(mSession->ComputeRoundTripTimeout(applicationProcessingTimeout));`
	`80`	`+ SetResponseTimeout(mSession->ComputeRoundTripTimeout(applicationProcessingTimeout, !HasReceivedAtLeastOneMessage()));`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`void ExchangeContext::SetResponseTimeout(Timeout timeout)`
Original file line number	Diff line number	Diff line change
`@@ -126,7 +126,8 @@ Optional<ReliableMessageProtocolConfig> GetLocalMRPConfig()`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`System::Clock::Timeout GetRetransmissionTimeout(System::Clock::Timeout activeInterval, System::Clock::Timeout idleInterval,`
`129`		`- System::Clock::Timeout lastActivityTime, System::Clock::Timeout activityThreshold)`
	`129`	`+ System::Clock::Timeout lastActivityTime, System::Clock::Timeout activityThreshold,`
	`130`	`+ bool isFirstMessageOnExchange)`
`130`	`131`	`{`
`131`	`132`	`auto timeSinceLastActivity = (System::SystemClock().GetMonotonicTimestamp() - lastActivityTime);`
`132`	`133`
`@@ -135,7 +136,14 @@ System::Clock::Timeout GetRetransmissionTimeout(System::Clock::Timeout activeInt`
`135`	`136`	`System::Clock::Timestamp timeout(0);`
`136`	`137`	`for (uint8_t i = 0; i < CHIP_CONFIG_RMP_DEFAULT_MAX_RETRANS + 1; i++)`
`137`	`138`	`{`
`138`		`- auto baseInterval = ((timeSinceLastActivity + timeout) < activityThreshold) ? activeInterval : idleInterval;`
	`139`	`+ auto baseInterval = activeInterval;`
	`140`	`+ // If we are calculating the timeout for the initial message, we never know whether the peer is active or not, choose`
	`141`	`+ // active/idle interval from PeerActiveMode of session per 4.11.2.1. Retransmissions.`
	`142`	`+ // If we are calculating the timeout for response message, we know the peer is active, always choose active interval.`
	`143`	`+ if (isFirstMessageOnExchange)`
	`144`	`+ {`
	`145`	`+ baseInterval = ((timeSinceLastActivity + timeout) < activityThreshold) ? activeInterval : idleInterval;`
	`146`	`+ }`
`139`	`147`	`timeout += Messaging::ReliableMessageMgr::GetBackoff(baseInterval, i, /* computeMaxPossible */ true);`
`140`	`148`	`}`
`141`	`149`
Original file line number	Diff line number	Diff line change
`@@ -69,13 +69,14 @@ class IncomingGroupSession : public Session, public ReferenceCounted<IncomingGro`
`69`	`69`
`70`	`70`	`System::Clock::Timestamp GetMRPBaseTimeout() const override { return System::Clock::kZero; }`
`71`	`71`
`72`		`- System::Clock::Milliseconds32 GetAckTimeout() const override`
	`72`	`+ System::Clock::Milliseconds32 GetAckTimeout(bool isFirstMessageOnExchange) const override`
`73`	`73`	`{`
`74`	`74`	`VerifyOrDie(false);`
`75`	`75`	`return System::Clock::Timeout();`
`76`	`76`	`}`
`77`	`77`
`78`		`- System::Clock::Milliseconds32 GetMessageReceiptTimeout(System::Clock::Timestamp ourLastActivity) const override`
	`78`	`+ System::Clock::Milliseconds32 GetMessageReceiptTimeout(System::Clock::Timestamp ourLastActivity,`
	`79`	`+ bool isFirstMessageOnExchange) const override`
`79`	`80`	`{`
`80`	`81`	`// There are no timeouts for group sessions.`
`81`	`82`	`VerifyOrDie(false);`
`@@ -128,13 +129,14 @@ class OutgoingGroupSession : public Session, public ReferenceCounted<OutgoingGro`
`128`	`129`
`129`	`130`	`System::Clock::Timestamp GetMRPBaseTimeout() const override { return System::Clock::kZero; }`
`130`	`131`
`131`		`- System::Clock::Milliseconds32 GetAckTimeout() const override`
	`132`	`+ System::Clock::Milliseconds32 GetAckTimeout(bool isFirstMessageOnExchange) const override`
`132`	`133`	`{`
`133`	`134`	`VerifyOrDie(false);`
`134`	`135`	`return System::Clock::Timeout();`
`135`	`136`	`}`
`136`	`137`
`137`		`- System::Clock::Milliseconds32 GetMessageReceiptTimeout(System::Clock::Timestamp ourLastActivity) const override`
	`138`	`+ System::Clock::Milliseconds32 GetMessageReceiptTimeout(System::Clock::Timestamp ourLastActivity,`
	`139`	`+ bool isFirstMessageOnExchange) const override`
`138`	`140`	`{`
`139`	`141`	`// There are no timeouts for group sessions.`
`140`	`142`	`VerifyOrDie(false);`
Original file line number	Diff line number	Diff line change
`@@ -162,14 +162,15 @@ class SecureSession : public Session, public ReferenceCounted<SecureSession, Sec`
`162`	`162`
`163`	`163`	`bool AllowsLargePayload() const override { return GetPeerAddress().GetTransportType() == Transport::Type::kTcp; }`
`164`	`164`
`165`		`- System::Clock::Milliseconds32 GetAckTimeout() const override`
	`165`	`+ System::Clock::Milliseconds32 GetAckTimeout(bool isFirstMessageOnExchange) const override`
`166`	`166`	`{`
`167`	`167`	`switch (mPeerAddress.GetTransportType())`
`168`	`168`	`{`
`169`	`169`	`case Transport::Type::kUdp: {`
`170`	`170`	`const ReliableMessageProtocolConfig & remoteMRPConfig = mRemoteSessionParams.GetMRPConfig();`
`171`	`171`	`return GetRetransmissionTimeout(remoteMRPConfig.mActiveRetransTimeout, remoteMRPConfig.mIdleRetransTimeout,`
`172`		`- GetLastPeerActivityTime(), remoteMRPConfig.mActiveThresholdTime);`
	`172`	`+ GetLastPeerActivityTime(), remoteMRPConfig.mActiveThresholdTime,`
	`173`	`+ isFirstMessageOnExchange);`
`173`	`174`	`}`
`174`	`175`	`case Transport::Type::kTcp:`
`175`	`176`	`return System::Clock::Seconds16(30);`
`@@ -181,7 +182,8 @@ class SecureSession : public Session, public ReferenceCounted<SecureSession, Sec`
`181`	`182`	`return System::Clock::Timeout();`
`182`	`183`	`}`
`183`	`184`
`184`		`- System::Clock::Milliseconds32 GetMessageReceiptTimeout(System::Clock::Timestamp ourLastActivity) const override`
	`185`	`+ System::Clock::Milliseconds32 GetMessageReceiptTimeout(System::Clock::Timestamp ourLastActivity,`
	`186`	`+ bool isFirstMessageOnExchange) const override`
`185`	`187`	`{`
`186`	`188`	`switch (mPeerAddress.GetTransportType())`
`187`	`189`	`{`
`@@ -190,7 +192,7 @@ class SecureSession : public Session, public ReferenceCounted<SecureSession, Sec`
`190`	`192`	`const auto & defaultMRRPConfig = GetDefaultMRPConfig();`
`191`	`193`	`const auto & localMRPConfig = maybeLocalMRPConfig.ValueOr(defaultMRRPConfig);`
`192`	`194`	`return GetRetransmissionTimeout(localMRPConfig.mActiveRetransTimeout, localMRPConfig.mIdleRetransTimeout,`
`193`		`- ourLastActivity, localMRPConfig.mActiveThresholdTime);`
	`195`	`+ ourLastActivity, localMRPConfig.mActiveThresholdTime, isFirstMessageOnExchange);`
`194`	`196`	`}`
`195`	`197`	`case Transport::Type::kTcp:`
`196`	`198`	`return System::Clock::Seconds16(30);`
Original file line number	Diff line number	Diff line change
`@@ -64,16 +64,18 @@ const OutgoingGroupSession * Session::AsConstOutgoingGroupSession() const`
`64`	`64`	`return static_cast<const OutgoingGroupSession *>(this);`
`65`	`65`	`}`
`66`	`66`
`67`		`-System::Clock::Timeout Session::ComputeRoundTripTimeout(System::Clock::Timeout upperlayerProcessingTimeout)`
	`67`	`+System::Clock::Timeout Session::ComputeRoundTripTimeout(System::Clock::Timeout upperlayerProcessingTimeout,`
	`68`	`+ bool isFirstMessageOnExchange)`
`68`	`69`	`{`
`69`	`70`	`if (IsGroupSession())`
`70`	`71`	`{`
`71`	`72`	`return System::Clock::kZero;`
`72`	`73`	`}`
`73`	`74`
`74`		`- // Treat us as active for purposes of GetMessageReceiptTimeout(), since the`
`75`		`- // other side would be responding to our message.`
`76`		`- return GetAckTimeout() + upperlayerProcessingTimeout + GetMessageReceiptTimeout(System::SystemClock().GetMonotonicTimestamp());`
	`75`	`+ // Treat us as active for purposes of GetMessageReceiptTimeout(), pass false into GetMessageReceiptTimeout to`
	`76`	`+ // indicate we are processing non-initial message since the other side would be responding to our message.`
	`77`	`+ return GetAckTimeout(isFirstMessageOnExchange) + upperlayerProcessingTimeout +`
	`78`	`+ GetMessageReceiptTimeout(System::SystemClock().GetMonotonicTimestamp(), false /isFirstMessageOnExchange/);`
`77`	`79`	`}`
`78`	`80`
`79`	`81`	`uint16_t Session::SessionIdForLogging() const`