Perguntas[c++](coding)

Sou novo em C++. Tenho um código parecido com este:

//static
absl::optional<bool> someFunc() {
    if(absl::getFlag(FLAG_is_real) < absl::now())
        // do something...
    return true;
}

//static
absl::optional<bool> someOtherFunc() {
    if(absl::getFlag(FLAG_is_real) > absl::now())
        // do something...
    return true;
}

Não quero chamar absl::getFlag()duas vezes, pois é caro. Mas também não poderia declará-lo como uma variável global, pois o tipo de valor do sinalizador é absl::Duratione não é trivialmente destrutível.

Qual é a melhor maneira de reutilizar o valor do sinalizador em ambos os métodos sem precisar chamar absl::getFlag()duas vezes?

Eu tenho um CreateBasePopulation do kernel CUDA onde eu uso printf para imprimir valores de struct dentro do kernel. No entanto, nenhuma saída está sendo impressa quando eu executo o kernel, aqui está o código relevante:

__global__ void CreateBasePopulation(Population* pop, int pop_num, int input_num, int output_num) {
    int idx = threadIdx.x + blockIdx.x * blockDim.x;

    if (idx >= pop_num) {
        return;
    }

    Network* net = &pop->Networks[idx];
    net->num_neurons = input_num + output_num;
    net->num_connections = input_num * output_num;
    net->fitness = 0.0f;

    curandState state;
    curand_init(clock64(), idx, 0, &state);

    for (int i = 0; i < output_num; ++i) {
        net->Neurons[i].type = 2;
        net->Neurons[i].bias = (2.0f * sqrtf((float)input_num) * curand_uniform(&state)) - sqrtf((float)input_num);
        net->Neurons[i].output = 0.0f;
        net->Neurons[i].input_sum = 0.0f;

        printf("%f\n", net->Neurons[i].bias);
    }

    for (int i = 0; i < input_num; ++i) {
        net->Neurons[i].type = 0;
        net->Neurons[i].bias = 0.0f;
        net->Neurons[i].output = 0.0f;
        net->Neurons[i].input_sum = 0.0f;

        for (int j = 0; j < output_num; ++j) {
            int offset = j + (output_num * i);

            net->Connections[offset].from = i;
            net->Connections[offset].to = j;
            net->Connections[offset].innovationid = offset;
            net->Connections[offset].enabled = true;
            net->Connections[offset].weight = (2.0f * curand_uniform(&state)) - 1.0f;

            printf("Weight [%d]: %f\n", offset, net->Connections[offset].weight);
        }
    }
}

Eu também tentei alocar memória assim;

    ....

    curandState state;
    curand_init(clock64(), idx, 0, &state);

    cudaMalloc((void**)&(net->Neurons), sizeof(Neuron) * net->num_neurons);
    cudaMalloc((void**)&(net->Connections), sizeof(Connection) * net->num_connections);

    ....

Mas não dá nenhuma saída (tentei copiar o dispositivo para o host e havia números muito grandes e muito pequenos, então parece que há um problema com o gerenciamento de memória)

Também função principal;

int main() {
    int population_size = 1024;
    int input_num = 10;
    int output_num = 5;

    Population* d_population;
    cudaMalloc(&d_population, sizeof(Population));

    Network* d_networks;
    cudaMalloc(&d_networks, sizeof(Network) * population_size);
    cudaMemcpy(&(d_population->Networks), &d_networks, sizeof(Network*), cudaMemcpyHostToDevice);

    int threadsPerBlock = 512;
    int blocks = (population_size + threadsPerBlock - 1) / threadsPerBlock;

    CreateBasePopulation<<<blocks, threadsPerBlock>>>(d_population, population_size, input_num, output_num);
    cudaDeviceSynchronize();

    std::cout << "Population created successfully!" << std::endl;

    cudaFree(d_networks);
    cudaFree(d_population);
    return 0;
}

Também estruturas;

struct Connection {
    int innovationid;
    int from; 
    int to; 
    float weight;     
    bool enabled;   
};

struct Neuron {
    int type;             //0 = input, 1 = hidden, 2 = output
    float input_sum;      // Sum of inputs into neuron
    float bias;
    float output;         // Activated output
};

struct Network {
    Connection* Connections;
    Neuron* Neurons;
    int num_connections;
    int num_neurons;
    float fitness;
};

struct Population {
    Network* Networks;
    int num_networks;
    int generation_id;
};

Estou tentando executar uma std::vectorredução de soma com uma declaração de redução OpenMP para ela:

// g++ -fopenmp MRE.cpp -o MRE
#include <vector>
#include <algorithm>
#include <omp.h>

struct Particles {
    std::vector<double> fx;
};

#pragma omp declare reduction(vec_double_plus : std::vector<double> : \
std::transform(omp_out.begin(), omp_out.end(), omp_in.begin(), omp_out.begin(), std::plus<double>()) \
) initializer(omp_priv = decltype(omp_orig)(omp_orig.size()))

int main() {
    Particles particles;
    
    // Initialize fx vector with 100 elements
    for (int i = 0; i < 100; ++i){
        particles.fx.push_back(0.0);
    }

    // Parallel region to set the values of fx
    #pragma omp parallel
    {
        // Thread-private local vector
        std::vector<double> thread_fx(particles.fx.size(), 0.0);

        #pragma omp for
        for (size_t i = 0; i < particles.fx.size(); ++i){
            thread_fx[i] = 1.0;  // Assign values to thread_fx
        }

        // Now we reduce thread_fx into particles.fx
        #pragma omp for reduction(vec_double_plus: particles.fx)
        for (size_t i = 0; i < particles.fx.size(); ++i) {
            particles.fx[i] += thread_fx[i];
        }
    }

    return 0;
}

...mas o compilador reclama da ausência de declaração de redução para minha estrutura, mesmo que eu esteja executando a operação em um std::vectortipo:

MRE.cpp: In function ‘int main()’:
MRE.cpp:31:57: error: expected ‘)’ before ‘.’ token
   31 |     #pragma omp for reduction(vec_double_plus: particles.fx)
      |                                                         ^
      |                                                         )
MRE.cpp:31:48: error: user defined reduction not found for ‘particles’
   31 |     #pragma omp for reduction(vec_double_plus: particles.fx)

Como declaro especificamente a cláusula de redução para um std::vectordentro de um struct?

Estou tentando entrar no Vulkan, mas estou tendo alguns problemas. Meu aplicativo ( repositório GitHub ) deve renderizar um triângulo vermelho no centro da tela. No entanto, cada vez que o executo, obtenho um de cinco resultados diferentes em vez da saída esperada.

Parece que há vários erros de camada de validação relacionados à criação do pipeline. Suspeito que essa seja a causa raiz, mas não tenho certeza por onde começar.

Estou usando 6.13.6-arch1-1. Minha placa de vídeo é Intel Corporation TigerLake-LP GT2 [Iris Xe Graphics]. É uma placa de vídeo integrada.

O erro definitivamente acontece aqui:

void App::drawFrame()
{
    uint32_t imageIndex;
    auto result = tveSwapChain.acquireNextImage(&imageIndex);

    if(result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR)
    {
        throw std::runtime_error("Failed to acquire swap chain image");
    }

    result = tveSwapChain.submitCommandBuffers(&commandBuffers[imageIndex], &imageIndex);
    if(result != VK_SUCCESS)
    {
        throw std::runtime_error("Failed to present swap chain image");
    }
}

Ou aqui:

void TvePipeline::createGraphicsPipeline(const TveDevice &device, const std::string &vertFilepath,
                                         const std::string &fragFilepath, const PipelineConfigInfo &configInfo)
{
    assert(configInfo.pipelineLayout != VK_NULL_HANDLE &&
           "Cannot create graphics pipeline: no pipelineLayout provided in configInfo.");
    assert(configInfo.renderPass != VK_NULL_HANDLE &&
           "Cannot create graphics pipeline: no renderPass provided in configInfo.");

    auto vertCode = readFile(vertFilepath);
    auto fragCode = readFile(fragFilepath);

    createShaderModule(vertCode, &vertShaderModule);
    createShaderModule(fragCode, &fragShaderModule);

    VkPipelineShaderStageCreateInfo shaderStages[2];
    shaderStages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
    shaderStages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
    shaderStages[0].module = vertShaderModule;
    shaderStages[0].pName = "main";
    shaderStages[0].flags = 0;
    shaderStages[0].pNext = nullptr;
    shaderStages[0].pSpecializationInfo = nullptr;

    shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
    shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
    shaderStages[1].module = fragShaderModule;
    shaderStages[1].pName = "main";
    shaderStages[1].flags = 0;
    shaderStages[1].pNext = nullptr;
    shaderStages[1].pSpecializationInfo = nullptr;

    VkPipelineVertexInputStateCreateInfo vertexInputInfo{};
    vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
    vertexInputInfo.vertexAttributeDescriptionCount = 0;
    vertexInputInfo.vertexBindingDescriptionCount = 0;

    vertexInputInfo.pVertexAttributeDescriptions = nullptr;
    vertexInputInfo.pVertexBindingDescriptions = nullptr;

    VkPipelineViewportStateCreateInfo viewportInfo{};
    viewportInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
    viewportInfo.viewportCount = 1;
    viewportInfo.pViewports = &configInfo.viewport;
    viewportInfo.scissorCount = 1;
    viewportInfo.pScissors = &configInfo.scissor;

    VkGraphicsPipelineCreateInfo pipelineInfo;
    pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
    pipelineInfo.stageCount = 2;
    pipelineInfo.pStages = shaderStages;
    pipelineInfo.pVertexInputState = &vertexInputInfo;
    pipelineInfo.pInputAssemblyState = &configInfo.inputAssemblyInfo;
    pipelineInfo.pViewportState = &viewportInfo;
    pipelineInfo.pRasterizationState = &configInfo.rasterizationInfo;
    pipelineInfo.pMultisampleState = &configInfo.multisampleInfo;

    pipelineInfo.pColorBlendState = &configInfo.colorBlendInfo;
    pipelineInfo.pDepthStencilState = &configInfo.depthStencilInfo;
    pipelineInfo.pDynamicState = nullptr;

    pipelineInfo.layout = configInfo.pipelineLayout;
    pipelineInfo.renderPass = configInfo.renderPass;
    pipelineInfo.subpass = configInfo.subpass;

    pipelineInfo.basePipelineIndex = -1;
    pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;

    if (vkCreateGraphicsPipelines(tveDevice.device(), VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &graphicsPipeline) !=
        VK_SUCCESS)
    {
        throw std::runtime_error("Failed to create graphics pipeline");
    }
}

Estou encontrando uma diferença inesperada no comportamento entre o SFINAE tradicional (usando type_traitsand std::void_t) e os conceitos modernos do C++20 ao definir um fallback genérico operator<<. O propósito é direto: criar um genérico operator<<que seja habilitado somente se nenhuma definição personalizada existente operator<<for encontrada via Argument-Dependent Lookup (ADL) .

A detecção baseada em SFINAE da velha escola usando características ( is_std_streamable) funciona como esperado, definido como:

template <class T, class = void>
struct is_std_streamable : std::false_type {};

template <class T>
struct is_std_streamable<T, std::void_t<decltype(std::declval<std::ostream&>() << std::declval<const T&>())>> : std::true_type {};

E a detecção baseada em conceitosStdStreamable ( ) é definida como:

template <class T>
concept StdStreamable = requires(const T t, std::ostream& os) {
    { os << t } -> std::same_as<std::ostream&>;
};

O fallback genérico operator<<se parece com isto ( requirescláusulas comentadas):

template <StdPrintable T>
// requires(!StdStreamable<T>)
// requires(!is_std_streamable<T>::value)
std::enable_if_t<!is_std_streamable<T>::value, std::ostream&>
operator<<(std::ostream& os, T const& val) {
...
}

Ao descomentar a cláusula baseada em conceitos ( ou ), tanto o GCC quanto o Clang produzem o seguinte erro de restrição cíclica:requiresrequires(!StdStreamable<T>)requires(!is_std_streamable<T>::value)

error: satisfaction of constraint 'StdStreamable<T>' depends on itself

Entendo que usar a std::declval<std::ostream&>() << std::declval<const T&>()expressão em uma requirescláusula ao definir uma nova versão de operator<<pode ser interpretado pelo compilador como uma dependência cíclica. Mas por que os conceitos do C++20 acionam esse problema de restrição cíclica, enquanto o SFINAE tradicional não? Esse comportamento é obrigatório pelo padrão, uma limitação conhecida de conceitos ou potencialmente um bug do compilador?

Exemplo mínimo reproduzível completo e detalhes adicionais:

• https://godbolt.org/z/be7Yqxo93

Desde já, obrigado.

(talvez o título já se enquadre no problema XY...)

Dada esta função modelada:

template <typename T, typename U, typename V, typename W>
void MyFunc()
{
    // stuff...
}

Gostaria de chamá-lo para todas as combinações dadas de tipos. Por exemplo, gostaria de chamar para:

• T: char, int, longo longo
• U: flutuar, duplo
• V: std::uint64_t, std::string_view
• W: int, MeuEnum1, MeuEnum2, MeuEnum3

Em pseudocódigo, ficaria assim:

foreach (t in { char, int, long long })
{
    foreach (u in { float, double })
    {
        foreach (v in { std::uint64_t, std::string_view })
        {
            foreach (w in { int, MyEnum1, MyEnum2, MyEnum3 })
            {
                MyFunc<t, u, v, w>();
            }
        }
    }
}

Como posso conseguir isso?

Acredito que truques/padrões de modelos variáveis, como tuplas ou "listas de tipos", são o caminho a seguir, mas não consegui resolvê-los.

Tenho as duas funções a seguir, mas sempre recebo este erro do compilador:

deduziu tipos conflitantes para o parâmetro 'T'

Imagino que o problema é que Tse refere a um array e intao mesmo tempo, mas como eu poderia resolver esse problema? Se bem me lembro, já vi algo parecido sendo feito com a adição de mais algum código à templateparte, mas não consegui encontrar isso agora.

template<typename T>
int binSearch(const T& A, int u, int v, T x) {
    if (u > v) return 0;
    int m = (u + v) / 2;

    if(A[m] > x) return binSearch(A, u, m-1, x);
    if(A[m] < x) return binSearch(A, m+1, v, x);
    else return m;
}

template<typename T>
int logSearch(const T& A, T x) {
    return binSearch(A, 0, sizeof(A) / sizeof(A[0]), x);
}

exemplo de como quero usar esta função:

#include <iostream>

#include "..\binSearch.hh"

int main() {
    int asd[] = {0,1,2,3,4,5,6,7,8,9};

    std::cout << logSearch(asd, 3);

    return 0;
}

Ao compilar este arquivo com g++, recebo o seguinte:

g++ .\Algorithms\tests\example.cpp
.\Algorithms\tests\example.cpp: In function 'int main()':
.\Algorithms\tests\example.cpp:8:27: error: no matching function for call to 'logSearch(int [10], int)'
    8 |     std::cout << logSearch(asd, 3);
      |                  ~~~~~~~~~^~~~~~~~
In file included from .\Algorithms\tests\example.cpp:3:
.\Algorithms\tests\..\binSearch.hh:15:5: note: candidate: 'template<class T> int logSearch(const T&, T)'
   15 | int logSearch(const T& A, T x) {
      |     ^~~~~~~~~
.\Algorithms\tests\..\binSearch.hh:15:5: note:   template argument deduction/substitution failed:
.\Algorithms\tests\example.cpp:8:27: note:   deduced conflicting types for parameter 'T' ('int [10]' and 'int')
    8 |     std::cout << logSearch(asd, 3);
      |                  ~~~~~~~~~^~~~~~~~

O código a seguir tem a intenção de ter um loop infinito sem terminação e sem saída. Compilando com MSVC 2022 e GCC 14 e flag -O2 obtive o mesmo comportamento errado (saída é produzida).

// main.cpp
#include <test.h>

int main()
{
    Test t;
    t.test();
    return 0;
}

// test.h
#pragma once

class Test
{
public:
    void test();

private:
    int m_i = 0;
};

// test.cpp
#include "test.h"

#include <iostream>

void Test::test()
{
    while (true) {
        if (m_i > 100) {
            std::cout << "m_i is " << m_i << std::endl;
            return;
        }
    }
}

a saída é a seguinte

m_i is 0

substituindo a função de teste pelo seguinte

void Test::test()
{
    while (true) {
        if (int i = m_i; i == 100) {
            std::cout << "m_i is " << m_i << std::endl;
            std::cout << "i is " << i << std::endl;
            return;
        }
    }
}

a saída no GCC é a seguinte

m_i is 0
i is 100

Depurando o código, ambos parecem bugs de otimização. Há alguma referência útil e regras para manter em consideração para evitar problemas semelhantes com antecedência? Eu encontrei esse problema depurando uma corrupção de memória substituindo e removendo código, e fui enganado por um tempo.

Referência https://man7.org/linux/man-pages/man2/getrandom.2.html

Oi,

Parece-me que deve ser thread-safe, mas não consegui encontrar nenhuma documentação oficial falando sobre isso.

getrandom() em sys/random.h é sempre e necessariamente thread-safe?

Obrigado.

usando o seguinte código

template <typename T>
concept SomeConcept = requires(T t) {
    { t++ } -> std::convertible_to<T>;
};

O conceito SomeConceptgarante que o tipo Ttenha sobrecarregado o operator++(int)e o tipo de resultado seja conversível para T. E std::convertible_to recebe 2 parâmetros, o primeiro é From, e o segundo é To.

Então minha pergunta é: qual parâmetro recebe o resultado da expressão e por quê? E com essa resposta, por que ele Té passado como o outro parâmetro e não o contrário?

Por favor, forneça uma referência adequada para respaldar a resposta, de preferência do rascunho padrão, se possível.

desde já, obrigado