dxdt.ru: занимательный интернет-журнал

Посмотрим на совсем небольшой фрагмент кода.

while(1){
	GP0 = 0;
	GP0 = 1;
}

Этот код предназначен для микроконтроллера PIC12F675 (один из очень популярных и очень простых микроконтроллеров) и, можно считать, написан на C (но здесь это не важно). Некоторые пояснения для тех, кто с микроконтроллерами дела не имел: микроконтроллеры предназначены для управления прочей электроникой и электротехникой, а GP0 здесь – это такой “синтаксический сахар”, а именно – способ задать логическое значение на выводе микроконтроллера при помощи специальной, зарезервированной переменной. PIC12F675 имеет несколько подходящих выводов, все они пронумерованы: GP0..GP5 (GP – это от General Purpose). Строчкам кода, приведённым выше, ещё предшествует несколько строк, настраивающих начальное состояние микроконтроллера и задающих режим работы, это здесь тоже не важно, поскольку речь пойдёт о другом.

Итак, GP0 = 0 – “записывает” в нулевой выход логический ноль, GP0 = 1 – “записывает” логическую единицу. Так что это не совсем “запись переменной”. Вариант while(1) – не менее типовой для мира микроконтроллеров способ задать бесконечный цикл. У микроконтроллера нет развесистой операционной системы. В алгоритмическом смысле, микроконтроллеры, обычно, либо спят, либо работают в бесконечном цикле while(1), иногда – то есть, очень редко, – отвлекаясь на обработку прерываний (в данном случае, считаем, что никаких прерываний и прочих неожиданностей не происходит).

Получается, что приведённый фрагмент последовательно выполняет запись ноля и единицы в логический вывод. Какой сигнал образуется на этом выводе? Пусть логические уровни задаются напряжением 0 вольт – для ноля и +5 вольт – для единицы (на практике, понятно, используется отсечение по порогу, но, опять же, это детали из области микроэлектроники). Нетрудно предположить, что некоторые предложения языка высокого уровня C аппаратурой выполняются пошагово, а значит, на выводе с номером ноль должен появиться ноль, а потом единица, а потом опять ноль, опять единица и так далее. Продолжительность импульса – ключевой момент, о нём как раз и пойдёт речь.

Обычно, даже не знакомые с аппаратурой и языками ассемблера разработчики быстро догадываются, что, пусть в исходном коде ничего про это не написано, но какая-то продолжительность переключения всё же будет наблюдаться. Если считать, что на переключение, описанное в коде, затрачивается одинаковое время, то, подключив осциллограф для вывода развёртки по времени, сможем наблюдать набор “прямоугольных” импульсов одинаковой продолжительности (“ширины”), которые разделены “ямами” той же продолжительности (соответствует состоянию “ноль”). Такой “прямоугольный” сигнал называют “меандром”.

Однако, если скомпилировать код, прошить программу в микроконтроллер, запустить его и подключить осциллограф к нужному выводу, то картина получится несколько иная, меандр не очень-то сбалансирован. Вот результат на фото ниже.

(Здесь я использовал компилятор Microchip MPLAB XC8 версии 2.46, в бесплатном варианте.) Единицы получились в четыре раза длиннее нолей (здесь положительное направление, как обычно, вверх). Как так вышло? Вообще, “чисто структурное” понимание исходного кода подразумевает, что while(1) лишь задаёт бесконечный цикл – это доступно компилятору, а как там работают остальные детали, какой алгоритм задуман – компилятор учитывать не может. То есть, текст на ЯВУ задаёт лишь схему итераций. Это логично, но иногда нужно знать ассемблер и то, как работает аппаратура. В данном случае, происходит следующее.

Микроконтроллер работает со скоростью миллион программных тактов в секунду. Компилятор превращает цикл с двумя присваиваниями в некоторый набор кодов команд микроконтроллера. Реализация цикла должна использовать команду безусловного перехода, которая тоже потребляет такты. При этом начало цикла содержит дополнительную команду, задающую способ адресации регистров. В итоге, получается следующий набор машинных команд, которые, в результате прошивки, выполняет микроконтроллер (псевдокод, соответствующий ассемблеру; здесь loop – это метка, по которой происходит передача управления каждый раз в конце тела цикла):

loop:
 STATUS 5      // выбор режима адресации, один такт;
 SET_BIT_GP0 0 // установка бита вывода GP0 в ноль, один такт;
 SET_BIT_GP0 1 // установка бита вывода GP0 в единицу, один такт;
 GOTO loop     // переход к началу цикла, два такта;

В данном микроконтроллере GOTO (безусловный переход) занимает два программных такта, а остальные упомянутые команды – по одному. Это означает, что в цикле, между переключениями статуса вывода, будет четыре такта. Здесь перед последней командой (GOTO) вывод установлен в единицу (SET_BIT_GP0 1). Посчитаем, начиная с команды, устанавливающей единицу, такты: 1 (SET_BIT_GP0) + 2 (GOTO) + 1 (STATUS) == 4 такта. После чего вывод устанавливается в ноль на один такт. Интерпретация полностью соответствует картинке с осциллографа. Ниже, для сравнения, соответствующий фрагмент кода уже на ассемблере PIC. Точно в такой код преобразует исходную конструкцию с while(1) компилятор. Для задания состояния логического вывода микроконтроллер использует один бит в специальном регистре, поэтому тут выведены команды, устанавливающие (bsf) и сбрасывающие (bcf) биты.

mainloop: // while(...)
	bcf status, 5 // выбор режима адресации;
	bcf (5), 0    // GP0 = 0 (clear bit);
	bsf (5), 0    // GP0 = 1 (set bit);
	goto mainloop // while(1);

Получается, вывод компилятора тут не соответствовал ожиданиям при элементарном подходе. Но, конечно, догадаться о том, что реализация цикла тоже требует некоторых команд – не так трудно. Вообще же, текст программы ничего не говорит об организации цикла: while(1){…} только описывает его границы, это чисто структурный элемент, если воспринимать реализацию на высоком уровне – на языке высокого уровня.

Небольшое “лирическое отступление”. Автоматическая оптимизация циклов компиляторами является хрестоматийным примером неверной интерпретации того, как “программы работают”: многие разработчики на языках высокого уровня, – даже опытные, – пытаясь измерять производительность реализации той или иной функции, начинают с того, что вызывают функцию повторно в цикле, фиксируя время начала и время окончания, – лишь для того, чтобы по результатам измерений обнаружить, что функция “исполняется” практически мгновенно, поскольку оптимизирующий компилятор просто выкинул её вызов из результирующего кода, так как выяснилось, что вывод функции в программе ни на что не влияет (а что касается переменной счётчика цикла, то тут всё заменяется на единственное присваивание – в переменную записывается окончательное значение, которое можно определить на этапе компиляции). Интересно, кстати, что конкретно в C есть и достаточно много неопределённостей на уровне языка, связанных с обработкой присваиваний значений переменным, но наш пример – это не тот случай, поскольку здесь диалект C использует не-совсем-переменные для вывода электрических значений на контакты.

Вернёмся к рисованию меандра программой для микроконтроллера. Хотелось бы получить “ровный” меандр. На языке C для PIC в нашем конкретном случае это можно сделать так.

while(1){
	GPIO = GPIO^0x01;
}

Здесь присваивание значений конкретным выводам заменено на XOR для всего регистра. GPIO – это псевдоним, обозначающий тот самый специальный регистр (массив битов), биты которого соответствуют конкретным логическим выводам. В нашем случае – переключается нулевой вывод (GP0), поэтому изменяется младший бит (бит с индексом нуль, этому соответствует значение маски – 0x01, единица). Логика, стоящая за данным решением, следующая: нужно исключить из тела цикла двойственность состояний. А именно – XOR переключает бит: если там был ноль, то будет единица, если была единица, то станет ноль; тут больше нет записи двух разных значений. Такой вариант кода гораздо лучше соответствует задаче, если бы задачей было получение “ровного, сбалансированного” меандра (заметьте, впрочем, что изначальная задача этой записки – другая: определить, что выводится микроконтроллером и, главное, почему).

Меандр “сбалансировался”, а результат, демонстрируемый осциллографом, поменялся, что и видно на фото экрана ниже.

Однако длительность каждого импульса теперь равна шести тактам. Почему? Потому что компилятор дописал новых команд, опасаясь за целостность общей логики кода: значения в регистрах микроконтроллера могут поменяться вне зависимости от работы АЛУ (арифметико-логического устройства). И это только нам известно, что подобные изменения не предусмотрены ни схемой включения, ни настройками микроконтроллера, а вот компилятор про это догадаться не может, поскольку компилятор не видит сам алгоритм.

Если PIC-ассемблер взять, что называется, в руки, то данный цикл можно оптимизировать. Во-первых, команду выбора схемы адресации можно вынести за пределы цикла, так как выбор зафиксирован. Это сэкономит один такт. Во-вторых, компилятор здесь записывает предложение “GPIO = GPIO^0x01” в три команды: загружает значение специального регистра GPIO в рабочий регистр (в PIC-микроконтроллерах он называется W), выполняет XOR и записывает значение в GPIO. Но нужный XOR можно сделать в одну команду, загрузив заранее, до начала цикла, маску (единицу) в рабочий регистр W и выполняя XOR непосредственно с GPIO. Это позволит сэкономить ещё два такта. А вот два такта, нужных на goto – так сэкономить уже не выйдет (можно, наверное, придумать особенно экзотические методы, но это на общий смысл не повлияет). Естественно, всё это возможно только потому, что задача сводится к преобразованию цикла записи состояний в значение одного логического вывода микроконтроллера, но в итоге – можно добиться трёх тактов на цикл. Соответствующий фрагмент ассемблерного кода приведён ниже.

        bcf     status, 5
        movlw   0x01
mainloop:
        xorwf   (5), 1
        goto    mainloop

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

Конечно, реальная ситуация может быть сложнее, а компилятор может “догадаться” о какой-то лучшей оптимизации. Если рассматривать современные мощные микропроцессоры, то там, например, вообще сложно судить о реальном количестве тактов, затрачиваемых той или иной машинной командой, даже на уровне ассемблера. Ассемблер сейчас не всегда нужен, даже если нужно программировать микроконтроллеры, но знакомство с ассемблерами и принципами работы той аппаратуры, на которой программа будет исполняться, часто помогает осознать причины несоответствия ожиданий тексту программы на языке высокого уровня.

Адрес записки: https://dxdt.ru/2024/07/29/13493/