UNIVERSIDADE FEDERAL DO RIO GRANDE DO SUL

INSTITUTO DE INFORMTICA
CURSO DE BACHARELADO EM CINCIA DA COMPUTAO

FLIX CARVALHO RODRIGUES

Programao Dinmica Eficiente com

Algoritmos Cache-Oblivious

Trabalho de Graduao

Prof. Dr. Marcus Ritt

Orientador

Profa . Dra . Luciana Salete Buriol

Co-orientador

Porto Alegre, Dezembro de 2008

UNIVERSIDADE FEDERAL DO RIO GRANDE DO SUL

Reitor: Prof. Jos Carlos Ferraz Hennemann
Vice Reitor: Prof. Pedro Cezar Dutra da Fonseca
Pr-Reitor de Graduao: Prof Carlos Alexandre Netto
Diretor do Instituto de Informtica: Prof. Flvio Rech Wagner
Coordenador da Comisso de Graduao da CIC: Prof. Raul Fernando Weber
Bibliotecria-Chefe do Instituto de Informtica: Beatriz Regina Bastos Haro

We apologise for the inconvenience

G OD S F INAL M ESSAGE TO H IS C REATION
(T HE H ITCHHIKER S G UIDE TO THE G ALAXY )

AGRADECIMENTOS

Agradeo principalmente ao meu pai, Osvaldir Rodrigues, por sempre acreditar em

mim e me apoiar em todos os meus objetivos, no interessando o grau de dificuldade deles,
assim como compreender o quanto ele significa para mim, mesmo eu no demonstrando
isso.
Agradeo muito a minha me, Helena Carvalho, e minha irm, Priscila Carvalho, pelo
imenso carinho recebido e pela compreenso de que apesar de eu passar muito pouco
tempo fisicamente com elas, eu as amo muito.
Agradeo tambm:
Ao meu colega e amigo Daniel Osmari, pelo modelo de determinao, inspirao e
por me mostrar que eu necessito me esforar para ser o melhor sempre.
Aos meus amigos Kao Flix, Daniel Beck, Mrcio Zacarias e Letcia Nunes, pela
diverso e grande apoio nas horas mais difceis, alm das constantes discusses estimulantes.
E por fim, aos meus orientadores Prof. Dr. Marcus Ritt e Profa . Dra . Luciana Salete
Buriol, pela excelente orientao, pela quantidade de informao adquirida e pelo exemplo a ser seguido.

SUMRIO

LISTA DE ABREVIATURAS E SIGLAS . . . . . . . . . . . . . . . . . . . .

LISTA DE FIGURAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

10

RESUMO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

11

ABSTRACT

12

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 INTRODUO . . . . . . . . .
1.1
Hierarquias de Memria . . .
1.2
Outros Modelos . . . . . . . .
1.2.1
RAM . . . . . . . . . . . . .
1.2.2
Memria Externa . . . . . .

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

. . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .

13
14
15
15
16

2 ALGORITMOS CACHE-OBLIVIOUS . .
2.1
Modelo de cache Ideal . . . . . . . . . .
2.1.1
Poltica de Substituio . . . . . . . . .
2.1.2
Nveis de Memria . . . . . . . . . . .
2.1.3
Associatividade e Reposio Automtica
2.2
Algoritmos Estudados . . . . . . . . . .
2.2.1
Maior Subseqncia Comum . . . . . .
2.2.2
Multiplicao de Matrizes . . . . . . . .
2.2.3
Gap Problem . . . . . . . . . . . . . .

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

. . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .

17
17
18
18
19
19
20
21
22

3 BIN PACKING . . . . . . . . . . . . . . . . . . . .
3.1
Solues para o Empacotamento Unidimensional
3.1.1
Heursticas e Meta-heursticas . . . . . . . . . .
3.1.2
Algoritmos Exatos . . . . . . . . . . . . . . . . .

.
.
.
.

.
.
.
.

. . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .

24
24
24
24

4 PROBLEMA DA MOCHILA . . . . .
4.1
Problema . . . . . . . . . . . . . . .
4.2
Variaes . . . . . . . . . . . . . . .
4.2.1
Problema Fracionrio da Mochila . .
4.2.2
Problema Booleano da Mochila . . .
4.2.3
Problema da Mochila Limitado . . .
4.3
Problema da Mochila No Limitado
4.3.1
Dominncias . . . . . . . . . . . . .

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

. . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .

26
26
27
27
27
27
28
28

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

SOLUO CACHE-OBLIVIOUS PARA O PROBLEMA DA MOCHILA

ILIMITADO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.1
Soluo Tradicional . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2
Soluo Cache-Oblivious . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3
Dominncias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.4
Complexidade das Solues . . . . . . . . . . . . . . . . . . . . . . . . .
5.5
Resultados Computacionais . . . . . . . . . . . . . . . . . . . . . . . . .
5.5.1
Instncias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.5.2
Comparaes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

30
30
32
33
36
39
39
40

6 CONSIDERAES FINAIS . . . . . . . . . . . . . . . . . . . . . . . .
6.1
Trabalhos Futuros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

44
45

REFERNCIAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

46

LISTA DE ABREVIATURAS E SIGLAS

RAM Random Access Machine

CPU

Central Processing Unit

LRU

Least Recently Used

FIFO

First In, First Out

LISTA DE FIGURAS

Figura 1.1:
Figura 1.2:

A memria no modelo RAM . . . . . . . . . . . . . . . . . . . . . .

O modelo de Memria Externa . . . . . . . . . . . . . . . . . . . . .

15
16

Figura 2.1:

O Modelo de cache Ideal . . . . . . . . . . . . . . . . . . . . . . . .

17

Figura 4.1:

Todos os casos em que i dominado: (a) dominncia simples, (b)

dominncia mltipla, (c) dominncia coletiva e (d) dominncia limiar

29

Figura 5.1:
Figura 5.2:
Figura 5.3:
Figura 5.4:

Figura 5.5:

Figura 5.6:
Figura 5.7:

Acesso a memria no algoritmo 5.3 . . . . . . . . . . . . . . . . . .

Acesso a memria no algoritmo 5.1 . . . . . . . . . . . . . . . . . .
Item i como um ponto no plano. Qualquer ponto nas reas destacadas
ou dominam o item i ou so dominados por ele. . . . . . . . . . . . .
Nmero de cache misses para diferentes configuraes de cache com
uma entrada de W = 250.000 e n = 10.000 para os algoritmos 5.1
(T) e 5.3 (CO) . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Nmero de cache misses para as verses que utilizam Dominncia
para diferentes configuraes de cache com uma entrada de W =
10.000.000 e n = 10.000 para os algoritmos 5.1 (T) e 5.3 (CO) . . . .
Tempo de execuo dos algoritmos 5.1 (T) e 5.3 (C), em escala logartmica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Tempo de execuo dos algoritmos 5.4 (domT) e 5.5 (domCO), em
escala logartmica. . . . . . . . . . . . . . . . . . . . . . . . . . . .

37
38
39

41

41
42
43

RESUMO

A memria nos computadores modernos geralmente est organizada em uma hierarquia complexa. Dessa forma, torna-se importante projetar algoritmos que utilizem a cache
de forma eficiente. Alm disso, as configuraes da memria e da cache tem grande variao de computador para computador. Assim, necessrio tambm que os algoritmos
desenvolvidos dependam o mnimo possvel de informaes da mquina para usar a cache
eficientemente.
No modelo de cache ideal, existem dois nveis de memria. Uma tem acesso aleatrio
e infinita (memria principal), porm tem um custo associado ao seu acesso, enquanto
que a outra de acesso rpido, porm com um tamanho finito.
Um algoritmo dito cache-oblivious se ele usa a cache de forma eficiente mesmo
sem ter nenhuma informao sobre a cache. Para medirmos a complexidade desse tipo
de algoritmo, no basta utilizarmos somente a complexidade do nmero de instrues
executadas. Dessa maneira, utilizamos tambm a complexidade de cache-misses, que
pode ser medida utilizando o modelo de cache ideal, para medir o quo eficientemente
um algoritmo acessa a cache.
Existem muitos problemas ainda no analisados quanto a sua eficincia de cache. Um
desses problemas o Problema da Mochila. Nele, dado uma mochila de um certo tamanho
e um conjunto de itens com um peso e um lucro associado, pede-se que se encontre a
combinao de itens que caibam na mochila que resultem no maior lucro acumulado.
Esse problema de extrema importncia para vrias reas da computao, sendo subproblema de muitos problemas. Um desses problemas o Bin-Packing, de inmeras
aplicaes prticas.
Apresentamos, nesse trabalho, um algoritmo cache-oblivious para o Problema da Mochila Ilimitado. Alm disso, apresentamos tambm uma pesquisa e anlise de problemas
em que j existem algoritmos cache-oblivious desenvolvidos.

Palavras-chave: Programao dinmica, algoritmos cache-oblivious, problema da mochila ilimitado, problema bin-packing.

Efficient Cache-Oblivious Dynamic Programming Algorithms

ABSTRACT

Memory in modern computers is usually organized in a complex hierarchy. Thus, it is

important to design algorithms that use the cache efficiently. Moreover, the configuration
of memory and cache varies greatly from a computer to another. Therefore, it is necessary
that the algorithms developed depend on the minimum information from the machine to
use the cache in a efficient way.
In the ideal-cache model, there are two levels of memory. The first one has random
access and is infinite (main memory), but has a cost associated with its access, while the
other can be quickly accessed, but has a finite size.
An algorithm is said to be cache-oblivious if it uses the cache efficiently even without
having any information about the cache. To measure the complexity of such a algorithm,
it is not enough to use only the work complexity. Thus, we also use the cache-miss complexity, which can be measured using the ideal-cache model, measuring how efficiently
an algorithm accesses the cache.
Many problems have not yet been analyzed for their cache efficiency. An example of
such problems is the knapsack problem. Given a bag of a certain size and a number of
items with a weight and profit associated to it, discover the combination of items that fit
in the bag such that the profit is maximized.
The solution to this problem is of utmost importance to several areas of computer
science, and subproblem of many other problems. An example of such problem is the
Bin-Packing, which has many practical applications.
In this work we present a cache-oblivious algorithm to the Unlimited Knapsack Problem. Furthermore, we also present a research and analysis of problems in which a cacheoblivious algorithms has already been developed.

Keywords: dynamic programming, cache-oblivious algorithms, unbounded knapsack

problem, bin-packing problem.

13

INTRODUO

Tradicionalmente o projeto de algoritmos tem como foco o desenvolvimento de algoritmos que levam em conta apenas o nmero de instrues executadas, sendo considerado
o acesso memria constante. Esse tipo de complexidade pode ser medida pelo modelo
RAM (Random Access Machine), onde existe somente um processador e uma memria
com acesso aleatrio constante.
Com o desenvolvimento de memrias mais rpidas, porm mais caras, e a disparidade
entre a velocidade do processador e das memrias mais baratas, tornou-se comum o uso
de uma hierarquia de memrias nos computadores. Nessa hierarquia, somente a memria
mais rpida (e tambm a menor) tem contato direto com o CPU. A segunda memria mais
rpida tem contato com essa cache e assim por diante at a memria mais lenta e de maior
capacidade.
Sendo os computadores atuais projetados com hierarquias de memria com mltiplos
nveis, torna-se importante tambm levar em conta no projeto de algoritmos, alm do
nmero de instrues executadas, o custo para acessar os diferentes nveis de memria
existentes.
O modelo de cache ideal, proposto por Prokop em (PROKOP, 1999), lida justamente
com esse tipo de custo. Nele, alm da complexidade do nmero de instrues, possvel
calcular a complexidade de cache-misses de um algoritmo.
H duas maneiras de se desenvolver um algoritmo que utiliza a cache eficientemente.
Um algoritmo dito cache-aware se ele tem algum conhecimento de como a cache, tal
como o tamanho dela ou quantas palavras existem em uma linha de cache. Pelo outro
lado, um algoritmo dito cache-oblivious se ele usa a cache de forma eficiente mesmo
sem ter nenhuma informao sobre a cache.
Devido grande diversidade de configuraes de computadores existentes, tanto no
nmero de nveis de memria, quanto no tamanho dessas memrias, importante que os
algoritmos desenvolvidos para usar a cache eficientemente sejam cache-oblivious.
Programao Dinmica um mtodo para problemas que tem por caracterstica uma
subestrutura tima e subproblemas que se sobrepem. Um problema que tem subestrutura
tima aquele em que as solues timas para os seus subproblemas podem ser utilizadas
para achar a soluo tima para o problema maior. Nesse tipo de tcnica, utiliza-se a
memria para guardar as solues para os subproblemas, de forma a no ser necessrio
recalcular nenhuma informao.
Esse tipo de mtodo depende pesadamente da memria, com muitos acessos sendo
feitos a ela a cada passo do clculo da soluo. Dessa forma, esse tipo de algoritmo
ideal para se utilizar tcnicas a fim de diminuir o nmero de cache-misses. Existem um
nmero considervel de algoritmos cache-oblivious j desenvolvidos para problemas que
utilizam programao dinmica, porm a eficincia da cache na maioria dos algoritmos

14

conhecidos no foi estudado.

Um exemplo de problema em que ainda no se conhece um algoritmo cache-oblivious
o Problema da Mochila. Nele, deve-se preencher uma mochila com uma certa capacidade, tendo um array indicando os tipos de itens existentes, com seu peso e seu lucro,
buscando obter o lucro mximo. Vrias variantes so conhecidas, tais como o com itens
ilimitados (Problema da Mochila Ilimitado) ou com somente um item de cada tipo (Problema da Mochila Binrio), porm, no temos conhecimento de nenhum algoritmo cacheoblivious desenvolvido at hoje para sequer uma dessas variantes.
O Problema da Mochila Ilimitado pode ser resolvido como um subproblema em algoritmos que resolvem outros problemas mais complexos, em particular do problema BinPacking (Problema de Empacotamento Unidimensional). Para o soluo do bin-packing,
o melhor algoritmo conhecido via o mtodo de otimizao chamado gerao de colunas. Neste algoritmo, calculado, por diversas vezes, o problema da mochila ilimitado,
de forma que uma melhora no tempo de execuo desse problema tem conseqncias na
resoluo do bin-packing.
Neste trabalho, procuramos desenvolver um algoritmo cache-oblivious para o Problema da Mochila Ilimitado, alm de pesquisar e analisar problemas em que j existem
algoritmos cache-oblivious desenvolvidos.
Esse trabalho est estruturado da seguinte maneira:
O captulo 1 aborda os conhecimentos mnimos necessrios para o bom entendimento do trabalho. Alm disso, fornece uma breve explicao de outros modelos
referenciados no restante do trabalho.
O captulo 2 apresenta o modelo de cache ideal utilizado para o clculo de complexidade de cache-misses e justifica o seu uso, assim como apresenta os algoritmos
estudados e seus resultados prticos.
No captulo 3, o problema Bin-Packing introduzido, bem como sua relao com
o Problema da Mochila Ilimitado e a importncia do desenvolvimento de um algoritmo cache-oblivious para ele.
O captulo 4 aborda o Problema da Mochila, explicando em detalhes as suas principais variantes e apresentando algumas caractersticas especiais da variante com
quantidade de itens ilimitada.
No captulo 5, apresentada a soluo cache-oblivious para o Problema da Mochila
Ilimitado e a verso tradicional, assim como a prova da complexidade de ambos.
Ainda, abordado adaptaes nos algoritmos para a utilizao de dominncias para
acelerar o clculo da soluo tima.
Por fim, no captulo 6 so apresentadas as consideraes finais e planos para trabalhos futuros.

1.1

Hierarquias de Memria

A hierarquia de memria a forma como as diferentes memrias em um computador

esto organizadas. Normalmente em uma hierarquia de memria os diferentes tipos de
memrias so dispostas de forma que o processador est mais prximo da memria mais
rpida, e mais longe da memria mais lenta.

15

A idia de mltiplos nveis de memria est fortemente baseado na constatao de

que um programa que acessou uma posio na memria provavelmente ir utiliz-lo novamente dentro de um curto espao de tempo (localidade temporal) e que um programa
que acessou uma posio de memria provavelmente utilizar as posies prximas a ela
em seguida (localidade temporal).
A cache repartida em linhas, que podem conter um nmero fixo de palavras. Quando
um dado acessado, se ele no est no nvel mais perto da CPU, um cache-miss acontece
e essa palavra buscada de um nvel superior. At essa operao terminar, o programa
sob execuo no pode prosseguir, o que tem um impacto negativo no seu desempenho.
Ao alocar esse dado, a cache trs junto as palavras prximas a esse dado, com o tamanho
de uma linha dela. Assim, a localidade espacial aproveitada. J para se aproveitar da
localidade temporal, a cache procura manter um dado o maior tempo possvel em sua
memria, utilizando diferentes estratgias para a substituio quando a cache est cheia.
O nmero de palavras total da cache geralmente maior ou igual ao quadrado do
nmero de palavras em uma linha da cache, ou seja, o nmero de linhas em uma cache
de no mnimo o nmero de palavras por linha da cache. Esse tipo de cache referenciado
como cache alta (tall-cache).

1.2

Outros Modelos

Alm do modelo de cache ideal, existem outros modelos utilizados amplamente no

desenvolvimento de algoritmos. A seguir apresentaremos alguns desses modelos para um
melhor entendimento do trabalho.
1.2.1

RAM

Neste modelo, instrues so executadas com uma memria to larga quanto necessria, de acesso aleatrio constante. Com ele, possvel calcular tanto a complexidade de
nmero de instrues quanto a complexidade espacial.

Figura 1.1: A memria no modelo RAM

Todavia, no possvel calcular a complexidade de entrada e sada da memria (ou
seja, a complexidade de cache-misses). Logo, outros modelos devem ser utilizados para
tal tarefa.

16

1.2.2

Memria Externa

Este modelo, tambm conhecido como modelo de acesso ao disco, introduz dois nveis
memria:
Uma memria (cache) na qual o CPU acessa diretamente, que barata de acessar,
porm pequena em tamanho.
Uma memria (disco) na qual o CPU no consegue acessar diretamente, que
custosa para acessar, mas contm uma capacidade to grande quanto o necessrio.

Figura 1.2: O modelo de Memria Externa

Ao contrrio do modelo de cache ideal, porm, o acesso memria feito explicitamente, sendo necessrio um conhecimento da cache, assim como definir explicitamente
cada leitura ou escrita do algoritmo.
Como discos so dispositivos consideravelmente diferentes da memria, modelos de
memria externa geralmente so mais complexos. Por exemplo o parallel disk model
(PDM) de Vitter (VITTER, 2007), considera o nmero de discos em paralelo alm do
tamanho de um bloco transferido. Modelos mais sofisticados diferenciam ainda entre
acesso aleatrio ou seqencial, e modelam a sobreposio (overlap) entre entrada/sada e
computao (VITTER, 2007).
No modelo de cache ideal, como veremos a seguir, essa complexidade extra no existe,
de forma que o algoritmo no necessita conhecer absolutamente nada sobre a cache, simplificando em grande parte o trabalho do programador.

17

2.1

ALGORITMOS CACHE-OBLIVIOUS

Modelo de cache Ideal

O modelo de cache ideal um modelo criado para facilitar a anlise de complexidade

de entrada e sada. O modelo conta com dois nveis de memria, sendo o primeiro nvel
de memria uma memria (cache) finita com Z palavras, com um tamanho de linha de
L palavras. O segundo nvel de memria contm a memria principal, infinita e, assim
como no modelo RAM, com acesso aleatrio constante.
O processador pode acessar somente o primeiro nvel de memria (cache). Se o processador necessita de algo fora dessa cache, um cache-miss acontece e L palavras so
buscadas do segundo nvel de memria para a cache. Logo, a memria principal contm
uma penalidade extra para ser acessada. Essa cache totalmente associativa, ou seja, cada
linha dela pode armazenar qualquer linha da memria principal.
Utilizando esse modelo, possvel calcular a complexidade de cache-misses de algoritmos sem a necessidade de conhecer ou tratar com a memria, ao contrrio de outros
modelos conhecidos, tais como os descritos no captulo 1.
Nesse modelo, a cache no necessariamente precisa ser alta, porm alguns algoritmos
assumem uma cache alta para o clculo de sua complexidade pessimista de cache-miss.
Uma cache alta, ou tall-cache pode ser definida como uma cache em que a expresso
Z
L verdadeira, ou seja, que Z = (L2 ).
L

Figura 2.1: O Modelo de cache Ideal

18

O modelo assume algumas propriedades explicadas a seguir:

2.1.1

Poltica de Substituio

Quando ocorre um cache-miss e a cache est cheia, necessrio escolher uma linha da
cache para ser substituda. No modelo de cache ideal, a linha escolhida para a substituio
aquela que mais demoraria para ser acessada no futuro. Essa poltica de substituio
chamada de estratgia de substituio tima, e explora a localidade temporal dos dados o
melhor possvel.
Essa estratgia, obviamente, no pode ser utilizada nos computadores reais. Existem
diversos algoritmos de substituio utilizados atualmente, tais como LRU, e FIFO (HENNESSY; PATTERSON, 1996). Na FIFO a linha a ser substituda sempre o que esteve
na cache por mais tempo. J no LRU, a linha a ser substituda a que foi menos utilizada
recentemente.
Felizmente, uma cache com substituio tima pode ser substituda por uma com substituio LRU sem perda da otimalidade assinttica, desde que seja permitida a mudana
dos limites de Z da cache.
Em (FRIGO et al., 1999), foi provado que um algoritmo que causa Q0 (n; Z, L) cachemisses em um problema de tamanho n usando uma cache (Z, L) tima causar Q(n; Z, L)
2Q0 (n; Z2 , L) cache-misses em uma cache (Z, L) que use uma poltica de substituio
LRU. Isso significa que, se permitirmos usar uma cache com o dobro de tamanho, a poltica LRU no gera mais que o dobro de cache-misses em relao poltica de substituio
tima.
Por consequncia, se um algoritmo satisfaz a condio de regularidade (FRIGO et al.,
1999), o nmero de cache-misses assintoticamente igual nas duas polticas, isto
QLRU (n; Z, L) = (QOP T (n; Z, L))

(2.1)

A condio de regularidade satisfeita se o tamanho do crescimento assinttico da

complexidade de cache no alterado, caso o tamanho da cache seja duas vezes maior:
Q(n; Z, L) = O(Q(n; 2Z, L))

(2.2)

Essa condio razovel se o algoritmo no se aproveita mais do que linearmente

do tamanho da cache e isso satisfeito por todos algoritmos estudados nesse trabalho.
Logo, como consequncia da afirmao 2.1, todas as anlises podem ser feitas tanto no
modelo timo quanto no modelo LRU. importante ressaltar, entretanto, que na prtica a
estratgia LRU geralmente aproximada, o que possivelmente aumenta a diferena entre
a cache ideal e as caches reais.
2.1.2

Nveis de Memria

Embora o modelo utilize apenas dois nveis de memria, ele prova resultados sobre
qualquer hierarquia de nveis de memria. Para tanto, a memria deve possuir a propriedade da incluso, que pode ser definida pelas seguintes caractersticas:
Um dado pode estar em uma memria de nvel i se e somente se ela est presente em
uma memria de nvel i + 1 (onde o nvel 1 o nvel mais prximo do processador).
Se dois elementos pertencem mesma linha em um nvel i, eles pertencem mesma
linha em um nvel i + 1.

19

O tamanho de uma memria de nvel i estritamente menor do que uma memria

de nvel i + 1.
Tendo essas propriedades garantidas, Frigo et al. provaram em (FRIGO et al., 1999)
que uma cache (Zi , Li ) em um nvel i de um modelo LRU multi-nvel sempre contm
as mesmas linhas de cache que uma cache (Zi , Li ) simples gerenciada por LRU desde
que tenha a mesma seqncia de acessos memria. Com isso, possvel provar que
o modelo com apenas dois nveis suficiente para provar resultados sobre modelos com
hierarquia de cache mais complexas.
2.1.3

Associatividade e Reposio Automtica

O modelo de cache ideal tem como caracterstica ter a memria totalmente associativa,
ou seja, qualquer bloco da memria pode ser guardado em qualquer lugar da cache.
J a reposio automtica diz que quando um bloco est para ser trazido para a cache, isso automaticamente feito pelo hardware, e o algoritmo no necessita tratar essas
operaes de memria.
Nem sempre assim que a cache funciona. Para a associatividade, a cache geralmente
implementa uma associatividade limitada, significando que cada linha de cache pertence
a um agrupamento de x blocos, sendo chamada de uma cache x-associativa. A maioria
das caches variam de 1-way associativity at 8-way associativity. Sendo assim, faz-se
necessrio uma converso para algo mais realista.
Para que o modelo de cache ideal possa ser utilizado quando o sistema no gerencia
operaes de memria automaticamente, necessrio provar que se pode simular uma
cache com reposio automtica sem um acrscimo na complexidade tanto de nmero de
instrues quanto de cache-misses.
Frigo et al., em (FRIGO et al., 1999) provaram que para uma constante > 0, uma
cache LRU (Z, L) pode ser simulada em um espao O(Z) tal que cada acesso cache
tem O(1) de complexidade de tempo. Com isso, o modelo de cache ideal pode ser reduzido para utilizar uma memria 1-way associativity e um gerenciamento de memria
manual.

2.2

Algoritmos Estudados

Existem muitos problemas j estudados sob o aspecto da eficincia de cache. Em

(CHOWDHURY; RAMACHANDRAN, 2006), Chowdhury e Ramachandran apresentaram uma coleo de algoritmos que utilizam programao dinmica que so cacheoblivious e minimizam o nmero de cache-misses transcorridos.
Alm dos algoritmos apresentados, Chowdhury e Ramachandran tambm apresentam
em (CHOWDHURY; RAMACHANDRAN, 2006) um framework para o desenvolvimento de algoritmos cache-oblivious. Esse framework pode ser utilizado para problemas
que utilizam trs laos aninhados, tais como o algoritmo de Floyd-Warshall, multiplicao
de matrizes e o gap problem.
Apesar de estudarem os problemas, muito pouco apresentado de resultados prticos.
Ao se implementar na prtica os algoritmos cache-oblivious da literatura, observa-se que
para se obter uma melhora no tempo de execuo em relao aos algoritmos comuns, muitos ajustes devem ser feitos, e muitas vezes quebrando o pressuposto de que o programa
no tem conhecimento nenhum sobre a cache.

20

Uma tcnica bastante utilizado nesses algoritmos a diviso e conquista, onde o problema recursivamente subdividido em subproblemas at que o subproblema tenha um
tamanho b e ento seja resolvido de maneira trivial. Um ponto de ajuste comum em quase
todos os algoritmos cache-oblivious de programao dinmica conhecidos a escolha de
que tamanho b deve ter. Sem o conhecimento do tamanho da cache, necessrio configurar esse tamanho ao menor possvel, realizando assim vrias subdivises desnecessrias
dentro da cache. Se soubermos o tamanho da cache, possvel escolher um b tal que
quando o subproblema couber na cache, ele ser resolvido da maneira tradicional, no
fazendo assim nenhuma subdiviso desnecessria.
A seguir apresentamos alguns problemas estudados, assim como resultados prticos
parciais das solues para esses problemas. Para avaliarmos o desempenho dos algoritmos na prtica, implementamos tanto a verso tradicional quanto a cache-oblivious.
Escolhemos aplicar uma metodologia em que nenhum conhecimento prvio da cache
conhecido. Dessa forma, o b escolhido foi sempre o menor possvel, para todos os problemas analisados.
2.2.1

Maior Subseqncia Comum

Dada uma seqncia X = (x1 , ..., xn ) e uma seqncia Y = (y1 , ..., ym ), uma seqncia Z = (z1 , ..., zk ) uma subseqncia comum de X e Y se ela uma subseqncia de
X e de Y . No problema da maior subseqncia comum, deve-se achar a subseqncia
comum entre elas de maior tamanho.
Esse problema pode ser resolvido pela seguinte recorrncia, onde C(i, j) representa o
tamanho da maior subseqncia comum de X e Y :

se i = 0 ou j = 0,
0
(2.3)
C(i, j) = C(i 1, j 1) + 1
se i, j > 0 e xi = yj ,

max(C(i, j 1), C(i 1, j)) se i, j > 0 e xi 6= yj .

A soluo por programao dinmica segue diretamente dessa recorrncia. A complexidade de tempo do algoritmo de (nm) e ele tem O( nm
) cache misses (CHOWDHURY;
L
RAMACHANDRAN, 2006). O algoritmo cache-oblivious para encontrar a maior subseqncia comum, apresentado em (CHOWDHURY; RAMACHANDRAN, 2006), tem
uma complexidade de cache-misses de apenas O( mn
), enquanto mantm a mesma comZL
plexidade de tempo (nm).
A idia por trs do algoritmo dividir recursivamente a computao da soluo do
problema em quatro subproblemas de um quarto do tamanho do problema original, at que
o vetor utilizado caiba inteiramente na cache. Para isso, necessrio propagar pela matriz
os resultados computados pelos subproblemas para podermos recuperar a subseqncia
correta.
Tabela 2.1: Tempo de execuo dos algoritmos da Maior Subseqncia Comum (em segundos) para cada entrada do problema. A ltima linha apresenta a razo obtida (acelerao) entre o tempo dos dois algoritmos.
Algoritmo
Tradicional (LCS-T)
Cache-Oblivious (LCS-CO)
Acelerao (LCS-T/LCS-CO)

8192
0, 680
0, 650
1, 046

16384
2, 770
2, 180
1, 270

32768
12, 920
8, 580
1, 506

65536
43, 639
39, 370
1, 108

21

O teste foi realizado com uma instncia com seqncias com 8192 a 65536 itens, escolhidos aleatoriamente entre as letras do alfabeto. Como visto na Tabela 2.1, o tempo de
execuo um pouco melhor do que o algoritmo tradicional. Todavia, a melhora no tempo
de execuo est longe do reportado em (CHOWDHURY, 2005), que alcana uma acelerao de at 2, 38. O principal motivo disso que a implementao do algoritmo tem o
caso base definido como o menor possvel, ao contrrio do ocorrido em (CHOWDHURY,
2005).
2.2.2

Multiplicao de Matrizes

Dado uma matriz A de tamanho m n e uma matriz B de tamanho n p, devese gerar uma matriz C de tamanho m p contendo a multiplicao de A por B. Essa
multiplicao pode ser definida como:
(
A(i, 1) B(1, j)
se k = 1,
C(i, j, k) =
(2.4)
C(i, j) + A(i, k) B(k, j) se i, j > 0 e k > 1.
O algoritmo para resoluo desse problema segue diretamente da definio do problema, tendo complexidade O(mpn). Entretanto, existem algoritmos com menor complexidade para esse problema. Strassen, em (STRASSEN, 1969), apresenta um algoritmo com complexidade O(nlog2 7 ) e, conforme Prokop, em (PROKOP, 1999), incorre
log 7
2
em ( nL + nL2Z ) cache misses, que timo.
O problema da multiplicao de matrizes um problema bastante conhecido, tendo o
seu algoritmo cache-oblivious apresentado por Prokop em (PROKOP, 1999). O algoritmo
divide as matrizes A e B conforme o seu tamanho, em um dos 3 casos:
 


A1
A1 B
B=
(2.5)
A2
A2 B
 

B1
A1 A2
= A1 B1 + A2 B2
(2.6)
B2




A B1 B2 = AB1 AB2

(2.7)

O primeiro caso (2.5) acontece quando m max(n, p). O segundo (2.6) quando
n max(m, p) e o terceiro (2.7), quando p max(n, m). As matrizes so divididas
dessa maneira at um caso base de tamanho b, e ento resolvidas de forma tradicional.
Tabela 2.2: Tempo de execuo do algoritmo de Multiplicao de Matrizes (em segundos)
para cada entrada do problema. A ltima linha apresenta a razo obtida (acelerao) entre
o tempo dos dois algoritmos.
Algoritmo
Tradicional (MAT-T)
Cache-Oblivious (MAT-CO)
Acelerao (MAT-T/MAT-CO)

256
0, 49
0, 53
0, 92

512
2, 78
3, 31
0, 84

1024
21, 06
25, 25
0, 83

Os resultados no chegam nem perto dos descritos em (PROKOP, 1999). A causa mais
aparente a mesma pela qual o algoritmo da Maior Subseqncia Comum no conseguiu
repetir os resultados apresentados na literatura. Por no definirmos o caso base levando

22

em considerao o tamanho da cache, muitas instrues extras so realizadas para dividir

a matriz, o que acaba encobrindo a vantagem do menor nmero de cache misses.
2.2.3

Gap Problem

O problema do gap (WATERMAN, 1995) uma generalizao do problema da distncia de edio (edit distance problem) (LEVENSHTEIN, 1966). Seja X e Y seqncias de
elementos de tamanho m e n, respectivamente, ao transformarmos X em Y , um gap em
X corresponde a uma seqncia de excluses consecutivas, e um gap em Y corresponde
a uma seqncia de inseres consecutivas.
Nesse problema o custo de um gap no necessariamente igual a soma dos custos
de cada excluso (ou insero). Com isso, uma funo W(i,j) definida como o custo
de excluir xi+1 , ..., xj de X, e uma funo W(i,j) definida como o custo de inserir
yi+1 , ..., yj em X. Ainda, temos o custo de substituio de um elemento de X por um
de Y, definido como S(xi , yj ). Sendo D(i,j) o custo mnimo de transformar x1 , ..., xi em
y1 , ..., yi , a seguinte recorrncia resolve o problema:

W (0, j)
D(i, j) =

W 0 (0, j)

min(D[i 1, j 1] + S(xi , yj ), E(i, j), F (i, j))

se i, j = 0,
se i = 0, 1 j n.
se j = 0, 1 i m.
se i, j > 0.
(2.8)

onde:
E(i, j) = min {D(i, q) + W (q, j)}
0q<j

e
F (i, j) = min {D(p, j) + W 0 (p, i)}
0p<i

A soluo por programao dinmica segue pela recorrncia. Para utilizarmos a idia
de dividir o problema em subproblemas menores, at que eles caibam na cache, agora
necessrio propagar mais informaes, uma vez que agora cada D(i, j) depende, alm de
D(i 1, j 1), de D(0, j)...D(i 1, j) e D(i, 0)...D(i, j 1) tambm. Dessa forma, as
funes E(i, j) e F (i, j) tambm necessitam ser subdivididas.
Para podermos utilizar os resultados calculados de E e F , definimos funes que
propagam essas informaes de uma subdiviso para a outra, e aplicamos essas novas
funes recursivamente ao mesmo tempo em que calculamos o Gap.
Tabela 2.3: Tempo de execuo do algoritmo do Gap (em segundos) para cada entrada
do problema. A ltima linha apresenta a razo obtida (acelerao) entre o tempo dos dois
algoritmos.
Algoritmo
Tradicional (GAP-T)
Cache-Oblivious (GAP-CO)
Acelerao (GAP-T/GAP-CO)

512
0, 439
2, 36
0, 186

1024
4, 55
17, 36
0, 26

2048
44, 30
141, 89
0, 31

23

Para W e W foram escolhidas funes constantes, que retornavam o tamanho total

da seqncia dada. Mais uma vez, o problema no foi otimizado levando em conta o
tamanho da cache, e dessa forma o seu desempenho ficou longe da verso tradicional.
Nesse problema em particular especialmente importante a escolha tima para a base,
uma vez que a cada subdiviso do problema, a propagao de E e de F tambm realizada
de forma recursiva, gerando muitas subdivises extras.

24

BIN PACKING

O problema Bin packing um problema clssico da otimizao combinatria. Este

problema conhecido na literatura portuguesa como o problema de empacotamento unidimensional.
O problema de empacotamento unidimensional pode ser enunciado como a seguir:
Dada a capacidade W de recipientes (todos tm a mesma capacidade), um conjunto finito
I = {1, 2, ..., n} de itens, e um valor real wi [0, B] associado a cada item i, representando o tamanho (size) do item i, encontre uma partio de I em conjuntos disjuntos
I1 , I2 , ..., Ik tal que a soma dos tamanhos dos itens em cada Ij no seja maior que W e k
seja o menor possvel.
O empacotamento unidimensional um problema classificado como NP-Difcil (GAREY; JOHNSON, 1979). Um outro problema NP-Difcil (3-Partition) um caso especial
do empacotamento unidimensional (GAREY; JOHNSON, 1979).

3.1
3.1.1

Solues para o Empacotamento Unidimensional

Heursticas e Meta-heursticas

Muitas heursticas e meta-heursticas j foram propostas para este problema. Dentre

as heursticas, existem algumas que possuem aproximao com garantia. Dentre elas,
podemos citar:
First Fit (FF): considerando os itens em qualquer ordem, insere-se os itens num recipiente, at que no se possa inserir mais nenhum item sem extrapolar a capacidade
do mesmo. Quando a capacidade for alcanada, iniciar um novo recipiente. Este
algoritmo classificado como um algoritmo online, pois os elementos podem ser
processados conforme so recebidos, sem necessidade de conhecer informao prvia, antes da aplicao do algoritmo. Este algoritmo possui aproximao garantida
17
(OP T (I) 1) (GAREY; JOHNSON, 1979).
F F (I) 10
First Fit Decreasing (FFD): para cada item, tenta inseri-lo em todos bins previamente alocados, antes de iniciar um novo bin. O FFD possui aproximao garantida
F F D(I) = 11
OP T (I) (GAREY; JOHNSON, 1979).
9
Outros algoritmos de aproximao para este problema, tais como o Best Fit e o Best
Fit Decreasing, podem ser encontrados em (AUSIELLO et al., 1999).
3.1.2

Algoritmos Exatos

Alm das heursticas e meta-heursticas, algoritmos exatos tambm foram propostos.

Dentre os algoritmos exatos, destaca-se o algoritmo que usa a tcnica de gerao de colu-

25

nas. A tcnica de gerao de colunas uma tcnica de otimizao combinatria indicada

para resolver problemas que possuem um grande nmero de variveis, que o caso do
problema de empacotamento unidimensional. Esta tcnica pode ser vista com mais detalhes na literatura de otimizao (DESAULNIERS; DESROSIERS; SOLOMON, 2005).
A idia bsica do mtodo de gerao de colunas resolver um subproblema do problema
original, cuja soluo tima a mesma que no problema original. Para determinar este
subproblema, executa-se um nmero de iteraes, que no mximo ser igual ao nmero
de variveis do problema original, determinando-se o valor associado s variveis a cada
restrio do problema (coluna), por iterao.
Para determinar os valores destas variveis, a cada iterao deve ser resolvido um
outro problema, que no caso, o problema da mochila. Maiores detalhes do mtodo de
gerao de colunas no sero aqui expostos, visto que o mesmo requer o entendimento
de procedimentos de otimizao que requerem conhecimentos avanados de otimizao,
que no o foco deste trabalho.
Atualmente, considerando nossa reviso bibliogrfica sobre este problema, o algoritmo de gerao de colunas para o empacotamento unidimensional que resolve as maiores
instncias propostas na literatura para este problema foi proposto por Applegate, Buriol,
Dillard, Johnson e Shor (APPLEGATE et al., 2003). O tempo de cada iterao depende
principalmente de uma resoluo linear, e da resoluo do problema da mochila, sendo
que a otimizao da resoluo de ambos pode ser considerada igualmente importante para
a diminuio do tempo gasto pelo mtodo.
Visto que o problema da mochila resolvido inmeras vezes (a cada iterao) para
resolver uma instncia do problema de empacotamento unidimensional, torna-se ainda
mais importante ter um algoritmo do problema da mochila que seja o mais rpido possvel. Esta otimizao ter um impacto direto e importante na diminuio do tempo total da
resoluo do problema de empacotamento unidimensional. Com esta motivao, o problema da mochila a seguir apresentado, para depois descrevermos o mtodo de resoluo
proposto.

26

PROBLEMA DA MOCHILA

O Problema da Mochila (Knapsack Problem) um dos problemas mais estudados em

otimizao combinatria. Ele e suas variantes tem muitas aplicaes prticas, e so de extrema importncia para a informtica terica, uma vez que aparecem como subproblemas
de vrios outros problemas de otimizao combinatria.
Todas as variaes do Problema da Mochila (inteiro) pertencem classe de problemas
NP-Completo, ou seja, no se conhece um algoritmo que o resolva em tempo polinomial. Entretanto, utilizando programao dinmica existem algoritmos que resolvem os
diversas variaes do problema da mochila em tempo pseudo-polinomial.
Para um algoritmo executar em tempo pseudo-polinomial, necessrio que o seu
tempo de execuo seja polinomial em relao ao valor da entrada, ao invs de ser polinomial em relao ao comprimento da entrada (o nmero de dgitos da entrada). Logo,
um algoritmo pseudo-polinomial pode ser exponencial em relao ao comprimento da
entrada.
O problema da mochila no til apenas em problemas de empacotamento. Existem aplicaes nas mais diversas reas como criptografia e gerenciamento de projetos.
Alm dessas, ele freqentemente um subproblema de outro problema, sendo executado
diversas vezes, e seu desempenho nesses casos crtico.
Nesse sentido, importante encontrar maneiras de diminuir ao mximo o tempo de
processamento do algoritmo, e minimizar o nmero de cache-misses uma maneira nova
de abordar esse problema.

4.1

Problema

O Problema da Mochila definido como:

Definio 4.1.1. Dado uma capacidade de uma mochila W N, um conjunto de tipos
de itens I = {1, ..., n}, tal que que cada tipo possua um peso wi e um lucro pi , para
1 i n. Encontre o subconjunto de objetos que maximize o lucro total na mochila,
respeitando a capacidade W da mochila.
O problema da mochila tem diversas variantes, tais como s aceitar um objeto de cada
tipo, limitar ou no o nmero de objetos por tipo, permitir que se tenha uma nmero de
objetos fracionrio, entre outros. Desses, estamos interessados no Problema da Mochila
No Limitado (Unbounded Knapsack Problem). A seguir, apresentamos rapidamente
algumas variaes importantes do problema da mochila.

27

4.2
4.2.1

Variaes
Problema Fracionrio da Mochila

Nessa variante o nmero de itens por tipo fracionrio, ou seja, possvel dividir um
item para caber dentro da mochila.
A definio em termos de programao linear a seguinte:

Maximizar

n
X

p j xj

(4.1)

i=1

Sujeito a

n
X

w i xi W

i=1

xi 0, xi R+ | i {1, ..., n}
Note que pela caracterstica fracionria, uma soluo gulosa exata possvel. Basta
W
, com todos
escolher o tipo de item i que tenha a maior razo wpii e a resposta ser xi = w
i
os outros xj , j 6= i iguais a 0.
4.2.2

Problema Booleano da Mochila

O Problema Booleano da Mochila (0-1 Knapsack Problem) aquele em que s se

pode colocar um item para cada tipo, ou seja, s pode escolher se o item faz parte da
soluo tima. Definindo formalmente:

Maximizar

n
X

p j xj

(4.2)

i=1

Sujeito a

n
X

w i xi W

i=1

xi {0, 1} | i {1, ..., n}

4.2.3

Problema da Mochila Limitado

No Problema da Mochila Limitado (Bounded Knapsack Problem), um tipo de item i

s pode aparecer na soluo um numero mximo de bi vezes. Definindo formalmente:

Maximizar

n
X

p j xj

(4.3)

i=1

Sujeito a

n
X

w i xi W

i=1

xi {0, 1, ..., bi } | i {1, ..., n}

Esse problema j possui algumas caractersticas interessantes, porm o fato ter um
nmero fixo de vezes que um item pode aparecer na mochila limita bastante o quanto o
problema pode ser otimizado. J o problema a seguir no possui essa limitao.

28

4.3

Problema da Mochila No Limitado

O Problema da Mochila No Limitado (Unbounded Knapsack Problem, UKP) aquele

onde o nmero de objetos por tipo no limitado, ou seja, podemos utilizar quantos objetos de um tipo quanto quisermos.
Formulando como um problema de programao inteira:

Maximizar

n
X

p j xj

(4.4)

i=1

Sujeito a

n
X

w i xi W

i=1

xi 0, xi Z | i {1, ..., n}
Esse problema pode ser facilmente convertido para o Problema da Mochila Limitado,
W
c, i {1, ..., n}.
apenas pondo como limite de cada tipo de objeto um valor bi = b w
i
Todavia, existem algumas caractersticas desse problema que permitem otimizar a sua
soluo.
Para a resoluo desse problema, existem duas tcnicas principais utilizadas: a Programao Dinmica e o Branch & Bound. Esse trabalho tem como foco exclusivamente
a soluo por programao dinmica, tanto a verso trivial quanto a verso que utiliza algumas propriedades exclusivas do problema no limitado para acelerar o processamento
da soluo.
4.3.1

Dominncias

Uma vez que o problema sabidamente NP-Completo, torna-se importante a busca de

maneiras de reduzir o tamanho do espao de busca, e a eliminao de termos redundantes
uma excelente maneira de se atingir esse objetivo.
Ao compararmos tipos de itens par a par, possvel observarmos situaes em que
nunca utilizaramos um tipo de item, e ento podemos simplesmente no process-lo,
reduzindo o problema a ser considerado.
Dominncia simples acontece quando um tipo de objeto tem um lucro associado maior
e um peso associado menor do que outro. Esse conceito foi desenvolvido e provado por
Gilmore e Gomory (GILMORE; GOMORY, 1961, 1963). Martello e Toth, em (MARTELLO; TOTH, 1990), estenderam o conceito de dominncia para incluir dominncia
mltipla. Existem ainda mais tipos de dominncias, apresentadas a seguir:
1. Um tipo de item j domina um tipo diferente de item i se pj pi e wj wi .
2. Um tipo de item j domina multiplamente um tipo diferente de item i se b wwji c >

pi
.
pj

3. Um conjunto de tipos de itens J I domina coletivamente um tipo de item i,

i
/ J, se existe um conjunto de valores y1 , ..., yn tal que
X
jJ

yj wj wi e

X
jJ

yj pj pi .

29

4. Um conjunto de tipos de itens J I domina limiarmente (threshold dominates) um

tipo de item i, i
/ J, se existe um multiplicador N e um conjunto de valores
y1 , ..., yn tal que
X
X
yj wj wi e
yj pj pi .
jJ

jJ

Figura 4.1: Todos os casos em que i dominado: (a) dominncia simples, (b) dominncia
mltipla, (c) dominncia coletiva e (d) dominncia limiar
Identificar esses tipos de dominncias nem sempre uma tarefa fcil, porm apresentamos no prximo captulo uma verso do algoritmo utilizando programao dinmica
que calcula e se aproveita da maior parte dessas dominncias em tempo de execuo,
tanto para o algoritmo que no minimiza cache-misses quanto para o que minimiza.

30

5 SOLUO CACHE-OBLIVIOUS PARA O PROBLEMA

DA MOCHILA ILIMITADO

O Problema da Mochila Ilimitado tem melhores resultados quando resolvido por programao dinmica ou Branch & Bound. Nesse trabalho nos concentramos na soluo
por programao dinmica, com o intuito de minimizar o nmero de cache-misses do
algoritmo, enquanto mantendo o algoritmo cache-oblivious.
Dado um vetor de pesos w e um vetor de lucros p, pode-se definir Kp(i) como sendo
o lucro mximo obtido com uma mochila de tamanho i. Logo, Kp(i) pode ser computado
pela seguinte relao de recorrncia:
(
0
se i = 0,
Kp(i) =
(5.1)
max1jn {pj + Kp(i wj )|wj i} se i 6= 0.
Nas prximas sees, iremos descrever os algoritmos tradicionais e a verso cacheoblivious que minimiza o nmero de cache misses. Aps, veremos as verses que se
aproveitam das dominncias e ento iremos provar a complexidade de cache-misses para
cada algoritmo. Finalmente, iremos apresentar os resultados obtidos.

5.1

Soluo Tradicional

Derivando diretamente da relao de recorrncia (5.1), possvel calcular a soluo

tima do problema da mochila para um tamanho W , resolvendo incrementalmente para
cada mochila de tamanho i < W , e ento usando essas subsolues para derivar a soluo
para a mochila de tamanho W .
Utilizando um vetor Kp para guardar o lucro obtido para cada tamanho de mochila,
possvel reutilizar as solues j calculadas. Logo, para preencher esse vetor, deve-se para
cada tamanho de mochila i, guardar o mximo lucro obtido com qualquer combinao de
itens. Abaixo descrito o algoritmo que faz justamente isso.

31

A LGORITMO 5.1: P ROBLEMA DA M OCHILA I LIMITADO T RADICIONAL

Entrada Um vetor de lucros p e um vetor de pesos w com n elementos, e uma capacidade W .
Sada O lucro prof it e o peso weight timo para a capacidade W e um vetor de itens
K que torna possvel a recuperao da seqncia de itens utilizados na soluo
tima.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

para t o d o i {0, ..., W } :

K[i] 0
Kp[i] 0
prof it 0
weight 0
para t o d o s {1, ..., W } :
para t o d o i {1, ..., n} :
s e wi s :
s e pi + Kp[s wi ] Kp[s] :
Kp[s] pi + Kp[s wi ]
K[s] i
s e Kp[s] > prof it :
prof it Kp[s]
weight s
r e t o r n e (prof it, weight, K)

No algoritmo, dois vetores so preenchidos simultaneamente, K e Kp. Kp[i] contm

o mximo lucro possvel para uma mochila de tamanho i, enquanto que K[i] contm
o ltimo item utilizado para se chegar a Kp[i], o que torna possvel recuperar os itens
utilizados na construo da soluo.
Em (1 3), os vetores so inicializados. No lao (7 12), iterado todas as capacidades da mochila, at o tamanho W e em (10 12) determinado o item que fornece
maior lucro para o tamanho de mochila sendo analisado (se houver um). Em (14 16) os
valores timos so atualizados se necessrio.
Analisando o algoritmo 5.1, fica claro que a complexidade de nmero de instrues
executadas O(W n), uma vez que para cada tamanho da mochila, todos os itens so percorridos. Apesar disso, o algoritmo no polinomial, e sim pseudo-polinomial em relao
ao tamanho da mochila, que pode ter tamanho exponencial, e cuja entrada (log W ).
Os elementos acessados a cada iterao esto ligados ao peso de cada item, inutilizando
a localidade espacial no acesso memria desse algoritmo.
Note que com esse algoritmo ainda no possvel recuperar toda a seqncia de itens
utilizados. Todavia, como guardamos todos os itens utilizados no clculo em K, relativamente simples recuperar essa informao. O prximo algoritmo faz justamente isso.

32

A LGORITMO 5.2: R ECUPERAO DA SEQNCIA DE ITENS DA SOLUO

TIMA PARA O P ROBLEMA DA M OCHILA I LIMITADO
Entrada Um vetor de pesos de tipos de itens w, um vetor de itens K, o lucro prof it
e o peso weight timos sados do algoritmo para o Problema da Mochila.
Sada Um vetor S com os tipos de itens utilizados na soluo tima e um vetor Sq
que para cada i {0, ..., |S|}, Sq[i] indica a quantidade do tipo de item S[i]
utilizado.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

para t o d o i {0, ..., W } :

Ai 0
j0
s weight
enquanto s > 0 :
i K[s]
s e A[i] = 0 :
j j+1
S[j] i
Sq[j] 1
A[i] j
seno :
Sq[A[i]] Sq[A[i]] + 1
s s wi
r e t o r n e (S, Sq)

No algoritmo, o vetor A um vetor de ndices, indicando para um dado item i, em

qual posio de S (e Sq) esse item se encontra. S contm os itens utilizados na soluo
do problema e Sq a suas quantidades. Em (8), a condio testa se o item j foi encontrado
antes. Se ele foi, a quantidade dele incrementada (14), seno, um novo lugar em S e Sq
criado para o item, e o ndice dele armazenado em A.
O algoritmo 5.2 para a recuperao da seqncia de itens utilizados claramente no
interfere na complexidade de tempo dos algoritmos combinados, uma vez que feita no
mximo W operaes.

5.2

Soluo Cache-Oblivious

Uma outra opo equivalente para resolver o problema da mochila calcular os elementos de Kp da seguinte maneira: para cada tipo de item i, i {1, ..., n}, calcule o
mximo lucro obtido para cada tamanho de mochila. O algoritmo a seguir descreve essa
modificao no algoritmo original.

33

A LGORITMO 5.3: P ROBLEMA DA M OCHILA I LIMITADO Cache-Oblivious

Entrada Um vetor de lucros p e um vetor de pesos w com n elementos, e uma capacidade W .
Sada O lucro prof it e o peso weight timo para a capacidade W e um vetor de itens
K que torna possvel a recuperao da seqncia de itens utilizados na soluo
tima.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

para t o d o i {0, ..., W } :

Kp[i] 0 ; K[i] 0
para t o d o i {1, ..., n} :
para t o d o s {wi , ..., W } :
s e pi + Kp[s wi ] Kp[s] :
Kp[s] pi + Kp[s wi ]
K[s] i
prof it Kp[W ] ; weight W
f ound 0
enquanto f ound = 0 :
weight weight 1
s e Kp[weight] < prof it :
f ound 1
weight weight + 1
r e t o r n e (prof it, weight, K)

No algoritmo, novamente dois vetores so preenchidos simultaneamente, K e Kp,

com Kp[i] contendo o mximo lucro possvel para uma mochila de tamanho i, e K[i]
contendo o ltimo item utilizado para se chegar a Kp[i].
No lao (1 2), os vetores so inicializados. Em (4 8), para cada item i, calculado
cada Kp[s], com s variando at W . Em cada iterao do lao interno (5 8), calculado
se, para o Kp[s] atual, proveitoso utilizar o item i ou no. Em (10 16), calculado a
capacidade da menor mochila que obtm o maior lucro, o que nem sempre necessrio.
Apesar da lgica da soluo no ter se alterado no algoritmo 5.3, o padro de acesso
a memria se altera muito quando comparamos ao algoritmo 5.1. No algoritmo cacheoblivious o acesso memria seqencial, tanto para Kp[s wi ] quanto para Kp[s], j
que agora o s que varia no lao mais interno, ao invs de wi .

5.3

Dominncias

A fim de utilizarmos as informaes sobre dominncias explicadas na seo 4.3, necessrio fazer algumas mudanas no algoritmo. Utilizando a abordagem de programao
dinmica, trs dos quatro tipos de dominncias so testados em tempo de execuo: a

34

dominncia simples, a mltipla e a coletiva.

Para o algoritmo tradicional (5.1), necessrio, cada vez que um item dominado
encontrado, remover esse item do vetor de pesos e lucros. Isso pode ser conseguido em
tempo constante atravs da troca dos pesos e lucros do item dominado com o comeo do
vetor, e alterar o comeo do vetor para uma posio a mais (essa alterao seria apenas
incrementar um indicador do incio do vetor).
Para que essa soluo funcione, entretanto, necessrio que o vetor esteja ordenado
por peso, o que pode ser feito por um algoritmo como Mergesort (KNUTH, 1998, cap.
5.2.4) com complexidade de tempo O(n log n). A seguir descrito o algoritmo que utiliza
dominncias no clculo da soluo do Problema da Mochila Ilimitado.

A LGORITMO 5.4: P ROBLEMA DA M OCHILA I LIMITADO QUE UTILIZA

D OMINNCIAS
Entrada Um vetor de lucros p e um vetor de pesos w com n elementos (ordenados
pelo peso), e uma capacidade W .
Sada O lucro prof it e o peso weight timo para a capacidade W e um vetor de itens
K que torna possvel a recuperao da seqncia de itens utilizados na soluo
tima.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

para t o d o i {0, ..., W } :

Kp[i] 0 ; K[i] 0
A[i] = i
prof it 0 ; weight 0
j0
para t o d o s {1, ..., W } :
para t o d o i {j, ..., n} :
s e wi < s :
s e pi + Kp[s wi ] Kp[s] :
Kp[s] pi + Kp[s wi ]
K[s] i
seno :
s e wi = s :
s e Kp[s] pi :
temp wi ; wi wj ; wj temp
temp pi ; pi pj ; pj temp
temp A[i] ; A[i] A[j] ; A[j] temp
j j+1
seno :
Kp[s] pi
K[s] i
K[s] = A[K[s]]
s e Kp[s] > prof it :
prof it Kp[s]
weight s
r e t o r n e (prof it, weight, K)

35

Note que o algoritmo altera os vetores de entrada. Para evitar esse problema, necessrio fazer uma cpia do vetor dos pesos e uma do vetor dos lucros durante a inicializao
do algoritmo. Alm disso, tambm necessrio guardar os ndices originais durante o
algoritmo para podermos recuperar a seqncia de itens usados na soluo.
Para podermos executar o algoritmo 5.2 sem modificaes, necessrio fazer a ordenao dos vetores w e p novamente, para podermos recuperar os itens corretos.
No algoritmo, alm de K e Kp, um vetor extra utilizado. O vetor A contm o ndice
do item na configurao de itens originais, antes de qualquer troca em decorrncia de
descobertas de itens dominados acontea. Em (9) testado se o item menor do que o
tamanho da mochila sendo analisada. Se ele for menor, se analisa o item normalmente.
Caso ele tenha o mesmo tamanho da mochila atual, ele pode ser um item dominado. Em
(14), testado justamente isso. Se o item for dominado, ele posto para fora dos itens
sendo considerados (1618), e o indicador do comeo do vetor de itens atualizado (19).
A adaptao no algoritmo 5.3 para utilizar as dominncias muito mais simples. Basta
acrescentar um teste antes de executar o lao interno, verificando se o lucro do item a ser
utilizado (pi ) maior do que o lucro j calculado para a capacidade Kp[wi ], se ele for
menor nunca ser utilizado, e se pode passar para o prximo item. A seguir apresentado
o algoritmo para essa verso.

A LGORITMO 5.5: P ROBLEMA DA M OCHILA I LIMITADO Cache-Oblivious QUE

UTILIZA D OMINNCIAS
Entrada Um vetor de lucros p e um vetor de pesos w com n elementos (ordenados
pelo peso), e uma capacidade W .
Sada O lucro prof it e o peso weight timo para a capacidade W e um vetor de itens
K que torna possvel a recuperao da seqncia de itens utilizados na soluo
tima.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

para t o d o i {0, ..., W } :

Kp[i] 0 ; K[i] 0
para t o d o i {1, ..., n} :
s e Kp[wi ] < pi :
para t o d o s {wi , ..., W } :
s e pi + Kp[s wi ] Kp[s] :
Kp[s] pi + Kp[s wi ]
K[s] i
prof it Kp[W ] ; weight W
f ound 0
enquanto f ound = 0 :
weight weight 1
s e Kp[weight] < prof it :
f ound 1
weight weight + 1
r e t o r n e (prof it, weight, K)

36

As modificaes feitas para o algoritmo 5.5 so muito menores. A nica mudana

o teste em (5), que testa se o item dominado ou no. Ainda assim, o algoritmo se
aproveita dos mesmos 3 tipos de dominncias que as do algoritmo 5.4. Alm disso, no
feita nenhuma alterao nos dados de entrada, e por consequncia no necessrio fazer
o ordenamento aps a execuo do algoritmo para recuperar a seqncia de itens usados
(ou guardar os vetores de w e p originais).
Vale lembrar que o fato de usar dominncias para minimizar o nmero de itens analisados no altera de nenhuma maneira a complexidade dos algoritmos, uma vez que no
pior caso, sempre existir uma instncia em que no ocorre nenhuma dominncia. Na
prxima seo veremos qual a complexidade de cache miss dos algoritmos, e depois
os resultados obtidos pela nossa implementao.

5.4

Complexidade das Solues

A seguir seguem as provas da complexidade do algoritmo 5.1 e do algoritmo 5.3.

Uma vez que para cada instncia (n,W) do Problema da Mochila Ilimitado existe um caso
em que nenhum item dominado, o Algoritmo 5.4 se comportar exatamente como o
algoritmo tradicional (Algoritmo 5.1), e o algoritmo 5.5 se comportar exatamente como
o algoritmo cache-oblivious normal (Algoritmo 5.3).
Sendo assim, a utilizao de dominncias para tentar diminuir o nmero de itens no
interfere no clculo da complexidade de cache-miss dos algoritmos.
Teorema 5.4.1. Dado uma capacidade W , um conjunto de tipos de itens de tamanho n,
o algoritmo para o Problema da Mochila Ilimitado Tradicional (Algoritmo 5.1) implica
em (nW ) cache misses.
Prova. O pior caso que pode acontecer quando o nmero de itens n maior que a cache
e a distncia entre qualquer item maior que a linha da cache. Ou seja, o pior caso ocorre
quando n > ZL e |wi wj | > L , i 6= j , i, j {1, .., n}.
Para cada iterao de i, no lao interno (11 14), o elemento Kp[s wi ] acessado,
causando no mximo um cache miss. Porm, na prxima iterao no h proveito de
localidade de Kp[s wi ], uma vez que Kp[s wi+1 ] est a uma distncia maior que uma
linha de cache. Logo, para completar todos os itens, pelo menos n cache misses ocorrero
at que a cache esteja cheia.
Tendo a cache cheia, a prxima iterao de s no ter necessariamente n cache-misses.
Pela poltica de substituio tima, uma vez que a cache estiver cheia, a linha que ser
acessada mais longe no futuro ser a escolhida para ser substituda. Como a linha que
ser acessada mais futuramente sempre a que contm o ltimo Kp[s wi ] acessado,
uma linha da cache conter ele, enquanto que as outras contero os elementos K[s
w0 ], ..., K[s w Z ] e seus vizinhos, ou seja, os elementos acessados no incio.
L

Com isso, temos que para cada iterao de s em que a cache j est cheia, n ZL cache
misses ocorrero. Entretanto, a cada L iteraes, porm, todas as linhas da cache devero
j ter sido renovadas, com isso acrescenta-se n cache misses a cada L iteraes. Com
isso, aumentamos em WLn o nmero total de cache misses.
Logo, como temos no mximo W iteraes de s, teremos W (n ZL ) + WLn cachemisses ao todo. Como n ZL (n), e WLn (nW ), teremos uma complexidade
pessimista de cache-miss de (nW ).

37

Teorema 5.4.2. Dado uma capacidade W , um conjunto de tipos de itens de tamanho

n, o algoritmo para o Problema da Mochila Ilimitado Cache-Oblivious (Algoritmo 5.3)
) cache misses.
implica em O( nW
L
Prova. Podemos separar no clculo da complexidade de cache misses do algoritmo dois
casos distintos:
1. W Z:
Todo o vetor K cabe na cache. Com isso, a complexidade de cache misses consiste
no preenchimento da cache. Como o caso em que W > Z preenche toda a cache,
esse caso acaba por no influenciar na complexidade de cache misses do algoritmo.
2. W > Z:
O vetor K no cabe na cache. Para cada iterao do lao interno (9 13), os
elementos Kp[s] e Kp[sipeso ] so acessados, causando no mximo 2 cache misses.
Para a prxima iterao, como o ndice s s incrementado, tanto Kp[s + 1] quanto
Kp[s + 1 wi ] j esto na cache, e no h cache-miss. De fato, o prximo cachemiss s poder ocorrer quando L iteraes tiverem transcorrido.
Para o prximo item i, tendo toda a cache ocupada, pela poltica de substituio do
modelo de cache ideal, at a ultima linha da cache seria reaproveitada, diminuindo
Z cache misses a cada iterao de i. Logo, como temos no mximo W iteraes
para cada tipo de item i, temos WLZ cache misses por iterao do lao externo.




Logo, teremos O WLZ cache-misses por iterao de i e O n(WLZ) cache mis

ses para todo o algoritmo, o que resulta em O nW
cache misses.
L

Figura 5.1: Acesso a memria no algoritmo 5.3

A principal diferena entre os dois algoritmos est em como os elementos de K so
acessados. Como a verso cache-oblivious acessa os elementos de K em seqncia, com

38

um deslocamento entre os itens avaliados constante para cada iterao interna (como visto
na Figura 5.1), ela se aproveita da localidade da cache, dividindo todo o trabalho do
preenchimento e da atualizao da cache por L.

Figura 5.2: Acesso a memria no algoritmo 5.1

J a verso tradicional tem deslocamentos que variam conforme os itens (como visto
na figura 5.2), o que faz com que os acessos a K no se aproveitem da localidade, e tendo
ento a sua complexidade de cache-misses igual a sua complexidade de tempo.
Vale ainda destacar que o algoritmo 5.3 timo, no sentido que nenhum algoritmo que
resolva o problema da mochila com complexidade de tempo (nW ) e faa (nW ) aces), assintoticamente. Uma vez que
sos memria gera menos cache-misses do que O( nW
L
no conhecido se existe uma maneira de resolver um problema NP-Completo em tempo
polinomial, possvel que exista um algoritmo que tenha menos acessos a memria, e
dessa maneira tenha uma complexidade de cache-misses inferior ao nosso algoritmo.

39

5.5

Resultados Computacionais

Todos os algoritmos para o problema da mochila foram implementados em C, em

um Linux (kernel 2.6.27), compilados com o compilador GNU gcc 4.3.2, enquanto que
os algoritmos para os outros problemas foram implementados em C++. Todos os testes
R CoreTM 2 Quad (4 processadores de 2, 4 GHz
foram executados em uma mquina Intel
cada), com 4 GB de memria principal, 4MB de cache L2 e 32KB de cache L1 (dados).
Para os testes de cache, foi utilizado o software valgrind (NETHERCOTE; SEWARD,
2007) com a ferramenta cachegrind. Essa ferramenta permite que se simule diversas configuraes de cache, alm de no ser necessrio nenhuma modificao no cdigo original.
Uma vez que o valgrind faz uma simulao, o programa tem um tempo de execuo multiplicado por um fator de at 30. Dessa forma, para os testes de cache, foram escolhidos
problemas no muito grandes, com valores de cache menores do que as mquinas atuais
normalmente possuem. Porm, para os testes de tempo de execuo, os tamanhos normais
de instncias foram utilizados.
5.5.1

Instncias

Todas as instncias geradas so aleatrias, distribudas uniformemente entre um intervalo de (wmin , wmax ) para os pesos e de (pmin , pmax ) para os lucros. Os valores wmin ,
wmax , pmin e pmax so informados pelo usurio para o gerador, junto com o tamanho
da mochila W e o nmero de itens n. O gerador foi implementado em Python, utilizando o mdulo random para o gerar os nmeros aleatrios. Para esse tipo de instncia,
existem trs casos diferentes utilizados na literatura (MARTELLO; TOTH, 1990). O
primeiro o no correlacionado, onde tanto peso quanto lucro de um item so gerados
totalmente aleatrios. No segundo caso, o fracamente correlacionado, os pesos so escolhidos aleatoriamente, enquanto que os lucros so formados ao somarmos wi a um
valor aleatrio escolhido entre um intervalo [, +], para constantes e , ou seja,
pi = wi + brandom() 2c 2, onde random() tem como sada um valor aleatrio real entre [0, 1]. Finalmente, para o caso fortemente correlacionado, os pesos so
escolhidos aleatoriamente, enquanto que os lucros derivam diretamente do peso, sendo
pi wi + , para constantes e .

Figura 5.3: Item i como um ponto no plano. Qualquer ponto nas reas destacadas ou
dominam o item i ou so dominados por ele.

40

Ao escolhermos pesos e lucros no correlacionados, existe uma grande possibilidade

de os itens escolhidos serem ou dominados ou dominadores. Se considerarmos um item i
como um ponto (wi , pi ) no retngulo definido pelos pontos (wmin , pmin ) e (wmax , pmax ),
todos os pontos que estiverem na rea retangular entre (wmin , pi ) e (wi , pmax ) dominaro
i, e todos os pontos que estiverem na rea retangular entre (wi , pmin ) e (wmax , pi ) sero
dominados por i. Com isso, a cada item escolhido que no dominado nem domina
ningum, o nmero de pontos disponveis que no dominam nem so dominados diminui
pela metade. A Figura 5.3 ilustra esse conceito.
Ao analisarmos o desempenho dos algoritmos sem dominncias, essa caracterstica do
caso no correlacionado no importante, porm para os algoritmos que utilizam dominncias, ela vital. Dessa forma, para todos os testes feitos, foram escolhidas instncias
geradas pelos casos fraca e fortemente correlacionados.
5.5.2

Comparaes

Neste trabalho so comparados o nmero de cache misses ocorridos para os algoritmos simples e o tempo de execuo de cada algoritmo apresentado. Na tabela 5.1, so
apresentadas as abreviaes utilizadas nas comparaes.
Tabela 5.1: Abreviaes dos Algoritmos
Abreviao
T
CO
domT
domCO

Descrio
Algoritmo Tradicional (sem Dominncias)
Algoritmo Cache-Oblivious (sem Dominncias)
Algoritmo Tradicional (com Dominncias)
Algoritmo Cache-Oblivious (com Dominncias)

Algoritmo
5.1
5.3
5.4
5.5

Para os testes do nmero de cache-misses ocorridos, escolheu-se tamanhos de cache

entre 1KB e 8KB, em que obrigatoriamente os dados no caberiam totalmente na cache,
a fim de simular uma situao real, onde o tamanho da mochila e o nmero de itens
so muito maiores que o tamanho da cache. Optou-se por tamanho do problema, o caso
em que o tamanho da mochila 250.000 e o nmero de itens de 10.000. Ainda, O
tamanho da linha da cache escolhida foi o maior possvel, respeitando a regra do tallcache e escolhendo como tamanhos potncias de 2.
Tabela 5.2: Nmero de cache misses para as verses que no utilizam Dominncia, para
diferentes configuraes de cache com uma entrada de W = 250.000 e n = 10.000 para
os algoritmos 5.1 (T) e 5.3 (CO)
Algoritmo
T (5.1)
CO (5.3)
Fator T/CO

(Z=1024,L=32)
64, 683M
24, 899M
2, 598

(Z=2048,L=32)
56, 049M
24, 889M
2, 252

(Z=4096,L=64)
52, 577M
12, 442M
4, 226

(Z=8192,L=64)
38, 153M
12, 440M
3, 066

Ao analisarmos o nmero de cache-misses ocorridos em ambos algoritmos, podemos notar que h uma reduo muito significativa no nmero de cache-misses no algoritmo 5.3, como esperado. Outra observao necessria que o total de cache-misses do
algoritmo 5.3 (CO) diminui pela metade quando dobramos
o tamanho de L. Isso indica


que na prtica o nmero de cache-misses O nW
como
comprovado
pelo clculo da
L
complexidade de cache-misses do algoritmo.

41

Figura 5.4: Nmero de cache misses para diferentes configuraes de cache com uma
entrada de W = 250.000 e n = 10.000 para os algoritmos 5.1 (T) e 5.3 (CO)

Figura 5.5: Nmero de cache misses para as verses que utilizam Dominncia para diferentes configuraes de cache com uma entrada de W = 10.000.000 e n = 10.000 para
os algoritmos 5.1 (T) e 5.3 (CO)
Ao compararmos a Figura 5.4 com a Figura 5.5, notamos que a diferena do nmero
de cache misses aumentou muito, indicando que a adaptao para utilizao de dominncias acentua as diferenas dos algoritmos. Pela dominao dos itens, eles acabam por
ficarem muito mais espaados entre si, caindo no pior caso para o algoritmo normal (a
adaptao para utilizar dominncias tambm tem o mesmo pior caso).
Entretanto, de nada adianta o nmero de cache-misses ser menor se o tempo de execuo no obtiver nenhuma melhora. Dessa forma, foram feitos testes para medir o desempenho desses algoritmos que no utilizam informao de dominncia. Devido ao alto

42

Tabela 5.3: Nmero de cache-misses de cada algoritmo com dominncia (em milhes)
para cada configurao de cache (Z,L)
Algoritmo
T (5.1)
CO (5.3)
Fator T/CO

(2048,32)
4832.63M
703.40M
6, 87

(8192,64)
4266.48M
351.47M
12, 14

(32768,128)
3230.68M
175.14M
18, 45

(65536,256)
2236.73M
87.61M
25, 53

tempo de execuo desses algoritmos, e pelo fato deles no serem utilizados na prtica,
testes com um menor W e n foram realizados.

Figura 5.6: Tempo de execuo dos algoritmos 5.1 (T) e 5.3 (C), em escala logartmica.

Tabela 5.4: Tempo de execuo (em segundos) e Speed-Up dos algoritmos sem Dominncias.
W
0, 1 M
0, 1 M
1M
1M
10 M
10 M

n
1.000
10.000
1.000
10.000
1.000
10.000

T
0, 788
8, 960
9, 009
98, 870
100, 200
1242, 341

CO
0, 410
3, 710
3, 780
36, 820
36, 942
362, 36

Speed-Up (T/CO)
1, 92
2, 42
2, 38
2, 69
2, 71
3.43

Comparando os testes na Tabela 5.4 e no grfico da Figura 5.6, observarmos uma acelerao no tempo de execuo de at 3, 43 vezes utilizando o algoritmo 5.3 (CO). Isso
significa que o CO demora somente 29% do tempo que o algoritmo 5.1 (T) leva para
computar a sua soluo. Embora essa acelerao seja significativa, ela no ter sentido
se no se verificar uma acelerao semelhante nos algoritmos que utilizam dominncias
para a diminuio da entrada.

43

Figura 5.7: Tempo de execuo dos algoritmos 5.4 (domT) e 5.5 (domCO), em escala
logartmica.
Tabela 5.5: Tempo de execuo (em segundos) e Speed-Up dos algoritmos com Dominncias
W
1M
10 M
10 M
100 M
100 M

n
10.000
1.000
10.000
1.000
10.000

domT
1, 82
5, 55
27, 57
47, 53
304, 50

domCO
1, 21
3, 92
13, 33
30, 47
141, 36

Speed-Up (domT/domCO)
1, 50
1, 42
2, 07
1, 56
2, 15

Ao verificarmos os valores na Tabela 5.5 e no grfico da Figura 5.7, vemos que a

acelerao do tempo de execuo no se manteve nas verses dos algoritmos com dominncias. Isso confirma a afirmao de que o fato do algoritmo utilizar dominncias para
diminuir o nmero de itens a processar no altera a complexidade de cache dele.
Alguns fatores tambm contribuem para a manuteno do rendimento do algoritmo
cache-oblivious. Como afirmado anteriormente, o fato de termos menos itens causa um
espaamento maior entre eles, e por conseqncia uma pior utilizao da cache pelo algoritmo tradicional. Dessa forma, a melhora na utilizao da cache justificada. Alm disso,
outro fator que causa um aumento na acelerao em relao ao algoritmo tradicional o
fato de que na implementao de dominncia no algoritmo tradicional necessrio fazer
mais operaes alm do teste para descobrir se um item dominado (como fisicamente
trocar elementos de lugar nos vetores de peso e lucro da entrada).

44

CONSIDERAES FINAIS

Nesse trabalho foi apresentado um estudo sobre o modelo de cache ideal e as suas
propriedades e demonstrado que o modelo factvel com a maioria dos computadores
atuais. Tambm foram estudados e implementados algoritmos cache-oblivious propostos
na literatura, alm de apresentados resultados e limitaes desses algoritmos. Alm disso,
um novo algoritmo cache-oblivious foi proposto para o Problema da Mochila Ilimitado, e
sua complexidade pessimista de cache-misses foi analisada.
Inicialmente, foi realizada uma apresentao de conceitos bsicos sobre memrias cache e hierarquias de memria. Ento, a ttulo de comparao com o modelo de cache
ideal, foram apresentados o modelo RAM e o modelo de memria externa. Aps, foi
apresentado o modelo de cache ideal. Todos os algoritmos utilizados aqui tiveram suas
complexidades provadas utilizando esse modelo. O modelo apresenta algumas caractersticas que geralmente no so encontradas nas mquinas atuais, tais como a estratgia
de substituio tima e a cache totalmente associativa. Sendo assim, foi mostrado para
cada caso que os resultados provados para o modelo so vlidos para a grande maioria de
configuraes de cache encontradas na atualidade.
Foram apresentados algoritmos cache-oblivious propostos na literatura, expondo resultados prticos das implementaes desses algoritmos, bem como as limitaes deles.
Os algoritmos apresentados foram o da Maior Subseqncia Comum (Longest Commom
Subsequence), a Multiplicao de Matrizes e o Problema do Gap (Gap Problem). Em
todos eles ficou claro que apesar de o algoritmo ser cache-oblivious para o clculo da
complexidade, preciso quebrar o pressuposto de no ter nenhuma informao sobre a
cache para se obter resultados satisfatrios na prtica.
A seguir foi introduzido brevemente o problema do Empacotamento Unidimensional
(Bin-Packing Problem), com o intuito de dar uma motivao para a escolha do Problema
da Mochila Ilimitado para ser analisado em termos de eficincia de cache. Assim, foram
introduzidas as principais heursticas e metaheursticas para resolver o problema do binpacking, e mencionado como soluo exata a tcnica de gerao de colunas e onde que o
Problema da Mochila Ilimitado aparece nesse contexto.
Foi definido formalmente as variantes mais importantes do Problema da Mochila, comentando sobre a importncia do problema como um todo. O problema NP-Completo, e
at hoje o melhor algoritmo conhecido tem complexidade de tempo de O(nW ), que um
algoritmo pseudo-polinomial no tamanho da mochila, uma vez que a entrada (log W ).
Para o Problema da Mochila Ilimitado, em que a quantidade de cada tipo de item no limitada, o conceito de dominncia de itens, que permitem uma grande reduo no nmero
de itens computados de fato, foi apresentado, assim como o porqu dessas caractersticas
no alterarem as complexidades do problema.
O algoritmo tradicional para a soluo do Problema da Mochila Ilimitado e sua ver-

45

so cache-oblivious foi apresentada, assim como verses desses algoritmos que fazem
uso de dominncias para reduzir o nmero de itens computados. Ento foi provado a
complexidade pessimista de cache-misses tanto para o algoritmo tradicional quanto para
o algoritmo cache-oblivious.
Finalmente, foram apresentados resultados prticos para as implementaes dos algoritmos desenvolvidos. Nesses resultados, ficou claro que o algoritmo cache-oblivious
apresentou um desempenho consideralvemente melhor que o algoritmo tradicional, tanto
utilizando ou no dominncias. Outro ponto importante desse algoritmo o fato dele
ser cache-oblivious tambm na prtica, ao contrrio da maioria dos algoritmos cacheoblivious propostos na literatura. Ainda, algoritmo cache-oblivious com dominncias
extremamente mais simples do que o algoritmo tradicional com dominncias, alm de no
alterar a entrada (o que causa a necessidade de se ordenar a entrada uma segunda vez ao
trmino do algoritmo).

6.1

Trabalhos Futuros

Existem diversas possibilidades para trabalhos futuros, entre elas:

Ampliar a idia do algoritmo cache-oblivious para as outras variantes do problema
da mochila;
Aplicar o algoritmo implementado em algumas das diversas aplicaes do Problema da Mochila Ilimitado, dentre eles, e principalmente, o Problema do Empacotamento Unidimensional (Bin-Packing);
Analisar do ponto de vista de eficincia de cache as outras solues para o Problema
da Mochila Ilimitado, tais como a soluo por Branch & Bound.

46

REFERNCIAS

APPLEGATE, D. L.; BURIOL, L. S.; DILLARD, B. L.; JOHNSON, D. S.; SHOR,

P. W. The Cutting-Stock Approach to Bin Packing: theory and experiments. In: ALENEX 2003, 2003. Anais. . . [S.l.: s.n.], 2003.
AUSIELLO, G.; CRESCENZI, P.; GAMBOSI, G.; KANN, V.; MARCHETTISPACCAMELA, A.; PROTASI, M. Complexity and approximation Combinatorial
Optimization Problems and their Approximability Properties. [S.l.]: Springer-Verlag,
1999.
CHOWDHURY, R. A. Experimental Evaluation of an Efficient Cache-Oblivious LCS
Algorithm. [S.l.]: University of Texas, Austin, 2005. (TR-05-43).
CHOWDHURY, R. A.; RAMACHANDRAN, V. Cache-oblivious dynamic programming. In: SODA 06: PROCEEDINGS OF THE SEVENTEENTH ANNUAL ACMSIAM SYMPOSIUM ON DISCRETE ALGORITHM, 2006, New York, NY, USA.
Anais. . . ACM, 2006. p.591600.
DESAULNIERS, G.; DESROSIERS, J.; SOLOMON, M. M. Column Generation. [S.l.]:
Springer Verlag, 2005.
FRIGO, M.; LEISERSON, C. E.; PROKOP, H.; RAMACHANDRAN, S. Cacheoblivious algorithms. In: IEE SYMPOS. FOUND. COMP. SCI., 40., 1999. Proceedings. . . [S.l.: s.n.], 1999. p.285297.
GAREY, M. R.; JOHNSON, D. S. Computers and Intractibility, A Guide to the Theory of NP-Completeness. New York: W. H. Freeman and Company, 1979.
GILMORE, P. C.; GOMORY, R. E. A linear programming approach to the cutting stock
problem. Operations research, [S.l.], v.9, p.848859, 1961.
GILMORE, P. C.; GOMORY, R. E. A linear programming approach to the cutting stock
problem Part II. Operations research, [S.l.], v.11, p.863888, 1963.
HENNESSY, J. L.; PATTERSON, D. A. Computer architecture: a quantitative approach. Zweite.ed. [S.l.]: Morgan Kauffmann Publishers Inc., 1996.
KNUTH, D. E. The art of computer programming. 2nd.ed. [S.l.]: Addison-Wesley,
1998. v.III, Sorting and searching.
LEVENSHTEIN, V. Binary codes capable of correcting deletions, insertions and reversals. Soviet Physics Doklady, [S.l.], v.10, n.8, p.707710, 1966.

47

MARTELLO, S.; TOTH, P. Knapsack Problems. Algorithms and Computer Implementations. Chichester: John Wiley and sons, 1990. 296p.
NETHERCOTE, N.; SEWARD, J. Valgrind: a framework for heavyweight dynamic binary instrumentation. In: ACM SIGPLAN 2007 CONFERENCE ON PROGRAMMING
LANGUAGE DESIGN AND IMPLEMENTATION (PLDI 2007), 2007. Proceedings. . .
[S.l.: s.n.], 2007.
PROKOP, H. Cache-oblivious algorithms. 1999. Tese (Doutorado em Cincia da Computao) MIT.
STRASSEN, V. Gaussian elimination is not optimal. Numerische Mathematik, [S.l.],
v.14, n.3, p.354356, 1969.
VITTER, J. S. External Memory Algorithms and Data Structures: dealing with massive
data. ACM Computing Surveys, [S.l.], v.33, n.2, Feb. 2007.
WATERMAN, M. S. Introduction to Computational Biology. [S.l.]: Chapman and Hall,
London, UK, 1995.