class SlowStart:
    """慢启动算法"""
    
    def __init__(self, ssthresh=65535):
        self.cwnd = 1  # MSS
        self.ssthresh = ssthresh
    
    def on_ack(self, acked_bytes):
        """收到 ACK 时更新 cwnd"""
        # 每收到一个 ACK，cwnd += MSS
        # 等效于每个 RTT 翻倍
        mss = 1460
        self.cwnd += (acked_bytes / mss) * 1
        
        if self.cwnd >= self.ssthresh:
            return "CONGESTION_AVOIDANCE"
        return "SLOW_START"

class CongestionAvoidance:
    """拥塞避免算法"""
    
    def __init__(self, cwnd, ssthresh):
        self.cwnd = cwnd
        self.ssthresh = ssthresh
    
    def on_ack(self, acked_bytes):
        """收到 ACK 时更新 cwnd"""
        mss = 1460
        # 线性增长：每个 RTT 增加 1 MSS
        self.cwnd += (acked_bytes * mss) / self.cwnd

class RenoCongestionControl:
    """Reno 拥塞控制算法"""
    
    SLOW_START = "slow_start"
    CONGESTION_AVOIDANCE = "congestion_avoidance"
    FAST_RECOVERY = "fast_recovery"
    
    def __init__(self):
        self.cwnd = 1.0 * 1460  # 1 MSS
        self.ssthresh = 65535
        self.state = self.SLOW_START
        self.dup_ack_count = 0
    
    def on_ack(self, ack_num, new_data=False):
        """收到 ACK"""
        if self.state == self.SLOW_START:
            if new_data:
                self.cwnd += 1460  # 每个 ACK 增加 1 MSS
                self.dup_ack_count = 0
                if self.cwnd >= self.ssthresh:
                    self.state = self.CONGESTION_AVOIDANCE
            else:
                self.dup_ack_count += 1
                if self.dup_ack_count >= 3:
                    self.ssthresh = self.cwnd / 2
                    self.cwnd = self.ssthresh + 3 * 1460
                    self.state = self.FAST_RECOVERY
        
        elif self.state == self.CONGESTION_AVOIDANCE:
            if new_data:
                self.cwnd += 1460 * (1460 / self.cwnd)
                self.dup_ack_count = 0
            else:
                self.dup_ack_count += 1
                if self.dup_ack_count >= 3:
                    self.ssthresh = self.cwnd / 2
                    self.cwnd = self.ssthresh + 3 * 1460
                    self.state = self.FAST_RECOVERY
        
        elif self.state == self.FAST_RECOVERY:
            if new_data:
                self.cwnd = self.ssthresh
                self.dup_ack_count = 0
                self.state = self.CONGESTION_AVOIDANCE
            else:
                self.cwnd += 1460  # 每个重复 ACK 增加 1 MSS
    
    def on_timeout(self):
        """超时"""
        self.ssthresh = self.cwnd / 2
        self.cwnd = 1460  # 回到 1 MSS
        self.dup_ack_count = 0
        self.state = self.SLOW_START

import math

class CUBIC:
    """CUBIC 拥塞控制算法"""
    
    C = 0.4
    BETA = 0.7
    
    def __init__(self):
        self.cwnd = 1460.0  # 1 MSS
        self.wmax = 0       # 上次丢包时的窗口
        self.k = 0          # 时间偏移
        self.epoch_start = 0  # 当前周期开始时间
    
    def on_loss(self):
        """丢包时"""
        self.wmax = self.cwnd
        self.cwnd = self.cwnd * (1 - self.BETA)
        self.k = (self.wmax * self.BETA / self.C) ** (1/3)
        self.epoch_start = 0  # 重置 epoch
    
    def update_cwnd(self, t):
        """更新窗口大小（每个 ACK 调用）"""
        if self.epoch_start == 0:
            self.epoch_start = t
        
        elapsed = t - self.epoch_start
        target = self.C * ((elapsed - self.k) ** 3) + self.wmax
        
        if target > self.cwnd:
            self.cwnd = target
        else:
            # 确保至少和标准 TCP 一样快
            self.cwnd += 1460 / self.cwnd

# 模拟 CUBIC 增长
cubic = CUBIC()
cubic.cwnd = 100 * 1460  # 初始 100 MSS
cubic.wmax = 200 * 1460  # 丢包时 200 MSS

print("CUBIC 窗口增长曲线：")
for t in range(0, 10):
    cubic.update_cwnd(t)
    mss = cubic.cwnd / 1460
    print(f"t={t}: cwnd={mss:.1f} MSS")

# 启用 BBR
$ sudo sysctl -w net.ipv4.tcp_congestion_control=bbr

# 加载 BBR 模块
$ sudo modprobe tcp_bbr

# 验证
$ sysctl net.ipv4.tcp_congestion_control
net.ipv4.tcp_congestion_control = bbr

# 查看当前拥塞控制算法
$ sysctl net.ipv4.tcp_congestion_control
net.ipv4.tcp_congestion_control = cubic

# 可用算法
$ sysctl net.ipv4.tcp_available_congestion_control
net.ipv4.tcp_available_congestion_control = reno cubic bbr

# 设置默认算法
$ sudo sysctl -w net.ipv4.tcp_congestion_control=bbr

# 持久化配置
$ echo "net.ipv4.tcp_congestion_control = bbr" | sudo tee -a /etc/sysctl.d/99-tcp.conf

# 初始拥塞窗口大小
$ sysctl net.ipv4.tcp_init_cwnd

"""
拥塞控制对应用的影响：

1. 上传大文件时，速度受 cwnd 限制
2. 跨洋连接需要更大的窗口
3. 切换拥塞控制算法可能影响性能
"""

def estimate_transfer_time(file_size_mb, rtt_ms, cwnd_init_kb=10):
    """估算文件传输时间"""
    cwnd = cwnd_init_kb * 1024  # bytes
    rtt = rtt_ms / 1000
    transferred = 0
    time_elapsed = 0
    
    while transferred < file_size_mb * 1024 * 1024:
        # 每个 RTT 能发送的数据量
        send_size = cwnd
        transferred += send_size
        time_elapsed += rtt
        
        # 慢启动：每个 RTT 翻倍（直到 ssthresh）
        cwnd = min(cwnd * 2, 10 * 1024 * 1024)
    
    return time_elapsed

# 不同 RTT 的传输时间
for rtt in [10, 50, 100, 200]:
    t = estimate_transfer_time(100, rtt)  # 100MB
    print(f"RTT={rtt}ms: 传输 100MB 约需 {t:.1f} 秒")