40

I'm reading through K&R and came to the small section on register variables, and was wondering if people here have some good examples of this put into practice.

From section 4.7 in K&R:

The register declaration looks like
register int x;
register char c;

To be clear, I'm just hoping to see some cool code samples. I (am pretty sure that I) understand the subject matter so don't feel the need to type up a verbose explanation (unless you want to).

Deduplicator
  • 44,692
  • 7
  • 66
  • 118
Kyle Walsh
  • 2,774
  • 4
  • 27
  • 25

6 Answers6

85

There is no good example of register usage when using modern compilers (read: last 15+ years, and note that this answer is from 2008) because it almost never does any good and can do some bad. When you use register, you are telling the compiler "I know how to optimize my code better than you do" which is almost never the case. One of three things can happen when you use register:

  • The compiler ignores it, this is most likely. In this case the only harm is that you cannot take the address of the variable in the code.
  • The compiler honors your request and as a result the code runs slower.
  • The compiler honors your request and the code runs faster, this is the least likely scenario.

Even if one compiler produces better code when you use register, there is no reason to believe another will do the same. If you have some critical code that the compiler is not optimizing well enough your best bet is probably to use assembler for that part anyway but of course do the appropriate profiling to verify the generated code is really a problem first.

klutt
  • 30,332
  • 17
  • 55
  • 95
Robert Gamble
  • 106,424
  • 25
  • 145
  • 137
  • 3
    "Three things can happen, and two are bad"? Where have I heard that before... ;-) – Steve Jessop Nov 25 '08 at 03:13
  • Remember the compiler is perfectly free to ignore your suggestion - there is nothing in the standard to say it has to put a register variable in a register. – Martin Beckett Dec 13 '08 at 22:09
  • could also be the case you write a compiler backend and you say "register" for all locals in a function will make a stackless function. that would be quite useful i think. – Johannes Schaub - litb Dec 13 '08 at 22:51
  • although in that case __attribute__((register_function)) or the like would be better i think – Johannes Schaub - litb Dec 14 '08 at 00:01
  • 13
    Quite a big impact this answer had. [Vast majority of register declarations was removed from Perl code](https://github.com/Perl/perl5/commit/eb578fdb5569b91c28466a4d1939e381ff6ceaf4), with reference to this answer. – Palec Aug 11 '14 at 13:51
  • 3
    This answer is misleading. The `register` keyword is not about hardware registers but about optimization. Its only effect is that the address of such a variable can't be take. In particular it can be used to asset aliasing of variables, which can be quite useful. – Jens Gustedt Jul 24 '15 at 10:09
  • 3
    It's not misleading, it's flat-out wrong. A conforming compiler *cannot* ignore `register`: taking the address of the variable is invalid, it can't ignore that. This is the only thing the keyword does: generate extra checks and errors to help *humans*. – Alex Celeste Aug 30 '15 at 18:57
  • @Leushenko: I wonder if it would be useful to have "pointer to register-qualified-value" types, such that `void foo(int register *p);` would guarantee that `p` would not be persisted past the function call, and `int scanf(char const *fmt, register ...)` would guarantee that no pointers passed as variable arguments would be persisted. A compiler could then have `register int i; scanf("%d", &i);` be equivalent to `register int i; int temp; scanf("%d", &temp); i=temp;` but would be allowed to omit the temp when it didn't need it. – supercat Jan 28 '16 at 17:42
15

In general i agree with Robert, but as any good rule this one has exceptions as well.
If you working on deeply embedded system you might know better than compiler how to optimize the code for your specific application on your specific hardware architecture.

But in 99% of cases Roberts explanation good for embedded word as well.

Community
  • 1
  • 1
Ilya
  • 3,104
  • 3
  • 23
  • 30
4

I know this is from quite some time, but here is an implementation of a subprocedure from heapsort in which the use of register variables makes the algorithm faster, at least using gcc 4.5.2 to compile the code

inline  void max_heapify(int *H, int i){
    char OK = FALSE;
    register int l, r, max, hI;
    while(!OK){
        OK = TRUE;
        l = left(i);
        r = right(i);
        max = i;
        if(l <= H[SIZE] && H[l] > H[i]){
            max = l;
        }
        if(r <= H[SIZE] && H[r] > H[max]){
            max = r;
        }
        if(max != i){
            OK = FALSE;
            hI = H[i];
            H[i] = H[max];
            H[max] = hI;
            i = max;
        }
    }
}

I tested the algortihm with and without the register keyword before the attributes and executed it to sort a random array with 50,000,000 elements on my notebook, a few times for each version.

the use of registers dropped the heapsort time from ~135s to ~125s.

I also tested with 5,000,000 elements only, but executed it more times.

The version without the register started at 11s but each execution lowered the time until it reached 9,65s and stopped at it

the version with the register started at 10s and lowered the time until 8,80s.

I think it has something to do with the cache memory. Nonetheless it seems the registers make the algorithm faster by a constanct factor

Since these variables are quite much used along the algorithm, by ensuring they are on the register instead of leaving this work to the compiler led to a better result in this case. However, it didn't improved the time that much.

Hopefully thill will be helpful to somebody, greetings.

Rafael
  • 1
  • 2
  • 6
    In order to take your benchmarking seriously, you should provide information about how you compiled it (what flags), what platform you did it on, and perhaps some details about your architecture and/or CPU. How you ran max_heapify is important too. – raylu Jul 02 '14 at 07:13
3

Another common case is when implementing low-level interpreters. Keeping some state in registers, eg. virtual machine stack pointer, can reduce the memory access significantly and speed up you code.

See vmgen — a generator of efficient virtual machine interpreters for an example of the optimization (5.2 Top of stack caching).

Hrvoje Prgeša
  • 2,051
  • 5
  • 21
  • 36
1

first is, register variable should be use for heavily used variables such as loop control variable to enhance performance by minimizing access time. secondary you can use only and only register storage specifier in this situation like , fun (auto int a,auto int b) :error fun (register int a,register int b) :right only this would be run fun (static int a,static int b) :error fun (extern int a,extern int b) :error

Ashutosh Tiwari
  • 75
  • 1
  • 4
  • 4
    What?! The K&R text is from the 1970's, so some of their recommendations are a bit out of date. Using `register` is definitely one of those. – Bo Persson Jan 05 '13 at 12:43
0

Well This is a Question that needs multiple answers because there are multiple coding contexes: from the high level language perspective, the mid level and low level (down to assembly) since the C language can call assembly routines.

The reason for using assembly instead of C is exavtly because of performance issues encountered during development soz yes there is a need for the register keyword but no it is not working as intended by developer in many cases

yan bellavance
  • 4,710
  • 20
  • 62
  • 93