Hi,

Reading https://en.cppreference.com/w/cpp/language/transactional_memory.

My question is about atomic transactions.
I understand that *atomic_cancel* block will throw an exception if the
transaction cannot succeed.

Is it the responsibility of the caller to decide to retry in the catch
statement or is there a hidden mechanism that tries again up to the point
it succeeds?

*Eg:*

int f(){
   static int i = 0;
   atomic_noexcept {
      // other operations that may fail and throw
      ++i;
      return i;
   }}

int caller(){

unsigned k;

try{

  k = f();

}

catch(...){

  // retry here? What if that fails again and the program must keep running?

  k = f();

}

}

or should we do that this way instead?

int recursive_caller(){

unsigned retry_limit = 15;

unsigned k;

while(retry_limit--){

try{

k = f();

return k;

}
catch(...){

}

}

//handle that failure situation with an exception or else

}


As for *atomic_commit, *how can it commit if there is an exception
laying around?

An example and clarifications would be welcome.

Thanks