quantos núcleos devo utilizar para cálculos? #cores ou #cores -1?

Eu tenho um grande cálculo para fazer. Embora eu possa utilizar todos os núcleos, pensei que há alguma razão para deixar de fora um núcleo e não utilizá-lo? (cpu de cálculo apenas sem IO). Ou estou subestimando o sistema operacional que ele não saberia manipular e fazer a alternância de contexto adequada, mesmo que eu utilize todos os núcleos?

Os principais sistemas operacionais são maduros o suficiente para saber como lidar com processos que usam todos os núcleos disponíveis. Outros processos podem (e geralmente serão) afetados, mas a computação não se tornará mais lenta porque você usou todos os núcleos disponíveis.

A escolha do número de núcleos depende mais da sua intenção de fazer outra coisa enquanto o cálculo está sendo realizado.

Se, em uma máquina desktop, você quiser usar o navegador da Web ou assistir a um vídeo enquanto o cálculo estiver sendo feito, é melhor manter um núcleo livre para isso. Da mesma forma, se o servidor estiver fazendo duas coisas (como fazer cálculos e, ao mesmo tempo, processar e relatar suas métricas), manter um núcleo livre para a tarefa paralela pode ser uma boa idéia.

Por outro lado, se sua prioridade é tornar o cálculo o mais rápido possível, é necessário usar todos os núcleos.

Depende.

Se a máquina é dedicada a esse cálculo, você deve usar todos os núcleos - os recursos de computação não utilizados não aceleram as coisas .

Se você estiver usando um agendador em tempo real, um agendador não preventivo ou afinidade de processador, tenha um pouco mais de cuidado, pois é fácil privar acidentalmente outros processos de todos os recursos de computação. No entanto, você precisaria alterar manualmente essas configurações para que algo desse errado; portanto, por padrão, não há problema aqui na maioria dos sistemas operacionais.

Se a máquina não for dedicada ao cálculo, fornecer 100% ao cálculo pode não ser o ideal. Por exemplo, se você estiver usando um navegador da Web enquanto o cálculo estiver em execução. Como a carga da sua máquina ocasionalmente atinge um pico acima de 100%, ela fica lenta. Tarefas orientadas à taxa de transferência, como a computação, não serão realmente mais lentas, mas tarefas sensíveis à latência, como GUIs, não reagirão tão rapidamente. É sensato iniciar apenas threads / processos NPROC-1 para o cálculo. Como alternativa, o uso explícito de uma prioridade mais baixa para a computação do que para tarefas normais pode resolver esse problema; nesse caso, a computação deve usar processos NPROC para não desperdiçar recursos.

Sou um pouco cauteloso em concordar com @motoDrizzt, abaixo, devido aos votos negativos :), mas essa foi realmente a minha experiência real - mais é melhor, mesmo além do número real de núcleos (mas não milhares). Por exemplo, dê uma olhada em http://www.forkosh.com/images/avoronoi.gif, onde cada plano 2D desse voronoi_diagrama 3D pode ser gerado independentemente. E o programa usa um atributo nfork = n query_string para realizar os cálculos para n planos "simultaneamente".

Com um processador de quatro núcleos, o tempo (de usuário) para concluir o diagrama diminui bastante linearmente com o nfork, até cerca de nfork = 8 (quatro núcleos com hyperthread). Mas além dos 8, o tempo ainda diminui, embora mais lentamente. E além dos 16 anos, mais ou menos, nenhuma melhoria perceptível. Não analisei esse comportamento, mas atribuí-lo ingenuamente aos processos de malabarismo os (linux slackware 14.2x64 neste caso) para reduzir ainda mais o tempo ocioso geral.

A melhor escolha depende do sistema. Portanto, o que você deseja fazer é executar as duas versões em um sistema real e, em seguida, verificar como o sistema responde. Você ainda pode usar navegador, editor de texto, outras coisas no seu sistema? E o desempenho é melhor ao usar n threads e não n-1? O que acontece se você executar o aplicativo em conjunto com outro aplicativo que tente usar todas as CPUs?

E então você precisa considerar o hyperthreading. Com quatro núcleos mais hyperthreading, você pode usar 8 núcleos ou 7 núcleos. Mais uma vez, tente a capacidade de resposta do sistema e a hora de terminar.

E, finalmente, considere dividir seu trabalho em mais blocos do que threads. O motivo é que diferentes threads concluirão o trabalho em momentos diferentes e, então, você deseja que algum trabalho seja entregue aos threads mais rápidos. Caso contrário, você terá que esperar até que o último encadeamento seja concluído.

PS. "Hyperthreading não pode ajudar com código intensivo de FPU porque existe apenas um FPU". Absolutamente errado. É incrivelmente difícil, mesmo com código intensivo de FPU, fazer pleno uso da FPU devido a latências. O Hyperthreading ajuda porque há duas vezes mais operações independentes disponíveis para agendamento.

Eu não sei escrever isso de uma maneira que não pareça "ruim", então é só uma observação amigável, ok?

Dado que um PC comum já possui normalmente milhares ou mais threads, o que faz você pensar que usar 8 x 7 fará alguma diferença? :-)

Use o maior número possível de threads. E se você não precisa se preocupar com a resposta do sistema operacional, e seus threads funcionam por um longo tempo (mais de um segundo), você pode experimentar usar o dobro do número de núcleos.