Конвейеризация в железе

Учимся повышать частоту схемы, разбивая длинные вычисления на ступени с регистрами между ними.

Конвейеризация (pipelining) — разбиение длинной комбинационной цепочки на ступени, между которыми ставят регистры; это сокращает путь сигнала за такт и поднимает достижимую тактовую частоту.

Чем длиннее комбинационная цепочка (например, умножение, за которым сложение, за которым сравнение), тем дольше сигнал бежит от входа до выхода за один такт — и тем ниже частота, на которой схема ещё успевает. Конвейеризация решает эту проблему так же, как фабричный конвейер: длинную операцию режут на короткие ступени, между ними ставят регистры, и на каждой ступени за такт делается лишь маленький кусочек работы. Это поднимает частоту и пропускную способность ценой задержки в несколько тактов.

Зачем это нужно

Представьте вычисление result = (a*b + c) > threshold. Без конвейера за один такт сигнал должен пройти умножитель → сумматор → компаратор — длинный путь, ограничивающий частоту. С конвейером разбиваем на 3 ступени:

Без конвейера (1 такт на весь путь — низкая частота):
  a,b -> [ * ] -> [ + ] -> [ > ] -> result
         <----- длинный путь за 1 такт ----->

С конвейером (3 ступени, регистр между ними — высокая частота):
  a,b -> [ * ] -|R|-> [ + ] -|R|-> [ > ] -|R|-> result
        ступень1     ступень2      ступень3
        <-короткий->  <-короткий->  <-короткий->
           путь          путь          путь

Каждый короткий участок проходится за такт быстро, поэтому частоту можно поднять. Платим тем, что результат для конкретных входов появится через 3 такта (это задержка, latency). Но зато новый набор входов можно подавать каждый такт — и поток результатов идёт без пауз (это пропускная способность, throughput).

Конвейер на Verilog

Каждая ступень — это регистр, защёлкивающий промежуточный результат:

always @(posedge clk) begin
    // ступень 1: умножение
    mul_r  <= a * b;
    c_r    <= c;            // c «едет» вместе с данными
    // ступень 2: сложение (использует результат ступени 1)
    sum_r  <= mul_r + c_r;
    // ступень 3: сравнение
    result <= (sum_r > threshold);
end

Обратите внимание: c приходится «прокидывать» через регистр c_r, чтобы он совпал по времени с результатом умножения. Это типичный приём конвейера — выравнивание данных по ступеням.

Как работает под капотом: latency против throughput

Промоделируем 3-ступенчатый конвейер: подаём новые данные каждый такт и смотрим, когда появляются результаты. Это показывает, что после «прогрева» результат выходит каждый такт:

inputs = [10, 20, 30, 40, 50]   # новый вход каждый такт
stage = [None, None, None]      # 3 ступени конвейера
print("такт | вход | ст1 | ст2 | ст3 (результат)")
print("-----+------+-----+-----+----------------")
for t in range(7):
    new_in = inputs[t] if t < len(inputs) else None
    # сдвигаем конвейер: каждая ступень берёт результат предыдущей
    stage[2] = stage[1]
    stage[1] = stage[0]
    stage[0] = (new_in * 2) if new_in is not None else None   # ступень 1: *2
    fmt = lambda x: "--" if x is None else str(x)
    print(f"  {t}  |  {fmt(new_in):3} | {fmt(stage[0]):3} | {fmt(stage[1]):3} | {fmt(stage[2])}")

Вывод:

такт | вход | ст1 | ст2 | ст3 (результат)
-----+------+-----+-----+----------------
  0  |  10  | 20  | --  | --
  1  |  20  | 40  | 20  | --
  2  |  30  | 60  | 40  | 20
  3  |  40  | 80  | 60  | 40
  4  |  50  | 100 | 80  | 60
  5  |  --  | --  | 100 | 80
  6  |  --  | --  | --  | 100

Первый результат (20) появился на такте 2 — это задержка (latency) в 3 ступени. Зато начиная с такта 2 результат выходит каждый такт: 20, 40, 60, 80, 100. Конвейер не ускоряет одну операцию, но позволяет обрабатывать поток данных с полной скоростью такта — в этом его сила для DSP и потоковых задач.

Частые ошибки

• Не выравнивать данные по ступеням. Если один сигнал прошёл регистр, а параллельный — нет, они «разъедутся» по времени и сложатся неверно. Прокидывайте все сопутствующие данные через регистры.
• Путать latency и throughput. Конвейер увеличивает задержку первого результата, но обеспечивает результат каждый такт — для потоков это выигрыш.
• Конвейеризировать там, где нужна низкая задержка. Если важен быстрый ответ на единичный запрос, лишние ступени только вредят.

Итог

• Конвейер режет длинную комбинационную цепочку регистрами на короткие ступени.
• Это повышает тактовую частоту и пропускную способность ценой задержки в несколько тактов.
• Сопутствующие данные нужно выравнивать, прокидывая через регистры.
• Latency растёт, throughput — один результат за такт после «прогрева».