Intel Inspector berichtet über ein Daten Rennen in meiner spinlock Umsetzung

Question

Ich habe einen sehr einfachen spinlock die miteinander verflochtenen Funktionen in Windows verwenden und getestet es auf einem Dual-Core-CPU (zwei Threads, die eine Variable erhöhen);

Das Programm scheint gut zu funktionieren (es das gleiche Ergebnis, jedes Mal gibt was nicht der Fall ist, wenn keine Synchronisation verwendet wird), aber Intel Inspector Parallel sagt, dass es eine Race-Bedingung in < em> Wert + = j (siehe Code unten). Die Warnung verschwindet, wenn Kritische Abschnitte statt meiner SpinLock verwenden.

Ist meine Implementierung von SpinLock korrekt ist oder nicht? Es ist wirklich seltsam, denn alle verwendeten Operationen sind Atome und haben die richtigen Speicherbarrieren und es soll nicht zu Rennbedingungen führen.

class SpinLock
{
   int *lockValue;
   SpinLock(int *value) : lockValue(value) { }

   void Lock() {
      while(InterlockedCompareExchange((volatile LONG*)lockValue, 1, 0) != 0) {
          WaitABit();
      }
   }

   void Unlock() { InterlockedExchange((volatile LONG*)lockValue, 0); }
};

Das Testprogramm:

static const int THREADS = 2;
HANDLE completedEvents[THREADS];
int value = 0;
int lock = 0; // Global.

DWORD WINAPI TestThread(void *param) {
    HANDLE completed = (HANDLE)param;
    SpinLock testLock(&lock);

    for(int i = 0;i < 1000*20; i++) {
        for(int j = 0;j < 10*10; j++) {
            // Add something to the variable.
            testLock.Lock();
            value += j;
            testLock.Unlock();
        }
    }
    SetEvent(completed);
}

int main() {
   for(int i = 0; i < THREADS; i++) {
        completedEvents[i] = CreateEvent(NULL, true, false, NULL);
   }
   for(int i = 0; i < THREADS; i++) {
        DWORD id;
        CreateThread(NULL, 0, TestThread, completedEvents[i], 0, &id);
   }

   WaitForMultipleObjects(THREADS, completedEvents, true, INFINITE);
   cout<<value;
}

Answer 1

Dokumentation des Parallel Inspector Daten Rennen einen kritischen Abschnitt oder einen Mutex schlägt mit Rennen auf Windows zu beheben. Es gibt nichts darin, die Parallel Inspector legen nahe, dass weiß, wie anderen Verriegelungsmechanismus zu erkennen, Sie erfinden könnten.

Werkzeuge für die Analyse neuartiger Verriegelungsmechanismen sind in der Regel statische Werkzeuge sein, die durch den Code bei jedem möglichen Weg suchen, Dokumentation Parallel Inspector impliziert, dass es den Code einmal ausgeführt wird.

Wenn Sie mit neuartigen Verriegelungsmechanismen experimentieren wollen, ist die häufigste Werkzeug Ich habe in der wissenschaftlichen Literatur verwendet gesehen ist die Spin Model Checker . Es gibt auch ESP , die den Zustandsraum reduzieren könnte, aber ich weiß nicht wissen, ob es um die gleichzeitige Probleme angewendet wird worden, und auch die Mobilität Werkbank denen würde eine Analyse geben, wenn Sie können Couch Ihr Problem in pi-Kalkül. Intel Parallel Inspector scheint nicht so etwas wie diese Werkzeuge kompliziert, sondern die für gewöhnlich zu überprüfen Probleme auftreten, unter Verwendung von Heuristiken.

Answer 2

Für andere arme Leute in einer ähnlichen Situation zu mir: Intel macht einen Satz bereitzustellen, umfasst und Bibliotheken für die genau das tun, diese Art der Sache. Überprüfen Sie im Inspektor-Installationsverzeichnis (Sie werden sehen, \ include, \ lib32 und \ lib64 im Installationsverzeichnis) für diese Materialien. Dokumentation, wie sie verwenden (Stand Juni 2018, obwohl Intel kümmert sich nicht über Links konsistent zu halten):

https: // Software .intel.com / en-us / Prüfer-user-guide-windows-apis-for-custom-Synchronisation

Es gibt 3 Funktionen:

void __itt_sync_acquired(void *addr)
void __itt_sync_releasing(void *addr)
void __itt_sync_destroy(void *addr)

Answer 3

Ich bin mir ziemlich sicher, dass es umgesetzt werden soll wie folgt:

class SpinLock
{
   long lockValue;
   SpinLock(long value) : lockValue(value) { }

   void Lock() {
      while(InterlockedCompareExchange(&lockValue, 1, 0) != 0) {
          WaitABit();
      }
   }

   void Unlock() { InterlockedExchange(&lockValue, 0); }
};