Типы даных, ARM7 NXP Опции

[espectro]

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

Код

#define VALUE  100

for(... i; i < VALUE; i++) {

/* code */

}

как объявить переменную i - uchar, uint, ulong?

И если в коде используется много семафоров что лучше использовать: битовые операции, или для каждого флага объявлять свою переменную (какого типа)?

[Rst7]

как объявить переменную i - uchar, uint, ulong?

Если значение переменной меньше 256, то имеет прямой смысл объявить ее как uint_fast8_t. Это получится наиболее переносимый вариант. Только не забыть подключить stdint.h

[DpInRock]

как объявить переменную i - uchar, uint, ulong?

Наиболее быстро - объявить ее локальной и как register.

[Rst7]

Наиболее быстро - объявить ее локальной и как register.

Если Вы внимательно посмотрите на то место, куда топикстартер желает вставить идентификатор типа, то увидите, что переменная и так будет локальной. К сожалению, современные компиляторы очень зря игнорируют ключевое слово register.

Посему главное - чтобы переменная занимала ровно один регистр, ни больше, ни меньше (грубо говоря). Для этого есть специальные волшебные слова, описанные в stdint.h

[espectro]

Спасибо за ответы .
Ответ на второй вопрос меня волнует не меньше первого ))

[Rst7]

И если в коде используется много семафоров что лучше использовать: битовые операции, или для каждого флага объявлять свою переменную (какого типа)?

Если Вы работаете с этим переменными в ОЗУ, то быстее всего будет volatile(если надо) uint8_t. Это, конечно, будет проигрыш по ОЗУ, но зато выигрыш по быстродействию.

[espectro]

Если Вы работаете с этим переменными в ОЗУ, то быстее всего будет volatile(если надо) uint8_t. Это, конечно, будет проигрыш по ОЗУ, но зато выигрыш по быстродействию.

Понятно. А как они будут укладываться в ОЗУ: 4 переменных типа uint8_t подряд или одна будет занимать 32 бита?
И еще вопрос: если же особого быстродействия не требуется то лучше объявить одну переменную и проверять биты

CODE

#define FLAG0 0
#define FLAG1 1
/*...................*/

uint FLAGS;

/*...............*/

main(void) {

if(FLAGS & (1 << FLAGn) /* do something */ ;

}

?

[Rst7]

А как они будут укладываться в ОЗУ: 4 переменных типа uint8_t подряд или одна будет занимать 32 бита?

Обычно компилятор складывает их вместе. Более точно ответы на Ваши вопросы даст ассемблеровский листинг, генерируемый компилятором и map-файл, генерируемый линкером.

И еще вопрос: если же особого быстродействия не требуется то лучше объявить одну переменную и проверять биты

Да. Но это увеличивает объем программного кода.

[sonycman]

Если Вы работаете с этим переменными в ОЗУ, то быстее всего будет volatile(если надо) uint8_t. Это, конечно, будет проигрыш по ОЗУ, но зато выигрыш по быстродействию.

Э-эм, а разве с байтами (8 бит) 32-ух битный проц будет работать быстрее, чем с двойными словами (32 бита)?

[Rst7]

Э-эм, а разве с байтами 32-ух битный проц будет работать быстрее

Ключевое слово - в ОЗУ, а не в регистрах.

[espectro]

Если не затруднит, приведите пожалуйста пример, в каком случае следует использовать 2-ные слова. На будущее.

[Rst7]

Если не затруднит, приведите пожалуйста пример, в каком случае следует использовать 2-ные слова. На будущее.

Дык в цикле Вам предложено сделать именно 32хбитную переменную. Для Вашего процессора uint_fast8_t соответствует uint32_t.

[DpInRock]

быстее всего будет volatile

Это будет медленнее всего.
Это волшебное слово означает, что чтение данной переменной ВСЕГДА будет осуществлятся из места пребывания, и никогда не будет сохранятся даже для временных целей.

К примеру , компилятор бы рад расположить переменную цикла в регистре (что будет быстро и экономно), но volatile это дело запретит.

Далее. IAR легко воспринимает слово register.

Зависимость скорости обращения от разряднсти переменной. Зависит кроме всего прочего от схемы электрической принципиальной.

[espectro]

Дык в цикле Вам предложено сделать именно 32хбитную переменную. Для Вашего процессора uint_fast8_t соответствует uint32_t.

Мдаааа. Чувстую себя дурак - дураком, после АВР в моем мозгу прочно засело вредное заблуждение, что unsigned int всегда имеет размерность 2 байта (((. Только что проверил с помощью нехитрого кода что заблуждался..

Значит вся вот эта красота:

Код

   /* fastest minimum-width unsigned integer types */
typedef unsigned           int uint_fast8_t;
typedef unsigned           int uint_fast16_t;
typedef unsigned           int uint_fast32_t;

для обеспечения переносимости?

[Rst7]

Это будет медленнее всего.
Это волшебное слово означает

Вы, похоже, не читаете, что я пишу. Написано же в скобках - "если надо".

К примеру , компилятор бы рад расположить переменную цикла в регистре (что будет быстро и экономно), но volatile это дело запретит.

Причем тут переменная цикла? Обсуждаем уже второй вопрос - про флаги.

Далее. IAR легко воспринимает слово register.

Путем игнорирования.

Зависимость скорости обращения от разряднсти переменной. Зависит кроме всего прочего от схемы электрической принципиальной.

Я может чего пропустил, но у заявленного проца внешней шины вроде не видать

для обеспечения переносимости?

Даже для обеспечения оптимальности кода независимо от разрядности проца. Хоть 8, хоть 64 бита.

[rezident]

Мдаааа. Чувстую себя дурак - дураком, после АВР в моем мозгу прочно засело вредное заблуждение, что unsigned int всегда имеет размерность 2 байта (((. Только что проверил с помощью нехитрого кода что заблуждался..

Размерность стандартных типов (char, int, long и т.п.) вовсе не гарантируется стандартом языка Си. Стандартом гарантируется лишь, что sizeof(char) ≤ sizeof(short int) ≤ sizeof(int) ≤ sizeof(long int). А конкретная размерность этих типов определяется архитектурой МК и/или компилятором.
По поводу вашего примера в начале топика, быстрее всего (компилятор его оптимизирует для этого) будет выполняться цикл вида

Код

#define VALUE  100

for (unsigned int i = VALUE; i != 0; i--)
{
   /* code */
}

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

[Rst7]

Во-первых, используется "естественный" для архитектуры тип локальной переменной.

И все-же uint_fast8_t будет более к месту.

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

Тогда уж можно доходить до логического конца (или начала, с этого начиналась борьба человека с компиляторами Си)

Код

uint_fast8_t i=VALUE;
do
{
   /* code */
}
while(--i);

С таким циклом справятся любые компиляторы, даже самые древние

[rezident]

Тогда уж можно доходить до логического конца (или начала, с этого начиналась борьба человека с компиляторами Си)

Угу. Я подумал-подумал и... не стал приводить пример с while, т.к. изначально пример с for был.

[dch]

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

[sergeeff]

Если в память влазиете пишите int - в большинстве это поделки

Любезный! Не снизойдете ли до простых смертных разъяснить, что вы хотели этой фразой сказать?