Início / coding / Perguntas / 78090706
Accepted
Damir Tenishev
Asked: 2024-03-02 06:11:10 +0800 CST

Qual é a abordagem para lidar com membros de classe opcionais?

  • 772

Processando grandes quantidades de dados (gigabytes) uso índices para matrizes de dados. Como o acesso aos dados pode levar à ineficiência do cache, quero armazenar em cache alguns dados do array junto com o índice, o que proporciona uma aceleração drástica para operações por meio de índices.

A quantidade de dados armazenados em cache é uma escolha em tempo de compilação que deve incluir quantidade zero de dados em cache. Tenho uma grande quantidade de índices, então neste caso não quero pagar por elementos “vazios” extras como std::arrayacontece, por exemplo.

Então, fiz um template com especialização:

using index_t = unsigned int;
using lexem_t = unsigned int;

template <std::size_t t_arg_cache_line_size>
struct lexem_index_with_cache_t {
    index_t index;
    std::array<lexem_t, t_arg_cache_line_size> cache_line;

    constexpr std::size_t cache_line_size() const {
        return t_arg_cache_line_size;
    }
};

template<>
struct lexem_index_with_cache_t<0> {
    index_t index;
    static std::array<lexem_t, 0> cache_line;

    constexpr std::size_t cache_line_size() const {
        return 0;
    }
};

std::array<lexem_t, 0> lexem_index_with_cache_t<0>::cache_line;

O problema é esse “hack” que usei na especialização com tamanho zero que utiliza membro estático para dar acesso formal ao cache_linewhile está vazio e o acesso não é realmente necessário. Isso me permite evitar especializações em funções que utilizam este modelo, como aqui:

using lexem_index_with_cache = lexem_index_with_cache_t<0>;

template <typename T>
class seq_forward_comparator_cached
{
    const std::vector<T>& vec;
public:
    seq_forward_comparator_cached(const std::vector<T>& vec) : vec(vec) { }

    bool operator() (const lexem_index_with_cache& idx1, const lexem_index_with_cache& idx2)
    {
        if (idx1.index == idx2.index) {
            return false;
        }

        const auto it1_cache_line = idx1.cache_line;  // This code wouldn’t compile in absence of static “hack”
        const auto it2_cache_line = idx2.cache_line;  // This code wouldn’t compile in absence of static “hack”

        auto res = std::lexicographical_compare_three_way(
            it1_cache_line.begin(), it1_cache_line.end(),
            it2_cache_line.begin(), it2_cache_line.end());

        if (res == std::strong_ordering::equal) {
            auto range1 = std::ranges::subrange(vec.begin() + idx1.index + idx1.cache_line_size(), vec.end());
            auto range2 = std::ranges::subrange(vec.begin() + idx2.index + idx2.cache_line_size(), vec.end());

            return std::ranges::lexicographical_compare(range1, range2);
        }

        return res == std::strong_ordering::less;
    }
};

Claro, posso implementar outra especialização de modelo deste modelo para cache de tamanho zero, mas isso levará à duplicação de código e tenho muitas dessas funções, então não quero especializar todas elas.

staticPor outro lado, qual é a maneira adequada no C++ moderno de evitar esse hack e possível duplicação de código?

Não tenho certeza, talvez algum tipo de código condicional incluído dependendo do tipo possa ajudar.

Eu gostaria de evitar o acesso a cache_lineuma função, mas se esse for o único caso, dê uma pista sobre a abordagem.

O código compilável está aqui .

c++

1 respostas

  1. Best Answer

    Adicionei um exemplo com um truque para usar o if constexpr(...)código que não é de modelo.

    Agora é impossível usar a at()função acidentalmente, ao contrário da solução de membro estático.

    #include <array>

using data_type = int;

template<size_t _data_size>
class ExtendableIndex
{
public:
    constexpr static size_t data_size = _data_size;

    data_type& at(size_t idx) { return data[idx]; }

    size_t index;
    std::array<data_type, _data_size> data;
};

template<>
class ExtendableIndex<0>
{
public:
    constexpr static size_t data_size = 0;

    data_type& at(size_t idx);

    size_t index;
};

using DefaultIndex = ExtendableIndex<0>;

class DataUser
{
public:

    void process(DefaultIndex& index)
    {
        if constexpr (DefaultIndex::data_size > 0)
        {
            // auto value = index.data[0]; // -> this fails to compile
            auto value = index.at(0); // -> but this slight workaround solves the issue, `at()` is not implemented and thats OK.
        }
    }

    template<size_t _data_size>
    void process_template(ExtendableIndex<_data_size>& index)
    {
        if constexpr (DefaultIndex::data_size > 0)
        {
            auto value = index.data[0]; // -> this compiles even if index.data doesn't exist when 'process' is a template
        }
    }

};

int main()
{
    DataUser r;
    ExtendableIndex<0> index_zero;

    r.process(index_zero);
    r.process_template(index_zero);

    ExtendableIndex<1> index_one;
    r.process_template(index_one);
}
    • 1

relate perguntas