Quale sarebbe il modo migliore per gestire gli errori nei programmi paralleli?

Con gli algoritmi paralleli che bussano alla porta, potrebbe essere un buon momento per pensare alla gestione degli errori.

Quindi all'inizio c'erano dei codici di errore. Quelle succhiate. È stato libero di ignorarli, quindi potresti fallire in ritardo e produrre codice difficile da eseguire il debug.

Poi sono arrivate le eccezioni. A loro è stato impossibile ignorare una volta che si verificano e alla maggior parte delle persone (tranne Joel) piacciono di più.

E ora abbiamo librerie che aiutano il codice parallelo. Il problema è che non è possibile gestire le eccezioni nel codice parallelo con la stessa facilità con il codice non parallelo. Se avvii un'attività in modo asincrono e viene generata un'eccezione, non c'è traccia di stack oltre la quale svolgere; la cosa migliore che puoi fare è catturarlo e registrarlo sull'oggetto task, se esiste un tale oggetto. Tuttavia, sconfigge la forza primaria delle eccezioni: devi verificarle e puoi ignorarle senza alcuno sforzo aggiuntivo , mentre nel codice a thread singolo un'eccezione attiverà necessariamente le azioni appropriate (anche se significa terminare il tuo programma).

In che modo le implementazioni linguistiche o le librerie dovrebbero supportare errori nel codice parallelo?

programming-languages parallelism exceptions

— zneak
fonte

Non dovrebbe appartenere a StackOverflow ?

— Graviton,

@Ngu Soon Hui È soggettivo e riguarda funzionalità che non necessariamente esistono, quindi penso che appartenga qui.

— zneak,

Ma riguarda la programmazione, non i programmatori. :)

— bzlm,

Le FAQ di @bzlm dicono "Programmatori - Stack Exchange è per programmatori esperti interessati a discussioni soggettive sullo sviluppo del software." e SO scoraggia esplicitamente le discussioni soggettive.

— zneak,

Risposte:

Sono piuttosto appassionato di callback per errori che possono essere gestiti. E possono essere fatti funzionare bene in modo asincrono ...

Ma per errori che non possono essere gestiti, errori davvero eccezionali , preferirei vedere le informazioni rilevanti salvate e il programma terminato. Dato che di solito questo viene realizzato tramite una sorta di gestore globale di errori, non vedo la necessità di trasformare le eccezioni in qualcosa che funzioni per questo - ma un supporto della piattaforma migliore per rilevare errori critici e produrre dump di memoria, ecc. Sarebbe bello.

— Shog9
fonte

Io secondo richiamate. L'idea sopra sembra abbastanza perfetta per me.

— Pax Noctis,

-2

Sembra che tu voglia assicurarti che l'attività gestisca le proprie eccezioni, quindi restituisce qualcosa che fa sapere al programma chiamante che il thread deve essere chiuso. Avrebbe quindi la logica per elaborare il risultato di tutti i thread, sapendo che alcuni di questi thread avevano fallito.

"restituendo qualcosa" - a chi? Il chiamante è già passato.

— Segna H il

Come ha detto @sparkie, non puoi semplicemente farlo. Anche se mantieni lo stack di chiamate come root per la coroutine, il chiamante sarà probabilmente molto, molto lontano. Come ho già detto, le eccezioni sono state progettate in modo da interrompere il tuo programma , ora . Controllandolo tu stesso in seguito lo sconfiggi completamente poiché le eccezioni potrebbero subire inosservate.

— zneak,

@Zneak, suppongo che quando ho menzionato le eccezioni che non stavo usando la tua definizione (standard), intendevo solo che l'errore era stato colto. Dopo che una qualsiasi funzione è terminata, deve tornare da qualche parte, a quel punto si può gestire l '"eccezione" / errore (a quel livello). Non sono sicuro del motivo per cui voi ragazzi vi riferite al fatto che il programma di chiamata è lontano, qualsiasi valore di ritorno dalla funzione deve essere trattato in qualche modo. Mi rendo conto che questo non funzionerà altrettanto bene se i risultati dei thread si mescolano tra loro in modo dipendente.

Non tutte le attività parallele "ritornano" da qualche parte. Ad esempio, potresti semplicemente delegare un'attività lunga a un thread separato mentre fai qualcos'altro sul thread principale, (a torto) senza mai chiederti se è stato completato correttamente. Ad esempio, potrei scrivere un software di edizione delle immagini che scrive su file da un thread secondario e tornare dalla finestra di dialogo di salvataggio non appena viene avviata l'attività. Non avrò bisogno del valore restituito, qualunque esso sia, per qualsiasi ulteriore operazione, quindi ad eccezione degli errori, non c'è motivo di verificarlo.

— zneak,