包时间戳
简介
每当收到或传输数据包时，许多网络接口卡 (NIC 或网络适配器) 都可以在其硬件中生成时间戳。 时间戳是使用 NIC 自己的硬件时钟生成的。 此功能特别由精确时间协议 (PTP) 使用，这是一种时间同步协议。 PTP 预配以在协议本身中使用此类硬件时间戳。
例如，时间戳可用于计算计算机网络堆栈中的数据包在发送到线路或从线路接收数据包之前所花费的时间。 然后，PTP 可以使用这些计算来提高时间同步的准确性。 网络适配器的数据包时间戳支持有时专门用于 PTP 协议。 在其他情况下，会提供更常规的支持。
时间戳 API 使 Windows 能够支持 PTP 版本 2 协议的网络适配器的硬件时间戳功能。 总的来说，这些功能包括为网络适配器的驱动程序提供支持时间戳的功能，以及用户模式应用程序通过 Windows 套接字 使用与数据包关联的时间戳 (请参阅 Winsock 时间戳) 。 此外，还可以生成软件时间戳，这允许网络驱动程序在软件中生成时间戳。 此类软件时间戳由 NIC 驱动程序使用 与 QueryPerformanceCounter (QPC) 等效的内核模式生成。 但是，不支持同时 启用硬件和软件时间戳 。
具体而言，本主题中所述的 IP 协议帮助程序 (IP 帮助程序) 数据包时间戳 API，使用户模式应用程序能够确定网络适配器的时间戳功能，以及以交叉时间戳的形式从网络适配器查询时间戳， (如下) 所述。
支持精度时间协议版本 2
如前所述，Windows 中时间戳支持的main目标是支持精度时间协议版本 2 (PTPv2) 协议。 在 PTPv2 中，并非所有消息都需要时间戳。 具体而言，PTP 事件消息确实使用时间戳。 目前，支持范围限定为基于用户数据报协议的 PTPv2 (UDP) 。 不支持通过原始以太网进行 PTP。
在 2 步 模式下运行的 PTPv2 支持时间戳。 2 步骤 是指 PTP 数据包中的实际时间戳不是在硬件中动态生成，而是从硬件中检索并作为单独的消息 (传递的模式，例如，使用后续消息) 。
总之，可以在 PTPv2 应用程序中使用 Internet 协议帮助程序 (IP 帮助程序) 数据包时间戳 API 以及 Winsock 的时间戳支持，以提高其时间同步准确性。
检索网络适配器的时间戳功能
PTP 时间同步服务等应用程序需要确定网络适配器的时间戳功能。 然后，使用检索到的功能，应用程序可以决定是否要使用时间戳。
即使网络适配器 确实 支持时间戳，也要求默认关闭此功能。 适配器在指示时打开时间戳。 Windows 为应用程序提供 API 来检索硬件的功能，以及打开的功能。
若要检索网络适配器支持的时间戳功能，请调用 GetInterfaceSupportedTimestampCapabilities 函数， (网络适配器的 LUID) 提供本地唯一标识符，并返回以 INTERFACE_TIMESTAMP_CAPABILITIES 对象的形式检索支持的时间戳功能。
从 GetInterfaceSupportedTimestampCapabilities 返回的代码指示调用是否成功，以及是否检索了填充 INTERFACE_TIMESTAMP_CAPABILITIES 值。
若要检索网络适配器当前启用的时间戳功能，请调用 GetInterfaceActiveTimestampCapabilities 函数， (网络适配器的 LUID) 提供本地唯一标识符，并返回以 INTERFACE_TIMESTAMP_CAPABILITIES 对象的形式检索已启用的时间戳功能。
同样，从 GetInterfaceActiveTimestampCapabilities 返回的代码指示成功还是失败，以及是否检索了有效的 INTERFACE_TIMESTAMP_CAPABILITIES 值。
网络适配器可以支持各种时间戳功能。 例如，某些适配器可以在发送和接收期间对每个数据包进行时间戳，而其他适配器仅支持 PTPv2 数据包。 INTERFACE_TIMESTAMP_CAPABILITIES结构描述了网络适配器支持的确切功能。
从网络适配器检索交叉时间戳
使用硬件时间戳时，PTP 应用程序需要 (建立关系，例如，通过在网络适配器的硬件时钟与系统时钟之间) 适当的数学技术。 这是必需的，以便可以将表示一个时钟单位中的时间的值转换为另一个时钟单位。 为此，提供了交叉时间戳，应用程序可以定期对交叉时间戳进行采样，以建立这种关系。
为此，请调用 CaptureInterfaceHardwareCrossTimestamp 函数， (网络适配器的 LUID) 提供本地唯一标识符，并返回以 INTERFACE_HARDWARE_CROSSTIMESTAMP 对象的形式从网络适配器检索时间戳。
时间戳功能更改通知
若要在网络适配器的时间戳功能发生更改时收到通知，请调用 RegisterInterfaceTimestampConfigChange 函数，提供指向已实现的回调函数的指针，以及调用方分配的可选上下文。
RegisterInterfaceTimestampConfigChange 返回一个句柄，随后可以传递给 UnregisterInterfaceTimestampConfigChange ，以便取消注册回调函数。
代码示例 1 - 检索时间戳功能和交叉时间戳
// main.cpp in a Console App project.
#include <stdio.h>
#include <winsock2.h>
#include <iphlpapi.h>
#pragma comment(lib, "Iphlpapi")
BOOL
IsPTPv2HardwareTimestampingSupportedForIPv4(PINTERFACE_TIMESTAMP_CAPABILITIES timestampCapabilities)
{
// Supported if both receive and transmit side support is present
if (((timestampCapabilities->HardwareCapabilities.PtpV2OverUdpIPv4EventMessageReceive) ||
(timestampCapabilities->HardwareCapabilities.PtpV2OverUdpIPv4AllMessageReceive) ||
(timestampCapabilities->HardwareCapabilities.AllReceive))
&&
((timestampCapabilities->HardwareCapabilities.PtpV2OverUdpIPv4EventMessageTransmit) ||
(timestampCapabilities->HardwareCapabilities.PtpV2OverUdpIPv4AllMessageTransmit) ||
(timestampCapabilities->HardwareCapabilities.TaggedTransmit) ||
(timestampCapabilities->HardwareCapabilities.AllTransmit)))
{
return TRUE;
}
return FALSE;
}
BOOL
IsPTPv2HardwareTimestampingSupportedForIPv6(PINTERFACE_TIMESTAMP_CAPABILITIES timestampCapabilities)
{
// Supported if both receive and transmit side support is present
if (((timestampCapabilities->HardwareCapabilities.PtpV2OverUdpIPv6EventMessageReceive) ||
(timestampCapabilities->HardwareCapabilities.PtpV2OverUdpIPv6AllMessageReceive) ||
(timestampCapabilities->HardwareCapabilities.AllReceive))
&&
((timestampCapabilities->HardwareCapabilities.PtpV2OverUdpIPv6EventMessageTransmit) ||
(timestampCapabilities->HardwareCapabilities.PtpV2OverUdpIPv6AllMessageTransmit) ||
(timestampCapabilities->HardwareCapabilities.TaggedTransmit) ||
(timestampCapabilities->HardwareCapabilities.AllTransmit)))
{
return TRUE;
}
return FALSE;
}
enum SupportedTimestampType
{
TimestampTypeNone = 0,
TimestampTypeSoftware = 1,
TimestampTypeHardware = 2
};
// This function checks and returns the supported timestamp capabilities for an interface for
// a PTPv2 application
SupportedTimestampType
CheckActiveTimestampCapabilitiesForPtpv2(NET_LUID interfaceLuid)
{
DWORD result = NO_ERROR;
INTERFACE_TIMESTAMP_CAPABILITIES timestampCapabilities;
SupportedTimestampType supportedType = TimestampTypeNone;
result = GetInterfaceActiveTimestampCapabilities(
&interfaceLuid,
×tampCapabilities);
if (result != NO_ERROR)
{
printf("Error retrieving hardware timestamp capabilities: %d\n", result);
goto Exit;
}
if (IsPTPv2HardwareTimestampingSupportedForIPv4(×tampCapabilities) &&
IsPTPv2HardwareTimestampingSupportedForIPv6(×tampCapabilities))
{
supportedType = TimestampTypeHardware;
goto Exit;
}
else
{
if ((timestampCapabilities.SoftwareCapabilities.AllReceive) &&
((timestampCapabilities.SoftwareCapabilities.AllTransmit) ||
(timestampCapabilities.SoftwareCapabilities.TaggedTransmit)))
{
supportedType = TimestampTypeSoftware;
}
}
Exit:
return supportedType;
}
// Helper function which does the correlation between hardware and system clock
// using mathematical techniques
void ComputeCorrelationOfHardwareAndSystemTimestamps(INTERFACE_HARDWARE_CROSSTIMESTAMP *crossTimestamp);
// An application would call this function periodically to gather a set
// of matching timestamps for use in converting hardware timestamps to
// system timestamps
DWORD
RetrieveAndProcessCrossTimestamp(NET_LUID interfaceLuid)
{
DWORD result = NO_ERROR;
INTERFACE_HARDWARE_CROSSTIMESTAMP crossTimestamp;
result = CaptureInterfaceHardwareCrossTimestamp(
&interfaceLuid,
&crossTimestamp);
if (result != NO_ERROR)
{
printf("Error retrieving cross timestamp for the interface: %d\n", result);
goto Exit;
}
// Process crossTimestamp further to create a relation between the hardware clock
// of the NIC and the QPC values using appropriate mathematical techniques
ComputeCorrelationOfHardwareAndSystemTimestamps(&crossTimestamp);
Exit:
return result;
}
int main()
{
}
代码示例 2 - 注册时间戳功能更改通知
此示例演示应用程序如何使用端到端时间戳。
// main.cpp in a Console App project.
#include <stdlib.h>
#include <stdio.h>
#include <winsock2.h>
#include <mswsock.h>
#include <iphlpapi.h>
#include <mstcpip.h>
#pragma comment(lib, "Ws2_32")
#pragma comment(lib, "Iphlpapi")
// Globals and function declarations used by the application.
// The sample functions and skeletons demonstrate:
// - Checking timestamp configuration for an interface to determine if timestamping can be used
// - If timestamping is enabled, starts tracking changes in timestamp configuration
// - Performing correlation between hardware and system timestamps using cross timestamps
// on a separate thread depending on the timestamp type configured
// - Receiving a packet and computing the latency between when the timestamp
// was generated on packet reception, and when the packet was received by
// the application through the socket
// The sample tries to demonstrate how an application could use timestamps. It is not thread safe
// and does not do exhaustive error checking.
// Lot of the functions are provided as skeletons, or only declared and invoked
// but are not defined. It is up to
// the application to implement these suitably.
// An application could use the functions below by e.g.
// - Call InitializeTimestampingForInterface for the interface it wants to track for timestamping capability.
// - Call EstimateReceiveLatency to estimate the receive latency of a packet depending on the timestamp
// type configured for the interface.
enum SupportedTimestampType
{
TimestampTypeNone = 0,
TimestampTypeSoftware = 1,
TimestampTypeHardware = 2
};
// interfaceBeingTracked is the interface the PTPv2 application
// intends to use for timestamping purpose.
wchar_t* interfaceBeingTracked;
// The active timestamping type determined for
// interfaceBeingTracked.
SupportedTimestampType timestampTypeEnabledForInterface;
HANDLE correlationThread;
HANDLE threadStopEvent;
HIFTIMESTAMPCHANGE TimestampChangeNotificationHandle = NULL;
// Function from sample above to check if an interface supports timestamping for PTPv2.
SupportedTimestampType CheckActiveTimestampCapabilitiesForPtpv2(NET_LUID interfaceLuid);
// Function from sample above to retrieve cross timestamps and process them further.
DWORD RetrieveAndProcessCrossTimestamp(NET_LUID interfaceLuid);
// Helper function which registers for timestamp configuration changes.
DWORD RegisterTimestampChangeNotifications();
// Callback function which is invoked when timestamp configuration changes
// for some network interface.
INTERFACE_TIMESTAMP_CONFIG_CHANGE_CALLBACK TimestampConfigChangeCallback;
// Function which does the correlation between hardware and system clock
// using mathematical techniques. It is periodically invoked and provided
// a sample of cross timestamp to compute a correlation.
void ComputeCorrelationOfHardwareAndSystemTimestamps(INTERFACE_HARDWARE_CROSSTIMESTAMP *crossTimestamp);
// Helper function which converts a hardware timestamp from the NIC clock
// to system timestamp (QPC) values. It is assumed that this works together
// with the ComputeCorrelationOfHardwareAndSystemTimestamps function
// to derive the correlation.
ULONG64 ConvertHardwareTimestampToQpc(ULONG64 HardwareTimestamp);
// Start function of thread which periodically samples
// cross timestamps to correlate hardware and software timestamps.
DWORD WINAPI CorrelateHardwareAndSystemTimestamps(LPVOID);
// Helper function which starts a new thread at CorrelateHardwareAndSystemTimestamps.
DWORD StartCorrelatingHardwareAndSytemTimestamps();
// Helper function which restarts correlation when some change is detected.
DWORD RestartCorrelatingHardwareAndSystemTimestamps();
// Stops the correlation thread.
DWORD StopCorrelatingHardwareAndSystemTimestamps();
DWORD
FindInterfaceFromFriendlyName(wchar_t* friendlyName, NET_LUID* interfaceLuid)
{
DWORD result = 0;
ULONG flags = 0;
ULONG outBufLen = 0;
PIP_ADAPTER_ADDRESSES pAddresses = NULL;
PIP_ADAPTER_ADDRESSES currentAddresses = NULL;
result = GetAdaptersAddresses(0,
flags,
NULL,
pAddresses,
&outBufLen);
if (result == ERROR_BUFFER_OVERFLOW)
{
pAddresses = (PIP_ADAPTER_ADDRESSES)malloc(outBufLen);
result = GetAdaptersAddresses(0,
flags,
NULL,
pAddresses,
&outBufLen);
if (result != NO_ERROR)
{
goto Done;
}
}
else if (result != NO_ERROR)
{
goto Done;
}
currentAddresses = pAddresses;
while (currentAddresses != NULL)
{
if (wcscmp(friendlyName, currentAddresses->FriendlyName) == 0)
{
result = ConvertInterfaceIndexToLuid(currentAddresses->IfIndex, interfaceLuid);
goto Done;
}
currentAddresses = currentAddresses->Next;
}
result = ERROR_NOT_FOUND;
Done:
if (pAddresses != NULL)
{
free(pAddresses);
}
return result;
}
// This function checks if an interface is suitable for
// timestamping for PTPv2. If so, it registers for timestamp
// configuration changes and initializes some globals.
// If hardware timestamping is enabled it also starts
// correlation thread.
DWORD
InitializeTimestampingForInterface(wchar_t* friendlyName)
{
DWORD error;
SupportedTimestampType supportedType = TimestampTypeNone;
NET_LUID interfaceLuid;
error = FindInterfaceFromFriendlyName(friendlyName, &interfaceLuid);
if (error != 0)
{
return error;
}
supportedType = CheckActiveTimestampCapabilitiesForPtpv2(interfaceLuid);
if (supportedType != TimestampTypeNone)
{
error = RegisterTimestampChangeNotifications();
if (error != NO_ERROR)
{
return error;
}
if (supportedType == TimestampTypeHardware)
{
threadStopEvent = CreateEvent(
NULL,
FALSE,
FALSE,
NULL
);
if (threadStopEvent == NULL)
{
return GetLastError();
}
error = StartCorrelatingHardwareAndSytemTimestamps();
if (error != 0)
{
return error;
}
}
interfaceBeingTracked = friendlyName;
timestampTypeEnabledForInterface = supportedType;
return error;
}
return ERROR_NOT_SUPPORTED;
}
DWORD
RegisterTimestampChangeNotifications()
{
DWORD retcode = NO_ERROR;
// Register with NULL context
retcode = RegisterInterfaceTimestampConfigChange(TimestampConfigChangeCallback, NULL, &TimestampChangeNotificationHandle);
if (retcode != NO_ERROR)
{
printf("Error when calling RegisterIfTimestampConfigChange %d\n", retcode);
}
return retcode;
}
// The callback invoked when change in some interface’s timestamping configuration
// happens. The callback takes appropriate action based on the new capability of the
// interface. The callback assumes that there is only 1 NIC. If multiple NICs are being
// tracked for timestamping then the application would need to check all of them.
VOID
WINAPI
TimestampConfigChangeCallback(
_In_ PVOID /*CallerContext*/
)
{
SupportedTimestampType supportedType;
NET_LUID interfaceLuid;
DWORD error;
error = FindInterfaceFromFriendlyName(interfaceBeingTracked, &interfaceLuid);
if (error != NO_ERROR)
{
if (timestampTypeEnabledForInterface == TimestampTypeHardware)
{
StopCorrelatingHardwareAndSystemTimestamps();
timestampTypeEnabledForInterface = TimestampTypeNone;
}
return;
}
supportedType = CheckActiveTimestampCapabilitiesForPtpv2(interfaceLuid);
if ((supportedType == TimestampTypeHardware) &&
(timestampTypeEnabledForInterface == TimestampTypeHardware))
{
// NIC could have been restarted, restart the correlation between hardware and
// system timestamps.
RestartCorrelatingHardwareAndSystemTimestamps();
}
else if (supportedType == TimestampTypeHardware)
{
// Start thread correlating hardware and software timestamps
StartCorrelatingHardwareAndSytemTimestamps();
}
else if (supportedType != TimestampTypeHardware)
{
// Hardware timestamps are not enabled, stop correlation
StopCorrelatingHardwareAndSystemTimestamps();
}
timestampTypeEnabledForInterface = supportedType;
}
DWORD
StartCorrelatingHardwareAndSytemTimestamps()
{
// Create a new thread which starts at CorrelateHardwareAndSoftwareTimestamps
correlationThread = CreateThread(
NULL,
0,
CorrelateHardwareAndSystemTimestamps,
NULL,
0,
NULL);
if (correlationThread == NULL)
{
return GetLastError();
}
}
// Thread which periodically invokes functions to
// sample cross timestamps and use them to compute
// correlation between hardware and system timestamps.
DWORD WINAPI
CorrelateHardwareAndSystemTimestamps(LPVOID /*lpParameter*/)
{
DWORD error;
NET_LUID interfaceLuid;
DWORD result;
result = FindInterfaceFromFriendlyName(interfaceBeingTracked, &interfaceLuid);
if (result != 0)
{
return result;
}
while (TRUE)
{
error = RetrieveAndProcessCrossTimestamp(interfaceLuid);
// Sleep and repeat till the thread gets a signal to stop
result = WaitForSingleObject(threadStopEvent, 5000);
if (result != WAIT_TIMEOUT)
{
if (result == WAIT_OBJECT_0)
{
return 0;
}
else if (result == WAIT_FAILED)
{
return GetLastError();
}
return result;
}
}
}
DWORD
StopCorrelatingHardwareAndSystemTimestamps()
{
SetEvent(threadStopEvent);
return 0;
}
// Function which receives a packet and estimates the latency between the
// point at which receive timestamp (of appropriate type) was generated
// and when the packet was received in the app through the socket.
// The sample assumes that there is only 1 NIC in the system. This is the NIC which is tracked through
// interfaceBeingTracked for correlation purpose, and through which packets are being
// received by the socket.
// The recvmsg parameter is of type LPFN_WSARECVMSG and an application can
// retrieve it by issuing WSAIoctl
// with SIO_GET_EXTENSION_FUNCTION_POINTER control
// and WSAID_WSARECVMSG. Please refer to msdn.
void EstimateReceiveLatency(SOCKET sock, LPFN_WSARECVMSG recvmsg)
{
DWORD numBytes;
INT error;
CHAR data[512];
CHAR control[WSA_CMSG_SPACE(sizeof(UINT64))] = { 0 };
WSABUF dataBuf;
WSABUF controlBuf;
WSAMSG wsaMsg;
UINT64 socketTimestamp = 0;
ULONG64 appLevelTimestamp;
ULONG64 packetReceivedTimestamp;
dataBuf.buf = data;
dataBuf.len = sizeof(data);
controlBuf.buf = control;
controlBuf.len = sizeof(control);
wsaMsg.name = NULL;
wsaMsg.namelen = 0;
wsaMsg.lpBuffers = &dataBuf;
wsaMsg.dwBufferCount = 1;
wsaMsg.Control = controlBuf;
wsaMsg.dwFlags = 0;
// Configure rx timestamp reception.
TIMESTAMPING_CONFIG config = { 0 };
config.Flags |= TIMESTAMPING_FLAG_RX;
error =
WSAIoctl(
sock,
SIO_TIMESTAMPING,
&config,
sizeof(config),
NULL,
0,
&numBytes,
NULL,
NULL);
if (error == SOCKET_ERROR)
{
printf("WSAIoctl failed %d\n", WSAGetLastError());
return;
}
error =
recvmsg(
sock,
&wsaMsg,
&numBytes,
NULL,
NULL);
if (error == SOCKET_ERROR)
{
printf("recvmsg failed %d\n", WSAGetLastError());
return;
}
if (timestampTypeEnabledForInterface != TimestampTypeNone)
{
// Capture system timestamp (QPC) upon message reception.
LARGE_INTEGER t1;
QueryPerformanceCounter(&t1);
appLevelTimestamp = t1.QuadPart;
printf("received packet\n");
// Look for socket rx timestamp returned via control message.
BOOLEAN retrievedTimestamp = FALSE;
PCMSGHDR cmsg = WSA_CMSG_FIRSTHDR(&wsaMsg);
while (cmsg != NULL)
{
if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SO_TIMESTAMP)
{
socketTimestamp = *(PUINT64)WSA_CMSG_DATA(cmsg);
retrievedTimestamp = TRUE;
break;
}
cmsg = WSA_CMSG_NXTHDR(&wsaMsg, cmsg);
}
if (retrievedTimestamp)
{
// Compute socket receive path latency.
LARGE_INTEGER clockFrequency;
ULONG64 elapsedMicroseconds;
if (timestampTypeEnabledForInterface == TimestampTypeHardware)
{
packetReceivedTimestamp = ConvertHardwareTimestampToQpc(socketTimestamp);
}
else
{
packetReceivedTimestamp = socketTimestamp;
}
QueryPerformanceFrequency(&clockFrequency);
// Compute socket receive path latency.
elapsedMicroseconds = appLevelTimestamp - packetReceivedTimestamp;
elapsedMicroseconds *= 1000000;
elapsedMicroseconds /= clockFrequency.QuadPart;
printf("RX latency estimation: %lld microseconds\n",
elapsedMicroseconds);
}
else
{
printf("failed to retrieve RX timestamp\n");
}
}
}
int main()
{
}
反馈
即将发布：在整个 2024 年，我们将逐步淘汰作为内容反馈机制的“GitHub 问题”，并将其取代为新的反馈系统。 有关详细信息，请参阅：https://aka.ms/ContentUserFeedback。
提交和查看相关反馈