TCP 혼잡 제어

public class TcpRenoSimulator {

    enum Phase { SLOW_START, CONGESTION_AVOIDANCE, FAST_RECOVERY }

    static double cwnd     = 1;   // 혼잡 윈도우 (MSS 단위)
    static double ssthresh = 16;  // Slow Start 임계값
    static Phase  phase    = Phase.SLOW_START;

    // ACK 수신 시 처리
    static void onAck() {
        if (phase == Phase.SLOW_START) {
            cwnd += 1;                      // ACK마다 +1 → RTT마다 2배
            if (cwnd >= ssthresh)
                phase = Phase.CONGESTION_AVOIDANCE;

        } else if (phase == Phase.CONGESTION_AVOIDANCE) {
            cwnd += 1.0 / cwnd;              // ACK마다 1/cwnd → RTT마다 +1

        } else if (phase == Phase.FAST_RECOVERY) {
            cwnd += 1;                      // 추가 Dup ACK마다 +1
        }
    }

    // 3개 중복 ACK 감지 → Fast Retransmit + Fast Recovery
    static void onThreeDupAck() {
        ssthresh = Math.max(cwnd / 2, 2);  // ssthresh = cwnd / 2
        cwnd     = ssthresh + 3;            // cwnd = ssthresh + 3 (Dup ACK 3개 반영)
        phase    = Phase.FAST_RECOVERY;
        // 손실 패킷 즉시 재전송 (Fast Retransmit)
    }

    // Fast Recovery 완료 (새 ACK 수신)
    static void onNewAckInFastRecovery() {
        cwnd  = ssthresh;                  // cwnd = ssthresh로 복귀
        phase = Phase.CONGESTION_AVOIDANCE;
    }

    // 타임아웃 → Slow Start 재시작
    static void onTimeout() {
        ssthresh = Math.max(cwnd / 2, 2);  // ssthresh = cwnd / 2
        cwnd     = 1;                      // cwnd = 1 MSS로 리셋
        phase    = Phase.SLOW_START;        // Slow Start 재시작
    }

    public static void main(String[] args) {
        System.out.printf("%-5s %-8s %-10s %-20s%n",
                          "RTT", "cwnd", "ssthresh", "Phase");
        for (int rtt = 1; rtt <= 20; rtt++) {
            System.out.printf("%-5d %-8.1f %-10.1f %-20s%n",
                              rtt, cwnd, ssthresh, phase);

            // 시뮬레이션: RTT 10에서 3-Dup ACK, RTT 15에서 타임아웃
            if (rtt == 10) onThreeDupAck();
            else if (rtt == 11) onNewAckInFastRecovery(); // 새 ACK 수신 → cwnd=ssthresh로 deflate 후 CA 복귀
            else if (rtt == 15) onTimeout();
            else {
                int acksPerRtt = (int) cwnd;
                for (int a = 0; a < acksPerRtt; a++) onAck();
            }
        }
    }
}

import socket
import struct
import subprocess

# ── Linux TCP 혼잡 제어 알고리즘 확인 ───────────────────
def get_tcp_congestion_info():
    # 현재 사용 중인 혼잡 제어 알고리즘
    with open('/proc/sys/net/ipv4/tcp_congestion_control') as f:
        algo = f.read().strip()
    print(f"혼잡 제어 알고리즘: {algo}")  # cubic (Linux 기본)

    # 사용 가능한 알고리즘 목록
    with open('/proc/sys/net/ipv4/tcp_available_congestion_control') as f:
        available = f.read().strip()
    print(f"사용 가능: {available}")

    # 초기 cwnd 크기 (기본값: 10 MSS)
    result = subprocess.run(
        ['ip', 'route', 'show'], capture_output=True, text=True
    )
    print(result.stdout)  # initcwnd 10 표시됨

# ── TCP 소켓 혼잡 제어 정보 (TCP_INFO) ─────────────────
def get_socket_tcp_info(sock):
    # TCP_INFO 구조체 (Linux): 혼잡 윈도우 포함
    TCP_INFO = 11
    info = sock.getsockopt(socket.IPPROTO_TCP, TCP_INFO, 104)

    # 주요 필드 파싱 (오프셋은 Linux 커널 버전에 따라 다름)
    fields = struct.unpack('B' * 8 + 'I' * 24, info[:104])
    state        = fields[0]   # TCP 상태
    snd_cwnd     = fields[14]  # 송신 혼잡 윈도우 (MSS 단위)
    snd_ssthresh = fields[15]  # ssthresh
    rtt          = fields[16]  # RTT (마이크로초)
    rttvar       = fields[17]  # RTT 분산

    print(f"cwnd: {snd_cwnd} MSS")
    print(f"ssthresh: {snd_ssthresh}")
    print(f"RTT: {rtt/1000:.2f}ms")

# ── 혼잡 제어 알고리즘 변경 (root 권한 필요) ───────────
# $ sysctl -w net.ipv4.tcp_congestion_control=bbr
# $ sysctl -w net.ipv4.tcp_congestion_control=cubic
# $ sysctl -w net.ipv4.tcp_congestion_control=reno

# ── ss 명령으로 실시간 cwnd 모니터링 ───────────────────
# $ watch -n 0.5 'ss -tin | grep cwnd'
# → cwnd:10 ssthresh:7 send 14.2Mbps ...