Когда используется ключевое слово register, как компилятор обрабатывает эту переменную? [Дубликат]

Он сообщает компилятору попытаться использовать регистр ЦП, а не ОЗУ, чтобы сохранить переменную. Регистры находятся в ЦП и намного быстрее доступны, чем оперативная память. Но это всего лишь предложение компилятору, и это может не произойти.

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

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

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

Последний проект стандарта C ++ 11 N3485 говорит об этом в 7.1.1 / 3:

Спецификатор register - это намек на реализацию, которую объявленная переменная будет сильно использоваться. [ note: Подсказка может быть проигнорирована, и в большинстве реализаций она будет игнорироваться, если будет принят адрес переменной. Это использование устарело ... -end note ]

В C ++ (но не в C) в стандарте не указано, что вы не можете принять адрес переменной, объявленной register; однако, поскольку переменная, хранящаяся в регистре CPU на протяжении всего жизненного цикла, не имеет связанного с ней местоположения памяти, попытка получить его адрес будет недействительной, а компилятор будет игнорировать ключевое слово register, чтобы разрешить прием адреса.

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

Я тестировал ключевое слово register под QNX 6.5.0, используя следующий код:

#include <stdlib.h>
#include <stdio.h>
#include <inttypes.h>
#include <sys/neutrino.h>
#include <sys/syspage.h>

int main(int argc, char *argv[]) {
    uint64_t cps, cycle1, cycle2, ncycles;
    double sec;
    register int a=0, b = 1, c = 3, i;

    cycle1 = ClockCycles();

    for(i = 0; i < 100000000; i++)
        a = ((a + b + c) * c) / 2;

    cycle2 = ClockCycles();
    ncycles = cycle2 - cycle1;
    printf("%lld cycles elapsed\n", ncycles);

    cps = SYSPAGE_ENTRY(qtime) -> cycles_per_sec;
    printf("This system has %lld cycles per second\n", cps);
    sec = (double)ncycles/cps;
    printf("The cycles in seconds is %f\n", sec);

    return EXIT_SUCCESS;
}

Я получил следующие результаты:

-> 807679611 истекших циклов

-> Эта система имеет 3300830000 циклов в секунду

-> Циклы в секундах ~ 0.244600

И теперь без регистра int:

int a=0, b = 1, c = 3, i;

Я получил:

-> 1421694077 пройденных циклов

-> Эта система имеет 3300830000 циклов в секунду

-> Циклы в секундах ~ 0.430700

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

Ключевое слово было использовано long, long back. Когда было только так мало регистров, которые могли подсчитать их всех с помощью указательного пальца.

Но, как я уже сказал, устаревшее не означает, что вы не можете его использовать.

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

Еще одна вещь: если вы объявляете переменную как регистр, вы не можете получить ее адрес, поскольку он не хранится в памяти. он получает свое распределение в регистре CPU.

Я прочитал, что он используется для оптимизации, но четко не определен ни в одном стандарте.

Фактически это является , четко определенным C. Цитирование N1570 draft раздела 6.7.1, пункт 6 (другие версии имеют одинаковую формулировку):

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

Унарный оператор & не может применяться к объекту, определенному с помощью register, а register может не быть используется в внешней декларации.

Существует несколько других (довольно неясных) правил, специфичных для register -qualified objects:

• Определение объекта массива с помощью register имеет неопределенное поведение. Исправление: законно задавать объект массива с помощью register, но вы не можете ничего использовать с таким объектом (индексирование в массив требует ввода адреса его начального элемента).
• _Alignas (новый в C11) не может быть применен к такому объекту.
• Если имя параметра, переданное макросу va_start, [register -qualified, поведение не определено.

Могут быть несколько других; Загрузите черновик стандарта и выполните поиск «register», если вам интересно.

Как следует из названия, значение оригинала для register должно было требовать от объекта храниться в регистре CPU. Но с улучшением оптимизации компиляторов это стало менее полезным. Современные версии стандарта C не относятся к регистрам CPU, потому что они больше не нуждаются (должны) предполагать, что есть такая вещь (существуют архитектуры, которые не используют регистры). Общая мудрость заключается в том, что применение register к объявлению объекта с большей вероятностью ухудшает сгенерированный код, потому что это мешает распределению собственного регистра компилятора. Там может быть несколько случаев, когда это полезно (скажем, если вы действительно знаете, как часто переменная будет доступна, и ваши знания лучше, чем то, что может вычислить современный оптимизирующий компилятор).

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

Компилятор Microsoft Visual C ++ игнорирует ключевое слово register, когда включена глобальная оптимизация распределения регистров (флаг компилятора / Oe).

См. регистр ключевого слова в MSDN.

Storytime!

C, как язык, является абстракцией компьютера. Это позволяет вам делать то, что делает компьютер, манипулировать памятью, делать математику, печатать вещи и т. Д.

Но C - это только абстракция. И, в конечном счете, то, что он извлекает из вас , является языком ассемблера. Assembly - это язык, который читает процессор, и если вы его используете, вы делаете что-то с точки зрения процессора. Что делает процессор? В принципе, он читает из памяти, выполняет математику и записывает в память. CPU не просто выполняет математику по номерам в памяти. Во-первых, вам нужно переместить число из памяти в память внутри процессора, называемого регистром . Как только вы закончите делать все, что вам нужно сделать, чтобы это число, вы можете переместить его обратно в обычную системную память. Зачем использовать системную память? Регистры ограничены по количеству. В современных процессорах вы получаете около ста байтов, а более старые популярные процессоры были еще более фантастически ограничены (у 6502 было 3 8-битных регистра для вашего бесплатного использования). Итак, ваша средняя математическая операция выглядит так:

load first number from memory
load second number from memory
add the two
store answer into memory

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

Когда вы объявляете переменную register, вы сообщаете компилятору «Yo, я намерен использовать эту переменную много и / или быть коротким. Если бы я был вами, Я постараюсь сохранить его в реестре. Когда в стандарте C говорится, что компиляторам вообще не нужно что-то делать, это потому, что стандарт C не знает, на каком компьютере вы компилируете, и это может быть как 6502 выше, где все 3 регистра необходимы только для работы , и нет запасного регистра, чтобы сохранить свой номер. Однако, когда говорится, что вы не можете принять адрес, это потому, что регистры не имеют адресов. Это руки процессора. Поскольку компилятор не должен указывать вам адрес, и поскольку он вообще не может иметь адрес, в настоящее время для компилятора открываются несколько оптимизаций. Он мог, скажем, всегда держать номер в регистре. Он не должен беспокоиться о том, где он хранится в памяти компьютера (за исключением необходимости вернуть его обратно). Это может даже записать его в другую переменную, передать его другому процессору, дать ему изменение местоположения и т. Д.

tl; dr: Краткоживущие переменные, которые выполняют много математики. Не объявляйте слишком много сразу.

Это не актуально в течение как минимум 15 лет, так как оптимизаторы принимают более правильные решения, чем вы можете. Даже когда это было актуально, это имело гораздо больший смысл в архитектуре процессора с большим количеством регистров, таких как SPARC или M68000, чем у Intel с небольшим количеством регистров, большинство из которых зарезервировано компилятором в своих целях.

Просто небольшое демо (без какой-либо реальной цели) для сравнения: при удалении ключевых слов register перед каждой переменной этот фрагмент кода занимает 3,41 секунды на моем i7 (GCC), с register тот же код завершается через 0,7 секунды.

#include <stdio.h>

int main(int argc, char** argv) {

     register int numIterations = 20000;    

     register int i=0;
     unsigned long val=0;

    for (i; i<numIterations+1; i++)
    {
        register int j=0;
        for (j;j<i;j++) 
        {
            val=j+i;
        }
    }
    printf("%d", val);
    return 0;
}