Std :: Call_once Lazy Initialisierungsproblem auf QNX

Question

Mein Code stürzt regelmäßig auf QNX. Es stürzt mit Fehler

Fehlervariable zu lesen: Speicher kann nicht auf 0x85dd6ac Adresse zugreifen)

bei dem Versuch, std :: map Membervariable von 0x85dd6ac Objekt zuzugreifen, die initialisiert std::call_once mit faul ist.

Initialisierung wird mit dem folgenden Pseudocode durchgeführt:

mutable std::aligned_storage<sizeof(A), alignof(A) >::type m_value; 

void init(A *ptr) 
{ 
    new (ptr) A(); 
} 

inline T* data() const 
{ 
    return reinterpret_cast<A*>(&m_value); 
} 

const A& get() const 
{ 
    std::call_once(m_once_flag, init, data()); 
    return *data(); 
} 

An einem gewissen Punkt, wenn Objekt zurückgegeben von get() den Vorgang zugegriffen wird, abgestürzt ist.

Auf anderen Plattformen wird das Problem nicht reproduziert und es ist sehr schwierig zu debuggen. Aus dem Code kann ich sehen, dass das Objekt nicht nicht initialisiert werden kann und auch an diesem Punkt nicht gelöscht werden kann.

Ich vermute, es kann ein Problem mit std::call_once Implementierung mit Thread-Sicherheit oder Speicherordnung sein. Hat jemand Erfahrung mit std :: call_once auf QNX-Plattform oder Bugs so? Irgendwelche Ideen, wie ich das Problem finden kann?

Answer 1

Ich habe die gleiche Erfahrung mit std :: call_once in QNX, aber neben Absturz kann es auch Dead Lock in Multithreading-Anwendung verursachen. Ich schlage vor, das folgende Muster verwenden std :: call_once zu ersetzen:

static std::atomic<bool> once_flag = false; 
if (!once_flag.exchange(true)) 
{ 
    // This part will be executed only once. 
    // ... 
} 

UPDATE Basierend auf Kommentar von fefe diese Lösung nicht die Bedingung der Blockierung der passiven Ausführung (siehe Details auf http://www.cplusplus.com/reference/mutex/call_once/).

Wenn Sie dies auch sättigen müssen, sollten Sie eine komplexere Lösung implementieren. Hier ein Beispiel:

static std::atomic<bool> once_flag = false; 
static std::atomic<bool> once_call_done = false; 
if (!once_flag.exchange(true)) 
{ 
    // This part will be executed only once. 
    // ... 

    once_call_done = true; 
} 
else 
{ 
    // Block until the call once part is running. 
    while(!once_call_done) 
    { 
     sleep(1); 
    } 
} 

Answer 2

Problem wurde mit Std :: Call_once. Es ist ein Fehler in der Implementierung. Temporäres Ersetzen mit Mutex löste das Problem. Hatte nicht mehr Zeit, um in Details zu graben, aber hoffentlich wird diese Information jemandem mit ähnlichem Problem helfen.

Vielen Dank für Ihre Kommentare!