Эта часть документации [1] посвящена библиотеке реального времени для цифровой обработки сигналов, ЦОС (DSP run-time library). Предоставляемые библиотечными функциями службы включают такие алгоритмы как компандеры, фильтры, БПФ (Быстрое Преобразование Фурье, Fast Fourier Transform, FFT). Эти службы от Analog Devices работают как расширения к стандартному ANSI C. Непонятные термины и сокращения см. в статье Словарик [2].

Для дополнительной информации по используемым алгоритмам DSP и математическим функциям, на которых они основаны, см. книжку авторов W. J. Cody и W. Waite "Software Manual for the Elementary Functions", Englewood Cliffs, New Jersey: Prentice Hall, 1980.

Примечание: в дополнение к вызываемым пользователем функциям, которые описаны в этой статье, библиотека DSP run-time также содержит функции поддержки компилятора, которые выполняют те базовые операции над целыми типами и типами с плавающей точкой, которые компилятор не может генерировать самостоятельно. Эти функции вызываются из кода, генерируемого компилятором, чтобы реализовать преобразование базовых типов, операций с плавающей точкой (Blackfin не имеет аппаратной поддержки операций над числами с плавающей точкой), и т. д. Функции для поддержки компилятора не должны вызываться напрямую из кода пользователя.

В разделе "Руководство по библиотеке DSP Run-Time" содержится общая информация по библиотеке, приводится описание заголовочных подключаемых файлов, предназначенных для текущего релиза компилятора ccblkfn. В разделе "DSP Run-Time Library Reference" [1, 4] содержится полная справочная информация по каждой из библиотечных функций DSP run-time.

[Руководство по библиотеке DSP Run-Time]

Библиотека DSP Run-Time содержит функции, предназначенные для вызова из приложения пользователя процессора Blackfin.

Линковка DSP-библиотеки. Библиотека DSP run-time размещена в каталоге инсталляции VisualDSP++ (%ProgramFiles%\Analog Devices\VisualDSP 5.0\), в поддиректории Blackfin/lib. Предоставляются различные версии этой библиотеки, перечисленные в таблице 4-1.

Таблица 4-1. Файлы DSP-библиотеки (каталог Blackfin/lib).

Версии библиотеки, которые содержат "532" в имени dlb-файла, собраны для использования процессорами ADSP-BF531, ADSP-BF532, ADSP-BF533, ADSP-BF534, ADSP-BF536, ADSP-BF537, ADSP-BF538 или ADSP-BF539. Версии библиотеки, которые содержат в имени файла "535", предназначены для процессоров ADSP-BF535. Версии библиотеки, которые содержат в имени файла "561", предназначены для работы с процессорами ADSP-BF561.

Версии библиотеки, имя файлов которых без расширения заканчиваются на "y" (например libdsp532y.dlb), собраны с опцией компилятора -si-revision, и включают все доступные способы обхода ошибок кремния (compiler workarounds) для аппаратных аномалий процессора (hardware anomalies). Подробнее см. описание ключа командной строки -si-revision в [5].

Когда приложение вызывает библиотечную функцию DSP, этот вызов создает ссылку на внешнюю функцию, которую разрешает линкер. Один из способов, которым линкеру указывают место нахождения библиотеки, будет использования файла настроек линкера по умолчанию (default linker description file, < имя_целевого_процессора >.ldf). Если для линковки приложения используется файл .ldf, настроенный пользователем, то добавьте к проекту подходящий библиотечный файл DSP run-time к файлу .ldf, который задан в проекте.

Примечание: вместо того, чтобы модифицировать пользовательский файл .ldf, используйте опцию командной строки -l (см. описание опций линкера в [1]), чтобы указать библиотеку, которую должен искать линкер. Например, опция -ldsp532 добавит к используемым линкером библиотекам файл libdsp532.dlb. Для дополнительной информации по файлам .ldf см. руководство по линкеру и утилитам VisualDSP++ (VisualDSP++ Linker and Utilities Manual).

Атрибуты DSP-библиотеки. Библиотека DSP run-time содержит те же самые атрибуты, что и библиотека C/C++. Для дополнительной информации см. "Library Attributes" в разделе "C/C++ Run-Time Library" руководства [1].

Заголовочные файлы DSP-библиотеки. В них содержатся прототипы для библиотечных функций DSP. Когда соответствующий заголовочных файл подключается директивой #include, препроцессор компилятора использует прототипы в заголовочном файле, чтобы проверить каждый вызов функции в коде пользователя на корректность подставленных аргументов. Таблица 4-2 показывает заголовочные файлы DSP, которые включены в текущий релиз компилятора ccblkfn.

Таблица 4-2. Хедеры библиотеки DSP.

complex.h. В этом заголовочном файле содержатся определения типов и базовые арифметические операции для переменных типа complex_float, complex_double, complex_long_double, complex_fract16 и complex_fract32. Комплексные функции, определенные в этом хедере, перечислены в таблице 4-3. Функции, которые работают с числами complex_fract16 и complex_fract32, используют арифметическое насыщение [6]. Тип данных complex_fract16 имеет 32-битное выравнивание.

Следующие структуры представляют комплексные числа в прямоугольных координатах:

typedef struct
{
   float re;
   float im;
} complex_float;

typedef struct
{
   double re;
   double im;
} complex_double;

typedef struct
{
   long double re;
   long double im;
} complex_long_double;

typedef struct
{
   #pragma align 4
   fract16 re;
   fract16 im;
} complex_fract16;

typedef struct
{
   fract32 re;
   fract32 im;
} complex_fract32;

Подробное описание базовых комплексных функций имеется в разделе "DSP Run-Time Library Reference" [1, 4].

Таблица 4-3. Комплексные функции.

cycle_count.h. Этот заголовочный файл предоставляет недорогой метод оценки скорости выполнения кода на языке C при помощи аппаратного счетчика циклов процессора. Функционал состоит из двух макросов и типа данных, как это описано в разделе "Счетчик тактов процессора".

cycles.h. Этот заголовочный файл определяет набор из 5 макросов и связанный с ними тип данных, который можно использовать для измерения прошедших тактов процессора при выполнении секций кода на языке C. Эти макросы могут записать сколько раз выполнилась определенная часть кода, и вычислить минимальное, среднее и максимальное количество используемых циклов. Возможности, доступные через этот заголовочный файл, описаны в разделе "Счетчик тактов процессора".

filter.h. Здесь содержатся функции для фильтров, используемых в обработке сигналов. Этот файл также включает компандеры A-law и ?-law, используемые приложениях компрессии и декомпрессии сигналов звукового диапазона. Этот заголовок также содержит функции, выполняющие ключевые трансформации сигнала, включая обработки FFT и конволюцию.

Библиотека предоставляет разные формы функции FFT, соответствующие radix-2, radix-4, и двумерным преобразованиям FFT. Количество точек предоставляется как аргумент. Заголовочный файл также определяет комплексную функцию FFT (cfftf_fr16) реализованную на основе оптимизированного алгоритма radix-4. Однако функция cfftf_fr16 задает определенные требования к вычислительным ресурсам, которые могут не подойти для некоторых приложений. Таблица вращения (twiddle table) для функций FFT предоставляется как отдельный аргумент, и она обычно вычисляется один раз на этапе инициализации программы.

Внимание: библиотечная функция cfftf_fr16 задействует регистр M3, который может использоваться эмулятором (аппаратный отладчик JTAG) для переключения контекста. За дополнительной информацией обратитесь к руководству по аппаратному отладчику.

Для инициализации таблицы вращения предоставлены библиотечные функции. Таблица вращения может быть приспособлена к нескольким преобразованиям FFT разных размеров путем выделения таблицы максимального размера, после чего нужно использовать аргумент stride функции FFT, чтобы указать шаг, с которым нужно использовать таблицу. Если аргумент stride установлен в 1, то функция FFT будет использовать всю таблицу целиком; если FFT использует только половину точек самого большого размера, то stride задается как 2.

Имеется функция магнитуды FFT, которая вычисляет нормализованную мощность спектра FFT.

Функции, определенные в заголовочном файле filter.h, перечислены в таблицах 4-4 и 4-5, и также описаны в разделе "DSP Run-Time Library Reference" [1, 4].

Таблица 4-4. Библиотека фильтров.

Таблица 4-5. Функции трасформаций.

math.h. Здесь определены стандартные математические функции с аргументами типов float и long double, и в некоторых случаях математические функции определены для типов fract16 и fract32, и встроенных C-типов данных _Fract и long _Fract.

Таблица 4-6 суммарно перечисляет функции, определенные в заголовочном файле math.h. Описания этих функций даны в double-версиях функций раздела "C Run-Time Library Reference" руководства [1].

Хедер math.h также предоставляет прототипы для дополнительных математических функций (clip, copysign, max и min), и целочисленную функцию (countones). Описание этих функций см. в разделе "DSP Run-Time Library Reference" [1, 4].

Таблица 4-6. Математические функции.

matrix.h. Здесь находятся матричные функции для работы с матрицами реальных и комплексных чисел, для операций матрица-скаляр и матрица-матрица. Описание комплексных чисел см. в описании заголовочного файла complex.h.

Матричные функции перечислены в таблице 4-7. Они работают с типами fract16, fract32, complex_fract16 и complex_fract32, и со встроенными C-типами данных _Fract и long _Fract, с использованием арифметики насыщения [6].

Таблица 4-7. Матричные функции.

В большинстве прототипов функций используются следующие определения:

В функциях умножения матрица*матрица параметры rows_a и columns_a это размерности матрицы a, и rows_b и columns_b это размерности матрицы b.

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

stats.h. Функции этого заголовочного файла перечислены в таблице 4-8 и подробно описаны в разделе "DSP Run-Time Library Reference" [1, 4].

Таблица 4-8. Статистические функции.

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

Функции, определенные в vector.h, перечислены в таблице 4-9. Векторные функции могут работать с типами данных complex_fract16 и complex_fract32, и со встроенными C типами данных _Fract и long _Fract, с использованием арифметики насыщения.

В столбце "Прототип функции" определения vec[], vec_a[] и vec_b[] это входные векторы, scalar это входной скаляр, out[] это выходной вектор, и sample_length это количество элементов. Функции подразумевают, что входные аргументы массивов являются константами; таким образом, они не будут изменены в теле подпрограммы. В частности это означает, что входные аргументы не могут перекрывать выходной аргумент. Обычно самая лучшая производительность достигается для векторных функций в том случае, когда входные и выходные векторы находятся в разных физических банках памяти [6, 7]. Код, структурированный таким образом, позволяет избежать потери вычислительных ресурсов на коллизии банков памяти.

Таблица 4-9. Векторные функции.

window.h. Здесь содержатся функции для генерации окон по разным методикам (так называемые оконные функции). Они перечислены в таблице 4-10, и подробно описаны в разделе "DSP Run-Time Library Reference" [1, 4].

Для всех оконных функций параметр шага (window_stride) используется для определения пространства между значениями окна. Параметр длины окна (window_size) равен количеству элементов в окне. Таким образом, для window_stride=2 и window_length=10 требуется массив длиной 20, где каждая вторая запись остается нетронутой.

Таблица 4-10. Функции генератора окна.

[Счетчик тактов процессора]

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

Внимание: макросы для подсчета тактов, описанные в этой секции, не являются потокобезопасными (not thread-safe). Если макросы подсчета тактов используются в многопоточной среде выполнения (multi-threaded environment), то они должны запускаться внутри критического региона кода.

Базовый метод подсчета тактов процессора. Фундаментальный метод измерения скорости выполнения секции кода - записать текущее значение регистра счетчика тактов перед выполняемой секцией кода, и чтение того же регистра снова после того, как измеряемая секция кода выполнилась. Этот процесс реализуется с помощью двух макросов, определенных в заголовочном файле cycle_count.h:

START_CYCLE_COUNT(S)
STOP_CYCLE_COUNT(T,S)

Параметр S устанавливается макросом START_CYCLE_COUNT в текущее значение регистра счетчика тактов; это значение потом передается макросу STOP_CYCLE_COUNT, который вычислит разницу между этим параметром и текущим значением регистра счетчика тактов. Чтение регистра счетчика тактов влечет некоторое малое количество затраченных тактов, и макрос гарантирует, что возвращенная разница (параметр T) будет подстроена с учетом этой дополнительной траты процессорного времени. Параметры S и T должны быть разными переменными; они должны быть декларированы с использованием типа данных cycle_t, который в заголовочном файле cycle_count.h определен следующим образом:

typedef volatile unsigned long long cycle_t;

Примечание: использование квалификатора типа volatile в определении типа данных cycle_t означает, что этот тип не может использоваться в качестве типа для возврата результата из функции.

Заголовочный файл cycle_count.h также определяет макрос PRINT_CYCLES(STRING,T), который дает общий пример, как использовать значение типа cycle_t; макрос выводит текст STRING в stdout, после чего выводится количество циклов T.

Описанный здесь инструментарий работает только когда программа скомпилирована с опцией командной строки компилятора –DDO_CYCLE_COUNTS. Если эта опция не указана, то макросы будут заменены пустыми операторами, и не окажут никакого эффекта на поведение программы.

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

#include < cycle_count.h >

#include < stdio.h >

int main(void)
{
   cycle_t start_count;
   cycle_t final_count;
   START_CYCLE_COUNT(start_count);
   Some_Function_Or_Code_To_Measure();
   STOP_CYCLE_COUNT(final_count, start_count);
   PRINT_CYCLES("Количество тактов: ", final_count);
}

Библиотеки реального времени предоставляют альтернативные возможности для измерения скорости выполнения кода C (см. раздел "Подсчет тактов с накоплением статистики" и "Использование time.h для измерения количества тактов").

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

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

Если опция -DDO_CYCLE_COUNTS указана во время компиляции, то заголовочный файл cycles.h определяет следующие макросы:

CYCLES_INIT(S). Этот макрос инициализирует системный механизм измерения времени и очищает параметр S; приложение должно содержать одну ссылку на этот макрос.
CYCLES_START(S). Этот макрос выбирает текущее значение регистра счетчика тактов, и сохраняет его в параметре S.
CYCLES_STOP(S). Этот макрос выбирает текущее значение регистра счетчика тактов, и накапливает статистику в параметре S, основываясь на предыдущей ссылке на макрос CYCLES_START.
CYCLES_PRINT(S). Этот макрос печатает суммарную накопленную статистику, записанную в параметре S.
CYCLES_RESET(S). Этот макрос обнуляет накопленную статистику в параметре S.

Параметр S, который передается в макросы, должен быть декларирован как переменная типа cycle_stats_t. Это специальный структурированный тип данных, который определен в заголовочном файле cycles.h. Этот тип данных может записать количество раз, с которым был выполнен измеряемый блок кода, а также максимальное, минимальное и среднее количество тактов, которое было затрачено на выполнение измеряемого блока кода. Например, если измеряемый кусок кода был выполнен 4 раза, то макрос CYCLES_PRINT сгенерирует вывод в стандартный поток stdout следующего вида:

AVG : 95
MIN : 92
MAX : 100
CALLS : 4

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

CYCLES : 95

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

Макросы, определенные в заголовочном файле cycles.h, могут быть изменены для какого-то частного приложения, без необходимости повторной сборки библиотек run-time.

Ниже приведен пример, показывающий функционал макросов заголовка cycles.h.

#include < cycles.h >

#include < stdio.h >

extern void foo(void);

extern void bar(void);

int main(void)
{
   cycle_stats_t stats;
   int i;
   CYCLES_INIT(stats);
   for (i = 0; i < LIMIT; i++)
   {
      CYCLES_START(stats);
      foo();
      CYCLES_STOP(stats);
   }
   printf("Такты, потраченные на foo\n");
   CYCLES_PRINT(stats);
   CYCLES_RESET(stats);
   for (i = 0; i < LIMIT; i++)
   {
      CYCLES_START(stats);
      bar();
      CYCLES_STOP(stats);
   }
   printf("Такты, потраченные на bar\n");
   CYCLES_PRINT(stats);
}

Этот пример выведет что-то наподобие следующего:

Такты, потраченные на foo
AVG : 25454
MIN : 23003
MAX : 26295
CALLS : 16
Такты, потраченные на bar
AVG : 8727
MIN : 7653
MAX : 8912
CALLS : 16

Альтернативные методы измерения скорости выполнения кода C описаны в секциях "Базовый метод подсчета тактов процессора" и "Использование time.h для измерения количества тактов". Также см. "Замечания по использованию измерения количества тактов процессора", где даются полезные советы, связанные с измерениями скорости выполнения кода.

Использование time.h для измерения количества тактов. Заголовочный файл time.h определяет тип данных clock_t, функцию clock и макрос CLOCKS_PER_SEC, которые совместно друг с другом используются для вычисления количества секунд, потраченного в программе.

В стандарте ANSI C функция clock определена как количество зависящих от конкретной реализации элементарных тактовых "тиков", которые прошли с момента запуска программы. В текущей версии компилятора C/C++ функция clock вернет количество циклов процессора, которое было использовано приложением.

Обычный метод использования хедера time.h состоит в следующем: вызвать функцию clock в начале программы, и затем вычитать это значение из значения, которое будет возвращено последующими вызовами этой функции. Вычисленная разница обычно приводится к типу с плавающей точкой, и затем делится на макрос CLOCKS_PER_SEC, чтобы определить количество времени в секундах, которое прошло между двумя вызовами функции clock.

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

• Значение, присвоенное макросу CLOCKS_PER_SEC должно быть проверено независимо, чтобы гарантировать корректное значение, используемое для каждого конкретного процессора (см. секцию "Determining the Processor Clock Rate").
• Возвращенный из функции clock результат не учитывает накладные расходы на вызов библиотечной функции.

Ниже показан типичный пример, демонстрирующий использование хедера time.h для измерения количества времени, которое приложение тратит на выполнение.

#include < time.h >

#include < stdio.h >

int main(void)
{
   volatile clock_t clock_start;
   volatile clock_t clock_stop;
   double secs;

   clock_start = clock();
   Some_Function_Or_Code_To_Measure();
   clock_stop = clock();
   secs = ((double) (stop_time - start_time)) / CLOCKS_PER_SEC;
   printf("Затраченное время %e секунд\n",secs);
}

Заголовочные файлы cycles.h и cycle_count.h определяют другие методы для оценки скорости работы приложения, как это описано в секциях "Базовый метод подсчета тактов процессора" и "Подсчет тактов с накоплением статистики" соответственно. Также см. секцию "Замечания по использованию измерения количества тактов процессора", где предоставлены полезные советы.

Determining the Processor Clock Rate. Скорость выполнения приложения может оцениваться с учетом затрат тактов процессора. Однако приложения обычно оцениваются по отношению к реальному затраченному времени (например в секундах).

Определение количества времени, которое приложение потратило на выполнение кода процессором Blackfin, обычно сначала заключается в определении количества потраченных тактов, после этого полученное число делится на частоту тактов процессора (либо умножается на длительность такта процессора). Заголовочный файл time.h определяет макрос CLOCKS_PER_SEC как количество "тиков" процессора в секунду.

На процессорах Blackfin это устанавливается библиотекой run-time в одно из следующих значений в нисходящем порядке приоритета:

• С помощью указания опции -DCLOCKS_PER_SEC=< определение_количества_тактов > командной строки во время компиляции проекта приложения. Из-за того, что тип time_t основывается на целом типе данных long long, рекомендуется назначить символическому имени CLOCKS_PER_SEC значение таким образом, чтобы получился тот же самый тип данных, т. е. с использованием суффикса LL (или ll). Например, -DCLOCKS_PER_SEC=60000000LL.
• С помощью Библиотеки Системных Служб (System Services Library, SSL).
• С помощью настройки скорости процессора в диалоге опций проекта VisualDSP++, закладка Compile, категория настроек Processor (1).
• С помощью заголовочного файла cycles.h.

Если значение макроса CLOCKS_PER_SEC было получено из заголовка cycles.h, имейте в виду, что тактовая частота процессора обычно будет взята как максимально возможная частота процессора, что вовсе не обязательно будет соответствовать скорости работы процессора после его сброса (RESET).

[Замечания по использованию измерения количества тактов процессора]

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

Базовый метод подсчета тактов процессора. Эта возможность подсчета циклов самая недорогая по ресурсам и довольно мало влияет на тестируемый код. Эта технология базируется на макросах, которые могут быть изменены. Эти макросы также могут быть подключены или отключены без какой-либо правки исходного кода, что позволяет легко переключаться между отладочной версией и версией релиза. Одинаковый набор таких макросов доступен на других платформах, предоставляемых компанией Analog Devices.

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

Использование time.h для измерения количества тактов. Функционал заголовочного файла time.h представляет простые методы для измерения скорости выполнения приложения, которые являются портируемыми на различные архитектуры и системы. Этот функционал основан на функции clock.

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

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

При анализе производительности кода требуется учесть некоторые обстоятельства, связанные с добавлением инструментального измеряющего кода в оптимизируемый код C. Если последовательность измеряющих операторов не была тщательно выбрана, то оптимизатор может переместить измеряемый региона код, и/или может даже переместить сам измеряющий инструментальный код, что может привести к порче измерений. Таким образом, считается более надежным измерять счетчик цикла при вызове функции (и возврате из неё), вместо оценки времени выполнения последовательности операторов внутри функции.

Рекомендуется, чтобы используемые напрямую переменные в бенчмарке были простыми скалярными, и находились бы во внутренней памяти (это те переменные, которым присваивается результат ссылки на функцию clock, или переменные, которые используются как аргументы для считающих циклы макросов). В том случае, когда переменным назначается результат вызова функции clock, также рекомендуется задавать эти переменные с ключевым словом volatile [8]. Регистры счетчиков циклов архитектуры Blackfin называются CYCLES и CYCLES2, они являются 32-битными. Регистр CYCLES инкрементируется на каждом такте процессора; когда CYCLES переваливает через максимальное значение в 0, инкрементируется регистр CYCLES2. Работая совместно, эти два регистра представляют 64-битный счетчик, который вряд ли когда-нибудь переполнится во время анализа скорости выполнения приложения.

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

[Ссылки]

1. VisualDSP++ 5.0 C/C++ Compiler and Library Manual for Blackfin® Processors site:analog.com.
2. DSP: словарик.
3. Window function site:en.wikipedia.org.
4. Библиотека Blackfin DSP Run-Time, справочник функций.
5. Опции командной строки компилятора Blackfin.
6. Blackfin: система команд (ассемблер) - часть 1.
7. Оптимизация системы на процессоре Blackfin.
8. Как использовать ключевое слово volatile на языке C.