Cap 6

Pesquisa em Memria Secundria
ltima alterao: 31 de Agosto de 2010
Transparncias elaboradas por Wagner Meira Jr, Flvia Peligrinelli Ribeiro, Israel Guerra, Nvio Ziviani e Charles Ornelas
Almeida
Projeto de Algoritmos Cap.1 Introduo 1
Contedo do Captulo
6.1 Modelo de Computao para Memria Secundria
6.1.1 Memria Virtual
6.1.2 Implementao de um Sistema de Paginao
6.2 Acesso Sequencial Indexado
6.2.1 Discos pticos de Apenas-Leitura
6.3 rvores de Pesquisa
6.3.1 rvores B
6.3.2 rvores B
6.3.3 Acesso Concorrente em rvores B
6.3.4 Consideraes Prticas

Projeto de Algoritmos Cap.1 Introduo 2
Introduo
Pesquisa em memria secundria: arquivos contm mais registros do que
a memria interna pode armazenar.
Custo para acessar um registro algumas ordens de grandeza maior do que
o custo de processamento na memria primria.
Medida de complexidade: custo de trasferir dados entre a memria principal
e secundria (minimizar o nmero de transferncias).
Memrias secundrias: apenas um registro pode ser acessado em um dado
momento (acesso seqencial).
Memrias primrias: acesso a qualquer registro de um arquivo a um custo
uniforme (acesso direto).
O aspecto sistema de computao importante.
As caractersticas da arquitetura e do sistema operacional da mquina
tornam os mtodos de pesquisa dependentes de parmetros que afetam
seus desempenhos.
Projeto de Algoritmos Cap.6 Pesquisa em Memria Secundria Seo 6.1 3
Modelo de Computao para Memria Secundria -
Memria Virtual
Normalmente implementado como uma funo do sistema
operacional.
Modelo de armazenamento em dois nveis, devido necessidade de
grandes quantidades de memria e o alto custo da memria principal.
Uso de uma pequena quantidade de memria principal e uma grande
quantidade de memria secundria.
Programador pode enderear grandes quantidades de dados,
deixando para o sistema a responsabilidade de trasferir o dado da
memria secundria para a principal.
Boa estratgia para algoritmos com pequena localidade de referncia.
Organizao do uxo entre a memria principal e secundria
extremamente importante.
Projeto de Algoritmos Cap.6 Pesquisa em Memria Secundria Seo 6.1.1 4
Memria Virtual
Organizao de uxo transformar o endereo usado pelo
programador na localizao fsica de memria correspondente.
Espao de Endereamento endereos usados pelo programador.
Espao de Memria localizaes de memria no computador.
O espao de endereamento N e o espao de memria M podem ser
vistos como um mapeamento de endereos do tipo: f : N M.
O mapeamento permite ao programador usar um espao de
endereamento que pode ser maior que o espao de memria
primria disponvel.
Memria Virtual: Sistema de Paginao
O espao de endereamento dividido em pginas de tamanho igual,
em geral, mltiplos de 512 Kbytes.
A memria principal dividida em molduras de pginas de tamanho
igual.
As molduras de pginas contm algumas pginas ativas enquanto o
restante das pginas esto residentes em memria secundria
(pginas inativas).
O mecanismo possui duas funes:
1. Mapeamento de endereos determinar qual pgina um
programa est endereando, encontrar a moldura, se existir, que
contenha a pgina.
2. Transferncia de pginas transferir pginas da memria
secundria para a memria primria e transfer-las de volta para a
memria secundria quando no esto mais sendo utilizadas.
Memria Virtual: Sistema de Paginao
Endereamento da pgina uma parte dos bits interpretada como
um nmero de pgina e a outra parte como o nmero do byte dentro
da pgina (offset).
Mapeamento de endereos realizado atravs de uma Tabela de
Pginas.
a p-sima entrada contm a localizao p
da Moldura de Pgina
contendo a pgina nmero p desde que esteja na memria
principal.
O mapeamento de endereos : f(e) = f(p, b) = p
+ b, onde e o
endereo do programa, p o nmero da pgina e b o nmero do byte.
Memria Virtual: Mapeamento de Endereos
p
p +b
Tabela_de_Pginas Pgina p
N
da
pgina
N
do
byte
Endereo
de
programa
p b
p = nil pgina no
presente na
memria

Memria Virtual: Reposio de Pginas
Se no houver uma moldura de pgina vazia uma pgina dever
ser removida da memria principal.
Ideal remover a pgina que no ser referenciada pelo perodo de
tempo mais longo no futuro.
tentamos inferir o futuro a partir do comportamento passado.
Memria Virtual: Polticas de Reposio de Pginas
Menos Recentemente Utilizada (LRU):
um dos algoritmos mais utilizados,
remove a pgina menos recentemente utilizada,
parte do princpio que o comportamento futuro deve seguir o
passado recente.
Menos Freqentemente Utilizada (LFU):
remove a pgina menos feqentemente utilizada,
inconveniente: uma pgina recentemente trazida da memria
secundria tem um baixo nmero de acessos e pode ser removida.
Ordem de Chegada (FIFO):
remove a pgina que est residente h mais tempo,
algoritmo mais simples e barato de manter,
desvantagem: ignora o fato de que a pgina mais antiga pode ser a
mais referenciada.
Memria Virtual: Poltica LRU
Fim
Incio
Pgina p
`
.
.
.
.
Toda vez que uma p-

gina utilizada ela
removida para o m da
la.
A pgina que est no
incio da la a pgina
LRU.
Quando uma nova p-
gina trazida da me-
mria secundria ela
deve ser colocada na
moldura que contm a
pgina LRU.
Memria Virtual: Estrutura de Dados
#define TAMANHODAPAGINA 512
#define ITENSPORPAGINA 64 / TamanhodaPagina / TamanhodoItem /
typedef struct TipoRegisto {
TipoChave Chave;
/ outros componentes /
} TipoRegistro;
typedef struct TipoEndereco {
long p;
char b;
} TipoEndereco;
typedef struct TipoItem {
TipoRegistro Reg;
TipoEndereco Esq, Dir ;
} TipoItem;
typedef TipoItem TipoPagina[ ItensPorPagina] ;
Memria Virtual
Em casos em que precisamos manipular mais de um arquivo ao
mesmo tempo:
A tabela de pginas para cada arquivo pode ser declarada
separadamente.
A la de molduras nica cada moldura deve ter indicado o
arquivo a que se refere aquela pgina.
typedef struct TipoPagina {
char ti po ; / armazena o codigo do ti po:0,1,2 /
union {
TipoPaginaA Pa;
TipoPaginaB Pb;
TipoPaginaC Pc;
}P;
} TipoPagina;
Memria Virtual
Procedimentos para comunicao com o sistema de paginao:
ObtemRegistro torna disponvel um registro.
EscreveRegistro permite criar ou alterar o contedo de um
registro.
DescarregaPaginas varre a la de molduras para atualizar na
memria secundria todas as pginas que tenham sido
modicadas.
Memria Virtual - Transformao do Endereo Virtual para
Real
P2
Determina
endereo
real
P4
Recupera pgina
da memria
secundria
A1
Tabela
de
pginas
A3
Memria
secundria
Programa
Usurio
A2
Fila
de
molduras
P5
Grava pgina
na memria
secundria
P1
Consulta
tabela de
pginas
P3
Determina
moldura
para pgina
?
6
6
?
6
6
-
-
?
-
p
p
p
p
p
Pgina
p
p
p
Pgina
p
p
p
p
p
Pgina
p
Quadrados resulta-
dos de processos ou ar-
quivos.
Retngulos proces-
sos transformadores de
informao.
Acesso Seqencial Indexado
Utiliza o princpio da pesquisa seqencial cada registro lido
seqencialmente at encontrar uma chave maior ou igual a chave de
pesquisa.
Providncias necessrias para aumentar a ecincia:
o arquivo deve ser mantido ordenado pelo campo chave do registro,
um arquivo de ndices contendo pares de valores < x, p > deve ser
criado, onde x representa uma chave e p representa o endereo da
pgina na qual o primeiro registro contm a chave x.
Estrutura de um arquivo seqencial indexado para um conjunto de
15 registros:
3 14 25 41
1 2 3 4
3 5 7 11 1 14 17 20 21 2 25 29 32 36 3 41 44 48 4
Acesso Seqencial Indexado: Disco Magntico
Dividido em crculos concntricos (trilhas).
Cilindro todas as trilhas verticalmente alinhadas e que possuem o
mesmo dimetro.
Latncia rotacional tempo necessrio para que o incio do bloco
contendo o registro a ser lido passe pela cabea de leitura/gravao.
Tempo de busca (seek time) tempo necessrio para que o
mecanismo de acesso desloque de uma trilha para outra (maior parte
do custo para acessar dados).
Acesso seqencial indexado = acesso indexado + organizao
seqencial,
Aproveitando caractersticas do disco magntico e procurando
minimizar o nmero de deslocamentos do mecanismo de acesso
esquema de ndices de cilindros e de pginas.
Acesso Seqencial Indexado: Discos ticos de
Apenas-Leitura (CD-ROM)
Grande capacidade de armazenamento (600 MB) e baixo custo.
Informao armazenada esttica.
A ecincia na recuperao dos dados afetada pela localizao dos dados
no disco e pela seqncia com que so acessados.
Velocidade linear constante trilhas possuem capacidade varivel e tempo
de latncia rotacional varia de trilha para trilha.
A trilha tem forma de uma espiral contnua.
Tempo de busca: acesso a trilhas mais distantes demanda mais tempo que
no disco magntico. H necessidade de deslocamento do mecanismo de
acesso e mudanas na rotao do disco.
Varredura esttica: acessa conjunto de trilhas vizinhas sem deslocar
mecanismo de leitura.
Estrutura seqencial implementada mantendo-se um ndice de cilindros na
memria principal.
rvores B
rvores n-rias: mais de um registro por nodo.
Em uma rvore B de ordem m:
pgina raiz: 1 e 2m registros.
demais pginas: no mnimo m registros e m + 1 descendentes e no
mximo 2m registros e 2m + 1 descendentes.
pginas folhas: aparecem todas no mesmo nvel.
Registros em ordem crescente da esquerda para a direita.
Extenso natural da rvore binria de pesquisa.
rvore B de ordem m = 2 com trs nveis:
30
10 20
40 50
3 4 8 9 11 13 17 25 28 33 36 43 45 48 52 55
rvores B - TAD Dicionrio
Estrutura de Dados:
typedef long TipoChave;
typedef struct TipoRegistro {
TipoChave Chave;
/outros componentes/
} TipoRegistro;
typedef struct TipoPagina TipoApontador;
short n;
TipoRegistro r [ MM] ;
TipoApontador p[ MM + 1] ;
} TipoPagina;
rvores B - TAD Dicionrio
Operaes:
Inicializa
void I ni ci al i za (TipoApontador Dicionario)
{ Dicionario = NULL; }
Pesquisa
Insere
Remove
rvores B - Pesquisa
void Pesquisa(TipoRegistro x, TipoApontador Ap)
{ long i = 1;
i f (Ap == NULL)
{ pr i nt f ( "TipoRegistro nao esta presente na arvore\n" ) ;
return;
}
while ( i < Ap>n && x>Chave > Ap>r [ i 1].Chave) i ++;
i f ( x>Chave == Ap>r [ i 1].Chave)
{ x = Ap>r [ i 1];
return;
}
i f ( x>Chave < Ap>r [ i 1].Chave)
Pesquisa(x, Ap>p[ i 1]);
else Pesquisa(x, Ap>p[ i ] ) ;
}
rvores B - Insero
1. Localizar a pgina apropriada aonde o regisro deve ser inserido.
2. Se o registro a ser inserido encontra uma pgina com menos de 2m
registros, o processo de insero ca limitado pgina.
3. Se o registro a ser inserido encontra uma pgina cheia, criada uma
nova pgina, no caso da pgina pai estar cheia o processo de diviso
se propaga.
Exemplo: Inserindo o registro com chave 14.
_
1 10
2 3 3 4 8 9 16 20 25 29
(a)
_
1 10 20
2 3 4 3 4 8 9 14 16 25 29
(b)
rvores B - Insero
Exemplo de insero das chaves: 20, 10, 40, 50, 30, 55, 3, 11, 4, 28, 36,
33, 52, 17, 25, 13, 45, 9, 43, 8 e 48
(a)
20
(b)
30
>
>
10 20 40 50
(c)
10 20 30 40
3 4 11 13 17 25 28 33 36 50 52 55
(d)
30
10 20
40 50
3 4 8 9 11 13 17 25 28 33 36 43 45 48 52 55
rvores B - Primeiro renamento do algoritmo Insere
void Ins(TipoRegistro Reg, TipoApontador Ap, short Cresceu,
TipoRegistro RegRetorno, TipoApontador ApRetorno)
{ long i = 1; long j ; TipoApontador ApTemp;
i f (Ap == NULL)
{ Cresceu = TRUE; Atri bui Reg a RegRetorno;
Atri bui NULL a ApRetorno; return;
}
while ( i < Ap > n && Reg.Chave > Ap > r [ i 1].Chave) i ++;
i f (Reg.Chave == Ap > r [ i 1].Chave) { pr i nt f ( " Erro: Registro j a esta presente\n" ) ; return; }
i f (Reg.Chave < Ap > r [ i 1].Chave) Ins(Reg, Ap > p[ i ], Cresceu, RegRetorno, ApRetorno) ;
i f ( ! Cresceu) return;
i f (Numero de registros em Ap < mm)
{ Insere na pagina Ap e Cresceu = FALSE; return; }
/ Overflow: Pagina tem que ser dividida /
Cria nova pagina ApTemp;
Transfere metade dos registros de Ap para ApTemp;
Atri bui registro do meio a RegRetorno;
Atri bui ApTemp a ApRetorno;
}
void Insere(TipoRegistro Reg, TipoApontador Ap)
{ Ins(Reg, Ap, &Cresceu, &RegRetorno, &ApRetorno) ;
i f (Cresceu) { Cria nova pagina rai z para RegRetorno e ApRetorno; }
}
rvores B - Procedimento InsereNaPgina
void InsereNaPagina(TipoApontador Ap,
TipoRegistro Reg, TipoApontador ApDir)
{ short NaoAchouPosicao;
int k;
k = Ap>n; NaoAchouPosicao = (k > 0);
while (NaoAchouPosicao)
{ i f (Reg.Chave >= Ap>r [ k1].Chave)
{ NaoAchouPosicao = FALSE;
break;
}
Ap>r [ k] = Ap>r [ k1];
Ap>p[ k+1] = Ap>p[ k] ;
k;
i f ( k < 1) NaoAchouPosicao = FALSE;
}
Ap>r [ k] = Reg;
Ap>p[ k+1] = ApDir;
Ap>n++;
}
rvores B - Renamento nal do algoritmo Insere
void Ins(TipoRegistro Reg, TipoApontador Ap, short Cresceu,
TipoRegistro RegRetorno, TipoApontador ApRetorno)
{ long i = 1; long j ;
TipoApontador ApTemp;
i f (Ap == NULL)
{ Cresceu = TRUE; ( RegRetorno) = Reg; ( ApRetorno) = NULL;
return;
}
while ( i < Ap>n && Reg.Chave > Ap>r [ i 1].Chave) i ++;
i f (Reg.Chave == Ap>r [ i 1].Chave)
{ pr i nt f ( " Erro: Registro j a esta presente\n" ) ; Cresceu = FALSE;
return;
}
i f (Reg.Chave < Ap>r [ i 1].Chave) i ;
Ins(Reg, Ap>p[ i ] , Cresceu, RegRetorno, ApRetorno) ;
i f ( ! Cresceu) return;
i f (Ap>n < MM) / Pagina tem espaco /
{ InsereNaPagina(Ap, RegRetorno, ApRetorno) ;
Cresceu = FALSE;
return;
}
/ Overflow: Pagina tem que ser dividida /
ApTemp = (TipoApontador)malloc(sizeof(TipoPagina) ) ;
ApTemp>n = 0; ApTemp>p[ 0] = NULL;
{ Continua na prxima transparncia }
rvores B - Renamento nal do algoritmo Insere
i f ( i < M + 1)
{ InsereNaPagina(ApTemp, Ap>r [ MM1], Ap>p[ MM] ) ;
Ap>n;
InsereNaPagina(Ap, RegRetorno, ApRetorno) ;
}
else InsereNaPagina(ApTemp, RegRetorno, ApRetorno) ;
for ( j = M + 2; j <= MM; j ++)
InsereNaPagina(ApTemp, Ap>r [ j 1], Ap>p[ j ] ) ;
Ap>n = M; ApTemp>p[ 0] = Ap>p[M+1];
RegRetorno = Ap>r [M] ; ApRetorno = ApTemp;
}
void Insere(TipoRegistro Reg, TipoApontador Ap)
{ short Cresceu;
TipoRegistro RegRetorno;
TipoPagina ApRetorno, ApTemp;
Ins(Reg, Ap, &Cresceu, &RegRetorno, &ApRetorno) ;
i f (Cresceu) / Arvore cresce na altura pela rai z /
{ ApTemp = (TipoPagina )malloc(sizeof(TipoPagina) ) ;
ApTemp>n = 1;
ApTemp>r [ 0] = RegRetorno;
ApTemp>p[ 1] = ApRetorno;
ApTemp>p[0] = Ap; Ap = ApTemp;
}
}
rvores B - Remoo
Pgina com o registro a ser retirado folha:
1. retira-se o registro,
2. se a pgina no possui pelo menos de m registros, a propriedade
da rvore B violada. Pega-se um registro emprestado da pgina
vizinha. Se no existir registros sucientes na pgina vizinha, as
duas pginas devem ser fundidas em uma s.
Pagina com o registro no folha:
1. o registro a ser retirado deve ser primeiramente substitudo por um
registro contendo uma chave adjacente.
rvores B - Remoo
Exemplo: Retirando a chave 3.
_
4
6 8
_
2
>
>
>
_
1
_
3
_
5
/
/
_
7
_
9
`
`

1 2
_
*
_
5
/
/
_
4
_
7
6 8
`
`
_
9
`
`

1 2
_
4
_
5
`
`
_
6
_
7
_
8
`
`
_
9
`
`
(a) Pgina vizinha possui mais do que m registros
_
1
_
2
_
3
`
`
_
4
_
5
_
6
`
`
_
7
`
`

1 2
_
*
_
4
_
5
_
6
`
`
_
7
`
`
_
4 6
1 2
_
5
_
7
`
`
(b) Pgina vizinha possui exatamente m registros
rvores B - Remoo
Remoo das chaves 45 30 28; 50 8 10 4 20 40 55 17 33 11 36; 3 9 52.
(d)
13 25 43 48
(c)
13
>
>
3 9 25 43 48 52
(b)
10 25 40 50
3 4 8 9 11 13 17 20 33 36 43 48 52 55
(a)
30
10 20
40 50
3 4 8 9 11 13 17 25 28 33 36 43 45 48 52 55
rvores B - Procedimento Retira
void Reconstitui (TipoApontador ApPag, TipoApontador ApPai,
int PosPai , short Diminuiu)
{ TipoPagina Aux; long DispAux, j ;
i f (PosPai < ApPai>n) / Aux = TipoPagina a di rei t a de ApPag /
{ Aux = ApPai>p[PosPai+1]; DispAux = (Aux>n M + 1) / 2;
ApPag>r [ApPag>n] = ApPai>r [PosPai ] ;
ApPag>p[ApPag>n + 1] = Aux>p[ 0] ; ApPag>n++;
i f (DispAux > 0) / Existe folga : transfere de Aux para ApPag /
{ for ( j = 1; j < DispAux; j ++)
InsereNaPagina(ApPag, Aux>r [ j 1], Aux>p[ j ] ) ;
ApPai>r [PosPai ] = Aux>r [DispAux1]; Aux>n = DispAux;
for ( j = 0; j < Aux>n; j ++) Aux>r [ j ] = Aux>r [ j + DispAux] ;
for ( j = 0; j <= Aux>n; j ++) Aux>p[ j ] = Aux>p[ j + DispAux] ;
Diminuiu = FALSE;
}
else / Fusao: intercala Aux em ApPag e l i bera Aux /
{ for ( j = 1; j <= M; j ++) InsereNaPagina(ApPag, Aux>r [ j 1], Aux>p[ j ] ) ;
free(Aux) ;
for ( j = PosPai + 1; j < ApPai>n; j ++)
{ ApPai>r [ j 1] = ApPai>r [ j ] ; ApPai>p[ j ] = ApPai>p[ j +1] ; }
ApPai>n;
i f (ApPai>n >= M) Diminuiu = FALSE;
}
}
else / Aux = TipoPagina a esquerda de ApPag /
{ Aux = ApPai>p[PosPai1]; DispAux = (Aux>n M + 1) / 2;
for ( j = ApPag>n; j >= 1; j )ApPag>r [ j ] = ApPag>r [ j 1];
ApPag>r [ 0] = ApPai>r [PosPai1];
for ( j = ApPag>n; j >= 0; j )ApPag>p[ j +1] = ApPag>p[ j ] ;
ApPag>n++;
i f (DispAux > 0) / Existe folga : transf . de Aux para ApPag /
{ for ( j = 1; j < DispAux; j ++)
InsereNaPagina(ApPag, Aux>r [Aux>n j ] ,
Aux>p[Aux>n j + 1] ) ;
ApPag>p[ 0] = Aux>p[Aux>n DispAux + 1] ;
ApPai>r [PosPai1] = Aux>r [Aux>n DispAux] ;
Aux>n = DispAux; Diminuiu = FALSE;
}
else / Fusao: intercala ApPag em Aux e l i bera ApPag /
{ for ( j = 1; j <= M; j ++)
InsereNaPagina(Aux, ApPag>r [ j 1], ApPag>p[ j ] ) ;
free(ApPag) ; ApPai>n;
i f (ApPai>n >= M) Diminuiu = FALSE;
}
}
void Ret(TipoChave Ch, TipoApontador Ap, short Diminuiu)
{ long j , Ind = 1;
TipoApontador Pag;
i f (Ap == NULL)
{ pr i nt f ( "Erro: registro nao esta na arvore\n" ) ; Diminuiu = FALSE;
return;
}
Pag = Ap;
while ( Ind < Pag>n && Ch > Pag>r [ Ind1].Chave) Ind++;
i f (Ch == Pag>r [ Ind1].Chave)
{ i f (Pag>p[ Ind1] == NULL) / TipoPagina folha /
{ Pag>n; Diminuiu = (Pag>n < M) ;
for ( j = Ind; j <= Pag>n; j ++) { Pag>r [ j 1] = Pag>r [ j ] ; Pag>p[ j ] = Pag>p[ j +1] ; }
return;
}
/ TipoPagina nao e folha : trocar com antecessor /
Antecessor(Ap, Ind , Pag>p[ Ind1], Diminuiu) ;
i f (Diminuiu) Reconstitui (Pag>p[ Ind1], Ap, Ind 1, Diminuiu) ;
return;
}
i f (Ch > Pag>r [ Ind1].Chave) Ind++;
Ret(Ch, &Pag>p[ Ind1], Diminuiu) ;
}
void Antecessor(TipoApontador Ap, int Ind,
TipoApontador ApPai , short Diminuiu)
{ i f (ApPai>p[ApPai>n] ! = NULL)
{ Antecessor(Ap, Ind , ApPai>p[ApPai>n] , Diminuiu) ;
i f (Diminuiu)
Reconstitui (ApPai>p[ApPai>n] , ApPai , ( long)ApPai>n, Diminuiu) ;
return;
}
Ap>r [ Ind1] = ApPai>r [ApPai>n 1];
ApPai>n; Diminuiu = (ApPai>n < M) ;
}
void Ret(TipoChave Ch, TipoApontador Ap, short Diminuiu)
{ long j , Ind = 1;
TipoApontador Pag;
i f (Ap == NULL)
{ pr i nt f ( "Erro: registro nao esta na arvore\n" ) ; Diminuiu = FALSE;
return;
}
Pag = Ap;
while ( Ind < Pag>n && Ch > Pag>r [ Ind1].Chave) Ind++;
i f (Ch == Pag>r [ Ind1].Chave)
{ i f (Pag>p[ Ind1] == NULL) / TipoPagina folha /
{ Pag>n;
Diminuiu = (Pag>n < M) ;
for ( j = Ind; j <= Pag>n; j ++)
{ Pag>r [ j 1] = Pag>r [ j ] ; Pag>p[ j ] = Pag>p[ j +1] ; }
return;
}
/ TipoPagina nao e folha : trocar com antecessor /
Antecessor(Ap, Ind , Pag>p[ Ind1], Diminuiu) ;
i f (Diminuiu)
Reconstitui (Pag>p[ Ind1], Ap, Ind 1, Diminuiu) ;
return;
}
i f (Ch > Pag>r [ Ind1].Chave) Ind++;
Ret(Ch, &Pag>p[ Ind1], Diminuiu) ;
}
void Retira(TipoChave Ch, TipoApontador Ap)
{ short Diminuiu;
TipoApontador Aux;
Ret(Ch, Ap, &Diminuiu) ;
i f ( Diminuiu && (Ap)>n == 0) / Arvore diminui na altura /
{ Aux = Ap; Ap = Aux>p[ 0] ;
free(Aux) ;
}
}
rvores B* - TAD Dicionrio
Estrutura de Dados:
typedef int TipoChave;
typedef struct TipoRegistro {
TipoChave Chave;
/ outros componentes /
} TipoRegistro;
typedef enum {
Interna , Externa
} TipoIntExt ;
typedef struct TipoPagina TipoApontador;
TipoIntExt Pt ;
union {
struct {
int ni ;
TipoChave r i [ MM] ;
TipoApontador pi [ MM + 1] ;
} U0;
struct {
int ne;
TipoRegistro re[ MM2] ;
} U1;
} UU;
} TipoPagina;
rvores B* - Pesquisa
Semelhante pesquisa em rvore B,
A pesquisa sempre leva a uma pgina folha,
A pesquisa no pra se a chave procurada for encontrada em uma
pgina ndice. O apontador da direita seguido at que se encontre
uma pgina folha.
rvores B* - Procedimento para pesquisar na rvore B
void Pesquisa(TipoRegistro x, TipoApontador Ap)

{ int i ;
TipoApontador Pag;
Pag = Ap;
i f ((Ap)>Pt == Interna)
{ i = 1;
while ( i < Pag>UU.U0. ni && x>Chave > Pag>UU.U0. r i [ i 1]) i ++;
i f ( x>Chave < Pag>UU.U0. r i [ i 1])
Pesquisa(x, &Pag>UU.U0. pi [ i 1]);
else Pesquisa(x, &Pag>UU.U0. pi [ i ] ) ;
return;
}
i = 1;
while ( i < Pag>UU.U1.ne && x>Chave > Pag>UU.U1. re[ i 1].Chave)
i ++;
i f ( x>Chave == Pag>UU.U1. re[ i 1].Chave)
x = Pag>UU.U1. re[ i 1];
else pr i nt f ( "TipoRegistro nao esta presente na arvore\n" ) ;
}
rvores B* - Insero e Remoo
Insero na rvore B*
Semelhante insero na rvore B,
Diferena: quando uma folha dividida em duas, o algoritmo
promove uma cpia da chave que pertence ao registro do meio
para a pgina pai no nvel anterior, retendo o registro do meio na
pgina folha da direita.
Remoo na rvore B*
Relativamente mais simples que em uma rvore B,
Todos os registros so folhas,
Desde que a folha que com pelo menos metade dos registros, as
pginas dos ndices no precisam ser modicadas, mesmo se uma
cpia da chave que pertence ao registro a ser retirado esteja no
ndice.
Acesso Concorrente em rvore B*
Acesso simultneo a banco de dados por mais de um usurio.
Concorrncia aumenta a utilizao e melhora o tempo de resposta do
sistema.
O uso de rvores B* nesses sistemas deve permitir o processamento
simultneo de vrias solicitaes diferentes.
Necessidade de criar mecanismos chamados protocolos para garantir
a integridade tanto dos dados quanto da estrutura.
Pgina segura: no h possibilidade de modicaes na estrutura da
rvore como conseqncia de insero ou remoo.
insero pgina segura se o nmero de chaves igual a 2m,
remoo pgina segura se o nmero de chaves maior que m.
Os algoritmos para acesso concorrente fazem uso dessa propriedade
para aumentar o nvel de concorrncia.
Acesso Concorrente em rvore B* - Protocolos de
Travamentos
Quando uma pgina lida, a operao de recuperao a trava, assim,
outros processos, no podem interferir com a pgina.
A pesquisa continua em direo ao nvel seguinte e a trava liberada
para que outros processos possam ler a pgina .
Processo leitor executa uma operao de recuperao
Processo modicador executa uma operao de insero ou
retirada.
Dois tipos de travamento:
Travamento para leitura permite um ou mais leitores acessarem
os dados, mas no permite insero ou retirada.
Travamento exclusivo nenhum outro processo pode operar na
pgina e permite qualquer tipo de operao na pgina.
rvore B - Consideraes Prticas
Simples, fcil manuteno, eciente e verstil.
Permite acesso seqencial eciente.
Custo para recuperar, inserir e retirar registros do arquivo logaritmico.
Espao utilizado , no mnimo 50% do espao reservado para o
arquivo,
Emprego onde o acesso concorrente ao banco de dados necessrio,
vivel e relativamente simples de ser implementado.
Insero e retirada de registros sempre deixam a rvore balanceada.
Uma rvore B de ordem m com N registros contm no mximo cerca
de log
m+1
N pginas.
rvore B - Consideraes Prticas
Limites para a altura mxima e mnima de uma rvore B de ordem m
com N registros: log
2m+1
(N + 1) altura 1 + log
m+1
N+1
2
Custo para processar uma operao de recuperao de um registro

cresce com o logaritmo base m do tamanho do arquivo.
Altura esperada: no conhecida analiticamente.
H uma conjectura proposta a partir do clculo analtico do nmero
esperado de pginas para os quatro primeiros nveis (das folha em
direo raiz) de uma rvore 2-3 (rvore B de ordem m = 1).
Conjetura: a altura esperada de uma rvore 2-3 randmica com N
chaves h(N) log
7/3
(N + 1).
rvores B Randmicas - Medidas de Complexidade
A utilizao de memria cerca de ln 2.
Pginas ocupam 69% da rea reservada aps N inseres
randmicas em uma rvore B inicialmente vazia.
No momento da insero, a operao mais cara a partio da pgina
quando ela passa a ter mais do que 2m chaves. Envolve:
Criao de nova pgina, rearranjo das chaves e insero da chave
do meio na pgina pai localizada no nvel acima.
Pr{j parties}: probabilidade de que j parties ocorram durante
a N-sima insero randmica.
rvore 2-3: Pr{0 parties} =
4
7
, Pr{1 ou mais parties} =
3
7
rvore B de ordem m: Pr{0 parties} = 1

1
(2 ln 2)m
+ O(m
2
),
Pr{1 ou + parties} =
1
(2 ln 2)m
+ O(m
2
).
rvore B de ordem m = 70: 99% das vezes nada acontece em
termos de parties durante uma insero.
rvores B Randmicas - Acesso Concorrente
Foi proposta uma tcnica de aplicar um travamento na pgina segura
mais profunda (Psmp) no caminho de insero.
Uma pgina segura se ela contm menos do que 2m chaves.
Uma pgina segura a mais profunda se no existir outra pgina
segura abaixo dela.
J que o travamento da pgina impede o acesso de outros processos,
interessante saber qual a probabilidade de que a pgina segura
mais profunda esteja no primeiro nvel.
rvore 2-3: Pr{Psmp esteja no 1
nvel} =
4
7
,
Pr{Psmp esteja acima do 1
nvel} =
3
7
rvore B de ordem m:
Pr{Psmp esteja no 1
nvel} = 1
1
(2 ln2)m
+ O(m
2
),
Pr{Psmp esteja acima do 1
nvel} =
3
7
=
1
(2 ln 2)m
+ O(m
2
).
rvores B Randmicas - Acesso Concorrente
Novamente, em rvores B de ordem m = 70: 99% das vezes a Psmp
est em uma folha. (Permite alto grau de concorrncia para processos
modicadores.)
Solues muito complicadas para permitir concorrncia de operaes
em rvores B no trazem grandes benefcios.
Na maioria das vezes, o travamento ocorrer em pginas folha.
(Permite alto grau de concorrncia mesmo para os protocolos mais
simples.)
rvore B - Tcnica de Transbordamento (ou Overow)
Assuma que um registro tenha de ser inserido em uma pgina cheia,
com 2m registros.
Em vez de particion-la, olhamos primeiro para a pgina irm direita.
Se a pgina irm possui menos do que 2m registros, um simples
rearranjo de chaves torna a partio desnecessria.
Se a pgina direita tambm estiver cheia ou no existir, olhamos
para a pgina irm esquerda.
Se ambas estiverem cheias, ento a partio ter de ser realizada.
Efeito da modicao: produzir uma rvore com melhor utilizao de
memria e uma altura esperada menor.
Produz uma utilizao de memria de cerca de 83% para uma rvore
B randmica.
rvore B - Inuncia do Sistema de Paginao
O nmero de nveis de uma rvore B muito pequeno (trs ou quatro)
se comparado com o nmero de molduras de pginas.
Assim, o sistema de paginao garante que a pgina raiz esteja
sempre na memria principal (se for adotada a poltica LRU).
O esquema LRU faz com que as pginas a serem particionadas em
uma insero estejam disponveis na memria principal.
A escolha do tamanho adequado da ordem m da rvore B
geralmente feita levando em conta as caractersticas de cada
computador.
O tamanho ideal da pgina da rvore corresponde ao tamanho da
pgina do sistema, e a transferncia de dados entre as memrias
secundria e principal realizada pelo sistema operacional.
Estes tamanhos variam entre 512 bytes e 4.096 bytes, em mltiplos de
512 bytes.

Cap 6

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Cap 6

Enviado por

Direitos autorais:

Formatos disponíveis

Pesquisa em Memria Secundria

ltima alterao: 31 de Agosto de 2010

6.3.3 Acesso Concorrente em rvores B

6.3.4 Consideraes Prticas

Projeto de Algoritmos Cap.6 Pesquisa em Memria Secundria Seo 6.1.1 8

Toda vez que uma p-

void Pesquisa(TipoRegistro x, TipoApontador Ap)

Custo para processar uma operao de recuperao de um registro

rvore B de ordem m: Pr{0 parties} = 1

Você também pode gostar