Планирование операций с плавающей точкой

Инструкции, оперирующие с плавающей точкой не могут спариваться, так же, как
другие инструкции, за исключением одного особого случая, определяемого
следующими правилами:
- первая инструкция (исполняющаяся в U-трубе) должна быть FLD, FADD, FSUB,
  FMUL, FDIV, FCOM, FCHS, or FABS

- вторая инструкция (в V-трубе), должна быть FXCH

- инструкция следующая за FXCH, должна быть инструкцией, оперирующей с
  плавающей точкой, в противном случае FXCH - возьмет дополнительный такт.

Этот особый случай спаривания очень важен, я кратко объясню почему.

Хотя инструкции с плавающей точкой не могут спариваться, многие могут
параллелится, т.е. новая инструкция начинается, пока не завершилась старая.
Например:
FADD ST(1),ST(0)   ; такты 1-3
FADD ST(2),ST(0)   ; такты 2-4
FADD ST(3),ST(0)   ; такты 3-5
FADD ST(4),ST(0)   ; такты 4-6

Очевидно, что две инструкции не могут перекрываться, если второй инструкции
требуется результат первой. Поскольку почти все инструкции с плавающей точкой
используют верхний регистр стека, ST(0), то на первый взгляд не много
возможностей получить независимые инструкции. Решение этой проблемы -
переименование регистра. Инструкция FXCH на самом деле не обменивает значения
регистров, а только меняет местами их имена. Инструкции вталкивающие или
выталкивающие из стека, так же работают переименованием. Процесс
переименования регистров очень хорошо оптимизирован на Pentium, по этому
процесс переименования может происходить прямо во время доступа к регистру.
Переименование регистра никогда не вызывает остановки AGI - возможна, даже,
неоднократное переименование регистров в одном такте, например когда вы
спариваете FLD или FCOMPP с FXCH.

Правильным использованием FXCH вы можете добиться  множественного  перекрывание
в вашем коде с плавающей точкой. Пример:

FLD     [a1]    ; такт  1
FADD    [a2]    ; такты 2-4
FLD     [b1]    ; такт  3
FADD    [b2]    ; такты 4-6
FLD     [c1]    ; такт  5
FADD    [c2]    ; такты 6-8
FXCH    ST(2)   ; такт  6
FADD    [a3]    ; такты 7-9
FXCH    ST(1)   ; такт  7
FADD    [b3]    ; такты 8-10
FXCH    ST(2)   ; такт  8
FADD    [c3]    ; такты 9-11
FXCH    ST(1)   ; такт  9
FADD    [a4]    ; такты 10-12
FXCH    ST(2)   ; такт  10
FADD    [b4]    ; такты 11-13
FXCH    ST(1)   ; такт  11
FADD    [c4]    ; такты 12-14
FXCH    ST(2)   ; такт  12

В вышеуказанном примере, мы используем три независимых потока. Каждый FADD
исполняется 3 такта, так что у нас есть время, чтобы запустить другие FADD.
Когда мы запускаем FADD в потоке "a" у нас есть время, чтобы запустить два
новых FADD в потоке "b" и с "c", до того как мы вернемся к потоку "a", таким
образом все три FADD принадлежат одному потоку. Мы используем инструкцию FXCH,
каждый раз, когда нам надо получить регистр, принадлежащий к желаемому потоку
ST(0). Как вы можете увидеть в вышеуказанном примере, мы создали неплохой
блок, однако не очень хорошо, что FXCH периодически повторяется. Вам придется
основательно "поиграться" с компьютером, чтобы всегда знать какой регистр
используется.

Все виды инструкций FADD, FSUB, FMUL, и FILD исполняются по 3 такта, и могут
перекрываться, таким образом вы можете спаривать их, используя выше описанный
алгоритм. Операнд адреса не занимает больше времени, чем операнд регистра,
если он находиться в кеше L1 и правильно выравнен.

Теперь пришло время познакомиться с правилами исключений, препядствующих
перекрытиям: Вы не можете запустить инструкцию FMUL, такт спустя после другой
инструкции FMUL, поскольку инструкция FMUL не очень хорошо реализована в
конвеере. Рекомендуется ставить другую инструкцию между двумя FMUL. Например:

FLD     [a1]    ; clock cycle 1
FLD     [b1]    ; clock cycle 2
FLD     [c1]    ; clock cycle 3
FXCH    ST(2)   ; clock cycle 3
FMUL    [a2]    ; clock cycle 4-6
FXCH            ; clock cycle 4
FMUL    [b2]    ; clock cycle 5-7    (остановка AGI)
FXCH    ST(2)   ; clock cycle 5
FMUL    [c2]    ; clock cycle 7-9    (остановка AGI)
FXCH            ; clock cycle 7
FSTP    [a3]    ; clock cycle 8-9
FXCH            ; clock cycle 10     (неспарено)
FSTP    [b3]    ; clock cycle 11-12
FSTP    [c3]    ; clock cycle 13-14

У нас получилась остановка AGI после FMUL [b2] и перед FMUL [c2], потому что
предыдущий FMUL был запущен в предыдущем такте. Однако, вы можете легко
улучшить этот код, просто вставив инструкцию FLD, между другими FMULами:

FLD     [a1]    ; такт  1
FMUL    [a2]    ; такты 2-4
FLD     [b1]    ; такт  3
FMUL    [b2]    ; такты 4-6
FLD     [c1]    ; такт  5
FMUL    [c2]    ; такты 6-8
FXCH    ST(2)   ; такт  6
FSTP    [a3]    ; такты 7-8
FSTP    [b3]    ; такты 9-10
FSTP    [c3]    ; такты 11-12

В других случаях вы можете установить FADD, FSUB или что-нибудь еще между
FMUL, чтобы избежать остановки AGI.

Перекрытие инструкций с плавающей точкой предполагает, конечно, что у вас есть
несколько потоков расчетов, которые вы можете чередовать. Если у вас есть
только одна большая формула, то вы можете считать разные ее части параллельно,
для того чтобы достичь перекрытия. Если вы хотите сложить, например, 6 чисел,
то вы можете разделить этот процесс на две части, по 3 числа, а результаты
сложить в конце:

FLD     [a]     ; clock cycle 1
FADD    [b]     ; clock cycle 2-4
FLD     [c]     ; clock cycle 3
FADD    [d]     ; clock cycle 4-6
FXCH            ; clock cycle 4
FADD    [e]     ; clock cycle 5-7
FXCH            ; clock cycle 5
FADD    [f]     ; clock cycle 7-9    (остановка AGI)
FADD            ; clock cycle 10-12  (остановка AGI)

Здесь у нас есть остановка AGI, на один такт, до FADD [f], потому что она
ждет результата FADD [d] и два такта остановки AGI перед последним FADD,
потому что идет ожидание результата FADD [f]. Последнюю остановку AGI можно
замаскировать, вставив несколько целочисленных инструкций, но с первой такой
фокус не пройдет, потому что в таком случае не спариться FXCH.

Первую остановку AGI можно анулировать, если иметь не две, а три потока, но
это будет стоить дополнительного FLD, таким образом мы не выиграем времени и
в этом нет необходимости до тех пор пока мы не складываем по крайней мере
восемь чисел.

Не все инструкции с плавающей точкой могут перекрываться. Но некоторые
инструкции с плавающей точкой могут перекрывать последующие инструкции с
целым операндом. К примеру инструкция FDIV исполняется 39 тактов. Все первые
такты могут перекрываться с целочисленными инструкциями, но только последние
два такта могут перекрыть инструкции с плавающей точкой. Пример:

FDIV            ; такты 1-39
FXCH            ; такты 1-2
CMC             ; такты 3-4
RCR EAX,1       ; такт  5
INC EBX         ; такт  5
FADD [x]        ; такты 38-40
FXCH            ; такты 38
FMUL [y]        ; такты 40-42

Сначала FXCH спаривается с FDIV, но использует дополнительный такт из=за того,
что не сопровождает инструкцию с плавающей точкой. CMC начала бы исполняться
сразу после FDIV, но вынуждена ждать окончания FXCH. Инструкции RCR и INC
спариваются. Инструкция FADD начинает исполняться в 38 такте, т.к. инструкции
с плавающей точкой могут начать перекрытие только в двух последних тактах
инструкции FDIV. Следующая инструкция FXCH спаривается с FADD. Инструкция FMUL
ждет окончания FDIV, т.к. использует результат ее деления.

Если у вас нет выбора и приходиться использовать инструкцию с плавающей точкой
после долго исполняемой инструкции типа FDIV или SQRT, то вы можете подставить
адрес из памяти и убедиться, что все значения находятся на уровне L1 кеша.
Например:
        FDIV    QWORD PTR [EBX]
        CMP     [ESI],EAX
        FMUL    QWORD PTR [ESI]
Здесь мы пользуемся перекрытием целочисленной инструкции, предзагружая
значение ESI в кеш(нам абсолютно не важен результат сравнения).

В разделе 21 приведен список полный инструкций с плавающей точкой, а так же
отражены их способности спариваться и перекрываться.

Особого упоминания требует инструкция FST или FSTP с операндом памяти. Эта
инструкция исполняется два такта, но в процессе старта, похоже, начинает
конвертировать значение в ST(0), так что один такт конвеер занят и не готов к
декодированию. Это полностью аналогично остановке AGI. Пример:

FLD     [a1]    ; такт  1
FADD    [a2]    ; такты 2-4
FLD     [b1]    ; такт  3
FADD    [b2]    ; такты 4-6
FXCH            ; такт  4
FSTP    [a3]    ; такты 6-7
FSTP    [b3]    ; такты 8-9

FSTP [a3] ждет один такт, поскольку результат FADD [a2] не готов в предыдущем
такте. Во многих случаях этого нельзя замаскировать не разбив вычисление на
четыре пути или не вставив несколько инструкций после. Никакие другие
инструкции не имеют этой странной особенности. Все два такта инструкция
FST(P) не может спариваться или перекрываться с другими инструкциями.

Инструкции с целочисленными операндами, как например FIADD, FISUB, FIMUL,
FIDIV, FICOM могут быть разбиты на более простые операции, и чуть улучшить
перекрытие.
Пример:

FILD    [a]     ; такты 1-3
FIMUL   [b]     ; такты 4-9

Разбивается на:

FILD    [a]     ; такты 1-3
FILD    [b]     ; такты 2-4
FMUL            ; такты 5-7

В данном примере, вы выигрываете два такта, вызывая перекрывание двух
инструкций FILD.