Você está na página 1de 6

Trabalhando Com o OpenFOAM em modo Parallelo

- O mtodo de processamento paralelo utilizado por OpenFOAM conhecido como


domnio decomposio, em que a geometria e campos associados so divididos em
peas e alocados para processadores separados para a soluo.
- O primeiro passo decompor o domnio usando o utilitrio decomposePar.
- O usurio deve editar o dicionrio associado decomposePar nomeado
decomposeParDict, que est localizado no diretrio de sistema do caso.

- A primeira entrada numberOfSubdomains que especifica o nmero de sub-domnios
em que o processo ser decomposto, que corresponde normalmente o nmero de
processadores disponveis para o caso.

- A corrida paralela usa a implementao openMPI domnio pblico do Message
Passing Interface standard (MPI).

- O processo de computao paralela envolve: decomposio de malha e campos;
execuo do aplicativo em paralelo; e, ps-processamento do caso decomposto.

- Vamos usar o caso pitzDaily para o tutorial aplicao simpleFoam:

tut
cd incompressible
cd simpleFoam
cd pitzDaily

- Podemos copiar o caso pitzDaily ao pitzDailyParallel:

mkdir pitzDailyParallel
cp -r pitzDaily/{0, system, constant} pitzDailyParallel

- E copiar para o diretrio do sistema do arquivo decomposeParDict disponvel no caso
pitzdailtExptInlet:

cp pitzDailyExptInlet/system/decomposeParDict pitzDailyParallel/system

Correndo em paralelo: domnio decomposio

- A malha e os campos so decompostos usando o utilitrio decomposePar.

- O objetivo subjacente romper o domnio com um esforo mnimo, mas de tal
maneira para garantir uma soluo bastante econmica.

- A geometria e os campos so divididos de acordo com um conjunto de parmetros
especificados num dicionrio chamado decomposeParDict que deve estar localizado no
sistema diretrio do caso de interesse.

- No arquivo decomposeParDict o usurio deve definir o nmero de domnios que
o caso deve ser decomposto em: geralmente, corresponde ao nmero de ncleos
disponveis para o clculo:

numberOfSubdomains 2;

- O usurio tem a opo de quatro mtodos de decomposio, especificado pelo mtodo
palavra-chave.

- Para cada mtodo, h um conjunto de coeficientes especificados em uma sub-
dicionrio de decompositionDict, chamado <method> coeffs, usados para instruir a
decomposio processo:

method simple/hierarchical/scotch/manual;

- simples: decomposio geomtrica simples, em que o domnio dividido em partes
por direo, por exemplo, 2 peas na direo x, 1 em y etc.

- hierrquica: decomposio geomtrica hierrquica, que o mesmo que simples
excepto o usurio especifica a ordem na qual a diviso direcional feito, por exemplo,
em primeiro lugar na direo y, ento a direo x etc.

- scotch: scotch decomposio, que no requer nenhuma entrada geomtrica do usurio
e as tentativas para minimizar o nmero de fronteiras de processador. O usurio pode
especificar uma ponderao para a decomposio entre os processadores que podem ser
teis em mquinas com comportamentos diferentes entre os processadores.

- manual: decomposio manual, onde o usurio especifica diretamente a alocao de
cada clula de um determinado processador.

- O coeficiente de sub-dicionrio para o mtodo simples so definidos da seguinte
forma:

simpleCoeffs
{
n (2 1 1);
delta 0.001;
}

Onde n o nmero de sub-domnios no x, y, Z (nx ny nz) e delta o factor de
inclinao da clula, normalmente 10-3.

- O coeficiente de sub-dicionrio para o mtodo hierrquico so definidas da seguinte
forma:

hierarchicalCoeffs
{
n (2 2 1);
delta 0.001;
order xyz;
}

Onde n o nmero de sub-domnios em x, y, z direes, delta a clula
fator e ordem de inclinao a ordem de decomposio xyz / xzy / YXZ ...
- O coeficiente de sub-dicionrio para o mtodo metis so definidos da seguinte forma:

metisCoeffs
{
processorWeights
(
1
...
1
);
}

a lista de fatores de ponderao para a alocao de clulas para processadores: <wt1>
o fator de ponderao para o processador 1, etc.

- O coeficiente de sub-dicionrio para o mtodo manual contm a referncia a um
arquivo:

manualCoeffs
{
dataFile "<fileName>";
}

o nome do arquivo que contm os dados de alocao de clulas para processadores.

- Os arquivos de dados pode necessitar de ser distribudo se apenas discos locais so
utilizados de modo a melhorar o desempenho.

- O caminho raiz para o diretrio caso pode variar entre as mquinas. Os caminhos
devem em seguida, ser especificado no dicionrio decomposeParDict usando distribudo
e palavras-chave razes.

- A entrada distribudo deve ler:

distributed yes

e a entrada razes uma lista de caminhos de raiz, <root0>, <root1>,. . . , Para cada n:

roots
<nRoots>
(
"<root0>"
"<root1>"
...
);

onde <nRoots> o nmero de razes.

- Cada um dos diretrios processorN deve ser colocado no diretrio em cada caso dos
caminhos raiz especificado no dicionrio decomposeParDict.
- O utilitrio decomposePar executada da maneira normal, digitando:

decomposePar -case [caseName]

- A sada ser algo como:

Calculating distribution of cells
Selecting decompositionMethod metis
...
Processor 0
Number of cells = 6113
Number of faces shared with processor 1 = 58
Number of processor patches = 1
Number of processor faces = 58
Number of boundary faces = 12514
Processor 1
Number of cells = 6112
Number of faces shared with processor 0 = 58
Number of processor patches = 1
Number of processor faces = 58
Number of boundary faces = 12496

- Em concluso, um conjunto de subdirectrios foram criados, um para cada
processador, no diretrio do caso.

- As pastas so nomeados processorN em que N = 0, 1, ... representa um processador
nmero e contm um directrio vez, contm o campo decomposto descries, e um
diretrio constant/polymesh contendo o decomposto malha descrio.

pitzDailyParallel
|------> 0
|------> constant
|------> processor0
|------> processor1
|------> system

- openMPI pode ser executado em uma mquina multiprocessador local, muito simples,
mas quando executado em mquinas atravs de uma rede, um arquivo deve ser criado
que contm os nomes de host das mquinas. O arquivo pode ter qualquer nome e
localizado em qualquer caminho.


Correndo em paralelo: execuo


- Um aplicativo executado em paralelo com o comando mpirun:

mpirun --hostfile <machines> -np <nProcs> <foamExec>
<root> <case> <otherArgs> -parallel > log

onde: <nProcs> o nmero de processadores; <foamExec> o executvel, por exemplo
simpleFoam; e, a sada redirecionada para um arquivo de log chamado.

- O arquivo <machines> contm os nomes das mquinas listadas, uma mquina por
linha.

- Os nomes devem corresponder a um nome de host totalmente resolvidos no
arquivo/etc/hosts de da mquina em que o openMPI executado. O arquivo
<machines> conteria:

hostname1
hostname2 cpu=2
hostname3

No nosso caso, torna-se:

decomposePar
mpirun -np 4 simpleFoam -case pitzDailyParallell -parallel > log
mpirun -np 4 simpleFoam -case pitzDailyParallell -parallel

Correndo em paralelo: o ps-processamento


Quando os casos de ps-processamento que foram executados em paralelo o usurio
tem duas opes:

- reconstruo dos dados de malha e de campo para recriar o domnio completo e
campos, que podem ser ps-processados como normal;

- ps-processamento de cada segmento do domnio decomposto individualmente;

- Depois de um caso tenha sido executado em paralelo, ele pode ser reconstrudo para
ps-processamento fundindo os conjuntos de diretrios de tempo de cada diretrio
processorN em um um nico conjunto de diretrios de tempo.

- A utilidade reconstructPar executa um tal reconstruo executando o
comando:

reconstructPar -case [case]

- No nosso caso, torna-se:

reconstructPar -case pitzDailyParallel
Time = 0
Reconstructing FV fields
Reconstructing volScalarFields
p
.....
Reconstructing volVectorFields
U
Reconstructing volTensorFields
R
No point fields
No lagrangian fields