Ahmed AEK's questions

É seguro ler um ponteiro para um atomic sem sincronização, supondo que ele nunca será um nullptr? Como no código a seguir, suponha que há duas threads em execução writere readersimultaneamente.

std::atomic<int>* g_atomic = new std::atomic<int>{};

void writer()
{
    for (int i = 0; i < 101; i++)
    {
        auto* new_atomic = new std::atomic<int>{i};
        std::atomic_thread_fence(std::memory_order_seq_cst); // memory barrier.
        g_atomic = new_atomic; // ignore the memory leak
    }
}

void reader()
{
    auto value = g_atomic->load();
    while (value < 100)
    {
        assert(value >= 0 && value <= 100);
        value = g_atomic->load();
    }
}

por seguro quero dizer que sempre lerei um valor de 0 a 100, não lerei um ponteiro inválido nem lerei o objeto apontado antes de sua inicialização.

minha intuição me diz que isso é seguro porque

1. ponteiros são lidos ou escritos atomicamente em todas as arquiteturas.
2. o valor apontado é lido atomicamente, ele precisa ser buscado na RAM, e a barreira de memória antes da gravação garante que a RAM esteja sempre correta.

Então, isso é seguro? Talvez apenas em todas as arquiteturas comuns?

A comparação de iteradores begin()e de dois s que apontam para a mesma memória está bem definida?end()std::span

#include <span>
#include <cassert>

int main() {
    int arr[5]{1,2,3,4,5};
    std::span s1{arr};
    std::span s2{arr};
    assert(s1.begin() == s2.begin());
    assert(s1.end() == s2.end());
    assert(s1.begin() + s1.size() == s2.end());
}

Todas as afirmações passam em todas as implementações std::spanaté agora, mas há algo que eu possa estar esquecendo que torna isso um bug, por exemplo, UB?

Para contextualizar, isso pode ocorrer se você tiver uma classe que tenta esconder seus componentes internos com um span.

class some_class
{
public:
  std::span<int> vec_view() { return vec; }
private:
  std::vector<int> vec;
};

int main() {
    some_class c;
    std::for_each(c.vec_view().begin(), c.vec_view().end(), [](auto&){});
}

Isso está relacionado a C++ permite comparação entre std::span::iterators quando um span é um subspan do outro?, mas esta questão não é sobre um std::subspan, e além disso a std::spanversão também passa asserções MSVC, diferente da versão com o std::subspan.

Eu estava tentando medir o custo de uma indireção, já que empilhar indireções umas sobre as outras pode degradar o desempenho específico que estou tentando medir.

1. Chamada de função direta (chamar função na mesma DLL diretamente, provavelmente em linha)
2. Chamada de função indireta (chama uma função em outra DLL por meio de um ponteiro, não embutido)
3. chamada de função virtual.
4. chamada de função virtual e, em seguida, uma chamada de função indireta (uma classe polimórfica que contém um ponteiro de função).

Para evitar que o compilador faça qualquer inlining, eu o dividi em um exee umdll

código executável

#include <limits.h>
#include <vector>
#include <chrono>
#include <iostream>
#include <span>

static int foo(int a, std::vector<int>& v) {
    v.push_back(a);
    if (v.size() > 2)
    {
        v.clear();
    }
    return a;
}

struct IFooable
{
    virtual int foo(int a) = 0;
};

__declspec(dllimport) int foo2(int a, std::vector<int>& v);

__declspec(dllimport) int direct_version(std::vector<int>& v);

__declspec(dllimport) int indirect_version(int (*fn)(int, void*), void* p);

__declspec(dllimport) int indirect_Interface(IFooable& f);

struct MyFoo final: public IFooable
{
    int foo(int a) override
    {
        return ::foo(a, v);
    }
    MyFoo(std::vector<int>& v) : v{ v } {}
    std::vector<int>& v;
};

struct MyFoo2 final : public IFooable
{
    using functype = int (*)(int, std::vector<int>&);
    int foo(int a) override
    {
        return f(a, v);
    }
    MyFoo2(std::vector<int>& v, functype f) : v{ v }, f{ f } {}
    std::vector<int>& v;
    functype f;
};

int main(int argc, char* argv[]) {
    std::vector<int> v;
    for (int i = 0; i < 20; i++)
    {
        foo(i, v);
    }

    std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();

    direct_version(v);
    std::chrono::steady_clock::time_point end1 = std::chrono::steady_clock::now();

    indirect_version([](int a, void* p) {return foo(a, *reinterpret_cast<std::vector<int>*>(p)); }, reinterpret_cast<void*>(&v));
    std::chrono::steady_clock::time_point end2 = std::chrono::steady_clock::now();

    MyFoo ff{ v };
    indirect_Interface(ff);
    std::chrono::steady_clock::time_point end3 = std::chrono::steady_clock::now();
    MyFoo2 ff2{ v, foo2 };
    indirect_Interface(ff2);
    std::chrono::steady_clock::time_point end4 = std::chrono::steady_clock::now();

    std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end1 - begin).count() << "[ms] " << "Direct" << std::endl;
    std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end2 - end1).count() << "[ms] " << "Indirect" << std::endl;
    std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end3 - end2).count() << "[ms] " << "Virtual" << std::endl;
    std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end4 - end3).count() << "[ms] " << "Virtual + Indirect" << std::endl;

    double micros_count = std::chrono::duration_cast<std::chrono::milliseconds>(end2 - end1).count();
    double iterations = INT_MAX;
    std::cout << "nanoseconds per iteration = " << (micros_count / iterations) * 1000000 << '\n';
    
    return 0;
}

código dll

// dllmain.cpp : Defines the entry point for the DLL application.
#include "pch.h"
#include <vector>
#include <span>

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

struct IFooable
{
    virtual int foo(int a) = 0;
};

static int foo(int a, std::vector<int>& v) {
    v.push_back(a);
    if (v.size() > 2)
    {
        v.clear();
    }
    return a;
}

__declspec(dllexport) int foo2(int a, std::vector<int>& v) {
    v.push_back(a);
    if (v.size() > 2)
    {
        v.clear();
    }
    return a;
}

__declspec(dllexport) int direct_version(std::vector<int>& v) {
    int i, b = 0;
    for (i = 0; i < INT_MAX; ++i) {
        b = foo(b, v);
    }
    return b;
}

__declspec(dllexport) int indirect_version(int (*fn)(int, void*), void* p) {
    int i, b = 0;

    for (i = 0; i < INT_MAX; ++i) {
        b = fn(b, p);
    }

    return b;
}

__declspec(dllexport) int indirect_Interface(IFooable& f) {
    int i, b = 0;

    for (i = 0; i < INT_MAX; ++i) {
        b = f.foo(b);
    }

    return b;
}

elas são compiladas no modo de lançamento, então /O2, o benchmark é construído de uma forma que evita qualquer perda de cache, e provavelmente permite que a CPU preveja para onde todas as funções apontarão, já que não estou interessado no custo de uma previsão incorreta de ramificação ou uma perda de cache, além disso, a função não é trivial, mas suficientemente pequena, e eu verifiquei o assembly e nada está embutido como esperado.

resultado:

3058[ms] Direct
8279[ms] Indirect
9109[ms] Virtual
7340[ms] Virtual + Indirect
nanoseconds per iteration = 3.85521

Uma função virtual é um pouco mais lenta que uma chamada indireta, como esperado, mas uma chamada virtual + indireta é mais rápida que qualquer uma delas... isso não faz sentido.

Minha pergunta é: por que a função virtual + indireção é mais rápida do que qualquer uma delas sozinha? E eu deveria esperar que o custo dessa indireção em cascata aumentasse?

Não é incomum ter uma API C++ com funções virtuais encapsulando uma API C que está em outra DLL, então este benchmark é o mais próximo possível do mundo real.

trocar a ordem das chamadas não muda nada, elas também são longas o suficiente para que qualquer fator como aumento de velocidade da CPU, superaquecimento e agendador não afete o benchmark.

Editar: parece que as verificações de estouro de buffer distorceram um pouco os resultados. Agora, esses são os resultados mais recentes, sem essas verificações extras.

3051[ms] Direct
6182[ms] Indirect
8002[ms] Virtual
7616[ms] Virtual + Indirect
nanoseconds per iteration = 2.87872

ainda virtual + Indireto é mais rápido que apenas virtual, o que é muito estranho.

normalmente encontro esse trecho aparecendo em meu código, onde dois objetos que não possuem um ao outro precisam ter um ponteiro um para o outro, e esse ponteiro deve ser "limpo" quando um deles for destruído da seguinte maneira.

struct bar;
struct foo;

struct foo
{
    bar* bar_item = nullptr;
    ~foo();
};

struct bar
{
    foo* foo_item = nullptr;
    ~bar()
    {
        if (foo_item)
        {
            foo_item->bar_item = nullptr;
        }
    }
};

foo::~foo()
{
    if (bar_item)
    {
        bar_item->foo_item = nullptr;
    }
}

int main()
{
    foo obj1;
    bar obj2;
    obj1.bar_item = &obj2;
    obj2.foo_item = &obj1;
}

o problema aqui é que eu também tenho que

1. exclua o construtor/atribuição de cópia e implemente o construtor/atribuição de movimento (muito clichê, espere pelo menos 5 membros por classe)
2. converta todos os objetos em shared_ptr e os objetos terão fraco_ptr entre si. (talvez nem sempre seja viável, pois posso não possuir a vida útil dos objetos, também me obriga a usar o heap)

existe alguma maneira de evitar isso? simplificá-lo? tem um wrapper RAII para um membro específico para evitar a implementação das operações de copiar/mover?

um exemplo simples que encontrei uma vez é um sistema gráfico onde preciso de uma linha para conectar duas esferas, a linha deve ter ponteiros para ambas as esferas e as esferas devem ter um ponteiro para a linha, todas elas pertencem à "cena" , mas perguntar a "cena" sobre eles requer uma longa pesquisa, os ponteiros evitam essa pesquisa.

Eu tenho um caso em que quero que o parâmetro de função padrão mude quando o tipo de entrada especificou certas características, por exemplo, um objeto pmr tem uma característica de alocador e uma get_allocatorfunção, então como faço isso? Eu apreciaria uma solução c++ 20 que não envolva SFINAE, a menos que seja impossível, talvez usando if constexpr ou conceitos, não quero escrever duas funções, a menos que seja impossível.

template<typename T>
void new_deleter(T* ptr)
{
    delete ptr;
}

template <typename T>
void pmr_deleter(T* ptr)
{
    ptr->get_allocator().delete_object(ptr);
}

template<typename T>
using deleter_t = void (*)(T*);

// use pmr_deleter by default when possible
template<typename T>
void delete_object(T* ptr, deleter_t<T> deleter = &new_deleter<T>)
{
    deleter(ptr);
}

Editar: graças à resposta descobri o seguinte padrão, que poderia ser facilmente adaptado aos conceitos e ao contexto.

template<typename T>
deleter_t get_default_deleter() {return &new_deleter<T>;}

template<typename T>
deleter_t get_default_deleter() 
requires requires (T* ptr) {ptr->get_allocator();}
{
 return &pmr_deleter<T>;
}

template<typename T>
void delete_object(T* ptr, deleter_t<T> deleter = get_default_deleter<T>())
{
    deleter(ptr);
}