К знатокам, Локальные переменные. Опции

[SasaVitebsk]

Пишу достаточно простую прогу. Пытаюсь оптимизировать.

Столкнулся с одной бедой. Попробую описать.

Построено на прерываниях. Между прерываниями разные промежутки. Есть короткие, есть длинные. Как назло именно короткое прерывание сильно загружено. Дабы разгрузить его я пытаюсь часть вычислений вынести в предыдущее не загруженное прерывание. Уже полностью перешёл на указатели, но всё равно шляпа получается.

Проблема в том, что я не могу ввести локальные переменные на два прерывания. Таким образом я ввожу статик. Но тогда во втором прерывании компилятор пытается сохранить значения. А мне это не надо ни капельки. Чтобы этого избежать я ввёл локальные переменные и во втором прерывании выполнил присваивание локальным статик. Код получился значительно компактнее, но всё равно выполняется никому не нужное присваивание. А это 6 указателей!

Теперь сам вопрос.
Могу ли я указать компилятору что можно разрушать переменные в данном прерывании. То есть что не надо их хранить. Или как это сделать. Надо типа переобъявить статические переменные локальными. Не знаю как выразится. Надеюсь поняли.

[SasaVitebsk]

Тут проскочила чья-то фраза, что компилятор лучше работает со структурами чем с массивами. И я решил проверить некоторые моменты моей проги.
Выводы просты - казалось бы мелочи, но они имеют важнейшее значение. И, главное, если вдуматься и проанализировать, то всё это лежит на поверхности!

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

uint16_t Speed[MAXDVG],SpeedReal[MAXDVG],State[MAXDVG],StateReal[MAXDVG];

Теперь переписал примерно так

struct
{
uint16_t Speed, SpeedReal...
} Dvg[MAXDVG];

там где идёт единичное обращение к конкретному полю конкретного двигателя, - естественно ничего не изменилось, но там где в цикле идёт работа с двигателями и сравниваются различные поля одного двигателя - там код уменьшился раза в два!

Переписал таки же образом работу с АЦП.

Если вдуматься, то это медленный дрейф к объектам и его свойствам и к С++ как дальнейшее развитие этих идей.

Похоже надо более полно изучать С++ и постепенно переходить.

[vmp]

Тут проскочила чья-то фраза, что компилятор лучше работает со структурами чем с массивами.

Вообще-то это была вольная цитата из документа:
AVR035: Efficient C Coding for AVR:

When global variables are required they should be collected in structures whenever
appropriate. This makes it possible for the C compiler to address them indirectly.

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

[rezident]

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

Извиняюсь конечно, но косвенная адресация (т.н. вами "адресация со смещением") не только одной лишь "архитектуре AVR" присуща.

[vmp]

Извиняюсь конечно, но косвенная адресация (т.н. вами "адресация со смещением") не только одной лишь "архитектуре AVR" присуща.

Не путаем два разных вида адресации. Косвенная (регистровая) - адрес равен значению регистра (пары регистров для AVR). Со смещением - сумме значения регистра (пары регистров) и константы (смещения). На примере PDP-11 (раз уж пошла речь о различных архитектурах):
Косвенная:
011200 MOV (R2),R0 ; Содержимое слова по адресу, равному значению R2 поместить в R0
Со смещением:
016200 MOV 4(R2),R0 ; Содержимое слова по адресу, равному значению R2 плюс 4 поместить в R0
000004
Особенность архитектуры AVR состоит в том, что в ней значение смещения помещается в код команды, которая занимает одно слово, что дает преимущество перед абсолютной адресацией, которая требует 2 слова.

[Dog Pawlowa]

Особенность архитектуры AVR состоит в том, что в ней значение смещения помещается в код команды, которая занимает одно слово, что дает преимущество перед абсолютной адресацией, которая требует 2 слова.

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

[IgorKossak]

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

Если речь зашла о компиляторе IAR, то ему как раз и не нужно помогать рассовывая локальные (да и не только) переменные по структурам или массивам. Он и сам это прекрасно делает если ему задать оптимизацию Clustering of variables.

[Rst7]

Если речь зашла о компиляторе IAR, то ему как раз и не нужно помогать рассовывая локальные (да и не только) переменные по структурам или массивам. Он и сам это прекрасно делает если ему задать оптимизацию Clustering of variables.

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

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

А вот C++ - штука двоякая, главное достоинство - чуть меньше писанины, но есть и подводные камни. Например, в связи с ограниченностью количества индексных регистров возможно код с классами будет хуже - из-за неявного this, занимающего пару регистров.

[dxp]

А вот C++ - штука двоякая, главное достоинство - чуть меньше писанины, но есть и подводные камни. Например, в связи с ограниченностью количества индексных регистров возможно код с классами будет хуже - из-за неявного this, занимающего пару регистров.

Отнюдь. В С код при обращении к структуре будет таким же - компилятор загрузит в pointer адрес структуры и будет обращаться со смещением. Ровно как и в случае с классом. Потому, что это эффективно. Если это менее эффективно - например, надо, скажем, всего одно член-данное прочитать и выгоднее обратиться напрямую, то ничего не мешает это сделать и в случае с С-структурой, и в случае с С++-классов. Это все зависит от компилятора, а не от языка.

[Rst7]

Отнюдь. В С код при обращении к структуре будет таким же - компилятор загрузит в pointer адрес структуры и будет обращаться со смещением. Ровно как и в случае с классом. Потому, что это эффективно. Если это менее эффективно - например, надо, скажем, всего одно член-данное прочитать и выгоднее обратиться напрямую, то ничего не мешает это сделать и в случае с С-структурой, и в случае с С++-классов. Это все зависит от компилятора, а не от языка.

ключевое слово в моем посте - "возможно".

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

[dxp]

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

C++ - это принципиально иной подход к программированию. При внешней схожести С и С++ очень разные языки. Прежде всего разные тем, что на них думать надо совсем по-разному (если, конечно, от ++ хочется получить то, что они дают, а не остаться в рамках процедурного С).

[SasaVitebsk]

C++ - это принципиально иной подход к программированию. При внешней схожести С и С++ очень разные языки. Прежде всего разные тем, что на них думать надо совсем по-разному (если, конечно, от ++ хочется получить то, что они дают, а не остаться в рамках процедурного С).

Да вот именно с этим у меня и проблемы пока.

Книги перечитывал уже не раз. И с Delfi работаю давно. Вроде всё понимаю и основные понятия объектного программирования чётко знаю, но пока на душу не легло.

Как zltigo где-нибудь в графике применить бы смог. Там это понятно. Но создание объекта "фильтр" пока из души не идёт и кажется притянутым за уши. (мне естественно. Я совершенно не утверждаю что это неправильно). Вот, к слову (извините за отступление, но уж если начали) прислал мне один молодой программист текст проги. Я ему слегка завидую, потому что я бы такое не написал не в жизь. Прошу прощение что на дельфях, но я думаю для большинства это не проблема. Главное не реализация а само чуство объекта. Итак может ли мне кто-нибудь наглядно пояснить в чём (в приведенном примере) объектная реализация удобнее (или какие преимущества имеет).

Приведу текст. (вырывать кусок не буду по понятным причинам)
1) Объектный

Код

unit CRCUnit;

interface

type
    TByteArray = array of Byte;

    // Вычислитель CRC8
    TCRC8Calc = class
    private
        FValue : Byte;
    public
        constructor Create;
        function Evaluate(B : Byte) : Byte; overload;
        function Evaluate(B : TByteArray) : Byte; overload;
        property CurrentValue : Byte read FValue write FValue;
    end;

    // Вычислитель CRC16
    TCRC16Calc = class
    private
        FValue : Word;
    public
        constructor Create;
        function Evaluate(B : Byte) : Word; overload;
        function Evaluate(B : TByteArray) : Word; overload;
        function Evaluate(B : TByteArray; Position, Count : Integer) : Word; overload;
        property CurrentValue : Word read FValue write FValue;
    end;

implementation

const
    crc8InitValue = $DE;
    crc8tab : array[0..255] of byte = (
        $00, $5E, $BC, $E2, $61, $3F, $DD, $83, $C2, $9C, $7E, $20, $A3, $FD, $1F, $41,
        $9D, $C3, $21, $7F, $FC, $A2, $40, $1E, $5F, $01, $E3, $BD, $3E, $60, $82, $DC,
        $23, $7D, $9F, $C1, $42, $1C, $FE, $A0, $E1, $BF, $5D, $03, $80, $DE, $3C, $62,
        $BE, $E0, $02, $5C, $DF, $81, $63, $3D, $7C, $22, $C0, $9E, $1D, $43, $A1, $FF,
        $46, $18, $FA, $A4, $27, $79, $9B, $C5, $84, $DA, $38, $66, $E5, $BB, $59, $07,
        $DB, $85, $67, $39, $BA, $E4, $06, $58, $19, $47, $A5, $FB, $78, $26, $C4, $9A,
        $65, $3B, $D9, $87, $04, $5A, $B8, $E6, $A7, $F9, $1B, $45, $C6, $98, $7A, $24,
        $F8, $A6, $44, $1A, $99, $C7, $25, $7B, $3A, $64, $86, $D8, $5B, $05, $E7, $B9,
        $8C, $D2, $30, $6E, $ED, $B3, $51, $0F, $4E, $10, $F2, $AC, $2F, $71, $93, $CD,
        $11, $4F, $AD, $F3, $70, $2E, $CC, $92, $D3, $8D, $6F, $31, $B2, $EC, $0E, $50,
        $AF, $F1, $13, $4D, $CE, $90, $72, $2C, $6D, $33, $D1, $8F, $0C, $52, $B0, $EE,
        $32, $6C, $8E, $D0, $53, $0D, $EF, $B1, $F0, $AE, $4C, $12, $91, $CF, $2D, $73,
        $CA, $94, $76, $28, $AB, $F5, $17, $49, $08, $56, $B4, $EA, $69, $37, $D5, $8B,
        $57, $09, $EB, $B5, $36, $68, $8A, $D4, $95, $CB, $29, $77, $F4, $AA, $48, $16,
        $E9, $B7, $55, $0B, $88, $D6, $34, $6A, $2B, $75, $97, $C9, $4A, $14, $F6, $A8,
        $74, $2A, $C8, $96, $15, $4B, $A9, $F7, $B6, $E8, $0A, $54, $D7, $89, $6B, $35
        );
    crc16InitValue = $00DE;
    crc16tab : array[0..255] of Word = (
        $0000, $1189, $2312, $329B, $4624, $57AD, $6536, $74BF,
        $8C48, $9DC1, $AF5A, $BED3, $CA6C, $DBE5, $E97E, $F8F7,
        $1081, $0108, $3393, $221A, $56A5, $472C, $75B7, $643E,
        $9CC9, $8D40, $BFDB, $AE52, $DAED, $CB64, $F9FF, $E876,
        $2102, $308B, $0210, $1399, $6726, $76AF, $4434, $55BD,
        $AD4A, $BCC3, $8E58, $9FD1, $EB6E, $FAE7, $C87C, $D9F5,
        $3183, $200A, $1291, $0318, $77A7, $662E, $54B5, $453C,
        $BDCB, $AC42, $9ED9, $8F50, $FBEF, $EA66, $D8FD, $C974,
        $4204, $538D, $6116, $709F, $0420, $15A9, $2732, $36BB,
        $CE4C, $DFC5, $ED5E, $FCD7, $8868, $99E1, $AB7A, $BAF3,
        $5285, $430C, $7197, $601E, $14A1, $0528, $37B3, $263A,
        $DECD, $CF44, $FDDF, $EC56, $98E9, $8960, $BBFB, $AA72,
        $6306, $728F, $4014, $519D, $2522, $34AB, $0630, $17B9,
        $EF4E, $FEC7, $CC5C, $DDD5, $A96A, $B8E3, $8A78, $9BF1,
        $7387, $620E, $5095, $411C, $35A3, $242A, $16B1, $0738,
        $FFCF, $EE46, $DCDD, $CD54, $B9EB, $A862, $9AF9, $8B70,
        $8408, $9581, $A71A, $B693, $C22C, $D3A5, $E13E, $F0B7,
        $0840, $19C9, $2B52, $3ADB, $4E64, $5FED, $6D76, $7CFF,
        $9489, $8500, $B79B, $A612, $D2AD, $C324, $F1BF, $E036,
        $18C1, $0948, $3BD3, $2A5A, $5EE5, $4F6C, $7DF7, $6C7E,
        $A50A, $B483, $8618, $9791, $E32E, $F2A7, $C03C, $D1B5,
        $2942, $38CB, $0A50, $1BD9, $6F66, $7EEF, $4C74, $5DFD,
        $B58B, $A402, $9699, $8710, $F3AF, $E226, $D0BD, $C134,
        $39C3, $284A, $1AD1, $0B58, $7FE7, $6E6E, $5CF5, $4D7C,
        $C60C, $D785, $E51E, $F497, $8028, $91A1, $A33A, $B2B3,
        $4A44, $5BCD, $6956, $78DF, $0C60, $1DE9, $2F72, $3EFB,
        $D68D, $C704, $F59F, $E416, $90A9, $8120, $B3BB, $A232,
        $5AC5, $4B4C, $79D7, $685E, $1CE1, $0D68, $3FF3, $2E7A,
        $E70E, $F687, $C41C, $D595, $A12A, $B0A3, $8238, $93B1,
        $6B46, $7ACF, $4854, $59DD, $2D62, $3CEB, $0E70, $1FF9,
        $F78F, $E606, $D49D, $C514, $B1AB, $A022, $92B9, $8330,
        $7BC7, $6A4E, $58D5, $495C, $3DE3, $2C6A, $1EF1, $0F78
        );


//==============================================================================
{ TCRC8Calc }

constructor TCRC8Calc.Create;
begin
    FValue := crc8InitValue;
end;
//------------------------------------------------------------------------------

function TCRC8Calc.Evaluate(B : Byte) : Byte;
begin
    FValue := crc8tab[FValue xor B];
    Result := FValue;
end;
//------------------------------------------------------------------------------

function TCRC8Calc.Evaluate(B : TByteArray) : Byte;
var
    i : Integer;
begin
    for i := Low(B) to High(B) do
        Evaluate(B[i]);
    Result := FValue;
end;
//==============================================================================
{ TCRC16Calc }

constructor TCRC16Calc.Create;
begin
    FValue := crc16InitValue;
end;
//------------------------------------------------------------------------------

function TCRC16Calc.Evaluate(B : Byte) : Word;
begin
    FValue := crc16tab[Byte(FValue) xor B] xor Byte(FValue shr 8);
    Result := FValue;
end;
//------------------------------------------------------------------------------

function TCRC16Calc.Evaluate(B : TByteArray) : Word;
var
    i : Integer;
begin
    for i := Low(B) to High(B) do
        Evaluate(B[i]);
    Result := FValue;
end;
//------------------------------------------------------------------------------

function TCRC16Calc.Evaluate(B : TByteArray; Position, Count : Integer) : Word;
var
    i : Integer;
begin
    for i := 0 to Count - 1 do
        Evaluate(B[i + Position]);
    Result := FValue;
end;
//==============================================================================
end.

Стандартное приводить не буду - оно очевидно