Como executar loops de um laço FOR em multiplos processadores em C++?

[Darcamo]

Tenho um programa em C++ com a seguinte estrutura

Código: [Selecionar]

Inicia laço FOR externo (poucas repetições podendo variar entre 1 a +- 15 repetições)
     Inicia Laço FOR interno (muitas repetições)
          processamento
     Termina laço interno
Termina laço externo
Cada loop do laço externo é independente dos demais.
Gostaria de saber como rodar o laço interno em diferentes processos para aproveitar mais de um processador e no final passar só o resultado do processamento.

Já mexi um pouco com theads faz tempo e eu poderia me virar se fossem threads, mas agora preciso que sejam múltiplos processos com passagem de informação entre os processos para acumular os resultados após o término do laço FOR externo.

Que funções/bibliotecas devo usar?
Alguma oritentação para deixar minhas pesquisas no google mais focadas já seria suficiente, mas uma classe para isso seria melhor ainda. 

[yzarc]

em java eu faria um mult thread, em c++ não sei como se faz mult thread

[kunigas]

Olá,

Eu não sei muito sobre computação paralela, mas acho que você poderia procurar por esse tópico:
MPI - Message Passing Interface

[Darcamo]

Não acho que preciso ir muito a fundo com a computação paralela, apenas o mais simples: de executar os laços (independentes) de um for.
Vou procurar sobre MPI.
Veleu

[fpissarra]

O gcc 4.2.x suporta OMP, mas recomendo mesmo que você dê uma olhada em pthreads.

Não há garantias de que suas threads serão espalhadas uniformemente pelos processadores/cores. Isso depende do scheduler do sistema operacional... A técnica para garantir esse comportamente pode ser dependente de arquitetura.

Ainda: Pelo que eu saiba, a Intel e a AMD não documentam muito bem a distribuição de threads pelos cores em CPU multicore.

[]s
Fred

[Darcamo]

O problema é que preciso que sejam múltiplos processos e não múltiplas threads.
É para rodar em um cluster com vários nós, cada nó com dois processadores. Se forem múltiplos processos o programa que gerencia o cluster pode alocar cada processo em um processador, mas múltiplas threads não (acho que elas ainda seria alocadas entre dois cores de um processador dual core, mas não mais que isso).

Atualmente simplesmente quebramos o programa em vários e submetemos cada um individualmente para o cluster, mas se pudesse ser um programa só que criasse múltiplos processos deixaria as coisas mais organizadas e facilitaria reunir todos os dados depois reduzindo o trabalho.

A minha idéia, se não fosse complicado demais, seria criar um processo para cada repetição do loop externo (que são independentes) e possivelmente um processo central com o qual cada um dos outros se comunicaria para passar os dados depois de terminarem. Como os loops são independentes achei que seria o caso mais simples de um "programa com múltiplos processos" e isso pudesse ser feito sem grandes complicações.

Mas pelo que encontrei a coisa não é tão simples assim. Parece que é necessário usar até pragmas do compilador para fazer isso e me pergunto se isso traria mais prejuízo (chance de bugs esquisitos) do que benefícios. É, múltiplas threads é mais fácil mesmo (menos complicado).

Se alguém já tiver mexido com isso eu gostaria de saber se vale a pena e qual a maneira "mais padrão" de se fazer isso (já que no meu entendimento pragmas são específicos de cada compilador).

[yzarc]

de uma olhada na system call "fork"