Discussion :

[divide]

Bonjour,

Je cherche depuis une semaine, hélas sans succès, comment additionner 2 floats de manière atomique (plus précisement, comment ajouter une emplacement mémoire float à un autre emplacement mémoire float). Par "atomique", j'entend que cette opération puisse être effectuée depuis plusieurs threads différents sur le même emplacement mémoire, sans avoir recours à un mutex (qui ferait perdre trop de temps).
Et j'ai juste besoin de faire une addition, pas d'implémenter toute une classe complète dédié à la gestion atomique de float (si jamais ca peut simplifier le problème...)

Merci

[moldavi]

Bonjour.

Peut-être que le mot clé volatile sera suffisant.

Mais si l'addition nécessite une synchronization pour une raison ou pour une autre, cela ne résoudra pas le problème. Disons que si un thread fait une addition en même temps qu'un autre thread mais que l'ordre pour l'addition n'a pas d'importance, le mot clé volatile peut être utile ici.

Le mot clé volatile signifie au compilateur de ne pas optimiser l'emplacement mémoire de la variable. Par exemple, lorsque deux threads utilisent la même variable, celui-ci peut positionner cette variable dans des registres propres aux threads. Du coup il y a deux copies de ta variable, pour des raisons d'optimisation. Le premier thread fait l'addition et la variable retourne à son emplacement d'origine. Le second thread fait l'addition, on va dire que c'est le dernier à s'exécuter, et la variable va retourner à son emplacement d'origine, écrasant la dernière valeur.

Avec le mot clé volatile, la variable ne possédant pas de copie, le thread 1 fera l'addition et le thread 2 fera l'addition sur le résultat de l'addition du thread 1. Peut-être que c'est le resultat que tu souhaites.

Mais si tu devais être certain que l'addition commence d'abord par le thread 1, puis le thread 2, dans cet ordre, une synchronisation devient indispensable.

[divide]

L'ordre des additions n'a aucune importance, donc d'après ta description volatile pourrait répondre à mon problème;
Par contre je ne saisis pas bien comment l'utiliser en pratique, voila un pseudo-code minimaliste qui correspond à mon cas pratique:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
float destinationvalue=0.f;
float addvaluethread1=2.f;
float addvaluethread2=3.f;
 
thread(float *destinationvalue, float *addvalue)
{
   *destinationvalue+=*addvalue;
}

thread étant appelé en parallèle avec &destinationvalue, mais 2 &addvalue différents: au final j'attend que destinationvalue soit égal à 2+3=5, peu importe l'ordre des additions.
Comment changerai tu cet exemple pour que volatile soit effectif ?

[divide]

Bon j'ai essayé différents cas de figure avec volatile, malheureusement les threads se marchent quand meme sur les pieds, mon résultat final ne correspond pas à la somme de toutes les valeurs ajoutés...
L'article wikipedia souligne d'ailleurs le fait que volatile n'est pas vraiment prévu pour protéger des variables d'un acces simultané en multithread: http://en.wikipedia.org/wiki/Volatile_variable

[Davidbrcz]

Volatile ne sert a rien ici et est hors propros. Il empêche juste le compilateur d'optimiser du code en fonction d'une variable qui POUR LUI lui ne semble ne jamais évoluer mais en fait si (variable décrivant l'état d'un bumper sur une carte électronique par exemple).

Sinon pour une réponse précise, il faut du contexte, tu fais quoi, tu veux faire quoi, avec quels outils ?

Car une solution pourrait se trouver dans std::atomic.

[moldavi]

Bonjour.

En effet cela ne marche pas. Je viens de comprendre pourquoi. J'utilise volatile, mais en conjonction avec InterlockedIncrement, et c'est finalement cette dernière qui s'occupe de l'aspect atomique. Le mot clé volatile permet d'éviter une optimisation indésirable du compilateur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <Windows.h>
#include <iostream>
 
class CMyClass{
 
public:
    CMyClass() : lValue(0){}
    volatile long lValue;
};
 
DWORD WINAPI MyThreadFunction(LPVOID lpParam){
 
    CMyClass* theClass = (CMyClass*)lpParam;
 
    /*for(int i = 0; i < 100000; i++)
       theClass->lValue += 1;*/
 
    for(int i = 0; i < 100000; i++)
        InterlockedIncrement(&theClass->lValue);
 
    return 0L;
}
 
void main(){
 
    HANDLE hThread[3];
    CMyClass theClass;
 
    for(int i = 0; i < 3; i++)
        hThread[i] = CreateThread(NULL, 0, MyThreadFunction, (LPVOID)&theClass, 0,NULL);
 
    WaitForMultipleObjects(3, hThread, TRUE, INFINITE);
 
 
    for(int i = 0; i < 3; i++)
        CloseHandle(hThread[i]);
 
    std::cout << theClass.lValue << std::endl;
 
    char c;
    std::cin >> c;
}

J'ai vu que sous Windows tu as des fonctions pour l'addition atomique :

http://msdn.microsoft.com/en-us/libr...(v=vs.85).aspx

C'est pour Windows et je n'ai pas vu de fonction d'addition atomique pour des float.