Bonjour à tous,

Je cherche à rendre atomique une opération de lecture/écriture sur un espace mémoire de 8 octets (64 bits) sur une machine à architecture 32bits.

je ne veux utiliser aucun lock (sémaphore, mutex etc) ni de solution de buffer tournant...

J'ai entendu parler d'une technique consistant à utiliser un cast de réel double sur la zone mémoire en question mais je n'arrive pas à le faire fonctionner :

la zone mémoire partagée par deux processus concurrents :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
unsigned long long zone_64;
le code accédant à cette fonction en lecture :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
char buffer[8];
 
*(double *)buffer = *(double *)&zone_64;
le code accédant à cette fonction en écriture :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
char buffer[8]; //puis initialisation avec une valeur
 
*(double *)&zone_64 = *(double *)buffer;
Globalement le test que je fais consiste à créer deux processus :
un premier écrit 0x0000000000000000 puis 0xffffffffffffffff à l'infini avec le code d'écriture ci dessus et le deuxième lit avec le code de lecture ci dessus. Les programmes sont en priorité hautes et égales donc ont un accès concurrent sur la zone mémoire qui est une zone de mémoire partagée.

évidemment le résultat est que de temps en temps je lis 0x00000000ffffffff ou 0xffffffff00000000. (car l'opération d'écriture 64 bits sur architecture 32 bits n'est pas atomique).

j'ai essayé en plaçant des variables de type double intermédiaire, cela n'a pas marché ni en utilisant le mot clé volatile pour la variable en shm.

Si quelqu'un à déjà utilisé cette "méthode" du type double, je suis preneur !

merci.