Eu tenho um programa C ++ em execução no Linux em que um novo thread é criado para fazer algum trabalho computacionalmente caro independente do thread principal (O trabalho computacional é concluído gravando os resultados em arquivos, que acabam sendo muito grandes). No entanto, estou obtendo um desempenho relativamente ruim.

Se eu implementar o programa diretamente (sem introduzir outros threads), ele conclui a tarefa em aproximadamente duas horas. Com o programa multi-thread leva cerca de 12 horas para fazer a mesma tarefa (isso foi testado com apenas um segmento gerado).

Eu tentei algumas coisas, incluindopthread_setaffinity_np para definir o segmento para uma única CPU (dos 24 disponíveis no servidor que estou usando), bem comopthread_setschedparam para definir a política de agendamento (eu tentei apenas SCHED_BATCH). Mas os efeitos destes têm sido até agora insignificantes.

Há alguma causa geral para esse tipo de problema?

EDIT: Eu adicionei alguns exemplos de código que estou usando, que é esperançosamente as partes mais relevantes. A função process_job () é o que realmente faz o trabalho computacional, mas seria demais incluir aqui. Basicamente, ele lê dois arquivos de dados e os usa para executar consultas em um banco de dados de gráficos na memória, no qual os resultados são gravados em dois arquivos grandes em um período de horas.

EDITAR parte 2: Só para esclarecer, o problema não é que eu queira usar threads para aumentar o desempenho de um algoritmo que tenho. Mas, em vez disso, quero executar muitas instâncias do meu algoritmo simultaneamente. Portanto, espero que o algoritmo seja executado em uma velocidade semelhante quando colocado em um thread, como seria se eu não usasse multi-threads.

EDITAR parte 3: Obrigado pelas sugestões todos. Atualmente estou fazendo alguns testes de unidade (ver quais partes estão abrandando), como alguns sugeriram. Como o programa demora um pouco para carregar e executar, está demorando para ver os resultados dos testes e, portanto, peço desculpas por respostas tardias. Eu acho que o ponto principal que eu queria esclarecer é possíveis razões pelas quais o threading poderia fazer com que um programa rodasse lentamente. Pelo que eu recebi dos comentários, simplesmente não deveria ser. Vou postar quando puder encontrar uma resolução razoável, obrigado novamente.

(FINAL) EDITAR parte 4: Acontece que o problema não estava relacionado à segmentação, afinal. Descrevê-lo seria muito complicado neste momento (incluindo o uso de níveis de otimização do compilador), mas as idéias postadas aqui foram muito úteis e apreciadas.

struct sched_param sched_param = {
    sched_get_priority_min(SCHED_BATCH)
};

int set_thread_to_core(const long tid, const int &core_id) {
   cpu_set_t mask;
   CPU_ZERO(&mask);
   CPU_SET(core_id, &mask);
   return pthread_setaffinity_np(tid, sizeof(mask), &mask);
}

void *worker_thread(void *arg) {
   job_data *temp = (job_data *)arg;  // get the information for the task passed in
   ...
   long tid = pthread_self();
   int set_thread = set_thread_to_core(tid, slot_id);  // assume slot_id is 1 (it is in the test case I run)
   sched_get_priority_min(SCHED_BATCH);
   pthread_setschedparam(tid, SCHED_BATCH, &sched_param);
   int success = process_job(...);  // this is where all the work actually happens
   pthread_exit(NULL);
}

int main(int argc, char* argv[]) {
   ...
   pthread_t temp;
   pthread_create(&temp, NULL, worker_thread, (void *) &jobs[i]);  // jobs is a vector of a class type containing information for the task
   ...
   return 0;
}