网络传输-平滑发送

山水阳泉曲

已于 2024-08-29 14:34:55 修改

阅读量1.1k

点赞数 19

文章标签：网络开发语言 udp webrtc 算法

于 2024-08-29 11:39:54 首次发布

本文链接：https://blog.csdn.net/zhangdonghuirjdd/article/details/141671131

版权

文章目录

需求
实现
- 平滑发送的作用
- 常用方法
优先级队列
最小堆
漏桶算法+优先级
- 测试代码
相同优先级数据包处理
实际使用

需求

在网络传输中，数据包实际是突发的，这可能会导致一些问题，比如网络拥塞、缓冲区膨胀，甚至是数据包丢失，为了解决这些问题需要在发送数据的时候尽可能保证平滑。

“平滑发送”通常指的是控制数据包的发送速率，使其在网络中的分布更加均匀，从而减少网络拥塞的可能性。这对于实时应用特别重要，比如视频会议、在线游戏等场景中，需要发送一个视频轨道和一个音频轨道，如果一次将一个视频帧发送到网络上，并且这些数据包假设需要 100ms 达到对端——这意味着你现在阻塞了任何音频数据包及时到达远端
接收端为了保证音画同步会出现延时

实现

平滑发送的作用

减少网络拥塞：通过控制数据包的发送速率，可以降低网络拥塞的风险，提高数据传输的质量。
改善用户体验：对于实时应用来说，平滑的数据流可以减少延迟和抖动，提供更好的用户体验。
资源利用效率：合理分配带宽资源，确保所有连接都能获得足够的服务而不浪费网络资源

常用方法

固定间隔发送：这是最简单的方法，即每隔一定的时间间隔发送一定数量数据包。这种方法适用于对实时性要求不高的应用。
效果：容易实现，但在网络状况变化时可能不够灵活。
基于窗口的算法：
滑动窗口：维护一个发送窗口，根据接收端的反馈调整窗口大小。这通常结合流量控制机制、带框估算使用
效果：比固定间隔发送更智能，能够更好地适应网络变化。
自适应速率控制：
动态调整发送速率：根据网络条件（如丢包率、往返时间RTT等）动态调整发送速率。
效果：能够较好地应对网络波动，提供更稳定的传输质量。
基于预测的算法：
预测网络状况：通过对历史数据的分析，预测未来的网络状况，从而提前调整发送策略。
效果：需要复杂的计算，但能提供较高的服务质量

优先级队列

在网络传输中，采用平滑发送首先要保证的就是数据的发送顺序优先级队列可以用来确保具有较高优先级的数据包能够被优先处理。
这在实时通信、视频流传输等场景中尤为重要，因为这些应用往往对延迟敏感。
比如在游戏或者音视频实时通信场景中
优先级要求
指令包>音频包 > 重传包 > 视频包 > FEC 包

优先级队列是一种常用的数据结构，其中元素具有不同的优先级。队列中的元素按照其优先级排序，当从队列中移除元素时，总是移除具有最高优先级的元素。
例子：

Python 标准库中的 heapq
模块提供了一个高效的最小堆实现，可以用来构建优先级队列。最小堆的特点是父节点的值小于或等于其子节点的值，因此堆顶元素总是最小的。我们可以通过给每个数据包分配一个优先级（例如，越小的数值表示越高的优先级），并使用
heapq 来管理这些数据包

import heapq
import time
import random

class Packet:
    def __init__(self, id, priority):
        self.id = id
        self.priority = priority # 优先级

    def __lt__(self, other):
        # 为了使 Packet 类能够被 heapq 使用，我们需要定义比较操作
        return self.priority < other.priority

def send_packet(packet):
    print(f"Sending packet {packet.id} with priority {packet.priority}")

def main():
    priority_queue = []
    packets_sent = 0
    # 模拟数据包到达
    for i in range(10):
        priority = random.randint(1, 10)
        packet = Packet(i, priority)
        heapq.heappush(priority_queue, packet)
        print(f"Packet {i} with priority {priority} added to the queue.")

    # 模拟发送过程
    while priority_queue:
        # 每隔一段时间检查队列并发送最高优先级的数据包
        time.sleep(0.5)  # 模拟发送间隔
        if priority_queue:
            highest_priority_packet = heapq.heappop(priority_queue)
            send_packet(highest_priority_packet)
            packets_sent += 1
            print(f"Sent {packets_sent} packets so far.")

if __name__ == "__main__":
    main()

最小堆

最小堆是一种非常实用的数据结构，广泛应用于各种算法中，特别是涉及到优先级队列的地方，通过下面代码可以很方便理解

class MinHeap:
    def __init__(self):
        self.heap = [] //数组 
    def parent(self, i): # 父节点
        return (i - 1) // 2
    def left_child(self, i):
        return 2 * i + 1
    def right_child(self, i):
        return 2 * i + 2

    def get(self, i):
        return self.heap[i]

    def swap(self, i, j): #交换 i j 位置数据 
        self.heap[i], self.heap[j] = self.heap[j], self.heap[i]

    def insert(self, key):  # 插入数据
        self.heap.append(key)
        self.swim(len(self.heap) - 1)

    def swim(self, k):  # 从给定索引处开始向上移动元素
        while k > 0 and self.get(self.parent(k)) > self.get(k):
            self.swap(k, self.parent(k))
            k = self.parent(k)

    def extract_min(self): # 下沉操作来保持堆的性质
        if len(self.heap) == 0:
            return None
        elif len(self.heap) == 1:
            return self.heap.pop()
        else:
            min_element = self.heap[0]
            self.heap[0] = self.heap.pop()
            self.sink(0)
            return min_element

    def sink(self, k):
        while True:
            left = self.left_child(k)
            right = self.right_child(k)
            smallest = k

            if left < len(self.heap) and self.get(left) < self.get(k):
                smallest = left
            if right < len(self.heap) and self.get(right) < self.get(smallest):
                smallest = right
            if smallest == k:
                break
            self.swap(k, smallest)
            k = smallest

# 使用示例
if __name__ == "__main__":
    heap = MinHeap()
    heap.insert(3)
    heap.insert(2)
    heap.insert(15)
    heap.insert(5)
    heap.insert(4)
    heap.insert(45)

    print("Extracted min:", heap.extract_min())
    print("Extracted min:", heap.extract_min())

漏桶算法+优先级

漏桶算法（Leaky Bucket Algorithm）是一种常用的流量控制算法，用于平滑网络数据流，防止突发流量导致网络拥塞。该算法的核心思想是将数据包放入一个“桶”中，然后以恒定的速度从桶中流出。这样即使输入的数据流是突发性的，输出的数据流也会变得更加平滑。

漏桶算法原理

桶的容量：桶有一个固定的容量，超过这个容量的数据包会被丢弃。
数据流入：数据包以任意速率进入桶中。
数据流出：数据包以固定的速率从桶中流出

测试代码

初始化：创建一个容量为 bucket_size 的桶，并设置一个优先级队列 priority_queue 和一- 个计时器 leak_rate 表示每秒流出的数据量。
数据包到达：当数据包到达时，将其按照优先级插入到优先级队列中。
数据包流出：按照漏桶算法的速率定时从优先级队列中取出数据包并发送。

function initialize(bucket_size, leak_rate):
    bucket = new Bucket(bucket_size)
    priority_queue = new PriorityQueue()
    timer = setTimer(leak_rate)

function insertPacket(packet, priority):
    // 将数据包按照优先级插入到优先级队列中
    priority_queue.insert(packet, priority)

function processPacket():
    // 如果桶未满且优先级队列中有数据包
    if not bucket.isFull() and not priority_queue.isEmpty():
        packet = priority_queue.extractHighestPriority()
        // 尝试将数据包放入桶中
        if bucket.tryAdd(packet):
            // 数据包成功添加到桶中
            sendPacket(packet)
        else:
            // 桶已满，丢弃数据包
            dropPacket(packet)

function sendPacket(packet):
    // 发送数据包
    network.send(packet)

function dropPacket(packet):
    // 丢弃数据包
    log("Dropped packet: " + packet)

function timerCallback():
    // 定时处理数据包
    processPacket()
    // 重新设置定时器
    timer = setTimer(leak_rate)

// 主函数
function main():
    initialize(bucket_size, leak_rate)
    // 当数据包到达时调用 insertPacket
    onPacketArrival(insertPacket)
    // 启动定时器
    startTimer(timerCallback)

相同优先级数据包处理

在使用最小堆实现的优先级队列中处理优先级相同的元素时，通常需要一种方法来区分这些元素，以确保它们在队列中的正确排序。有几种常见的方法可以实现这一点：

使用时间戳：为每个元素分配一个时间戳，当两个元素具有相同的优先级时，使用时间戳作为次要排序依据。
使用序列号：为每个元素分配一个序列号，当两个元素具有相同的优先级时，使用序列号作为次要排序依据。
使用额外的排序字段：为每个元素添加一个额外的排序字段，当两个元素具有相同的优先级时，使用这个字段作为次要排序依据。
测试代码

import heapq

class PriorityItem:
    def __init__(self, priority, timestamp, sequence_number, data):
        self.priority = priority
        self.timestamp = timestamp
        self.sequence_number = sequence_number
        self.data = data

    def __lt__(self, other):
        # 主要排序依据是优先级
        if self.priority == other.priority:
            # 如果优先级相同，则使用时间戳作为次要排序依据
            if self.timestamp == other.timestamp:
                # 如果时间戳相同，则使用序列号作为再次排序依据
                return self.sequence_number < other.sequence_number
            return self.timestamp < other.timestamp
        return self.priority < other.priority

class PriorityQueue:
    def __init__(self):
        self.queue = []

    def insert(self, item):
        heapq.heappush(self.queue, item)

    def extract(self):
        if self.queue:
            return heapq.heappop(self.queue)
        return None

    def is_empty(self):
        return len(self.queue) == 0

# 示例用法
if __name__ == "__main__":
    queue = PriorityQueue()

    # 假设的数据包
    data_packets = [
        (0x01, 1000, 1, I video data 1'),
        (0x01, 1001, 2, I video data 2'),
        (0x02, 1002, 3,I video data 3'),
        (0x01, 1003, 4, I video data 4')
    ]

    # 插入数据包
    for priority, timestamp, sequence_number, data in data_packets:
        packet = PriorityItem(priority, timestamp, sequence_number, data)
        queue.insert(packet)

    # 从队列中提取数据包
    while not queue.is_empty():
        packet = queue.extract()
        print(f"Processing RTP packet with priority {packet.priority}, timestamp {packet.timestamp}, sequence number {packet.sequence_number}")

实际使用

WebRTC 中 PrioritizedPacketQueue
模块是一个用于管理具有不同优先级的数据包的队列。在WebRTC中，这样的队列可以用来确保高优先级的数据包（如关键帧）能够被优先处理，从而提高实时通信的质量。
PrioritizedPacketQueue 是一个使用最小堆实现的优先级队列，它可以按优先级顺序处理数据包。每个数据包都有一个优先级，优先级越低的数据包会被优先处理。

PrioritizedPacketQueue 主要功能