pthread_cancel si comporta diversamente su arm e ppc?

Question

Attualmente sto lavorando ad un'applicazione multi-thread che verrebbe distribuita su arm e ppc architecture. Sto riscontrando qualche problema con pthread_cancel sul braccio.

pthread_cancel on arm non si comporta allo stesso modo con ppc. Il thread viene annullato ma il distruttore per la variabile locale del thread non viene richiamato su arm. Ho anche provato a definire esplicitamente una routine del gestore di pulizia di annullamento installata tramite pthread_cleanup_push. Ma non viene chiamato quando il thread viene annullato.

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

Mi sto perdendo qualcosa? Alcune opzioni del compilatore forse?

• Linguaggio di programmazione: C ++
• Compilatori: arm-linux-g ++ / powerpc-linux-g ++
• Sistema operativo: Linux

EDIT:

Ho riscontrato una sorta di problema simile connesso a questo bug libc .

Usare gcc invece di g ++ e aggiungere l'opzione del compilatore -fno-exception ha fatto il trucco. Ma voglio davvero capire le cose dietro questo problema. Inoltre, l'eccezione -fno significa che non sarò in grado di eseguire la gestione delle eccezioni nella mia applicazione, non che la sto usando ora ma che potrei essere 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 C ++ 0x. Puoi cercare http://www.open -std.org/jtc1/sc22/wg21/docs/papers/2008/n2497.html e non troverà alcuna menzione di cancellazione. Ecco la definizione della classe di thread proposta (qui non troverai Annulla):

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();
};