pthread_cancel si comporta diversamente su arm e ppc?

Question

Attualmente sto lavorando a un'applicazione multi-thread che verrebbe distribuita su arm e su architettura ppc. Sto avendo qualche problema con pthread_cancel al braccio.

pthread_cancel sul braccio non si comporta allo stesso modo con ppc. Il thread viene annullato ma il distruttore per la variabile locale del thread non viene chiamato sul braccio. Ho anche provato a definire in modo esplicito una routine di cancellazione cleanup installata tramite pthread_cleanup_push. Ma non viene chiamato quando il thread viene annullato.

Il codice funziona correttamente con ppc. Quando un thread viene cancellato, viene chiamato il distruttore della variabile locale. E quando ho definito esplicitamente un gestore di cleanup, è stato chiamato ed eseguito quando è stato chiamato pthread_cancel.

Mi manca qualcosa? Alcune opzioni del compilatore forse?

• linguaggio di programmazione: C++
• compilatori: arm-linux-g ++/PowerPC-linux-g ++
• SO: Linux

EDIT:

ho trovato una sorta di problema analogo registrato su questo libc bug.

Utilizzare gcc invece di g ++ e l'aggiunta dell'opzione del compilatore -fno-exception ha fatto il trucco. Ma voglio davvero capire le cose dietro a questo problema. Inoltre, il -fno-exception significa che non sarò in grado di eseguire la gestione delle eccezioni nella mia applicazione, non che lo sto usando ora, ma potrei esserlo in futuro.

Grazie.

Answer 1

La cancellazione del thread senza l'aiuto dell'applicazione è una cattiva idea. Solo google. È molto meglio dire al thread di terminare se stesso impostando una variabile flag che viene controllata periodicamente dal thread.

In realtà la cancellazione è così difficile che è stata omessa dall'ultima bozza di C++ 0x. Puoi cercare http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2497.html e non troverai alcuna menzione di cancellazione. Ecco la definizione della classe thread proposta (non troverai cancellazioni):

class thread 
{ 
public: 
    // types: 
    class id; 
    typedef implementation-defined native_handle_type; // See [thread.native] 

    // construct/copy/destroy: 
    thread(); 
    template <class F> explicit thread(F f); 
    template <class F, class ...Args> thread(F&& f, Args&&... args); 
    ~thread(); 
    thread(const thread&) = delete; 
    thread(thread&&); 
    thread& operator=(const thread&) = delete; 
    thread& operator=(thread&&); 

    // members: 
    void swap(thread&&); 
    bool joinable() const; 
    void join(); 
    void detach(); 
    id get_id() const; 
    native_handle_type native_handle(); // See [thread.native] 

    // static members: 
    static unsigned hardware_concurrency(); 
};