Ультраточное измерение длительности кода (14.11.2026). Печать
2026 - Ноябрь
14.11.2026 14:33
Save & Share
Ранее была статья на эту тему. Тогда наслаждался собственным превосходством в познании материала (жалкие людишки). Но чем больше шло время, тем больше уверенность испарялась - и появлялась полная растерянность. Пока жизнь не окунула котёнка в его же дерьмо, полностью и окончательно.


Придётся исправлять весь материал и писать краткую выжимку, иначе количество бросков между "всё правильно сделано" и "всё переделывать" будет слишком много:
- теория гласит, что функции QueryPerformanceFrequency и QueryPerformanceCounter работают идеально и берут информацию из материнской платы, из аппаратного таймера HPET - сверхточные вычисления, хоть до пикосекунд;
- тогда предполагалось, что все прочие таймеры являются программными (сам гугл это подтверждал). Но потом эта же тварь стала утверждать, что таймер TSC является аппаратным и зашит прямо в ядро ЦП (к вопросу веры информации, поставляемой любым ИИ). Поэтому, когда в виртуальной машине проводились измерения, QueryPerformanceFrequency выдавала реальную частоту потока ЦП - что не отменяло парадигмы сверхточных вычислений (берёт именно реальность);
- началась борьба с искажающими факторами. Идеально - Turbo Boost нужно выключить в BIOS: тогда частота ЦП будет плавать без разгона в пределах своей погрешности. Но людей такие вещи сделать не заставишь - делал QueryPerformanceFrequency сразу после QueryPerformanceCounter (более точно, а не совсем неточно в функции расчёта самого времени). Далее убрал паразитное время большого цикла (измерение пустого цикла сразу до рабочего цикла - вычитание полученного времени. Тестирование сверхмалых времён - потребовало ещё и выполнять одни и те же функции в цикле 100к раз - как было с тестированием времени выделения указателя на char.

А далее - было обнаружено: время первого пустого цикла всегда больше времени второго пустого цикла. Значит, все скорости ГБ/с, измеренные за последние 1-2 недели, - сделаны с искажением в большую сторону (время было больше, по факту, на 0.7-0.9с при частоте потока 3.57ГГц). И искажения - бешеные (например, скорость 369ГБ/с быстрого генератора - за время 5.55с, когда настоящее время 6.35с - выше настоящего на 14.4% - реальная скорость 323ГБ/с). А это означает - что абсолютно все скорости, указанные в разных частях исходников генератора и в статье про маленькие генераторы, - нужно тоже пересчитывать (а лучше - перемерять).

Осознав собственный провал, начал искать хоть какое-то доказательство, что это неправда. Гугл злорадно писал про прогрев процессора, предсказательные переходы и прочие оптимизации при работе второго цикла. Уже сделал решение: первый цикл просто прогоняется, потом измеряется пустой второй - и потом выполняется уже пустой третий (который должен быть полным при реальных измерениях). Но что-то подсказывало: если тебя пытаются надурить - значит, точно пытаются надурить (а если оно братом назвало - значит, уже надурило). 12.56с первый цикл, 11.55с второй цикл и... 12.40с третий цикл. Врёт гугл про все эти прогревы и переходы - надо дальше рыть.

...тем временем, перенёс проект из виртуалки в родительскую ОС - разница между двумя первыми циклами... стала ещё больше на 0.1с. Бл*ть!..

Неужели, всё пересчитывать? Но каким алгоритмом (с 3 циклами же не выгорело)? И тут гугл палится на очередной лжи. Говорил, что когда частота QueryPerformanceFrequency плавает - это хорошо (и, казалось бы, да: вот, реальная частота ядра в текущий момент времени - что тебе ещё надо, собака?). Это - чёткий признак TSC, но гугл говорил о внутреннем счётчике конкретно VirtualBox. И когда запрос был задан с другими словами - он подтвердил, что это именно TSC, аппаратный счётчик ядра ЦП, а не программный VirtualBox. Это даёт понимание: не важно, где запускается алгоритм: он должен оставить в себе противодействие изменению частоты, если каким-то образом ОС работает в TSC.

А что делать с этими 3 циклами, как перебороть "оптимизацию гугловскую" - пока вообще непонятно. Хотя наиболее вероятно - TSC тики пишет некорректно: QueryPerformanceFrequency вернула 3 раза одну и ту же максимальную частоту - значит, хотя бы её расположение в исходниках абсолютно верно, и она успешно противостоит Turbo Boost (в контексте выведения его на максимальную частоту и не ловле её на понижении).

Вообще, позиция ЦП, родительской ОС, VirtualBox, дочерней ОС и среды разработки - очень агрессивная к программисту. Не ожидал такого группового... сопротивления. Ни о доработке быстрого генератора, ни его функции оценки энтропии, ни даже быстрой функции загрузки и анализа файла для оценки энтропии - речи не идёт вообще: тут застрял.

(добавлено 15.11.2026) Не только всё перемерять нужно. В такую глубокую нору влез, которую даже не представлял. Полученную функцию расчёта времени - точно надо оформлять как отдельный проект-библиотеку. Потому что для настройки точности измерения - нужно пройти ад. И опять, если это читает программист с зарплатой 500-700к, - проржётся, а потом скажет: "Ну, ещё денёк - и он узнает про %new_item%".

Когда исследование именно кода зашло в тупик - было принято совсем тупое решение. Как ранее в заготовке параллелизма: высочайший приоритет на дочерние потоки и обязательно самый низкий на родительский - практически устранило влияние их друг на друга. Так и здесь: максимальные SetPriorityClass и SetThreadPriority в момент работы с циклами - уменьшили время 0.7-0.9с до 0.1-0.15с. Именно ОС решала: а сделаю-ка я цикл №2 быстрее циклов №1, 3 - причём всегда №2. При этом, и родительская 7 x64 так решала, и дочерняя XP x32.

Далее началась борьба с 0.1-0.15с, при длине цикла 9-11с (максимальная погрешность 1.67% - всё равно много), - в попытке выжать 0.01с (специально спросил у гугла: возможно такое? - да). Отключил энергосбережение (mmsystem.h: timeBeginPeriod(1) и timeEndPeriod(1) - выставление максимальной точности таймера системного вдобавок). Перебросил процесс на отдельный несистемный поток (в XP x32 не работает - но точно сработает в 7 x64: SetThreadAffinityMask). Ничего не помогло - и гугл такой: а что ты паришься, это шум процессов в многозадачной ОС - его ничем не преодолеть.


Смирившись с погрешностью, начал причёсывать исходники. И тут всё ломается: время становится 0.6-0.7с. Вообще ничего не понял. Оказалось, существует такая штука как %new_item%: выравнивание исходного кода в оперативной памяти по границе 16 (чёртов набор бессмысленных слов). Почему это не делает сама среда программирования - вообще не понятно; но если адрес цикла не кратен 16 - его работа резко замедляется, т.к. процессор использует больший набор команд при его обработке.

Текущая среда разработки не умеет выравнивать автоматически - пришлось вручную __asm {необходимое_количество nop). Делаешь останов на первом цикле - видишь его адрес - смещаешь до кратности 16. Останов на втором (он тоже сместился из-за nop в первом) - его выравниваешь. Потом третий выравниваешь. Если сверху от нижнего nop код меняется - выравнивание надо заново менять. Если сверху вне функции код изменился (не весь - но всё же) - заново перемерять количество nop. То есть, требуется ещё и всю функцию переносить в самый верх CPP-файла - и каждый новый инклуд и библиотека выше может всё похерить.

Гугл при этом - врёт безбожно. Типа, в отдельные функции циклы вынеси, автоматом выровняется - но выравнивается функция, а не код в ней. Или напиши pragma что-то там - но билдер выравнивает прагмой данные, а не исходники. Другой компилятор TASM, грит, подключай: он тебе всё сделает ассемблерной вставкой (но не говорит, что текущий исходный код не подойдёт для такой реализации) - ответ здесь может быть только один. Эта цифровая жестянка годится только для выравнивания вставляемых адресов генерацией нужного количества nop.

Используем LSD и обратим ложь гугла против него самого. Раз любая функция выравнивается по границе 16 - нужно вынести циклы в самописные минифункции. Тогда, добавив внутри минифункций нужное количество nop - запрет на изменение кода распространится только на то, что вверху nop именно этой функции. И, действительно, сколько nop кратных 17 ни вставлял перед функцией - адрес цикла внутри неё даже не шелохнулся (а вот заставить бы сместиться, чтобы проверить выравнивание). Использую сотни nop (nop! nop!!! NOP!!!) - адрес не смещается. Миллион интов в куче, заполненных rand(), - не смещается. Создал отдельную функцию с кучей nop, вызвал перед основной функцией - адрес цикла стал новым числом и недосместился на 12Б. И цифровая жестянка скандирует: "В Borland C++ Builder 6 (BCB 6) по умолчанию вызываемые функции выравниваются по границе 4 байта".


В общем, решение где-то близко. Выравнивание приводит к погрешности 0.1-0.15с в дочерней ОС; но в родительской, за счёт выноса приложения на несистемный поток, - 0.048с. Можно меньшее время обеспечить: просто гугл опять звездил. Как только добавляешь хоть 1 строчку кода в минифункции - выравнивание едет: например, обнулить глобальную переменную в стеке стоит 1 или 17 nop - тактов ЦП.

Прочие решения:
- volatile запрещает компилятору оптимизировать код в Release - дописать ко всем переменным циклов, иначе компилятор их просто выбросит;
- nop внутри пустого цикла - отключает оптимизацию цикла в Debug (но и увеличивает время работы пустого цикла на 1+с).


(добавлено 15.11.2026) Выравнивание кода по границе 16 - это писец...
Обновлено ( 15.11.2026 21:14 )