Your SlideShare is downloading. ×
Pilhas
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Saving this for later?

Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime - even offline.

Text the download link to your phone

Standard text messaging rates apply

Pilhas

487
views

Published on


0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
487
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
14
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Pilhas
    • Você já deve saber que uma pilha
    • é uma estrutura de dados que
    • consiste em um amontoado de valo-
    • res (empilhados, daí o nome)
    • Pilhas serão importantes na execução
    • de programas. Veremos a seguir como
    • elas são utilizadas
  • 2.
    • Toda pilha possui duas operações básicas: PUSH, que consiste em adicionar um valor
    • na pilha; e POP, que retira da pilha o
    • valor presente no topo
    • Para a nossa arquitetura, pilhas serão
    • blocos contíguos presentes na memó-
    • ria principal que conterão dados a serem processados, com um ponteiro SP ( Stack Pointer ) que indicará o endereço onde está o topo da pilha
    • À medida que descemos pela memória, os endereços aumentam. Ou seja, sempre que adicionarmos um valor na pilha (PUSH), o ponteiro SP apontará para o endereço atual – 1, um endereço acima
    • O contrário acontece para a operação POP
  • 3.
    • A pilha do exemplo a seguir começa no endereço 1000 da memória, e seu topo está em 996
    . . . . . . . . . . . 1000 999 998 997 996 4 9 7 2 5 SP
  • 4.
    • Fazendo PUSH 3, o valor 3 será acrescentado na pilha, e o topo será o endereço 996 – 1 = 995
    . . . . . . . . . . . 1000 999 998 997 996 4 9 7 2 5 SP 995 3
  • 5.
    • Por outro lado, se tivéssemos feito POP, o valor 9 passaria a ser lixo e o novo topo estaria em 996 + 1 = 997
    . . . . . . . . . . . 1000 999 998 997 996 4 9 7 2 5 SP
  • 6.
    • Algumas linguagens de programação são organizadas em blocos (escopos)
    • Em Java, por exemplo, o escopo de uma classe são todos os procedimentos existentes naquela classe, e no escopo de cada procedimento existem todas as operações realizadas por ele, inclusive eventuais chamadas a outros procedimentos
  • 7.
    • Para essas linguagens, é interessante utilizar pilhas durante a execução de um programa para liberar o espaço ocupado pelas variáveis locais de um procedimento, quando ele é finalizado
    • Variáveis locais são variáveis utilizadas e conhecidas exclusivamente nos procedimentos onde foram inicializadas, e no nível de macroprogramação são geralmente carregadas nas pilhas
    • Já as variáveis globais são variáveis conhecidas em todo o programa e a princípio estão presentes em endereços da memória que não fazem parte da pilha de um procedimento em particular
  • 8.
    • Além das operações PUSH e POP, outra operação útil para pilhas é mover arbitrariamente o ponteiro SP, sem inserir dados inicialmente
    • Isto é útil para quando a execução entrar em um procedimento que utilizará variáveis locais, de maneira que SP será decrementado (topo subirá) para reservar espaço para essas variáveis
    • Em Pascal, isso fica fácil de ser visto, já que as variáveis locais são inicializadas antes da palavra begin , que indica o começo do procedimento
    • O exemplo a seguir mostra o começo do método de ordenação BubbleSort , em Pascal
  • 9.
    • procedure BubbleSort(var A: ArrayType);
    • var i, j: integer;
    • begin
    • .
    • .
    • .
    • Repare que as variáveis i e j são inicializadas. Em seguida, a palavra begin indica o começo das operações do procedimento – é neste ponto onde SP é decrementado em 2
    • A pilha agora ocupa mais 2 espaços: os espaços de i e j , que eventualmente receberão valores durante a execução do procedimento
    • E se o topo da pilha atingir endereços que já estão sendo usados pelo programa?
  • 10.
    • Familiar?
    • Agora vamos supor uma função, também em Pascal, que recebe duas entradas e retorna como resultado o produto entre elas
    • Perceba como fica sua pilha de execução
  • 11.
        • function produto(a, b: integer): integer;
        • var p, j: integer;
        • begin
        • if (a = 0) or (b = 0) then
        • produto := 0
        • else
        • begin
        • p := 0;
        • for j := 1 to a do
        • p := p + b;
        • produto := p;
        • end
        • end;
    a b
    • Quando a função é chamada no programa, já temos na pilha as variáveis de entrada, e precisamos também do endereço de retorno, para que o processador saiba para onde voltar quando a função terminar
    end. ret. SP
  • 12.
        • function produto(a, b: integer): integer;
        • var p, j: integer;
        • begin
        • if (a = 0) or (b = 0) then
        • produto := 0
        • else
        • begin
        • p := 0;
        • for j := 1 to a do
        • p := p + b;
        • produto := p;
        • end
        • end;
    a b end. ret. p j
    • Já ao final desta linha, precisamos de mais 2 para as variáveis locais p e j
    SP
  • 13.
        • function produto(a, b: integer): integer;
        • var p, j: integer;
        • begin
        • if (a = 0) or (b = 0) then
        • produto := 0
        • else
        • begin
        • p := 0;
        • for j := 1 to a do
        • p := p + b;
        • produto := p;
        • end
        • end;
    a b end. ret.
    • Quando a função termina, os espaços das variáveis locais são liberados. Em outras palavras, SP é incrementado em 2, voltando a ser o endereço de retorno. Este endereço dirá onde a execução estava quando chamou a função produto , e ela continuará a partir daquele ponto
    SP
  • 14.
    • Com apenas estas descrições, fica a
    • impressão de que a função foi inútil,
    • já que a pilha guardou apenas seus
    • valores de entrada e manipulou as variáveis locais
    • Mas é óbvio que isto não é verdade. De que maneira então foram usadas as variáveis
    • a e b para chegar até o resultado final,
    • e onde ele foi parar?
    • Todos os resultados de operações intermediárias foram sendo armazenados no nosso registrador AC (Accumulator). O mesmo vale para o resultado final da função, que pode ser apenas um valor intermediário para o resto do programa
  • 15.
    • O endereço de retorno está relacionado a outro registrador, o Program Counter
    • Quando a função produto termina, o endereço de retorno é desempilhado e salvo em PC
    • Caso você não se lembre, AC e PC são dois dos nossos 16 registradores conectados aos barramentos A, B e C em N0
    • Isso nos dá bagagem suficiente para falar sobre o nível de macroprogramação