espressif/openthread
1
0
Fork 0
mirror of https://github.com/espressif/openthread.git synced 2026-09-06 01:00:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

[mpl] make MplBufferedMessageMetadata private to Mpl (#4715)

Browse Source
This commit is contained in:
Jonathan Hui
2020-03-23 20:59:41 -07:00
parent 6c365287e7
commit 2738b05af7
2 changed files with 79 additions and 209 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/core/net/ip6_mpl.cpp
+62 -41
View File
@@ -297,10 +297,10 @@ void Mpl::HandleSeedSetTimer(void)
void Mpl::AddBufferedMessage(Message &aMessage, uint16_t aSeedId, uint8_t aSequence, bool aIsOutbound)
{
otError error = OT_ERROR_NONE;
Message * messageCopy = NULL;
MplBufferedMessageMetadata messageMetadata;
uint8_t hopLimit = 0;
otError error = OT_ERROR_NONE;
Message *messageCopy = NULL;
Metadata metadata;
uint8_t hopLimit = 0;
#if OPENTHREAD_CONFIG_MPL_DYNAMIC_INTERVAL_ENABLE
// adjust the first MPL forward interval dynamically according to the network scale
@@ -319,15 +319,16 @@ void Mpl::AddBufferedMessage(Message &aMessage, uint16_t aSeedId, uint8_t aSeque
messageCopy->Write(Header::GetHopLimitOffset(), Header::GetHopLimitSize(), &hopLimit);
}
messageMetadata.SetSeedId(aSeedId);
messageMetadata.SetSequence(aSequence);
messageMetadata.SetTransmissionCount(aIsOutbound ? 1 : 0);
messageMetadata.GenerateNextTransmissionTime(TimerMilli::GetNow(), interval);
metadata.mSeedId = aSeedId;
metadata.mSequence = aSequence;
metadata.mTransmissionCount = aIsOutbound ? 1 : 0;
metadata.mIntervalOffset = 0;
metadata.GenerateNextTransmissionTime(TimerMilli::GetNow(), interval);
SuccessOrExit(error = messageMetadata.AppendTo(*messageCopy));
SuccessOrExit(error = metadata.AppendTo(*messageCopy));
mBufferedMessageSet.Enqueue(*messageCopy);
mRetransmissionTimer.FireAtIfEarlier(messageMetadata.GetTransmissionTime());
mRetransmissionTimer.FireAtIfEarlier(metadata.mTransmissionTime);
exit:
@@ -337,16 +338,6 @@ exit:
}
}
void MplBufferedMessageMetadata::GenerateNextTransmissionTime(TimeMilli aCurrentTime, uint8_t aInterval)
{
// Emulate Trickle timer behavior and set up the next retransmission within [0,I) range.
uint8_t t = (aInterval == 0) ? aInterval : Random::NonCrypto::GetUint8InRange(0, aInterval);
// Set transmission time at the beginning of the next interval.
SetTransmissionTime(aCurrentTime + static_cast<uint32_t>(GetIntervalOffset() + t));
SetIntervalOffset(aInterval - t);
}
void Mpl::HandleRetransmissionTimer(Timer &aTimer)
{
aTimer.GetOwner<Mpl>().HandleRetransmissionTimer();
@@ -354,37 +345,37 @@ void Mpl::HandleRetransmissionTimer(Timer &aTimer)
void Mpl::HandleRetransmissionTimer(void)
{
TimeMilli now = TimerMilli::GetNow();
TimeMilli nextTime = now.GetDistantFuture();
MplBufferedMessageMetadata messageMetadata;
Message * message;
Message * nextMessage;
TimeMilli now = TimerMilli::GetNow();
TimeMilli nextTime = now.GetDistantFuture();
Metadata metadata;
Message * message;
Message * nextMessage;
for (message = mBufferedMessageSet.GetHead(); message != NULL; message = nextMessage)
{
nextMessage = message->GetNext();
messageMetadata.ReadFrom(*message);
metadata.ReadFrom(*message);
if (now < messageMetadata.GetTransmissionTime())
if (now < metadata.mTransmissionTime)
{
if (nextTime > messageMetadata.GetTransmissionTime())
if (nextTime > metadata.mTransmissionTime)
{
nextTime = messageMetadata.GetTransmissionTime();
nextTime = metadata.mTransmissionTime;
}
}
else
{
// Update the number of transmission timer expirations.
messageMetadata.SetTransmissionCount(messageMetadata.GetTransmissionCount() + 1);
metadata.mTransmissionCount++;
if (messageMetadata.GetTransmissionCount() < GetTimerExpirations())
if (metadata.mTransmissionCount < GetTimerExpirations())
{
Message *messageCopy = message->Clone(message->GetLength() - sizeof(MplBufferedMessageMetadata));
Message *messageCopy = message->Clone(message->GetLength() - sizeof(Metadata));
if (messageCopy != NULL)
{
if (messageMetadata.GetTransmissionCount() > 1)
if (metadata.mTransmissionCount > 1)
{
messageCopy->SetSubType(Message::kSubTypeMplRetransmission);
}
@@ -392,27 +383,26 @@ void Mpl::HandleRetransmissionTimer(void)
Get<Ip6>().EnqueueDatagram(*messageCopy);
}
messageMetadata.GenerateNextTransmissionTime(now, kDataMessageInterval);
messageMetadata.UpdateIn(*message);
metadata.GenerateNextTransmissionTime(now, kDataMessageInterval);
metadata.UpdateIn(*message);
if (nextTime > messageMetadata.GetTransmissionTime())
if (nextTime > metadata.mTransmissionTime)
{
nextTime = messageMetadata.GetTransmissionTime();
nextTime = metadata.mTransmissionTime;
}
}
else
{
mBufferedMessageSet.Dequeue(*message);
if (messageMetadata.GetTransmissionCount() == GetTimerExpirations())
if (metadata.mTransmissionCount == GetTimerExpirations())
{
if (messageMetadata.GetTransmissionCount() > 1)
if (metadata.mTransmissionCount > 1)
{
message->SetSubType(Message::kSubTypeMplRetransmission);
}
// Remove the extra metadata from the MPL Data Message.
MplBufferedMessageMetadata::RemoveFrom(*message);
metadata.RemoveFrom(*message);
Get<Ip6>().EnqueueDatagram(*message);
}
else
@@ -430,6 +420,37 @@ void Mpl::HandleRetransmissionTimer(void)
}
}
void Mpl::Metadata::ReadFrom(const Message &aMessage)
{
uint16_t length = aMessage.GetLength();
OT_ASSERT(length >= sizeof(*this));
aMessage.Read(length - sizeof(*this), sizeof(*this), this);
}
void Mpl::Metadata::RemoveFrom(Message &aMessage) const
{
otError error = aMessage.SetLength(aMessage.GetLength() - sizeof(*this));
OT_ASSERT(error == OT_ERROR_NONE);
OT_UNUSED_VARIABLE(error);
}
int Mpl::Metadata::UpdateIn(Message &aMessage) const
{
return aMessage.Write(aMessage.GetLength() - sizeof(*this), sizeof(*this), this);
}
void Mpl::Metadata::GenerateNextTransmissionTime(TimeMilli aCurrentTime, uint8_t aInterval)
{
// Emulate Trickle timer behavior and set up the next retransmission within [0,I) range.
uint8_t t = (aInterval == 0) ? aInterval : Random::NonCrypto::GetUint8InRange(0, aInterval);
// Set transmission time at the beginning of the next interval.
mTransmissionTime = aCurrentTime + static_cast<uint32_t>(mIntervalOffset + t);
mIntervalOffset = aInterval - t;
}
#endif // OPENTHREAD_FTD
} // namespace Ip6
src/core/net/ip6_mpl.hpp
+17 -168
View File
@@ -243,172 +243,6 @@ private:
uint8_t mLifetime;
};
#if OPENTHREAD_FTD
/**
* This class represents metadata required for MPL retransmissions.
*
*/
class MplBufferedMessageMetadata
{
public:
/**
* Default constructor for the object.
*
*/
MplBufferedMessageMetadata(void)
: mSeedId(0)
, mSequence(0)
, mTransmissionCount(0)
, mTransmissionTime(0)
, mIntervalOffset(0){};
/**
* This method appends MPL Buffered Message metadata to the message.
*
* @param[in] aMessage A reference to the message.
*
* @retval OT_ERROR_NONE Successfully appended the bytes.
* @retval OT_ERROR_NO_BUFS Insufficient available buffers to grow the message.
*
*/
otError AppendTo(Message &aMessage) const { return aMessage.Append(this, sizeof(*this)); }
/**
* This method reads request data from the message.
*
* @param[in] aMessage A reference to the message.
*
*/
void ReadFrom(const Message &aMessage)
{
uint16_t length = aMessage.Read(aMessage.GetLength() - sizeof(*this), sizeof(*this), this);
OT_ASSERT(length == sizeof(*this));
OT_UNUSED_VARIABLE(length);
}
/**
* This method removes MPL Buffered Message metadata from the message.
*
* @param[in] aMessage A reference to the message.
*
*/
static void RemoveFrom(Message &aMessage)
{
otError error = aMessage.SetLength(aMessage.GetLength() - sizeof(MplBufferedMessageMetadata));
OT_ASSERT(error == OT_ERROR_NONE);
OT_UNUSED_VARIABLE(error);
}
/**
* This method updates MPL Buffered Message metadata in the message.
*
* @param[in] aMessage A reference to the message.
*
* @returns The number of bytes that have been updated.
*
*/
int UpdateIn(Message &aMessage) const
{
return aMessage.Write(aMessage.GetLength() - sizeof(*this), sizeof(*this), this);
}
/**
* This method returns the MPL Seed Id value.
*
* @returns The MPL Seed Id value.
*
*/
uint16_t GetSeedId(void) const { return mSeedId; }
/**
* This method sets the MPL Seed Id value.
*
* @param[in] aSeedId The MPL Seed Id value.
*
*/
void SetSeedId(uint16_t aSeedId) { mSeedId = aSeedId; }
/**
* This method returns the MPL Sequence value.
*
* @returns The MPL Sequence value.
*
*/
uint8_t GetSequence(void) const { return mSequence; }
/**
* This method sets the MPL Sequence value.
*
* @param[in] aSequence The MPL Sequence value.
*
*/
void SetSequence(uint8_t aSequence) { mSequence = aSequence; }
/**
* This method returns the number of already preformed transmissions.
*
* @returns The number of already preformed transmissions.
*
*/
uint8_t GetTransmissionCount(void) const { return mTransmissionCount; }
/**
* This method sets the number of already performed transmissions.
*
* @param[in] aTransmissionCount The number of already performed transmissions.
*
*/
void SetTransmissionCount(uint8_t aTransmissionCount) { mTransmissionCount = aTransmissionCount; }
/**
* This method returns the transmission timestamp of the message.
*
* @returns The transmission timestamp of the message.
*
*/
TimeMilli GetTransmissionTime(void) const { return mTransmissionTime; }
/**
* This method sets the transmission timestamp of the message.
*
* @param[in] aTransmissionTime The transmission timestamp of the message.
*
*/
void SetTransmissionTime(TimeMilli aTransmissionTime) { mTransmissionTime = aTransmissionTime; }
/**
* This method returns the offset from the transmission time to the end of trickle interval.
*
* @returns The offset from the transmission time to the end of trickle interval.
*
*/
uint8_t GetIntervalOffset(void) const { return mIntervalOffset; }
/**
* This method sets the offset from the transmission time to the end of trickle interval.
*
* @param[in] aIntervalOffset The offset from the transmission time to the end of trickle interval.
*
*/
void SetIntervalOffset(uint8_t aIntervalOffset) { mIntervalOffset = aIntervalOffset; }
/**
* This method generates the next transmission time for the MPL Data Message.
*
* @param[in] aCurrentTime Current time (in milliseconds).
* @param[in] aInterval The current interval size (in milliseconds).
*/
void GenerateNextTransmissionTime(TimeMilli aCurrentTime, uint8_t aInterval);
private:
uint16_t mSeedId;
uint8_t mSequence;
uint8_t mTransmissionCount;
TimeMilli mTransmissionTime;
uint8_t mIntervalOffset;
};
#endif // OPENTHREAD_FTD
/**
* This class implements MPL message processing.
*
@@ -499,7 +333,7 @@ public:
*
*/
const MessageQueue &GetBufferedMessageSet(void) const { return mBufferedMessageSet; }
#endif
#endif // OPENTHREAD_FTD
private:
enum
@@ -522,6 +356,21 @@ private:
uint8_t mSequence;
#if OPENTHREAD_FTD
struct Metadata
{
otError AppendTo(Message &aMessage) const { return aMessage.Append(this, sizeof(*this)); }
void ReadFrom(const Message &aMessage);
void RemoveFrom(Message &aMessage) const;
int UpdateIn(Message &aMessage) const;
void GenerateNextTransmissionTime(TimeMilli aCurrentTime, uint8_t aInterval);
TimeMilli mTransmissionTime;
uint16_t mSeedId;
uint8_t mSequence;
uint8_t mTransmissionCount;
uint8_t mIntervalOffset;
};
static void HandleRetransmissionTimer(Timer &aTimer);
void HandleRetransmissionTimer(void);
@@ -530,7 +379,7 @@ private:
MessageQueue mBufferedMessageSet;
TimerMilli mRetransmissionTimer;
uint8_t mTimerExpirations;
#endif
#endif // OPENTHREAD_FTD
};
/**