A2 - Sistemas Operacionais - Bruno Carvalho Maio Rodrigues

Prévia do material em texto

Matéria: Sistemas Operacionais Curso: Ciência da Computação Prof.: Miguel Angelo Z. de Figueiredo Turma: 1INF35A
Campus: Tijuca
Nome: Bruno Carvalho Maio Rodrigues Matrícula: 20181102643
1)
a) Código feito em Python.
def main(): qnt_paginas = 15
controle = 0
acho = 0
#a matriz tbl já se encontra com a listagem de páginas e os frames correspondentes.
Tbl = [int(qnt_pag)][2]
#agora a matriz tab_pag se encontra com a listagem de páginas e os frames. Tab_pag = [int(qnt_pah)][2]
D = input(“Informe d: “) P = input(“Informe p: “)
While int(controle) =! 1:
For i in range(int(qnt_pag)): For j in range(int(qnt_pag)):
If p == tbl[i][0]:
F = tbl[i][1] Controle = 1
Acho = 1 Break
Else:
Break If acho == 1:
New_endereco = str(d) + str(f)
#agora, vamos usar a string new_endereco para buscar na memória fisica o processo.
Else:
For i in range(int(qnt_pag)): For j in range(int(qnt_pag)):
If p == tab_pag[i][0]: F = tab_pag[i][1] Break
New_endereco = str(d) + str(f)
If	name	== ‘	main	’:
Print(“Hello There, está é a simulação de funcionamento da arquitetura de paginação de tabela de página”)
Print(“a memoria principal, possuindo uma TBL.”) Main()
b) Processo em que a CPU vai precisar acessar o: endereço lógico p e d, que fazem parte da página e a parte do deslocamento respectivamente. A parte do deslocamento se mantém igual, tanto no endereço lógico quanto no físico. Enquanto isso o p, ao invés de vir direto na tabela de páginas, ele busca na TLB e como ela não é do mesmo tamanho da tabela de páginas, esperando que a mesma conte na verdade, apenas referencias mais recentes que foram feitas na tabela das páginas. Então, é preciso ter além do frame, que normalmente já é armazenado na tabela das páginas, se faz necessário também guardar o número da página. Por isso deslocar-se apenas na TLB não é suficiente, pois não teria todas as páginas, vai haver somente algumas, no caso, as mais recentes. E como o princípio da localidade diz, terá apenas as mais recentes, então ganha-se eficiência nessa busca, porém se não achar, terá que ir até a tabela de páginas. E quando achar é preciso ler na TLB e depois ler na tabela de páginas para aí sim, ir para a memória física.
2)
a) Pode-se notar que no momento 7 do gráfico, na parte de processos ativos, ocorre uma elevação que chega ao máximo de processos já atingidos antes no gráfico, por consequência de um possível Deadlock. Podemos notar também, que a parir desse momento os processos vão se resolvendo, diminuindo o número de processos existentes e seguindo em constância até o final do gráfico, sem mais alterações. Isso pode indicar o fenômeno de um Deadlock, onde os processos se encontram num impasse e nenhum consegue terminar sua execução, gerando esse travamento e consumo de energia exagerado.
O que podemos fazer para resolver ou evitar isso é o uso do algoritmo do banqueiro, mantendo o uso da CPU constante e proporcional ao consumo de energia.
b) O código foi feito na linguagem Python e foi usado a biblioteca ‘Numpy’ (https://numpy.org/install/)
main:
import os
from functions import *
def main():
print(16 * '#' + '-Bankers algorithm-' + 16 * '#')
qtd_processos = int(input('Quantos processos estão em execução? '))
qtd_tipos_recursos = int(input('Quantos tipos de recursos cada processo vai necessitar? '))
recursos_totais = get_recursos_totais(qtd_tipos_recursos)
matriz_alocados = get_matriz_alocados(qtd_processos, qtd_tipos_recursos)
recursos_alocados = get_vetor_recursos_alocados(matriz_alocados)
recursos_disponiveis = get_vetor_recursos_disponiveis(recursos_totais, recursos_alocados)
matriz_recursos_necessarios = get_matriz_recursos_necessarios(qtd_processos, qtd_tipos_recursos)
input('Pressione Enter para continuar	')
os.system('clear')
imprimir_os_dados(recursos_totais, matriz_alocados, recursos_alocados, recursos_disponiveis, matriz_recursos_necessarios)
algoritmo_banqueiro(qtd_processos, qtd_tipos_recursos, recursos_disponiveis, matriz_recursos_necessarios, matriz_alocados)
if __name	== ' main__': main()
Funções:
import numpy as np import os
def get_recursos_totais(qtd_tipos_recursos):
recursos_totais = np.zeros((qtd_tipos_recursos), dtype='int64') for i in range(qtd_tipos_recursos):
recurso = int(input('Digite a quantidade do recurso %d:\n' '--> ' % (i+1)))
recursos_totais[i] += recurso
print('\nVetor de recursos existentes E =', recursos_totais) print()
return recursos_totais
def get_matriz_alocados(qtd_processos, qtd_tipos_recursos):
matriz_alocados = np.zeros((qtd_processos, qtd_tipos_recursos), dtype='int64') for i in range(len(matriz_alocados)):
for j in range(len(matriz_alocados[i])):
matriz_alocados[i, j] += int(input('Digite a quantidade do recurso %d alocada para o processo %d:\n' \
'--> ' % ((j + 1), (i + 1))))
print('\nMatriz de recursos alocados a cada processo C =\n', matriz_alocados) print()
return matriz_alocados
def get_vetor_recursos_alocados(matriz_alocados): recursos_alocados = np.zeros(len(matriz_alocados[0]), dtype='int64') for i in range(len(matriz_alocados)):
for j in range(len(matriz_alocados[i])): recursos_alocados[j] += matriz_alocados[i, j]
print()
return recursos_alocados
def get_vetor_recursos_disponiveis(recursos_totais, recursos_alocados): recursos_disponiveis = recursos_totais - recursos_alocados print('\nVetor de recursos disponíveis A =\n', recursos_disponiveis) print()
return recursos_disponiveis
def get_matriz_recursos_necessarios(qtd_processos, qtd_tipos_recursos): matriz_recursos_necessarios = np.zeros((qtd_processos, qtd_tipos_recursos),
dtype='int64')
for i in range(qtd_processos):
for j in range(qtd_tipos_recursos):
recurso_necessario = int(input('Digite a quantidade do recurso %d que é necessário ao processo %d:\n' \
'--> ' % ((j + 1), (i + 1))))
matriz_recursos_necessarios[i, j] += recurso_necessario
print('\nMatriz de recursos necessarios a cada processo R =\n', matriz_recursos_necessarios)
print()
return matriz_recursos_necessarios
def imprimir_os_dados(recursos_totais, matriz_alocados, recursos_alocados, recursos_disponiveis, matriz_recursos_necessarios):
print('Recursos totais E =\n', recursos_totais) print()
print('Recursos alocados a cada processo C =\n', matriz_alocados) print()
print('Vetor de recursos alocados P =\n', recursos_alocados) print()
print('Vetor de recursos disponiveis A =\n', recursos_disponiveis) print()
print('Matriz de recursos necessarios R =\n', matriz_recursos_necessarios) print()
input('Pressione Enter para continuar	')
os.system('clear')
def algoritmo_banqueiro(qtd_processos,qtd_tipos_recursos, recursos_disponiveis, matriz_recursos_necessarios, matriz_alocados):
# Vetor com 1's em cada processo, indicando se este ainda irá rodar (n = 1) ou não (n = 0)
rodando = np.ones(qtd_processos, dtype='int64')
# enquanto a quantidade de números diferentes de 0 for maior do que 0, a linha de código do while irá rodar
while np.count_nonzero(rodando) > 0: alocou_recursos = False
for num_processo in range(qtd_processos):
# se o processo de índice "num_processo" irá rodar ou não
if rodando[num_processo] != 0:
if all(i >= 0 for i in recursos_disponiveis - (matriz_recursos_necessarios[num_processo] - matriz_alocados[num_processo])):
alocou_recursos = True
print('Processo %d está rodando' % (num_processo + 1)) input('Pressione Enter para prosseguir	\n')
rodando[num_processo] = 0
recursos_disponiveis += matriz_alocados[num_processo] matriz_alocados[num_processo] = np.zeros(qtd_tipos_recursos,
dtype='int64')
print("Recursos Disponíveis A =\n", recursos_disponiveis) print()
print("Recursos Necessários R =\n", matriz_alocados) print()
if alocou_recursos == False:
print('--> Os processos entrarão em Deadlock') exit()
print('--> Os processos não entrarão em Deadlock.')
3)
a) Em um sistema multiprogramado a memória é compartilhada por um certo número de processos, isto é, as páginas lógicas desses processos são alocadas a páginas físicas até que não haja mais memória RAM disponível. Logo, para alocar mais memória o sistema operacionaldeve liberar uma página física, selecionando por consequência uma página lógica associada a essa página física. A determinação da página a ser substituída é feita por um algoritmo de substituição de páginas. No caso do exercício, foi escolhido o FIFO, onde é feita a substituição da página que está há mais tempo na memória, como numa fila de banco, quem chegou antes, vai ser atendido primeiro. Também temos a técnica de gerenciamento de memória denominada Swapping, onde o sistema escolhe um programa residente que é levado da memoria para o disco swapp out e retornado posteriormente para a memória principal RAM, como se nada tivesse ocorrido. E quando o programa tiver necessidade de ser executado de novo, ele é novamente carregado para a memoria principal (swapp in). Ou seja, é uma técnica computacional usada pelos sistemas operacionais para aumentar a quantidade de memoria real do computador a fim de rodar os programas e o próprio sistema sem travamentos. Uma curiosidade sobre essa técnica é que, ela tem diferença entre sistemas operacionais, onde no Windows é um arquivo da raiz do sistema (c:/) chamado Pagefile.sys e ele é criado automaticamente e vem com o tamanho da memoria RAM que tiver no PC, 4GB de RAM será 4096 MB no Pagefiles.sys. Embora no Linux também possa ser automatizado, geralmente os usuários preferem defini- lo na hora da formatação do sistema, além de que, ele não fica no arquivo raiz como no Windows.
Voltando para o FIFO, o processo é simplesmente a alocação da memoria em ordem, onde o sistema mantém uma lista de todas as páginas atuais na memória, com a pagina mais antiga na topo da lista, a que chegou mais recentemente situada no final dessa lista. E a técnica de swap in e swap out se encaixa no sentido de que, se a pagina for retirada, pretende-se usa-lá novamente depois e se não quiser esperar chegar a vez, basicamente, basta trazê-la de volta, e durante o tempo em que o processo fica em swap out, o outro que necessitava de memória entra em execução ocupando o espaço deixado pelo que saiu.
Referências bibliográficas:
Os arquivos retirados do Groups - MIGUEL ANGELO: https:// groups.google.com/g/uva-so
Sistemas Operacionais Modernos, 2a edição Andrew Tanenbaum, Editora Pearson, 2003.
Operating Systems (4th edition), William Stallings, Prentice Hall, 2001 Sistemas Operacionais - Conceitos e Aplicações, A, Silberschatz, P. Galvin, e
G. Gane, Editora Campus, 2001
Sistemas Operacionais R. S. Oliveira, A. Carissimi e S. Toscani, Editora Sagra Luzzatto, 2004
https://www.cin.ufpe.br/~can/Arquivos/gerenciamento-de-memoria.htm
http://www.inf.ufes.br/~zegonc/material/Sistemas_Operacionais/Gerencia%20d e%20Memoria%20(3)%20-
%20Algoritmos%20de%20Substitui%C3%A7%C3%A3o%20de%20Paginas.pdf