# 延迟确认的工作方式
# 接收方不会立即发送 ACK，而是等待一段时间

"""
延迟确认的目的：
1. 减少网络中的小包数量
2. 可以和数据一起发送（ACK 搭载数据）

延迟时间：
• 通常 40-200ms
• 最多等待 2 个段

问题：可能与 Nagle 算法互相等待
解决方案：TCP_NODELAY 选项
"""

def calculate_rto(srtt, rttvar):
    """
    计算重传超时时间 (RTO)
    
    基于 RFC 6298 算法：
    SRTT = 平滑 RTT
    RTTVAR = RTT 偏差
    """
    # RTO = SRTT + max(G, 4*RTTVAR)
    # G = 时钟粒度（通常 1ms）
    G = 0.001
    rto = srtt + max(G, 4 * rttvar)
    
    # 限制范围：1秒 - 60秒
    return max(1.0, min(60.0, rto))

def update_rtt(srtt, rttvar, measured_rtt):
    """更新 RTT 估计值"""
    alpha = 0.125  # 1/8
    beta = 0.25    # 1/4
    
    # RTTVAR = (1 - beta) * RTTVAR + beta * |SRTT - R|
    rttvar = (1 - beta) * rttvar + beta * abs(srtt - measured_rtt)
    
    # SRTT = (1 - alpha) * SRTT + alpha * R
    srtt = (1 - alpha) * srtt + alpha * measured_rtt
    
    return srtt, rttvar

# 示例
srtt = 0.1    # 初始 RTT 100ms
rttvar = 0.05 # 初始偏差 50ms

for measured in [0.1, 0.12, 0.09, 0.5, 0.1]:  # 模拟 RTT 变化
    srtt, rttvar = update_rtt(srtt, rttvar, measured)
    rto = calculate_rto(srtt, rttvar)
    print(f"RTT={measured:.3f}s, SRTT={srtt:.3f}s, RTO={rto:.3f}s")

class FastRetransmit:
    """快速重传示例"""
    
    def __init__(self):
        self.dup_ack_count = {}  # {seq: count}
        self.threshold = 3       # 重复 ACK 阈值
    
    def on_ack_received(self, ack_num):
        """收到 ACK 时的处理"""
        if ack_num in self.dup_ack_count:
            self.dup_ack_count[ack_num] += 1
            
            if self.dup_ack_count[ack_num] >= self.threshold:
                # 触发快速重传
                return True
        else:
            # 新的 ACK，重置计数
            self.dup_ack_count.clear()
            self.dup_ack_count[ack_num] = 1
        
        return False

def parse_sack_block(data):
    """解析 SACK 块"""
    import struct
    
    blocks = []
    for i in range(0, len(data), 8):
        if i + 8 <= len(data):
            left, right = struct.unpack('!II', data[i:i+8])
            blocks.append((left, right))
    return blocks

# 示例
sack_data = b'\x00\x00\x0B\xB8\x00\x00\x13\x88'  # 3000-5000
blocks = parse_sack_block(sack_data)
print(f"SACK 块: {blocks}")  # [(3000, 5000)]

class SlidingWindow:
    """滑动窗口实现"""
    
    def __init__(self, window_size):
        self.window_size = window_size
        self.base = 0          # 窗口基序号（最早未确认）
        self.next_seq = 0      # 下一个要发送的序列号
        self.buffer = {}       # 已发送未确认的数据
    
    def can_send(self):
        """是否可以发送数据"""
        return self.next_seq < self.base + self.window_size
    
    def send(self, data):
        """发送数据"""
        if not self.can_send():
            return False
        
        seq = self.next_seq
        self.buffer[seq] = data
        self.next_seq += len(data)
        return seq
    
    def receive_ack(self, ack_num):
        """收到 ACK"""
        # 累积确认：释放 ack_num 之前的所有数据
        while self.base < ack_num:
            if self.base in self.buffer:
                del self.buffer[self.base]
            self.base += 1
    
    @property
    def available_window(self):
        """可用窗口大小"""
        return self.window_size - (self.next_seq - self.base)

def calculate_throughput(window_size, rtt):
    """
    计算最大吞吐量
    
    吞吐量 = 窗口大小 / RTT
    """
    throughput = window_size / rtt
    throughput_mbps = throughput * 8 / 1_000_000
    return throughput_mbps

# 不同窗口大小和 RTT 的吞吐量
print("窗口大小 | RTT 10ms | RTT 100ms | RTT 200ms")
print("-" * 50)
for window in [16384, 65535, 131072, 1048576]:  # 16K, 64K, 128K, 1M
    t10 = calculate_throughput(window, 0.01)
    t100 = calculate_throughput(window, 0.1)
    t200 = calculate_throughput(window, 0.2)
    print(f"{window:>8} | {t10:>7.1f} | {t100:>8.1f} | {t200:>8.1f} Mbps")

# 查看重传统计
$ netstat -s | grep -i retrans
    123 segments retransmitted
    45 fast retransmits

# 调整重传参数
# 最大重传次数（默认15）
$ sysctl net.ipv4.tcp_retries2
net.ipv4.tcp_retries2 = 15

# 早超时检测（Early Retransmit）
$ sysctl net.ipv4.tcp_early_retrans
net.ipv4.tcp_early_retrans = 3

# RACK（Recent ACKnowledgment）
$ sysctl net.ipv4.tcp_recovery
net.ipv4.tcp_recovery = 1