Variáveis Dinâmicas Caixas de Nós

1. Variáveis Dinâmicas Caixas de Nós Inhaúma Neves Ferraz Departamento de Ciência da Computação Universidade Federal Fluminense ferraz@ic.uff.br

2. Sumário • Dados estáticos e dinâmicos • Variáveis dinâmicas • Caixa de nós • Conceito • Funções que tratam de caixas de nós • Implementação em memória • Implementação em memória secundária

3. Variáveis Dinâmicas Caixas de Nós

4. Dados estáticos e dinâmicos Os tipos de dados e as estruturas de dados utilizados nos algoritmos e programas podem ser estáticos e dinâmicos No primeiro caso a alocação de espaço de memória é feita uma só vez e é imutável Para melhor aproveitar os espaços disponíveis pode-se postergar as solicitações de memória até a ocasião de sua necessidade real e liberar espaços tornados desnecessários em processos que evoluam dinamicamente

5. Variáveis Dinâmicas Pode-se utilizar um processo de alocação de memória de forma dinâmica, isto é, só requisitar memória no momento de utilização de cada registro Isto é feito declarando uma variável como sendo um ponteiro para um tipo específico de objeto e criando dinamicamente objetos desse tipo e atribuindo seu endereço à variável ponteiro

6. Caixa de nós (1) A alocação de espaços requeridos pelos algoritmos e programas pode ser considerada como a manipulação de registros originados em uma “CAIXA DE NÓS” Esta caixa de nós contém, inicialmente, um número finito de registros Os programas só tem acesso à caixa de nós através das operações getnode e freenode A criação de uma lista de nós disponíveis ou caixa de nós é feita pelo procedimento create_avail Os nós são obtidos de um “array” quando se utiliza a memória principal O procedimento é o mesmo em memória secundária quando os nós são obtidos seqüencialmente de um arquivo de acesso direto

7. Caixa de nós (2) getnode remove um registro da caixa de nós e o fornece ao programa freenode devolve à caixa de nós um registro que não mais esteja sendo utilizado pelo programa. a operação getnode em uma caixa de nós vazia mostra qeue a memória reservada para as estruturas de dados do programa é insuficiente Esta situação configura um transbordamento ou “overflow”

8. Caixa de nós (3)

9. * * * * * * * * * . . . . . ^ Avail . . . . . Avail ^ Getnode . . . . . Getnode ^ Avail . . Getnode Avail * * * ^ Gerenciamento de espaçodisponível (“available”) • Alocação de um novo nó If Avail = Null then sem-espaço (a) else begin Getnode := Avail; (b) Avail := Next(Avail); (c) Next(Getnode) := Null end;

10. * * * * * * INFO NEXT Q * . . . . . Avail ^ Q NEXT Avail * . . . . . ^ Liberação de um nó Procedimento Freenode(Q) (a) Next(Q) := Avail (b) Info(Q) := Null (c) Avail := Q

11. Algoritmos

12. FUNÇÕES QUE TRATAM DAS CAIXAS DE NÓS Implementação por ponteiros inteiros sobre um “array” Definição de dados Constantes

13. Tipo de registro Tipo de dado t_caixa array[0..NUMNODES - 1] de reg

14. Algoritmos Início avail  ZERO Para i variando de ZERO até NUMNODES - 2 caixa[i].next  i + 1 Fim do Para caixa[NUMNODES - 1].next  MENOS_UM Fim do procedimento

15. Método create_avail() void create_avail(void){ int i; avail = 0; for(i=0; i<numNodes-1; i++){ node[i].next = i+1; } node[numNodes-1].next = -1; }

16. Método getnode() Início Se (avail = MENOS_UM) então retorne(MENOS_UM) Fim do Se p  avail avail  caixa[avail].next retorne(p) Fim do procedimento

17. Getnode (2) int getNode(void){ int p; if (avail==-1){ std::cout<<"Overflow\n"; exit(1); } p=avail; avail=node[avail].next; return p; }

18. Freenode (1) Início caixa[p].next  avail avail  p retorne Fim do procedimento

19. Freenode (2) void freenode(int p) { node[p].next = avail; avail = p; return; } /* end freenode */ 19

20. Implementação em memória

21. Caixa de nós em memória

22. Getnode em C++ template <class T> Node<T> *GetNode(const T& item, Node<T> *nextPtr=NULL) { Node<T> *newNode; //declaração de ponteiro para nó newNode=new Node<T>(item, nextPtr); //alocação de memória // passagem de item e nextptr para o construtor // encerrar se a alocação falhar if (newNode==NULL) {cerr<<“A alocação de memória falhou"<<endl; exit(1); } return newNode; }

23. Implementação em memória secundária

24. Getnode em C++ //Retorna um nó (Registro) disponível do arquivo de acesso direto Int getNode() { Bucket *header; Bucket *areaTrab; int posicao; header = new Bucket; areaTrab = new Bucket; header = &(lerBucket(0)); posicao = header->proximo; if (posicao == 0) cout << "Nao ha mais nos disponiveis"; else { //Atualiza o indicador do próximo registro disponível areaTrab = &(lerBucket(posicao)); header->proximo = areaTrab->proximo; gravarBucket(0,*header); } delete(header); delete(areaTrab); return posicao; }

25. Freenode em C++ //Libera um registro e o coloca de volta na caixa de nós disponíveis Void freeNode(int posicao) { Bucket *header; Bucket *areaTrab; header = new Bucket; areaTrab = new Bucket; header = &(lerBucket(0)); areaTrab = &(lerBucket(posicao)); areaTrab->proximo = header->proximo; header->proximo = posicao; gravarBucket(0,*header); gravarBucket(posicao,*areaTrab); delete(header); delete(areaTrab); }

26. Getnode em Java (1) /* getnode * Parametros: * arq: arquivo de acesso direto da caixa de nós */ public static int getnode(RandomAccessFile arq) { Bucket header = new Bucket(); int endereco = 0; try { arq.seek(0); header.read(arq); // Extrair de header o endereço do próximo registro disponível endereco = header.proximo; if (header.proximo == -1) { System.out.println("Nao ha mais nos!");// - Arquivo lotado }

27. Getnode em Java (2) else // Ainda ha nos { Bucket areaTrabalho = new Bucket(); arq.seek(endereco*Bucket.size()); areaTrabalho.read(arq); header.proximo = areaTrabalho.proximo; arq.seek(0); header.write(arq); } } catch(IOException ex) { ex.printStackTrace(); } finally { return endereco; } }

28. Freenode em Java (1) /* Devolver a caixa de nos um bucket não mais necessário. * Parametros: * endBucket: endereço do bucket a ser liberado **/ public static void freenode(int endBucket) { Bucket areaDeTrabalho = new Bucket(); Bucket header = new Bucket(); // int proxBucketDisponivel; //endereço de bucket que pode ser alocado

29. Freenode em Java (2) try { arqDireto.seek(endBucket*Bucket.size()); areaDeTrabalho.read(arqDireto); arqDireto.seek(0); header.read(arqDireto); areaDeTrabalho.setProximo(header.proximo); // Susbstitui em header o valor do antigo proximo bucket disponivel // pelo endereco do bucket devolvido a caixa de nos. header.setProximo(endBucket); //Limpa o bucket devolvido a caixa de nos Cisao.Inicializar(areaDeTrabalho); //Grava o bucket devolvido a caixa de nos e o header atualizado. arqDireto.seek(endBucket*Bucket.size()); areaDeTrabalho.write(arqDireto); arqDireto.seek(0); header.write(arqDireto); }

30. Freenode em Java (3) catch (IOException ex) { ex.printStackTrace(); } }