Ambiente de execução.

Ambiente de execução

Estado de um programa S1  S2  ...  Sn
Execução de um programa é resultado de uma sequência de transições de estado S1  S2  ...  Sn

Representação da memória (de um programa em execução)
Área estática: espaço para meta- dados associados ao código Heap: espaço reservado para alocação dinâmica de memória Pilha: Contexto de chamada de funções Program Counter (PC): instrução corrente na prática, pilha cresce para endereços menores de memória e heap para endereços maiores, nos exemplos por conveniência de notação, a pilha vai crescer para endereços mais altos

Representação da memória (de um programa em execução)
Correção... Considerando concorrência, há um PC e pilha para cada thread do programa!

Compilador O compilador embute gerenciador de mémória em cada programa gerado Serve para fazer interface com SO gerenciador de memória Representação do programa em memória Sistema Operacional .exe

Área estática Área reservada para armazenar:
Variáveis globais Estrutura de dados Funções estáticas Tamanho da área estática determinado em tempo de compilação

Pilha Fluxo de controle de chamadas de funções
Cada frame da pilha corresponde ao registro de ativação de uma função. Criada pelo chamador da função Inclui parâmetros e endereço de retorno Função chamada retorna para aquele endereço

Exemplo Árvore de Execução
voltando ao nosso exemplo Adaptado de Alfred Aho, Monica Lam, Ravi Sethi, Jeffrey Ullman Compilers: Principles, Techniques & Tools

Pilha de Chamadas (call stack)
o array é global, espaço é alocado antes da execução de main ativação do procedimento main Adaptado de Alfred Aho, Monica Lam, Ravi Sethi, Jeffrey Ullman Compilers: Principles, Techniques & Tools

Exemplo ao controle alcançar a primeira chamada no corpo de main procedimento r é ativado e o registro é empilhado registro tem espaço para a variável i ao terminar ativação registro é desempilhado, deixando apenas main Adaptado de Alfred Aho, Monica Lam, Ravi Sethi, Jeffrey Ullman Compilers: Principles, Techniques & Tools

Exemplo controle alcança chamada de qs com parâmetros reais 1 e 9, registro é empilhado, com espaço para parâmetros m e n e variável local i espaçø usado por r é reutilizado na pilha, nada de r é disponível para qs(1,9) Adaptado de Alfred Aho, Monica Lam, Ravi Sethi, Jeffrey Ullman Compilers: Principles, Techniques & Tools

Exemplo veja que ao termos procedimentos recursivos, é natural que tenhamos vários registros de ativação na pilha ao mesmo tempo Adaptado de Alfred Aho, Monica Lam, Ravi Sethi, Jeffrey Ullman Compilers: Principles, Techniques & Tools

Exemplo o array é global, espaço é alocado antes da execução de main ativação do procedimento main Adaptado de Alfred Aho, Monica Lam, Ravi Sethi, Jeffrey Ullman Compilers: Principles, Techniques & Tools

Java Em Java, a pilha também é usada na interpretação de instruções => operand stack Como você representaria o estado de uma JVM?

Exemplo public class Foo { public static void main(String[] args){
int t = 10; t += t + 1; } $ javac Foo.java $ javap -classpath . -c Foo

Exemplo $ javac Foo.java $ javap -classpath . -c Foo class Foo extends java.lang.Object{ Foo(); Code: 0: aload_0 1: invokespecial #1; //Method java/lang/Object."<init>":()V 4: return public static void main(); 0: bipush 10 2: istore_0 3: iload_0 4: iload_0 5: iconst_1 6: iadd 7: iadd 8: istore_0 9: return } Total de 204 instruções; próximo de 100 quando consideramos apenas uma por grupo (iadd, dadd, etc.)

Exemplo para um procedimento
public static void main(); Code: 0: bipush 10 2: istore_0 3: iload_0 4: iload_0 5: iconst_1 6: iadd 7: iadd 8: istore_0 9: return } Reservado para variáveis locais 10 ?

public static void main(); Code: 0: bipush 10 2: istore_0 3: iload_0 4: iload_0 5: iconst_1 6: iadd 7: iadd 8: istore_0 9: return } Reservado para variáveis locais 10

10 public static void main(); Code: 0: bipush 10 2: istore_0 3: iload_0 4: iload_0 5: iconst_1 6: iadd 7: iadd 8: istore_0 9: return } Reservado para variáveis locais 10 10

1 10 public static void main(); Code: 0: bipush 10 2: istore_0 3: iload_0 4: iload_0 5: iconst_1 6: iadd 7: iadd 8: istore_0 9: return } Reservado para variáveis locais 10 10

11 public static void main(); Code: 0: bipush 10 2: istore_0 3: iload_0 4: iload_0 5: iconst_1 6: iadd 7: iadd 8: istore_0 9: return } Reservado para variáveis locais 10 10

public static void main(); Code: 0: bipush 10 2: istore_0 3: iload_0 4: iload_0 5: iconst_1 6: iadd 7: iadd 8: istore_0 9: return } Reservado para variáveis locais 21 10

public static void main(); Code: 0: bipush 10 2: istore_0 3: iload_0 4: iload_0 5: iconst_1 6: iadd 7: iadd 8: istore_0 9: return } Reservado para variáveis locais 21

public static void main(); Code: 0: bipush 10 2: istore_0 3: iload_0 4: iload_0 5: iconst_1 6: iadd 7: iadd 8: istore_0 9: return } Retorna ao chamador 21 O registro de ativação contém endereço para onde o controle deve retornar. Isto é, próximo PC.

Exemplo para vários procedimentos
public class Foo { public static void main(String[] args){ bar(10); } static void bar(int t){ t += t + 1;

public class Foo { public static void main(String[] args){ bar(10); } static void bar(int t){ t += t + 1; 10 main

public class Foo { public static void main(String[] args){ bar(10); } static void bar(int t){ t += t + 1; 10 bar 10 main main

public class Foo { public static void main(String[] args){ bar(10); } static void bar(int t){ t += t + 1; 10 10 10 bar bar 10 ... main main main

public class Foo { public static void main(String[] args){ bar(10); } static void bar(int t){ t += t + 1; Referência para variáveis locais e parâmetros do procedimento. 10 10 10 bar bar 10 ... main main main

Heap Grafo Nós correspondem as alocações dinâmica de dados
Aresta correspondem a referências para tais dados Importante! Referências podem partir da pilha ou da área estática também

Exemplo public class Tree { Node root; static class Node {
Node l, r; int val; Node(int v) { val = v; }... } Tree(int v) { if (root == null) root = new Node(v); else ... } ...

Exemplo public class Tree { ...
public static void main(String[] args){ Tree t = new Tree(5); } Objetos estão na heap! Instâncias não alcançáveis a partir da pilha ou campos estáticos estão sujeitas a garbage collection! val=5, l= null , r=null root

Liberação explícita de memória
Eficiente quando realizada adequadamente Depende do programador Quando liberação é inadequada: Em excesso, causa corrupção de memória Em falta, causa uso excessivo de memória

Memory Leaks O programador pode esquecer de liberar espaço de memória
Em C(++), usa-se explicitamente comando (delete) para liberar objetos alcançáveis por uma determinada referência Em Java, o programador precisa liberar referência para objetos

Memory Leaks: Exemplo Neste cenário, objeto referenciado por p não é mais usado. Porém, o programador esqueceu de liberar o objeto aponta por p! Heap p

Memory Leaks: Exemplo Este cenário mostra o objeto sendo liberado. Os nós em cor escura estão disponíveis para coleta. Heap Heap p p null

Garbage Collection Evita problemas relacionados a liberação explícita de memória Faz limpeza de memória automaticamente Garbage collection pode funcionar… Ocasionalmente (ex. Mark-Sweep) Incrementalmente (ex. Reference Counting)

Garbage collection (Mark-Sweep)
Heap

Garbage Collection (Reference Count.)
Reference counting Adiciona campo extra a cada célula de memória Atualiza campo de acordo com operação Quando contador de um objeto chega a zero, elimina-se todos objetos alcançáveis a partir dele Pros Promove previsibilidade - Evita interrupção da execução com eventual execução do processo de GC Cons Custo de incrementar-decrementar Problemas com estruturas cíclicas (recursivas)

Heap e Pilha public class Tree { ...
public static void main(String[] args){ Tree t = new Tree(5); } $ javap -classpath . -c Tree public class Tree extends java.lang.Object{ public static void main(java.lang.String[]); Code: 0: new #2; //class Tree 3: dup 4: iconst_5 5: invokespecial #3; //Method "<init>":(I)V 8: astore_1 9: return }}

Heap e Pilha root=null ? ? $ javap -classpath . -c Tree
public class Tree extends java.lang.Object{ public static void main(java.lang.String[]); Code: 0: new #2; //class Tree 3: dup 4: iconst_5 5: invokespecial #3; //Method "<init>":(I)V 8: astore_1 9: return }}

Heap e Pilha 5 root=null ? ? $ javap -classpath . -c Tree
public class Tree extends java.lang.Object{ public static void main(java.lang.String[]); Code: 0: new #2; //class Tree 3: dup 4: iconst_5 5: invokespecial #3; //Method "<init>":(I)V 8: astore_1 9: return }}

Heap e Pilha val=5, l= null , r=null root ? ?
$ javap -classpath . -c Tree public class Tree extends java.lang.Object{ public static void main(java.lang.String[]); Code: 0: new #2; //class Tree 3: dup 4: iconst_5 5: invokespecial #3; //Method "<init>":(I)V 8: astore_1 9: return }}

Heap e Pilha val=5, l= null , r=null root ?
$ javap -classpath . -c Tree public class Tree extends java.lang.Object{ public static void main(java.lang.String[]); Code: 0: new #2; //class Tree 3: dup 4: iconst_5 5: invokespecial #3; //Method "<init>":(I)V 8: astore_1 9: return }}

Heap e Área Estática Como organizar os dados ?
Como implementar dynamic binding ?

Exemplo class Point { protected int x,y; public Point (int x, int y) {
this.x=x; this.y=y; } public void move(int dx, int dy) { this.x += dx; this.y += dy; public float area() { return 0.0; public float dist(Point that) { int dx= this.x – that.x; int dy= this.y – that.y; return Math.sqrt(dx*dx + dy*dy);

Exemplo 1: código init Área Estática move area dist x y Heap
Instâncias Heap

Exemplo 2: atualização de estado
3 Construtor move area dist q Point p = new Point(2,3); Point q = new Point(0,0); Pilha Heap Área Estática

3 4 Construtor move area dist q Point p = new Point(2,3); Point q = new Point(0,0); p.move(1,1); Pilha Heap Área Estática

Heap p 3 4 q Construtor move area dist Point p = new Point(2,3); Point q = new Point(0,0); p.move(1,1); q = p; Pilha Área Estática

Dynamic binding class Circle extends Point { protected int r;
public Circle (int x, int y, int r) { this.x = x; this.y = y; this.r = r; } public int radius() { return this.r; } public double area() { double pi=3.1416; return pi*this.r*this.r; class Box extends Point { protected int w,d; public Box (int x, int y, int w, int d) { this.x = x; this.y = y; this.d=d; this.w = w; } public int width() { return this.w; } public int depth() { return this.d; } public double area() { return (double) this.w * this.d;

Criação de objetos e herança
Point p = null; Circle c = new Circle(0,12,4); Box b = new Box(0,4,8,8); Construtor move(herdado) area(sobreposto) dist(herdado) radius p 12 4 c b Construtor move(herdado) dist(herdado) area(sobreposto) width depth 4 8 Pilha Heap Área Estática

Polimorfismo Construtor move(herdado) area(sobreposto) dist(herdado)
p = c; p.move(20,20); double a = p.area(); Construtor move(herdado) area(sobreposto) dist(herdado) radius p 20 c 32 4 b a 50.3 Construtor move(herdado) dist(herdado) area(sobreposto) width depth 4 8 Pilha Heap Área Estática

Geração de Código

Geração de código Assembler é usado para isolar programador de detalhes de implementação de arquitetura Exemplos: Jasmin MSIL (Microsoft Intermediate Language)

Exemplo Jasmin (para Java)
Projetista não precisa se preocupar como bytecode (arquivo) é organizado .class public HelloWorld.j .super java/lang/Object .method public <init>()V aload_0 invokenonvirtual java/lang/Object/<init>()V return .end method .method public static main([Ljava/lang/String;)V .limit stack 2 .limit locals 2 getstatic java/lang/System/out Ljava/io/PrintStream; ldc "Hello World." invokevirtual java/io/PrintStream/println(Ljava/lang/String;)V

Exemplo: MSIL (1/3) // Metadata version: v2.0.50215
.assembly extern mscorlib { .publickeytoken = (B7 7A 5C E0 89 ) // .z\V.4.. .ver 2:0:0:0 } .assembly sample .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( ) .hash algorithm 0x .ver 0:0:0:0 .module sample.exe // MVID: {A224F460-A049-4A03-9E71-80A36DBBBCD3} .imagebase 0x // SEE NEXT SLIDE

Exemplo: MSIL (2/3) // SEE PREVIOUS SLIDE .file alignment 0x00000200
.stackreserve 0x .subsystem 0x // WINDOWS_CUI .corflags 0x // ILONLY // Image base: 0x02F20000 // =============== CLASS MEMBERS DECLARATION =================== .class public auto ansi beforefieldinit Hello extends [mscorlib]System.Object { .method public hidebysig static void Main(string[] args) cil managed { .entrypoint // Code size (0xd) .maxstack 8 IL_0000: nop IL_0001: ldstr "Hello World!" IL_0006: call void [mscorlib]System.Console::WriteLine(string) IL_000b: nop IL_000c: ret } // SEE NEXT SLIDE

Exemplo: MSIL (3/3) // SEE PREVIOUS SLIDE
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed { // Code size (0x7) .maxstack 8 IL_0000: ldarg.0 IL_0001: call instance void [mscorlib]System.Object::.ctor() IL_0006: ret } // end of method Hello::.ctor } // end of class Hello

Aula prática—ilasm.exe
ilasm.exe é o assembler da Microsoft Entrada: MSIL Saída: código x86 executável nas máquinas Windows do laboratório

Ambiente de execução.

Apresentações semelhantes

Apresentação em tema: "Ambiente de execução."— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback

Login

Autorizar-se através da rede social:

Ambiente de execução.

Apresentações semelhantes

Apresentação em tema: "Ambiente de execução."— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback