C++: Termina chiamata, senza eccezione attiva (GCC)

Question

Si consideri il seguente programma:

#include <iostream> 
#include <pthread.h> 
#include <stdexcept> 
#include <unistd.h> 

static void* busy(void*) 
{ 
    int oldstate ; 
    auto result = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,&oldstate) ; 
    if (result != 0) 
#ifdef NOEXCEPT 
    { std::cerr << "pthread_setcanceltype" << std::endl ; abort() ; } 
#else 
    throw std::runtime_error("pthread_setcanceltype") ; 
#endif 
    while (true) 
    ; 
    return nullptr ; 
} 

static pthread_t start() 
{ 
    pthread_t t ; 
    int result = pthread_create(&t,nullptr,busy,nullptr) ; 
    if (result != 0) 
    throw std::runtime_error("pthread_create") ; 
    return t ; 
} 

static void terminate(pthread_t t) 
{ 
    auto result = pthread_cancel(t) ; 
    if (result != 0) 
    throw std::runtime_error("pthread_cancel()") ; 
    result = pthread_join(t,nullptr) ; 
    if (result != 0) 
    throw std::runtime_error("pthread_join()") ; 
} 

int main() 
{ 
    auto t = start() ; 
    sleep(1) ; // may not cause an abort otherwise 
    terminate(t) ; 
    return 0 ; 
} 

Questo funziona bene finché non l'ottimizzazione (o -O1) viene utilizzato, ad esempio, con g ++ -std = C++ 11 -Wall -o test test.cc -pthread

Tuttavia, con -O2 o -O3 il programma si interrompe con il messaggio sopra.

Anche un po 'interessante: viene eseguito se compilato con -DNOEXCEPT. Quindi, se una discussione viene cancellata in una funzione che potenzialmente [sic!] Genera un'eccezione, e se l'ottimizzazione è attivata, il programma potrebbe interrompersi. - E non riesco a vedere alcun modo per impedirlo.

È riproducibile per me su amd64 gcc 4.8.4 (Ubuntu 14.04.3) e armv7l gcc 4.9.2 (Raspbian 4.9.2-10).

Puoi riprodurre questo? Hai una spiegazione? Questo comportamento sembra strano (almeno per me). Sarei felice di ricevere una sorta di feedback. Grazie!

Answer 1

Su Linux (come sulla maggior parte dei sistemi operativi) eccezioni sono una caratteristica del linguaggio-agnostico, e la cancellazione pthread è implementato utilizzando eccezioni indipendente dal linguaggio (si veda ad esempio Cancellation and C++ Exceptions).

Quando una cancellazione di pthread viene consegnata a un thread (utilizzando un segnale, ma non è necessario saperlo), il meccanismo di svolgimento richiama tutte le personalità installate in modo che possano eseguire una pulizia specifica della lingua prima dell'uscita dal thread . (Questo è abbastanza bello, significa che come nell'articolo sopra è possibile inserire un blocco catch per abi::__forced_unwind per rilevare, anche se non impedire, un annullamento del thread.)

Il problema è che una cancellazione asincrona può verificarsi in qualsiasi istruzione, e le tabelle di eccezione C++ generate da g ++ gestiscono solo eccezioni che si verificano su istruzioni note per essere in grado di generare eccezioni (cioè, ma non solo chiamate a funzioni di lancio di eccezioni). Se viene generata un'eccezione in un punto non coperto dalle tabelle C++, la personalità del C++ va in panico e termina il processo (quindi "termina chiamata senza un'eccezione attiva").

Il motivo per cui questo è influenzato dall'ottimizzazione è che la personalità C++ è installata pigramente, ma con livelli di ottimizzazione più elevati il ​​compilatore potrebbe decidere di installare preventivamente la personalità C++. È possibile garantire il crash anche a livelli di ottimizzazione inferiori esercitando il meccanismo di eccezione C++, ad es. con try { throw 0; } catch (int) {}.

La soluzione più semplice è garantire che la personalità C++ non sia installata nel thread che si desidera annullare in modo asincrono. Puoi assicurarlo compilando la funzione thread come C e non richiamando alcuna funzione C++ da esso.

A più hacky e altamente soluzione supportata è garantire che tutti i punti di cancellazione asincroni (cioè tutte le istruzioni in cui il filo annullata potrebbe essere quando si riceve la cancellazione asincrono) sono infatti coperti dal Tabelle di svolgimento C++. In primo luogo è necessario compilare con -fnon-call-exceptions; in secondo luogo devi assicurarti che ogni istruzione che potrebbe essere un punto di annullamento asincrono sia tra due punti noti come punti di annullamento sincrono, ad es. pthread_testcancel:

static void* busy(void*) 
{ 
    int oldstate ; 
    auto result = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,&oldstate) ; 
    if (result != 0) 
#ifdef NOEXCEPT 
    { std::cerr << "pthread_setcanceltype" << std::endl ; abort() ; } 
#else 
    throw std::runtime_error("pthread_setcanceltype") ; 
#endif 
    pthread_testcancel(); 
    for (unsigned i = 1; ; ++i) 
    if (i == 0) 
     pthread_testcancel(); 
    return nullptr ; 
} 

Answer 2

Qualcuno ha scritto qui che un programma interrompe "quando un oggetto thread esce dal campo di applicazione ed è in stato joinable".

Questo è ciò che 39.3.1.3/1 [distruttore thread] dice in realtà:

Se unibili(), chiama std :: terminate(). [...] Quindi il programmatore deve assicurarsi che il distruttore non venga mai eseguito mentre il thread è ancora unificabile.