Sistema Operacional

Como executar:

git clone https://github.com/lucasmsoares96/Sistema-Operacional.git
make
make run

Integrantes:

• Vitor Martins Soares
• Jorge Vitor Gonçalves
• Lucas Martins Soares
• Gabriel Mesquita Pereira

Lista de Termos:

Durante a execução do programa, são mostradas os seguintes termos e abreviações:

Nome:	Descrição
processo	identificador do processo que está sendo executando atualmente
Ciclos	quantidade de ciclos mínima que o processo precisa para concluír o seu processamento
Cnt_Ciclos	contador da quantidade de cíclos decorridos que um processo participou
Rst_Ciclos	quantidade de ciclos restantes comparada à quantidade mínima de ciclos necessários
Max_Quantum	quantidade máxima de quantum que um processo pode receber por ciclo
Timestamp	tempo de já processado de um processo
Prioridade	a prioridade do processo
Tipo	se o processo é cpu, I/O ou memory bound
Processos Novos	processos que ainda não passaram pela política de escalonamento
Processos Bloqueados	processos que estão sendo penalizados por serem I/O ou memory bound
Processos Prontos	processos que estão prontos para serem executados
Processo em Execução	processo que estão utilizando o processador atualmente
Processos Finalizados	porocessos que já executaram o seu quantum no ciclo atual
Processos Concluidos	processos que já concluíram todos os seus ciclos

Tarefas

[13/13] Escalonador

• [X] Criar uma thread para o escalonador
• [X] ler o json de processos
  • processo
  • ciclos
  • max_quantum
  • init_type
  • timestemp
  • prioridade
• [X] [3/3] Escalonador
  • [X] política no json de configuração
  • [X] política no escalonador
  • [X] mecanismo no escalonador
• [X] Resultado
  • [X] logica
• [X] gerar arquivo de resultado
  • resultado.json
  • [X] timestamp total
  • [X] ciclos de cpu
  • [X] sequancia da ações (cpu, memory ou io bound) aleatorias
• [X] [3/3] comandos
  • [X] execute: Executa a fila de processos definida conforme configuração prévia.
  • [X] kill -9: Finaliza a execução do sistema operacional, voltando o mesmo para o estado inicial, em que os processos estariam ainda em faze de criação inicial.
  • [X] queueschell: detalha quais processos estão sendo gerenciados pelo seu sistema, quais estão em estado de pronto, bloqueado, execução e/ou sendo criados e finalizados.
• [X] print loop
• [X] conferir timestamp bloqueados
• [X] semente fixa
• [X] print tipo atual
• [X] ciclos em float
• [X] sortear quantum de maxquantum
• [X] erro exit

• um único processo é executado por ciclo de tempo pré-definido pelo seu JSON.
• processos apenas ganham certo tempo, rodam por esse tempo e voltam a ficar prontos e/ou bloqueados, tudo isso considerando a sequência de chegada.
• estratégia de escalonamento o modelo RoundRobin, o qual executa os processos na ordem que vão chegando no sistema.
• guarde em disco um log da execução detalhando quanto tempo cada processo ganhou de cada recurso e qual foi o timestamp final dele ao fechar seu ciclo de execuções.

[4/4] Shell

• [X] [3/3] Sua função é criar:
  • [X] uma estrutura básica,
  • [X] um kernel, que represente esse modelo de hardware e
  • [X] um shell básico que consiga apresentar esses dispositivos e sua capacidade
• [X] Simbolo do shell
• [X] [4/4] Json de configuração
  • [X] 5 unidades de memória: espaço suficiente para guardar tudo que um processo precisa
  • [X] 1 disco
  • [X] 1 processador
  • [X] configurar com json
• [X] [3/3] comandos
  • [X] help: Demonstra quais comandos podem ser executados pelo shell desenvolvido;
  • [X] meminfo: detalha quantas unidades de memória so sistema possui, quantas estão livres e quantas estão alocadas e para quais processos.
  • [X] cpuinfo: detalha qual processo está em execução, qual o timestamp e quantum desse.
  • cores para cpu
  • segmentos para memoria
  • blocos para disco

Observação: Neste trabalho é muito importante que vocês pensem sua construção de forma modular, pois, cada módulo sofrerá alterações conforme caminhamos na disciplina. Além disso, considere nesse primeiro protótipo o shell como o inicializador do sistema, ou seja, a entrada de comandos para o simulador como um prompt que se abre, ha uma escolha do comando a ser executado e tudo começa a ser feito a partir dai. Como nosso sistema é não preemptivo então, dependendo da função escolhida, o shell ficará travado até a finalização da execução.

Observação: Note que neste momento o objetivo é ter um shell funcional e que ainda não teremos processos em execução ou recursos sendo consumidos. A ideia é mostrar como o sistema de vocês vai representar tais módulos na tela e como esses foram estruturados para, no futuro, receber uma lista de entrada para processar. Como dito em sala, tentem imaginar a execução em duas etapas: (i) módulo que executa o processamento da entrada e; (ii) módulo que define a política utilizada por (i) para organizar a execução.

próxima etapa

• [-] [1/4] Json de processos
  • [X] quantos processos
  • [ ] intervalo medio de criação
  • [ ] porcentagem de chance do processo ser cpu-bound, memory-bound ou I/O-bound
  • [ ] médias de acesso a memória, disco e cpu
    • Considere como média a quantidade de vezes que ele deve utilizar o recurso a cada ciclo de avaliação
    • Considere como ciclo um tempo de execução em que você para tudo e o escalonador avalia quem executará em seguida.
    • Ao criar um processo tente elaborar uma regra de atribuição para sua função conforme as porcentagens definidas.
• [X] processo aumentar quantidade de recursos