TCC Libre

PONTIFCIA UNIVERSIDADE CATLICA DE GOIS
DEPARTAMENTO DE COMPUTAO
CINCIA DA COMPUTAO
PROGRAMAO PARALELA CUDA PARA SIMULAO

DE MODELOS EPIDEMIOLGICOS BASEADOS EM
INDIVDUOS
LAURO CSSIO MARTINS DE PAULA
GOINIA
2012
PONTIFCIA UNIVERSIDADE CATLICA DE GOIS

DEPARTAMENTO DE COMPUTAO
CINCIA DA COMPUTAO
PROGRAMAO PARALELA CUDA PARA SIMULAO DE MODELOS

EPIDEMIOLGICOS BASEADOS EM INDIVDUOS
Trabalho de Concluso de Curso apresentado por Lauro Cssio

Martins de Paula Pontifcia Universidade Catlica de Gois PUC Gois, como requisito parcial para obteno do ttulo de
Bacharel em Cincia da Computao, aprovado em 29/06/2012
pela banca examinadora:.
Professor Clarimar Jos Coelho, Dr. PUC Gois - Orientador
Arlindo Rodrigues Galvo Filho, M.Sc. ITA - Co-orientador
Daniel Vitor de Lucena, Esp.
Wagner Oliveira de Arajo, M.Sc.
PROGRAMAO PARALELA CUDA PARA SIMULAO DE MODELOS

EPIDEMIOLGICOS BASEADOS EM INDIVDUOS
LAURO CSSIO MARTINS DE PAULA
Trabalho de Concluso de Curso apresentado por Lauro Cssio Martins de Paula Pontifcia Universidade Catlica de Gois, como parte dos requisitos para obteno do ttulo de
Bacharel em Cincia da Computao.
Prof. Esp. Jeov Martins Ribeiro

Coordenador de Trabalho de Concluso de Curso
BANCA EXAMINADORA:
Prof. Dr. Clarimar Jos Coelho

Orientador
M.Sc. Arlindo Rodrigues Galvo Filho

Co-orientador
Esp. Daniel Vitor de Lucena

Banca
M.Sc. Wagner Oliveira de Arajo

Banca
CIP CATALOGAO NA PUBLICAO

Paula, Lauro Cssio Martins de
Programao Paralela CUDA para simulao de modelos epidemiolgicos
baseados em indivduos / Lauro Cssio Martins de Paula. Goinia: BC
da UCG, 2012.
66 f.: il.: 23 cm.
Monografia (graduao) Pontifcia Universidade Catlica de Gois.
Graduao em Cincia da Computao, Goinia, BRGO, 2012. Orientador:
Clarimar Jos Coelho; Co-orientador: Arlindo Rodrigues Galvo Filho.
1. Epidemiologia matemtica. 2. modelo baseado em indivduos. 3. modelo
SIR. 4. processamento paralelo. 5. GPU. 6. CUDA. I. Coelho, Clarimar Jos.
II. Rodrigues Galvo Filho, Arlindo. III. Ttulo.
Deus pela f e sabedoria fornecidas constantemente.

Ao meu pai, Carlos Gardel, e minha me, Beti Martins, pelo apoio e compreenso.
AGRADECIMENTOS
Ao Professor Dr. Clarimar Jos Coelho e ao M.Sc. Arlindo Rodrigues Galvo Filho,
orientador e co-orientador acadmicos, pelo apoio e confiana depositada. Aos professores
Dr. Leonardo Barra Santana de Souza e M.Sc. Leandro Barra Santana de Souza por me
incentivarem a tornar um pesquisador e pela inestimvel colaborao. todos os professores
do Departamento de Computao da PUC Gois, especialmente ao professor M.Sc. Alexandre
Ribeiro, por terem ajudado minha formao acadmica. Aos meus colegas de graduao pelas
discusses tcnicas e sugestes.
Eletrobras Furnas, em especial ao Eng. M.Sc. Flvio Mamede, por terem me proporcionado o melhor estgio que j tive.
Descobri como bom chegar quando se tem pacincia.

E para se chegar, onde quer que seja, aprendi que no
preciso dominar a fora, mas a razo. preciso, antes de
tudo, querer.
Amyr Klink
viii
RESUMO
A epidemiologia computacional consiste no desenvolvimento e uso de modelos
computacionais com o objetivo de compreender a proliferao de doenas do ponto
de vista dinmico. Os modelos computacionais so capazes de simular o comportamento de uma determinada epidemia e seus efeitos na populao de uma regio e
desenvolvem estratgias de controle e preveno de enfermidades. A epidemiologia
computacional prope modelos que classificam indivduos como suscetveis, infectados e recuperados (SIR) e baseados no indivduo (IBM). O modelo SIR considera
a distribuio homognea de indivduos no espao e no tempo e no capaz de
explicar a persistncia ou erradicao de doenas infecciosas. O IBM reproduz as
premissas do modelo SIR para a anlise do indivduo. O custo computacional de
um modelo para simular o comportamento de uma epidemia cresce em funo do
tamanho da populao considerada. Este trabalho implementa o IBM empregando
programao paralela em unidade de processamento grfico (GPU) e arquitetura
de dispositivo unificado de computao (CUDA) visando ganhar desempenho em
relao a implementao tradicional. Os resultados mostram que em algumas
situaes a reduo do tempo computacional fica em torno de 170% e que a taxa
de crescimento com o aumento do tamanho da populao duas vezes menor na
implementao paralela quando comparada com uma implementao sequencial.
Palavras-Chave: Epidemiologia matemtica, modelo baseado em indivduos, modelo SIR,

processamento paralelo, GPU, CUDA.
ix
ABSTRACT
The computational epidemiology is the development and use of computational
models that aims to understand the proliferation of diseases of the dynamic point
of view. The computational models are capable to simulate the behavior of an
epidemic and its effects on the population of a region and develop strategies of
control and prevention of diseases. The computational epidemiology proposes
models that classify individuals as susceptible, infected and recovered (SIR) and
based on individual (IBM). The SIR model considers the homogeneous distribution
of individuals in space and time and it is not capable to tell the persistence or eradication of infectious diseases. The IBM reproduces the premises of the SIR model
to the individual analyse. The model computational cost to simulate the behavior
of an epidemic grows up with the size of the population considered. This work
implements a IBM using parallel programming through the use of GPUs (Graphics
Processor Unit) compatible with CUDA (Compute Unified Device Architecture).
The goal is to gain performance compared to the traditional implementation. The
results show that in some cases the reduction of computational time is around
170% and the growth rate with the increase of the population size is, in some
cases, two times lower in a parallel implementation when compared to a sequencial
implementation.
Key-Words: Mathematical epidemiology, model based on individuals, SIR model, parallel

processing, GPU, CUDA.
Lista de Figuras
1
Representao esquemtica do modelo SIR, conforme mostrado em [1], [2] e [3].
Fluxograma para simulao do IBM homogneo. . . . . . . . . . . . . . . . .
Comparao de capacidades de processamento entre CPUs e GPUs [4]. . . . .
12
Organizao de blocos em um grid [4]. . . . . . . . . . . . . . . . . . . . . . .
16
Hieraquia de memria [4]. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
Fluxo de execuo no host e no device [4]. . . . . . . . . . . . . . . . . . . . .
18
Chamada s funes utilizadas no processo de simulao do IBM-C. . . . . . .
22
Chamada s funes utilizadas no processo de simulao do IBM-CUDA. . . .
25
Exemplo de 1024 threads distribudas em 32 blocks com 32 threads cada. . . .
26
10
Quadro FX 5800 - Resultados de simulao realizada com uma populao de

1.000 indivduos e um incremento de tempo entre as iteraes igual a 3. . . . .
38
Variao dos resultados para as curvas das implementaes IBM-C e IBMCUDA com uma populao de 1.000 indivduos. . . . . . . . . . . . . . . . .
39

5.000 indivduos e um incremento de tempo entre as iteraes igual a 1,5. . . .
40

41
GeForce GT 240 - Resultados de simulao realizada com uma populao de

1.000 indivduos e um incremento de tempo entre as iteraes igual a 3. . . . .
42

43

43
17
Tempo mdio por iterao para um comparativo entre IBM-C e IBM-CUDA. .
44
18
Fluxograma para simulao do IBM homogneo [3]. . . . . . . . . . . . . . .
46
11
12
13
14
15
16
xi
Lista de Algoritmos
1
Definio dos parmetros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
Alocao de espao na memria. . . . . . . . . . . . . . . . . . . . . . . . . . .
21
Gerao dos indivduos da populao para o IBM-C. . . . . . . . . . . . . . . .
22
Gerao dos nmeros aleatrios. . . . . . . . . . . . . . . . . . . . . . . . . . .
22
Implementao da funo random. . . . . . . . . . . . . . . . . . . . . . . . . .
23
Realizao do teste de infeco. . . . . . . . . . . . . . . . . . . . . . . . . . .
23
Realizao do teste de recuperao. . . . . . . . . . . . . . . . . . . . . . . . .
23
Realizao do teste de mortalidade. . . . . . . . . . . . . . . . . . . . . . . . .
24
Gerao dos indivduos da populao para o IBM-CUDA. . . . . . . . . . . . .
27
10
Teste de infeco entre os indivduos suscetveis. . . . . . . . . . . . . . . . . .
28
11
Teste de recuperao entre os indivduos infectados. . . . . . . . . . . . . . . .
28
12
Teste de mortalidade entre os indivduos da populao. . . . . . . . . . . . . . .
29
13
Contagem do nmero de indivduos. . . . . . . . . . . . . . . . . . . . . . . . .
30
14
Implementao da funo RandomGPU. . . . . . . . . . . . . . . . . . . . . .
34
xii
Lista de Abreviaturas e Siglas

SIR
IBM
CUDA
CPU
GPU
MT
AMD
Suscetvel, Infectado e Recuperado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

Individual Based Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Compute Unified Device Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Central Processing Unit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Graphic Processor Unit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Mersenne Twister . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Advanced Micro Devices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
xiii
Lista de Smbolos
N
S
I
R
Pin f ec
Prec
Pmor
S(0)
I(0)
R(0)
t0
tf
t
t
Taxa de natalidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Taxa de mortalidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Taxa de recuperacao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Coeficiente de transmisso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Tamanho da populao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Indivduos suscetveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Indivduos infectados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Indivduos recuperados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Probabilidade de infeco . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Probabilidade de recuperao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Probabilidade de morte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Indivduos inicialmente suscetveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Indivduos inicialmente infectados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Indivduos inicialmente recuperados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Tempo inicial da simulao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Tempo final da simulao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Incremento de tempo entre as iteraes da simulao . . . . . . . . . . . . . . . . . . 7
Derivada em relao ao tempo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
xiv
Sumrio
1
INTRODUO
MODELOS MATEMTICOS PARA EPIDEMIOLOGIA
2.1
Suscetvel-Infectado-Recuperado . . . . . . . . . . . . . . . . . . . . . . . . .
2.1.1
Introduo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.1.2
Equaes do modelo . . . . . . . . . . . . . . . . . . . . . . . . . . .
Modelo Baseado em Indivduos . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.1
Conceitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.2
Algoritmo do IBM homogneo . . . . . . . . . . . . . . . . . . . . . .
2.2.3
Equivalncia entre o SIR e o IBM homogneo . . . . . . . . . . . . . .
2.2
PROCESSAMENTO PARALELO NA PLATAFORMA CUDA
11
3.1
Motivao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
3.2
Computao paralela . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13
3.3
CUDA - Uma arquitetura para computao paralela . . . . . . . . . . . . . . .
13
3.3.1
Prs e contras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13
3.4
Kernels - Ncleos de processamento . . . . . . . . . . . . . . . . . . . . . . .
14
3.5
Hierarquia de threads e memria . . . . . . . . . . . . . . . . . . . . . . . . .
15
3.6
Programao heterognea . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
IBM-C E IBM-CUDA
20
4.1
Detalhes de implementao do IBM-C . . . . . . . . . . . . . . . . . . . . . .
20
4.2
Detalhes de implementao do IBM-CUDA . . . . . . . . . . . . . . . . . . .
24
4.2.1
Cdigo do host . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
24
4.2.2
Cdigo do device . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
26
Mersenne Twister - Um gerador de nmeros aleatrios . . . . . . . . . . . . .
31
4.3.1
Prs e contras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
31
4.3.2
Detalhes de implementao . . . . . . . . . . . . . . . . . . . . . . .
32
4.3
xv
Sumrio
4.3.3
5
Implementao da funo RandomGPU . . . . . . . . . . . . . . . . .
34
RESULTADOS
37
5.1
Validao das implementaes IBM-C e IBM-CUDA . . . . . . . . . . . . . .
37
5.2
Avaliao do ganho computacional proporcionado pelo IBM-CUDA . . . . . .
43
CONCLUSES
48
6.1
Consideraes finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
48
6.2
Propostas para trabalhos futuros . . . . . . . . . . . . . . . . . . . . . . . . .
49
INTRODUO
Epidemiologia o estudo da frequncia, distribuio e determinantes de estados ou eventos

relacionados sade em populaes especficas e a aplicao destes estudos no controle dos
problemas de sade [5]. Epidemiologia computacional consiste no desenvolvimento e uso de
modelos computacionais para compreender a proliferao de doenas no espao e no tempo [6].
A epidemiologia computacional usa tcnicas da cincia da computao, matemtica, cincia
da informao geogrfica e de sade pblica para desenvolver ferramentas e modelos para
ajudar epidemiologistas no estudo da propagao de doenas. Se preocupa em estudar como as
doenas se espalham e no a doena propriamente dita [7].
Modelos matemticos tem se tornado ferramentas importantes na anlise da propagao e
controle de doenas infecciosas, especialmente quando combinado a mtodos computacionais
modernos capazes de desenvolver modelos de simulao para anlise da dinmica da contaminao. Os modelos so usados para compreender os processos fundamentais da propagao
de doenas, comparar polticas alternativas e intervenes e no apoio tomada de deciso. Os
modelos fornecem guias para exerccios de treinamento e desenvolvimento de cenrios assim
como para avaliao de riscos e previso de tendncias futuras [8].
Profissionais de sade pblica necessitam de apoio computacional para o estudo da dinmica dos surtos de doenas. Modelo de surtos de doenas em grandes populaes uma
tarefa orientada a dados que requer enormes recursos computacionais. O desenvolvimento de
novas tecnologias computacionais ajudam epidemiologistas na modelagem do contexto scioeconmico de surtos de doenas [9]. Atualmente, epidemiologistas e cientistas da computao
esto desenvolvendo novas ferramentas orientadas a dados com o emprego da computao de
alto desempenho com base em inferncia estatstica para modelar o contexto socioeconmico e
estratgias para a administrao de surtos de doenas [10].
O custo computacional dos modelos usados para simular epidemias cresce em funo do
tamanho da populao usada como entrada para elaborar o modelo de simulao computacional. A busca de alternativas para a melhoria de desempenho computacional torna-se uma
contribuio importante para a viabilidade da implementao destes modelos. Este trabalho tem
como objetivo implementar uma verso sequencial e uma verso paralela do modelo baseado
em indivduos (Individual Based Model, IBM) e comparar os resultados obtidos com as duas
verses.
Epidemia a ocorrncia sbita de doena infecciosa que se dissemina rapidamente na
populao [11]. Ao longo da histria, ocorre um grande nmero de epidemias como a peste
negra entre os anos de 1347 at 1350. Entre os anos de 1918 e 1921, ocorre a epidemia
de tifo na Rssia. Em 1919, registrada a epidemia mundial da gripe. Atualmente, a
1 INTRODUO
humanidade convive com a presena da sndrome de imunodeficincia adquirida (Acquired

Immunodeficiency Syndrome, AIDS).
O primeiro modelo matemtico aplicado na modelagem de epidemias proposto por Daniel
Bernoulli entre os anos de 1700 e 1782. Em 1906, John Brownlee recorre estatstica para a
anlise de sries temporais de dados epidemiolgicos. No ano de 1906, Hamer sugere que a taxa
de transmisso de doenas proporcional ao produto da densidade de indivduos suscetveis e
infectados. Em 1930, Kermack e McKendrick desenvolvem a teoria que relaciona o surgimento
de uma epidemia a um valor crtico do nmero de indivduos e formulam o modelo suscetveis,
infectados e recuperados (Susceptible, Infectious and Recovered, SIR) [7]. Em 2005, Grimm
e Railsback [12] publicam o livro Individual-Based Modeling and Ecology sobre o modelo
baseado em indivduos (Individual Based Model, IBM).
Atualmente, o interesse na modelagem de doenas infecciosas crescente e torna-se objeto
de muitos trabalhos, tais como o trabalho de Galvo Filho [3], Vieira e Takahashi [13], Barros
et al. [14], Grimm et al. [15], Yang [16], Pereira [1] e Neponuceno [17], cujo objetivo
compreender a dinmica da transmisso de doenas e as foras que determinam essa dinmica
visando proporcionar estratgias de controle efetivas.
O modelo SIR usado para estudar a propagao de doenas infecciosas atravs do
rastreamento de um nmero (S) de pessoas suscetveis doena, um nmero (I) de pessoas
infectadas com a doena e um nmero (R) de pessoas que tiveram a doena e foram recuperadas
ou mortas. Supe-se que a populao total, N = S(t) + I(t) + R(t), fixa. Da, segue-se que
N S I R
=
+ + , t > 0.
t
t t t
(1.1)
Com base no modelo, a nica maneira de uma pessoa deixar o grupo dos suscetveis
tornar-se infectada e a nica maneira de uma pessoa deixar o grupo dos infectados se recuperar
ou morrer. Assume-se ainda que os recuperados ou os que morrem com a doena so sempre
mais imunes. claro que estas suposies so mais realistas para certas doenas (por exemplo,
catapora) do que para outras (como resfriado comum). Supe-se tambm que todos que no
tiveram a doena so igualmente suscetveis e que a probabilidade de contrair a doena no
tempo t proporcional ao produto de I(t) por S(t). Isto pode ser realista se a populao sendo
considerada consiste de um grupo de aproximadamente mesma idade e do mesmo nvel de
sade geral, se no houver imunidade herdada e se os membros do grupo estiverem misturados
homogeneamente [18].
Os conceitos fundamentais utilizados para formular o modelo SIR so usados para elaborar
o modelo IBM. A estratgia IBM usa fundamentos estocsticos para modelar alteraes nas
caractersticas dos indivduos [17].
O modelo IBM implementado neste trabalho usa a linguagem computacional C++ e suas
extenses para a arquitetura GPU-CUDA [4, 19, 20, 21, 22, 23]. So feitas duas implementaes
para o modelo IBM denominadas, respectivamente, de IBM-C e IBM-CUDA. A implementao
IBM-C uma verso sequencial do modelo IBM. O propsito dessa implementao gerar
resultados para comparar com a verso paralela do modelo IBM. A implementao IBMCUDA feita com o objetivo de reduzir o tempo computacional em relao implementaes
sequenciais.
1 INTRODUO
Os resultados obtidos com o IBM-CUDA mostram que o tempo computacional reduzido

significativamente e que a taxa de crescimento com o aumento do tamanho da populao
consideravelmente menor quando comparada com a implementao sequencial IBM-C.
O texto est organizado em seis Captulos. O Captulo 2 introduz o modelo SIR e o modelo
IBM. O Captulo 3 apresenta os detalhes do paradigma de programao paralela utilizado na
implementao do IBM-CUDA. O Captulo 4 mostra detalhes da implementao do IBM-C e
IBM-CUDA. O Captulo 5 apresenta os resultados para o IBM-C e IBM-CUDA e a comparao
entre eles com as especificidades de cada uma das implementaes. Finalmente, o Captulo 6
apresenta as concluses e as sugestes para trabalhos futuros.
MODELOS MATEMTICOS PARA

EPIDEMIOLOGIA
A epidemiologia matemtica fundamenta-se em hipteses que buscam quantificar alguns

aspectos do fenmeno biolgico relacionado interao entre o parasita (bactria, vrus) e o
hospedeiro (homem, animal) [1]. Nesse sentido, este captulo mostra os principais conceitos
sobre dois modelos matemticos para epidemiologia.
O primeiro, conhecido como Suscetvel-Infectado-Recuperado (SIR), divide os indivduos
de uma populao em apenas trs classes (ou compartimentos): Suscetveis, Infectados, Recuperados.
O segundo uma estratgia conhecida como Modelo Baseado em Indivduos (Individuals
based Model, IBM), a partir do qual possvel obter um modelo formulado com as mesmas
premissas utilizadas na formulao do SIR, onde a principal caracterstica de um indivduo
consiste na sua condio epidemiolgica atual.
Ambos os modelos apresentados neste trabalho so considerados modelos homogneos,
devido ao fato de se considerar uma nica caracterstica para cada indivduo e os parmetros e
o tamanho da populao serem mantidos constantes durante todo o processo de simulao.
2.1
Suscetvel-Infectado-Recuperado
2.1.1
Introduo
SIR um modelo de compartimentos bastante utilizado na modelagem da dinmica de

transmisso de doenas infecciosas como, por exemplo, sarampo, rubola, varicela etc. Neste
modelo, um indivduo pode pertencer uma das trs classes, as quais so especificadas abaixo.
a) Suscetveis: indivduos que no esto infectados, mas podem contrair a doena.
b) Infectados: indivduos que esto infectados e podem transmit-la para outros
indivduos.
c) Recuperados: indivduos que esto recuperados e, por hiptese, imunes ao
contgio.
O diagrama da Figura 1 apresenta a dinmica de transio entre cada um dos compartimentos criados:
2.1 Suscetvel-Infectado-Recuperado
SI
Suscetveis
Infectados
Recuperados
Mortos
Figura 1: Representao esquemtica do modelo SIR, conforme mostrado em [1], [2] e [3].
Os indivduos no estado Suscetveis passam para o estado Infectados de acordo com a taxa
de infeco definida para a enfermidade sob anlise.
J a transio entre os estados Infectados e Recuperados ocorre segundo a taxa de recuperao . As variveis e , por sua vez, definem com que frequncia ocorrem nascimentos e
mortes, respectivamente.
Na ocorrncia de um nascimento, h um aumento no nmero de indivduos suscetveis
doena, j que se admite que no h indivduos nascidos nos estados Infectados ou Recuperados.
Em outras palavras, admite-se que cada indivduo que nasce, automaticamente, o mesmo passa
a pertencer classe dos Suscetveis.
2.1.2
Equaes do modelo
Atravs de um conjunto de equaes possvel descrever o modelo SIR:
onde N = S(t) + I(t) + R(t).
IS
dS
= N S
,
dt
N
(2.1)
dI IS
=
I I,
dt
N
(2.2)
dR
= I R,
dt
(2.3)
2.2 Modelo Baseado em Indivduos
Tais equaes so diferenciais no-lineares a tempo contnuo. Devido isso, o SIR possui a
caracterstica de ser um modelo determinstico, pois a partir destas equaes pode-se determinar
a quantidade de indivduos, pertencentes uma determinada classe, em algum tempo t.
As equaes 2.1, 2.2 e 2.3 so obtidas a partir de algumas consideraes. A taxa de
infeco, dada pela letra grega , representa o percentual de contatos entre indivduos que se
infectaram durante o contato com indivduos j infectados.
A letra grega representa a taxa de natalidade de novos indivduos por unidade de tempo.
Considera-se que os recm-nascidos so todos suscetveis, no havendo transmisso vertical da
doena ou da imunidade por parte dos pais [3].
A taxa de recuperao e o tamanho da populao so representados pelas letras e N,
respectivamente.
Considerar que o tamanho da populao mantido constante, equivale a afirmar que = ,
isto , taxa de natalidade igual a taxa de mortalidade.
A equao 2.1 representa a quantidade de indivduos pertencentes classe Suscetveis em
um determinado tempo t. A multiplicao dada por N fornece o nmero de indivduos recmnascidos mais os indivduos suscetveis. A multiplicao S indica o nmero de mortes de
indivduos, sendo que isso possvel devido a taxa de natalidade ser considerada igual a taxa
de mortalidade. O termo IS
N fornece o nmero de indivduos que se infectaram.
J a equao 2.2 representa a quantidade de indivduos pertencentes classe Infectados
em um determinado tempo t. O termo IS
N indica o nmero de indivduos que se encontram
infectados. A multiplicao I fornece o nmero de indivduos que se recuperaram, segundo
uma taxa de recuperao . A multiplicao I fornece o nmero de indivduos que morreram.
Utilizando a equao 2.3 possvel representar a quantidade de indivduos pertencentes
classe Recuperados em um determinado tempo t. A multiplicao I fornece o nmero de
indivduos que esto recuperados, e a multiplicao R, assim como nas equaes 2.1 e 2.2,
indica o nmero de indivduos que vieram a falecer.
2.2
Modelo Baseado em Indivduos
Nesta seo, so detalhados os principais conceitos envolvidos na modelagem de sistemas

epidemiolgicos baseados em indivduos. Alm disso, mostrado o algoritmo do IBM homogneo utilizado nas simulaes para o IBM-C e IBM-CUDA (detalhados no captulo 4), criados
para se estabelecer comparaes de desempenho entre os mesmos.
2.2.1
Conceitos
Modelos Baseados em Indivduos so simulaes que obtm as consequncias globais de

interaes entre indivduos de uma populao. O IBM consiste tipicamente em um ambiente
no qual ocorrem interaes entre indivduos detentores de caractersticas que definem seus
comportamentos [1].
Devido necessidade de uma modelagem que permitisse a investigao de fenmenos

epidemiolgicos de uma forma mais realista, foi proposto por Nepomuceno [17] um modelo,
formulado com as mesmas premissas utilizadas na formulao do SIR, para a modelagem
matemtica de doenas epidemiolgicas. Neste modelo, cada indivduo da populao descrito
por um conjunto de caractersticas de relevncia do ponto de vista epidemiolgico e os mesmos
so representados por um vetor da forma:
Id (t) = [Cd1 (t) Cd2 (t) ... Cdn (t)]T ,
A letra d, no vetor, o d-simo indivduo de uma populao de tamanho N, t o instante de
tempo considerado e C uma caracterstica do indivduo.
Sendo assim, uma populao de N indivduos pode ser representada pela seguinte matriz de
dimenses Nn:
P(t) =
2.2.2
[C11 (t) C12 (t) ... C1n (t)]T

[C21 (t) C22 (t) ... C2n (t)]T
.
.
.
T
[CN1 (t) CN2 (t) ... CNn (t)]
Algoritmo do IBM homogneo
Inicialmente, so definidos os seguintes parmetros:

a) N: tamanho da populao;
b) S(0): quantidade de indivduos inicialmente suscetveis;
c) I(0): quantidade de indivduos inicialmente infectados;
d) R(0): quantidade de indivduos inicialmente recuperados;
e) t0 : tempo inicial da simulao;
f) t f : tempo final da simulao;
g) t: incremento de tempo entre as iteraes;
h) Pin f ec : probabilidade de infeco;
i) Prec : probabilidade de recuperao;
j) Pmor : probabilidade de morte.
A figura 2 mostra o fluxograma para simulao do IBM empregado neste trabalho. Os blocos destacados em cinza na figura so referentes s partes que foram implementadas aplicandose processamento paralelo (utilizado para o IBM-CUDA).
Incio
Gera Populaes
S, I e R
Gerao de
Nmeros
Aleatrios
Teste de
infeco entre
os indivduos
suscetveis
Teste de
recuperao entre
os indivduos
infectados
Teste de
mortalidade para
os indivduos da
populao
t t +t
Sim
t < tf
No
Fim
Figura 2: Fluxograma para simulao do IBM homogneo.
Na inicializao da simulao, so gerados os indivduos da populao, onde cada indivduo

pertence classe Suscetveis (S), Infectados (I) ou Recuperados (R). Logo aps, so gerados os
nmeros aleatrios, com base em uma distribuio uniforme no intervalo [0, 1], utilizados nos
processos de infeco, recuperao e morte.
Aps a a gerao de nmeros aleatrios, realizado o teste de infeco. fornecido um
nmero, a partir dos nmeros aleatrios gerados, para cada indivduo pertencente classe S. Se
este nmero menor do que Pin f ec , ento admite-se que o indivduo em questo foi infectado
atravs do contato com um outro indivduo infectado e, portanto, o mesmo passa a pertencer
classe I.
Logo aps, realizada a etapa de recuperao. De forma anloga ao processo de infeco,
obtm-se um nmero aleatrio, a partir dos nmeros aleatrios gerados, para cada indivduo
pertencente classe I. Caso tal nmero seja menor do que Prec , considera-se que o indivduo em
questo foi recuperado e, automaticamente, transferido para a classe R.
Aps isso, prossegue-se para a etapa de morte. Como cada indivduo pode vir a falecer,
obtido um nmero aleatrio, tambm a partir dos nmeros aleatrios gerados, para cada um dos
indivduos da populao. Se este nmero menor do que Pmor , supem-se que o indivduo veio
a bito. Vale ressaltar que, para cada indivduo que vem a falecer, nasce um novo indivduo,
garantindo-se uma populao de tamanho constante.
Por fim, a varivel (t) que representa o nmero de iteraes somada com o valor de t e
verificado se essa varivel menor do que a quantidade total de iteraes a serem realizadas.
Se verdadeiro, ento uma nova iterao ser realizada. Seno, o algoritmo finalizado.
Por envolver eventos aleatrios relacionados aos processos de infeco, recuperao e
morte, a simulao do IBM possui carter estocstico [3]. Portanto, esta a principal diferena
entre o SIR e o IBM, devido o primeiro ser considerado um modelo determinstico.
2.2.3
Equivalncia entre o SIR e o IBM homogneo
De modo a obter resultados equivalentes, em mdia, aos do modelo SIR, possvel escolher
valores para os parmetros Pin f ec , Prec e Pmor do modelo IBM [3]. Como o IBM utiliza as
mesmas premissas do modelo SIR, acredita-se que haja uma certa equivalncia entre esses
modelos [17].
A probabilidade de infeco pode ser dada por:
Pin f ec = (I / N)t,
(2.4)
A letra I, na equao 2.4, representa a quantidade de indivduos atualmente infectados,

a taxa de infeco considerada no modelo SIR, e t o incremento de tempo entre as iteraes.
A probabilidade de recuperao pode ser igual a multiplicao entre a taxa de recuperao
considerada no modelo SIR e o incremento de tempo entre as iteraes:
Prec = t.
(2.5)
10
J a probabilidade de morte pode ser dada pela multiplicao entre a taxa de mortalidade e
t:
Pmor = t.
(2.6)
Alm disso, o tamanho da populao (N) deve ser o mesmo nos dois modelos.
Por motivos de simplicidade, neste trabalho no explicado o motivo pela escolha dos
valores dos parmetros Pin f ec , Prec e Pmor . Maiores detalhes sobre a equivalncia entre o SIR e
o IBM podem ser obtidos nos trabalhos de Pereira [1] e Nepomuceno [17].
11
PROCESSAMENTO PARALELO NA
PLATAFORMA CUDA
Processamento paralelo consiste na utilizao de mltiplos processadores para executar

partes diferentes de um mesmo programa simultaneamente, onde o principal objetivo reduzir
o tempo total de processamento. Nesse sentido, este captulo ir detalhar os principais conceitos
envolvidos no paradigma de programao paralela utilizando CUDA.
A seo 3.1 mostra algumas motivaes para se fazer uso de uma GPU, que fornece o
recurso de processamento paralelo atravs de seus cores (ncleos) de processamento.
A seo 3.2 expe algumas vantagens e desvantagens de se utilizar o recurso de processamento paralelo, e a seo 3.3 mostra alguns aspectos prs e contras relacionados arquitetura
CUDA.
J as sees 3.4, 3.5 e 3.6 mostram, respectivamente, a definio das funes kernel e sua
funcionalidade, uma introduo hierarquia de threads e hierarquia de memria empregada
na arquitetura CUDA, e as principais diferenas entre host e device.
3.1
Motivao
Devido crescente utilizao de alto poder computacional, a necessidade de processadores

mais velozes vem se tornando inevitvel. Como pode ser verificado atravs da figura 3, desde
2003, a capacidade de processamento de uma GPU tem se mostrado superior em relao uma
CPU nos ltimos anos [21].
3.1 Motivao
12
Figura 3: Comparao de capacidades de processamento entre CPUs e GPUs [4].
GPUs so melhores adaptadas para enderear problemas que podem ser expressos atravs
de clculos realizados de forma paralela [2]. Como o mesmo programa executado para cada
elemento de dado, h menos requisitos referentes controles de fluxo. E, exatamente por ser
executado em muitos elementos de dados, a latncia de acesso memria pode ser ocultada
pela realizao de clculos, ao invs de grandes quantidade de dados armazenados em memria
cache (tipo de memria que serve para armazenar os dados mais frequentemente usados pelo
processador).
Alm disso, pode-se citar vrios tipos de aplicao onde o uso de processamento paralelo
contribui bastante, como por exemplo:
a) Meteorologia (previso de tempo e clima);
b) processamento de imagens (satlites, mdicas etc.);
c) anlise aerodinmica e estrutural;
d) mecnica de fluidos.
Portanto, percebe-se que, atravs da utilizao do poder computacional proporcionado pelas
GPUs, pode-se tentar obter um maior desempenho de processamento dos IBMs em relao aos
mesmos IBMs implementados usando processamento sequencial.
3.2 Computao paralela
3.2
13
Computao paralela
Como toda tecnologia, a computao paralela possui vantagens e desvantagens. Uma das
vantagens a possibilidade de usar todo o poder de processamento de CPUs e GPUs, de forma
a acelerar clculos [24]. Uma outra vantagem a capacidade de cada processador (ou ncleo
de processamento) ficar responsvel pela execuo de uma tarefa, ou seja, cada um realiza sua
tarefa concorrentemente com o outro.
Outras vantagens relacionam-se com a capacidade de processamento, principalmente quando
se trata da execuo de mais de um programa (ou funo) ao mesmo tempo. Nos processadores
e GPUs atuais, existe tambm uma melhora no acesso memria e na troca de dados entre os
ncleos de processamento.
A principal desvantagem que nem todos os algoritmos so totalmente paralelos e pode ser
complexo reescrever algoritmos para execuo em paralelo. Patterson e Hennessy [25] fazem a
seguinte pergunta: Por que difcil desenvolver programas paralelos que sejam rpidos?
Patterson e Hennessy [25] afirmam que possvel fazer uma analogia entre o overhead
(processamento em excesso) de comunicao para uma tarefa realizada por uma pessoa comparado com o overhead para uma tarefa realizada por um comit, especialmente enquanto o
tamanho do comit aumenta. Embora n pessoas possam ter o potencial para concluir qualquer
tarefa n vezes mais rpido, o overhead de comunicao para o grupo pode impedir isso. A
multiplicao da velocidade por n se torna especialmente improvvel conforme n aumenta.
Como exemplo, imagine a mudana no overhead de comunicao se um comit crescer de 10
para 1.000 pessoas e, depois, para 1.000.000 [25].
Outra razo por que difcil escrever programas paralelos que o programador precisa
saber muito sobre o hardware [25]. Em uma mquina com um nico processador, o programador pode desenvolver o programa com uma linguagem de alto nvel e ignorar grande
parte da organizao bsica da mquina porque, geralmente, o compilador fica responsvel por
isso. J para uma mquina com multiprocessadores ou uma placa de vdeo com vrias GPUs,
infelizmente, isso no to simples.
3.3
CUDA - Uma arquitetura para computao paralela
As subseo 3.3.1 expe algumas vantagens e desvantagens de se utilizar os recursos

fornecidos pela arquitetura CUDA.
3.3.1
Prs e contras
A Compute Unified Device Architecture, tambm chamada CUDA, uma extenso para a
linguagem de programao C, desenvolvida pela NVIDIA, que possibilita o uso de computao
paralela. A NVIDIA uma empresa multinacional que fabrica componentes de computador
(como, por exemplo, chipsets para placas de vdeo, componentes grficos para videogames
etc.). A ideia por trs disso tudo que programadores possam usar os poderes da unidade de
processamento grfico (GPU) para realizar algumas operaes mais rapidamente [26].
3.4 Kernels - Ncleos de processamento
14
Atravs da arquitetura CUDA, possvel utilizar as funes de uma placa grfica usando
funes em C (C para CUDA), o que a torna uma ferramenta relativamente simples para
desenvolvedores familiarizados com a linguagem [27]. Uma outra vantagem que, alm de
oferecer uma boa flexibilidade, permite gerar aplicativos bastante otimizados.
Existe, tambm, uma arquitetura chamada OpenCL (Open Computing Language) desenvolvida pela Khronos Group, uma associao de fabricantes destinada a desenvolver padres
abertos [28]. Atravs da utilizao do OpenCL, possvel desenvolver programas que funcionam em plataformas heterogneas, consistindo em CPUs, GPUs e outros processadores. Essa
arquitetura partilha uma srie de interfaces computacionais, incluindo CUDA, o que a torna
uma opo mais ou menos universal [29].
primeira vista, a escolha do OpenCL parece ser mais bvia, devido ao fato de que
seria possvel desenvolver aplicativos que poderiam ser usados em qualquer GPU, em vez de
desenvolver uma verso (utilizando CUDA) para placas da NVIDIA e outra para placas da
AMD, por exemplo. Porm, na prtica essa escolha um pouco mais complicada, j que o
OpenCL oferece funes e extenses que so especficas para cada famlia [27].
Nesse contexto, possvel concluir que h uma necessidade de escolha sobre qual arquitetura utilizar. Com o OpenCL possvel desenvolver aplicativos genricos, isto , aplicativos que
podem ser executados independente do hardware utilizado. Entretanto, isso implica em nivelar
por baixo, utilizando apenas as funes mais comuns, o que resulta em um desempenho longe
do ideal [27]. Por outro lado, na arquitetura CUDA o hardware grfico famoso pelo alto poder
computacional ao processar streams (fluxos) de dados [30]. Porm, a CUDA uma tecnologia
da NVIDIA e, portanto, ela s funciona com placas de vdeo fabricadas por essa empresa.
3.4
Kernels - Ncleos de processamento
Geralmente, uma GPU deve processar apenas dados que so independentes entre si. Portanto, possvel processar vrios dados em paralelo. Neste sentido, GPUs podem ser consideradas como sendo stream processors - processadores que podem operar em paralelo, executando
uma nica instruo em muitos registros em um fluxo de uma vez.
Um stream um conjunto de registros que requerem computao similar, fornecendo
possibilidade de paralelismo de dados.
Kernels so funes que so aplicadas para cada elemento no stream e, em CUDA, podem
ser definidos utilizando o especificador de declarao __global__ [4]. Atravs da utilizao da
tecnologia CUDA, o programador pode definir kernels utilizando a mesma sintaxe da linguagem
C que, quando invocados, so executados n vezes em paralelo por n threads diferentes.
Thread (ou linha de execuo) uma forma de um processo dividir a si mesmo em duas
ou mais tarefas que podem ser executadas concorrentemente. Em CUDA, para cada uma das
threads que executam um kernel dado um nico identificador (local ID) que est acessvel,
dentro do kernel, atravs da varivel threadIdx.
Na chamada de uma funo kernel, deve-se especificar o nmero total de threads da
seguinte maneira:
3.5 Hierarquia de threads e memria
15
KernelFunction<<<numBlocks, numThreadsPerBlock>>> (p1 , p2 , ..., pn ).

KernelFunction representa o nome da funo kernel, numBlocks representa o nmero de
blocks (blocos) a serem gerados e distribudos entre os mltiplos ncleos de processamento da
GPU, numT hreadsPerBlock indica a quantidade de threads que cada block contm, e p1 , p2 ,
..., pn representam os parmetros de entrada para a funo.
3.5
Hierarquia de threads e memria
Em CUDA, a varivel threadIdx um vetor de 3 componentes. Assim, as threads podem ser

identificadas utilizando-se ndices com 1, 2 ou 3 dimenses, formando blocos unidimensionais,
bidimensionais ou tridimensionais, respectivamente.
O ndice de uma thread e sua respectiva ID (thread ID) se relacionam da seguinte maneira:
Para um bloco unidimensional, representam a mesma informao, ou seja, o ndice de uma
thread igual ao ID dessa mesma thread [4].
Para um bloco bidimensional de tamanho (Dx , Dy ), o thread ID de uma thread de ndice (x,
y) (x + yDx ).
Para um bloco tridimensional de tamanho (Dx , Dy , Dz ), o thread ID de uma thread de ndice
(x, y, z) (x + yDx + zDx Dy ).
H um limite de threads por bloco, uma vez que todas as threads de um bloco devem residir
num mesmo ncleo de processador e devem compartilhar os mesmos recursos de memria desse
ncleo. Nas GPUs (de uma placa da NVIDIA) atuais, um bloco pode conter at 1.024 threads
[4]. Consequentemente, um kernel pode ser executado por mltiplos blocos de threads com o
mesmo formato, fazendo com que o nmero total de threads seja igual ao nmero de threads
por bloco vezes o nmero de blocos.
Como representado na figura 4, os blocos podem ser organizados em grids de uma, duas
ou trs dimenses. Cada bloco dentro do grid pode ser identificado por um ndice uni, bi ou
tridimensional, acessvel dentro do kernel, atravs da varivel blockIdx. A dimenso do bloco
de threads acessvel dentro do kernel pela varivel blockDim, que retorna o nmero de threads
por bloco.
3.5 Hierarquia de threads e memria
16
Figura 4: Organizao de blocos em um grid [4].
Tambm em CUDA, as threads podem acessar os dados a partir de mltiplos espaos de

memria durante suas execues, como ilustrado pela Figura 5:
17
3.6 Programao heterognea
Figura 5: Hieraquia de memria [4].

Cada thread possui uma memria local privada, e cada block possui uma regio de memria
compartilhada visvel a todas as threads do mesmo block e com o mesmo tempo de vida do
block. Alm disso, todas as threads tm acesso mesma memria global.
3.6
Programao heterognea
Um programa em CUDA consiste de uma ou mais fases que so executadas pelo host (CPU)
ou pelo device (GPU) [22]. As fases que no dispe de paralelismo de dados so implementadas
18
no cdigo do host. J as fases que dispe de paralelismo de dados so implementadas no cdigo

do device. Geralmente, o programa composto por um nico cdigo fonte contendo ambos os
cdigos.
A figura 6 mostra um exemplo de execuo de um programa em CUDA:
Figura 6: Fluxo de execuo no host e no device [4].
19
O modelo de programao CUDA tambm assume que ambos o host e o device mantm
seus prprios espaos de memria separados, identificados como host memory e device memory,
respectivamente.
Portanto, um programa deve gerenciar o espao global de memria visvel aos kernels
atravs de chamadas funes CUDA, em tempo de execuo. Alm disso, deve tratar de
aes tais como alocao e desalocao de memria do device, e transferncia de dados entre o
host e o device.
20
IBM-C E IBM-CUDA
Neste trabalho, o algoritmo para simulao do IBM homogneo (descrito na Seo 2.2)
foi codificado na linguagem computacional C++ empregando uma implementao inteiramente
sequencial, bem como uma implementao paralelizada empregando a arquitetura CUDA. Tais
implementaes foram denominadas IBM-C e IBM-CUDA, respectivamente.
As sees 4.1 e 4.2 mostram, respectivamente, os detalhes da implementao utilizada para
o IBM-C e para o IBM-CUDA.
J a seo 4.3 mostra os conceitos e detalhes sobre um algoritmo, chamado Mersenne
Twister, que gera nmeros aleatrios atravs da utilizao dos cores de processamento de uma
GPU.
4.1
Detalhes de implementao do IBM-C
Atravs da utilizao de um nico arquivo possvel implementar a lgica utilizada para o

IBM-C. O cdigo do arquivo inicia-se com a definio de alguns parmetros apresentados na
subseo 2.2.2 deste trabalho. Isso pode ser visualizado atravs do algoritmo 1. Vale ressaltar
que, as informaes entre parnteses so apenas comentrios para uma melhor compreenso do
algoritmo.
4.1 Detalhes de implementao do IBM-C
21
Algoritmo 1: Definio dos parmetros.

incio
Entrada: TAM_POP (tamanho da populao, N),
beta (taxa de transmisso da doena, ),
mi (taxa de natalidade igual a taxa de mortalidade, = ),
gama (taxa de recuperao, ),
deltaIBM (incremento de tempo entre as iteraes, t),
n_iteracoes (nmero de iteraes para cada simulao),
recuperacao (probabilidade de recuperao, Prec ),
mortalidade (probabilidade de morte, Pmor ),
N_S_CPU (quantidade de indivduos inicialmente suscetveis para o IBM-C),
N_I_CPU (quantidade de indivduos inicialmente infectados para o IBM-C),
N_R_CPU (quantidade de indivduos inicialmente recuperados para o IBM-C),
prob_in f ec_CPU (probabilidade de infeco para o IBM-C, Pin f ec ),
N_S (quantidade de indivduos inicialmente suscetveis para o IBM-CUDA),
N_I (quantidade de indivduos inicialmente infectados para o IBM-CUDA),
N_R (quantidade de indivduos inicialmente recuperados para o IBM-CUDA),
prob_in f ec_GPU (probabilidade de infeco para o IBM-CUDA, Pin f ec ).
fim
Logo aps, d-se incio ao processo de alocao de memria para o armazenamento dos
dados referentes populao, tais como: os indivduos da populao e os nmeros aleatrios
necessrios nos testes de infeco, recuperao e morte. O algoritmo 2 mostra essa etapa:
Algoritmo 2: Alocao de espao na memria.
incio
h_pop_CPU [TAM_POP] (alocao para o vetor que armazenar os indivduos
da populao, onde cada posio do vetor representa um indivduo),
h_prob_in f ec [TAM_POP] (alocao para o vetor que armazenar os nmeros
aleatrios utilizados no teste de infeco),
h_recuperados [TAM_POP] (alocao para o vetor que armazenar os nmeros
aleatrios utilizados no teste de recuperao),
fim
h_mortos [TAM_POP] (alocao para o vetor que armazenar os nmeros

aleatrios utilizados no teste de morte).
Feito isso, dado incio ao processo de simulao. A figura 7 representa a sequncia de

chamada s funes para se realizar a simulao do IBM-C:
22
GeraPopulacao()
TesteInfeccao()
GeraNumAleatorios()
TesteMorte()
TesteRecuperacao()
Figura 7: Chamada s funes utilizadas no processo de simulao do IBM-C.
Como detalhado na subseo 2.2.2 deste trabalho, os algoritmos 3 e 4 mostram, respectivamente, a implementao das funes GeraPopulao e GeraNumAleatorios:
Algoritmo 3: Gerao dos indivduos da populao para o IBM-C.
incio
para i 1 at TAM_POP faa
se i < N_S_CPU ento
h_pop_CPU(i) S (a letra S indica que o indivduo na posio i do vetor
ir pertencer classe Suscetveis)
seno
se i < (N_S_CPU + N_I_CPU) ento
h_pop_CPU(i) I (a letra I indica que o indivduo na posio i do
vetor ir pertencer classe Infectados)
seno
h_pop_CPU(i) R (a letra R indica que o indivduo na posio i do
vetor ir pertencer classe Recuperados)
fim se
fim se
fim para
fim
Algoritmo 4: Gerao dos nmeros aleatrios.

incio
(a funo random() abaixo retorna um nmero aleatrio no intervalo [0, 1])
h_prob_in f ec(i) random()
h_recuperados(i) random()
h_mortos(i) random()
fim para
fim
A funo random, no algoritmo 4, uma funo que chama a funo padro rand (definida
na biblioteca <cstdlib>).
23
A funo rand retorna um nmero inteiro pseudo-aleatrio (pseudo-random integral number) no intervalo entre 0 e RAND_MAX [31]. Ento, esse nmero dividido por RAND_MAX
e retornado pela funo random. Desta forma, todos os nmeros retornados esto no intervalo
[0, 1].
RAND_MAX uma constante (definida na biblioteca <cstdlib>) e seu valor padro pode
variar dependendo da implementao, mas concedido a ser de, pelo menos, 32.767 [31].
O algoritmo 5 mostra a implementao da funo random:
Algoritmo 5: Implementao da funo random.
incio
return rand() / RAND_MAX
fim
J os algoritmos 6, 7 e 8 mostram, respectivamente, a implementao das funes TesteInfeccao, TesteRecuperacao e TesteMorte:
Algoritmo 6: Realizao do teste de infeco.
incio
(Teste de infeco entre os indivduos atualmente suscetveis)
se h_pop_CPU(i) = S ento
se h_prob_in f ec(i) < prob_in f ec_CPU ento
h_pop_CPU(i) I
fim se
fim se
fim para
fim
Algoritmo 7: Realizao do teste de recuperao.

incio
(Teste de recuperao para os indivduos atualmente infectados)
se h_pop_CPU(i) = I ento
se h_recuperados(i) < recuperacao ento
h_pop_CPU(i) R
fim se
fim se
fim para
fim
4.2 Detalhes de implementao do IBM-CUDA
24
Algoritmo 8: Realizao do teste de mortalidade.

incio
(Morte de indivduos segundo a taxa de mortalidade definida)
se h_mortos(i) < mortalidade ento
h_pop_CPU(i) S (para cada indivduo que morre, nasce um novo
indivduo em seu lugar)
fim se
fim para
fim
4.2
Detalhes de implementao do IBM-CUDA
Para a implementao do IBM-CUDA, optou-se pela distribuio dos passos do algoritmo

(apresentado na subseo 2.2.2) entre o host e o device.
O host realiza, em sequncia, as seguintes tarefas:
a) Definio da quantidade inicial de indivduos em S, I e R;
b) alocao de espao na memria do device para os indivduos da populao e para
os nmeros aleatrios, utilizados nos processos de infeco, recuperao e morte;
c) chamada s funes kernel, que so executadas pelo device;
d) atualizao da populao atravs da transferncia dos dados processados no
device para a memria do host.
O device fica responsvel por:
a) Gerao das populaes de S, I e R;
b) gerao dos nmeros aleatrios;
c) verificao de infeco entre os indivduos atualmente suscetveis com base na
probabilidade de infeco;
d) separao e recuperao dos indivduos atualmente infectados com base na
probabilidade de recuperao;
e) morte de indivduos segundo a taxa de mortalidade definida.
As subsees 4.2.1 e 4.2.2 explicam os detalhes do cdigo utilizado para a implementao
do host e do device, respectivamente.
4.2.1
Cdigo do host
De acordo com a seo 3.6 deste trabalho, um programa em CUDA pode ser composto por
um nico cdigo fonte contendo ambos os cdigos do host e do device. Portanto, o cdigo
utilizado para a lgica do IBM-CUDA foi implementado no mesmo arquivo que contm o
cdigo para o IBM-C.
25
Alguns parmetros do algoritmo so comuns tanto para o IBM-C quanto para o IBMCUDA, tais como: TAM_POP, beta, mi, gama, deltaIBM, n_iteracoes, recuperacao e mortalidade (mostrados no algoritmo 1).
J a probabilidade de infeco no comum para ambos os modelos. Isso se deve ao fato de
a probabilidade de infeco estar diretamente relacionada com o nmero de indivduos infectados, como mostrado na subseo 2.2.3 deste trabalho. O algoritmo 1 (na seo anterior) mostra a
declarao de dois parmetros distintos: prob_in f ec_CPU para o IBM-C; e prob_in f ec_GPU
para o IBM-CUDA.
Primeiramente, realizado o processo de alocao de espao na memria do device para
o armazenamento das informaes que sero utilizadas durante o processamento paralelo.
Esse processo realizado atravs de chamadas uma funo padro (definida na biblioteca
<cuda_runtime.h>) chamada cudaMalloc. Assim como mostrado no algoritmo 2, so utilizados
quatro vetores distintos (d_pop, d_prob_infec, d_recuperados e d_mortos) para armazenar os
indivduos da populao e os nmeros aleatrios necessrios nos teste de infeco, recuperao
e morte.
Aps ser concludo o processo de alocao de espao na memria do device, dado incio
ao processo de simulao do IBM-CUDA. A figura 8 representa a sequncia de chamada s
funes kernel:
GeraPopulacao_GPU()
TesteInfeccao_GPU()
RandomGPU()
TesteMorte_GPU()
TesteRecuperacao_GPU()
Figura 8: Chamada s funes utilizadas no processo de simulao do IBM-CUDA.
Conforme detalhado na seo 3.4, na chamada de uma funo kernel necessrio especificar o nmero de blocks e threads por block.
Esse nmero pode ser calculado de acordo com a
raiz quadrada do tamanho da populao ( N). Dessa forma, h uma melhor distribuio entre
o nmero de blocks e threads por block, garantindo-se um melhor aproveitamento dos cores de
processamento da GPU e, consequentemente, um melhor desempenho de processamento.
Para uma populao com N = 1.000 indivduos, por exemplo, 1.000 threads
podero ser
utilizadas para cada uma das funes kernel que so executadas. Como 1.000
= 31,62,
este valor poder ser arredondado para cima, ou seja, para cada uma das funes kernel
podero ser gerados 32 blocks sendo cada block com 32 threads, obtendo-se um total de 1.024
threads. Nesse caso, 24 threads sero inutilizadas, porm isso no afetar no desempenho de
processamento devido ao fato de as threads serem executadas independente uma das outras.
Para garantir isso, necessrio utilizar uma condio de que apenas as threads que contm o
seu global ID (identificador global) menor do que 1.000 executam a funo. Esse procedimento
pode ser visualizado atravs dos algoritmos mostrados na prxima subseo (subseo 4.2.2).
A figura 9 mostra como fica a distribuio das threads entre os blocks, de acordo com o
exemplo citado acima:
26
Thread 0
Thread 1
...
Thread 31
Bloco 0
Thread 0
Thread 1
Bloco 1
...
Thread 31
...
Thread 0
Thread 1
...
Thread 31
Bloco 31
Figura 9: Exemplo de 1024 threads distribudas em 32 blocks com 32 threads cada.
De acordo com a seo 3.4 deste trabalho, cada thread possui seu prprio identificador
(thread ID). Tal identificador chamado local ID (identificador local) e nico para cada thread
pertencente um mesmo block. Para diferenciar as threads entre os blocks, necessrio utilizar
um identificador global. Esse identificador global obtido, em CUDA, da seguinte maneira:
(blockIdx.x blockDim.x + threadIdx.x), onde a varivel blockIdx.x retorna o identificador do
block, e a varivel blockDim.x sempre retorna a quantidade de threads que cada block possui.
J a varivel threadIdx.x retorna o local ID da thread [23].
Aps a chamada de uma funo kernel, o fluxo de execuo para a funo chamada passa
a ser controlado pelo device, que distribuir a execuo nos mltiplos cores de processamento
das GPUs.
Imediatamente aps a chamada de uma funo kernel, a CPU volta a executar normalmente
mesmo se ainda existirem threads sendo executadas. A utilizao da funo padro cudaDeviceSynchronize (definida na biblioteca <cuda_runtime_api.h>) faz com que o fluxo de execuo
na CPU bloqueie at que todas as threads no device tenham sido executadas. Isto necessrio
para que haja um sincronismo entre as threads. Assim, fica garantido a consistncia dos dados
que so executados paralelamente.
Por exemplo, o teste de recuperao somente poder ser realizado aps o teste de infeco
ter sido concludo. Portanto, antes de realizar uma chamada funo TesteRecuperacao_GPU,
deve-se chamar a funo padro cudaDeviceSynchronize para garantir que todas as threads da
funo TesteIn f eccao_GPU tenham sido executadas.
4.2.2
Cdigo do device
Primeiramente, como mostra o algoritmo 9, so gerados os indivduos da populao atravs

da chamada funo GeraPopulacao_GPU:
27
Algoritmo 9: Gerao dos indivduos da populao para o IBM-CUDA.

incio
(como cada thread executa esta funo, a varivel id varia de 0 a n, onde n igual ao
numero total de threads - 1)
id identificador global da thread
(apenas as threads que possuem id < TAM_POP geram um indivduo da populao)
se id < TAM_POP ento
se id < N_S ento
d_pop(id) S (a letra S indica que o indivduo na posio i do vetor ir
pertencer classe Suscetveis)
seno
se id < (N_S + N_I) ento
d_pop(id) I (a letra I indica que o indivduo na posio i do vetor ir
pertencer classe Infectados)
seno
d_pop(id) R (a letra R indica que o indivduo na posio i do vetor
ir pertencer classe Recuperados)
fim se
fim se
fim se
fim
Ao mesmo tempo em que so gerados os indivduos da populao, so gerados tambm os
nmeros aleatrios utilizados nos processos de infeco, recuperao e morte. Isso possvel
devido ao fato de a etapa de gerao dos nmeros aleatrios ser independente da execuo da
etapa de gerao dos indivduos da populao.
Por simplicidade, nesta subseo no mostrado o algoritmo utilizado para a funo
RandomGPU, que gera os nmeros aleatrios. Os detalhes sobre essa funo so mostrados
na seo 4.3.
Aps a gerao dos nmeros aleatrios, realizado o teste de infeco entre os indivduos
atualmente suscetveis, como mostra o algoritmo 10:
28
Algoritmo 10: Teste de infeco entre os indivduos suscetveis.

incio
(apenas as threads que possuem id < TAM_POP realizam o teste de infeco para o
indivduo em questo, d_pop(id))
se d_pop(id) = S ento
(se verdadeiro, ento admite-se que o indivduo suscetvel foi infectado)
se d_prob_in f ec(id) < prob_in f ec_GPU ento
d_pop(id) I
fim se
fim se
fim se
fim
Logo aps, realizado o teste de recuperao entre os indivduos atualmente infectados.
Em seguida, realiza-se o teste de mortalidade para os indivduos da populao. Os algoritmos
11 e 12 mostram, respectivamente, essas duas etapas:
Algoritmo 11: Teste de recuperao entre os indivduos infectados.
incio
(apenas as threads que possuem id < TAM_POP realizam o teste de recuperao
para o indivduo em questo, d_pop(id))
se d_pop(id) = I ento
(se verdadeiro, ento admite-se que o indivduo infectado est livre da
doena)
se d_recuperados(id) < recuperacao ento
d_pop(id) R
fim se
fim se
fim se
fim
29
Algoritmo 12: Teste de mortalidade entre os indivduos da populao.

incio
(apenas as threads que possuem id < TAM_POP realizam o teste de morte para o
indivduo em questo, d_pop(id))
(se verdadeiro, ento admite-se que o indivduo em questo veio a bito)
se d_mortos(id) < mortalidade ento
d_pop(id) S (admite-se que um novo indivduo nasce em seu lugar)
fim se
fim se
fim
Aps a execuo da ltima funo kernel, o fluxo de execuo do algoritmo retorna para o
cdigo do host. Ento, os dados processados no device so transferidos para a memria do host
para atualizao da populao, como mostra o algoritmo 13. A transferncia dos dados ocorre
atravs da chamada funo padro cudaMemcpy (definida na biblioteca <cuda_runtime.h>).
Para isso, utilizado um vetor auxiliar (h_pop) para receber os dados do vetor d_pop, alocado
na memria do device.
30
Algoritmo 13: Contagem do nmero de indivduos.

incio
h_pop d_pop
(Contagem do nmero de indivduos em cada uma das classes S, I e R ao final de
cada iterao)
N_S_CPU 0 (quantidade de indivduos suscetveis - IBM-C)
N_I_CPU 0 (quantidade de indivduos infectados - IBM-C)
N_R_CPU 0 (quantidade de indivduos recuperados - IBM-C)
N_S 0 (quantidade de indivduos suscetveis - IBM-CUDA)
N_I 0 (quantidade de indivduos infectados - IBM-CUDA)
N_R 0 (quantidade de indivduos recuperados - IBM-CUDA)
(contagem dos indivduos - IBM-C)
se h_pop_CPU(i) = S ento
N_S_CPU N_S_CPU + 1
seno
se h_pop_CPU(i) = I ento
N_I_CPU N_I_CPU + 1
seno
N_R_CPU N_R_CPU + 1
fim se
fim se
(contagem dos indivduos - IBM-CUDA)
se h_pop(i) = S ento
N_S N_S + 1
seno
se h_pop(i) = I ento
N_I N_I + 1
seno
N_R N_R + 1
fim se
fim se
fim para
fim
Por fim, a varivel que representa o nmero de iteraes somada com o valor de t
(deltaIBM) e verificado se essa varivel menor do que a quantidade total de iteraes a
serem realizadas (n_iteracoes). Se verdadeiro, ento uma nova iterao ser realizada. Seno,
o algoritmo finalizado.
A prxima seo ir mostrar os conceitos e detalhes sobre um algoritmo que possui a
capacidade de gerar, de forma paralela, diversas sequncias distintas de valores aleatrios.
4.3 Mersenne Twister - Um gerador de nmeros aleatrios
4.3
31
Mersenne Twister - Um gerador de nmeros aleatrios
Gerao de nmeros aleatrios uma operao importante para a cincia da computao e

bastante utilizada, por exemplo, em mtodos de simulaes Monte Carlo (mtodo estatstico
utilizado em simulaes no-determinsticas para obteno de aproximaes numricas de
funes complexas).
O Mersenne Twister (MT) um gerador de nmeros pseudo-aleatrios desenvolvido em
1998 pelos japoneses Matsumoto e Nishimura [32].
Um gerador de nmeros pseudo-aleatrios um algoritmo que gera uma sequncia de
nmeros, que so aproximadamente independentes uns dos outros.
A subseo 4.3.1 expe algumas vantagens e desvantagens deste algoritmo, e a subseo
4.3.2 mostra alguns detalhes de implementao.
J a subseo 4.3.3 mostra os detalhes sobre a funo RandomGPU, utilizada para a gerao
de nmeros aleatrios necessrios nos testes de infeco, recuperao e morte do IBM-CUDA.
importante ressaltar que, para uma perfeita compreenso desta seo, necessrio que o
leitor entenda conceitos de programao na linguagem computacional C.
O contedo aqui detalhado est fortemente baseado em [32], [33] e [34].
4.3.1
Prs e contras
O MT fornece uma rpida gerao de nmeros pseudo-aleatrios e foi projetado especificamente para corrigir muitas das falhas encontradas em algoritmos mais antigos. A verso mais
recente e mais usada, MT19937, gera uma sequncia de nmeros inteiros de 32 bits e possui
um perodo de 219937 - 1.
Um perodo, na rea da fsica, o tempo necessrio para que um movimento realizado por
um corpo volte a se repetir. Nesse contexto, o MT garante que um nmero aleatrio gerado
no ir se repetir antes de serem gerados 219937 - 1 nmeros. Alm disso, possui propriedades
importantes, tais como: uso eficiente de memria, boas propriedades de distribuio e alto
desempenho.
Atualmente, alm de ser considerado um gerador de nmeros aleatrios bastante conhecido,
o MT considerado o melhor algoritmo entre todos os geradores j implementados [32].
tambm considerado adequado para simulaes Monte Carlo. Alm disso, j foi aprovado em
vrios testes para aleatoriedade estatstica, incluindo os Diehard tests (uma bateria de testes
estatsticos para medio da qualidade de um gerador de nmeros aleatrios).
No entanto, o MT tem recebido algumas crticas no campo da cincia da computao. George Marsaglia, matemtico e cientista da computao americano, afirmou que da mesma forma
que o MT um timo gerador de nmeros aleatrios, ele deselegante e desnecessariamente
complexo para se trabalhar. Alm do mais, ele no considerado criptograficamente seguro.
Victor Podlozhnyuk [34] afirma que o MT no pretendido para aplicaes criptogrficas,
uma vez que n sadas do gerador suficiente para predizer todos os valores futuros.
32
4.3.2
Detalhes de implementao
O MT (verso MT19937) gera vetores de bits com tamanho fixo de 32-word (palavra de 32
bits) atravs da recorrncia:
upper
xk+n = xk+m + (xk

onde:
lower
|xk+1
)A,
(4.1)
n > m so inteiros fixos positivos;

xk , k = 0, 1, ..., uma sequncia de vetores de bits com largura fixa igual a w
(o qual 32 para esta verso);
upper
lower uma concatenao de r bits mais significativos de x e w r

| xk+1
xk
k
bits menos significativos de xk+1 ;
upper
(xk
Aww ;
lower ) A a multiplicao entre o vetor de bits concatenado e a matriz

| xk+1
Aww uma matriz de bits na seguinte forma:
0
1
0 0 ...
0
0
1 0 ...
0
0
0 1 ...
.
1
.
.
.
.
...
...
1
aw1 aw2 ...
a1 a0
onde a ltima linha da matriz,{aw1 , aw2 , ..., a1 , a0 }, chamada vetor a [34].

Como resultado da equao (4.1), em qualquer posio k n, xk a funo de trs
elementos de sequncia: xk = f (xkn , xkn+1 , xkn+m ), onde os n primeiros elementos, x0 , x1 ,
..., xn1 , so dados como sementes, isto , so dados como valores iniciais para inicializar o
estado do gerador a cada iterao.
Em termos de algoritmos, suficiente armazenar o estado do gerador, o qual um array
(vetor) com comprimento de n bits (state[0], state[1], ..., state[n 1]), inicializado com alguns
valores iniciais, x0 , x1 , ..., xn1 (sementes), e atualiz-lo a cada iterao.
O algoritmo se encaixa bem para o modelo de programao CUDA, pois ele usa uma
aritmtica bit a bit e uma quantidade arbitrria de escritas em memria [34].
Por um lado, o MT, como a maioria dos geradores de nmeros pseudo-aleatrios, iterativo.
Portanto, difcil de paralelizar uma nica etapa de atualizao do estado entre vrias threads
em execuo.
33
Por outro lado, na chamada de uma funo kernel, deve-se especificar uma quantidade
considervel de threads, a fim de fazer com que os cores de processamento da GPU sejam totalmente utilizados [34]. Dessa forma, existe a possibilidade de se obter uma melhor qualidade
nas propriedades de distribuio.
4.3.3
34
Implementao da funo RandomGPU
Algoritmo 14: Implementao da funo RandomGPU.

/ / W r i t e MT_RNG_COUNT v e r t i c a l l a n e s o f NPerRng random numbers t o * d_Random .
For c o a l e s c e d g l o b a l w r i t e s MT_RNG_COUNT s h o u l d be a m u l t i p l e o f warp
s i z e . I n i t i a l s t a t e s f o r e a c h g e n e r a t o r a r e t h e same , s i n c e t h e s t a t e s
are i n i t i a l i z e d from t h e g l o b a l seed . In order t o improve d i s t r i b u t i o n
p r o p e r t i e s on s m a l l NPerRng s u p p l y d e d i c a t e d ( l o c a l ) s e e d t o e a c h
t w i s t e r . The l o c a l s e e d s , i n t h e i r t u r n , can be e x t r a c t e d f r o m g l o b a l
s e e d by means o f any s i m p l e random number g e n e r a t o r , l i k e LCG .
_ _ g l o b a l _ _ v o i d RandomGPU ( f l o a t * d_Random , i n t NPerRng )
{
c o n s t i n t t i d = blockDim . x * b l o c k I d x . x + t h r e a d I d x . x ;
c o n s t i n t THREAD_N = blockDim . x * g r i d D i m . x ;
i n t i S t a t e , i S t a t e 1 , iStateM , iOut ;
u n s i g n e d i n t mti , mti1 , mtiM , x , mt [MT_NN ] ;
f o r ( i n t iRng = t i d ; iRng < MT_RNG_COUNT; iRng += THREAD_N)
{
/ / Load b i t v e c t o r Mersenne T w i s t e r p a r a m e t e r s
m t _ s t r u c t _ s t r i p p e d c o n f i g = ds_MT [ iRng ] ;
/ / I n i t i a l i z e current state
mt [ 0 ] = c o n f i g . s e e d ;
f o r ( i S t a t e = 1 ; i S t a t e < MT_NN; i S t a t e ++)
mt [ i S t a t e ] = ( 1 8 1 2 4 3 3 2 5 3U * ( mt [ i S t a t e 1 ] ^ ( mt [ i S t a t e 1 ]
>> 3 0 ) ) + i S t a t e ) & MT_WMASK;
i S t a t e = 0;
m t i 1 = mt [ 0 ] ;
f o r ( i O u t = 0 ; i O u t < NPerRng ; i O u t ++)
{
iState1 = i S t a t e + 1;
i S t a t e M = i S t a t e + MT_MM;
i f ( i S t a t e 1 >= MT_NN) i S t a t e 1 = MT_NN;
i f ( i S t a t e M >= MT_NN) i S t a t e M = MT_NN;
mti = mti1 ;
m t i 1 = mt [ i S t a t e 1 ] ;
mtiM = mt [ i S t a t e M ] ;
x
= ( m t i & MT_UMASK) | ( m t i 1 & MT_LMASK) ;
x
= mtiM ^ ( x >> 1 ) ^ ( ( x & 1 ) ? c o n f i g . m a t r i x _ a : 0 ) ;
mt [ i S t a t e ] = x ;
iState = iState1 ;
/ / Tempering t r a n s f o r m a t i o n
x ^= ( x >> MT_SHIFT0 ) ;
x ^= ( x << MT_SHIFTB ) & c o n f i g . mask_b ;
x ^= ( x << MT_SHIFTC ) & c o n f i g . mask_c ;
x ^= ( x >> MT_SHIFT1 ) ;
/ / C o n v e r t t o ( 0 , 1 ] f l o a t and w r i t e t o g l o b a l memory
d_Random [ iRng + i O u t * MT_RNG_COUNT] = ( ( f l o a t ) x + 1 . 0 f ) /
4294967296.0 f ;
}
}
}
35
O algoritmo 14 acima mostra a implementao da funo kernel RandomGPU. Como

afirmado na subseo 4.3.1, o cdigo para a implementao dessa funo bastante complexo.
Esse um cdigo padro utilizado para a gerao de nmeros aleatrios atravs dos cores de
processamento de GPUs.
O parmetro de entrada d_Random, no algoritmo 14, um ponteiro que aponta para a
mesma posio de memria apontada pelo ponteiro passado como argumento na chamada da
funo. Em outras palavras, d_Random representa o vetor que conter os nmeros aleatrios
gerados.
Como cada thread executa a funo de forma independente, a varivel iRng, no lao de
repetio f or mais externo, inicialmente recebe o global ID (identificador global) da thread em
questo e varia de T HREAD_N em T HREAD_N at que a condio iRng < MT_RNG_COUNT
seja falsa. A constante T HREAD_N sempre ser igual ao nmero de threads por block vezes o
nmero total de blocks (blockDim.x * gridDim.x), e a constante MT_RNG_COUNT (declarada
na classe MersenneTwister.h) definida, por padro, como sendo igual a 4.096 (tamanho
mximo permitido), podendo ser alterada conforme a necessidade.
J a condio iOut < NPerRng, no segundo lao de repetio f or mais interno, indica que
cada thread gera, em cada iterao do f or mais externo, NPerRng nmeros aleatrios no vetor
d_Random.
Como resultado, foi possvel perceber que a escolha de valores para o parmetro de entrada
NPerRng e para a constante MT_RNG_COUNT de extrema importncia, pelo fato de interferir
diretamente na quantidade de nmeros aleatrios a serem gerados e na qualidade dos resultados
das simulaes.
Para uma populao com 1.000 indivduos, por exemplo, ao setar NPerRng como sendo
igual a 100 e MT_RNG_COUNT igual a 10 possvel obter 1.000 nmeros aleatrios no vetor
d_Random. Porm, os resultados obtidos no so muito similares em comparao com os
mesmos resultados obtidos p
com o IBM-C. Nesse caso, na chamada da funo RandomGPU
1.000 (arredondado para cima) = 6 blocks com 6 threads cada,

foi especificado um total de
obtendo um total de 36 threads. Apenas as threads com o seu global ID igual a 0, 1, 2, ...,
9 realizam os passos da funo, isto , as threads com seu identificador global maior do que
9 no satisfazem a condio iRng < MT_RNG_COUNT. Portanto, essas threads finalizam sua
execuo rapidamente, no contribuindo no processo de gerao de nmeros aleatrios.
Devido ao fato de apenas 10 threads realizarem os passos da funo, sendo cada uma
responsvel pela gerao de 100 nmeros aleatrios no vetor d_random, o estado do gerador
atualizado apenas 10 vezes, o que ocasiona em uma m qualidade nas propriedades de
distribuio da gerao dos nmeros aleatrios. Com isso, os resultados obtidos com a
simulao do IBM-CUDA tendem a se afastar dos mesmos resultados obtidos com a simulao
do IBM-C.
Setando a constante MT_RNG_COUNT como sendo igual a 20, mantendo o parmetro de
entrada NPerRng igual a 100, e especificando o mesmo nmero de blocks e threads por block,
por exemplo, foi possvel obter resultados muito similares em comparao com os mesmos
resultados obtidos com o IBM-C. Isso ocorre porque o estado do gerador, nesse caso, foi
atualizado duas vezes mais, o que implica em uma melhor qualidade nas propriedades de
distribuio da gerao dos nmeros. Embora nesse caso sejam gerados 2.000 nmeros no
36
vetor d_Random, apenas 1.000 nmeros sero utilizados, devido ao fato de ser atribudo um
nico nmero para cada indivduo da populao a cada chamada da funo RandomGPU.
Em CUDA, existem algumas recomendaes de prioridade que devem ser levadas em
considerao. Para evitar a elevao de latncia entre as dependncias dos registradores, devese manter, pelo menos, 25% da utilizao total dos cores de processamento da GPU [19, 20].
Sendo assim, maximizando a utilizao dos cores de processamento possvel obter um melhor
desempenho em relao ao tempo computacional.
Alm disso, o nmero de threads por block deve ser um mltiplo de 32, porque isso
fornece uma melhor eficincia de computao e facilita a coalescncia (combinao de parties
adjacentes de memria). No vivel ter 5 blocks de 512 threads cada ou 1.000 blocks de 10
threads cada, por exemplo [19].
Ainda, o comentrio em ingls no incio do algoritmo 14 enfatiza que, para uma coalescncia de escritas em memria, a constante MT_RNG_COUNT deve ser um nmero mltiplo de
tamanho de um warp. Um warp uma unidade de escalonamento de thread em um core de
processamento (streaming multiprocessor) [23].
Portanto, percebe-se que a escolha do valor para NPerRng e MT_RNG_COUNT deve
estar relacionado com o nmero total de threads para se obter uma melhor qualidade nas
propriedades de distribuio da gerao dos nmeros aleatrios.
37
RESULTADOS
Com o intuito de se estabelecer comparaes com os resultados obtidos atravs do modelo

SIR, a seo 5.1 exibe os grficos que apresentam os resultados de trs simulaes para o IBMC e para o IBM-CUDA. Essas simulaes foram realizadas com diferentes valores de tamanho
da populao (N) e diferentes passo de tempo entre as iteraes (t). Para todos os casos,
as trajetrias referentes ao IBM-C e ao IBM-CUDA consistem na mdia de 10 realizaes da
simulao.
J a seo 5.2 apresenta uma avaliao do ganho computacional obtido atravs da implementao IBM-CUDA.
5.1
Validao das implementaes IBM-C e IBM-CUDA
Em todos os casos, os modelos foram configurados de modo a obter equivalncia com o

modelo SIR utilizando os seguintes valores de parmetros:
a) = 0,005; (Taxa de natalidade = Taxa de mortalidade)
b) = 0,8; (Taxa de infeco)
c) = 0,067; (Taxa de recuperao)
d) S(0) = 90% dos indivduos da populao so inicialmente suscetveis;
e) I(0) = 10% dos indivduos da populao so inicialmente infectados;
f) R(0) = 0% dos indivduos da populao so inicialmente recuperados.
Com o intuito de validar as implementaes IBM-C e IBM-CUDA, os resultados de
simulao obtidos foram confrontados com os do modelo SIR equivalente.
Todos os testes foram executados em duas mquinas distintas. A primeira mquina utilizada
foi denominada Quadro FX 5800. Segue abaixo as configuraes desta mquina:
a) Processador Intelr Xeon CPU X5670 @ 2.93 GHz (2 processadores);
b) 20 GB de memria RAM instalada;
c) 1,21 TB de HD;
d) Windows 7 Ultimate, 64 Bits;
e) Placa de vdeo NVIDIA Quadro FX 5800, 240 CUDA cores, 4 GB Memory Size
Total, 102 GB/sec Memory Bandwidth.
Em cada simulao, o nmero de iteraes pode ser definido da seguinte maneira: 100
t [3].
Como mostra a figura 10, para o caso em que N = 1.000 e t = 3, executa-se um total de apenas
38
5.1 Validao das implementaes IBM-C e IBM-CUDA
33 iteraes. Nesse caso, percebe-se um comportamento similar entre as curvas S, I e R dos

modelos SIR, IBM-C e IBM-CUDA. Porm, as curvas para os IBMs no ficam muito prximas
s curvas do SIR.
900
800
S: SIR
I: SIR
R: SIR
S: IBMC
I: IBMC
R: IBMC
S: IBMCUDA
I: IBMCUDA
R: IBMCUDA
Nmero de indivduos
700
R
600
500
400
I
300
200
100
0
0
20
40
60
Nmero de iteraes
80
100
Figura 10: Quadro FX 5800 - Resultados de simulao realizada com uma populao de 1.000
indivduos e um incremento de tempo entre as iteraes igual a 3.
Analisando as curvas S, I e R para o IBM-C e IBM-CUDA, na figura 10, possvel perceber

um comportamento similar, mas em alguns pontos h alguma variao. A figura 11 mostra com
mais nfase a variao entre os resultados em cada uma das 10 simulaes realizadas:
39
800
Nmero de indivduos
700
600
S: IBMC
I: IBMC
R: IBMC
S: IBMCUDA
I: IBMCUDA
R: IBMCUDA
500
400
300
200
100
0
4
6
Nmero de simulaes
10
Figura 11: Variao dos resultados para as curvas das implementaes IBM-C e IBM-CUDA
com uma populao de 1.000 indivduos.
Conforme detalhado na seo 4.3 deste trabalho, a equivalncia entre as implementaes

IBM-C e IBM-CUDA est diretamente relacionada etapa de gerao de nmeros aleatrios,
utilizados nos processos de infeco, recuperao e morte.
Os nmeros aleatrios utilizados para as simulaes do IBM-C so gerados pela CPU. J os
nmeros aleatrios utilizados para as simulaes do IBM-CUDA so gerados atravs dos cores
de processamento das GPUs contidas em uma placa de vdeo. Portanto, os nmeros gerados
pela CPU podem diferir dos nmeros gerados por uma GPU, o que ocasiona em uma certa
variao entre os resultados.
Ainda, de acordo com a subseo 4.3.3, na etapa de gerao de nmeros aleatrios para
o IBM-CUDA deve-se atentar para a escolha de valores para os parmetros de entrada da
funo kernel RandomGPU. Alm disso, a especificao do nmero de threads na chamada
da funo tambm influencia nas propriedades de distribuio dos nmeros aleatrios. Para
maiores detalhes sobre o processo de gerao de nmeros aleatrios utilizados neste trabalho,
deve-se verificar os trabalhos de Matsumoto [32] e Podlozhnyuk [34].
Aumentando o nmero de indivduos de 1.000 para 5.000 e diminuindo o valor de t de 3
para 1,5, possvel perceber, atravs da figura 12, uma aproximao maior entre as curvas S, I
e R dos modelos:
40
4500
4000
Nmero de indivduos
3500
R
3000
2500
2000
I
1500
S: SIR
I: SIR
R: SIR
S: IBMC
I: IBMC
R: IBMC
S: IBMCUDA
I: IBMCUDA
R: IBMCUDA
1000
500
0
0
20
40
60
Nmero de iteraes
80
100
indivduos e um incremento de tempo entre as iteraes igual a 1,5.
No ltimo caso, para N = 15.000 e t = 0,3, mostrado pela figura 13, nota-se uma
aproximao ainda maior entre as curvas, sendo que os resultados para o IBM-C e IBM-CUDA
se tornam to prximos do modelo SIR de tal forma que as curvas para o SIR quase no podem
ser visualizadas.
41
14000
Nmero de indivduos
12000
10000
8000
6000
I
4000
S: SIR
I: SIR
R: SIR
S: IBMC
I: IBMC
R: IBMC
S: IBMCUDA
I: IBMCUDA
R: IBMCUDA
2000
0
0
20
40
60
Nmero de iteraes
80
100
Como pode ser observado atravs dos grficos, os resultados obtidos com o IBM-C e IBMCUDA tendem a se aproximar daqueles gerados pelo modelo SIR medida que N aumenta
e t diminui. Isso ocorre devido ao fato de que quanto menor o valor para t, maior ser o
nmero de iteraes. Portanto, existe uma maior probabilidade de os resultados gerados pelo
IBM se aproximarem dos resultados gerados pelo SIR, desde que os valores definidos para os
parmetros do algoritmo estejam de acordo com a subseo 2.2.3 deste trabalho.
A segunda mquina utilizada foi denominada GeForce GT 240. As configuraes desta
mquina so:
a) Processador core i7 860 @ 2.80 GHz;
b) 4,0 GB de memria RAM instalada;
c) 100 GB de HD;
d) Windows 7 Professional, 64 Bits;
e) Placa de vdeo NVIDIA GeForce GT 240, 96 CUDA cores, 1 GB Standard
memory config, 54.4 GB/sec Memory Bandwidth.
As figuras 14, 15 e 16 apresentam, respectivamente, os resultados de simulao realizada
com os mesmos valores de parmetros utilizados nas figuras 10, 12 e 13. Nota-se que os testes
executados em ambas as mquinas forneceram resultados muito similares.
42
900
800
S: SIR
I: SIR
R: SIR
S: IBMC
I: IBMC
R: IBMC
S: IBMCUDA
I: IBMCUDA
R: IBMCUDA
Nmero de indivduos
700
R
600
500
400
I
300
200
100
0
0
20
40
60
Nmero de iteraes
80
100
Figura 14: GeForce GT 240 - Resultados de simulao realizada com uma populao de 1.000
indivduos e um incremento de tempo entre as iteraes igual a 3.
4500
4000
Nmero de indivduos
3500
R
3000
2500
2000
I
1500
S: SIR
I: SIR
R: SIR
S: IBMC
I: IBMC
R: IBMC
S: IBMCUDA
I: IBMCUDA
R: IBMCUDA
1000
500
0
0
20
40
60
Nmero de iteraes
80
100
43
5.2 Avaliao do ganho computacional proporcionado pelo IBM-CUDA
14000
Nmero de indivduos
12000
10000
8000
6000
I
4000
S: SIR
I: SIR
R: SIR
S: IBMC
I: IBMC
R: IBMC
S: IBMCUDA
I: IBMCUDA
R: IBMCUDA
2000
0
0
20
40
60
Nmero de iteraes
80
100
A prxima seo apresenta uma comparao, em relao ao tempo computacional, entre

as implementaes IBM-C e IBM-CUDA. Alm disso, apresenta uma avaliao do ganho
computacional obtido atravs da implementao IBM-CUDA.
5.2
Avaliao do ganho computacional proporcionado pelo

IBM-CUDA
Aps a verificao de equivalncia entre os IBMs implementados e o modelo SIR, foram

realizadas simulaes com tamanhos diversos de populao. O intuito foi medir o desempenho
do processamento paralelo utilizando as GPUs das placas de vdeo.
Vale ressaltar que, para todas as simulaes, foram utilizados os mesmos valores de
parmetros mostrados na seo anterior.
44
A figura 17 apresenta uma comparao entre os tempos computacionais gastos, utilizando

as implementaes IBM-C e IBM-CUDA, para execuo nas mquinas Quadro FX 5800 e
GeForce GT 240:
Tempo mdio por iterao (segundos)
9 x 10
8
7
IBMC Quadro FX 5800

IBMCUDA Quadro FX 5800
IBMC GeForce GT 240
IBMCUDA GeForce GT 240
6
5
4
3
2
1
0
0
4
6
Nmero de indivduos
10
4
x 10
Figura 17: Tempo mdio por iterao para um comparativo entre IBM-C e IBM-CUDA.
Analisando a figura 17 possvel verificar que o IBM-C requer um esforo computacional
que aumenta de forma aproximadamente linear com o tamanho da populao. E, analisando a
curva que representa o tempo gasto pelo IBM-CUDA, observa-se que o tempo tambm aumenta
nesse caso, mas com taxa de crescimento menos expressiva.
Deve-se levar em considerao que, na mquina Quadro FX 5800, para populaes menores
que aproximadamente 20.000 indivduos o IBM-C apresenta um desempenho melhor que o
IBM-CUDA. J na mquina GeForce GT 240, o IBM-C se mostra mais rpido que o IBMCUDA para populaes menores que aproximadamente 25.000 indivduos. Isso ocorre devido
existncia de um overhead (processamento em excesso) de aproximadamente 1103 segundos
associado paralelizao das tarefas na placa de vdeo [3]. Portanto, dependendo da quantidade
de dados a serem processados em paralelo pelos cores de processamento de uma GPU, o
desempenho da CPU poder ser melhor processando os mesmos dados.
A tabela 1 apresenta os comparativos de velocidade com o intuito de se quantificar as
velocidades relativas de execuo entre as implementaes realizadas nas mquinas Quadro
FX 5800 e GeForce GT 240:
45
N indivduos
1.000
5.000
10.000
20.000
40.000
60.000
80.000
100.000
IBM-C Quadro FX
5800 (ms)
0,07227
0,34894
0,70443
1,41854
2,83053
4,25735
5,72074
7,01359
IBM-C GeForce GT
240 (ms)
0,08513
0,39025
0,76944
1,35474
3,01965
4,99490
7,75829
8,85114
IBM-CUDA Quadro FX 5800

(ms)
0,90939
1,12009
1,20152
1,37853
1,71945
2,08360
2,19347
2,91151
IBM-CUDA GeForce GT 240

(ms)
0,91779
1,40000
1,30000
1,77060
2,14680
2,82486
3,47336
5,28425
Tabela 1: Tempo (em milissegundos) mdio por iterao para cada uma das implementaes.
Atravs da prxima tabela, possvel verificar que a implementao IBM-CUDA, em
ambas as mquinas, apresenta um ganho de desempenho maior ao se comparar com a implementao IBM-C. Alm disso, o IBM-CUDA, na mquina Quadro FX 5800, apresenta um
desempenho computacional mais elevado.
Anlise
Base
Ganho mximo
Quadro FX 5800:
IBM-CUDA
Quadro FX 5800:
IBM-C
165,58%
GeForce GT 240:
IBM-CUDA
GeForce GT 240:
IBM-C
142,35%
Quadro FX 5800:
IBM-CUDA
GeForce GT 240:
IBM-CUDA
142,00%
Tabela 2: Comparativos de velocidade entre as implementaes realizadas.

Como resultado, percebe-se que o IBM-CUDA seria uma implementao mais apropriada,
do ponto de vista computacional, desde que o tamanho da populao empregado seja suficientemente grande para justificar o overhead gasto na paralelizao [3].
importante destacar que todos os testes realizados neste trabalho foram realizados com
base nos testes realizados no trabalho de Galvo Filho [3], onde o intuito foi melhorar o tempo
computacional.
A figura 18 mostra o fluxograma utilizado para as simulaes do IBM implementado no
trabalho de Galvo Filho [3]:
46
Incio
Sorteia pares da
populao
No
um par S-I?
Sim
Teste de
infeco
X < Xi
Sim
No
Sorteio de
indivduos para
recuperao
Gera nascimentos
e mortes
t t +t
No
t < tf
Sim
Fim
Figura 18: Fluxograma para simulao do IBM homogneo [3].
Comparando a figura 18 com a figura 2 (mostrada na subseo 2.2.2), possvel verificar

algumas diferenas de implementao. Assim como na figura 2, os blocos destacados em cinza,
na figura 18, so referentes s partes que foram implementadas aplicando-se processamento
paralelo.
47
Na figura 18, as etapas de gerao dos indivduos da populao e gerao de nmeros

aleatrios, apesar de no constarem no fluxograma, foram realizadas de forma sequencial pela
CPU. Para o teste de infeco, realizado um sorteio de pares de indivduos. Para cada par,
verifica-se se um indivduo suscetvel e o outro infectado. Caso essa condio seja verdadeira,
realiza-se um teste de infeco com base em uma probabilidade de infeco (Pin f ec ). Nas etapas
de recuperao e gerao de nascimentos e mortes, o procedimento ocorre de forma anloga ao
procedimento descrito na subseo 2.2.2 deste trabalho.
No IBM implementado neste trabalho, foi aplicado o recurso de processamento paralelo nas
etapas de gerao dos indivduos da populao e gerao de nmeros aleatrios. Alm disso,
foi aplicada uma estratgia na especificao do nmero total de threads, na chamada de
uma
funo kernel. Nessa estratgia, o resultado da raiz quadrada do tamanho da populao ( N)
define o nmero de blocks e threads por block a serem executados em paralelo pelos cores de
processamento das GPUs. Sendo assim, foi possvel obter um melhor aproveitamento dos cores
de processamento de uma GPU e uma melhora em relao ao tempo total de processamento das
simulaes, devido ao fato de se levar em considerao algumas recomendaes de prioridade
descritas em CUDA C Programming Best Practices Guide [19].
48
6.1
CONCLUSES
Consideraes finais
Neste trabalho, foi utilizado um algoritmo para simulao de epidemias em populaes

homogneas. Tal algoritmo considerado um Modelo Baseado em Indivduos (Individuals
Based Model, IBM), no qual o tamanho da populao considerado constante durante todo o
processo de simulao e cada indivduo composto por uma nica caracterstica: suscetvel
doena sob anlise, infectado ou recuperado.
importante ressaltar que o modelo est limitado pelas hipteses que regem o mesmo. O
modelo aqui estudado no incorpora transmisso vertical da doena, transmisso de imunidade
nem variao nos valores dos parmetros.
A simulao de um IBM, dependendo do tamanho da populao, pode levar um custo
computacional elevado, o que justifica a tentativa de se utilizar o poder computacional proporcionado por uma GPU. Utilizando a arquitetura CUDA, explorou-se o uso da capacidade
de processamento paralelo fornecido por GPUs para paralelizao das etapas envolvidas na
simulao do IBM.
importante destacar que a implementao do IBM empregado neste trabalho foi consideravelmente simples. Alm disso, o intuito da implementao foi de obter uma comparao direta com o modelo SIR (Suscetvel-Infectado-Recuperado) para fins de validao das
implementaes realizadas. Foram realizadas duas implementaes de um IBM homogneo,
sendo uma implementao inteiramente sequencial (IBM-C) e uma implementao paralelizada
(IBM-CUDA).
Para fins de comparao, as mesmas simulaes foram realizadas em duas mquinas com
configuraes distintas. Concluiu-se que uma placa de vdeo que contm um nmero maior de
cores de processamento apresenta um maior poder computacional.
Com base nos resultados obtidos, foi possvel afirmar que houve, de fato, ganhos de
processamento ao se utilizar o paradigma de programao paralela para a simulao do IBM
implementado. Tambm, foi possvel perceber que esses ganhos somente so obtidos quando
o tamanho da populao empregado suficientemente grande para justificar um processamento
em excesso (overhead) associado paralelizao das tarefas na placa de vdeo.
6.2 Propostas para trabalhos futuros
6.2
49
Propostas para trabalhos futuros
Em trabalhos futuros, pretende-se explorar o processamento em GPUs para implementao

de um IBM que leva em considerao aspectos de heterogeneidade da populao. Neste caso,
diferentemente de um IBM homogneo, um indivduo ser considerado como sendo um vetor
de n caractersticas, levando-se em considerao atributos tais como: idade, condio social,
condio de sade, entre outros. Adicionalmente, espera-se que os ganhos computacionais
proporcionados sejam ainda mais expressivos, devido necessidade de se tratar um indivduo
com vrias caractersticas.
Alm disso, pretende-se realizar um estudo mais profundo do algoritmo Mersenne Twister,
levando-se em considerao possveis alteraes no cdigo padro utilizado neste trabalho, afim
de obter uma viso mais clara das etapas de atualizao dos parmetros e das operaes bit a
bit. Sendo assim, acredita-se na possibilidade de obter melhores propriedades de distribuio na
gerao dos nmeros aleatrios e, consequentemente, espera-se obter, atravs de simulaes do
IBM-CUDA, resultados cada vez mais similares aos mesmos resultados obtidos com o IBM-C
e o modelo SIR.
50
Referncias Bibliogrficas
[1] PEREIRA, E. B. Modelos baseados em indivduos para anlise e controle de epidemias
em populaes heterogneas e metapopulaes. Dissertao de Mestrado Instituto
Tecnolgico de Aeronutica, So Jos dos Campos, SP, 2008.
[2] ARRUDA, F. D. B. Simulao de modelos baseados em indivduos para epidemiologia.
Trabalho de graduao Instituto Tecnolgico de Aeronutica, So Jos dos Campos,
SP, 2009.
[3] FILHO, A. R. G.; ARRUDA, F. D. B.; GALVAO, R. K. H.; YONEYAMA, T. Programao
paralela cuda para simulao de modelos epidemiolgicos baseados em indivduos.
Simpsio Brasileiro de Automao Inteligente (SBAI), 2011.
[4] CUDAT M , N. Nvidia cuda c programming guide. 4.0. ed. 2701 San Tomas Expressway
Santa Clara, CA 95050: NVIDIA Corporation, 2011.
[5] LAST, J. M. Dictionary of epidemiology. 1995.
[6] BARABASI, A. L.; OLTVAI, Z. N. Network biology: understanding the cells functional
organization. Nature Rev. Genetics, v. 5, p. 101113, feb 2004.
[7] ANDERSON, R. M.; MAY, R. M. Infectious diseases of humans: Dynamics and control.
Oxford University Press, 1992.
[8] HETHCOTE, H. W. The mathematics of infectious diseases. Society for Industrial and
Applied Mathematics, v. 42, p. 599653, 2000.
[9] CORLEY, C. D.; MIKLER, A. R. A computational framework to study public health
epidemiology. In: . c2009. p. 360363.
[10] APOLLONI, A.; KUMAR, A. V. S.; MARATHE, M. V.; SWARUP, S. Computational
epidemiology in a connected world. Computer, v. 42, p. 8386, 2009.
[11] FERREIRA, A. B. H. Novo dicionrio da lngua portuguesa. 2a . ed. Rio de Janeiro: Nova
Fronteira, 1986.
[12] GRIMM, V.; RAILSBACK, S. F. Individual-based modeling and ecology: (princeton
series in theoretical and computational biology). Princeton University Press, 2005.
[13] VIEIRA, A. L.; TAKAHASHI, L. T.
Biomatemtica, v. 19, p. 109124, 2009.
A sobrevivncia do vrus varicela-zoster.
[14] BARROS, L. C.; DE OLIVEIRA, R. Z. G.; LEITE, M. B. F.; BASSANEZI, R. C.

Modelo sis com dinmica vital e populao total no constante baseado em regras fuzzy.
Biomatemtica, v. 18, p. 8190, 2008.
51
[15] GRIMM, V.; BERGER, U.; BASTIANSEN, F.; ELIASSEN, S.; GINOT, V. A standard
protocol for describing individual-based and agent-based models. Ecological Modelling,
v. 198, p. 115126, september 2006.
[16] YANG, H. M. Epidemiologia matemtica - estudo dos efeitos da vacinao em doenas
de transmisso direta. Editora da Unicamp, 2001.
[17] NEPOMUCENO, E. G. Dinmica, modelagem e controle de epidemias. 2005. Thesis
(PhD) - Universidade Federal de Minas Gerais, Belo Horizonte, MG, 2005.
[18] TUNG, K. K. Topics in mathematical modelling. Princeton University Press, 2007.
[19] CUDAT M , N. Nvidia cuda c programming best practices guide.
Expressway Santa Clara, CA 95050: NVIDIA Corporation, 2009.
2701 San Tomas
[20] CUDAT M , N. Nvidia cuda curand library. 2701 San Tomas Expressway Santa Clara, CA
95050: NVIDIA Corporation, 2010.
[21] KIRK, D.; MEI HWU, W. Chapter 1: Introdution. David Kirk/NVIDIA and Wen-mei
Hwu, 2008. This is a draft chapter from an upcoming CUDA textbook by David Kirk from
NVIDIA and Prof. Wen-mei Hwu from UIUC.
[22] KIRK, D.; MEI HWU, W. Chapter 2: Cuda programming model. David Kirk/NVIDIA
and Wen-mei Hwu, 2008. This is a draft chapter from an upcoming CUDA textbook by
David Kirk from NVIDIA and Prof. Wen-mei Hwu from UIUC.
[23] KIRK, D.; MEI HWU, W. Chapter 3: Cuda threads. David Kirk/NVIDIA and Wen-mei
Hwu, 2008. This is a draft chapter from an upcoming CUDA textbook by David Kirk from
NVIDIA and Prof. Wen-mei Hwu from UIUC.
[24] KIRK, D. B. Nvidia cuda software and gpu parallel computing architecture. NVIDIA
Corporation, 2006-2008.
[25] PATTERSON, D. A.; HENNESSY, J. L. Organizao e projeto de computadores. 3. ed.
CAMPUS, 2005.
[26] ARRUDA, F.
O que a tecnologia de processamento grfico cuda.
http://www.tecmundo.com.br/10507-o-que-e-a-tecnologia-de-processamento-graficocuda.htm, jun 2011.
[27] MORIMOTO, C. E.
Opencl, cuda, brook: processamento usando a gpu.
http://www.hardware.com.br/dicas/opencl.html, aug 2009.
[28] TSUCHIYAMA, R.; NAKAMURA, T.; IIZUKA, T.; ASAHARA, A.
programming book. Fixstars Corporation, 2010.
The opencl
[29] KARIMI, K.; DICKSON, N. G.; HAMZE, F. A performance comparison of cuda and
opencl. D-Wave Systems Inc., 2010.
[30] PAMPLONA, V. Cuda. http://vitorpamplona.com/wiki/Cuda, Dec. 2008.
[31] CPLUSPLUS.COM COMPANY. rand function. http://www.cplusplus.com/reference
/clibrary/cstdlib/rand, Dec. 2011.
52
[32] MATSUMOTO, M.; NISHIMURA, T.

Mersenne twister: A 623-dimensionally
equidistributed uniform pseudorandom number generator. ACM Trans. on Modeling and
Computer Simulation, v. 8, n. 1, jan 1998.
[33] MATSUMOTO, M. Mersenne twister home page: A very fast random number generator of
period 219937 - 1. http://www.math.sci.hiroshima-u.ac.jp/ m-mat/MT/emt.html, jan 2011.
[34] PODLOZHNYUK, V. Parallel mersenne twister. 2701 San Tomas Expressway Santa
Clara, CA 95050: NVIDIA Corporation, 2007.

TCC Libre

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

TCC Libre

Enviado por

Direitos autorais:

Formatos disponíveis

PONTIFCIA UNIVERSIDADE CATLICA DE GOIS

PROGRAMAO PARALELA CUDA PARA SIMULAO

LAURO CSSIO MARTINS DE PAULA

PONTIFCIA UNIVERSIDADE CATLICA DE GOIS

PROGRAMAO PARALELA CUDA PARA SIMULAO DE MODELOS

Trabalho de Concluso de Curso apresentado por Lauro Cssio

PROGRAMAO PARALELA CUDA PARA SIMULAO DE MODELOS

LAURO CSSIO MARTINS DE PAULA

Prof. Esp. Jeov Martins Ribeiro

Prof. Dr. Clarimar Jos Coelho

M.Sc. Arlindo Rodrigues Galvo Filho

Esp. Daniel Vitor de Lucena

M.Sc. Wagner Oliveira de Arajo

CIP CATALOGAO NA PUBLICAO

Deus pela f e sabedoria fornecidas constantemente.

Descobri como bom chegar quando se tem pacincia.

Palavras-Chave: Epidemiologia matemtica, modelo baseado em indivduos, modelo SIR,

Key-Words: Mathematical epidemiology, model based on individuals, SIR model, parallel

Representao esquemtica do modelo SIR, conforme mostrado em [1], [2] e [3].

Fluxograma para simulao do IBM homogneo. . . . . . . . . . . . . . . . .

Comparao de capacidades de processamento entre CPUs e GPUs [4]. . . . .

Organizao de blocos em um grid [4]. . . . . . . . . . . . . . . . . . . . . . .

Hieraquia de memria [4]. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Fluxo de execuo no host e no device [4]. . . . . . . . . . . . . . . . . . . . .

Chamada s funes utilizadas no processo de simulao do IBM-C. . . . . . .

Chamada s funes utilizadas no processo de simulao do IBM-CUDA. . . .

Exemplo de 1024 threads distribudas em 32 blocks com 32 threads cada. . . .

Quadro FX 5800 - Resultados de simulao realizada com uma populao de

Quadro FX 5800 - Resultados de simulao realizada com uma populao de

Quadro FX 5800 - Resultados de simulao realizada com uma populao de

GeForce GT 240 - Resultados de simulao realizada com uma populao de

GeForce GT 240 - Resultados de simulao realizada com uma populao de

GeForce GT 240 - Resultados de simulao realizada com uma populao de

Tempo mdio por iterao para um comparativo entre IBM-C e IBM-CUDA. .

Fluxograma para simulao do IBM homogneo [3]. . . . . . . . . . . . . . .

Definio dos parmetros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Alocao de espao na memria. . . . . . . . . . . . . . . . . . . . . . . . . . .

Gerao dos indivduos da populao para o IBM-C. . . . . . . . . . . . . . . .

Gerao dos nmeros aleatrios. . . . . . . . . . . . . . . . . . . . . . . . . . .

Implementao da funo random. . . . . . . . . . . . . . . . . . . . . . . . . .

Realizao do teste de infeco. . . . . . . . . . . . . . . . . . . . . . . . . . .

Realizao do teste de recuperao. . . . . . . . . . . . . . . . . . . . . . . . .

Realizao do teste de mortalidade. . . . . . . . . . . . . . . . . . . . . . . . .

Gerao dos indivduos da populao para o IBM-CUDA. . . . . . . . . . . . .

Teste de infeco entre os indivduos suscetveis. . . . . . . . . . . . . . . . . .

Teste de recuperao entre os indivduos infectados. . . . . . . . . . . . . . . .

Teste de mortalidade entre os indivduos da populao. . . . . . . . . . . . . . .

Contagem do nmero de indivduos. . . . . . . . . . . . . . . . . . . . . . . . .

Implementao da funo RandomGPU. . . . . . . . . . . . . . . . . . . . . .

Lista de Abreviaturas e Siglas

Suscetvel, Infectado e Recuperado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

MODELOS MATEMTICOS PARA EPIDEMIOLOGIA

Modelo Baseado em Indivduos . . . . . . . . . . . . . . . . . . . . . . . . .

Algoritmo do IBM homogneo . . . . . . . . . . . . . . . . . . . . . .

Equivalncia entre o SIR e o IBM homogneo . . . . . . . . . . . . . .

PROCESSAMENTO PARALELO NA PLATAFORMA CUDA

CUDA - Uma arquitetura para computao paralela . . . . . . . . . . . . . . .

Kernels - Ncleos de processamento . . . . . . . . . . . . . . . . . . . . . . .

Hierarquia de threads e memria . . . . . . . . . . . . . . . . . . . . . . . . .

Detalhes de implementao do IBM-C . . . . . . . . . . . . . . . . . . . . . .

Detalhes de implementao do IBM-CUDA . . . . . . . . . . . . . . . . . . .

Mersenne Twister - Um gerador de nmeros aleatrios . . . . . . . . . . . . .

Implementao da funo RandomGPU . . . . . . . . . . . . . . . . .