# data[].attributes.body
-Não preemptivo;
-Processos são executados na CPU na mesma ordem que chegam na fila;
-Fácil de entender e programar;
-Processo só libera o processador quando realiza chamada de sistema ou ocorre um erro de execução;

-Desvantagem- ineficiente quando há processos que demoram na execução;

# data[].attributes.body
-Os processos enviam msgs em vez de ler e escrever em variáveis compartilhadas;
-Garantida pela restrição de que uma msg só poderá ser recebida depois de ter sido enviada;
-Transferência de dados é feita após ter sido realizada a sincronização.

# data[].attributes.body
Mecanismo de sincronização, usado de forma explícita.
-Visto como variável composta, possui uma fila de tarefas S.QUEUE, e um contador inteiro S.COUNTER, que depende do semáforo utilizado;
-O conteúdo do semáforo não é diretamente acessível ao programador;
-Para manipular deve-se usar operações atômicas:
--DOWN, decrementa o contador interno S.COUNTER e o testa, caso negativo adiciona a fila S.QUEUE. Caso contrário retorna a tarefa, chamado de P(s);
--UP, incrementa o contador interno S.COUNTER e o testa, caso negativo a tarefa está suspensa. A primeira tarefa da fila S.QUEUE é devolvida a fila de tarefas prontas e retorna para execução V(s);
-Operações sobre semáforos são atômicas. Depois de iniciada nenhum outro pode acessar;
-Geralmente implementado como System Call;
-O SO desabilita todas as interrupções enquanto está testando o semáforo;
-Se existirem múltiplas CPUs, cada semáforo é protegido por uma variável LOCK como instrução TSL;
-TSL (Test and Set Lock), SO desabilita as interrupções enquanto estiver testando o semáforo;
-Não deixa que outro processo acesse o semáforo enquanto um processo está atualizando o semáforo;

# data[].attributes.body
-Condições de disputa;
-Regiões críticas;
-Exclusão mútua;
-Dormir e acordar;
-Semáforos;

# data[].attributes.body
-Scheduler seleciona um processo disponível para execução;
-Se houver vários processos os demais esperam até estar livre para um rescheduler;
-A troca é realizada pelo escalonador;
-Escalonador é o processo que escolhe o próximo processo;
-Nível mais baixo do SO;

# data[].attributes.body
-Início do sistema;
-Execução de chamada por outro processo;
-Solicitação do usuário;
-Início de um job em lote;

# data[].attributes.body
-CRIAÇÃO E REMOÇÃO
-ESCALONAMENTO
-SINCRONIZAÇÃO
-COMUNICAÇÃO
-TRATAMENTO DE IMPASSES

# data[].attributes.body
-Send (destino, &mensagem);
-Receive (fonte, &mensagem), se não houver msg disponível o receptor pode bloquear até que haja (Blocked), ou retornar com mensagem de erro (Unblocked);
-Implementadas como chamada de sistema;
-Sincronia entre os processos;

# data[].attributes.body
-Geral:
--Usado para controlar acessos a um determinado recurso com um número finito de instâncias;
--Pode assumir qualquer inteiro não negativo;
-Binário ou Mutex;
--Usado para implementar a exclusão mútua;
--Só pode assumir os valores zero e um;

# data[].attributes.body
Dois processos que querem ter acesso simultâneo a memória compartilhada

Processo A entra para execução, para e vai para In7 vaga_livre, nesse momento entra Processo B na In7 vaga_livre. Os dois se encontram na vaga_livre In7. PB vai para In8 e PA volta a ser executado pois In7 está livre sobrescrevendo PB indo para In8. Dessa forma PB nuca será executado.

Evitar - Prover um meio de assegurar que outros processos sejam impedidos de usar uma variável ou arquivo compartilhado que já estiver em uso.

# data[].attributes.body
-Não preemptivo;
-Deve-se prever o tempo de execução do processo;
-Menor processo da lista é executado primeiro;
-Menor turnaround (médio);

-Desvantagem- todos os jobs precisam ser conhecidos com antecedência e se jobs curtos começam a chegar, os longos demoram a serem executados

# data[].attributes.body
-A mudança leva ao Overhead;
--É preciso salvar as informações de processo que deixam/entram no CPU;
--Salvar o conteúdo dos registros;

# data[].attributes.headline
ESPAÇO DE ENDEREÇAMENTO DO NOVO PROCESSO

# data[].attributes.subject
ESPAÇO DE ENDEREÇAMENTO DO NOVO PROCESSO

# data[].attributes.body
-Processo Filho é uma cópia do Pai;
-O processo Filho tem um programa carregado nele;

# data[].attributes.body
Processo é um programa em execução;
-Texto (instruções);
-Contador de programa;
-Pilha: parâmetros de função, endereço de retorno e variáveis locais;
-Seções de dados;

# data[].attributes.body
-Bloqueante, quando o processo que as executar ficar bloqueado até operação seja bem sucedida;
-Não bloqueantes, quando o processo que executar a primitiva continua sua execução normal:
--Envia Bloqueante - Recebe bloqueante (Síncrono);
--Envia Bloqueante - Recebe Não bloqueante (Semi Síncrono);
--Envia Não Bloqueante - Recebe bloqueante (Semi Síncrono);
--Envia Não Bloqueante - Recebe Não bloqueante (Assíncrono);

# data[].attributes.body
MUTual EXclusion = Exclusão mútua
-Tipo abstrato de dados composto por um valor lógico e uma fila de processos;
-Uma variável especial que pode ter dois estados:
--Bloqueado (livre);
--Desbloqueado (ocupado);
-Quando um thread ou processo adquire um mutex bloqueado, ele obtém acesso exclusivo ao recurso associado ao mutex;
-Se outro thread ou processo tentar adquiri o mesmo mutex bloqueado, ele será bloqueado;
-Uma vez que mutex é liberado, outra thread ou processo pode adquiri-lo e obter acesso exclusivo;
-Normalmente oferece duas operações:
--Bloquear (lock), usada para adquirir um mutex;
--Desbloqueado (unlock), usada para liberar um mutex previamente adquirido;

# data[].attributes.body
-Parte do programa que gera uma condição de disputa;
--Os que não geram disputas são chamados: Reentrante ou Público;

# data[].attributes.body
-Preemptivo;
-Cada processo possuí uma prioridade;
-Os processos prontos com maior prioridade são executados primeiro;
-Prioridades são atribuídas dinamicamente ou estabelecidas;

# data[].attributes.body
-Despachante (Dispatcher)
--Armazena e recupera o contexto;
--Atualiza as informações no PCB;
--Processo relativamente rápido (0,1s);
-Escalonador (Scheduler)
--Escolher a próxima tarefa;
--Cria fila e a manutenção da fila;

# data[].attributes.body
-fork() : cria um novo processo;
-exec() : usado depois de um fork para substituir o espaço de memória do processo por um novo programa;

# data[].attributes.body
-PID (Número indentificador);
-Estado de processo;
-Contador de programas;
-Registro da CPU;
-Pilha de execução;
-Seção de dados;
-Informações de escalonamento;
-Informações de gerenciamento de memória;
-Informação para contabilidade;
-Informação do status de E/S;

# data[].attributes.body
-Produtor produz um item e envia uma msg contendo esse item;
- Processo Consumidor recebe a msg e consome o item;
-----------------------------------
-Função produzirItem() é responsável por criar;
-Função consumirItem(item) é responsável por processar o item recebido;
-Função enviarMensagem(item) envia uma mensagem contendo o item para o processo Consumidor;
-Função receberMensagem() espera por uma mensagem enviada pelo Produtor e retorna o conteúdo da mensagem;

# data[].attributes.body
Solução com três semáforos:
-Full (cheio), conta o número de Slots Ocupados no buffer (inicia com zero);
-Empty (vazio), conta o número de Slots Vazios no buffer (começa com o total de slots por buffer);
-Mutex, garante que o processo produtor e consumidor não acessem o buffer ao mesmo tempo, iniciando com 1, permite a exclusão mútua;

# data[].attributes.body
Quatro condições:
-Nunca dois processos podem estar simultaneamente em suas regiões críticas;
-Nada pode ser afirmado sobre a velocidade ou sobre número de CPUs;
-Nenhum processo executando fora de sua região crítica pode bloquear outros processos;
-Nenhum processo deve esperar eternamente para entrar em sua região crítica;

Alternativas para realizar:
-Desabilitar interrupções;
-Variáveis de impedimento/trava (lock variables);
-Alternância obrigatória;
-Solução/Algoritmo de Peterson;

# data[].attributes.body
-Preemptivo;
-Antigo, mais simples e mais utilizado;
-Cada processo recebe um tempo de execução (quantum);
-Ao final desse tempo o processo é suspenso e outro processo é colocado em execução;
-Também suspenso em caso de interrupção;
Escalonador mantém uma fila de processo prontos;

# data[].attributes.body
-Preemptivo:
--Quando o processo pode perder uso do CPU;
--Provoca uma interrupção forçada de um processo para  rodar outro;
-Não-preemptivo:
--Permite o processo sendo executado continuar executando;
--Condições de parada:
---Terminar de executar;
---Solicita uma operação de e/s;
---Libera explicitamente o processador;

# data[].attributes.body
-Durante a execução de um processo, ele altera seu estado;
-Em uma máquina com vários processadores, diversos processos executam ao mesmo tempo;
-Em uma máquina com apenas um processador é necessário mater uma fila com os processos aptos a ganhar o processador - Fila de aptos (ready queue)
---------------------------------
-Novo (new) processo está sendo criado;
-Executando (running) instruções estão sendo executadas;
--Um processo pode fazer chamadas de sistema;
--Até a chamada ser atendida o processo fica em Blocked;
--Blocked não disputa processador;
--Ao término do chamado o processo retorna ao Ready;
-Esperando (waiting) processo está esperando algum evento acontecer;
-Pronto (ready) processo está esperando ser associado a um processador;
-Terminado (terminated) processo terminou;
---------------------------------
-A mudança de estado de qualquer processo é iniciada por um evento
--Execuntando -> Bloqueado, evento é uma chamada;
--Apto -> Executando, realizado pelo escalonador (scheduler);
--Bloqueado -> Apto, evento é uma interrupção de hardware;

# data[].attributes.body
-Processo chamador utiliza SEND para solicitar a execução de uma rotina em outro processo;
-Passa os parâmetros para essa rotina como parte da mensagem;
-Executa um RECEIVE para receber o pedido de uma execução de rotina. Excuta a rotina. Utiliza SEND para enviar os resultados para o chamador;
-Dessa forma a comunicação entre processos baseados em mensagem é disfarçada em uma simples chamada de sub-rotina;

# data[].attributes.body
-Primitiva de alto nível para sincronizar processos e de fácil uso;
-Conjunto de procedimentos, variáveis e estruturas de dados agrupados em um único módulo ou pacote;
-Somente um processo pode estar ativo dentro do monitor em um mesmo instante;
-Outros processos ficam bloqueados até que possam estar ativos no monitor;

# data[].attributes.body
-Sleep é uma chamada de sistema que faz com que o processo que a chama durma/suspenso até outro processo o desperte;
-Wakeup tem como parâmetro o processo a ser despertado;

--Podem ainda ter um endereço de memória para equiparar os wakeups a seus sleeps;

# data[].attributes.body
-Um novo processo é criado;
-Quando um processo cria outro;
-Quando um processo chega ao fim;
-Quando um processo é bloqueado;

# data[].attributes.body
-Saída normal (voluntária);
-Saída por erro (voluntária);
-Erro fatal (involuntária);
-Cancelamento por outro processo (involuntária);

# data[].attributes.body
-Independência total entre processos, operação sobre cada processo individualmente;
-Grupo de processos, operações podem ser aplicadas sobre todo o grupo de processo;
-Hierarquia de processo, processos pai e filhos formando uma árvore de processos;

# data[].attributes.body
-Executar o processo que estava esperando esse evento;
-Continuar executando o processo que já estava sendo executado;
-Executar um terceiro processo;

# data[].attributes.body
-Processo que faz a chamada de sistema para criar um outro processo é chamado de Pai;
-Processo criado é chamado de Filho;
-Um mesmo processo Pai pode estar associado a vários Filho. Filho pode criar outros processos;
-Hierarquia pela UNIX é chamada "de grupo de processos";
-Windows não possui o conceito de hierarquia, todos os processos são criados iguais;

# data[].attributes.body
-Fila de Job, conjunto de todos os processos no sistema;
-Fila de Processos prontos (Ready queue), conjunto de todos os processos resistentes na memória principal, prontos e esperando para executar (lista encadeada);
-Fila de dispositivos, conjunto dos processos esperando por um dispositivo de E/S;
-Migração de processos entre as filas;

# data[].attributes.body
-Módulo que fornece o controle da CPU ao processo selecionado pelo escalonador da CPU;
--Troca de contexto;
--Mudança para modo usuário;
--Desvio para o endereço adequado no programa do usuário, para reiniciar o programa;
-Latência do Despacho, tempo gasto pelo despachante para interromper a execução de um processo e iniciar a executar outro;

# data[].attributes.body
-Utilização da CPU, manter a CPU ocupada a maior parte possível do tempo;
-Produtividade (Throughput), número de processos que completam sua execução por unidade de tempo;
-Tempo de processamento (Turnaround), quantidade de tempo necessário para executar um determinado processo;
-Tempo de espera, quantidade de tempo que um processo esteve esperando na fila de processos prontos;
-Tempo de resposta, intervalo de  tempo entre envio de uma requisição e a produção da primeira resposta;

# data[].attributes.body
-MAXIMIZAR UTILIZAÇÃO DA CPU;
-MAXIMIXAR PRODUTIVIDADE;
-MINIMIZAR O TEMPO DE PROCESSAMENTO;
-MINIMIZAR O TEMPO DE ESPERA;
-MINIMIZAR O TEMPO DE RESPOSTA;

# data[].attributes.body
Prover os mecanismos necessários para que os diversos processos compartilhem a memória de forma segura e eficiente.

# data[].attributes.body
-> Gerenciar a hierarquia de memória
-> Controlar as partes que estão em uso e as que não estão para:
◼ Alocar memória aos processos, quando estes precisarem
◼ Liberar memória quando um processo termina
◼ Tratar o problema do swapping:
---> Responsável por gerenciar o chaveamento entre a memória principal e o disco e memória principal e memória cache.

# data[].attributes.body
armazena dados sensíveis
é abstrato (não existe no hardware, o SO que cria pro usuário)
diretório = pastas

Partição: divisão lógica gerenciada pelo SO
ARQUIVO é a menor parte do sistema de arquivos

# data[].attributes.body
--> Memória lógica de um processo é aquela que um processo enxerga;
--> Memória física - hardware

--> Espaço de endereçamento lógico de um processo é formado por todos os
endereços lógicos que esse processo pode gerar.
--> Espaço de endereçamento físico é formado por todos os endereços aceitos
pelos circuitos integrados dememória.
--> Unidade de gerência de memória (MMU) é o dispositivo de hardware
responsável que transforma endereços virtuais em endereços
físicos.

# data[].attributes.body
◼ Primeira escolha (first fit): utiliza a primeira lacuna com tamanho mínimo necessário disponível;
◼ Melhor escolha (best fit): utiliza a lacuna que resultar na menor sobra (que gere uma nova lacuna de menor tamanho possível);
◼ Pior escolha (worst fit): utiliza a lacuna que resultar na maior sobra (que gere uma nova lacuna com maior tamanho possível);
◼ Circular-fit: utiliza a lacuna disponível após a última sobra.

# data[].attributes.body
--> A paginação é um mecanismo de gerenciamento de memória que apresenta pequena fragmentação interna e nenhuma fragmentação externa. Isto garante ao sistema que o implementa um melhor aproveitamento do hardware de memória.
--> Páginas são blocos de alocação de tamanho fixo, que são ocupados por processos.
--> Basicamente, a memória física é dividida em páginas e estas páginas são mapeadas na memória lógica.

# data[].attributes.body
Criação
Remoção
Leitura
Alteração
Escrita no fim
Execução do código contido
Alteração de permissões

Cópia de arquivo: cria > lê > escreve no arquivo recém criado
Mover arquivo: cria > lê > escreve > remove arquivo na origem

# data[].attributes.body
-- SO controla todos os dispositivos de E/S:

=> Tratar erros nas operações desses dispositivos

=> Atender interrupções geradas pelos dispositivos

=> Fornecer uma interface entre o dispositivo e o sistema

=> Emitir comandos (read, write, etc) para o dispositivo.

# data[].attributes.body
sequência de bytes
significado conhecido pelo usuário
formato difere no armazenamento dele

# data[].attributes.body
Podem ser classificados:
=> Tipo de conexão:
---> Módulo de E/S x periférico.
Serial: Mais barata; mais lenta; relativamente confiável.
normalmente usados em Impressoras e terminais
Paralela: Mais complexa; Mais cara; Mais rápida; Altamente confiável. Usada em dispositivos mais velozes. ex: disco.

=> Tipo de transferência de dados:

Dispositivos de bloco (block devices):
- Blocos de tamanho fixo.
- Transferências realizadas com um ou mais blocos.
- Mais otimizados. ex: HD, CD-ROM , USB

Dispositivos de caractere (character devices):

- Não consideram bloco.

- Não são endereçáveis
- ex: Impressoras, Interfaces de Rede, Mouses.

=> Tipo de compartilhamento de conexões:
Ponto a ponto:
- conexão mais simples;
- entre o módulo de E/S e periférico. ex:Protocolos RTS/CTS

Multiponto:
- Compartilha um conjunto de linhas.

- Entre diversos periféricos.

- Maior escalabilidade que a ponto a ponto.

- Usada para armazenamento. ex: IDE, SCSI, USB

# data[].attributes.body
Aquela coisa de professor poder excluir um arquivo e o aluno não, ou acessar etc
com acesso, o SO libera pro usuário
não tendo acesso, o SO bloqueia o usuário

também pode haver grupos de usuários... etc

# data[].attributes.body
Sequencial - início ao fim
Relativo - de uma posição relativa
Posição corrente - a partir de onde estamos no arquivo

# data[].attributes.body
- Guarda todas as infos importantes sobre aquele arquivo
- é tipo um documento do arquivo
- uma das infos mais importantes é a LOCALIZAÇÃO do arquivo no disco

- é info persistente - não se perde
- são guardados no próprio disco na partição referente ao arquivo
- fica na memória enquanto arquivo tá aberto e é atualizado constantemente

# data[].attributes.body
- processos realizam chamada de sistema para acessar arquivos e isso é mantido na memória pelo SO na TDAA
- para o SO saber quais arquivos estão abertos aonde e por quais processos
- ela controla tudo do arquivo e dos processos enquanto tá acontecendo

# data[].attributes.body
- mesma coisa porém agora por processo porque mais que um processo pode acessar o mesmo arquivo
- pra não confudir as coisas tem essa tabela daí

# data[].attributes.body
tendo uma chamada de sistema de um processo pra acessar um arquivo o SO faz:

- pesquisa o diretório corrente ou passado pela chamada de sistema
- descritor não encontrado: não existe
- descritor encontrado: variáveis passadas pra chamada de sistema

# data[].attributes.body
=> As unidades de E/S são constituídas por:
--> Componente mecânico.
--> Controladora de dispositivo.

O SO trata com a controladora.

Não lida com os dispositivos.

Comunicação CPU e controladoras.
Obs: Cada controladora possui registradores, controle pela CPU, dados para ler/escrever no dispositivo.

# data[].attributes.body
-> E/S programada.
Forma mais simples de E/S

Os dados são trocados entre a CPU e o módulo de E/S.

-> E/S via interrupções.
Interrupções são identificadas por números.

O menor número tem prioridade sobre o maior.

-> E/S via acesso direto à memória.