计算机网络进化论：从比特流到量子通信的深层解构

原创

于 2025-03-17 12:00:00 发布 · 1.2k 阅读

标签

#计算机网络

第一章物理媒介与链路层（1960-1970）

1.1 比特流物理编码

// 曼彻斯特编码实现
vector<bool> manchester_encode(uint8_t byte) {
   
   
    vector<bool> bits;
    for(int i=7; i>=0; --i) {
   
   
        bool bit = (byte >> i) & 1;
        bits.push_back(bit);  // 前半周期
        bits.push_back(!bit); // 后半周期
    }
    return bits;
}

物理层关键参数：

波特率：300-9600 baud
误码率：10^-4（铜缆） vs 10^-9（光纤）
同步机制：前导码检测（1010交替模式）

代码解析：

曼彻斯特编码通过电平跳变解决时钟同步问题，每个比特周期中间必然发生跳变：
• bit表示原始数据位（0或1）
• bits.push_back(bit)对应前半周期电平
• bits.push_back(!bit)产生后半周期的反向电平
这种编码方式使10Mbps以太网的波特率达到20Mbaud，但牺牲了50%的带宽效率。前导码（56位交替1010…）帮助接收端建立时钟同步。

1.2 以太网帧深度解析

┌─────────┬─────────┬─────────┬─────┬─────────┐
│ 前导码  │ 帧起始符 │ 目标MAC │ 源MAC │ 类型   │ 数据(46-1500B) │ CRC32 │
├─────────┼─────────┼─────────┼─────┼─────────┤
│ 7字节   │ 1字节   │ 6字节   │6字节│ 2字节   │ 变长           │4字节  │
└─────────┴─────────┴─────────┴─────┴─────────┘

// CSMA/CD伪代码实现
void transmit_frame(Frame f) {
   
   
    while(true) {
   
   
        if(carrier_sense() == IDLE) {
   
   
            send(f);
            while(!collision_detect()) {
   
   
                if(transmission_complete()) return;
            }
            send_jam_signal();
            backoff_time = calculate_backoff();
            sleep(backoff_time);
        }
    }
}

机制详解：
冲突检测多路访问（CSMA/CD）是早期以太网的核心：

载波侦听：检测信道是否空闲（物理层电压检测）
冲突检测：发送同时监听信道，若检测到异常电压则判定冲突
退避算法：采用二进制指数退避（BEB），冲突次数n对应的等待时间为rand(0, 2^n - 1) * slot_time
该机制使得10BASE5网络的端到端传播延迟必须小于512位时（51.2μs），限制了网络直径不超过2500米。

第二章网络层革命（1974-1981）

2.1 IP协议解剖

// IP头结构体（兼容IPv4/v6）
struct IPHeader {
   
   
#if IPV4
    uint8_t version:4, ihl:4;
    uint8_t tos;
    uint16_t total_length;
    uint16_t identification;
    uint16_t frag_off:13, flags:3;
    uint8_t ttl;
    uint8_t protocol;
    uint16_t checksum;
    uint32_t saddr;
    uint32_t daddr;
#else 
    uint32_t flow_label:20, version:4, traffic_class:8;
    uint16_t payload_length;
    uint8_t next_header;
    uint8_t hop_limit;
    uint128_t saddr;
    uint128_t daddr;
#endif
};

MTU分片算法：

vector<IPFragment> fragment_packet(IPPacket p, uint16_t mtu) {
   
   
    vector<IPFragment> fragments;
    uint16_t header_len = p.header.ihl * 4;
    uint16_t max_data = mtu - header_len;
    uint16_t offset = 0;
    
    while(offset < p.payload.size()) {
   
   
        uint16_t frag_size = min(max_data, p.payload.size() - offset);
        bool more_frag = (offset