Оптимизация кода C (AVR)

Ответ 1

Я могу увидеть несколько областей, над которыми нужно начинать работу, перечисленных в конкретном порядке:

1. Уменьшите количество регистров, чтобы нажать, так как каждая пара push/pop занимает четыре цикла. Например, avr-gcc позволяет удалить несколько регистров из своего распределителя регистров, поэтому вы можете просто использовать их для переменных регистров в этом одиночном ISR и быть уверенным, что они все еще содержат значение с последнего времени. Вы также можете избавиться от нажатия r1 и eor r1,r1, если ваша программа никогда не устанавливает r1 на что-либо, кроме 0.

2. Используйте локальную временную переменную для нового значения индекса массива, чтобы сохранить ненужную нагрузку и сохранить инструкции для этой изменчивой переменной. Что-то вроде этого:

volatile uint8_t amplitudePlace;

ISR() {
    uint8_t place = amplitudePlace;
    [ do all your stuff with place to avoid memory access to amplitudePlace ]
    amplitudePlace = place;
}

3. Отсчитайте назад от 59 до 0 вместо 0 до 59, чтобы избежать отдельной команды сравнения (сравнение с 0 в любом случае происходит при вычитании). Псевдокод:

     sub  rXX,1
     goto Foo if non-zero
     movi rXX, 59
Foo:

вместо

     add  rXX,1
     compare rXX with 60
     goto Foo if >=
     movi rXX, 0
Foo:

4. Возможно, вместо указателей массива используйте указатели и сравнения указателей (с предварительно рассчитанными значениями!). Его нужно проверить по сравнению с обратным отсчетом, который более эффективен. Возможно, выровняйте массивы с границами 256 байт и используйте только 8-битные регистры, чтобы указатели могли сохранять и загружать более 8 бит адресов. (Если у вас заканчивается SRAM, вы можете поместить содержимое 4 из этих 60 байтов массивов в один 256-байтовый массив и по-прежнему получить преимущество всех адресов, состоящих из 8 постоянных высоких бит и 8 младших бит переменной. )

uint8_t array[60];
uint8_t *idx = array; /* shortcut for &array[0] */
const uint8_t *max_idx = &array[59];

ISR() {
    PORTFOO = *idx;
    ++idx;
    if (idx > max_idx) {
        idx = array;
    }
}

Проблема заключается в том, что указатели имеют 16 бит, тогда как ваш простой индекс массива ранее был размером 8 бит. Помочь с этим может быть трюк, если вы создадите адреса массива таким образом, чтобы более высокие 8 бит адреса были константами (в коде сборки, hi8(array)), и вы имеете дело только с более низкими 8 битами, которые фактически изменяются в ISR, Это значит, что писать код сборки. Сгенерированный код сборки сверху может быть хорошей отправной точкой для написания этой версии ISR в сборке.

5. Если это возможно с точки зрения синхронизации, отрегулируйте размер буфера выборки до степени 2, чтобы заменить часть if- reset -to-zero простой i = (i+1) & ((1 << POWER)-1);, Если вы хотите пойти с 8-битным/8-разрядным распределением адресов, предложенным в 4. Возможно, даже переход на 256 для мощности двух (и дублирование выборочных данных по мере необходимости для заполнения 256-байтового буфера) даже сэкономит вам инструкция AND после ADD.

6. Если ISR использует только инструкции, которые не влияют на регистр состояния, остановите нажатие и нажмите SREG.

Общие

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

firmware-%.lss: firmware-%.elf
        $(OBJDUMP) -h -S $< > [email protected]

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

Если вы решите не писать этот ISR в коде ассемблера напрямую, я бы рекомендовал вам написать код C и проверить сгенерированный код сборки после каждой компиляции, чтобы сразу наблюдать за тем, как ваши изменения заканчиваются.

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

Примечание Не делая резервирования регистра, я получаю что-то около 31 цикла для ISR (исключая ввод и увольнение, что добавляет еще 8 или 10 циклов). Полностью избавиться от нажатия регистра приведет к сокращению ISR до 15 циклов. Переход к буферу выборки с постоянным размером 256 байт и предоставление эксклюзивного использования ISR из четырех регистров позволяет сэкономить до 6 циклов, потраченных в ISR (плюс 8 или 10 для входа/выхода).

Ответ 2

Я бы сказал, что лучше всего написать свой ISR в чистом ассемблере. Это очень короткий и простой код, и у вас есть существующий дизассемблер, который поможет вам. Но для чего-то такого характера вы должны быть в состоянии сделать лучше: например. используйте меньшее количество регистров, чтобы сохранить на push и pop; повторите его так, чтобы он не загружал amplitudePlace из памяти три отдельных раза и т.д.

Ответ 3

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

Ответ 4

Чтобы уточнить, ваше прерывание должно быть следующим:

ISR(TIMER1_COMPA_vect) 
{
    PORTD = amplitudes[amplitudePlace++];
    amplitudePlace &= 63;
}

Для этого потребуется, чтобы ваша таблица составляла 64 записи. Если вы можете выбрать адрес своей таблицы, вы можете уйти с одним указателем, увеличить его, а с помощью 0xffBf.

Если использование переменных вместо фиксированной константы замедляет работу, вы можете заменить переменную указателя на определенный массив:

PORTD = amplitudes13[amplitudePlace++];

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

Что касается использования реестра. Как только вы получите действительно простой ISR, как это, вы можете проверить пролог и эпилог ISR, которые нажимают и вызывают состояние процессора. Если ваш ISR использует только 1 регистр, вы можете сделать это на ассемблере и сохранить и восстановить только один регистр. Это уменьшит накладные расходы прерывания, не затрагивая остальную часть программы. Некоторые компиляторы могут сделать это за вас, но я сомневаюсь.

Если есть время и пространство, вы также можете создать длинную таблицу и заменить ++ на + = freq, где freq приведет к тому, что форма волны будет целочисленной кратной базовой частоты (2x, 3x, 4x и т.д.).), пропуская это множество образцов.

Ответ 5

Вместо того, чтобы переходить через таблицу по одной записи за раз с разными скоростями прерывания, рассмотрели ли вы вопрос о проблеме и о переходе на переменную скорость с фиксированной частотой прерывания? Таким образом, сам ISR будет тяжелее, но вы можете позволить себе запустить его с меньшей скоростью. Кроме того, с небольшой арифметикой с фиксированной точкой вы можете легко генерировать более широкий спектр частот, не вмешиваясь в несколько таблиц.

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

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

Ответ 6

Может быть, достаточно избавиться от условного и сравнения все вместе, используя арифметическое выражение:

ISR(TIMER1_COMPA_vect) 
{
        PORTD = amplitudes[amplitudePlace];

        amplitudePlace = (amplitudePlace + 1) % numOfAmps;
}

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