Esiste una teoria per le sequenze "transazionali" di azioni fallite e non fallite?

La mia domanda riguarda la scrittura di funzioni simili a transazioni che eseguono sequenze di azioni, alcune delle quali potrebbero non riuscire. È legato al principio generale del C ++ "i destructors non possono lanciare", proprietà no-fail, e forse anche con transazioni multifase o sicurezza delle eccezioni. Tuttavia, ci sto pensando in termini linguistici. La mia preoccupazione è nel progettare correttamente la gestione degli errori nelle funzioni C ++ che deve essere affidabile. Mi piacerebbe sapere quali sono i concetti qui sotto in modo che io possa imparare di più su di loro.

Mi dispiace di non poter fare la domanda più direttamente. Dato che non conosco quest'area, ho fornito un esempio per spiegare la mia domanda. La domanda è alla fine. Ecco qui:

Considera una sequenza di passaggi o azioni eseguite sequenzialmente, in cui le azioni appartengono a una delle due classi: quelle che hanno sempre esito positivo e quelle che potrebbero non riuscire. Negli esempi di seguito:

• S sta per un'azione che ha sempre successo (chiamata "no-fail" in alcune impostazioni).

• F sta per un'azione che potrebbe fallire (ad esempio, potrebbe non riuscire ad allocare memoria o fare I / O che potrebbe fallire).

Considera una sequenza di azioni (eseguite sequenzialmente da sinistra a destra):

S->S->S->S

Poiché ogni azione nella sequenza sopra ha esito positivo, l'intera sequenza ha esito positivo.

D'altro canto, la seguente sequenza potrebbe fallire perché l'ultima azione potrebbe fallire:

S->S->S->F

Quindi, claim: una sequenza ha la proprietà no-fail (S) se e solo se tutte le sue azioni sono non-fallite.

Ora, mi interessano le sequenze d'azione che formano "transazioni atomiche", con "atomicità fallita", cioè dove l'intera sequenza si completa con successo, oppure non c'è alcun effetto. Cioè se un'azione fallisce, i precedenti devono essere ripristinati. Ciò richiede che tutte le azioni eseguite correttamente prima di un'azione non riuscita debbano sempre essere ripristinate. Considera la sequenza:

S->S->S->F
S<-S<-S

Nell'esempio sopra, la prima riga è il percorso forward della transazione, e la seconda riga sono azioni inverse (eseguite da destra a sinistra) che possono essere utilizzate per il rollback se l'ultima azione della riga superiore fallisce.

Mi sembra che per una transazione che supporta l'atomicità fallita, il seguente invariante deve contenere:

Rivendicazione: per supportare failure atomicity (esito positivo completo o rollback completo in caso di errore) tutte le azioni precedenti all'ultima azione f disponibile (F) sul percorso in avanti (contrassegnato * nell'esempio seguente) deve avere inversioni non fail (S). Quello che segue è un esempio di una sequenza che supporta l'atomicità fallita:

         *
S->F->F->F
S<-S<-S

Inoltre, se vogliamo che la transazione sia in grado di tentare la cancellazione a metà percorso, ma comunque garantiamo il completamento completo o il rollback completo, abbiamo bisogno della seguente proprietà:

Claim: per supportare failure atomicity and cancellation a metà dell'esecuzione, a fronte di errori nel percorso inverso (cancellazione), tutte le azioni successive alla prima (F) inverso sul percorso inverso (contrassegnato *) deve essere non-fallito (S).

F->F->F->S->S
S<-S<-F<-F
      *

Credo che queste due condizioni garantiscano che una transazione facilmente cancellabile non si "bloccherà".

Le mie domande sono:

Che cos'è lo studio e la teoria di queste proprietà? le mie affermazioni sono corrette? e cos'altro c'è da sapere?

UPDATE 1: Terminologia aggiornata: ciò che ho chiamato "robustezza" è chiamato atomicità nella letteratura del database.

AGGIORNAMENTO 2: aggiunto riferimento esplicito a errore atomicità , che sembra essere una cosa.