Por que std :: atomic <T> :: is_lock_free () não estático, assim como constexpr?

Alguém pode me dizer se std :: atomic :: is_lock_free () não é estático, assim como constexpr? Tê-lo não estático e / ou não constexpr não faz sentido para mim.

Conforme explicado na cppreference :

Todos os tipos atômicos, exceto std :: atomic_flag, podem ser implementados usando mutexes ou outras operações de bloqueio, em vez de usar as instruções da CPU atômica sem bloqueio. Às vezes, os tipos atômicos também podem ser livres de bloqueios; por exemplo, se apenas os acessos à memória alinhados são naturalmente atômicos em uma determinada arquitetura, objetos desalinhados do mesmo tipo precisam usar bloqueios.

O padrão C ++ recomenda (mas não exige) que operações atômicas sem bloqueio também sejam livres de endereço, ou seja, adequadas para comunicação entre processos usando memória compartilhada.

Conforme mencionado por várias outras pessoas, std::is_always_lock_freepode ser o que você realmente está procurando.

Editar: para esclarecer, os tipos de objetos C ++ têm um valor de alinhamento que restringe os endereços de suas instâncias a apenas determinados múltiplos de potências de dois ( [basic.align]). Esses valores de alinhamento são definidos pela implementação para tipos fundamentais e não precisam ser iguais ao tamanho do tipo. Eles também podem ser mais rigorosos do que o que o hardware realmente suporta.

Por exemplo, x86 (principalmente) suporta acessos não alinhados. No entanto, você encontrará a maioria dos compiladores que possuem o alignof(double) == sizeof(double) == 8x86, pois os acessos desalinhados têm uma série de desvantagens (velocidade, cache, atomicidade ...). Mas, por exemplo, #pragma pack(1) struct X { char a; double b; };ou alignas(1) double x;permite que você tenha "desalinhados" doubles. Portanto, quando cppreference fala sobre "acessos de memória alinhados", presumivelmente o faz em termos do alinhamento natural do tipo para o hardware, não usando um tipo C ++ de uma maneira que contradiga seus requisitos de alinhamento (que seria UB).

Aqui estão mais informações: Qual é o efeito real de acessos não alinhados com êxito no x86?

Confira também os comentários perspicazes de @Peter Cordes abaixo!

Você pode usar std::is_always_lock_free

is_lock_free depende do sistema real e não pode ser determinado em tempo de compilação.

Explicação relevante:

Às vezes, os tipos atômicos também podem ser livres de bloqueios, por exemplo, se apenas os acessos alinhados à memória são naturalmente atômicos em uma determinada arquitetura, objetos desalinhados do mesmo tipo precisam usar bloqueios.

Instalei o Visual Studio 2019 no meu PC com Windows e este devenv também possui um compilador ARMv8. O ARMv8 permite acessos desalinhados, mas a comparação e trocas, adições bloqueadas etc. são obrigatórias para serem alinhadas. E também carga pura / armazenamento puro usando ldpor stp(par de carga ou par de registros de 32 bits) só são garantidos como atômicos quando alinhados naturalmente.

Então, escrevi um pequeno programa para verificar o que is_lock_free () retorna para um ponteiro atômico arbitrário. Então aqui está o código:

#include <atomic>
#include <cstddef>

using namespace std;

bool isLockFreeAtomic( atomic<uint64_t> *a64 )
{
    return a64->is_lock_free();
}

E essa é a desmontagem do isLockFreeAtomic

|?isLockFreeAtomic@@YA_NPAU?$atomic@_K@std@@@Z| PROC
    movs        r0,#1
    bx          lr
ENDP

Isto é apenas returns true, aka 1.

Essa implementação escolhe usar alignof( atomic<int64_t> ) == 8para que todos atomic<int64_t>estejam alinhados corretamente. Isso evita a necessidade de verificações de alinhamento do tempo de execução em cada carregamento e armazenamento.

(Nota do editor: isso é comum; a maioria das implementações da vida real em C ++ funciona dessa maneira. É por std::is_always_lock_freeisso que é tão útil: porque geralmente é verdade para tipos onde is_lock_free()é verdade.)