Pdelay = ((t6-t3)-(t5-t4))/2        
Gm = t1 + Pdelay + CorrectionField // 主时钟时刻+线缆传输时间+路由报文花销掉的时间
TimeOffset = t2 - Gm //用于调相或者调幅

Ratio = (Gm-Gm_last) / (t2-t2_last) //Gm_last和t2_last可以更久之前的。
FreqOffset = (1-Ratio)*1e9//用于调频

根据规范，sync报文一般是125ms发送一次；而Pdelay报文是1s发送一次，也可以是每次sync报文触发一次Pdelay报文，并且一般来说说同步精度是可配置的，当超过threshold时才去调整本地时钟。gptp调整的时钟（gptp时钟），是与网卡时钟源同一层级的时钟树端点，在linux上一般会抽象成设备，也就是/dev/ptpx；在使用硬件时钟戳时，当网络报文发送或者接收时的采样点到达时，会从gptp时钟上获取时间戳。采样点如下图所示：

// get t1, t2, t3, t4, t5, t6, adjust clock with /dev/ptp0
int clock_fd = open("/dev/ptp0", O_RDWR);
int RecvMsg(std::chrono::nanoseconds& hw_timestamp,
            std::array<std::uint8_t, MAX_PTP_LENGTH>& message, int flag)
{
    recvmsg(sock_fd, message, flag);
    // get hardware timestamp
    for (struct cmsghdr* control_message = CMSG_FIRSTHDR(&message);
         control_message;
         control_message = CMSG_NXTHDR(&message, control_message)) {
        if ((control_message->cmsg_level) == SOL_SOCKET) {
            // Fetch the Sync Rx/Tx timestamp
            if ((control_message->cmsg_type) == SO_TIMESTAMPING) {
                struct scm_timestamping* stamp =
                        (struct scm_timestamping*)CMSG_DATA(control_message);
                hw_timestamp = timespecToDuration(
                        stamp->ts[m_soTsConfig.tx_scm_ts_record_index]);
            }
        }
    }
}
// get t2
int OnSyncMsg(std::chrono::nanoseconds& t2)
{
    std::array<std::uint8_t, MAX_PTP_LENGTH> message;
    return RecvMsg(t2, message, 0);
}

// get t1, correction and adjust clock
int OnFollowUpMsg(std::chrono::nanoseconds& t1)
{
    std::array<std::uint8_t, MAX_PTP_LENGTH> message;
    std::chrono::nanoseconds unuse_timestamp;
    auto ret = RecvMsg(unuse_timestamp, message, 0);
    std::unique_ptr<PtpSlaveMsg> ptp_msg =
            std::make_unique<PtpSlaveMsg>(message);
    t1 = PtpSlaveMsg->GetPreciseOriginTimestamp();
    auto correction = PtpSlaveMsg->getCorrectionField();

    auto CaculateOffset = [
        t1, correction, &Gm, &ratio
    ](std::chrono::nanoseconds t2, std::chrono::nanoseconds pdelay) -> auto
    {
        Gm = t1 + pdelay + correction;
        ratio = (Gm - Gm_lat) / (t2 - t2_last);
        return (t2 - Gm);
    };
    auto AdjustClock = [ratio](std::chrono::nanoseconds offset) {
        AdjustClockOffset(offset);
        adjustClockFreq(ratio);
    };
    if (auto offset = CaculateOffset() > threshold) {
        AdjustClock(offset);
    }
    Gm_last = Gm;
    t2_last = t2;
}
// get t3
int SendPdelayReq()
{
    SetTriggerTimeStamp(pdelay_msg);
    auto ret = sendmsg(sock_fd, pdelay_msg, 0);
    GetTimestampWithSendmsg(t3)
    {
        std::array<std::uint8_t, MAX_PTP_LENGTH> message;
        RecvMsg(socket_fd, message, MSG_ERRQUEUE)
    }
}
// get t4, t6
int OnPdelayResp(std::chrono::nanoseconds& t4, std::chrono::nanoseconds& t6)
{
    std::array<std::uint8_t, MAX_PTP_LENGTH> message;
    auto ret = RecvMsg(t4, message, 0);
    std::unique_ptr<PtpSlaveMsg> ptp_msg =
            std::make_unique<PtpSlaveMsg>(message);
    t6 = PtpSlaveMsg->GetPreciseOriginTimestamp();
}

// get t5 and  pdelay
int OnPdelayResp(std::chrono::nanoseconds& pdelay)
{
    std::array<std::uint8_t, MAX_PTP_LENGTH> message;
    std::chrono::nanoseconds unuse_timestamp;
    auto ret = RecvMsg(unuse_timestamp, message, 0);
    std::unique_ptr<PtpSlaveMsg> ptp_msg =
            std::make_unique<PtpSlaveMsg>(message);
    t5 = PtpSlaveMsg->GetPreciseOriginTimestamp();

    pdelay = ((t6 - t3) - (t5 - t4)) / 2
}

int clock_fd = open("/dev/ptp0", O_RDWR);
int RecvMsg(std::chrono::nanoseconds & hw_timestamp,
            std::array<std::uint8_t, MAX_PTP_LENGTH> & message, int flag)
{
    recvmsg(sock_fd, message, flag);
    // get hardware timestamp
    for (struct cmsghdr* control_message = CMSG_FIRSTHDR(&message);
            control_message;
            control_message = CMSG_NXTHDR(&message, control_message)) {
        if ((control_message->cmsg_level) == SOL_SOCKET) {
            // Fetch the Sync Rx/Tx timestamp
            if ((control_message->cmsg_type) == SO_TIMESTAMPING) {
                struct scm_timestamping* stamp =
                        (struct scm_timestamping*)CMSG_DATA(
                                control_message);
                hw_timestamp = timespecToDuration(
                        stamp->ts[m_soTsConfig.tx_scm_ts_record_index]);
            }
        }
    }
}

// get t1
int SendSyncMsg(std::chrono::nanoseconds & t1)
{
    SetTriggerTimeStamp(sync_msg);
    auto ret = sendmsg(sock_fd, sync_msg, 0);
    GetTimestampWithSendmsg(t1)
    {
        std::array<std::uint8_t, MAX_PTP_LENGTH> message;
        RecvMsg(socket_fd, message, MSG_ERRQUEUE)
    }
}

// get t5
int SendPdelayRespMsg(std::chrono::nanoseconds & t5)
{
    SetTriggerTimeStamp(fup_msg);
    auto ret = sendmsg(sock_fd, req_msg, 0);
    GetTimestampWithSendmsg(t5)
    {
        std::array<std::uint8_t, MAX_PTP_LENGTH> message;
        RecvMsg(socket_fd, message, MSG_ERRQUEUE)
    }
}
// sedn t5
int SendPdelayFupMsg()
{
    SetPreciseOriginTimestamp(t5);  // set t4
    auto ret = sendmsg(sock_fd, fup_msg, 0);
}

// get t4 and send t4
int OnPdelayReq(std::chrono::nanoseconds & t5)
{
    std::array<std::uint8_t, MAX_PTP_LENGTH> message;
    std::chrono::nanoseconds t4;
    auto ret = RecvMsg(t4, message, 0);  // get t4
    SetPreciseOriginTimestamp(t4);       // set t4
    SendPdelayRespMsg(t5);                // send pdelay response with t4
    SendPdelayFupMsg();
}