" title="Написать письмо">Написать письмо
На выжить после операций проктологии
2200 4002 2461 6363

Статистика

Пользователи : 1
Статьи : 2544
Просмотры материалов : 10320262
 
Выравнивание кода в RAM по границе 16 (15.11.2026). Печать E-mail
2026 - Ноябрь
15.11.2026 15:05
Save & Share
Чем дальше пишутся статьи в разделе-ит, касательно программирования, - тем трешовее материалы выходят.

Ну что это за набор слов, что за нелепица, - а между тем, за этим скрывается скорость работы высоконагруженных и/или высокоточных частей исходного кода. И искажение времени их работы - не флуктуация частоты ЦП или фоновые процессы ОС, это - не выровненный именно исходный код, именно в RAM и кеше L1 процессора, именно по границе... пока неясно: 16 надо, 32 или 64.

Что за дрянь это выравнивание: придётся использовать обобщённое описание - или мозги окончательно вытекут через уши. Компилятор, при подготовке программы и создании EXE-файла, закладывает алгоритмы распределения адресов выполняемых её частей в RAM. Каждая следующая выполняемая строка исходного кода займёт какой-то новый адрес. Если этот адрес не кратен 16 - строка кода будет выполнена медленно, а итоговая скорость зависит от недостающего числа до кратности 16.

Конкретно в Borland C++ Builder v.6.0 - смотрится через View - Debug Windows - CPU.


На кратность адреса конкретной строки кода влияет куча факторов:
- исходный код, написанный выше (при этом, область искажения зависит от самих исходников: что-то, написанное выше, исказит; а что-то - нет);
- какие начальные адреса назначила ОС;
- в режиме Release компилятор может просто скрытно удалять куски неиспользуемого кода (пустой цикл, например) - скрытно породит смещение адресов;
- в режиме Debug компилятор проводит скрытые оптимизации, в т.ч. процессорные инструкции, - тоже влияет на смещение;
- цикличный вызов кусков кода - скрытое смещение для кода ниже. Цикл выполнится 1 раз - сместит на 1 адрес, например. 2 раза вызвал - уже на 2. Похоже, для программы не существует понятия "цикл": она его просто разворачивает на огромный массив адресов и последовательно их выполняет;
- попытка узнать текущий адрес, чтобы сделать его кратным 16, - как с электроном: либо скорость его узнаешь толчком другим электроном, либо координату. А электрон-то уже смылся, полученное значение не имеет никакого смысла, если не отнестись к нему с максимальным вниманием (расчёт точного адреса, где будет следующая строка кода после выполнения функции определения текущего уже устаревшего адреса);
- самописная функция определения адреса как числа - вернёт один результат. Ровно такая же функция определения адреса как текста (просто перетипирование в конце) - вообще другой. Почти любая изменённая или добавленная/убранная строка кода - искажает корректный результат, убивая весь смысл последующего выравнивания;
- нельзя проверить смещение: функция проверки смещения сместит строчку кода ниже на другой адрес;
- нельзя сместить внешний адрес внутри внутренностей типа функций, процедур, for, if, while. Если ручной ввод __asm {nop} стабильно смещает на 1 адрес, то вызванный во внутренности он ни к чему не приведёт (видел только, как независимо от количества итераций for с nop внутри - сместил на 1 nop и всё);
- внутренний адрес в функции не влияет на внешний при её вызове - так ещё и внешний не влияет на внутренний.

Если о практике: 
- не выровненный пустой цикл 0...4294967295 с неизвестным смещением - выполнялся быстрее на 0.7-0.9с точно такого же пустого цикла, размещённого чуть ниже со своим неизвестным смещением. Гигантская разница, искажающая измерение скорости работы функций процентов на 15;
- когда в другой ОС измерил - адреса в памяти там были другие - смещение обоих циклов стало другим - разница вообще до 1с увеличилась - проорался из-за осознания катастрофы;
- когда перенёс циклы каждый в свою функцию - вопреки гугловскому выравниванию на 16 (этот тостер будет врать в этом материале ещё очень много), произошло выравнивание на 4. И скорость стала лучше: 0.2-0.39с;
- когда вручную выровнял всё по 16 - время стало 0.1-0.15с (а в родительской ОС - вообще 0.048с).

Поняв, в какую сторону рыть, решил напрячь гугл для выполнения рутинной работы. Казалось бы, сделанный для облегчения рутины, он должен был ускорить работу в разы: мозги после изучения писеца выше - уже совсем не работали (и палец ещё этот болит). Но оказалось, что гугл тупее человека с прокисшими мозгами. Вместо предложения решения - он начал опять травить байки о pragma, align 16 и прочих вещах, которые в текущей среде программирования не работают (а она была указана в каждом вопросе, это как постоянный префикс уже шло). Пишу, чтобы убрал из себя эти байки, - а он не может редактировать собственную БД - о чём сообщил с невозмутимым видом ржущего капитана Барбоссы (и разработка - временно прервалась по техническим причинам).


Всё крутилось вокруг автоматизации. Смотреть CPU, считать смещение, необходимый сдвиг - ну, может, тут гугл себя проявит, в рутине? 50 функций. Полсотни функций предложил он мне, отлаживая их с бесконечными моими замечаниями после практического тестирования: не работало ни-ху-*. Но, как ни странно, даже такой безумный путь - дал именно корректный результат - что делает ИИ выгоднее современных стажёров, в контексте рутины. Выступая как наставник стажёра-ИИ, была получена функция - возвращающая точный адрес следующей строки исходного кода (в 2 вариантах) и число необходимых nop смещения для кратности 16. Выложу одну сюда - но только чтобы посмотреть, как при ограничении 160 символов на этом сайте - будете копировать её себе; при условии, что скоро она окажется в готовом проекте - и надо тупо подождать.

struct strNextStringCode_Adress_RAM
{
    unsigned int uiAddress; //Числовой адрес следующей строки кода.
    String sAddress_Hex; //Адрес в формате HEX (8 символов).
    unsigned int uiNops_Needed_16; //Сколько байт NOP (0..15) нужно до границы 16 байт.
};

strNextStringCode_Adress_RAM __cdecl Fill_Struct(int dummyParam = 0) {
    unsigned int* pStack = reinterpret_cast<unsigned int*>(&dummyParam);

    strNextStringCode_Adress_RAM oNextStringCode_Adress_RAM;

    //Поправка + 0x0D (13 байт): очистка аргументов __cdecl и вызов деструктора
    //временной структуры при инициализации переменной.
    oNextStringCode_Adress_RAM.uiAddress = *(pStack - 2) + 0x0D;
    oNextStringCode_Adress_RAM.sAddress_Hex = IntToHex(static_cast<__int64>(oNextStringCode_Adress_RAM.uiAddress), 8);
    oNextStringCode_Adress_RAM.uiNops_Needed_16 = (16 - (oNextStringCode_Adress_RAM.uiAddress & 0x0F)) & 0x0F;

    return oNextStringCode_Adress_RAM;
}

Но проблема-то осталась: количество nop есть, но прокрутить-то как? Много что было сделано, всего и не напишешь:
- через define ничего не вышло;
- топорно: сделать 16 функций с пустым циклом и 16 функций с непустым - в каждой из которых прибавляется 1 nop. Результат - провал: у первой функции нужно 10 nop, у второй - 2;
- #include видны только на этапе компиляции - хорошее решение. При запуске функции, в неё инклудится H-файл с пустотой, рассчитывается смещение, файл заполняется nop - при перекомпиляции подтянутся из файла нужное количество nop. Но когда EXE готов - никаких инклудов он не делает. Если не перекомпилировать проект с нужным содержимым файла - ошибка останется. Также в функции останется паразитный расчёт nop: удалишь - сместишься;
- прыжок программистской веры: заставил сброситься защиту RAM, перебросить функцию с выравниванием 16, сбросить кеш-инструкции процессора - провал;
- а ведь простое решение было на поверхности."Внутренний адрес в функции не влияет на внешний при её вызове - так ещё и внешний не влияет на внутренний" - это не баг, а фича. Инклуды добавлял, функции паразитные вызывал - а адрес внутри минифункции как был со смещением 10 - так и остался. И это - ошибка: нужно было просто много паразитных функций вызвать - и адрес поплыл - внешний влияет-таки на внутренний;
- но начало было положено. Вынести код в самый верх CPP-файла - тоже костыль, но он надёжнее костыля выше;
- а вот вынести функцию в отдельный CPP-файл и добавить его в верх всего проекта - ... полный провал, опять с подсказки гугла, задрал.

В общем, помучившись, - выводы:
- __asm {align 16} - простая конструкция в новых языках программирования;
- в билдере же - ручное добавление nop - именно когда все исходники уже написаны. И если исходники меняются - о перерасчёте nop надо помнить. Или - костыль с инклудящимся файлом - попроще будет, и функции плевать где находятся;
- уменьшение вероятности изменения адреса выравниваемой функции, при ручном вводе nop, - расположение её выше всего остального кода;
- выделение ускоряемого участка в отдельную функцию - обеспечивает выравнивание по границе 4. Ни разу за сегодня не было такого, чтобы nop требовалось >12 и не делилось на 4.


(добавлено 16.11.2026) Достиг практически идеального выравнивания циклов по критерию времени - 2 пустых цикла работают с погрешностью 0.014-0.034с (а в родительской ОС - стабильные -0.029с). Было-стало в Windows XP и стало в Windows 7.


Но самые внимательные читатели уже заметили подвох. Что же произошло? А то, что гугл - пиздабол.

Забудьте про выравнивание по границе 16 - нужно не просто выравниваться по границе 4 (или даже 2), а искать оптимальную комбинацию этого выравнивания. Когда перенёс ранее все функции в отдельный CPP-файл, и у них сбились адреса, - выравнивание по 16 ни хрена не помогло. Гугл писал про накладные расходы - это ложь: скрины говорят обратное - настроил-таки.

А алгоритм - простой. В жопу даже функцию, возвращающую адрес текущий:
- отдельный CPP-файл или отдельная функция - выравнивание по 4;
- но это выравнивание - не оптимальное. Нужно прибавлять по 4 nop, сдвигая адрес всё ниже и ниже, - пока экспериментально рассчитанное время не станет минимальным;
- так оптимизировался первый цикл, но не смог оптимизироваться второй. Единственная догадка, что прибавлять надо по 2 адреса, а не по 4, - и тупо оптимальный вариант проскочил, сделав больше 16 вставок по 4шт.

Поэтому, вместо идеального понижения времени второго цикла: нашёл в нём меньшее время - и подогнал под него первый цикл.

Вот что говорит гугл, если ему сказать, что его граница 16 - полное фуфло. У него всегда есть, чем отговориться. Напоминает недопрограммиста из прошлого отдела: ни 1 строчки кода за 12 лет - зато куча идей и объяснений, не имеющих практической значимости и являющихся флудом.



Теперь, когда времена циклов стали одинаковыми, с малой погрешностью и с малой её девиацией (хоть и не минимальными по времени) - это можно внедрять в генератор хаотичных данных 369ГБ/с: чтобы опозорить себя и измерить реальную скорость его генерации ~323ГБ/с...

(добавлено 17.11.2026) Теперь - нужно убирать последствия гугла. Могло совпасть, что когда добавил высочайший приоритет (и теперь это полностью подвешивает ОС) - тупо строками кода сверху оба цикла выровнял до разницы 0.1-0.15с. Каждую вероятную строку "разгона" циклов перепроверять надо.

...гугл предложил jmp вместо nop - внутри if (какие перспективы! И что ж ты молчал, сволочь). Отнёсся скептически - и не зря: не заработало. И тут он начинает нести фигню, что смещения просто не видно, - и всё в порядке. Но времена-то выполнения цикла одинаковые при разных "невидимых смещениях". Убейте его...

После переноса функционала измерения времени в генератор и повторного ручного выравнивания, стало ясно:
- выравнивание точно кратно 4;
- но место расположения оптимального адреса неясно. Прибавил 16 nop к циклу - и он заработал быстро - речь точно не о сущности 16;
- выравниваемые функции - вверху CPP-файла, насколько это возможно (даже сторонние инклуды ниже). H-файл - инклудится в самой первой строке Unit1.cpp. Посмотрим, на сколько этого хватит при изменении проекта в будущем.

Не хватило и на 1 строчку в Form_Create "String sss[5000]" - разница скоростей 2 циклов тут же сбивается. Хоть H-файл располагай в самом верху, хоть CPP-файл делай первым в настройках проекта, хоть линкуй его первым в списке (что после Project1.*, что до), хоть объектный файл делай первым в списке - фиолетово. Но были получены закономерности:
- увеличитель частоты системного счётчика времени с 15.6мс до 1мс timerBeginPeriod(1) нужно ставить до функций приоритета (так и не понял, нужны или нет, - хоть и очень критичный вопрос);
- расположение сверхточных функций выше других в CPP-файле - защищает их от смены адреса при изменении функций ниже;
- расположение в отдельном файле - точно выравнивает по границе 4;
- функции тоже могут быть volatile - защитить их от оптимизации. Но не собьёт ли выравнивание по границе 4?

Поэтому: сначала написание всех исходников полностью - потом ручное добавление nop по 4шт, найдя максимум или оптимум скорости. Но - с выравниванием сначала по границе 4 единичными nop. Это в моём случае повезло, и в выровненной функции по границе 4 исходники до цикла были написаны так, что сместились на кратное 4 адресам число, - иначе бы совсем запутался.

Есть решение средней температуры по больнице - возможно, сделаю, чтобы определить границу: 32, 64 или 128. Мой цикл, с измерением его тиков, занимает 29 адресов. Предполагая минимальную границу 32 - можно добавить 3 nop. И повторять данную конструкцию нужное количество раз с дополнительным смещением 4 nop. Потерпеть, измерить все времена во всех смещениях по границам 4 - и посмотреть, как они себя ведут.

Когда же будет определён номинал настоящего выравнивания (вдруг, относительно адреса функции выравнивание надо, а не от адреса 0x00000000, или ещё от какого). Тогда можно и выровнять правильно. А если номинал границы не будет определён - эта функция, с кучей циклов, - будет средней температурой по больнице. Её можно запускать при старте программы, заставляя пользователя ждать, - с меньшим количеством итераций, чем 4.3млрд. И выдавать результат измерения скорости не числом, а диапазоном с вычетом температуры по больнице и её прибавлением. Мне такое решение не подходит - но это выход для тех, кому нужны точные, но не сверхточные вычисления.

Напоследок - фишка компилятора. Мне не просто повезло, что было выравнивание по границе 4 начала моего цикла. Компилятор сам всё выравнивает иногда: разница между двумя long double составила 12 адресов вместо 10, при размере в 10Б, - компилятор сам дописал эти 2Б для ускорения работы. А вот почему он после моего цикла адрес не округлил с 29 до 32 - х.з.: делает что хочет и когда хочет.

(добавлено 18.11.2026) Полный писец:
- произошло неожиданное: компилятор один раз не выровнял функцию по границе 4 - компилятор делает, что ему вздумается. У гугла, несмотря на прошлые клятвенные заверения о границе 4, - куча объяснений, почему это произошло;
- в результате, пишу функцию с запуском 128 пустых циклов, каждый раз со смещением 1 nop: чтобы с произвольного адреса функции хоть как-то добраться до истин;
- написал функцию сброса кеш-линии переменной (вышибания её из всех 3-х кешей ЦП) - на результат не влияет. Сделал полное отключение оптимизации компилятором участка файла (#pragma option push -Od -r-), запретив так ему и использовать регистры, - на результат не влияет (и не имею права отключать кеширование тестируемых на время функций в будущем: результат скорости будет меньший, чем в действительности). Причём последнее - подразнило: получил 2 результата -0.002с и 0.008с - и больше таких результатов больше никогда не было.

Когда функция 128 циклов была отлажена - единичные результаты получились совсем странными. Самый быстрый цикл отработал на адресе 0x4026CF: до кратности и 16, и 32, и 64 - не хватает 15. Другой адрес минимальный 0x40270A: до кратности и 16, и 32, и 64 - не хватает 10. Третий адрес минимальный 402614: до кратности 16 надо 4 - но до 32, 64, 128 надо 20. Ещё не использованы средства выделения всех ресурсов ЦП, подвешивающих систему, - но этим и интересны эти 3 именно неточных результата. Которые вообще непонятно, как интерпретировать. А потом ещё и адрес 0x402714 всё добил.

Думаю, надо просто болт забить - сделать ручное выравнивание паре функций и всё.

Разброс цикла, при неизменном исходном коде, в зависимости от выравнивания: 11.262-12.644с.

Всё чистенько причесал, скорость генератора замерил - да, оказалась меньше, чем была: 304-345ГБ/с (зависит от места запуска: виртуальная машина, родительская ОС и т.д.). И был получен интересный результат: скорости релиза и дебага - практически сравнялись. Значит, полученные алгоритмы, действительно, делают точные измерения, - и только это недовыравнивание мешает выжать максимум.

Так как в ОС x64 адрес занимает 8Б, а не 4Б, - естественно, результат в ОС разных битностей - разный. В конкретно текущей настройке проекта - в x64 скорость меньше. Но понравилось то, что эта скорость стала постоянной. Разовый замер пустого цикла и многоразовые замеры непустого с функциями - всегда показывают точный результат, в рамках запущенного места и времени. Запустишь 5 раз подряд EXE-шник - результат с точностью 0.5-1%. Пройдёт время, запустишь ещё 5 раз подряд - получишь результат больше предыдущего на 3%, но одинаковый в рамках 5 запусков.

Это значит, что используемые парадигмы создания ультраточной функции измерения времени выполнения других функций - можно попытаться оформить в виде отдельного модуля, в бросовом проекте - для демонстрации.
Обновлено ( 18.11.2026 18:09 )
 
 

Последние новости


©2008-2026. All Rights Reserved. Разработчик - " title="Сергей Белов">Сергей Белов. Материалы сайта предоставляются по принципу "как есть". Автор не несет никакой ответственности и не гарантирует отсутствие неправильных сведений и ошибок. Вся ответственность за использование материалов лежит полностью на читателях. Размещение материалов данного сайта на иных сайтах запрещено без указания активной ссылки на данный сайт-первоисточник (ГК РФ: ст.1259 п.1 + ст.1274 п.1-3).

Много статей не имеет срока устаревания. Есть смысл смотреть и 2011, и даже 2008 год. Политика сайта: написать статью, а потом обновлять ее много лет.
Рекламодателям! Перестаньте спамить мне на почту с предложениями о размещении рекламы на этом сайте. Я никогда спамером/рекламщиком не был и не буду!
Top.Mail.Ru