Come implementare un incremento atomico di un puntatore su un numero intero utilizzando C++ 11 <atomic>?

Question

Durante il porting di un codice Windows C++ su iOS, è necessario fornire un'implementazione della chiamata long InterlockedIncrement(long *p) di Win32. Questo è abbastanza facile utilizzando le funzioni definite in <libkern/OSAtomic.h>.

Tuttavia, mi chiedo se sia possibile scriverlo in modo indipendente dall'OS utilizzando semplicemente la funzione C++ 11, principalmente <atomic>. Sono arrivato con questo, che non sono sicuro realizza ciò che voglio:

inline long InterlockedIncrement(long* p) 
{ 
    std::atomic<long&> atomicP(*p); 
    return ++atomicP; 
} 

Funziona? È abbastanza buono? Le due linee non sono atomiche, ma l'incremento dovrebbe essere atomico, che è la chiave qui.

Tutti gli esempi di utilizzo per <atomic> che ho trovato sono diversi, in cui uno std::atomic<T> è definito e utilizzato direttamente. Qui voglio utilizzare una variabile lunga esistente che i chiamanti mi passano per indirizzo. Non sono riuscito a trovare un simile esempio.

Modifica: Clang 3.2 (in Xcode 4.x) non riesce a compilare ++atomicP con l'errore "non è possibile incrementare il valore di tipo std::atomic<long&>" (né atomicP += 1).

Quale sarebbe il modo corretto?

Edit di nuovo: un'implementazione puntatore compila ...

inline long InterlockedIncrement(long* p) 
{ 
    std::atomic<long*> atomicP(p); 
    return ++(*atomicP); 
} 

ma ho paura che questo non funziona, dal momento che non incrementare un tipo atomico, ma il valore puntato dal puntatore, che non è atomico.

Answer 1

L'implementazione di esempio sta costruendo un nuovo atomico da un puntatore ogni volta. Questo non è l'uso previsto di std :: atomic e non credo che funzioni come vorresti.

Per quanto ne so, l'unico modo per fare ciò che si sta cercando di fare (rimuovere la dipendenza da InterlockedIncrement in modo indipendente dalla piattaforma) è quello di sostituire tutte le dichiarazioni per le variabili che si stanno attualmente chiamando chiamate "interlock" Win32 con std :: versioni atomiche di loro. Quindi, è possibile rimuovere le chiamate interbloccate e utilizzare la semantica del valore normale per modificare la variabile atomicamente. Questo è più leggibile (e più gestibile in futuro), comunque.

Capisco che desideri lasciare il codice esistente (ben collaudato) sul posto ma non credo che tu possa nel tuo caso.

Answer 2

Credo che si possa utilizzare un'operazione atomic_fetch_add. Dai un'occhiata all'esempio here.

Answer 3

__atomic_add_fetch GCC estensione

Nel GCC 4.8, libreria standard C++ implementa std::atomic::operator++ con il CCG incorporato __atomic_add_fetch, così si potrebbe scrivere:

inline long InterlockedIncrement(long* p) 
{ 
    return __atomic_add_fetch(p, 1, __ATOMIC_SEQ_CST); 
} 

Non sono sicuro per clang, ma ci sembrano essere alcune opzioni come __c11_atomic_fetch_addhttp://clang.llvm.org/docs/LanguageExtensions.html

Come già menzionato, l'argomento p dovrebbe essere std::atomic per poter utilizzare solo i metodi di libreria standard: la conversione del puntatore in atomico non è di aiuto perché il puntatore atomico agisce solo sul puntatore, non su ciò a cui punta.