1

Utilizao de Programao Concorrente em um Software para

Vinculao de Registros


RELATRIO FINAL DO PROJETO DE
INICIAO CIENTFICA (PIBIC/UERJ)


Ricardo Dionisio Ado (UERJ, Bolsista PIBIC/UERJ)
E-mail: ricardo_adao@gmx.com

Sergio Miranda Freire (DTIES/FCM/UERJ, Orientador)
E-mail: sergio@lampada.uerj.br




Julho de 2010.

2

1. INTRODUO
A vinculao de registros (record linkage, em ingls) uma metodologia para vincular
registros de dois ou mais arquivos de dados ou para encontrar duplicatas dentro de um
mesmo arquivo e um campo em crescente expanso com aplicaes em muitas reas
da sade. H muitos trabalhos publicados sobre mtodos para vinculao de registros de
bases de dados em lngua inglesa e poucos utilizando bases com nomes e endereos
brasileiros. No Brasil, j existe um software de domnio pblico para a vinculao de
registros, denominado reclink (Camargo e Coeli, 2000) que, apesar de sua utilidade para
a vinculao de bases de pequeno porte, possui algumas limitaes que dificultam a sua
utilizao em cenrios onde se deseja trabalhar com grandes bases de dados ou quando
se deseja vincular um nmero grande de bases separadas. Este projeto visa a
desenvolver um framework de cdigo aberto que implemente as tcnicas de vinculao
probabilsticas e possa ser utilizado nas situaes apontadas acima.


2. OBJETIVO
O objetivo deste trabalho de iniciao cientfica o de investigar a utilizao de
programao concorrente no VincReg de modo a tornar o processo de vinculao de
registros mais eficiente. Como os processadores atuais possuem mais de 2 ncleos e os
servidores possuem mais de um processador (que por sua vez podem ter mais de um
ncleo tambm), partes do processamento podem ser paralelizadas com a utilizao da
programao concorrente.

3. METODOLOGIA
3.1 Atividades do projeto
As atividades desenvolvidas no projeto de Iniciao Cientfica foram:
- fazer um estudo do mtodo probabilstico para vinculao de registros;
- estudar a linguagem Java, e o uso de sua API de concorrncia e posteriormente,
fazer uso dela na implementao do framework;
O processo de vinculao, implementado no VincReg, e na maioria dos
softwares de vinculao de registros, possui as seguintes etapas (figura 1):
- Padronizao dos arquivos
Neste processo criado um novo arquivo com campos do arquivo original que so
selecionados e processados de acordo com diversas transformaes que podem ser
efetuadas sobre os mesmos, por exemplo: seleo de partes de uma string, formatao
de datas, separao das partes de um nome e fonetizao destas partes, etc.


3

- Blocagem
Esta a parte onde so criados blocos lgicos, onde somente os registros contidos
nesses blocos so comparados. Isto feito para evitar um excesso de comparaes.
Assim, por exemplo, uma chave de blocagem poderia ser o primeiro nome de uma
pessoa e o sexo. Desta forma somente os pares de registros com o mesmo primeiro
nome e o mesmo sexo seriam comparados para se determinar se seriam pares
verdadeiros ou no.





















Figura 1. Etapas da Vinculao de Registros
Banco de
Dados
Original 2
Banco de
Dados
Original 1

Padronizao
dos
Arquivos


Banco de
Dados
Padronizado
1
Banco de
Dados
Padronizado
2
Blocagem e
Pareamento
(Comparao e
Classificao)


Par
Verdadeiro

Possvel
Par
Verdadeiro


Par
Falso

4

- Pareamento dos registros
Aqui onde ocorre a comparao e a classificao dos pares. O VincReg implementa o
mtodo de Fellegi-Sunter (Fellegi e Sunter, 1969) para estimar o escore para cada par
de registros. Segundo este mtodo, o escore dado pela frmula:
Escore =
)) 1 ( ( ) (
i i
i
i i
wd wc o o - + -

Onde:
i = cada varivel usada para comparao de dois registros;
wc
i
= fator de ponderao de concordncia
wd
i
= fator de ponderao de discordncia
o
i
= 1 se houver concordncia entre os dois registros para a varivel i, 0 caso
contrrio.

O fator de ponderao de concordncia calculado como o logaritmo de base 2
da razo de verossimilhana entre m
i
e u
i
, segundo a frmula:

|
|
.
|

\
|
=
i
i
i
u
m
wc
2
log

O fator de ponderao de discordncia calculado como o logaritmo de base 2
da razo de verossimilhana entre 1-m
i
e 1-u
i
, segundo a frmula:
|
|
.
|

\
|

=
i
i
i
u
m
wd
1
1
log
2

m
i
a probabilidade de a varivel i concordar nos dois registros, uma vez que os dois
registros formam um par verdadeiro e

u
i
a probabilidade de a varivel i concordar nos
dois registros, dado que os dois registros no formam um par verdadeiro. Estes
parmetros podem ser estimados a partir da literatura, a partir de um conjunto de dados
para os quais se conhece o status de par verdadeiro ou falso para cada par de registros,
ou utilizando o algoritmo EM (Winkler, 2000).






5

3.2. Utilizao da programao concorrente
O tema desta pesquisa de iniciao cientfica estudar o cdigo-fonte do programa
VincReg e em seu cdigo, fazer uso da programao concorrente, aproveitando os
vrios ncleos e/ou processadores que os computadores atuais possuem.

Thread e Multithreading
Por meio de uma thread (que significa linha de execuo em portugus) vrias
instrues podem ser executadas em sequncia. Em Java, possvel que vrias threads
sejam executadas em paralelo (multithreading) repartidas nos processadores, o que pode
trazer um ganho considervel de desempenho.
Existem vrias maneiras de se criar as threads, entre elas, utilizando-se herana onde
definimos uma classe que estenda thread e que implemente o mtodo run (), como no
exemplo a seguir:
public class MyThread extends Thread {
public void run() {
//Aqui escrito o cdigo desejado
}
}

Para uma thread ser criada, declara-se um objeto de classe e o operador new para assim,
instanci-lo:
MyThread myThread1 = new MyThread ()

E por ltimo, para executar a instncia da thread, deve-se utilizar o mtodo start ():
myThread1.start ();

A API de concorrncia introduzida na verso 5 e 6 do Java possuem uma srie de
classes que facilitam a criao e o gerenciamento de threads. A seguir sero
apresentadas de maneira resumida as principais classes utilizadas no VincReg.

A classe Executor implementa a interface ExecutorService e permite a submisso de
threads que so executadas de maneira concorrente:
- SingleThreadExecutor: utiliza uma thread para executar atividades
seqencialmente.
- FixedThreadPool: utiliza um grupo de threads de tamanho fixo para executar
atividades.
- CachedThreadPool: cria threads sob demanda.

Exemplo:
ExecutorService exec = Executors.newCachedThreadPool();
for (int i=0; i<20; i++) {
// Cria e executa as thread
exec.submit(thread criada)
}

6

exec.shutdown();

A classe CyclicBarrier serve para trabalhar com sincronizao, fazendo com que as
threads esperem umas s outras em certo ponto da barreira. chamado de barreira
cclica porque depois de liberadas, podem ser reutilizadas.

A classe SwingWorker implementa as interfaces Runnable, Future<T> e
RunnableFuture<T> e possui o mtodo doInBackground() que deve ser implementado
para executar uma thread no plano de fundo numa interface grfica com o usurio
baseado no Swing.

Finalmente a classe LinkedBlockingQueue permite a implementao de problemas do
tipo produtor/consumidor de uma maneira bastante simples.

Paralelizao do VincReg

Nesta primeira implementao de concorrncia no VincReg, foi calculado o nmero de
processadores no computador para estabelecer o nmero de threads que seriam criadas
para realizar o processamento da vinculao de registros. As tabelas a serem
comparadas esto contidas num nico banco de dados (MySQL). O clculo do nmero
de processadores realizado pelo mtodo:

private int displayAvailableProcessors() {
Runtime runtime = Runtime.getRuntime();
int nrOfProcessors = runtime.availableProcessors();
return nrOfProcessors;
}

Uma classe que estende a classe SwingWorker (TableReadingDAO) realiza a
leitura das tabelas do banco de dados e, para cada par de registros a serem comparados,
monta um mapa com as variveis e os respectivos valores e coloca este mapa num
objeto da classe LinkedBlockingQueue. Estes mapas so extrados por instncias da
classe LinkageFS (que tambm estende SwingWorker) que realizam a comparao de
registros, geram uma lista com os resultados e a armazena num outro objeto do tipo
LinkedBlockingQueue. Finalmente, a classe ResultsStorageDAO extrai esta lista e
armazena os resultados no banco de dados, na tabela de resultados do processo de vinculao
para posterior classificao em pares verdadeiros e pares falsos.

Abaixo apresentado o cdigo principal do processo de vinculao, onde so
criadas as threads de leitura e armazenamento no banco e um nmero de threads
dependente do nmero de processadores que realizam o processamento dos pares de
registros extrados do banco de dados. Observe que uma barreira cclica criada no
incio com tamanho 2. A linha principal de execuo abaixo somente encerrada
quando a thread que armazena os resultados no banco de dados (resultsDAO) levanta a
barreira. Neste ponto todas as threads criadas anteriormente so fechadas.
int n = displayAvailableProcessors();
final CyclicBarrier barrier = new CyclicBarrier(2)
ExecutorService executorbackgroundExec = Executors.newCachedThreadPool()
long begin = System.currentTimeMillis();
phase = "linkage";
linkageConfig.createTableLinkagePairs();

7

SwingWorker<Void, Void> tableReadingDAO = linkageConfig.configureReading(1,
numberOfRecords, barrier);
ResultsStorageDAO resultsDAO = linkageConfig.getDao();
resultsDAO.addPropertyChangeListener(LinkageConfigurationControl.this);
backgroundExec.submit(resultsDAO);
backgroundExec.submit(tableReadingDAO);
for (int i = 1; i <= n; i++) {
linkage = linkageConfig.configureLinkage();
linkageList.add(linkage);
linkageFuture = backgroundExec.submit(linkage);
}
barrier.await();
backgroundExec.shutdown();

A classe LinkageFS realiza a comparao dos registros. Basicamente, ela retira uma
mapa da fila de dados a serem processados (dataQueue), faz a comparao, monta uma
lista com os resultados e a coloca na fila de resultados (resultsQueue). Ao retirar um
mapa vazio da fila de entrada, ela coloca uma lista vazia na fila de resultados e encerra
o processamento.
Map<String, Object> map = dataQueue.take();
while (!map.isEmpty()) {
ComparationResult eval = evaluator.evaluate(map);
storeLinkageTable(eval.getOverallResult(), map);
map = dataQueue.take();
if (map.isEmpty()) {
resultsQueue.put(new ArrayList<Object>());
}

Abaixo o cdigo simplificado do mtodo doInBackground da classe
TableReadingDAO. Ele varre as tabelas do banco de dados a serem vinculadas, cria o
mapa com os valores das variveis e o colocam na fila para processamento. Quando no
houver mais registros a serem comparados, ele coloca um mapa vazio na fila:
Linkable l;
while (((l = source.next()) != null) && !Thread.currentThread().isInterrupted()) {
blockedSource.block(l);
Linkable other;
while (((other = blockedSource.next()) != null)) {
Map<String, Object> map = new HashMap<String, Object>();
map.put("id1", (String) l.getField(sourceKey));
map.put("id2", (String) other.getField(blockedKey));
for (String s : comparisonFields) {
if (!s.equals(l.getKey())) {
map.put(s, (String) l.getField(s));
map.put(fieldMap.get(s), (String) other.getField(fieldMap.get(s)));
}
}
queue.put(map);
}
}
Map<String, Object> map = new HashMap<String, Object>();
queue.put(map);



8

Abaixo o cdigo simplificado do mtodo doInBackground da classe ResultsDAO. Ele
retira cada lista de resultados da fila e armazena no banco. Ao receber uma lista vazia,
ele levanta a barreira e encerra o processamento.
connection.setAutoCommit(false);
ps = connection.prepareStatement(query);
List<Object> list = queue.take();
while (!list.isEmpty()) {
int j = 1;
for (Object obj : list) {
if (obj instanceof Double) {
ps.setDouble(j++, (Double) obj);
} else {
ps.setString(j++, (String) obj);
}
}
ps.executeUpdate();
connection.commit();
list = queue.take();
}
}
barrier.await();

4. RESULTADOS OBTIDOS

No foi observado ganho de velocidade significativo no desempenho do processamento
de vinculao de registros ao introduzir a concorrncia. Como era de se esperar, o
tempo de leitura do banco de dados e, principalmente o tempo de gravao no banco de
dados bem maior do que o tempo de comparao dos pares de registros em si. Como
somente um banco de dados foi utilizado nesta primeira fase, o fato de se ter mais de
uma thread realizando o processamento no teve impacto no tempo total. Na sequncia
do projeto, o banco de dados ser replicado e este processamento ser repetido com dois
bancos de dados e, consequentemente, com duas threads acessando os banco.

5. AUTO AVALIAO DO BOLSISTA

Durante esse 1 ano de iniciao cientfica, foi estudada a linguagem de programao
Java e a programao concorrente dela para que houvesse condies de trabalhar com o
programa VincReg. A produo de pesquisa no foi a ideal porque no foi concludo
plenamente as metas da pesquisas porm mesmo assim, foi possvel desenvolver algo
durante esse tempo de pesquisa da iniciao cientfica, mesmo assim, foi possvel
ganhar uma maior proficincia em Java e tambm no uso da programao concorrente
disponvel na API da linguagem, alm de uma boa experincia em poder trabalhar com
um projeto de um software fazendo com que meu conhecimento acadmico fosse
bastante enriquecido.

6. AVALIAO DO BOLSISTA PELO ORIENTADOR

O aluno Ricardo Dionsio Ado teve o desempenho esperado de um aluno de Iniciao
Cientfica, tendo se dedicado s atividades com assiduidade e pontualidade.


9

BIBLIOGRAFIA


Camargo Jr. KR & Coeli CM (2000) Reclink: aplicativo para o relacionamento de bases
de dados, implementando o mtodo probabilistic record linkage. Cad. Sade
Pblica vol.16 n.2 Rio de Janeiro Apr./June.

Fellegi P e Sunter AB (1969). "A theory for record-linkage". Journal of the American
Statistical Association, 64:1183--1210.

Goetz B, Peierls T, Block J, Bowbeer J, Holmes D, Lea D, Java Concorrency in Prac-
tice, Addison-Wesley, 2006

Junior, Peter Jandl. Java: Guia do Programador Atualizado para Java 6. Editora
Novatec.

Oaks, Scott e Wong, Henry. Java Threads. Editora O'Reilly.

Winkler W (2000), Using the EM Algorithm for Weight Computation in the Fellegi-
Sunter Model of Record Linkage Research Report Series (Statistics #2000-05), Statisti-
cal Research Division, US Census Bureau, Washington DC 20233.