Wozu ist eigentlich register?

Wofür braucht man das?

http://de.wikipedia.org/wiki/Register

Das vor allem bei Schleifenzählern häufig verwendete Schlüsselwort register weist den Compiler darauf hin, dass auf diese Variable oft zugegriffen werden muss. Diese Empfehlung, die Variable nicht auf dem Stack anzulegen, sondern in einem Register des Prozessors zu halten, kann vom Compiler ignoriert werden. Ansonsten verhält sich eine register-Variable wie eine gewöhnliche lokale Variable.

Krux

register kann aber auch völlig vom compiler ignoriert werden, wenn man es zu oft anwendet. Ist halt einfach blos für die Geschwindigkeitsoptimierung gut. Ein guter compiler kann auch register einbauen, wo es grade passt. Das macht die verwendung eigentlich so gut wie überflüssig.

jsbach

Hallo zusammen,

Krux schrieb:

register kann aber auch völlig vom compiler ignoriert werden, wenn man es zu oft anwendet. Ist halt einfach blos für die Geschwindigkeitsoptimierung gut. Ein guter compiler kann auch register einbauen, wo es grade passt. Das macht die verwendung eigentlich so gut wie überflüssig.

Interessant, interresant..

Heisst es dann etwa, wenn ich beispielsweise 3 schleifen in einer Klassenmethode
habe, ich wuerde dann einen zaehler als register deklarieren und hoffen dass der
Prozessor diese in seinen Register uebernimmt?

Idle::tut_was(){

  register i ;
  //..

  // erste schleife
  for(i=0 ; i < grenze1 ; i++){
  // tut was
 }
 // zweite schleife
 for (i=0 ; i < grenze2 ; i++){
 // tut wieder was
 }
 //...nte schleife
 for (i=75 ; i > 0 ; i--){
  // ..
 }

}

Wie wuerde ich dann sicher sein dass diese Variable in Register uebernommen
wurde? Gibt es eine Kontrollmoeglichkeit? Ich habe bissle gegoogelt, habe
nichts weiteres als die Textdefinition gefunden...

Gruss,

drakon

Kontrollieren wirst du das kaum können.
In den meisten Fällen hat so oder so der Compiler das letzte Wort, was auch gut so ist.
Ich glaube nicht, dass man da (selber) noch gross was rausholen kann. ^

Hallo,
das Schlüsselwort register kannst du meiner Meinung nach komplett vergessen. Brauchst du nie!

Krux

Wichtige Regel der Softwareentwicklung: Die größten fehler zuerst beheben, und mit register kann man keine großen fehler beheben.

LordJaxom

Sutter geht sogar so weit, register als in den meisten Fällen genauso nutzlos wie auto einzustufen. Im C++-Standard steht auch nur, dass es dem Compiler den Hinweis gibt, dass die Variable oft benutzt wird.

Don06

@jsbach: Bei deinem Beispiel wäre es eventuell sogar "besser" in jeder Schleife ein neues i anzulegen. Indem man den Scope von Variablen klein hält, erhöht man die Chance das der Kompiler sie in einen Register packen kann,

jsbach schrieb:

Idle::tut_was(){

  register i ;
  //..

register int i ;

jsbach

Don06 schrieb:

@jsbach: Bei deinem Beispiel wäre es eventuell sogar "besser" in jeder Schleife ein neues i anzulegen. Indem man den Scope von Variablen klein hält, erhöht man die Chance das der Kompiler sie in einen Register packen kann,

Ein Versuch von meinerseits:

#include <stdio.h>
#include <time.h>
#include <unistd.h>

int i;  /* This will not be transformed into a
                      register variable because it is global.*/

int main(void)
{
  register int j;

  int k, counter=0 ;
  clock_t start, finish;
  long tic_in_sec ;

  tic_in_sec = sysconf(_SC_CLK_TCK) ;

  fprintf(stdout, "this komputer tics %ld times in a sec\n",tic_in_sec) ;

      while(1){
          fprintf(stdout,"==========Register versus Non-Register=====%d===\n",counter);
      start = clock();
        for(k = 0; k < 1000; k++)
            for(i=0; i<32000; i++)
                            ;

         finish = clock();
         printf("Non-register loop:\t %ld ticks\n", finish - start);

         start = clock();
         for(k = 0; k < 1000; k++)
            for(j = 0; j < 32000; j++)
                                    ;
          finish = clock();
          printf("Register loop:\t\t %ld ticks\n", finish - start);

      counter++ ;
      }
return 0 ;
}

jsbach@orgel:[~/rtpsender] > ./register
this komputer tics 100 times in a sec
==========Register versus Non-Register=====0===
Non-register loop: 80000 ticks
Register loop: 80000 ticks
==========Register versus Non-Register=====1===
Non-register loop: 80000 ticks
Register loop: 80000 ticks
==========Register versus Non-Register=====2===
Non-register loop: 80000 ticks
Register loop: 70000 ticks
==========Register versus Non-Register=====3===
Non-register loop: 90000 ticks
Register loop: 80000 ticks
==========Register versus Non-Register=====4===
Non-register loop: 80000 ticks
Register loop: 70000 ticks
==========Register versus Non-Register=====5===
Non-register loop: 90000 ticks
Register loop: 80000 ticks
==========Register versus Non-Register=====6===
Non-register loop: 80000 ticks
Register loop: 80000 ticks
==========Register versus Non-Register=====7===
Non-register loop: 80000 ticks
Register loop: 80000 ticks
==========Register versus Non-Register=====8===
Non-register loop: 90000 ticks
Register loop: 70000 ticks
==========Register versus Non-Register=====9===
Non-register loop: 90000 ticks
Register loop: 70000 ticks
==========Register versus Non-Register=====10===
Non-register loop: 90000 ticks
Register loop: 70000 ticks
==========Register versus Non-Register=====11===
Non-register loop: 90000 ticks
Register loop: 70000 ticks
==========Register versus Non-Register=====12===
Non-register loop: 90000 ticks
Register loop: 70000 ticks
==========Register versus Non-Register=====13===
Non-register loop: 90000 ticks
Register loop: 80000 ticks
==========Register versus Non-Register=====14===
Non-register loop: 90000 ticks
Register loop: 70000 ticks
==========Register versus Non-Register=====15===
Non-register loop: 90000 ticks
Register loop: 70000 ticks
==========Register versus Non-Register=====16===

wobei ich nicht daran glaube dass timer meiner Rechner in einer
Sekunde 100 mal tickt.. irgendwas mit sysconf(_SC_CLK_TCK) falsch..

Gruss

hustbaer

@jsbach:
die "k,j" schleife dürfte der compiler eigentlich komplett wegoptimieren.
und da "i" nicht volatile ist dürfte der compiler die "k,i" schleife durch eine einfache zuweisung i=32000 ersetzen.

bei uralten compilern mag "register" ja noch einen sinn machen, bei aktuelleren compilern würde ich davon ausgehen dass das keyword bei der code-erzeugung einfach ignoriert wird.

lagalopex

hustbaer schrieb:

die "k,j" schleife dürfte der compiler eigentlich komplett wegoptimieren.
und da "i" nicht volatile ist dürfte der compiler die "k,i" schleife durch eine einfache zuweisung i=32000 ersetzen.

Wenn ich es optimieren lasse, ist beides ticks=0
mit einer einfachen berechnung in der schleife, wird die zeitdifferenz etwas größer.

hustbaer schrieb:

bei uralten compilern mag "register" ja noch einen sinn machen, bei aktuelleren compilern würde ich davon ausgehen dass das keyword bei der code-erzeugung einfach ignoriert wird.

Es macht immernoch Sinn. Aber es ist wie mit vielen keywords: Es ist nur ein Hinweis an den Compiler. Was der dann draus macht, ist was anderes. Zudem glaube ich, dass die meisten es eher schlechter einsetzen würden, als der Compiler es eh schon macht

hustbaer

@lagalopex:

mit einer einfachen berechnung in der schleife, wird die zeitdifferenz etwas größer.

Ich glaube du misst Mist.

Guck dir mal (mit der "einfachen Berechnung" in der Schleife) an wie sich lokale Variable mit "register" gegen lokale Variable ohne "register" verhält. Oder global mit "register" vs. global ohne "register".
Wenn dann noch ein Unterschied besteht würde mich das sehr wundern.
Und natürlich immer mit Optimierungen, Benchmarks ohne Optimierungen machen wohl kaum Sinn.

Lokal vs. Global zu vergleichen macht halt überhaupt keinen Sinn um den Effekt des Keywords "register" zu beurteilen.

Und nochwas: der Compiler darf (und wird auch) "i" zumindest zwischenzeitlich in ein Register nehmen, trotz dem es global ist. Er wird den Wert nur an mehr Stellen neu lesen bzw. zurückschreiben als er das würde wenn "i" lokal wäre (und die Adresse von "i" nicht an andere Programmteile weitergegeben wurde).

Solange die Schleife allerdings nur einfache Berechnungen und keine Aufrufe von Funktionen in anderem Übersetzungseinheiten enthält sind die Chancen relativ gross dass es überhaupt keinen Unterschied macht, und "i" immer (global oder nicht) über den Zeitraum der gesamten Schleife im Register gehalten wird.