编码与格式 / 系统课时

设计并发转码策略

设计并发转码策略

本课将把单任务测试结果转换为可执行的并发方案:先计算 CPU、GPU、内存和磁盘分别允许的任务数,再以最小值作为初始并发上限,并通过任务队列、GPU 槽位和独立日志实现资源隔离与稳定调度。

学习目标

  • 根据实测资源消耗计算安全并发上限
  • 设计任务队列、GPU 槽位和失败隔离机制
  • 通过压力测试验证吞吐、等待时间与系统稳定性

用资源瓶颈计算并发上限

并发数不能只按 CPU 核数或 GPU 数量估算。对每种转码模板先测出单任务平均占用,再分别计算各资源允许的任务数,最终取最小值:

N=min⁡(⌊CavailableCjob⌋,⌊GslotsGjob⌋,⌊MavailableMjob⌋,⌊DsafeDjob⌋)N=\min\left( \left\lfloor\frac{C_{available}}{C_{job}}\right\rfloor, \left\lfloor\frac{G_{slots}}{G_{job}}\right\rfloor, \left\lfloor\frac{M_{available}}{M_{job}}\right\rfloor, \left\lfloor\frac{D_{safe}}{D_{job}}\right\rfloor \right)

其中,C 表示可用 CPU 核心或配额,G 表示可用硬件编码会话槽位,M 表示可分配内存,D 表示磁盘安全吞吐。生产环境不要把资源用满,通常应为系统、监控、文件缓存和突发任务预留 15%~30% 余量。

例如,一台机器按安全余量后可用 12 个 CPU 核心、24 GB 内存、600 MB/s 磁盘吞吐和 4 个 GPU 会话槽位。若单任务分别需要 3 核、4 GB、120 MB/s 和 1 个 GPU 槽位,则四项上限为 4、6、5、4,初始并发数应设为 4。

并发转码资源约束与调度结构

划分任务队列和资源槽位

调度层应维护一个有界队列,避免短时间大量提交把内存和磁盘打满。CPU 转码任务通过 -threads 限制单任务线程数;GPU 转码任务通过设备编号和每卡槽位数限制并发会话。每个任务使用独立输出文件、临时目录和日志,失败时只重试当前任务。

不同模板不要默认共享同一个并发池。4K 缩放、降噪、字幕烧录和纯编码的资源模型差异很大,适合按“模板或资源等级”划分队列,例如 cpu-heavy、gpu-light 和 io-heavy,分别设置并发上限。

实现一个最小并发调度器

下面的 Python 程序支持 CPU 与 NVIDIA GPU 两种模式。GPU 模式会把 GPU ID × 每卡槽位数 展开成可用槽位,任务开始时领取槽位,结束后归还,因此不会出现多个工作线程无限争用同一张卡。

将代码保存为 transcode_pool.py。程序要求 Python 3.10 及以上,并确保 ffmpeg 已加入 PATH。

python
from __future__ import annotations

import argparse
import queue
import subprocess
import threading
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path

def build_command(
    input_path: Path,
    output_path: Path,
    mode: str,
    gpu_id: str | None,
    cpu_threads: int,
) -> list[str]:
    base = [
        "ffmpeg",
        "-y",
        "-v",
        "warning",
        "-i",
        str(input_path),
        "-map",
        "0:v:0",
        "-map",
        "0:a?",
    ]

    if mode == "gpu":
        # 每个任务显式绑定 GPU,避免调度结果依赖驱动的隐式选择。
        video_args = [
            "-c:v",
            "h264_nvenc",
            "-gpu",
            str(gpu_id),
            "-preset",
            "p4",
            "-cq",
            "23",
            "-b:v",
            "0",
        ]
    else:
        video_args = [
            "-c:v",
            "libx264",
            "-preset",
            "veryfast",
            "-crf",
            "23",
            "-threads",
            str(cpu_threads),
        ]

    return base + video_args + ["-c:a", "aac", "-b:a", "128k", str(output_path)]

def transcode_one(
    input_path: Path,
    output_dir: Path,
    mode: str,
    gpu_slots: queue.Queue[str] | None,
    cpu_threads: int,
) -> tuple[Path, bool, str]:
    gpu_id: str | None = None
    if gpu_slots is not None:
        gpu_id = gpu_slots.get()

    try:
        output_path = output_dir / f"{input_path.stem}.mp4"
        log_path = output_dir / f"{input_path.stem}.log"
        command = build_command(input_path, output_path, mode, gpu_id, cpu_threads)

        # 不使用 shell=True,避免文件名被解释为额外命令。
        result = subprocess.run(
            command,
            stdout=subprocess.DEVNULL,
            stderr=subprocess.PIPE,
            text=True,
            check=False,
        )
        log_path.write_text(result.stderr, encoding="utf-8")
        return input_path, result.returncode == 0, str(log_path)
    finally:
        if gpu_slots is not None and gpu_id is not None:
            gpu_slots.put(gpu_id)

def main() -> int:
    parser = argparse.ArgumentParser(description="Bounded FFmpeg transcode pool")
    parser.add_argument("inputs", nargs="+", type=Path)
    parser.add_argument("--mode", choices=("cpu", "gpu"), default="cpu")
    parser.add_argument("--workers", type=int, default=2)
    parser.add_argument("--cpu-threads", type=int, default=2)
    parser.add_argument("--gpu-ids", default="0")
    parser.add_argument("--slots-per-gpu", type=int, default=1)
    parser.add_argument("--output-dir", type=Path, default=Path("output"))
    args = parser.parse_args()

    if args.workers < 1 or args.cpu_threads < 1 or args.slots_per_gpu < 1:
        raise ValueError("workers, cpu-threads and slots-per-gpu must be positive")

    args.output_dir.mkdir(parents=True, exist_ok=True)
    missing = [path for path in args.inputs if not path.is_file()]
    if missing:
        raise FileNotFoundError(f"missing inputs: {missing}")

    gpu_slots: queue.Queue[str] | None = None
    worker_count = args.workers

    if args.mode == "gpu":
        ids = [item.strip() for item in args.gpu_ids.split(",") if item.strip()]
        if not ids:
            raise ValueError("GPU mode requires at least one GPU ID")

        gpu_slots = queue.Queue()
        for gpu_id in ids:
            for _ in range(args.slots_per_gpu):
                gpu_slots.put(gpu_id)

        # 工作者数量不能超过实际 GPU 会话槽位。
        worker_count = min(worker_count, gpu_slots.qsize())

    print(f"start mode={args.mode} workers={worker_count}")
    failures = 0
    lock = threading.Lock()

    with ThreadPoolExecutor(max_workers=worker_count) as executor:
        futures = [
            executor.submit(
                transcode_one,
                input_path,
                args.output_dir,
                args.mode,
                gpu_slots,
                args.cpu_threads,
            )
            for input_path in args.inputs
        ]

        for future in as_completed(futures):
            input_path, success, log_path = future.result()
            with lock:
                print(f"{'ok' if success else 'failed'} input={input_path} log={log_path}")
            failures += 0 if success else 1

    print(f"finished total={len(args.inputs)} failed={failures}")
    return 1 if failures else 0

if __name__ == "__main__":
    raise SystemExit(main())

预期结果:源码保存后不会自动执行;运行时会创建输出目录,为每个输入生成一个 MP4 文件和独立日志,并以进程退出码汇总成功或失败。

CPU 模式示例把总并发限制为 3,每个任务最多使用 2 个编码线程:

bash
python3 transcode_pool.py --mode cpu --workers 3 --cpu-threads 2   --output-dir output input-01.mp4 input-02.mp4 input-03.mp4

预期输出格式如下,任务完成顺序可能不同:

text
start mode=cpu workers=3
ok input=input-01.mp4 log=output/input-01.log
ok input=input-02.mp4 log=output/input-02.log
ok input=input-03.mp4 log=output/input-03.log
finished total=3 failed=0

双 GPU 示例为每张卡分配 2 个会话槽位,但总工作者仍限制为 4:

bash
python3 transcode_pool.py --mode gpu --workers 4 --gpu-ids 0,1   --slots-per-gpu 2 --output-dir output input-01.mp4 input-02.mp4   input-03.mp4 input-04.mp4

预期输出格式如下,任务完成顺序可能不同:

text
start mode=gpu workers=4
ok input=input-<ID>.mp4 log=output/input-<ID>.log
ok input=input-<ID>.mp4 log=output/input-<ID>.log
ok input=input-<ID>.mp4 log=output/input-<ID>.log
ok input=input-<ID>.mp4 log=output/input-<ID>.log
finished total=4 failed=0

验证并发策略

从计算值开始压测,不要直接使用理论最大值。逐级增加并发,观察 15~30 分钟稳定阶段的 CPU、GPU 编码器利用率、显存、可用内存、磁盘吞吐、I/O 等待、队列长度、失败率和单任务耗时。

当并发增加后总吞吐不再明显上升,或单任务耗时、I/O 等待和失败率快速增长,就已经越过有效容量。此时应回退一个档位,并为生产峰值保留余量。若瓶颈来自缩放或滤镜,应优化处理链路,而不是继续增加编码会话。

隔离与恢复边界

任务隔离至少包括独立日志、唯一输出路径、临时文件目录和超时控制。输出应先写临时文件,成功后再原子重命名,避免失败任务留下看似完整的成品。

重试只适合瞬时故障,并应设置次数上限和退避间隔。输入损坏、参数非法或编码器不支持属于确定性失败,重复执行只会浪费资源,应直接进入失败队列等待人工处理。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

设计并发转码策略

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通