Algoritmos Paralelos em GPUs para Problemas de
Programao Quadrtica Binria Irrestrita
Eduardo Batista Gomes Moreira (Aluno)
Universidade Federal do ABC
Centro de Matemtica, Computao e Cognio
Santo Andr, So Paulo 09210580
Email: eduardo.moreira@ufabc.edu.br
Resumo - Este trabalho o resumo de uma dissertao1 de
mestrado, onde consideramos o problema de otimizao global:
maximize f (x) = xT Qx, onde x {0, 1}n e Q uma matriz
assimtrica de dimenso n n com coeficientes racionais. Este
problema comumente denominado problema de programao
quadrtica binria irrestrita (em ingls, Unconstrained binary
Quadratic Problem - UQP) e tem sido muito estudado nos
ltimos 50 anos. Este problema tem diversas aplicaes. Em
economia, um exemplo bem conhecido o de determinar um
portflio de investimento; uma aplicao tpica em estatstica
o problema de regresso linear; em otimizao combinatria,
uma aplicao o problema de encontrar um clique mximo
em um grafo. Nosso estudo se concentra: (1) no desenvolvimento
de implementaes paralelas de mtodos heursticos e exatos,
que objetivam resolver instncias do UQP e (2) na criao de
frmulas para recalcular o valor da funo objetivo, visto que o
desempenho das implementaes dependem significativamente da
quantidade de vezes que o valor da funo objetivo calculado.
Neste trabalho provamos um lower bound combinatrio, para um
branch and bound, melhor do que os encontrados na literatura
e apresentamos formas de reclculo mais eficientes para a
funo objetivo do UQP. As implementaes usam unidades
de processamento grfico (em ingls, Graphics Processing
Units - GPUs) e o ambiente de programao CUDA (Compute
Unified Device Architecture). Nossos resultados computacionais
sobre instncias do UQP, obtidas da literatura, evidenciam a
robustez e eficcia das nossas abordagens. Com os mtodos
heursticos tentamos resolver instncias com at 2.500 variveis
e com o mtodo exato foi possvel resolver instncias com
at 100 variveis. Em algumas das instncias testadas, as
implementaes de uma heurstica e de um mtodo exato foram
at 44 vezes e at 102 vezes, respectivamente, mais rpidas do
que as correspondentes verses sequenciais. Sem dvida, estas
so aceleraes significativas.
Palavras-chave: Otimizao Combinatria, Mtodo Exato, Heu-
rstica, Programao Quadrtica, CUDA.
Abstract - We consider the global optimization problem:
maximize f (x) = xT Qx, where x {0, 1}n and Q is an asym-
metric (n n)-matrix with rational coefficients. This problem
is commonly known as unconstrained binary quadratic problem
(UQP) and has been studied for at least 50 years. It has many
diverse applications. In economics, a well-known example arises
from portfolio theory; a typical application in statistics is the
linear regression problem; in combinatorial optimization, an
application is the problem of finding a maximum clique in a graph
(the maximum clique problem). Our work focus on: (1) parallel
1 A verso completa da dissertao encontra-se no link de Dissertaes
Defendidas em http://poscomp.ufabc.edu.br/
Cludio Nogueira de Meneses (Orientador)
Universidade Federal do ABC
Centro de Matemtica, Computao e Cognio
Santo Andr, So Paulo 09210580
Email: claudio.meneses@ufabc.edu.br
implementations of heuristic and exact methods to solve the
UQP and (2) finding closed formulae to recompute the objective
function values, since the performance of the implementations
depend on the number of times the objective function value
is computed. The implementations use modern programmable
Graphic Processing Units (GPU) and the NVIDIAs GPU pro-
gramming framework, Compute Unified Device Architecture
(CUDA). GPUs are SIMT (Single Instruction, Multiple Thread)
devices that are data-parallel. Our computational results were
done over a number of publically available data sets. The
heuristics methods were tested on instances involving up to 2,500
variables and the exact method was able to solve instances
with up to 100 variables. In some of the tested instances the
parallel implementations of a heuristic and of an exact method
were up to 44 times and up to 102 times, respectively, faster
than the corresponding sequential versions. Unquestionably, these
implementations produced impressive speedups.
Keywords: Combinatorial Optimization, Exact Method, Heuris-
tic, Quadratic Programming, CUDA.
I. I NTRODUO
Conforme Bixby [1], um problema de otimizao combi-
natria definido da seguinte maneira: Sejam E um conjunto
finito, S uma famlia de subconjuntos de E e w R|E| uma
funo peso de valores reais definida sobre os elementos de
E. O problema de otimizao combinatria associado tripla
(E, S, w) encontrar um conjunto S S tal que
w(S ) = max w(S)
SS
P
onde w(S) = w(e).
eS
Problemas de otimizao combinatria so estudados em
vrias reas de conhecimento como engenharia, administrao,
logstica, economia, biologia, finanas, marketing, planeja-
mento entre outras. Estas reas estudam maneiras para otimizar
suas operaes, mas comumente encontram dificuldades em
aplicar os modelos desenvolvidos a problemas reais, pois estes
envolvem muitas variveis de deciso.
Um problema de otimizao combinatria pode, normal-
mente, ser modelado de diversas maneiras. Para cada modelo
podem existir vrias tcnicas que melhor o resolve. Cabe
pessoa que est solucionando o problema decidir qual tcnica
e modelo utilizar. Estas vrias possibilidades podem tornar
difcil o processo de resoluo do problema. Portanto, seria
interessante desenvolver um modelo unificado, que pudesse re-
presentar diversos problemas de otimizao combinatria. Um
modelo deste tipo existe e definido como segue. O problema
quadrtico binrio irrestrito (em ingls, Unconstrained binary
Quadratic Program - UQP) pode ser escrito na forma:
max f (x) = xT Qx
sujeito a: x {0, 1}n
onde Q Qnn e f : {0, 1}n Q. Por Q e Qnn
queremos dizer: o conjunto dos nmeros racionais e o conjunto
das matrizes de coeficientes racionais de dimenso n n,
respectivamente. Em termos de complexidade computacional,
o UQP pertence a classe de complexidade NP-difcil, conforme
pode ser visto em [2].
Existem vrios mtodos que resolvem (i.e. mtodos exa-
tos), ou tentam resolver (i.e. mtodos heursticos), instncias
do UQP. Neste trabalho, desenvolvemos verses sequenciais
e paralelas de implementaes de mtodos para o UQP. As
verses paralelas utilizam unidades de processamento grfico
(em ingls, Graphics Processing Units - GPUs) da NVIDIA
e a arquitetura CUDA. GPUs so dispositivos com muitos
ncleos de processamento, que podem ser utilizados para
processamento paralelo.
A seguir apresentamos uma breve reviso da literatura
sobre mtodos heursticos e exatos que tratam o UQP.
II. T RABALHOS A NTERIORES
Nesta seo faremos uma reviso de alguns trabalhos que
tratam do UQP. As publicaes desta reviso so separadas de
acordo com o tipo de mtodo abordado, heurstico ou exato.
A. Mtodos Heursticos
Beasley [3] apresenta duas heursticas para tentar resolver
o UQP, um Tabu Search que se baseia em uma lista de
restries para tentar evitar que o mtodo fique preso em
um timo local e um Simulated Annealing, que um mtodo
evolutivo. Bahram et al. [4] apresentam vrias heursticas one-
pass para tentar resolver o UQP. Eles afirmam que estas
heursticas fornecem bons pontos de partida para mtodos mais
sofisticados. Merz e Freisleben [5] apresentam uma heurstica
gulosa e duas heursticas de busca local, 1-opt e k-opt, e
informam que estes mtodos tambm podem ser incorporados
a metaheursticas. Merz e Freisleben [6] descrevem um algo-
ritmo gentico. Eles afirmam que para instncias pequenas, um
crossover uniforme suficiente para encontrar solues timas
ou com valores iguais s melhores conhecidas. Para instncias
com mais de 200 variveis, se faz necessrio incorporar uma
estratgia de busca local. Bahram et al. [7] discutem o uso do
UQP como um framework para resoluo de vrios problemas.
Tais problemas so modelados na forma UQP e resolvidos
por um Tabu Search ou variaes deste mtodo. Em [8],
os autores apresentam o problema de colorao de vrtices
modelado como um UQP. Em [9], um novo modelo para o
Number Partitioning Problem estudado. Em [10], o problema
de encontrar um clique mximo, com peso nas arestas,
modelado com o framework proposto. Em [11], o problema
de encontrar conjuntos independentes generalizado escrito
na forma UQP.
B. Mtodos Exatos
Palubeckis [12] apresenta um algoritmo de busca em rvore
incorporando solues fornecidas por uma heurstica. Pardalos
e Rodgers [13] apresentam um mtodo Branch and Bound,
que usa limitantes baseados em fixao de variveis para
cada vrtice da rvore de enumerao. Billionet e Sutter [14]
descrevem um mtodo Branch and Bound. O limitante inferior
calculado em cada vrtice da rvore de busca em trs fases.
Helmberg e Rendl [15] apresentam um mtodo Branch and
Bound que combina Relaxao Semidefinida com a tcnica
de Plano de Corte. Pardalos e Rodgers [16] apresentam um
mtodo Branch and Bound, com seleo dinmica de variveis
para fixao, para resolver o problema de encontrar cliques m-
ximos. Embora o UQP pertena classe NP-difcil, algumas de
suas instncias podem ser resolvidas em tempo polinomial, em
relao ao nmero de variveis. Barahona [17], Chakradhar e
Bushnell [18], Gu [19] e Li et al. [20], discutem caractersticas
de tais instncias e mtodos para resolv-las.
C. Transformaes Gerais
Um fato que torna o UQP muito til o de que diversos
problemas de otimizao combinatria podem ser convertidos
em sua forma, via transformaes simples (ver referncias
[8], [9], [11], [10]). O que apresentamos nessa seo uma
sntese das transformaes utilizadas nestes trabalhos, de forma
padronizada.Isso pode, eventualmente, possibilitar ao leitor
deste trabalho, tentar converter outros problemas para a forma
UQP.
Transformao 1
Em muitos problemas de otimizao combinatria a funo
objetivo, ou parte dela, dada em uma
Pn forma linear com va-
riveis binrias: min / max aT x = i=1 ai xi , onde a Qn
n
e x {0, 1} . Por min / max queremos dizer que deseja-se
minimizar ou maximizar a funo.
Para converter estes problemas para o formato UQP, basta
utilizar o mesmo vetor x de variveis e construir a matriz
Q Qnn da seguinte forma: qi,j = ai se i = j e qi,j = 0
caso contrrio.
A prova de que o problema min / max aT x equivalente
ao problema min / max xT Qx, sendo Q uma matriz diagonal
contendo os valores qii = ai feita por meio dos seguintes
argumentos:
n X
X n
xT Qx = qi,j xi xj
i=1 j=1
Xn
aT x = ai xi
i=1
Como qi,j = 0 para i 6= j e x2i = xi pois xi {0, 1} para
1 i n, temos que
n X
n n n n
X X X X
qi,j xi xj = qi,i x2i = qi,i xi = ai xi
i=1 j=1 i=1 i=1 i=1
Transformao 2
Vrios problemas de otimizao combinatria podem ser
escritos na forma:
min / max xT Qx
sujeito a: Ax = b
onde x {0, 1}n , Q Qnn , A Qmn e b Qm .
A seguinte transformao consiste em adicionar uma fun-
o de penalidade funo objetivo. Isto , adicionando uma
funo de penalidade quadrtica multiplicada por um escalar
P , sendo P > 0 se o problema de minimizao e P < 0 se
o problema de maximizao [21]. O modelo resultante para
a transformao
min / max xT Qx + P (Ax b)T (Ax b)
onde x {0, 1}n .
Desenvolvendo xT Qx+P (Axb)T (Axb) obtemos uma
onde x {0, 1}n e Q
Qnn .
funo xT Qx
Transformao 3
Alguns problemas de otimizao combinatria possuem
restries do tipo: xi + xj 1 para 1 i, j n, com i 6= j e
x {0, 1}n . Neste caso adicionamos P xi xj funo objetivo
para 1 i, j n. Isto pode ser escrito usando uma matriz
simtrica D Qnn com coeficientes: di,j = 12 se existe a
restrio do tipo xi + xj 1, com i 6= j e di,j = 0 caso
contrrio. Ento, a Transformao 3 consiste em adicionar
xT P Dx funo objetivo.
Transformao 4
De forma similar ao que foi visto na Transformao 3,
podemos transformar restries da forma xi xj . Neste caso
precisamos adicionar funo objetivo o produto P xi (1xj ).
Definimos uma matriz simtrica M com coeficientes: mi,j = t
se i = j e existir a restrio xi xk , para algum k, mi,j = 21
se existir a restrio xi xj e mi,j = 0 caso contrrio. Onde
1 i, j, k n e t a quantidade de restries existentes para
xi . Exemplo: Se existirem duas restries para xi (xi xj e
xi xk ) ento t = 2.
Assim, a Transformao 4 consiste em adicionar xT P M x
funo objetivo.
Transformao 5
Suponha que o problema tem restries em variveis bin-
rias de forma que x {0, 1}nm . Neste caso x uma matriz
e a transformamos em um vetor da seguinte maneira:
x
k = x
(i1)m+j = xi,j (1 i n) e (1 j m) .
onde k = (i1)m+j. Esta transformao permite utilizar um
vetor, com as variveis de deciso, ao invs de uma matriz.
Transformao 6
H casos em que existem mais de um vetor de variveis
n m
binrias. Suponha que temos x {0, 1} e y {0, 1} . Po-
i = xi se 1 i n
demos associ-los da seguinte maneira: x
exi = yin se n + 1 i n + m.
De acordo com Kochenberger e Glover [7], sempre
possvel escolher um escalar P suficientemente grande ou
pequeno, de tal forma que o conjunto de solues timas so
iguais tanto para o problema original quanto para o problema
quadrtico, aps a sua transformao.
D. Mtodos Heursticos
Nesta seo descrevemos algumas heursticas que foram
adaptadas para tentar resolver instncias do UQP.
1) Tabu Search: Segundo Glover [22], o mtodo Tabu
Search (TS) uma estratgia que ajuda heursticas a escaparem
de timos locais, ao tentar resolver problemas de otimizao
combinatria. O TS impe restries para guiar o processo
de busca, com a finalidade de explorar regies difceis de se
alcanar por meio de heursticas. As restries de busca no
espao de solues no TS so criadas com o auxlio de uma
lista tabu. Uma lista tabu, L, para o UQP um vetor, com a
mesma quantidade de elementos que o vetor soluo x, onde
Li > 0 para 1 i n indica que o valor de xi no pode ser
modificado por uma quantidade K, constante pr-definida, de
iteraes.
O Algoritmo II.1 apresenta o esquema bsico do TS
sequencial. Neste algoritmo: Q a matriz de entrada para o
UQP, x representa uma soluo vivel para o problema, x
representa a melhor soluo encontrada pelo algoritmo, L
uma lista tabu e K um valor que representa a quantidade de
iteraes nas quais a varivel xi no sofrer alteraes.
O Algoritmo II.2 descreve o pseudo-cdigo do procedi-
mento BUSCA _ LOCAL _TS, que aparece em [3], chamado na
linha 25 do Algoritmo II.1. Nesta busca local usa-se a funo
de vizinhana 1-Flip. Uma vizinhana k-Flip de uma soluo
s formada por vetores que so diferentes de s em exatamente
k posies.
2) Gradient Midpoint Method: Pardalos et al. [23] apresen-
tam a heurstica Gradient Midpoint Method que utiliza infor-
maes do vetor gradiente de f (x) para gerar, rapidamente,
uma soluo para o UQP. Se considerarmos que deseja-se
minimizar a funo f (x) = xT Qx, calcula-se os limitantes
inferiores e superiores para o vetor gradiente, que denotamos
por a Qn e b Qn , da seguinte maneira:
n n
X
X
+
ai = qij , bi = qij para i = 1, . . . , n. (1)
j=1 j=1
+
onde qij = min{qij , 0} e qij = max{qij , 0} para i =
1, 2, . . . , n e j = 1, 2, . . . , n.
Se 21 (ai + bi ) 0, ento a varivel correspondente xi ter
seu valor fixado em 0, caso contrrio xi ter seu valor igual a
1.
De acordo com os autores do artigo na referncia [23], esta
heurstica capaz de resolver uma classe difcil de instncias
do UQP. Comentamos sobre estas instncias na Seo V-C.
 O Algoritmo II.3 apresenta o pseudo-cdigo do Gradient
Midpoint Method. Note que ele muito simples.

Algoritmo II.1: Pseudo-cdigo do mtodo bsico do

Tabu Search para o UQP Algoritmo II.3: Gradient Midpoint Method
Entrada: n N ,
Q Qnn , K
N ,
S OLUO _I NICIAL Entrada: n N , Q Qnn
{0, 1}n Sada: x {0, 1}n , f (x) Q
Sada: x {0, 1}n , f (x) Q 1 incio
1 incio 2 para i = 1 at n faa
2 x S OLUO _I NICIAL 3 ai 0; bi 0
3 x x 4 para j = 1 at n faa
4 t1 5 ai ai + min{qij , 0}
5 Li 0 para i = 1, 2, . . . , n 6 bi bi + max{qij , 0}
6 enquanto critrio de parada no for satisfeito faa 7 fim
7 para i = 1 at n faa 8 fim
8 se Li = 0 ento 9 para i = 1 at n faa
9 x0 x 10 se (ai + bi )/2 0 ento
10 x0i 1 x0i 11 xi 0
 n  12 seno
f (x0 ) f (x)+(12xi ) qii +
P
11 (qij +qji )xj 13 xi 1
j=1
j6=i 14 fim
12 se f (x0 ) > f (x) ento 15 fim
13 ti 16 c0
14 fim 17 para i = 1 at n faa
15 fim 18 para j = 1 at n faa
16 fim 19 c c + qij xi xj
17 xt = 1 xt 20 fim
18 para i = 1 at n faa 21 fim
19 se Li > 0 ento 22 f (x) c
20 Li Li 1 23 fim
21 fim
22 fim
23 Lt K
24 se f (x) > f (x ) ento
25 x BUSCA _ LOCAL _TS(n, Q, x, f (x ))
26 x x
27 fim E. Mtodos Exatos
28 fim
29 fim Nesta seo mostramos como calcular limitantes para
instncias do UQP e regras para determinar os valores das
variveis em uma soluo tima. Mostramos tambm um
Branch and Bound (B&B), que um mtodo exato baseado
em enumerao implcita das solues no espao de solues.
As referncias [13], [23], [24] so as fontes principais do texto
desta seo.

Algoritmo II.2: Pseudo-cdigo da BUSCA _ LOCAL _TS 1) Limitantes e Regras para Determinar Valores das Vari-
do Algoritmo II.1 veis em uma Soluo tima: Nesta seo apresentamos um
Entrada: n N , Q Qnn , x {0, 1}n , V Q mtodo para calcular limitantes, que til para diminuir o
Sada: x {0, 1}n nmero de vrtices explorados na rvore de enumerao do
1 incio mtodo Branch and Bound.
2 repita
3 melhorou f also Teorema 1. [13] Sejam f uma funo continuamente dife-
4 para t = 1 at n faa rencivel em um conjunto aberto que contm um conjunto
5 xt 1 xt compacto e convexo S Qn e x uma soluo tima para o
 n 
6 f (x) V + (1 2xt ) qtt +
P
(qtj + qjt )xj problema
j=1
j6=i min f (x) = xT Qx
7 se f (x) > V ento
8 V f (x) sujeito a: x S. (2)
9 melhorou verdadeiro
10 seno Ento x uma soluo tima para o problema
11 xt = 1 xt
12 fim min xT f (x )
13 fim sujeito a: x S. (3)
14 at melhorou = falso
15 fim 

Suponha que S = {x Qn : 0 x 1} um cubo

unitrio e x uma soluo tima para (2) e (3). Como
 n f (x )
xT f (x ) = Calculam-se os limitantes da seguinte maneira:
P
xi , podemos concluir que
i=1 xi a1 = 1 + 2(2), b1 = 1 + 2(3)

f (x ) a2 = 4 + 2(2), b2 = 4 + 2(5)
0

se 0 a3 = 6, b3 = 6 + 2(3 + 5)
xi
xi = para i = 1, 2, . . . , n. ou seja,
3 7


1 f (x ) a= 0 e b = 14
se < 0
xi 6 10

Isto verdade porque min{xT f (x ) : 0 x 1} = A partir das condicionais em (5), conclumos que uma soluo tima para
n f (x ) este exemplo tem x2 = 0.
: 0 xi 1}. Como a funo xT f (x )
P
min{xi
i=1 xi
linear, pois a funo f (x) quadrtica, o problema 
min T
x f (x ) 2) Branch and Bound: Branch and Bound (B&B) um
esquema que permite encontrar solues timas para proble-
sujeito a: 0x1 (4)
mas de otimizao combinatria, fazendo uso de uma busca
um problema de programao linear. Assim, uma soluo em rvore com uma estratgia de diviso e conquista. O B&B
tima para ele um dos vrtices do poliedro S = {x : divide o problema em vrios subproblemas disjuntos, de forma
0 x 1}. Portanto, min{xT f (x ) : 0 x 1} = que ao resolv-los encontra-se tambm uma soluo para o
min{xT f (x ) : x {0, 1}n }. De fato, no assumimos que problema original. A decomposio em subproblemas pode ser
uma soluo tima x conhecida. Mas se pudermos encontrar visualizada como uma rvore de enumerao, onde o vrtice
limitantes ai e bi tais que raiz representa o problema original, cada vrtice interno, na
rvore de enumerao, um subproblema e os vrtices folhas
f (x) fornecem solues viveis para o problema original. Uma
ai bi x S = [0, 1]n
xi caracterstica deste mtodo que pode-se encontrar limitantes,
ento superiores ou inferiores, para os subproblemas e, ao utiliz-los,
 pode-se desconsiderar parte da enumerao.
0 se ai 0
xi = para i = 1, 2, . . . , n. (5)
1 se bi < 0
s 0
x0 = 0 x0 = 1
Sendo f (x) = xT Qx, onde Q uma matriz assimtrica e
f (x) n
=
P
(qij + qji )xj , os valores dos limitantes podem s 1 s 2
xi j=1 x1 = 1 x1 = 0 x1 = 1
x1 = 0
ser determinados da seguinte maneira:
n
X

s 3 s 4 s 5 s 6
ai = qii + (qij + qji ) para i = 1, 2, . . . , n
j=1 Figura 1: Exemplo de uma rvore de enumerao do Branch
n
X
+ +
and Bound
bi = qii + (qij + qji ) para i = 1, 2, . . . , n
j=1
+ A Figura 1 apresenta um exemplo de uma rvore de enu-
onde qij
= min{qij , 0}, qji = min{qji , 0}, qij = max{qij , 0} merao para um B&B. Nesta rvore o n raiz S0 representa o
+
e qji = max{qji , 0} para i = 1, 2, . . . , n e j = 1, 2, . . . , n. problema original, os ns folhas S3 , S4 , S5 e S6 representam
n
solues viveis para o problema. O algoritmo percorre esta
f (x) P rvore calculando limitantes para cada n explorado e verifi-
Se a matriz Q for simtrica, ento =2 qij xj e
xi j=1 cando a viabilidade de explorar os ns filhos.
os valores dos limitantes podem ser determinados da seguinte
maneira: possvel implementar o mtodo B&B fazendo busca
n
em profundidade, em largura ou uma combinao destas. O
X
Algoritmo II.4 um mtodo B&B que utiliza uma busca em
ai = qii + 2 qij para i = 1, 2, . . . , n
profundidade. Neste algoritmo considera-se que o problema
j=1
n
UQP de minimizao. Vale ressaltar que este mtodo apa-
X
+ rece na referncia [13], implementado em paralelo utilizando
bi = qii + 2 qij para i = 1, 2, . . . , n MPI (Message Passing Interface), usando um modelo mestre-
j=1
escravo. Na Seo IV-E2 (na seo de contribuies) apresen-
tamos uma implementao paralela deste mtodo B&B com
Estes limitantes so utilizados no mtodo B&B mostrado GPUs, utilizando um modelo fork-join.
no Algoritmo II.4.
Exemplo 1. Sejam No restante desta seo assumimos que a matriz Q
simtrica, tal como foi assumido na referncia [13].
1 2 3
T
f (x) = x Qx e Q = 2 4 5 Uma soluo inicial gerada pelo Gradient Midpoint
3 5 6 Method (Algoritmo II.3), posteriormente melhorada pelo m-
todo Tabu Search (Algoritmo II.1) e fornecida como entrada
para o mtodo B&B, apresentado no Algoritmo II.4, atravs

do vetor x e tem OP T = f (x ). Denotamos por qij =
+
min{qij , 0} e qij = max{qij , 0} para i = 1, 2, . . . , n e
j = 1, 2, . . . , n.
As seguintes variveis e constantes so usadas na descrio
do Algoritmo II.4. qij so os coeficientes na linha i e coluna j Algoritmo II.4: Mtodo Branch and Bound com busca
na matriz Q; n o nmero de variveis de uma instncia; OP T em profundidade
valor da melhor soluo encontrada at o momento; x a Entrada: n N , Q Qnn simtrica, x Qn , OP T Q
Sada: x {0, 1}n , f (x) Q
melhor soluo encontrada at o momento; lev o nvel atual 1 pi i para i = 1, . . . , n
da rvore de enumerao do B&B; p1 , . . . , plev so os ndices 2 empilha({-1,-,-,-},stack)
das variveis fixadas no subproblema atual; plev+1 , . . . , pn 3 lev 0, N SU BP 0
n n
so os ndices das variveis livres no subproblema atual; 4 lbi 2
P
qij + qii , ubi 2
P +
qij + qii para i = 1, . . . , n
xp1 , xp2 , . . . , xplev so as variveis fixadas; g o limitante j=1 j=1
j6=i j6=i
inferior para f (x); lb o limitante inferior f (x) [0, 1]n ; 5 enquanto lev 6= 1 faa
ub o limitante superior f (x) [0, 1]n ; p o vetor de 6 g Calcula o limitante inferior g
permutaes; N SU BP o nmero de subproblemas resolvi- 7 se g OP T ou lev = n ento
dos. 8 se g < OP T ento OP T g, x x
9
Cada iterao do loop na Linha 5 trabalha com um vrtice 10 desempilha({lev, lb, ub, g},stack)
da rvore de enumerao do B&B. Uma pilha, estrutura de da- 11 se lev 6= 1 ento xplev 1 xplev
12
dos, utilizada para armazenar informaes de subproblemas 13 N SU BP N SU BP + 1
quando um branching (ramificao da rvore) necessrio. Na 14 seno
Linha 1, a pilha iniciada com o valor 1 para a varivel lev, 15 se lev 6= 0 ento
que indica que a pilha est vazia. O algoritmo termina quando 16 se xplev = 1 ento
este valor desempilhado. lbpi lbpi + 2qp+i plev para i = lev + 1, . . . , n
17
ubpi ubpi + 2qpi plev para i = lev + 1, . . . , n
Na Linha 4 mostramos como calcular os limitantes do 18 seno
gradiente da funo f (x) = xT Qx. Na Linha 6 calcula-se lbpi lbpi 2qpi plev para i = lev + 1, . . . , n
19
o limitante inferior para o valor de uma soluo tima para o ubpi ubpi 2qp+i plev para i = lev + 1, . . . , n
20 fim
subproblema corrente. A frmula utilizada a seguinte: 21 fim
n
n X  X n
lev X 22 entrou = falso
para i = lev at n faa
X

g = qij 2 qpi pj (1 xpi ) 23
24 se lbpi 0 ou ubpi 0 ento
i=1 j=1 i=1 j=i+1 25 se ubpi 0 ento
lev
X  lev X
X lev 26 xpi 1
seno
+ qpi pj (1 xpi ) + qp+i pj xpi xpj (6) 27
28 xpi 0
i=1 i=1 j=1 29 fim
30 entrou = verdadeiro
Na Linha 7 verificamos se possvel podar um vrtice 31 Sai do loop
interno, g OP T , ou um vrtice folha encontrado, lev = n. 32 fim
33 fim
No ltimo caso, uma nova soluo foi encontrada e avaliada 34 se entrou = falso ento
na Linha 8. Na Linha 9 desempilha-se as informaes de um 35 i j onde j = max{min{lbpt , ubpt }} para
t
subproblema ainda no resolvido. Na Linha 11 altera-se o t = lev + 1, . . . , n
valor da varivel xplev para resolver um outro subproblema. 36 xpi 0
O nmero de subproblemas resolvidos, N SU BP , incremen- 37 gAux Calcula o limitante inferior g
tado na Linha 13. Este valor usado somente para medidas 38 xpi 1
39 g Calcula o limitante inferior g
estatsticas, mas tambm pode ser utilizado como critrio de 40 se gAux < g ento
parada como apresentado em [24]. 41 xpi 0
42 g gAux
Se nenhuma das condies da Linha 7 for satisfeita, uma 43 fim
busca em profundidade iniciada na Linha 15. Se o nvel 44 empilha({lev+1, lb, ub, g},stack)
de profundidade na rvore de enumerao diferente de zero 45 fim
(lev 6= 0), ento os limitantes dos gradientes da funo 46 lev lev + 1
47 plev pi %Troca de valores de plev e pi
so atualizados. Da Linha 15 at a Linha 21, feita uma 48 fim
atualizao eficiente, com complexidade computacional linear, 49 fim
dos limitantes do vetor gradiente para as variveis ainda no
fixadas (isto , variveis livres). Esta atualizao leva em
considerao o valor da ltima varivel fixada. Esses limitantes
so testados na Linha 24 verificando se alguma varivel pode
ter seu valor fixado. Se algum limitante inferior, lbi , for maior
ou igual a zero ou um limitante superior, ubi , for menor ou
igual a zero, ento a varivel correspondente, xi , tem seu valor
fixado como apresentam as Linhas de 25 at 29. Uma vez que
a diferena entre os limitantes vo diminuindo a cada nvel que
se desce na rvore de enumerao, as variveis so fixadas de
maneira dinmica. Este processo chamado pelos autores de
pr-processamento dinmico.
Se nenhuma varivel puder ser fixada, ento a regra da Li-
nha 35 utilizada. A regra define a prxima varivel livre a ser
fixada. A varivel livre escolhida aquela que possivelmente
no conseguir ser fixada nos nveis subsequentes da rvore de
enumerao. Por isso as variveis que tm maior possibilidade
de serem fixadas em iteraes seguintes, so deixadas livres.
Depois que a varivel escolhida, o seu valor determinado
nas Linhas 36 a 43, definindo o valor que menos incrementa o
limitante inferior. Este procedimento escolhe um subproblema
que ser resolvido e o outro subproblema armazenado
na pilha, Linha 43, para posterior anlise. Na Linha 46 a
varivel que controla a altura da rvore de enumerao, lev,
incrementada. Na Linha 47 feita uma troca de valores no
vetor de permutao.
Dada a enorme quantidade de vrtices em uma rvore
de enumerao, para uma instncia de tamanho moderado do
UQP, e a atual facilidade em utilizar programao com GPUs
para implementar algoritmos, vimos nesta situao uma exce-
lente oportunidade para testar a capacidade de processamento
paralelo das GPUs. A mesma justificativa aplica-se para o
Tabu Search, que precisa realizar uma quantidade grande de
reclculos do valor da funo objetivo.
III. P ROGRAMAO PARALELA COM GPU S
Paralelizar a computao implica na capacidade de dividir
o problema em problemas menores e conseguir resolv-los de
forma eficaz.
A. CPUs e GPUs
Tradicionalmente, a diferena fundamental entre os proces-
sadores (CPUs) e as placas grficas (GPUs) o fato de que
as CPUs so otimizadas para clculos sequenciais, enquanto
as GPUs so otimizadas para clculos massivamente paralelos
(por exemplo, processando grficos 3D).
Com o avano da indstria de materiais tornou-se possvel
colocar em um chip de silcio cada vez mais transistores,
permitindo mais funcionalidades aos processadores. Junto com
esta evoluo veio o aumento da velocidade do clock que
permitiu processamentos muito rpidos. Chegou-se a um mo-
mento crtico, em que uma placa de silcio, como feita atual-
mente, no suporta velocidades maiores, pois esquentam muito
e rompem as trilhas. A soluo encontrada foi colocar mais
ncleos de processamento dentro de um processador, tornando
as tarefas possivelmente mais rpidas, no pela velocidade
de processamento, mas sim pelo aumento da quantidade de
ncleos de processamento.
B. Arquitetura CUDA
Compute Unified Device Architecture (CUDA) uma arqui-
tetura de computao paralela de propsito geral desenvolvida
pela empresa NVIDIA. Nesta arquitetura possvel acelerar
o desempenho dos programas, utilizando as GPUs como um
co-processador matemtico paralelo.
CUDA apresenta-se ao programador como uma extenso da
linguagem C/C++. O fluxo de processamento de um programa
escrito em CUDA no complexo.
A NVIDIA produziu vrias arquiteturas para implementar
GPUs, a Kepler uma delas. Ao desenvolver a Kepler a NVI-
DIA buscou ter um melhor desempenho por watt, velocidade
e prover mais facilidade de programao.
As GPUs possuem vrias reas de memria, com dife-
rentes caractersticas que podem influenciar diretamente no
desempenho dos programas. As memrias disponveis para o
desenvolvedor so: registradores, compartilhada, global, local,
constantes e textura. Em [25], discute-se sobre as vantagens
do uso de alguns tipos de memria em um algoritmo de busca
local.
A arquitetura CUDA possui limitaes que devem ser
consideradas. Um exemplo disto o tempo gasto para realizar
cpias entre a memria RAM e a memria interna da GPU,
isto pode diminuir o desempenho dos programas. Entretanto,
este tempo varia com o tipo do barramento do sistema.
Outro fato a ser considerado que embora o desenvolvi-
mento de um programa utilizando CUDA seja relativamente
simples, manter todos os cores ocupados a maior parte do
tempo possvel durante a execuo de um programa, pode
exigir muita engenhosidade do programador. Isto se deve s
limitaes de memrias de acesso rpido dentro das GPUs e
da prpria caracterstica dos multiprocessadores utilizados.
A partir da prxima seo apresentamos as contribuies
feitas neste trabalho.
IV. C ONTRIBUIES E I MPLEMENTAES PARALELAS
Nesta seo apresentamos as nossas contribuies ao de-
senvolvimento de mtodos para resolver instncias do UQP e
descrevemos implementaes paralelas com GPUs.
Tanto nas abordagens heursticas quanto nas exatas, faz-
se necessrio efetuar o clculo do valor da funo objetivo
diversas vezes. Assim, saber fazer este clculo de maneira
rpida primordial. Por isso este um dos temas tratados
nesta seo.
Conforme exposto nas Sees II-D1 e II-E2, os mtodos
Tabu Search, Busca Local e Branch and Bound, necessitam
computar diversas vezes o valor de f (x) = xT Qx. Esta
computao requer O(n2 ) operaes e pode ser determinante
para o bom desempenho de um mtodo. No caso do Branch
and Bound precisa-se computar diversas vezes o valor da
funo g, limitante inferior ao valor de uma soluo tima.
Nesta seo apresentamos a forma bsica de se efetuar
o clculo do valor da funo objetivo e tambm formas
mais eficientes, que aproveitam o valor de uma soluo j
computada.
A. Clculo do Valor da Funo Objetivo na Forma Bsica
O clculo de f (x) = xT Qx na forma bsica o seguinte:
Xn X n 
f (x) = xT Qx = qij xj xi
i=1 j=1
 n
Observamos que este clculo de f (x) requer n2 + n operaes
 X 
= f (x) + (1 2xi ) qii + (qij + qji )xj
de multiplicao e n2 1 operaes de adio. j=1
j6=i
Se tivermos calculado f (x), como acima, e depois for
feita uma alterao no vetor x, ento podemos reusar o 
valor de f (x) para realizar menos que n2 + n operaes de
Corolrio 1. Sejam f (x) o valor de xT Qx para um dado
multiplicao e menos que n2 1 operaes de adio no
x {0, 1}n e Q Qnn uma matriz simtrica. Se y um
prximo reclculo.
vetor idntico x exceto pela i-sima posio, onde yi = 1xi
com i {1, 2, . . . , n}, e f (x) j tiver sido calculado, ento o
B. Reclculo do Valor da Funo Objetivo com Mudana do valor de f (y) pode ser determinado, sem utilizar informaes
Valor de Uma Varivel o vetor y, da seguinte maneira:
n
A maneira de reclculo apresentada nesta seo assume  X 
que a componente xi do vetor x foi modificada para 1 xi . f (y) = f (x) + (1 2xi ) qii + 2 qij xj (8)
Desta forma, necessrio utilizar apenas uma parte da matriz j=1
j6=i
Q para efetuar o reclculo. Notamos que o reclculo pode ser
feito quando a instncia possui matriz assimtrica ou simtrica. Esta maneira de fazer o reclculo utiliza n + 2 operaes de
No segundo caso realiza-se menos operaes que o primeiro. multiplicao e n + 1 operaes de adio.
Os resultados apresentados nesta seo foram obtidos de Prova: Como a matriz Q simtrica, segue que qij = qji .
forma independente, embora a Frmula (7) aparea em [26] Ento:
sem uma prova.  n
X 
Proposio 1. Sejam f (x) o valor de xT Qx para um dado x f (y) = f (x) + (1 2xi ) qii + (qij + qji )xj
{0, 1}n e Q Qnn uma matriz assimtrica. Se y um vetor j=1
j6=i
idntico x, exceto pela i-sima posio, onde yi = 1 xi n
com i {1, 2, . . . , n}, e f (x) j estiver sido calculado, ento o  X 
valor de f (y) pode ser determinado, sem utilizar informaes = f (x) + (1 2xi ) qii + 2 qij xj
j=1
do vetor y, da seguinte maneira: j6=i
n
 X  
f (y) = f (x) + (1 2xi ) qii + (qij + qji )xj (7)
j=1
j6=i Em resumo, na Frmula (7) os nmeros de operaes so:
Esta maneira de fazer o reclculo utiliza n + 1 operaes de Multiplicaes: n1+1+1=n+1
multiplicao e 2n operaes de adio. Adies: 2(n 1) + 1 + 1 = 2n 2 + 2 = 2n
Prova: Suponha que x {0, 1}n , Q Qnn uma matriz Enquanto na Frmula (8), os nmeros de operaes so:
assimtrica e y um vetor idntico x exceto pela i-sima
posio, onde yi = 1 xi com i {1, 2, . . . , n}. Pode-se de- Multiplicaes: n1+1+1+1=n+2
terminar f (y) a partir do valor de f (x) subtraindo as parcelas Adies: n1+1+1=n+1
que envolvem xi e adicionando aquelas que envolvem 1 xi .
Como xi {0, 1}, segue que x2i = xi e (1 xi )2 = 1 xi . C. Reclculo do Valor da Funo Objetivo com Mudanas dos
Ento: Valores em Duas Variveis
n
X n
X Usando um raciocnio similar ao descrito na Seo IV-B,
f (y) = f (x) xi qij xj xi qji xj qii x2i podemos obter uma frmula geral para o reclculo do valor
j=1
j6=i
j=1
j6=i
da funo objetivo considerando que duas variveis tm seus
X n n
X valores alterados.
+(1 xi ) qij xj + (1 xi ) qji xj + qii (1 xi )2 Proposio 2. Sejam x {0, 1}n , f (x) = xT Qx e Q Qnn
j=1
j6=i
j=1
j6=i
uma matriz assimtrica. Se y um vetor idntico x exceto em
n duas posies distintas i, k {1, 2, . . . , n}, onde yi = 1 xi
e yk = 1 xk , e f (x) j estiver calculado, ento o valor de
X
= f (x) xi (qij + qji )xj qii xi
j=1 f (y) pode ser obtido por:
j6=i
n  X n 
X
+(1 xi ) (qij + qji )xj + qii (1 xi ) f (y) = f (x) + (1 2xi ) qii + (qij + qji )xj
j=1 j=1
j6=i j6=i,k
n
X  n 
X
= f (x) + (1 2xi ) (qij + qji )xj qii xi + qii qii xi +(1 2xk ) qkk + (qkj + qjk )xj
j=1
j=1
j6=i
j6=i,k
n
+(qik + qik )(1 xi xk ) (9)
X
= f (x) + (1 2xi ) (qij + qji )xj + qii (1 2xi )
j=1
j6=i Esta maneira de fazer o reclculo utiliza 2n + 1 operaes de
multiplicao e 4n operaes de adio. +qkk (1 xk ) + (qik + qki )(1 xi )(1 xk )
Xn
Prova: Sejam x {0, 1}n , f (x) = xT Qx e Q Qnn uma = f (x) + (1 2xi ) (qij + qji )xj + qii (1 2xi )
matriz assimtrica. Se y um vetor idntico x, exceto em j=1
duas posies distintas i, k {1, 2, . . . , n}, onde yi = 1 xi j6=i,k
n
e yk = 1 xk , e f (x) j estiver calculado, ento pode-se X
determinar f (y) a partir de f (x) subtraindo as parcelas que +(1 2xk ) (qkj + qjk )xj + qkk (1 2xk )
envolvem xi e xk e adicionando aquelas que envolvem (1xi ) j=1
j6=i,k
e (1 xk ). A Figura 2 mostra os ndices na matriz Q que
+(qik + qki )(1 xi )(1 xk ) (qik + qki )xi xk
 Xn 
i k = f (x) + (1 2xi ) qii + (qij + qji )xj
j=1
j6=i,k
 Xn 
i ii ik +(1 2xk ) qkk + (qkj + qjk )xj
j=1
j6=i,k
+(qik + qik )(1 xi xk )
k ki kk


D. Clculos do Limitante Inferior f (x) no Branch and

Figura 2: ndices da matriz Q para o clculo de f (y) Bound
Nesta seo apresentamos um limitante inferior f (x),
precisam ser considerados para o clculo do valor de f (y). Frmula (10), na forma bsica para o mtodo Branch and
Assim, Bound (B&B) discutido em [13]. Apresentamos tambm a
n n
nossa contribuio para este clculo na Frmula (11). Esta
X X ltima frmula gera limitantes, para quaisquer instncias do
f (y) = f (x) xi qij xj xi qji xj qii x2i
UQP, com valores sempre maiores ou iguais aos encontrados
j=1 j=1
j6=i,k j6=i,k pela Frmula (10).
n n
X X Para resolver o UQP por meio de um B&B, utiliza-se
xk qkj xj xk qjk xj qkk x2k uma rvore de enumerao, B = (P, E), para representar o
j=1 j=1
j6=i,k j6=i,k processo de decomposio. Sejam P um conjunto de vrtices
n
X e E um conjunto de arcos. A raiz de B denotada por P0 ,
qik xi xk qki xk xi + (1 xi ) qij xj representa o problema original e os subproblemas de P0 so
j=1
representados por Pi para i N . O subproblema Pj filho
j6=i,k de Pi quando Pj gerado a partir de uma decomposio de
n
X Pi , assim (Pi , Pj ) E.
+(1 xi ) qji xj + qii (1 xi )2
j=1
O mtodo B&B tenta resolver P0 examinando vrtices em
j6=i,k B. Durante este processo feito um teste para verificar se
Xn n
X o vrtice Pi incapaz de produzir uma soluo tima para
+(1 xk ) qkj xj + (1 xk ) qjk xj P0 , podendo assim eliminar este vrtice da investigao no
j=1 j=1 mtodo. Este teste utiliza uma funo g : P Q, que gera
j6=i,k j6=i,k
um limitante inferior ao valor de uma soluo tima para Pi .
+qkk (1 xk )2 + qki (1 xi )(1 xk ) Esta funo precisa satisfazer trs condies:
+qik (1 xi )(1 xk )
n 1) g(Pi ) f (Pi ) para Pi P ;
2) g(Pi ) = f (Pi ) para vrtices folha de B;
X
= f (x) xi (qij + qji )xj qii xi
j=1
3) g(Pj ) g(Pi ) se Pj um filho de Pi em B.
j6=i,k
n Em [13], Pardalos e Rodgers propem a funo dada na
xk
X
(qkj + qjk )xj qkk xk (qik + qki )xi xk Frmula (10) como um limitante inferior ao valor de qualquer
soluo tima de P0 . A ideia por trs da frmula a seguinte:
j=1
j6=i,k considere x {0, 1}n , a funo f (x) = xT Qx simplesmente
n a soma dos coeficientes qij , onde xi = xj = 1. Assim
uma funo que representa o limitante que satisfaz os trs
X
+(1 xi ) (qij + qji )xj + qii (1 xi )
critrios de limitante inferior : a soma de todos os coeficientes
j=1
j6=i,k negativos de Q Qnn , menos a soma dos coeficientes
n negativos que devem ser excludos do valor da funo devido
s variveis fixadas em 0, mais a soma dos coeficientes
X
+(1 xk ) (qkj + qjk )xj
positivos que devem ser includos no valor da funo devido
j=1
j6=i,k s variveis fixadas em 1. Sejam lev o nvel da rvore de
enumerao (isto , o nmero de variveis com valores fixados
em 0 ou 1), p1 , p2 , . . . , plev os ndices das variveis fixadas e 4 X
4  
plev+1 , plev+2 , . . . , pn os ndices das variveis livres (variveis
X
g1 (x) = min{qij , 0} 2 min{q12 , 0}(1 x1 )
com valores ainda no fixados). A funo do limitante inferior i=1 j=1
g1 (x) : + min{q13 , 0}(1 x1 ) + min{q14 , 0}(1 x1 )
n X
X n  Xlev X
n + min{q23 , 0}(1 x2 ) + min{q24 , 0}(1 x2 )

qpi pj (1 xpi )

g1 (x) = qij 2 + min{q34 , 0}(1 x3 ) + min{q11 , 0}(1 x1 )
i=1 j=1 i=1 j=i+1
+ min{q22 , 0}(1 x2 ) + min{q33 , 0}(1 x3 )
lev  lev X
lev
X X 4 X 4
qpi pi (1 qp+i pj xpi xpj
 X
+ xpi ) + (10) + min{q44 , 0}(1 x4 ) + max{qij , 0}xi xj
i=1 i=1 j=1
i=1 j=1

 
+
onde qij= min{qij , 0} e qij
= max{qij , 0} so os coeficien- = 14 2 0(1 0) + 0(1 0) + 0(1 0) + 0(1 1)
tes no positivos e no negativos de Q, respectivamente. 
+(7)(1 1) + 0(1 1) + 0(1 0) + 0(1 1)

+0(1 1) + 0(1 0) + 0

Quando se tem lev = n, o valor da funo g1 (x) deveria = 14 2(0)

coincidir com o valor de f (x) = xT Qx. Mas conforme o = 14
Exemplo 2 isso no ocorre para algumas instncias.

4 X
X 4  
g2 (x) = min{qij , 0} 2 min{q12 , 0}(1 x1 x2 )
Fizemos uma alterao na Frmula (10), para que seja i=1 j=1
possvel calcular um limitante inferior f (x) do UQP para + min{q13 , 0}(1 x1 x3 ) + min{q14 , 0}(1 x1 x4 )
quaisquer instncias, que apresentamos na Frmula (11). Os + min{q23 , 0}(1 x2 x3 ) + min{q24 , 0}(1 x2 x4 )
valores dos limitantes inferiores f (x) gerados por (11) so

+ min{q34 , 0}(1 x3 x4 ) + min{q11 , 0}(1 x1 )
maiores ou iguais aos gerados por (10), conforme provado na
+ min{q22 , 0}(1 x2 ) + min{q33 , 0}(1 x3 )
Proposio 3.  X 4 X 4
n X
X n X lev
lev  X + min{q44 , 0}(1 x4 ) + max{qij , 0}xi xj

g2 (x) = qij 2 qpi pj (1 xpi xpj )  
i=1 j=1

i=1 j=1 i=1 j=i+1 = 14 2 0(1 0 1) + 0(1 0 1) + 0(1 0 0)

n lev
!
X  X 
+0(1 1 1) + (7)(1 1 0) + 0(1 1 0)
+ qpi pj (1 xpi ) + qpi pi (1 xpi )

j=lev+1 i=1
+0(1 0) + 0(1 1) + 0(1 1) + 0(1 0) + 0
lev X
X lev
qp+i pj xpi xpj
 
+ (11) = 14 2(7)
i=1 j=1 = 14 + 14
Exemplo 2. Se f (x) = xT Qx, x = [0, 1, 1, 0], n = 4, lev = 4, = 0
p = [1, 2, 3, 4] e

Note que o valor de g2 (x) g1 (x) e g2 (x) = f (x).


0 28 49 0

28 0 0 7
Q=
49 0 0 0 A Proposio 3 relaciona as Frmulas (10) e (11).
0 7 0 33
Proposio 3. Suponha f (x) = xT Qx, x {0, 1}n e Q
Qnn uma matriz simtrica. As expresses nas Frmulas (10)
e (11) satisfazem g1 (x) g2 (x), onde xp1 , xp2 , . . . , xplev tm
seus valores fixados em 0 ou 1 e xplev+1 , xplev+2 , . . . , xpn no
ento os valores de f (x), g1 (x) e g2 (x) so:
tm seus valores fixados.
0 28 49 0 0

  28 0 0 7 1 Prova: Utilizamos o seguinte fato na demonstrao:
f (x) = 0, 1, 1, 0
49 0 0 0 1
0 7 0 33 0 max{1 xpi } min{1 xpi xpj }.
0

  1 O max{1 xpi } = 1 ocorre quando xpi = 0, neste caso
= 77, 0, 0, 7 min{1 xpi xpj } = 1. O min{1 xpi xpj } = 0 ocorre quando
1
0 xpi = xpj = 1, neste caso max{1xpi } = 0. Assim, max{1
= 0 xpi } min{1 xpi xpj } com xpi , xpj {0, 1}.
 E. Implementaes Paralelas
n X
n lev X
n
X

 X Nesta seo abordamos os algoritmos que foram parale-
g1 (x) = qij 2 qpi pj (1 xpi ) lizados neste trabalho para efetuar suas implementaes em
i=1 j=1 i=1 j=i+1 CUDA para GPUs.
lev  Xlev X
lev
1) Tabu Search na Forma Paralela: O mtodo TS tem
X
+ qpi pi (1 xpi ) + qp+i pj xpi xpj
i=1 i=1 j=1
uma dependncia de dados a cada iterao, pois a varivel
n X
n lev  X
lev
fixada na iterao anterior, que a que forneceu melhor
X

X incremento no valor da funo objetivo, deve ter seu valor
= qij 2 qpi pj (1 xpi ) preservado na prxima iterao. Ao realizar este procedimento,
i=1 j=1 i=1 j=i+1
n
em paralelo, faz-se necessrio realizar um sincronismo entre
X  todas as threads de todos os blocos, o que em CUDA significa
+ qpi pj (1 xpi ) encerrar o kernel. Por este motivo no paralelizamos todo o
j=lev+1 mtodo. Identificamos as partes que possivelmente requerem
lev
! lev X
lev
X X muito esforo computacional, para avaliar a possibilidade de
+ qpi pi (1 xpi ) + qp+i pj xpi xpj paraleliz-las. As partes identificadas foram o clculo do valor
i=1 i=1 j=1 da funo objetivo e a busca local.
n X
n lev  X
lev

X

qij 2
X
qpi pj (1 xpi xpj ) Como a busca local implementada tem uma grande de-
pendncia de dados e pouco custo computacional em cada
i=1 j=1 i=1 j=i+1
n
iterao, provavelmente sua paralelizao no traria ganho em
termos de acelerao do tempo de processamento. Assim, a
X 
+ qpi pj (1 xpi )
parte do cdigo paralelizada foi o clculo do valor da funo
j=lev+1
! objetivo.
lev
X lev X
X lev
+ qpi pi (1 xpi ) + qp+i pj xpi xpj O mtodo Tabu Search explicado em detalhes na Seo
i=1 i=1 j=1 II-D1, aqui abordamos os aspectos da verso paralela com
= g2 (x) GPUs. Explicamos o Algoritmo IV.1 a seguir.
Na linha 5 alocam-se espaos de memria na GPU para
 armazenar o vetor soluo x, a lista tabu L, o vetor que
armazena o valor da melhor soluo de cada bloco V kernel e
No texto a seguir, apresentamos como efetuar de maneira o vetor V kernelIndice, que guarda os ndices das variveis xi
rpida o clculo do limitante inferior f (x) para o UQP. que ao alter-las forneceu a melhor soluo para cada bloco.
1) Reclculo do Limitante Inferior f (x) com Acrscimo Na linha 7 feita a cpia dos vetores x e L da CPU para a
de um Nvel na rvore de Enumerao: O clculo do limi- GPU. Na linha 8 feita a chamada do kernel, onde calcula-se
tante inferior f (x) na sua forma bsica tem complexidade o valor da funo objetivo em paralelo. Na linha 9 feita a
computacional O(n2 ). Utilizando o Algoritmo II.4, sempre cpia dos vetores V kernel e V kernelIndice da GPU para a
que se desce na rvore de enumerao do Branch and Bound CPU. Em seguida, percorre-se o vetor V kernel para encontrar
aumentando-se o nvel em uma unidade, possvel realizar o o ndice da varivel que fornece o maior valor para a funo
clculo do limitante inferior f (x) com complexidade O(n). objetivo e armazena-o na varivel k.
Proposio 4. Sejam f (x) o valor de xT Qx para um dado O Algoritmo IV.2 apresenta o pseudo-cdigo do kernel. Na
x {0, 1}n e Q Qnn uma matriz simtrica. Suponha que linha 4 utilizada a lista tabu para selecionar as variveis que
lev {1, 2, . . . , n} o nmero de variveis fixadas em 0 ou no podem sofrer alteraes. Na linha 5 feito o reclculo
1, em um vrtice da rvore de enumerao do Branch and do valor da funo objetivo, levando em considerao uma
Bound, e g2 Anterior o valor do limitante inferior f (x) possvel alterao na i-sima varivel, de tal forma que o valor
neste vrtice, calculado pela Frmula (11), no nvel lev 1. de xi torna-se 1xi . Na linha 10 feita uma chamada funo
Ento pode-se recalcular o valor do limitante, para o nvel lev, ReductionM ax(), que apresentada no Algoritmo IV.3. O
da seguinte maneira: objetivo desta funo encontrar o maior valor do vetor V , seu
ndice correspondente em V indice e copi-los para os vetores
g2 (x) = g2 Anterior + D, V kernel e V kernelIndice, na posio correspondente ao
onde D : bloco atual. Desta maneira, no trmino, os vetores V kernel e
V kernelIndice armazenam os maiores valores das solues
e os ndices correspondentes s variveis que foram alteradas.
  lev1 n
2) Branch and Bound na Forma Paralela: A referncia
X X 
D = (xplev 1) 2 qpi plev xpi + qplev pj
[24] descreve uma implementao paralela do B&B, utilizando
i=1 j=lev+1
 lev1 um modelo mestre-escravo. Nossa implementao paralela
 lev 
X X utiliza um modelo fork-join. Em um modelo mestre-escravo
+qplev plev + xplev qp+i plev xpi + qp+lev pj xpj (12) uma thread, denominada mestre, fornece trabalho para outras
i=1 j=1 threads, denominadas de escravas, j no modelo fork-join uma
thread encarregada do trabalho e em certo momento ela
Assim o reclculo realizado em tempo O(n). distribui os trabalhos para outras threads enquanto aguarda que
 o trabalho seja finalizado por todas as threads, havendo assim
Algoritmo IV.1: Pseudo-cdigo do mtodo Tabu Search uma sincronizao de tempo, e em seguida a thread principal
paralelo com GPUs continua com o trabalho.
Entrada: n N , Q Qnn , S OLUO _I NICIAL {0, 1}n
Sada: x {0, 1}n Uma soluo inicial gerada pelo Gradient Midpoint
1 incio Method (Algoritmo II-D2), que melhorada pelo mtodo Tabu
2 x S OLUO _I NICIAL Search (Algoritmo II-D1) e ento fornecida como entrada para
3 x x; V f (x)
4 Li 0 para i = 1, 2, . . . , n
o mtodo B&B, apresentado no Algoritmo IV.4, atravs do ve-

5 Cria espaos de memria na GPU para os vetores x, L, V kernel tor x e tem OP T = f (x ). Denotamos por qij = min{qij , 0}
+
e V kernelIndice e qij = max{qij , 0}.
6 enquanto critrio de parada no for satisfeito faa
7 Copia os vetores x e L da CPU para a GPU As seguintes variveis e constantes so usadas na descrio
8 Calcula_F O_Kernel(Q, x, L, V kernel, V kernelIndice, n) do Algoritmo IV.4. qij o coeficientes na linha i e coluna j
9 Copia os vetores V kernel e V kernelIndice da GPU para na matriz Q; n o nmero de variveis de uma instncia;
a CPU
10 V V kernel1 ; t V kernelIndice1 OP T o valor da melhor soluo encontrada; gOP T0 o
11 para i = 2 at Blocos faa valor da melhor soluo encontrada at o momento; gOP T1
12 se V kerneli > V ento a posio na memria que contm a melhor soluo en-
13 V V kerneli ; t V kernelIndicei contrada at o momento; x a melhor soluo encontrada
14 fim
15 fim
at o momento; levIni o nvel inicial na busca da rvore
16 xt 1 xt de enumerao do B&B; lev o nvel atual na rvore de
17 para i = 1 at n e Li > 0 faa enumerao do B&B; p1 , . . . , plev o ndices das variveis
18 Li Li 1 fixadas no subproblema atual; plev+1 , . . . , pn o ndices das
19 fim variveis livres no subproblema atual; xp1 , xp2 , . . . , xplev so
20 se f (x) > f (x ) ento
21 x BUSCA _ LOCAL(n, Q, x); as variveis fixadas; g2 o limitante inferior f (x); lb o
22 Lt K limitante inferior f (x) [0, 1]n ; ub o limitante superior
23 fim f (x) [0, 1]n ; p o vetor de permutaes; N SU BP o
24 fim nmero de subproblemas resolvidos; T id o identificador da
25 fim
thread.
Os valores de gOP T0 e gOP T1 so compartilhados entre
todas as threads do kernel.
Algoritmo IV.2: Pseudo-cdigo do Kernel do Tabu Se-
arch O Algoritmo IV.4 inicia fazendo alocaes de reas
Entrada: n N , Q Qnn , x {0, 1}n , L Qn , V kernel para dados na GPU, copiando os dados dos vetores
QBlocos , V kernelIndice QBlocos , x, x , p, lb, ub, gOP T e da matriz Q da CPU para a GPU. Em
f (x) Q seguida, na Linha 3 feito um lao com a informao para
1 incio cada thread EM PARALELO, que significa que cada thread
2 para i = 1 at n EM PARALELO faa
3 Vi ; executar uma nica vez o contedo deste lao. Na Linha 4
4 se Li > 0 ento um identificador da thread atribudo varivel nT id.
 n
P 
5 Vi f (x) + (1 2xi ) qii + (qij + qji )xj Cada thread resolver um subproblema do problema princi-
j=1
j6=i pal. O nmero de threads em execuo ser sempre um nmero
6 V Indicei i que potncia de 2. A decomposio dos subproblemas
7 fim feita fornecendo um trecho inicial fixo e diferente, de levIni
8 fim
9 Sincroniza as threads posies, no vetor x. Desta forma cada thread examinar uma
10 ReductionM ax(V, V Indice, V kernel, V kernelIndice) parte da rvore de enumerao. O cdigo entre as Linhas 5 e 10
11 fim preenche as primeiras levIni posies do vetor x, convertendo
o identificador da thread, nT id, em sua representao binria.
As demais posies do vetor so preenchidas com zeros. Na
Linha 7 nT id mod 2 representa o resto da diviso de nT id
Algoritmo IV.3: Pseudo-cdigo do ReductionMax no
por 2.
Kernel do Tabu Search
Entrada: V Qn , V Indice Qn , V kernel A Linha 12 inicializa os limitantes de f (x), lb e ub.
QBlocos , V kernelIndice QBlocos , Nmero_do_Bloco Na Linha 13 so atualizados estes limitantes levando em
N, Tamanho_do_bloco N
1 incio
considerao as primeiras levIni posies fixadas do vetor
2 b Nmero_do_Bloco x, da seguinte maneira:
3 V kernelb V1  
4 V KernelIndiceb 1 lbpj lbpj +2 xpi qp+i pj (1 xpi )qpi pj
5 para i = 2 at Tamanho_do_bloco faa  
6 se Vi > V kernelb ento ubpj ubpj +2 xpi qpi pj (1 xpi )qp+i pj
7 V kernelb Vi
8 V kernelIndiceb i para i = 1, . . . , lev e j = lev + 1, . . . , n.
9 fim
10 fim O vetor de permutaes p inicializado na Linha 14 e as
11 fim variveis lev, N SU BP e gOP T0 so inicializadas na Linha
15.
 Uma pilha, estrutura de dados, utilizada para armazenar
informaes de subproblemas quando um branching (ramifica-
Algoritmo IV.4: Pseudo-cdigo do mtodo Branch and o da rvore) necessrio. Na Linha 15 a pilha inicializada
Bound em paralelo com GPUs com o valor 1 para a varivel lev, que indica que a pilha
Entrada: n N , Q Qnn , x Qn , OP T Q, levIni est vazia. A thread termina seu trabalho quando este valor
N, T id N desempilhado. O clculo do limitante inferior f (x), na Linha
Sada: x {0, 1}n , f (x ) Q 18, feito conforme a Frmula (11).
1 Aloca rea de memria na GPU para os vetores x, x , p, lb, ub e
gOP T O restante do cdigo, nas Linhas 17 a 50, faz o mesmo
2 Aloca rea de memria na GPU para a matriz Q e copia os dados da que o mtodo B&B sequencial descrito no Algoritmo II.4, com
matriz da CPU para a GPU
3 para cada thread EM PARALELO faa algumas pequenas alteraes de implementao, mas no de
4 nT id Tid funcionalidade, que discutiremos a seguir:
5 para i = 1 at n faa
6 se i levIni ento Na Linha 22 o identificador da thread que encontrou
7 xi nT id mod 2, nT id nT id/2 a melhor soluo armazenado na varivel gOP T1 .
8 seno
9 xi 0 Nas Linhas 29 e 30, so atualizados os valores dos
10 fim vetores lb e ub. Estas linhas efetuam o mesmo clculo
11 fim
P P + que o apresentado no Algoritmo sequencial, porm
12 lbi 2 qij + qii , ubi 2 qij + qii para
j=1 j=1 eliminou-se o condicional (se), que em CUDA atra-
j6=i j6=i
i = 1, . . . , n
palha o fluxo do programa.
13 Atualiza limitantes lbi e ubi para i = 1, 2, . . . , n
14 pi i para i = 1, 2, . . . , n As Linhas 51 e 52 copiam os dados dos vetores gOP T e
15 lev levIni, N SU BP 0, gOP T0 OP T x da GPU para a CPU.
16 empilha({-1,-,-,-},stack)
17 enquanto lev 6= 1 faa A prxima seo mostra detalhes do cdigo escrito em
18 g2 Calcula o limitante inferior g2 CUDA.
19 se g2 gOP T0 ou lev = n ento
20 se g2 < gOP T0 ento 3) Cdigos da Implementao do Branch and Bound em
21 gOP T0 g Paralelo: Nesta seo abordaremos com mais detalhes os
22 gOP T1 Tid aspectos da implementao e otimizaes em CUDA, do
23 x x
24 fim
mtodo Branch and Bound paralelizado com GPUs. Para isso,
25 desempilha({lev, lb, ub, g},stack) apresentamos trechos do cdigo implementado em Linguagem
26 se lev 6= 1 ento xplev 1 xplev C / CUDA e uma discusso sobre o cdigo.
27 seno
28 se lev 6= 0 ento O Cdigo 1 apresenta parte do cdigo sequencial que faz
29 lbpi   a alocao de espao de memria na GPU, a cpia dos dados
lbpi + 2 xplev qp+i plev (1 xplev )qpi plev da CPU para a GPU, a chamada do kernel e a cpia dos dados
para i = lev + 1, . . . , n da GPU para a CPU. O Cdigo 2 mostra a funo que calcula
30 ubpi   o limitante inferior g, conforme a Frmula (11).
ubpi + 2 xplev qpi plev (1 xplev )qp+i plev
para i = lev + 1, . . . , n
31 fim 1 ...
2 size_t size = Inst->nVars * sizeof(int);
32 entrou = falso 3 size_t sizenVars = Inst->nVars * sizeof(int);
33 para i = lev at n faa 4 size_t sizenSubProb = nSubProb * sizeof(int);
34 se lbpi 0 ou ubpi 0 ento 5 size_t sizeSB = nSubProb * Inst->nVars * sizeof(bool);
35 se ubpi 0 ento xpi 1 6 size_t sizeP = nSubProb * Inst->nVars * sizeof(Pilha);
36 seno xpi 0 7 size_t sizePlim = nSubProb * Inst->nVars * Inst->nVars
37 entrou = verdadeiro 8 * sizeof(int);
38 Sai do loop
39 fim 9 //Aloca espao no device
10 cudaMalloc((void **)d_gOPT, 2 * sizeof(int));
40 fim 11 cudaMalloc((void **)d_x, sizeSB);
41 se entrou = falso ento 12 cudaMalloc((void **)d_xInc, sizeSB);
42 i j onde j = max{min{lbpt , ubpt } para
t
t = lev + 1, . . . , n 13 cudaMalloc((void **)d_pilha, sizeP);
43 xpi 0 ou 1 dependendo do valor que menos 14 cudaMalloc((void **)d_pilhaLB, sizePlim);
15 cudaMalloc((void **)d_pilhaUB, sizePlim);
incrementa g
44 empilha({lev+1, lb, ub, g},stack) 16 cudaMallocPitch((void **)d_Q, &Pitch, sizenVars, Inst->nVars);
45 fim 17 cudaMallocPitch((void **)d_p, &PitchSub, sizenSubProb,
46 lev lev + 1 18 Inst->nVars);
47 plev pi %Troca de valores de plev e pi 19 cudaMallocPitch((void **)d_lb, &PitchSub, sizenSubProb,
48 fim 20 Inst->nVars);
49 fim 21 cudaMallocPitch((void **)d_ub, &PitchSub, sizenSubProb,
50 fim 22 Inst->nVars);
51 Copia o vetor gOP T da GPU para a CPU
23 //Copia dados para o device
52 Copia o vetor x iniciando na posio indicada por gOP T1 da GPU 24 cudaMemcpy2D(*d_Q, Pitch, Inst->getMatriz(), size, size,
para a CPU 25 Inst->nVars, cudaMemcpyHostToDevice);

26 //Espao para a matriz Q e para os vetores ilb e iub

27 int sMem = Inst->nVars * Inst->nVars * sizeof(int)
28 + 2 * Inst->nVars * sizeof(int); esquema de armazenamento da matriz d_p, onde n o nmero
29 BB_Kernel<<<Blocks,nThreadsPerBlock, sMem>>>(d_Q,
de variveis da instncia, m o nmero de subproblemas nos
30 Inst->nVars, d_x, d_xInc, d_p, d_lb, d_ub, *OPT, d_gOPT, quais o problema principal foi dividido. Este nmero dado
31 d_pilha, d_pilhaLB, d_pilhaUB, pitch / sizeof(int), por 2levIni e pij representa o j-simo elemento da i-sima
32 pitchsub/ sizeof(int), nSubProb, lev);
thread.
33 cudaMemcpy(gOPT, d_gOPT, 2 * sizeof(int),
34 cudaMemcpyDeviceToHost);
35 cudaMemcpy(x, d_xInc + gOPT[1] * Inst->nVars, Inst->nVars
36 * sizeof(bool), cudaMemcpyDeviceToHost); p11 p21 p31 ... pm1

37 *OPT = gOPT[0];
38 ... p12 p22 p32 ... pm2
p p23 p33 ... pm3
d_p = 13
. .. .. .. ..
Cdigo 1: Cpias de Dados e Chamada do Kernel no .. . . . .
Branch and Bound p1n p2n p3n ... pmn

O Cdigo 1 apresenta parte do programa que exe-

cutado na CPU. Neste trecho apresentamos como aloca-
mos espaos de memria na GPU, com os comandos Portanto, para que a i-sima thread acesse a j-sima
cudaMalloc e cudaMallocPitch. Ambos os comandos posio do vetor p, deve-se utilizar o seguinte comando:
reservam uma seo contgua de memria, porm o comando p[j * pitch + i].
cudaMallocPitch destinado para matrizes. Ele cria um
espao vazio entre cada linha da matriz, gerando um alinha-
mento dos dados na memria global, ou seja, os dados de
uma linha da matriz sempre comeam em um endereo que
potncia de 2. Com isso pode-se aumentar a performance do 1 __host__ __device__ int calculaG_cuda(int *Q, int nVars,
2 int lev, const bool *x, int *p, int pitchsub, int tid)
programa ao acessar os dados desta matriz, que inicialmente 3 {
reside na memria global. O comando cudaMallocPitch 4 int i, j, pi, pj, qAux, g = 0;
retorna um valor, pitch, que indica o tamanho da rea de 5 bool xpi, xpj, xpixpj;
6 int *__pi, *__pj, *__Q;
dados somado a rea vazia. A Figura 3 mostra um esquema
do armazenamento dos dados na memria. 7 __pi = p+tid;
8 for(i = 0; i < nVars; i++){
9 pi = *__pi; __pi += pitchsub;
10 xpi = x[pi];
Pitch
11 if(i < lev)
12 //Terceira parte
1 Linha 2 Linha n-sima Linha 13 g -= negativo_cuda(Q[pi * nVars + pi] * (1 - xpi));
rea de dados rea vazia
14 __pj = p+tid;
15 __Q = &Q[pi * nVars];
16 for(j = 0; j < nVars; j++){
Figura 3: Matriz Linearizada Alocada com o Comando cuda- 17 pj = *__pj; __pj += pitchsub;
MallocPitch 18 xpj = x[pj];
19 qAux = *(__Q + pj);
20 xpixpj = xpi * xpj;

21 //Primeira parte
As matrizes d_pilha, d_pilhaLB e d_pilhaUB so 22 g += negativo_cuda(qAux);
armazenadas em matrizes linearizadas sem alinhamento de
memria. Enquanto as matrizes d_Q, d_p, d_lb e d_ub 23 if((i < lev) && (j > i)){
24 if(j < lev)
so armazenadas em matrizes linearizadas com alinhamento 25 //Segunda parte
de memria. 26 g -= 2 * negativo_cuda(qAux * (1 - xpixpj));
27 else
A matriz Q copiada da CPU para a GPU por meio do 28 //Segunda parte
29 g -= 2 * negativo_cuda(qAux * (1 - xpi));
comando cudaMemcpy2D, que faz a cpia de dados para uma 30 }
rea alocada pelo comando cudaMallocPitch. A varivel 31 if(j < lev)
sMem guarda o valor do tamanho em bytes que ser utilizado 32 //Quarta parte
33 g += positivo_cuda(qAux * xpixpj);
na memria compartilhada. Em seguida feita a chamada do 34 }
kernel, onde executado todo o cdigo do B&B. Por fim 35 }
feita a cpia dos vetores d_xInc e gOPT da GPU para a 36 return g;
37 }
CPU.
importante notar que cada coluna nas matrizes d_p,
d_lb e d_ub representam os vetores p, lb e ub, que cada Cdigo 2: Funo calculaG_cuda do Kernel no Branch
thread utiliza individualmente. Os dados foram armazenados and Bound
desta forma para possibilitar o acesso combinado memria
global, embora para d_lb e d_ub nem sempre isto seja
possvel. Esta forma de armazenamento dos dados gerou um
bom ganho em termos de speedup. A matriz a seguir ilustra o O Cdigo 2 efetua o clculo do limitante inferior funo
objetivo por meio da seguinte frmula: A situao (a) indesejvel, (b) o comportamento mais
n X
n comum, (c) a situao ideal, mas s ocorre se no houver

X
g2 = qij sobrecarga e (d) possvel. Um speedup supralinear ocorre,
i=1 j=1 por exemplo, quando um programa sequencial no consegue
armazenar todos os dados necessrios para o processamento
| {z }
P rimeira P arte
lev  X
X lev n
X  na memria RAM, enquanto a verso distribuda consegue, ao
2 qpi pj (1 xpi xpj ) + qpi pj (1 xpi ) utilizar mais computadores em que cada computador resolve
i=1 j=i+1 j=lev+1 parte do problema sem a necessidade de acessar o disco rgido
novamente durante sua execuo.
| {z }
Segunda P arte
lev
X
! lev X
X lev Definio 2. A Eficincia mede o aproveitamento dos recursos
+ qpi pi (1 xpi ) + qp+i pj xpi xpj computacionais disponveis. Ela a razo entre o speedup S(p)
i=1 i=1 j=1
| {z } | {z } e o nmero de processadores utilizados. Formalmente temos:
T erceira P arte Quarta P arte E(p) = S(p) T (1)
p = pT (p)
Definio 3. O Trabalho de um programa a soma dos
A funo calculaG_cuda foi desenvolvida para reduzir tempos de execuo de cada processo. Formalmente: W (p) =
o acesso s variveis que residem na memria global, uti- pT (p)
lizando as variveis auxiliares pi, pj, qAux, xpi, xpj e
xpixpj. Os ponteiros *__pi, *__pj e *__Q auxiliam no Definio 4. Sobrecarga a diferena entre o trabalho re-
acesso s matrizes, reduzindo operaes de multiplicao ao alizado por um programa paralelo e sua verso sequencial.
acessar os seus elementos. Formalmente: T0 = pT (p) T (1)
Definio 5. A Lei de Amdahl diz: Seja 0 f 1 a frao
Na prxima seo apresentamos os resultados computacio- da computao que s pode ser realizada sequencialmente, o
nais, que foram obtidos pelas implementaes dos algoritmos speedup mximo que um programa paralelo com p processa-
descritos nesse trabalho. dores pode obter : S(p) f +11f
p

V. E XPERIMENTOS C OMPUTACIONAIS
Nesta seo apresentamos os resultados computacionais
dos mtodos que implementamos para tentar resolver instn-
cias do UQP. Primeiro, definimos conceitos utilizados na rea
de programao paralela. Segundo, descrevemos o ambiente
computacional onde os experimentos so realizados. Terceiro,
apresentamos uma descrio dos conjuntos de instncias com
as quais os mtodos so testados. Quarto, os resultados
computacionais so apresentados para as implementaes dos
mtodos Tabu Search (TS), uma verso sequencial e outra
paralela de um Branch and Bound (B&B) que aparece em
[13] .
A seguir apresentamos algumas definies de mtricas, que
utilizaremos ao longo desta seo, para realizar comparao
entre as implementaes dos algoritmos.
Definio 1. O speedup mede quantas vezes mais rpido
a execuo de um programa em paralelo em relao ao
sequencial. Formalmente temos: S(p) = TT (p)
(1)
, onde T (1)
o tempo de execuo com 1 processador e T (p) o tempo de
execuo com p processadores.
De forma geral: 0 S(p) p. Se S(p) = p ento o
speedup chamado de linear. raro ocorrer speedup linear,
pois na maioria dos programas paralelos h perda de tempo
de processamento devido distribuio dos dados e pela
comunicao entre os processos.
As seguintes situaes podem ocorrer com o speedup em
programas paralelos:
A. Ambiente dos Experimentos
Os experimentos computacionais foram todos executados
em um computador com a seguinte configurao: Compu-
tador: Processador Intel Core i7 3930K, 6 Ncleos de 3.2
GHz, 32 GB de Memria RAM; GPU: 2 placas NVIDIA
EVGA GeForce GTX 680 (Arquitetura Kepler GK104), 1006
MHz, 64 bits, 8 SMX (Nova gerao de multi-processadores),
1536 Ncleos 2 GB Memria Global; Sistema Operacional:
Linux Ubuntu 12.04, 64 bits; Compilador: nvcc release 5.0,
V0.2.1221 para verso sequencial e paralela.
B. Instncias da OR Library
A OR Library um acervo que contm vrios conjuntos
de instncias para diversos problemas de otimizao com-
binatria. Especificamente, as instncias do UQP esto dis-
ponveis no site: http://people.brunel.ac.uk/~mastjjb/jeb/orlib/
bqpinfo.html. Todas estas instncias so para problemas de
maximizao. Cada instncia do UQP identificada por
bqpn, onde bqp significa binary quadratic programming e
n indica o nmero de variveis.
As instncias dessa classe possuem uma densidade de
aproximadamente 10% de constantes com valores diferentes de
zero, ou seja, as matrizes das instncias testadas so esparsas.

(a) Slowdown: T (1) < T (p) e portanto S(p) < 1. C. Instncias de uma Classe Difcil
(b) Sublinear: 1 < S(p) < p. Esta uma classe de instncias para problemas de mi-
(c) Linear: S(p) = p. nimizao, que segundo Pardalos e Rodgers [27] so de
difcil resoluo. Elas tm coeficientes inteiros na matriz Q
(d) Supralinear: p < S(p). e possuem um nmero exponencial de mnimos locais. A
frmula geral para estas instncias : execuo das duas implementaes cresceu quando aumentou-
n/2
se o nmero de variveis. Os desvios padro dos tempos de
n
X X X execuo so pequenos, considerando todas instncias nas duas
min f (x) = n(n 1) xi xi + n xi xj implementaes.
i=1 i=1 i<j
X Para realizar uma anlise dos resultados usamos as m-
+n xi xj
tricas: speedup, eficincia, trabalho, sobrecarga e a Lei de
i>j
Amdahl. As Tabelas II e III apresentam os valores das mtricas
sujeito a: x {0, 1}n . considerando as implementaes sequencial e a paralela do TS.
Esta classe de instncias interessante, porque a heurstica As colunas sob o ttulo Mtricas apresentam os valores dos
Gradient Midpoint Method (Seo II-D2) sempre encontra clculos das mtricas para cada classe de instncias, onde a
uma soluo tima, embora seja muito difcil prov-la com eficincia dada em porcentagem e o trabalho e a sobrecarga
o mtodo Branch and Bound. so dados em minutos, horas e dias; a coluna Lei de Amdahl
1536 procs. uma referncia do mximo speedup terico desse
Estas instncias so identificadas por cdn, onde cd sig- algoritmo paralelizado com 1536 processadores.
nifica classe difcil e n representa o nmero de variveis da
instncia. As instncias desta classe possuem uma densidade As anlises apresentadas nas Tabelas II e III sobre as
de 100% de constantes com valores diferentes de zero, ou seja, mtricas so feitas para os tempos de execuo apresentados
as matrizes das instncias testadas desta classe so densas. na Tabela I. A Lei de Amdahl calculada com base na
porcentagem no paralelizvel do algoritmo, que apresentada
na Tabela IV.
D. Comparaes entre as implementaes do Tabu Search
Sequencial e Paralelo utilizando Reclculo com Mudana de Instncias Lei de Amdahl
uma Varivel Nome 1536 procs.
bqp50 6,69
Nesta seo so comparados os tempos de execuo das bqp100 20,50
verses sequencial e paralela das implementaes do TS. O bqp250 82,68
critrio de parada em ambas de 50.000n vizinhos, onde n bqp500 182,42
o nmero de variveis da instncia. Na Tabela I so apresen- bqp1000 355,24
tados os resultados para uma anlise dos tempos de execuo bqp2500 243,04
das duas implementaes. Nestes experimentos foi utilizado
Tabela II: Lei de Amdahl para o TS com Reclculo com
uma GPU. As colunas Tempo Mdio e Desvio mostram os
Mudana de uma Varivel.
tempos mdios e os desvios padro dos tempos de execuo,
considerando as 10 instncias com a mesma quantidade de
variveis.
Instncias Mtricas
Instncias Sequencial Nome Speedup Eficincia Trabalho Sobrecarga
Nome Tempo Mdio (s) Desvio (s) bqp50 0,23 0,02 57,46m 57,45m
bqp50 0,52 0,01 bqp100 0,61 0,04 1,11h 1,11h
bqp100 1,57 0,01 bqp250 2,58 0,17 1,48h 1,48h
bqp250 8,95 0,05 bqp500 5,58 0,36 2,94h 2,92h
bqp500 38,38 0,06 bqp1000 23,92 1,56 5,33h 5,24h
bqp1000 298,57 0,30 bqp2500 44,79 2,92 1,05d 1,02d
bqp2500 2.645,12 2,36
Tabela III: Mtricas para o TS com Reclculo com Mudana
de uma Varivel. Os smbolos m, h e d significam minutos,
Instncias Paralelo
Nome Tempo Mdio (s) Desvio (s)
horas e dias.
bqp50 2,24 0,01
bqp100 2,60 0,00
bqp250 3,47 0,01
bqp500 6,88 0,03 Tempo (s)
bqp1000 12,48 0,10 10000
Programa Sequencial
bqp2500 59,05 2,54 1000
Programa Paralelo
100
Tabela I: Comparao entre as implementaes sequencial e
10
paralela do Tabu Search, com reclculo do valor da funo
1
objetivo com mudana no valor de uma varivel.
0,1
bqp50 bqp100 bqp250 bqp500 bqp1000 bqp2500

Da Tabela I e da Figura 4 notamos que para as instncias
pequenas, bqp50 e bqp100, a implementao sequencial exe-
cutou mais rpido que a paralela. Para as instncias bqp250,
bqp500, bqp1000 e bqp2500 a implementao paralela foi
mais rpida que a sequencial. A diferena entre os tempos de
Figura 4: Comparao entre as implementaes sequencial e
paralela do Tabu Search, com reclculo do valor da funo
objetivo com mudana no valor de uma varivel. Os tempos
esto em escala logartmica.
 Das Tabelas II e III percebemos que para as instncias pe-
quenas, bqp50 e bqp100, temos um speedup do tipo Slowdown.
Para as outras instncias ocorre um speedup Sublinear, che-
gando em at 44,79 para as instncias bqp2500. As eficincias
so menores que 3% e os trabalhos e sobrecarga chegam at
1 dia. De fato a sobrecarga realizada pelo programa paralelo
muito grande, s se atinge os speedups obtidos devido a
grande quantidade de ncleos na GPU. A Figura 5 mostra o
grfico para o speedup. As definies sobre os tipos de speedup
encontram-se na Definio 1.
Para realizar o clculo da Lei de Amdahl, apresentado na
Tabela II, necessrio previamente obter o valor da constante
f , que representa a frao da computao que s pode ser
realizada sequencialmente, como apresentamos na Definio
5. Pode-se calcular o valor de f de duas maneiras:
Se o algoritmo tem um fluxo bem comportado,
possvel fazer uma anlise do algoritmo e determinar
qual a poro, nmero no intervalo [0, 1], do algoritmo
que s pode ser executada sequencialmente;
Se o fluxo do algoritmo for complexo, uma aborda-
gem emprica pode ser adotada. Dentro do programa
sequencial criam-se dois contadores: Ts para a parte
que s pode ser executada sequencialmente e Tp
para a parte perfeitamente paralelizvel. Atribu-se aos
contadores a quantidade de tempo despendida para
realizar cada parte do algoritmo. O clculo feito da
Ts
seguinte forma f = . tado como entrada para a implementao sequencial do Tabu
Ts + Tp
A Tabela IV apresenta os valores de Ts, Tp e f que
foram obtidos de forma experimental, onde a coluna Ts, em
milissegundos (ms), representa o tempo mdio de execuo da
parte do algoritmo que s pode ser executada sequencialmente;
a coluna Tp (ms) representa o tempo mdio de execuo da
parte do algoritmo que pode ser perfeitamente paralelizvel;
f representa a porcentagem do algoritmo que s pode ser
executada de forma sequencial. Os valores dos tempos so
apresentados em milissegundos para no se perder preciso
numrica ao efetuar o clculo do valor de f.
Observando os resultados apresentados na Tabela IV, nota-
se que ao aumentar o nmero de variveis nas instncias
testadas, diminuiu o valor na coluna f, com exceo para as
instncias bqp2500. Isto ocorreu porque para estas instncias,
a implementao executou proporcionalmente mais vezes a
busca local do que para as outras instncias. Como a busca
Speedup
50
40
30
20
10
0 B&B sequencial; A coluna Tempo Paralelo (ms) indica o
bqp50 bqp100 bqp250 bqp500 bqp1000 bqp2500
Figura 5: Mtrica speedup para a implementao do Tabu Se-
arch, com reclculo do valor da funo objetivo com mudana
no valor de uma varivel.
local no foi paralelizada, isto causou um aumento na parte
sequencial.
Instncias Tempos Parte Sequencial
Nome Ts (ms) Tp (ms) f (%)
bqp50 77,53 442,87 14,8982
bqp100 75,77 1.497,38 4,8164
bqp250 102,53 8.850,80 1,1451
bqp500 185,53 38.195,48 0,4833
bqp1000 696,69 297.868,71 0,2333
bqp2500 9.167,57 2.635.950,99 0,3465
Tabela IV: Valores utilizados para os clculos nas Lei de
Amdahl da Tabela II. Os tempos so dados em milissegundos.
E. Comparaes entre as implementaes do Branch and
Bound Sequencial e Paralelo com Clculo do Valor da Funo
Objetivo na Forma Bsica
Nesta seo fazemos uma comparao entre as verses
sequencial e paralela da implementao do B&B e exibimos
mtricas de desempenho para estas verses. No fizemos uma
anlise da Lei de Amdahl para estas implementaes, pois todo
o mtodo foi paralelizado. Assim, os valores para essa mtrica
so muito prximos ou iguais ao nmero de processadores da
execuo de maneira paralela.
Inicialmente executamos a implementao sequencial do
mtodo Gradient Midpoint Method, fornecemos o seu resul-
Search e ento executamos o mtodo Branch and Bound
fornecendo como entrada a soluo encontrada pelo TS. O
critrio de parada do TS foi um nmero mximo de 5.000n
iteraes ou se no obtiver uma soluo melhor que a melhor
encontrada por 500n iteraes, onde n o nmero de variveis
da instncia.
A implementao paralela dividiu o problema principal de
cada instncia em 214 subproblemas de igual tamanho, que
foram resolvidos utilizando o Algoritmo IV.4. A quantidade de
subproblemas a ser utilizado foi decidida de forma emprica e
214 foi a que surtiu melhores resultados.
As Tabelas V e VI exibem as comparaes entre as verses
sequencial e paralela do mtodo B&B executadas para as
instncias de 50 variveis da OR Library (que so problemas
de maximizao, ver Seo V-B) e para instncias da classe
difcil (que so problemas de minimizao, ver Seo V-C). A
coluna Instncias indica a instncia testada. A coluna GMM
contm os valores das solues obtidas pelo mtodo Gradient
Midpoint Method; A coluna TS contm os valores das solues
obtidas pelo mtodo Tabu Search; A coluna B&B contm os
valores das solues obtidas pelo mtodo Branch and Bound;
A coluna NSUBP indica o nmero de subproblemas resolvidos
pelo mtodo B&B sequencial (ver Linha 13 do Algoritmo
II.4); A coluna Tempo Sequencial (ms) indica o tempo, em
milissegundos, das execues da implementao do mtodo
tempo, em milissegundos, das execues da implementao
do mtodo B&B paralelo;
Das Tabelas V e VI podemos concluir que o mtodo
Gradient Midpoint Method forneceu solues com valor, em
mdia, aproximadamente 80% do valor de uma soluo tima,
 para as instncias bqp50.x. J para as instncias da classe
difcil, esse mtodo encontrou solues timas, mas no po-
demos esquecer que esta uma caracterstica especfica destas
Valores das Solues instncias, conforme destacada na Seo II-D2. O mtodo
Instncias GMM TS B&B NSUBP
Tabu Search encontrou solues com valores, em mdia,
bqp50.1 1.011 2.098 2.098 228
bqp50.2 2.570 3.678 3.702 211 99,9% do valor de uma soluo tima. Para as instncias
bqp50.3 3.442 4.626 4.626 264 bqp50.x, a implementao sequencial do mtodo B&B foi
bqp50.4 2.817 3.502 3.544 50 mais rpida que a paralela e a instncia que precisou resolver
bqp50.5 3.244 4.012 4.012 65 mais subproblemas foi a bqp50.8, com 518 subproblemas
bqp50.6 3.284 3.693 3.693 31 resolvidos. Para as instncias da classe difcil, a implementao
bqp50.7 3.586 4.520 4.520 42 paralela do B&B foi mais rpida que a sequencial e a instncia
bqp50.8 3.578 4.216 4.216 518 que menos precisou resolver subproblemas foi a cd12 com
bqp50.9 3.018 3.780 3.780 243 924 subproblemas resolvidos. interessante notar que para
bqp50.10 3.057 3.507 3.507 314 as instncias da classe difcil, os nmeros de subproblemas
cd12 -438 -438 -438 924 crescem rapidamente com o aumento do nmero de variveis.
cd14 -693 -693 -693 3.432 Talvez isto acontea devido a grande quantidade de mnimos
cd16 -1.032 -1.032 -1.032 12.870 locais em cada instncia.
cd18 -1.467 -1.467 -1.467 48.620
cd20 -2.010 -2.010 -2.010 184.756 A Tabela VII mostra os valores para as mtricas envolvendo
cd22 -2.673 -2.673 -2.673 705.432 as implementaes sequencial e a paralela do B&B, com
cd24 -3.468 -3.468 -3.468 2.704.156 relao aos tempos de execuo exibidos na Tabela VI. As
cd26 -4.407 -4.407 -4.407 10.400.600 colunas sob o ttulo Mtricas apresentam o valor do clculo
cd28 -5.502 -5.502 -5.502 40.116.600
cd30 -6.765 -6.765 -6.765 155.117.520
das mtricas para cada classe de instncias, onde a eficincia
dada em porcentagem e o trabalho e a sobrecarga so dados
Tabela V: Resultados das implementaes sequencial e para- em segundos, minutos, horas e dias;
lelo do mtodo Branch and Bound, com clculo do valor da
Instncias Mtricas
funo objetivo na forma bsica. Nome Speedup Eficincia (%) Trabalho Sobrecarga
bqp50.1 0,58 0,04 14,48m 14,47m
bqp50.2 0,47 0,03 16,24m 16,24m
bqp50.3 0,76 0,05 11,05m 11,04m
bqp50.4 0,80 0,05 7,94m 7,94m
bqp50.5 0,75 0,05 8,61m 8,61m
bqp50.6 0,23 0,01 26,40m 26,40m
bqp50.7 0,57 0,04 11,37m 11,36m
bqp50.8 0,58 0,04 18,40m 18,39m
Tempos do B&B bqp50.9 0,32 0,02 28,59m 28,58m
bqp50.10 0,67 0,04 20,17m 20,16m
Instncias Sequencial (ms) Paralelo (ms)
bqp50.1 328,85 565,64 cd12 12,68 0,83 4,01s 3,98s
cd14 32,55 2,12 4,07s 3,98s
bqp50.2 300,95 634,45 cd16 102,40 6,67 6,01s 5,61s
bqp50.3 326,05 431,55 cd18 79,05 5,15 36,83s 34,94s
bqp50.4 248,46 310,21 cd20 89,26 5,81 2,64m 2,49m
bqp50.5 251,48 336,3 cd22 89,44 5,82 12,31m 11,60m
bqp50.6 236,63 1.031,27 cd24 87,85 5,72 57,39m 54,11m
bqp50.7 252,27 443,99 cd26 83,75 5,45 4,35h 4,11h
bqp50.8 419,90 718,59 cd28 85,48 5,56 19,09h 18,03h
bqp50.9 356,71 1.116,65 cd30 84,09 5,47 3,59d 3,39d
bqp50.10 528,33 787,89
Tabela VII: Mtricas para o B&B com clculo do valor da
cd12 33,10 2,61
cd14 86,27 2,65 funo objetivo na forma bsica. Os smbolos s, m, h e d cor-
cd16 400,40 3,91 respondem a segundos, minutos, horas e dias respectivamente.
cd18 1.895,58 23,98
cd20 9.209,26 103,17
cd22 43.024,38 481,03 Da Tabela VII podemos inferir que para as instncias
cd24 196.950,53 2.241,91 bqp50.x o speedup do tipo Slowdown, que a eficincia
cd26 854.008,21 10.196,92 inferior a 1% e que o maior trabalho se deu para a instncia
cd28 3.823.914,82 44.737,21 bqp50.9 com 28,59 minutos. Para as instncias da classe difcil
cd30 16.986.797,41 202.012,91 o speedup do tipo sublinear. O maior speedup foi de 102,40
que foi para a instncia cd16 e para as instncias de 20 a
Tabela VI: Tempos de execuo das implementaes sequen- 30 variveis o speedup em mdia de 86,64. Notamos que a
cial e paralelo do mtodo Branch and Bound, com clculo do mtrica sobrecarga tem valores muito prximos aos da mtrica
valor da funo objetivo na forma bsica. trabalho e que estas mtricas no tm uma relao direta com
o tamanho da instncia.
Em resumo: A implementao sequencial do TS resolveu
muito bem as instncias com 50 e 100 variveis da OR Library;
 Speedup
0,30
0,25
0,20
0,15
0,10
0,05
0,00
bqp50.1 bqp50.2 bqp50.3 bqp50.4 bqp50.5 bqp50.6
Figura 6: Speedup da implementao do B&B para instncias
da OR Library.
Speedup
120
100
80
60
40
20
0
cd12 cd14 cd16 cd18 cd20
Figura 7: Speedup da implementao do B&B para instncias
da classe difcil.
A implementao paralela do TS foi executada para instncias
da OR Library e obteve um speedup slowdown para instncias
de at 100 variveis e um speedup sublinear para instncias
de 250 a 2.500 variveis, chegando a ter uma acelerao de
at 44,79 vezes na execuo do programa; Quando utilizado
o clculo do valor da funo objetivo na forma bsica, o
TS paralelo obteve um speedup de at 14,74 para a verso
com memria global e de at 45,06 vezes com a verso com
memria compartilhada para as instncias de 1.000 variveis;
A implementao sequencial do B&B resolveu instncias da
OR Library de 50 variveis e instncias da classe difcil com
at 30 variveis; A implementao paralela do B&B obteve
um speedup slowdown para instncias da OR Library com
50 variveis e um speedup sublinear para instncias da classe
difcil com at 30 variveis, chegando a ter uma acelerao
de at 102,4 vezes na execuo do programa; Conclumos que
resolver instncias do UQP realmente um grande desafio,
mesmo utilizando processadores com grandes quantidades de
ncleos, ou seja, utilizando GPUs.
VI. C OMENTRIOS F INAIS
Neste trabalho estudamos o problema de programao qua-
drtica binria irrestrita, que chamamos de UQP, mtodos para
resolv-lo e como implement-los de maneira paralela com
placas grficas, GPUs. O UQP pertence a classe de complexi-
dade NP-difcil e um problema interessante porque muitos
problemas de otimizao combinatria podem ser modelados
desta maneira. Desenvolvemos verses sequenciais e paralelas
de mtodos no exatos, conhecidos como metaheursticas, e
um mtodo exato, Branch and Bound.
Nas verses paralelas utilizamos a arquitetura CUDA da
NVIDIA. Com esta arquitetura possvel usar os vrios
ncleos disponveis nas GPUs para executar programas de
propsito geral que so executados nas GPUs. Realizamos
tambm contribuies terica para o estudo do UQP, espe-
cificamente para a forma como o reclculo do valor da funo
objetivo pode ser feito.
O clculo do valor da funo objetivo na forma tradicional
tem complexidade computacional de O(n2 ) e o reclculo,
por ns apresentado, possui complexidade linear. Propusemos
uma maneira de calcular um limitante inferior para o valor
bqp50.7 bqp50.8 bqp50.9 bqp50.10
da funo objetivo, que fornece valores maiores ou iguais
aos mtodos apresentados na literatura, que utilizado no
mtodo Branch and Bound descrito na referncia [13]. Tam-
bm desenvolvemos um reclculo para o limitante inferior
da funo objetivo com complexidade computacional linear.
Implementamos de maneira sequencial as heursticas Tabu
Search, Gradient Midpoint Method e uma Busca Local, alm
disso implementamos um mtodo exato do tipo Branch and
Bound. De forma paralela com GPUs, implementamos os
mtodos Tabu Search e o Branch and Bound.
Para analisar a eficincia de nossas implementaes, utili-
zamos duas classes de instncias reportadas na literatura. Uma
cd22 cd24 cd26 cd28 cd30 classe de instncias est disponvel na OR Library e a outra
est definida em [13], que considerada de difcil resoluo.
Quanto ao paralelismo, conseguimos acelerar a implementao
do mtodo Tabu Search em at 44 vezes e a implementao
do mtodo Branch and Bound em at 102 vezes, dependendo
da instncia testada.
AGRADECIMENTO
Expresso aqui minha gratido a todos que me apoiaram
durante este trabalho e agradeo pelo financiamento feito a este
trabalho pela UFABC, CAPES e FAPESP (processo nmero
2012/06027-5).
R EFERNCIAS
[1] Bixby, R. E., Notes on Combinatorial Optimization, 1987.
[2] Pardalos, P. M. and Rosen, J. B., Constrained Global Optimization:
Algorithms and Applications (Lecture Notes in Computer Science).
Springer-Verlag, 1987.
[3] Beasley, J. E., Heuristic Algorithms for the Unconstrained Binary
Quadratic Programming Problem, Working Paper, Imperial College,
Tech. Rep., 1999.
[4] Bahram, A., Glover, F., Kochenberger, G. A. and Rego, C., One-Pass
Heuristics for Large-Scale Unconstrained Binary Quadratic Programs,
European Journal of Operational Research, vol. 137, pp. 272287,
2002.
[5] Merz, P. and Freisleben, B., Greedy and Local Search Heuristics for
the Unconstrained Binary Quadratic Programming Problem, Journal
of Heuristics, vol. 8, no. 2, pp. 197213, 2002.
[6] , Genetic Algorithms for Binary Quadratic Programming, in in
GECCO-1999: Proceedings of the Genetic and Evolutionary Computa-
tion Conference. Morgan Kauffman, 1999, pp. 417424.
[7] Bahram, A., Glover, F., Kochenberger, G. A. and Rego, C., A Unified
Modeling and Solution Framework for Combinatorial Optimization
Problems, OR Spectrum, vol. 26, no. 2, pp. 237250, 2004.
[8] , An Unconstrained Quadratic Binary Programming Approach to
the Vertex Coloring Problem, Annals of operations research, vol. 139,
no. 1, pp. 229141, 2003.
[9] , A New Modeling and Solution Approach for the Number
Partitioning Problem, Journal of Applied Mathematics and Decision
Sciences, pp. 113121, 2005.
[10] Bahram, A., Glover, F., Kochenberger, G. A. and Wang, H., Solving the
Maximum Edge Weight Clique Problem via Unconstrained Quadratic
Programming, European Journal of Operational Research, vol. 181,
no. 2, pp. 592597, 2007.
[11] , An Effective Modeling and Solution Approach for the Genera-
lized Independent Set Problem, Optimization Letters, vol. 1, no. 1, pp.
111117, 2007.
[12] Palubeckis, G., A Heuristic-Based Branch and Bound Algorithm
for the Unconstrained Quadratic Zero-One Programming Problem,
Computing, pp. 284301, 1995.
[13] Pardalos, P. M. and Rodgers, G. P., Computational Aspects of a
Branch and Bound Algorithm for Quadratic Zero-One Programming,
Computing, vol. 45, no. 2, pp. 131144, 1990. [Online]. Available:
http://dx.doi.org/10.1007/BF02247879
[14] Billionet, A. and Sutter, A., Minimization of a Quadratic Pseudo-
Boolean Function, European Journal of Operational Research, vol. 78,
pp. 106115, 1994.
[15] Helmberg, C. and Rendl, F., Solving Quadratic (0,1)-Problems by Se-
midefinite Programs and Cutting Planes, Mathematical Programming,
vol. 82, pp. 291315, 1998.
[16] Pardalos, P. and Rodgers, G. P., A Branch and Bound Algorithm for
Maximum Clique problem, Computers & Operations Research, vol. 19,
pp. 363375, 1992.
[17] Barahona, F., A Solvable Case of Quadratic 0-1 Programming,
Discrete Applied Mathematics, vol. 13, no. 1, pp. 2326, 1986.
[18] Chakradhar, S. T. and Bushnell, M. L., A Solvable Class of Quadratic
0-1 Programming, Discrete Applied Mathematics, vol. 36, no. 3, pp.
233251, 1992.
[19] Gu, S., A Polynomial Time Solvable Algorithm to Linearly Cons-
trained Binary Quadratic Programming Problems with Q being a
Tri-Diagonal Matrix, Advances in Information Sciences and Service
Sciences, vol. 3, no. 6, pp. 6572, 2011.
[20] Li, D., Sun, X., Gu, S., Gao, J. and Liu, C., Polynomially Solvable Ca-
ses of Binary Quadratic Programs, Optimization and Optimal Control,
Springer Optimization and Its Applications, pp. 199225, 2010.
[21] Hammer, P. L. and Rudeanu, S., Boolean Methods in Operations
Research. Springer-Verlag, New York, 1968.
[22] Glover, F. and Laguna, M., Modern Heuristic Techniques for Combi-
natorial Problems. Blackwell Scientific, 1993, ch. Tabu Search, pp.
71140.
[23] Horst, R. and Pardalos, P. M. and Thoai, N. V., Introduction to Global
Optimization. Kluwer Academic Publishers, 2000.
[24] Pardalos, P. M. and Rodgers, G. P., Parallel Branch and Bound
Algorithms for Quadratic Zero-One Programs on the Hypercube
Architecture, Annals of Operations Research, vol. 22, no. 1, pp. 271
292, 1990. [Online]. Available: http://dx.doi.org/10.1007/BF02023057
[25] Luong, T. V. and Melab, N. and Talbi, E. G., Parallel Local Search on
GPU, Institut National de Recherche en Informatique et en Automati-
que, Tech. Rep., 2009.
[26] Lu, Z., Glover, F. and Hao, J., Neighborhood Combination for
Unconstrained Binary Quadratic Problems, in MIC 2009: The VIII
Metaheuristics International Conference, 2009, pp. 17.
[27] Pardalos, P. M. and Rodgers, G. P., Parallel Branch and Bound
Algorithms for Unconstrained Quadratic Zero-One Programming. In:
Impacts of Recent Computer Advances on Operation Research. R.
Sharda et al., 1989.