パケットタイムスタンプ

[アーティクル]
06/13/2023

はじめに

多くのネットワークインターフェイスカード (NIC、またはネットワークアダプター) では、パケットが受信または送信されるたびに、ハードウェアでタイムスタンプを生成できます。タイムスタンプは、NIC 独自のハードウェアクロックを使用して生成されます。この機能は、特に時刻同期プロトコルである高精度タイムプロトコル (PTP) によって使用されます。 PTP は、プロトコル自体内でこのようなハードウェアタイムスタンプを使用するためのプロビジョニングを行います。

たとえば、タイムスタンプを使用して、ネットワークに送受信される前に、マシンのネットワークスタック内のパケットによって費やされた時間を計算できます。これらの計算を PTP で使用して、時刻同期の精度を向上させることができます。ネットワークアダプターのパケットタイムスタンプのサポートは、PTP プロトコル専用の場合があります。それ以外の場合は、より一般的なサポートが提供されます。

タイムスタンプ API を使用すると、Windows は PTP バージョン 2 プロトコルのネットワークアダプターのハードウェアタイムスタンプ機能をサポートできます。全体的に、ネットワークアダプターのドライバーがタイムスタンプをサポートする機能や、ユーザーモードアプリケーションが Windows ソケットを介してパケットに関連付けられているタイムスタンプを使用する機能の提供が含まれます ( Winsock タイムスタンプに関するページを参照)。さらに、ソフトウェアのタイムスタンプを生成する機能も利用できます。これにより、ネットワークドライバーはソフトウェアでタイムスタンプを生成できます。このようなソフトウェアタイムスタンプは、 QueryPerformanceCounter (QPC) と同等のカーネルモードを使用して NIC ドライバーによって生成されます。ただし、ハードウェア タイムスタンプと ソフトウェアタイムスタンプの両方を一緒に有効にすることはサポートされていません。

特に、このトピックで説明するインターネットプロトコルヘルパー (IP ヘルパー) パケットタイムスタンプ API は、ユーザーモードアプリケーションがネットワークアダプターのタイムスタンプ機能を判断し、クロスタイムスタンプの形式でネットワークアダプターからタイムスタンプを照会する機能を提供します (後述)。

高精度タイムプロトコルバージョン 2 のサポート

前述のように、Windows でのタイムスタンプのサポートのメインの目標は、高精度タイムプロトコルバージョン 2 (PTPv2) プロトコルをサポートすることです。 PTPv2 内では、すべてのメッセージにタイムスタンプが必要なわけではありません。特に、PTP イベントメッセージではタイムスタンプが使用されます。現在、サポートのスコープは、ユーザーデータグラムプロトコル (UDP) 経由の PTPv2 です。生イーサネット経由の PTP はサポートされていません。

タイムスタンプは、 2 ステップ モードで動作する PTPv2 でサポートされています。 2 ステップ は、PTP パケット内の実際のタイムスタンプがハードウェア内でその場で生成されず、代わりにハードウェアから取得され、別のメッセージとして伝達されるモードを指します (たとえば、フォローアップメッセージを使用)。

要約すると、PTPv2 アプリケーションでは、インターネットプロトコルヘルパー (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,
                 &timestampCapabilities);
    if (result != NO_ERROR)
    {
        printf("Error retrieving hardware timestamp capabilities: %d\n", result);
        goto Exit;
    }

    if (IsPTPv2HardwareTimestampingSupportedForIPv4(&timestampCapabilities) &&
        IsPTPv2HardwareTimestampingSupportedForIPv6(&timestampCapabilities))
    {
        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()
{
}

次の方法で共有

パケットタイムスタンプ

はじめに

高精度タイムプロトコルバージョン 2 のサポート

ネットワークアダプターのタイムスタンプ機能の取得

ネットワークアダプターからのクロスタイムスタンプの取得

タイムスタンプ機能の変更通知

コード例 1 — タイムスタンプ機能とクロスタイムスタンプの取得

コード例 2 — タイムスタンプ機能変更通知の登録

フィードバック

フィードバック

その他のリソース

次の方法で共有

パケット タイムスタンプ

はじめに

高精度タイム プロトコル バージョン 2 のサポート

ネットワーク アダプターのタイムスタンプ機能の取得

ネットワーク アダプターからのクロス タイムスタンプの取得

タイムスタンプ機能の変更通知

コード例 1 — タイムスタンプ機能とクロス タイムスタンプの取得

コード例 2 — タイムスタンプ機能変更通知の登録

フィードバック

フィードバック

その他のリソース

パケットタイムスタンプ

高精度タイムプロトコルバージョン 2 のサポート

ネットワークアダプターのタイムスタンプ機能の取得

ネットワークアダプターからのクロスタイムスタンプの取得

コード例 1 — タイムスタンプ機能とクロスタイムスタンプの取得