Ambiente de Execução - Rotinas

• Rotinas/subrotinas são o conceito equivalente a chamadas a procedimentos e funções.

• Instrução de desvio (call) e de retorno (return)

• Possível passagem de argumentos (valores ou endereços) e retorno de resultado.

Rotinas

• Vamos estudar: protocolos de passagem de argumentos e retorno de resultados.

• Argumentos

• Implementação de rotinas recursivas.

Protocolo de chamada de rotinas

• Em uma máquina baseada em registradores:– Parâmetros passados em registradores R1, R2,

etc.– Resultado em R0

• Em uma máquina de pilha:– Argumentos são passados no topo da pilha– Resultado no topo da pilha, depois de

removidos os argumentos.

Mecanismos de passagem de parâmetros

• Constant parameter ou value parameter ou call-by-value

• Variable parameter ou reference parameter ou call-by-reference

Call-by-Value

• os parâmetros são avaliados e seus valores passados ao procedimento chamado.

• Exemplos: C, Pascal.

Call-by-Value - implementação

– o procedimento que faz a chamada avalia os argumentos e coloca seus valores no topo da pilha.

– Um novo frame é empilhado sobre os argumentos, e carregado com dados de ligação (endereço de retorno, link dinâmico e link estático).

– A instrução de retorno desempilha o frame e coloca o resultado no topo da pilha.

Call-by-Value - exemplo

program reference(input,output);var a,b : integer;procedure swap (x,y:integer);var temp : integer;begin temp := x; x := y; y := temp;end;begin a := 1; b :=2; swap(a,b); writeln(a,‘ ’, b)end

Call-by-Value - implementação

– operações nos argumentos não afetam os valores no frame (registro de ativação) do caller.

– única maneira de afetar o caller é através de variáveis não-locais, ou através de ponteiros passados explicitamente como valores.

Call-by-Value – exemplo em C

swap (x,y);int *x, *y;{ int temp; temp = *x; *x = *y; *y = temp;}main (){ int a = 1,b = 2; swap (&a, &b); printf(“%d %d\n”,a,b)}

Call-by-Reference

• parâmetros são passados por referência, i.e. o caller passa para o processo chamado um ponteiro para o endereço do parâmetro real.

• uma referência ao parâmetro formal no procedimento chamado torna-se, na realidade, uma referência indireta através do ponteiro.

Call-by-reference - exemplo

program reference(input,output);var a,b : integer;procedure swap (var x,y:integer);var temp : integer;begin temp := x; x := y; y := temp;end;begin a := 1; b :=2; swap(a,b); writeln(a,‘ ’, b)end

Call-by-reference – exemplo 2

program reference(input,output);var i : integer; var a : array [1..10] of integer;procedure swap (var x,y:integer);var temp : integer;begin temp := x; x := y; y := temp;end;begin i := 5; swap(i,a[i]); end

Facilidades para alocação dinâmica de espaço

• Alocação explícita ou implícita

• Desalocação explícita ou implícita

• Exemplo: em Pascal, new e dispose, em C malloc/free.

Alocação e desalocação explícita - Exemplo

type link = ^cell;cell = record info : integer; next : link end;

var head : link;procedure insert(i : integer);

var p : link;begin new(p); p^info := i; p^next := head; head :=pend;

beginhead := nil; insert(1); insert(2); insert(3);writeln(head^.info); writeln(head^.next^.info);writeln(head^.next^.next^.info)

end.

Lixo

beginhead := nil; insert(1); insert(2); insert(3);head^.next := nil;writeln(head^.info)

end.• Linguagens funcionais e Java: coleta de lixo

automática (garbage collection).• C, Pascal: responsabilidade do programador.

Referências perdidas

beginhead := nil; insert(1); insert(2); insert(3);dispose(head^.next);writeln(head^.info)

end.• head^.next ainda existe, mas aponta para uma

área que foi liberada.

Alocação explícita de blocos de tamanho fixo

• cada bloco aponta para o próximo bloco livre• existe um ponteiro chamado available que

aponta para o primeiro bloco.• alocação e desalocação ocorre através da

inserção ou remoção de um bloco na lista.

Alocação explícita de blocos de tamanho variável

• fragmentação ocorre após várias alocações e desalocações.

• uso de método first fit.• vários algoritmos são possíveis para manter o

controle de espaço disponível.

Desalocação implícita

• Exige cooperação entre o programa do usuário e o sistema de execução da linguagem, para saber quando um bloco não está mais sendo usado.

• cooperação ocorre através do uso de um formato fixo para os blocos alocados:

tamanho do bloco (opc.)

contador de referências (opc.)

marca (opc.)

ponteiros para blocos

informação do usuário

Desalocação implícita

• É necessário saber da existência de todos os ponteiros armazenados: na pilha e na própria heap.

Técnicas para Desalocação implícita

• Contagem de referências: mantém a contagem de blocos que apontam para o bloco corrente; se o contador chega a zero o bloco é desalocado.Exemplo: p := q;Útil se não existem ciclos.

• Mark and scan: suspende temporariamente execução e percorre os ponteiros para determinar quais blocos estão sendo usados.implementação: 2-espaços, compactação, etc.