Бывает ситуация, когда вот стоит нормальный, не ветхий дом с жильцами, с работающими коммуникациями. И простоял бы он так еще много лет. Но принято решение проложить новую магистраль и дом ей мешает. Можно снести дом, недалеко построить новый и жильцов туда переселить. А можно переместить в нужное место сам этот дом прямо вместе с жильцами и тараканами.

Такая аналогия приходит на ум после принятия решения о переходе с платформы Windows на пока единственную сертифицированную альтернативу – ОС Астра Линукс. Как жильцы гипотетического дома не могли отменить решение о магистрали, так и мы не можем отменить это решение. Придется переходить. Однако легко сказать «перейти». Когда я познакомился с IBM-PC/XT, какой-нибудь Торвальдс еще школу не кончил. За эти годы (чего уж там годы - десятилетия) появилось много привычек, приемов, навыков. Жалко все это оставлять ради принудительного перехода в другую среду. И приходит мысль – попытаться переехать, так сказать, всем домом, а не строить новый.

Для броского заголовка здесь надо было бы употребить термин «супер-оптимизация» или даже «гипер-оптимизация». Но приставки «супер» ко всему на свете настолько затасканы, что, например, вполне нормальный и даже научный термин «супер-программирование», стал больше ассоциироваться с достижениями каких-то неведомых «супер-программистов», а не с методами преобразования программ. С другой стороны, народное творчество определяет «супер-программирование» как программирование во время варки супа. Поэтому буду использовать не хвастливую «супер», а всего лишь скромную «мета».

Мета-оптимизация (или, еще проще, над-оптимизация) - это оптимизация, примененная к другим методам оптимизации. Мне очень нравится придумывать в компиляторе, который я сопровождаю, всякие оптимизации. Но применить мета-оптимизацию как-то не приходило в голову. Натолкнул случай.

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

В компиляторе при генерации кода имеется такой момент, когда большинство команд будущей программы (точнее, компилируемого модуля) уже сгенерировано, но их еще можно менять или выбрасывать, поскольку адреса команд переходов и вызовов еще не вычислены, а окончательный размер кода программы (точнее, этого модуля) еще не получен.

Вот этот момент и является самым удобным для проведения «тактической» оптимизации в пределах 2-3 соседних команд. Как правило, и анализ при такой оптимизации очень прост, поскольку можно сравнивать прямо двоичные коды с шаблонами, а не проводить детальное изучение множества операций и их операндов во внутреннем представлении будущей программы.

Рассмотрим некоторые приемы оптимизации «сверткой» на простейшем примере.

Нет-нет, я не собираюсь рассказывать все прибаутки о константах, вроде того, как связано число E и год рождения Льва Толстого. Речь о другом.
Как-то один мой коллега попросил меня «свежим взглядом» посмотреть его программу. Он проводил проверочный расчет, и в итоге должна была получиться единичная матрица. На месте нулевых элементов оказались величины, близкие к нулю – что-то около 10**-17, что можно объяснить погрешностью расчета и исходных данных. Но у трех элементов было значение 10**-7. Вопрос состоял в том, а, собственно, почему так? ведь все формулы «симметричны».

Как известно, интерпретируемые и компилируемые языки имеют преимущества и недостатки относительно друг друга. Одним из таких преимуществ/недостатков является сохранение связи имени переменной из исходного текста с соответствующим объектом программы во время выполнения.

Для интерпретируемых языков эта связь естественным образом сохраняется, так как интерпретатор собственно и «выполняет» исходный текст программы, т.е. имеет к нему непосредственный доступ.

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

Я уже писал заметку об этом и вот решил продолжить тему второй частью. Для тех, кто не любит ходить по ссылкам, кратко напомню, о чем шла речь в первой части.

Позапрошлую заметку я начинал словами «вот уже 10 лет прошло…», а эту можно было бы начать «вот уже 20 лет прошло…». Хотя там речь шла лишь о выравнивании стека, а здесь – о целой организации взаимодействия программы с WinAPI. Помнится, здесь недавно в комментариях кто-то наивно удивлялся: зачем вы приводите устаревший и никому не интересный способ программирования через WinAPI? А как же иначе программа вообще может взаимодействовать со средой Windows, как не через вызовы ее стандартных функций? Через имеющиеся надстройки над WinAPI не все можно сделать.

Конечно, было бы прекрасно все время оставаться в рамках парадигмы используемого языка программирования и чтобы «на фотографии не торчали уши фотографа», т.е. чтобы в исходных текстах никак не проявлялись бы особенности взаимодействия со средой. Например, в большинстве языков есть понятие файла. Чтобы открыть файл не обязательно явно описывать стандартную функцию из WinAPI CreateFile или OpenFile, поскольку компилятор переведет встроенный в язык оператор открытия или прямо к обращению к этой функции или к вызову системной библиотеки, которая где-то внутри себя и вызовет требуемую функцию. В любом случае программист не обязан знать, как именно это реализовано в Windows.

В системной библиотеке языка PL/1-KT, который я использую, имеется обращение лишь к 28 функциям WinAPI и это вполне покрывает «обычные» возможности языка и можно было бы не заботиться о явных вызовах. Но увы, часто этого мало. И хотя нормальные люди ходят в двери, а не в окна (ах, какая свежая, искрометная шутка!), приходится в программах явно обращаться к функциям типа CreateWindow или CloseWindow. А это уже ну никак не входит в понятия языка.

Сначала я хотел назвать эту заметку «Редактор связей? Это очень просто». Именно так называл свои прекрасные книжки Евгений Айсберг: «Радио? Это очень просто!», «Телевидение? Это очень просто!» Но поскольку я уже использовал эту шутку в статье о планировщике Windows, чтобы не повторяться, теперь использую любимую формулу многих журналистов: «Вся правда о…».

На самом деле никакую ужасную правду о редакторе связей раскрывать не требуется. Для программистов старшего поколения эта заметка вообще вряд ли будет интересна, поскольку в ней описываются банальные вещи. Но я, к сожалению, неоднократно сталкивался с самыми дикими представлениями о работе, например, компилятора или того же редактора связей у молодого поколения работников ИТ. И я их даже не обвиняю. На фоне чудовищного потока информации в современном программировании заставлять кого-то еще шарить по книгам и сайтам, чтобы разобраться, как работает утилита, внутрь которой они никогда не полезут – это даже не этично.

Другое дело я, который сопровождает и даже по мере сил развивает средства программирования. Приходится разбираться и с работой редактора связей, а, значит, как говорится, мне и карты в руки. Попробую кратко и на пальцах объяснить назначение и работу этого программного инструмента. И не просто объяснить, а привести примеры из конкретной реализации. Иначе абстрактные рассуждения плохо воспринимаются. Сам не люблю лекторов, которым кажется, что им достаточно поводить пальцем в воздухе, чтобы аудитория все поняла с полуслова. Так не бывает.

Вот уже 10 лет прошло, как я переводил свои средства программирования в среду x86-64 для Windows 7. А как будто вчера было! Поскольку тогда многие особенности этой среды были для меня внове, они вызывали недоумение. Вот типичный пример.

Речь пойдет о безымянных константах в программе, которые часто называют литералами. Если такой литерал нельзя использовать как непосредственный операнд в машинной команде, компилятору приходится выделять – а куда деваться! – этому литералу собственную память и далее оперировать адресом этой памяти.

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

Уже очень давно создана и работает программа, отображающая космонавтам движение МКС на карте земной поверхности.

МКС, конечно, двигается вовсе не по земной поверхности, а по орбите. Но если соединить станцию и центр Земли прямой, то точка пересечения этой прямой с земной поверхностью будет являться т.н. «подспутниковой» точкой. Совокупность этих точек составляет «трассу» полета. Другими словами, трасса – это проекция на земную поверхность плоскости орбиты. Если земная поверхность представлена схематичным изображением континентов в цилиндрической проекции, то трасса МКС (наклонение ее орбиты 51,8°) отобразится кривой, напоминающей синусоиду. И где-то на этой «синусоиде» обычно красным кружочком отображается текущее положение МКС...

Все началось с глупой ошибки. В тексте программы вместо оператора x=20; где x – целая переменная со знаком и размером в байт, случайно написали x=200;

И компилятор, что называется не моргнув глазом, сформировал команду записи в переменную x константы 0C8H, что вообще-то соответствовало оператору x=-56; Выяснилось, что за долгие годы эксплуатации этого компилятора ни одна собака ни один пользователь (включая и нас самих) никогда не писал подобных ляпов и поэтому ошибка в компиляторе оставалась незамеченной. А виноваты оказались команды сужения данных.

Термин «мертвый код» - это, скорее, жаргонное, чем научное название участков программы, на которые не может попасть управление и, таким образом, они никогда не выполняются. Разумеется, в нормальных программах таких участков быть не должно. Но поскольку языки программирования становятся все сложнее и сложнее (а программисты все тупее и тупее, шутка!) в кодах программ может быть все, что угодно.

Я уже плакался по поводу исключения в x86-64 команд двоично-десятичной арифметики DAA/DAS и плакался по поводу отмены команды проверки целочисленного переполнения INTO. Теперь настала очередь плакаться по поводу выброшенной команды BOUND. Как говорится, леди и джентльмены, подставляйте свои жилетки и декольте. Начинаю плач.

Я уже упоминал, каким неприятным сюрпризом оказалось исключение команды INTO из системы команд x86-64, когда я переводил компилятор на эти команды. Давайте разберемся, нужна ли сейчас команда, которая отвечала за контроль целочисленного переполнения еще со времен процессора 8086.

Кстати, а чего вообще прицепились к этому целочисленному переполнению? И зачем для него иметь еще какую-то отдельную проверку? Например, ну, нет же никакой отдельной команды INTD проверки деления на число с нулевым значением.

Среди бесчисленных режимов адресации архитектуры х86 существует один такой…
Впрочем, почему «бесчисленных» режимов? Если разобраться, то их немного. Со времен первого процессора 8086 адресация укладывалась в байт, который имел аббревиатуру MODRM, где «MOD» - это собственно режим адресации (т.е. mode), «R» - регистр и «M» - очевидно, память (memory).
Если не рассматривать дальнейшее совершенствование системы адресации с помощью SIB-байта, то, поскольку под MODE в MODRM-байте выделено всего два бита, получается, что возможны всего-навсего четыре режима адресации.

Программисты старшего (и очень старшего) возраста наверняка помнят такую книгу Фролова и Олюнина: «Практический курс программирования на языке PL/1», изданную в 80-х массовым тиражом. В те времена не было Интернета, и поэтому получить нужную информацию можно было, только купив или взяв в библиотеке или у коллеги соответствующую книгу. Поэтому и специальная литература издавалась в Советском Союзе фантастическими по нынешним меркам тиражами. Впрочем, в масштабах страны тогда и стотысячный тираж не мог обеспечить требуемыми экземплярами все библиотеки. Но даже с учетом всех этих обстоятельств, общий тираж изданий книги Фролова и Олюнина велик, он превысил 300 000! Наверное, это был самый массовый учебник по языку программирования в нашей стране. А ведь это было всего лишь учебное пособие для студентов.

Еще послужит

Так и тянет меня задать в заголовке статьи вопрос, что по здешним правилам не допускается. А ответ опять очевиден: регистр SPL вообще не нужен.

Я уже давно выступал с критикой системы команд AMD64, сейчас более известной как x86-64. Причем, задача специально анализировать появившиеся и исчезнувшие команды не стояла. Просто при переносе средств программирования с Win32 на Win64 возникал ряд проблем, вызывавших один и тот же вопрос: «почему же раньше все работало, а теперь нет?». Это касается некоторых выброшенных разработчиками архитектуры AMD64 команд, которые пришлось эмулировать, и, особенно, аппаратной поддержки контроля целочисленного переполнения с помощью инструкции INTO, которая вдруг стала недоступной.

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

Но все-таки проблемы как-то разрешились, и пришло время не только бороться с недостатками системы команд AMD64, но и воспользоваться ее достоинствами. А основных достоинств, по сравнению с IA-32, напомню, два: восьмибайтная адресация, снимающая предел в 4 Гбайт, и увеличенное число регистров общего назначения в два раза.

В случае регистров размером в 2, 4 или 8 байт действительно все логично и естественно. Можно даже сказать, что число регистров увеличилось более чем в два раза, поскольку указатель стека и не используется в вычислениях как остальные. Поэтому в IA-32 у программиста реально было 7 регистров общего назначения, а в AMD64 их стало 15, т.е. RAX, RBX, RCX, RDX, RBP, RSI, RDI и R8-R15.

Что-то не получаются у меня заголовки статей. Потому, что на вопрос «Как увеличить стек FPU?» очевидно же следует прямой и ясный ответ – да никак. Это же аппаратное устройство. Даже если бы и удалось увеличить его стек – тогда пришлось бы переделывать систему команд, рассчитанную на адресацию только 8 регистров ST0-ST7 Да и зачем его увеличивать? Для большинства выражений он и так очень глубокий, прямо-таки бездонный. Стоп. Я забегаю вперед. Ведь статью могут читать и те, кто никогда не разбирался с командами процессора на низком уровне. Поэтому начну с самого начала.

Стоп. Я забегаю вперед. Ведь статью могут читать и те, кто никогда не разбирался с командами процессора на низком уровне. Поэтому начну с самого начала.

Итак, FPU (Float Point Unit) – устройство в процессоре x86 для вычислений чисел с «плавающей точкой» в формате IEEE-754. Когда-то это была отдельная микросхема 8087 с названием «сопроцессор». Работала параллельно с основным процессором 8086 и даже была команда WAIT, которая останавливала программу и дожидалась конца выполнения очередной долгой команды сопроцессора. Я еще помню времена, когда у нас в отделе на несколько ПК был лишь один сопроцессор, мы его выковыривали отверткой и переустанавливали на тот ПК, на котором проводились большие вычисления. С появлением процессора 80486 FPU переселилось внутрь его кристалла, и проблема ушла. Кстати, команда WAIT осталась, но работает теперь не так. Впрочем, все это присказка. Главное – у FPU есть собственный стек на восемь патронов, поэтому проводить вычисления очень удобно, а для адресации в командах FPU любого объекта в этом стеке достаточно трех бит в коде каждой такой команды.

Очередной «смешной случай из жизни» заставил немного понервничать.

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

Однако при эксплуатации получилось не очень удобно. Дело в том, что если при крахе приложение снять, то, естественно, графическое окно исчезает, и пользователю, по крайней мере, сразу видно, что вся система рухнула. Правда и информация о крахе системы так же исчезает с одновременным закрытием и консольного окна. А вот если управление перехватывает отладчик в консольном (свернутом по умолчанию) окне, то графическое изображение на экране «замораживается» и при беглом взгляде может показаться, что все еще продолжает работать. Бывали случаи введения пользователя такой картиной в заблуждение. В конце концов, был найден компромисс: при исключении программа все-таки снимается, но вся информация, выдаваемая в консольном окне, дублируется еще и в файл протокола.

В нашей системе программирования так легко сделать, поскольку в системной библиотеке перед каждой выдачей очередного байта стандартного сообщения в стандартную консоль, идет проверка: а есть ли подпрограмма пользователя, которую нужно каждый раз вызывать перед очередной выдачей байта? Если есть – она вызывается с единственным параметром, этим самым байтом.