{метка:} {параллельность} {[условие]} мнемоника {модуль} операнд1, операнд2 … {; комментарии} 

; Начало цикла: for(i = lenBuff - 1; i >= 0; i--) {
           ; Определение начального значения переменной цикла
           SUB .L2    lenBuff_A, 1, i_B    ; i = lenBuff - 1;
		   
           ; Определение начального значения индекса
           ; входного и выходного буферов
           ZERO .L1   count_A               ; count = 0;
		   
           ; Точка обратного перехода при циклических
           ; вычислениях
loop:
           ; Чтение данных из входного буфера
           LDH .D1T1 *+pInpBuff_A[count_A], var_A
                                            ; var = pInpBuff[count];
           ; Ожидания завершения операции чтения (4 такта)
           NOP 4
		   
           ; Умножение отсчета на два (при помощи сдвига)
           SHL .S1    var_A, 1, var_A        ; var <<= 1;
		   
           ; Запись результата в выходной буфер
           STH .D1T1  var_A, *+pOutBuff_A[count_A]
                                              ; pOutBuff[count] = var;
           ; Инкрементация индекса массива
           ADD .L1 count_A, 1, count_A        ; count++;

          ; Условный переход на метку с параллельной
          ; декрементацией переменной цикла
 [i_B]    B  .S2 loop
|| [i_B]  SUB .L2 i_B, 1, i_B
          ; Ожидания завершения операции условного
          ; перехода (5 тактов)
          NOP 5 ; }
; Конец цикла

Жирным шрифтом показаны мнемоники, а курсивом — комментарии. В данном примере реализован цикл умножения входного буфера на два и запись результата в выходной буфер.

Состав основных команд ассемблера процессоров семейства TMS320C6000:

• Арифметические операции:
  • сложение (мнемоники — ADD, ADDU, SADD, ADD2, ADDAB, ADDAH, ADDAW);
  • вычитание (мнемоники — SSUB, SUB, SUBU, SUBC, SUB2, SUBAB, SUBAH, SUBAW);
  • умножение (мнемоники — MPY, MPYU, MPYUS, MPYSU, MPYH, MPYHU, MPYHUS, MPYHSU, MPYHL, MPYHLU, MPYHULS, MPYHSLU, MPYLH, MPYLHU, MPYLUHS, MPYLSHU, SMPY, SMPYHL, SMPYLH, SMPYH);
  • сдвиг (мнемоники — SHL, SHR, SHRU, SSHL);
  • модуль (мнемоника — ABS).
• Логические действия:
  • логические операции (мнемоники — AND, NOT, OR, XOR);
  • операции сравнения (мнемоники — CMPEQ, CMPGT, CMPGTU, CMPLT, CMPLTU).
• Работа с памятью:
  • чтение (мнемоники — LDB, LDBU, LDH, LDHU, LDW);
  • запись (мнемоники — STB, STH, STW).
• Прочие (мнемоники — MV, MVC, MVK, MVKH, MVKLH, NORM, NEG, ZERO, LMBD, SAT, B, CLR, EXT, EXTU, SET).

Выше дан только краткий перечень основных команд. Более подробное описание команд можно посмотреть в литературе, поставляемой вместе с CCS под номером SPRU189.

Для вызова перечня прилагаемой к ИСР CCS справочной литературы необходимо в главном меню выбрать пункт Help, а в нем подпункт User Manual. (рис. 3). В статье будут описаны только те команды, которые присутствуют в примере ассемблерного кода.

Рис. 3. Вызов перечня дополнительной литературы

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

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

Затем необходимо определить имя функции, которую нужно переписать на ассемблере. Для примера выбрана функция convolution(). Необходимо установить курсор на файл convolution.cpp, содержащий требуемую функцию, и, щелкнув на нем правой кнопкой мыши, выбрать в контекстном меню пункт File Specific Options (рис. 4a). В появившемся окне на закладке Compiler в разделе Category выбрать пункт Assembly и установить флажок в позиции Keep generated .asm Files (рис. 4б).

Рис. 4. Вызов перечня дополнительной литературы

Нажать кнопку подтверждения ввода параметров (кнопка «OK»). Выбранный файл будет отмечен желтым цветом (рис. 4в), что говорит об отличии параметров его настройки от параметров настройки проекта в целом.

Откомпилировать проект заново, нажав кнопку . В папке проекта появится ассемблерный файл convolution.asm. В нем находится сгенерированный CCS ассемблерный код для выбранной функции (рис. 5).

Рис. 5. Файл с ассемблерным кодом

Из этого файла необходимо извлечь две строки:

«.sect «.text»» — секция, где расположена функция;
«.global _convolution__FPsT1s» — ассемблерное имя функции.

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

• Соглашение первое. Регистры А0–А9 и В0–В9 могут быть использованы вызываемой функцией без ограничений. Регистры А10–А15 и В10–В15 не могут быть использованы вызываемой функцией без их предварительного сохранения в стеке.
• Соглашение второе. Регистры А1–А2 и В0–В2 быть использованы в качестве регистров условия при выполнении команд (поле «условие»).
• Соглашение третье. Регистр В3 предназначен для передачи в вызываемую функцию адреса возврата.
• Соглашение четвертое. Регистры А4, В4, А6, В6, А8, В8, А10, В10, А12, В12, А14, В14 предназначены для передачи в вызываемую функцию ее параметров с первого по двенадцатый соответственно. Если параметров больше чем двенадцать, то они передаются через стек. В данном примере передача параметров через стек не рассматривается.
• Соглашение пятое. Регистр В15 предназначен для хранения адреса вершины стека.

Шаблон ассемблерного файла выглядит следующим образом:

; Назначение имен регистров
      .asg B3, adrReturn_B
      .asg B15, SP

; Определение функции

; Запрет прерываний
                MVC     .S2      CSR, B0
                AND     .S2      B0, -2, B1
                MVC     .S2      B1, CSR

; Сохранение регистров в стеке
                STW     .D2T2    B0, *-SP[11]

; Алгоритм обработки

; Восстановление регистров
                LDW     .D2T2    *-SP[11], B0
                NOP 4

; Восстановление регистра CSR
                MVC     .S2      B0, CSR

; Выход из функции
                B       .S2      adrReturn_B
                NOP 5

В разделе «Назначение имен регистров» регистрам общего назначения присваиваются осмысленные имена. Эту функцию выполняет директива предпроцессора «.asg». Обычно этот раздел ассоциируется с той частью программного кода функции на языке Си, где происходит создание локальных переменных, а также с параметрами функции.

Раздел «Определение функции» предназначен для указания секции размещения функции (директива предпроцессора «.sect»), определения имени (директива — «.global») и установки точки входа в функцию (установка метки с именем функции). Для рассматриваемого примера:

     .sect  «.text»                 ; секция размещения функции
     global _convolution__FPsT1s    ; имя функции
_convolution__FPsT1s:               ; точка входа в функцию

Написание ассемблерного кода подразумевает использование программного конвейера. Для корректной работы функции необходимо запретить обработку прерываний на время выполнения конвейера, что обеспечивается установкой нулевого значения в первом бите служебного регистра CSR. Работать напрямую со служебными регистрами в ЦСП семейства TMS320C6000 нельзя. Поэтому в разделе «Запрет прерываний» значение регистра CSR переносится в РОН при помощи специальной команды считывания и записи служебных регистров:

           MVC      .S2        CSR, B0.
		   

Установка в ноль первого бита производится наложением маски:

           AND        .S2         B0, -2, B1.

Новое значение перемещается в CSR:

           MVC        .S2          B1, CSR.

Старое значение CSR сохранено в РОН B0.

Если необходимо использовать все регистры общего назначения, то в разделе «Сохранение регистров в стеке» значения регистров с номерами 10–15 переносятся в стек. В примере в стеке сохраняется только старое значение CSR. Операция выполняется командой «STx»:

           STW          .D2T2 B0,     *-SP[11],

где «W» означает сохранение 32-разрядного значения («B» для 8-ми разрядного и «H» для 16-ти разрядного); «.D2T2» означает использование для обработки команды модуля АЛУ «.D2»; «*- SP[11]» определяет место в стеке, где сохраняется значение регистра B0 (адрес определяется как разность базового адреса SP и смещения, указанного в квадратных скобках).

Перенос данных из памяти в регистр и наоборот осуществляют специальные элементы ядра ЦСП, называемые путем коммутации. Их всего два. Один обеспечивает сохранение/чтение данных на стороне A(регистры A0–A15), а другой — на стороне B (регистры B0–B15). На какой стороне сохранять (или с какой читать) данные, определяют суффиксы «T1» и «T2». В данном случае «T2» указывает на то, что чтение данных производится со стороны B.

Перед выходом из функции необходимо восстановить значения регистров общего назначения с номерами 10–11, а также старое значение CSR. Это действие выполняется в разделе «Восстановление регистров» при помощи команды «LDx». В примере происходит восстановление только старого значения регистра CSR:

           LDW          .D2T2         *-SP[11], B0.

Значение полей аналогично полям команды «STx». Необходимо учитывать, что результат выполнения команды чтения памяти появится в регистре общего назначения только через 4 такта. Поэтому выполняются четыре пустых оператора (NOP 4).

В разделе «Алгоритм обработки» располагается ассемблерный код алгоритма обработки, который реализует функцию.

Раздел «Выход из функции» определяет точку выхода из функции:

           B           .S2             adrReturn_B,

где «B»— команда перехода; «.S2»— используемый для выполнения команды модуль; «adrReturn_B»— регистр, содержащий адрес возврата из функции.

Команда перехода выполняется с задержкой на пять тактов (NOP 5).

При необходимости, перед выполнением команды выхода из функции в регистр A4 заносят возвращаемое значение. Прежде чем заполнить раздел «Алгоритм обработки», модифицируем программный Си-код функции. Это делается для более полного соответствия кода на языке высокого уровня коду на ассемблере. Такой подход позволяет значительно упростить как написание ассемблерного кода, так и его отладку. При модификации Си-кода необходимо придерживаться следующих правил:

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

Текст модифицированного С-кода функции convolution() имеет вид:

#include «filter.h»
word16 convolution(word16* pSimpl, word16* pCoeff, word16 sizefilter){
// Объявление локальных переменных
word32 sum; // Переменная для накопления суммы
word32 mpy; // Переменная для временного хранения
// результата умножения
word32 n; // Переменная цикла
word16 coeff; // Переменная для коэффициента фильтра
word16 simpl; // Переменная для отсчета из линии задержки
// Инициализация локальных переменных
sum = 0; // Установка начального значения суммы
// Цикл обработки линии задержки
for(n = sizefilter — 1; n >= 0; n--){
// Чтение коэффициента фильтра
// с последующей инкрементацией адреса
coeff = *pCoeff++;
// Чтение отсчета из линии задержки
// с последующей инкрементацией адреса
simpl = *pSimpl++;
// Умножение коэффициента на отсчет
mpy = coeff * simpl;
// Накопление результата умножения
sum += mpy;
}
// Коррекция адреса линии задержки
pSimpl--;
// Цикл сдвига линии задержки
for (n = sizefilter — 2; n >= 0; n--){
// Чтение предыдущего отсчета
simpl = pSimpl[-1];
// Запись предыдущего отсчета на место текущего
// с последующей декрементацией адреса
*pSimpl-- = simpl;
}
// Нормирование результата суммирования
sum >>= 15;
// Выход из функции
return sum;
}

После набора кода необходимо откомпилировать программу, запустить на выполнение и убедиться в ее корректной работе (сравнив выходные файлы, как это описывалось ранее).

Исходя из модифицированного С-кода функции гораздо проще написать ассемблерный код. Один из возможных вариантов ассемблерного кода (написанный на основе приведенного выше шаблона ассемблерной функции) имеет вид:

; Назначение имен регистрам
.asg A4, pSimpl_A ; word16* pSimpl;
; (первый параметр функции)
.asg A5, simpl_A ; word16 simpl;
.asg A6, sizefilter_A ; word16 sizefilter;
; (третий параметр функции)
.asg A7, sum_A ; word32 sum;
.asg A8, mpy_A ; word32 mpy;
.asg B0, n_B ; Переменная цикла
.asg B3, adrReturn_B ; Адрес возврата
.asg B4, pCoeff_B ; word16* pCoeff;
; (второй параметр функции)
.asg B6, coeff_B ; word16 coeff;
.asg B15, SP ; Указатель на стек
; Определение функции
.sect «.text» ; секция размещения функции
.global _convolution__FPsT1s ; имя функции
_convolution__FPsT1s: ; точка входа в функцию (метка)
; Запрет прерываний
MVC .S2 CSR, B0
AND .S2 B0, -2, B1
MVC .S2 B1, CSR
; Сохранение регистров в стеке
STW .D2T2 B0, *-SP[11]
; Алгоритм обработки
; Инициализация локальных переменных
ZERO .D1 sum_A ; sum = 0;
; Цикл обработки линии задержки
; for(n = sizefilter - 1; n >= 0 n++){
; Определение начального значения переменной цикла
SUB .L2 sizefilter_A, 1, n_B
loop01: ; Точка возврата при циклических вычислениях
LDH .D2T2 *pCoeff_B++, coeff_B
; coeff = *pCoeffTmp++;
LDH .D1T1 *pSimpl_A++, simpl_A
; simpl = *pSimplTmp++;
NOP 4 ; Ожидание завершения операции чтения
; данных из памяти
MPY .M1X coeff_B, simpl_A, mpy_A
; mpy = coeff * simpl;
NOP ; Ожидание завершения операции умножения
ADD .S1 sum_A, mpy_A, sum_A
; sum += mpy;
; Условный переход при циклических
; вычислениях и одновременная условная
; декрементация переменной цикла
[n_B] B .S2 loop01
|| [n_B] SUB .L2 n_B, 1, n_B
NOP 5 ; Ожидание завершения операции
; условного перехода
; }
; Коррекция адреса линии задержки
SUB .L1 pSimpl_A, 2, pSimpl_A
; pSimplTmp--;
; Цикл сдвига линии задержки
; for (n = sizefilter — 2; n >= 0; n--){
; Определение начального значения переменной
; цикла
SUB .L2 sizefilter_A, 2, n_B ;
loop02: ; Точка возврата при циклических вычислениях
LDH .D1T1 *pSimpl_A[-1], simpl_A
; simpl = pSimplTmp[-1];
NOP 4 ; Ожидание завершения операции чтения
; данных из памяти
STH .D1T1 simpl_A, *pSimpl_A--
; *pSimplTmp-- = simpl;
; Условный переход при циклических
; вычислениях и одновременная
; условная декрементация переменной цикла
[n_B] B .S2 loop02
|| [n_B] SUB .L2 n_B, 1, n_B
NOP 5 ; Ожидание завершения операции
; условного перехода
; }
; Нормирование результата суммирования
SHR .S1 sum_A, 15, sum_A ; sum>>=15;
; Восстановление регистров
LDW .D2T2 *-SP[11], B0
NOP 4
; Восстановление регистра CSR
MVC .S2 B0, CSR
; Выход из функции
; Перемещение возвращаемого значения в регистр A4
MV .S1 sum_A, A4
B .S2 adrReturn_B
NOP 5

Необходимо создать файл для исходного кода, набрать текст ассемблерной функции и сохранить его с именем «convolution_my.asm», затем подключить его к проекту, как это было показано в предыдущей статье цикла.

Теперь к проекту подключено два файла, в которых описана одна и та же функция convolution():

• в файле «convolution.cpp» функция представлена кодом на языке Cи;
• в файле «convolution_my.asm» эта же функция представлена на ассемблере.

Необходимо исключить файл с Си-кодом из процесса компиляции. Для этого нужно щелкнуть правой кнопкой мыши на файле и выбрать пункт File Specific Options (рис. 6a).

Рис. 6. Исключение файла из процесса компилирования проекта

В появившемся окне перейти на закладку General и установить флажок в позиции Exclude file from build (рис. 6б).

Затем необходимо произвести компиляцию проекта и запустить программный код на выполнение. Сравнив результаты, полученные при выполнении программы с Си-кодом и с ассемблерным кодом функции convolution(), можно убедиться в их идентичности.

В конце статьи рассмотрим краткое описание применяемых ассемблерных команд.

Суффикс «Х», появившийся у объявления модуля выполнения команды умножения:

    MPY     .M1X        coeff_B, simpl_A, mpy_A,

говорит о том, что один из входных операндов находится в противоположном относительно модуля наборе РОН. Для этой операции используется специальный элемент ядра ЦСП — кросс-путь. Таких элементов только два — один обеспечивает перенос данных из регистров A0–A15 для модулей с номером 2, а другой — в обратном направлении (данных из регистров B0–B15 для модулей с номером 1). Использовать кросс-путь могут все модули, за исключением модуля «.D».

Ниже приведено краткое описание команд, использованных в рассмотренном примере.

• .asg — директива, которая назначает РОН произвольное имя.
• .sect — директива, которая определяет секцию в памяти, где будет размещен бинарный код функции.
• .global — директива, которая определяет глобальное имя функции.
• MVC — команда перемещения 32-разрядных данных между РОН и РСН. Выполняется модулем «.S2».
• MV — команда перемещения 32-разрядных данных между РОН. Выполняется модулями «.S», «.L» или «.D».
• AND — поразрядная операция «логическое И». Выполняется модулями «.S» или «.L».
• STW— команда заполняет память 32-разрядным знаковым значением из РОН.

Выполняется только модулем «.D». Например,

    STW     .D2T2        Src,*-baseR[offsetR],

где Src — регистр с данными; baseR и offsetR — базовый адрес и смещение для переноса данных соответственно. Значение регистра с базовым адресом после выполнения команды остается прежним.

• STH — команда заполняет память 16-разрядным знаковым значением из РОН. Выполняется только модулем «.D». Например,

    STH     .D2T2          Src,*baseR--,

где Src — регистр с данными, baseR — базовый адрес для переноса данных. Значение регистра с базовым адресом после выполнения команды декрементируется.

• LDW— команда заполняет регистр 32-разрядным знаковым значением из памяти. Выполнятется только модулем «.D». Например,

    LDW       .D2T2          *-baseR[offsetR], Dst

где Dst — регистр для приема данных, baseR и offsetR — базовый адрес и смещение для чтения данных из памяти соответственно. Значение регистра с базовым адресом после выполнения команды остается прежним. Значение в РОН появится только через 4 такта.

• LDH — команда заполняет регистр 16-разрядным знаковым значением из памяти. Выполняться только модулем «.D». Например,

    LDH      .D2T2          *baseR++, Dst

где Dst — регистр для приема данных, baseR — базовый адрес для чтения данных из памяти. Значение регистра с базовым адресом после выполнения команды инкрементируется. Значение в РОН появится только через 4 такта.

• SUB — команда определяет разность между значениями двух регистров и заносит результат в третий. Выполняется модулями «.S», «.L» или «.D». Например,

    SUB      .L2         Src1, Src2, Dst

В данном случае происходит вычитание из значения в регистре Src1 значения в регистре Src2, а результат заносится в Dst. При использовании модуля «.D» вычитание производится из Src2.

• ADD— команда определяет сумму значений двух регистров и заносит результат в третий. Выполняется модулями «.S», «.L» или «.D».
• ZERO — команда заполняет регистр нулями. Выполняется модулями «.S», «.L» или «.D».
• MPY — команда реализует операцию умножения 16-разрядных операндов. Результат 32-разрядный. Выполняется только модулем «.M». Значение в РОН появится через 1 такт.
• B — команда осуществляет переход на метку, имя которой указано в качестве операнда. Переход будет осуществлен через 5 тактов после команды.
• SHR — команда выполняет сдвиг вправо первого операнда на количество разрядов, определяемое вторым операндом. Результат с расширением знака размещается в третьем операнде.
• NOP — пустая операция.

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

Напомним, что при первом запуске проекта на новом компьютере необходимо загрузить его через пункт Project главного меню. Затем настроить интерфейс заново и сохранить настройки нового рабочего пространства.

Игорь ГУК

Статьи по: ARM PIC AVR MSP430, DSP, RF компоненты, Преобразование и коммутация речевых сигналов, Аналоговая техника, ADC, DAC, PLD, FPGA, MOSFET, IGBT, Дискретные полупрoводниковые приборы. Sensor, Проектирование и технология, LCD, LCM, LED. Оптоэлектроника и ВОЛС, Дистрибуция электронных компонентов, Оборудование и измерительная техника, Пассивные элементы и коммутационные устройства, Системы идентификации и защиты информации, Корпуса, Печатные платы