Quand le mot-clé de registre est-il réellement utile en C?

Je suis confus quant à l'utilisation du registermot - clé en C. On dit généralement que son utilisation n'est pas nécessaire comme dans cette question sur stackoverflow .

Ce mot-clé est-il totalement redondant en C à cause des compilateurs modernes ou existe-t-il des situations dans lesquelles il peut encore être utile? Si oui, dans quelles situations l'utilisation d'un registermot-clé est-elle réellement utile?

Ce n'est pas redondant en termes de langage, c'est juste qu'en l'utilisant, vous dites au compilateur, vous "préféreriez" avoir une variable stockée dans le registre. Il n'y a cependant absolument aucune garantie que cela se produira réellement pendant l'exécution.

Comme déjà mentionné, les optimiseurs de compilateur rendent essentiellement le registermot clé obsolète à des fins autres que la prévention de l'aliasing. Cependant, il existe des bases de code entières qui sont compilées avec l'optimisation désactivée ( -O0en gcc-speak ). Pour un tel code, le registermot - clé peut avoir un grand effet. Plus précisément, les variables qui autrement obtiendraient un emplacement sur la pile (c'est-à-dire tous les paramètres de fonction et les variables automatiques) peuvent être placées directement dans un registre si elles sont déclarées avec le registermot - clé.

Voici un exemple concret: supposez qu'une récupération de base de données s'est produite et que le code de récupération a placé le tuple récupéré dans une structure C. En outre, supposons qu'un certain sous-ensemble de cette structure C doit être copié dans une autre structure - peut-être que cette deuxième structure est un enregistrement de cache qui représente les métadonnées stockées dans la base de données qui, en raison de contraintes de mémoire, ne met en cache qu'un sous-ensemble de chaque enregistrement de métadonnées tel que stocké dans la base de données.

Étant donné une fonction qui prend un pointeur vers chaque type de structure et dont le seul travail consiste à copier certains membres de la structure initiale vers la deuxième structure: les variables du pointeur de structure vivront sur la pile. Comme les affectations se produisent des membres d'une structure à l'autre, les adresses de la structure seront, pour chaque affectation, chargées dans un registre afin d'effectuer l'accès des membres de la structure qui sont copiés. Si les pointeurs de structure devaient être déclarés avec le registermot clé, les adresses des structures resteraient dans les registres, supprimant effectivement les instructions de chargement d'adresse dans le registre pour chaque affectation.

Encore une fois, n'oubliez pas que la description ci-dessus s'applique au code non optimisé .

Vous dites au compilateur que vous ne prendrez pas l'adresse de la variable et le compilateur peut alors ostensiblement effectuer d'autres optimisations. Pour autant que je sache, les compilateurs modernes sont assez capables de déterminer si une variable peut / doit être conservée dans un registre ou non.

Exemple:

int main(){
        int* ptr;
        int a;
        register int b;
        ptr = &a;
        ptr = &b; //this won't compile
        return 0;
} 

À l'époque des ordinateurs 16 bits, il fallait souvent plusieurs registres pour exécuter des multiplications et des divisions 32 bits. Au fur et à mesure que les unités à virgule flottante étaient incorporées dans les puces et que les architectures 64 bits prenaient le relais, la largeur des registres et leur nombre augmentaient. Cela conduit finalement à une ré-architecture complète du CPU. Voir Enregistrer des fichiers sur Wikipedia.

En bref, cela vous prendrait un peu de temps pour comprendre ce qui se passe réellement si vous êtes sur une puce X86 ou ARM 64 bits. Si vous utilisez un processeur intégré 16 bits, cela pourrait vous apporter quelque chose. Cependant, la plupart des petites puces intégrées ne fonctionnent pas en temps critique - votre four à micro-ondes peut échantillonner votre pavé tactile 10 000 fois par seconde - rien qui ne fatigue un processeur de 4 MHz.

Afin de déterminer si le mot clé register a une signification, de minuscules exemples de codes ne suffiront pas. Voici un code-c qui me suggère, le mot-clé de registre a toujours une signification. Mais cela pourrait être différent avec GCC sur Linux, je ne sais pas. Le registre int k & l sera-t-il stocké dans un registre CPU ou non? Les utilisateurs Linux (en particulier) devraient compiler avec GCC et l'optimisation. Avec Borland bcc32, le mot-clé register semble fonctionner (dans cet exemple), car l'opérateur & donne des codes d'erreur pour les entiers déclarés de registre. REMARQUE! Ce n'est PAS le cas d'un petit exemple avec Borland sous Windows! Pour vraiment voir ce que le compilateur optimise ou non, il doit s'agir d'un exemple plus que minuscule. Les boucles vides ne feront pas l'affaire! Néanmoins - SI une adresse PEUT être lue avec l'opérateur &, la variable n'est pas stockée dans un registre CPU. Mais si une variable déclarée de registre ne peut pas être lue (provoquant un code d'erreur lors de la compilation) - je dois présumer que le mot-clé de registre place réellement la variable dans un registre CPU. Cela peut différer sur différentes plateformes, je ne sais pas. (Si cela fonctionne, le nombre de "ticks" sera beaucoup plus faible avec la déclaration de registre.

/* reg_or_not.c */  

#include <stdio.h>
#include <time.h>
#include <stdlib> //not requiered for Linux
#define LAPSb 50
#define LAPS 50000
#define MAXb 50
#define MAX 50000


int main (void)
{
/* 20 ints and 2 register ints */   

register int k,l;
int a,aa,b,bb,c,cc,d,dd,e,ee,f,ff,g,gg,h,hh,i,ii,j,jj;


/* measure some ticks also */  

clock_t start_1,start_2; 
clock_t finish_1,finish_2;
long tmp; //just for the workload 


/* pointer declarations of all ints */

int *ap, *aap, *bp, *bbp, *cp, *ccp, *dp, *ddp, *ep, *eep;
int *fp, *ffp, *gp, *ggp, *hp, *hhp, *ip, *iip, *jp, *jjp;
int *kp,*lp;

/* end of declarations */
/* read memory addresses, if possible - which can't be done in a CPU-register */     

ap=&a; aap=&aa; bp=&b; bbp=&bb;
cp=&c; ccp=&cc; dp=&d; ddp=&dd;
ep=&e; eep=&ee; fp=&f; ffp=&ff;
gp=&g; ggp=&gg; hp=&h; hhp=&hh;
ip=&i; iip=&ii; jp=&j; jjp=&jj;

//kp=&k;  //won't compile if k is stored in a CPU register  
//lp=&l;  //same - but try both ways !


/* what address , isn't the issue in this case - but if stored in memory    some "crazy" number will be shown, whilst CPU-registers can't be read */

printf("Address a aa: %u     %u\n",a,aa);
printf("Address b bb: %u     %u\n",b,bb);
printf("Address c cc: %u     %u\n",c,cc);
printf("Address d dd: %u     %u\n",d,dd);
printf("Address e ee: %u     %u\n",e,ee);
printf("Address f ff: %u     %u\n",f,ff);
printf("Address g gg: %u     %u\n",g,gg);
printf("Address h hh: %u     %u\n",h,hh);
printf("Address i ii: %u     %u\n",i,ii);
printf("Address j jj: %u     %u\n\n",j,jj);

//printf("Address k:  %u \n",k); //no reason to try "k" actually is in a CPU-register 
//printf("Address l:  %u \n",l); 


start_2=clock(); //just for fun      

/* to ensure workload */
for (a=1;a<LAPSb;a++) {for (aa=0;aa<MAXb;aa++);{tmp+=aa/a;}}
for (b=1;b<LAPSb;b++) {for (bb=0;bb<MAXb;bb++);{tmp+=aa/a;}}
for (a=1;c<LAPSb;c++) {for (cc=0;cc<MAXb;cc++);{tmp+=bb/b;}}
for (d=1;d<LAPSb;d++) {for (dd=0;dd<MAXb;dd++);{tmp+=cc/c;}}
for (e=1;e<LAPSb;e++) {for (ee=0;ee<MAXb;ee++);{tmp+=dd/d;}}
for (f=1;f<LAPSb;f++) {for (ff=0;ff<MAXb;ff++);{tmp+=ee/e;}}
for (g=1;g<LAPSb;g++) {for (gg=0;gg<MAXb;gg++);{tmp+=ff/f;}}
for (h=1;h<LAPSb;h++) {for (hh=0;hh<MAXb;hh++);{tmp+=hh/h;}}
for (jj=1;jj<LAPSb;jj++) {for (ii=0;ii<MAXb;ii++);{tmp+=ii/jj;}}

start_1=clock(); //see following printf
for (i=0;i<LAPS;i++) {for (j=0;j<MAX;j++);{tmp+=j/i;}} /* same double   loop - in supposed memory */
finish_1=clock(); //see following printf

printf ("Memory: %ld ticks\n\n", finish_1 - start_1); //ticks for memory

start_1=clock(); //see following printf
for (k=0;k<LAPS;k++) {for (l=0;l<MAX;l++);{tmp+=l/k;}}  /* same double       loop - in supposed register*/
finish_1=clock(); //see following printf     

printf ("Register: %ld ticks\n\n", finish_1 - start_1); //ticks for CPU register (?) any difference ?   

finish_2=clock();

printf ("Total: %ld ticks\n\n", finish_2 - start_2); //really for fun only           

system("PAUSE"); //only requiered for Windows, so the CMD-window doesn't vanish     

return 0;

}