Gerenciamentos de Processos nos S.Os

Prévia do material em texto

REDES DE COMPUTADORES
ATIVIDADE DE INTRODUÇÃO A SISTEMAS OPERACIONAIS
GERENCIAMENTO DE PROCESSOS
UÉSLEI LIMA DA SILVA
Março / 2016
GERENCIAMENTOS DE PROCESSOS NOS DIVERSOS S.Os
Gerencia de processos nada mais é que um módulo responsável pela supervisão e execução dos programas, onde o sistema operacional é quem gerencia esses recursos. A Gerência de Processos é responsável pela seguinte área do sistema operacional: 
- Algoritmo e estrutura de dados para implementar processos e abstrações de recursos;
- Escalonamento de Processos;
- Sincronização de Processos;
- Estratégia para tratamento de bloqueios perpétuos (deadlocks);
- Parte dos mecanismos de proteção e Segurança.
GERENCIAMENTO DE PROCESSOS LINUX
Para se ter uma divisão igualitária dos recursos entre os processos concorrentes, já que o sistema utiliza recursos do processador, memória e etc, o Linux deve saber o que cada um dos processos está fazendo no sistema, e para isso, usa o “task_struct” (estrutura complexa que possui como componentes uma serie de campos como ponteiros para áreas de memória, informações de escalonamento temporizadores e contexto de processo...) usados pelo scheduler (escalonador) para racionalizar o uso de recursos do sistema.
O Kernel ver um processo como uma entrada na tabela de processos, nada mais do que isso. Por conseguinte, a tabela de processos é uma das mais importantes estruturas de dados do sistema, juntamente com a tabela de gerenciamento de memória e o buffer cache. Resumindo os dois blocos, no Linux, cada processo é formado por uma estrutura de dado chamada task_struct.
O sistema suporta dois tipos de processos: os normais e os de tempo real, os de tempo real são aqueles que precisam estar rodando constantemente e necessitam do estado de espera menor.
CRIAÇÃO DE PROCESSOS
Nenhum processo é criado do zero no Linux, menos o processo inicial INIT, que é o ponto de partida para os demais. A criação acontece a partir de um já existente que se duplica a partir da chamada FORK( ). Este novo processo se chamará filho e terá seu código modificado pelo que será executado através da chamada EXEC( ), onde permite-se assumir seu próprio conteúdo, apagando os dados do pai. Depois da chamada FORK( ) duas copias do mesmo programa estarão rodando, uma dela usa o EXEC( ).
O Linux permite dois modos de execução de programas em modos normais:
Foreground: Enquanto o processo não termina o Shell não libera o prompt para o usuário, bloqueando novos comandos.
Background: Vários comando e programas sendo executados, independente do término de cada um deles. Usa-se o símbolo & no final das linhas de comando.
Ex: & netscape &
TERMINO DO PROCESSO
Os processos devem notificar o sistema invocando seu término, usando EXIT( ). Outra forma de encerrar um processo é a chamada de sistema KILL( ). Também pode-se suspender um processo pelo usuário ou mesmo pelo sistema caso ocorra coalescência ou sobrecarga, usa-se o comando Control+Z.
ESCALONADOR LINUX
È baseado em “time –sharing”, atua na divisão do tempo de processador entre os processos e utiliza um Scheduler que é um programa encarregado de agendar os processos, ou seja, escolher o próximo processo que vai rodar, decidir quando termina, o que fazer quando o processo requisita uma entrada I/O e etc. Essas ações se dividem em: 
Kernel Work: O Scheduler deve fazer varias rotinas especificas do kernel e deve administrar a lista de espera de taredas do Scheduler.
Seleção de Processo: O Scheduler deve escolher o processo que irá rodar.
Troca de Processos: O Scheduler salva as condições que o processo atual apresenta e carrega o contexto do próximo processo.
Uma das coisas que o escalonador precisa ter ciência é em qual estado está cada processo, na estrutura que armazena os dados de cada processo temos um array de possíveis estados onde apenas uma das opções abaixo estará ativa. 
TASK RUNNING - Em execução ou aguardando para ser executado. 
TASK INTERRUPTIBLE - O processo está suspenso até que determinada condição se torne verdadeira. 
TASK UNINTERRUPTIBLE - Como o estado anterior, exceto pelo fato de que o seu estado não será modificado quando receber um sinal. É importante para os processos que necessitam executar determinada tarefa sem ser interrompido. 
TASK STOPPED - Execução do processo foi parada. 
TASK ZOMBIE - O processo está terminado, mas o processo pai ainda não executou uma chamada de sistema para retornar informações sobre o processo morto "wait", as informações não são descartadas pois ainda podem ser utilizadas. 
PRIORIDADES
São dois tipos...
Estática: Exclusiva para processos em tempo real, logo é definida pelo usuário com privilégios especiais e não é modificada pelo escalonador.
Dinâmica: Aplicada aos demais, sua prioridade é calculada a partir da prioridade base dos processos e a quantidade de tempo que lhe resta.
Os processo de prioridade estática recebem mais prioridade do que os dinâmica. Onde as faixas variam de -20 a +20. A padrão é 0 e mais alta -20.
ALGORITMO DE ESCALONAMENTO 
Primeiramente usa-se o PREEMPITIVO: Cada processo tem sua prioridade, como segunda opção, o Linux implementa duas politas de escalonamento: FIFO e ROUND ROBIN.
POLITICAS DE ESCALONAMENTO
Policy: Pode haver duas políticas, round-robin e first-in-first-out (FIFO)
Priority: Dada de acordo com o tempo que ele gastou para executar (em jiffies)
Real time priority: è usado para processos em tempo real, podem ser alteradas em chamadas de sistemas.
Counter: Quantidade de tempo (em jiffies) que o processador tem permissão para rodaer.
COMANDOS NO LINUX PARA ADMINISTRAÇÃO DE PROCESSOS
Top: verifica processos, memória e processadores;
htop: igual ao top, porém interativo com o usuário;
ps: mostra os processos em andamento;
kill, killall: mata um ou todos os processos;
renice: altera uma prioridade de funcionamento;
time: roda um programa e mostra o tempo de uso.
Strace: mostra as chamadas realizadas por um comando.
GERENCIA DE PROCESSOS MAC OS
Kernel
É criado a partir do S.O 4.4BSD e do microkernal Mach 3.0, considerado um kernel híbrido por possuir diferentes partes (monolítico e microkernel) interagindo com o sistema. Em termos de estrutura de interação, é considerado um kernel em camadas.
Fig.1: Organização de S.O. em kernel e microkernel
Exite uma estrutura mínima que interage com o hardware, deixando assim uma maior interação com outros subsistemas. O kernel fica acima da estrutura básica do S.O. agindo como conjunto de serviços oferecidos ao microkernel para suprir as requisições (chamadas de sistemas) das aplicações de usuários.
Por ser em camada o S.O. tem diversas vantagens sobre um sistema monolítico.
- Interface padronizada; 
- Extensibilidade; 
- Flexibilidade no suporte de novos subsistemas; 
- Portabilidade; 
- Confiabilidade (isolamento dos subsistemas). 
Fig.2: Organização das camadas do MAC OS X
No S.O. Mac OS X, todo seu código referente a arquitetura está no microkernel. A partir disto a portabilidade se torna fácil, sendo necessário a tradução para outra arquitetura, ou otimização de um processador específico no microkernel.
ESCALONAMENTO DE PROCESSOS
É derivado do escalonador OSFMK, porém varias mudanças na interatividade do escalonador base foram feitas. 
Assim como o kernel do FreeBSD (5.0BSD), o escalonador de processos do MAC escalona os processos baseado numa variante do algoritmo de múltiplas filas com auto alimentação, porém divide as filas em 4 grupos de processos.
- NORMAL; Prioridade das aplicações normais do usuário.
- SISTEMA; Prioridade das aplicações do sistema, com prioridade superior as threads normais de usuário.
- KERNEL; Classe reservada para threads em espaço de kernel que necessitam rodar em uma prioridade superior as threads de sistema (como a thread de descalonamento de E/S, por exemplo).
- TEMPO REAL; Threads nas quais a prioridade está baseada na necessidade de reservar uma fração pré-definida de ciclos clock, independente de outras atividadessendo executadas no sistema.
GERENCIAMENTO DE PROCESSOS ANDROID
É baseado em Linux e utiliza o gerenciamento de memoria baseado em tal. Todas operações básicas do S.O. em níveis mais baixos, como I/O, gerenciamento de memoria e etc, são tratadas pelo kernel Linux, que utiliza a biblioteca padrão C.
O Android inlcui um grupo de bibliotecas que oferece na maioria das funcionalidades disponíveis em linguagem Java. Toda aplicação possui um processo de instancia próprios na maquina virtual Dalvik. Assim como nas plataformas Java e .Net, o Android utiliza-se de uma maquina virtual. A Dalvik usa o kernel do Linux para lidar com funcionalidades de nível mais baixo.
Todo hardware do dispositivo e serviços do sistema operacional são controlados usando a Dalvik como uma camada intermediária. Ela também possui uma extensão própria de arquivos a .dex que garante um menos consumo de memoria. São criadas a partir de comandos java fornecida pela ferramenta Android SDK.
Desde o 2.2 o sistema possui uma implementação de just-in-time (JIT). Diferentemente do java VM e .Net o Android gerencia o tempo de vida do processo.
PRIORIDADE E STATOS DE PROCESSO
São mantidos na memoria até que haja a necessidade de recursos para outros processos. Na figura abaixo temos os possíveis estados e os níveis de prioridade com o qual os processos são tratados.
Fig.3: Estado de Processo e seu nível de Prioridade
- Active Processes: São processos em interação com usuário (foreground). São os processos mantidos a todo custo pelo gerenciador;
- Visible Processes: São processos que estão visíveis, mas não estão interagindo com o usuário. Estes processos somente são terminados em casos de extrema necessidade, para que um processo ativo continue executando;
- Started Service Processes: São processos hospedando serviços que foram iniciados e não possuem interface visível. Como não interagem diretamente com o usuário possuem um nível de prioridade inferior ao de processos visíveis;
- Background Processes: São processos de atividades que não estão visíveis e não possuem serviços iniciados. Estes processos são finalizados utilizando-se o padrão Last–Seen–First–Killed ;
- Empty Processes: São processos já finalizados, que são mantidos na memória pelo sistema operacional, para acelerar o start–up do mesmo e melhorar a performance do sistema. Estes processos são frequentemente finalizados para serem finalizados e cederem recursos aos processos em execução.
MEMÓRIA VIRTUAL
Memória virtual, é uma técnica que usa a memória principal como uma cache para armazenamento secundário. A memória virtual consiste em recursos de hardware e software com três funções básicas:
Realocação: Que assegura que cada processo (aplicação) tenha o seu próprio espaço de endereçamento, começando em zero;
- Proteção: Impede que um processo utilize um endereço de memória que não lhe pertença;
- Paginação (paging) ou troca (swapping): Que possibilita a uma aplicação utilizar mais memória do que a fisicamente existente.
Segmentação
A segmentação divide a memória em 2 espaços distintos, o espaço do kernel (Kernel Space) e o espaço do usuário (User Space). Dentro destes espaços temos os 4 segmentos básicos:
- Kernel Code.
- Kernel Data/Stack.
- User Code.
- User Data/Stack.
Desta forma podemos garantir a proteção da memória, evitando o acesso de memória entre usuários. Garantindo principalmente que processos em modo kernel não se misturem com processos em modo usuário e que a pilha de dados não cresça indiscriminadamente.
PAGINAÇÃO
Com a Segmentação teríamos blocos de memória contínuos para cada processo. Isso faz com que a memória fique sobrecarregada. Para reolver este problema é usada a Paginação, onde a memória é dividida em pedaços de tamanho fixo.
COMUNICAÇÃO ENTRE PRCESSOS
Com a segmentação e paginação, o acesso de uma memória a outra não é permitida, por isso, foram criadas mecanismos de comunicação entre processos.
No Android usa-se o binder para comunicação entre processos, onde ele implementa um código no kernel em: “drivers/misc/binder.c” para esta tarefa. Toda comunicação passa por ele, mas para o desenvolvedor o processo é transparente, já que é abstraída pelas bibliotecas do sistema.
ESCALONAMENTO
Assim como no Linux, o S.O divide seus processos em três grandes classes: Processos Interativos, Batch e em Tempo Real. Em cada classe os processos podem ser subdivididos em I/O bound ou CPU bound. O S.O. Android não distingue processos interativos de Batch, diferenciando apenas os processos em Tempo Real. O Escalonador é baseado em time-sharing, ou seja em fatias de tempo, que são denominadas de quantum, onde são alocadas nos processos. O algoritmo do escalonador divide o tempo de processamento em épocas (epochs). Outra características do escalonador do S.O. é a existência de propriedades dinâmicas. 
DEADLOCKS
É caracterizado quando ocorre um impasse entre dois ou mais processos que ficam impedidos de operar. Ocorre com um conjunto de processos e recursos não-preemptíveis, onde um ou mais processos desse conjunto está aguardando a liberação de um recurso por outro processo, que por sua vez aguarda a liberação de outro recurso dependente do primeiro processo. O android não faz tratamento de deadlocks, o sistema parte do principio que eles não irão ocorrer.
GERENCIAMENTO DE PROCESSOS FIREFOX OS
Firefox OS usa threads POSIX para implementar as threads de aplicações, isso inclui a thread principal de cada aplicação bem como as Web workers e helper threads. Valores "Nice" são usados para priorizar os processos e a execução das threads confiando no agendador padrão do kernel do Linux.
Alguns níveis possuem os mesmos "nice values", isso acontece porque esses níveis diferem da forma que são tratados pelo "out-of-memory killer". Todas as prioridades podem ser ajustadas em tempo de compilação via "Preferências".
	Priority
	Nice
	Used for
	MASTER
	0
	main b2g process
	FOREGROUND_HIGH
	0
	applications holding a CPU wakelock
	FOREGROUND
	1
	foreground applications
	FOREGROUND_KEYBOARD
	1
	keyboard application
	BACKGROUND_PERCEIVABLE
	7
	background applications playing audio
	BACKGROUND_HOMESCREEN
	18
	homescreen application
	BACKGROUND
	18
	all other applications running in the background
	Process priority levels
Tab.1
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
Dentro de um processo a thread principal herda o "nice value" do processo, enquanto às threads do web worker é atribuido um "nice value" um ponto  maior que a thread principal que roda na menor prioridade. Isso é feito para evitar que processos que utilizem muita CPU degradem a performance da thread principal. Prioridades de processos são alterados sempre que acontece um grande evento como quando uma aplicação é enviada para rodar em background ou foreground, uma nova aplicação é iniciada, ou uma aplicação existente executa uma wake-lock da CPU. Toda vez que a prioridade de um processo é ajustada todas as prioridades de suas threads também são ajustadas em conformidade.
PRIORIDADE DE PROCESSOS
No Firefox OS os aplicativos são encerrados seguindo a política de ordem de prioridade, que é imposta dando a cada aplicação um nível de prioridade e associando uma pontuação de ajuste (OOM) a esses níveis:
Os primeiros aplicativos a serem encerrados serão os aplicativos em segundo plano, iniciando pelos menos utilizados recentemente.
O aplicativo homescreen é o próximo a ser encerrado.
Em seguida, são encerrados os aplicativos em segundo plano que são perceptíveis pelo usuário (por exemplo, um leitor de música reproduzindo áudio em segundo plano ou um aplicativo que possua um wakelock de high-priority ou cpu  e ter um manipulador de mensagens de sistema registrado.)
Se o teclado estiver em uso, será o próximo a ser encerrado.
Aplicações em primeiro plano serão as próximas a serem encerradas.
Finalmente, aplicações em primeiro plano que solicitaram um wakelock  high-priority ou cpu serão as últimas a serem encerradas.Existe algumas excessões para essas regras:
O processo principal nunca é terminado pelo LMK, pois se isso for feito todos os demais processos serão terminados e o sistema operacional seria reiniciado. O processo principal é executado com oom_adj 0.
Nós mantemos um processo que é utilizado para acelear o início de novos aplicativos chamado preallocated process. Normalmente esse processo é mantido ativo pois consome pouca memória e permite uma maior velocidade ao iniciar um aplicativo. A única situação na qual esse processo pode ser terminado é se não existir memória suficiente para o processo principal manter-se ativo após os outros processos terem sido terminados.
GERENCIMENTO DE PROCESSOS IOS
A estrutura do iOS é descrita como um conjunto de quatro camadas, como pode ser
visto na figura 1. Esse sistema obedece uma hierarquia, de forma que quanto mais
abaixo na camada, maior deve ser a dificuldade no desenvolvimento e na compreensão.
Fig.4 Estrutura do Sistema
Algumas APIs de Chamada de Sistema
Sabemos que as chamadas de sistema apresentam uma interface com os serviços disponibilizados por um S.O. As APIs especificam um conjunto de funções disponíveis para o programador de aplicações. Dentr algumas APIs mais comuns temos a fork( ) que cria um novo processo, sinopse: 
# include<unistd.h>
Pid_t
Fork(void);
Descrição da chamada fork( ): cria um novo processo“filho”que é uma cópia da chamada do “pai”, exceto quando:
- O processo filho tem um ID único.
 - O processo filho tem uma ID diferente do processo pai.
- O processo filho tem sua cópia de descritores pai
Após a conclusão do fork( ) retorna um valor 0 para o filho processar e retorna o ID do processo filho para o pai, caso contrario o valor de -1 é retornado para o pai.
Fork( ) irá falhar e nenhum processo será criado se:
1 - O limite do sistema impõe sobre o número total de processos em execução, se o mesmo for excedido. Esse limita é a configuração-dependente.
2 - O limite do sistema-imposto MAXUPRC (<sys/param.h>) sobre o número total de processos em execução por um único usuário, estaria ultrapassado.
3 - Existe espaço de troca insuficiente para o novo processo.
Há limites para que o usuário possa fazer no processo filho. Para ser totalmente seguro,
o usuário deve restringir-se apenas à execução assíncrona de sinal a segurança das
operações até que uma das funções exec é chamado.
Todas as APIs, incluindo símbolos de dados globais, em qualquer quadro ou biblioteca deve ser considerada insegura depois de um fork( ) a menos que explicitamente documentado para ser seguro ou sinalasync segura. Se o usuário precisar usar essas estruturas no processo filho, o mesmo deve fazer o uso das funções exec.
REFERÊNCIAS
Mac OS: http://pt.slideshare.net/dnxwit/mac-osx-9949164
Gerenciamento de Processos/ com Linux: www.ricardobarcelar.com.br/aulas/soa/mod1-ger_processos.pdf
Livro: Sistemas Operaionais Modernos, TANENBAUM, 3ª Edição: Processos e Processos do Linux.
Sistemas Operacional Android: www.midiacom.uff.br/~natalia/2012-1-sisop/tgrupo1.pdf
Gerencia de Processos Linux: https://www.vivaolinux.com.br/artigo/Estudo-sobre-os-tipos-de-gerenciamento-do-SO-Linux?pagina=5
Arquitetura Mozila OS: https://developer.mozilla.org/pt-BR/Firefox_OS/Architecture
Prioridade de Processos Mozila OS: https://developer.mozilla.org/pt-BR/Firefox_OS/Platform/Out_of_memory_management_on_Firefox_OS
processos IOS: http://www.midiacom.uff.br/~natalia/2012-1-sisop/tgrupo7.pdf
Imagens:
Figura1, Disponivel em: https://teamshellcode.wordpress.com/category/pisando-em-solo-fertio/sistemas-operacionais/
Figura2, Disponivel em: http://www.jornallivre.com.br/215117/as-caracteristicas-do-mac-os-x.html
Figura3, Retirada do material Sistemas Operacionais Android, Link acima.
Figura4, Disponivel em: http://diegofilipepedro.blogspot.com.br/2011/04/estrutura-do-sistema-ios.html