Segundo alguns autores (Silberschatz et al, 2005; Stallings, 2004; Tanenbaum, 1999), existem dois modos distintos de conceituar um sistema operacional:
- pela perspectiva do usuário ou programador (visão top-down): é uma abstração do hardware, fazendo o papel de intermediário entre o aplicativo (programa) e os componentes físicos do computador (hardware); ou
- numa visão bottom-up, de baixo para cima: é um gerenciador de recursos, i.e., controla quais aplicações (processos) podem ser executadas, quando, que recursos (memória, disco, periféricos) podem ser utilizados.
Na primeira geração (aproximadamente 1945-1955), os computadores eram tão grandes que ocupavam salas imensas. Foram basicamente construídos com válvulas e painéis, os sistemas operacionais "não existiam". Os programadores, que também eram os operadores, controlavam o computador por meio de chaves , fios e luzes de aviso. Nomes como Howard Aiken (Harvard), John von Neumann (Instituto de Estudos Avançados de Princeton), John Adam Presper Eckert Jr e William Mauchley (Universidade da Pennsylvania) e Konrad Zuse (Alemanha) formaram, com suas contribuições, a base humana para o sucesso na construção dos computadores primitivos. Na geração seguinte (aproximadamente 1955-1965), foram criados os sistemas em lote (batch systems), que permitiram melhor uso dos recursos computacionais. A base do sistema operacional era um programa monitor, usado para enfileirar tarefas (jobs). O usuário foi afastado do computador; cada programa era escrito em cartões perfurados, que por sua vez eram carregados, juntamente com o respectivo compilador (normalmente Fortran ou Cobol), por um operador, que por sua vez usava uma linguagem de controle chamada JCL (job control language).
História
Sistema operacional em linha de comando.
No início da computação os primeiros sistemas operacionais eram únicos, pois cada mainframe vendido necessitava de um sistema operacional específico. Esse problema era resultado de arquiteturas diferentes e da linguagem de máquina utilizada. Após essa fase, iniciou-se a pesquisa de sistemas operacionais que automatizassem a troca de tarefas (jobs), pois os sistemas eram monousuários e tinham cartões perfurados como entrada (eliminando, assim, o trabalho de pessoas que eram contratadas apenas para trocar os cartões perfurados).Um dos primeiros sistemas operacionais de propósito geral foi o CTSS, desenvolvido no MIT. Após o CTSS, o MIT, os laboratórios Bell da AT&T e a General Eletric desenvolveram o Multics, cujo objetivo era suportar centenas de usuários. Apesar do fracasso comercial, o Multics serviu como base para o estudo e desenvolvimento de sistemas operacionais. Um dos desenvolvedores do Multics, que trabalhava para a Bell, Ken Thompson, começou a reescrever o Multics num conceito menos ambicioso, criando o Unics (em 1969), que mais tarde passou a chamar-se Unix. Os sistemas operacionais eram geralmente programandos em assembly, até mesmo o Unix em seu início. Então, Dennis Ritchie (também da Bell) criou a linguagem C a partir da linguagem B, que havia sido criada por Thompson. Finalmente, Thompson e Ritchie reescreveram o Unix em C. O Unix criou um ecossistema de versões, onde destacam-se: System V e derivados (HP-UX, AIX); família BSD (FreeBSD, NetBSD, OpenBSD, etc.), Linux e até o Mac OS X (que deriva do Mach e FreeBSD).
Na década de 1970, quando começaram a aparecer os computadores pessoais, houve a necessidade de um sistema operacional de utilização mais fácil. Em 1980, William (Bill) Gates e seu colega de faculdade, Paul Allen, fundadores da Microsoft, compram o sistema QDOS ("Quick and Dirty Operating System") de Tim Paterson por $50.000, batizam-no de DOS (Disk Operating System) e vendem licenças à IBM. O DOS vendeu muitas cópias, como o sistema operacional padrão para os computadores pessoais desenvolvidos pela IBM. IBM e Microsoft fariam, ainda, uma parceria para o desenvolvimento de um sistema operacional multitarefa chamado OS/2. Após o fim da breve parceria a IBM seguiu sozinha no desenvolvimento do OS/2.
No começo da década de 1990, um estudante de computação finlandês postou um comentário numa lista de discussão da Usenet dizendo que estava desenvolvendo um núcleo de sistema operacional e perguntou se alguém gostaria de auxiliá-lo na tarefa. Este estudante chamava-se Linus Torvalds e o primeiro passo em direção ao tão conhecido Linux foi dado naquele momento.
Os sistemas operacionais mais utilizados no Mundo
| Nome | Fundação/Empresa | Ano de lançamento | Versão mais recente | Percentagem | Utilizadores |
|---|---|---|---|---|---|
| Windows | Microsoft | 1993 | Windows 7 | 88.90% | 400 milhões |
| Mac OS X | Apple | 2001 | Mac OS X v10.7 "Lion" | 5.54% | 22,5 milhões |
| Linux | Linux Foundation | 1991 | Linux Kernel 3.0.4 | 2,13% | 8,5 milhões |
Outros sistemas operacionais livres
| Nome | Equipe de desenvolvimento | Núcleo | Ano do início do desenvolvimento | Versão mais recente |
|---|---|---|---|---|
| ReactOS | ReactOS Foundation | ReactOS Kernel | 1996 | ReactOS 0.3.13 |
| FreeDOS | FreeDOS.org | FreeDOS Kernel | 1994 | FreeDOS 1.0 |
| FreeBSD | FreeBSD Team | FreeBSD Kernel | 1996 | FreeBSD 8.2 |
| GNU | Free Software Foundation | GNU Hurd | 1984 | GNU 0.2 |
Visão geral
Existem vários sistemas operativos; entre eles, os mais utilizados no dia a dia, normalmente utilizados em computadores domésticos, são o Windows, Linux e Mac OS X.
O sistema operativo funciona com a iniciação de processos que este irá precisar para funcionar correctamente. Esses processos poderão ser ficheiros que necessitam de ser frequentemente actualizados, ou ficheiros que processam dados úteis para o sistema. Poderemos ter acesso a vários processos do sistema operativo a partir do gestor de tarefas, onde se encontram todos os processos que estão em funcionamento desde o arranque do sistema operativo até a sua utilização actual. Pode-se também visualizar a utilização da memória por cada processo, no caso de o sistema operativo começar a mostrar erros ou falhas de acesso a programas tornando-se lento, pode-se verificar no gestor de tarefas qual dos processos estará bloqueado ou com elevado número de processamento que está a afectar o funcionamento normal da memória.
Sistemas Operacionais Modernos
Um sistema computacional moderno consiste em um ou mais processadores, memória principal, discos, impressoras, teclado, mouse, monitor, interfaces de rede e outros dispositivos de entrada e saída. Enfim, é um sistema complexo.Um dos conceitos mais fundamentais dos Sistemas Operacionais Modernos é a distinção entre o programa e a atividade de executá-lo. O programa é apenas um conjunto estático de diretrizes e sua execução é uma atividade dinâmica
Outra das diferenças que podemos observar entre um sistema operacional e aplicações convencionais é a forma com que suas rotinas são processadas em função do tempo. Um sistema operacional não é executado de forma estruturada. Suas rotinas são executadas concorrentemente em função de eventos assíncronos. Em outras palavras, eventos que podem ocorrer a qualquer momento.
Funcionamento
Um sistema operacional possui as seguintes funções:- gerenciamento de processos;
- gerenciamento de memória;
- sistema de arquivos;
- entrada e saída de dados.
Gerenciamento de processos
O sistema operacional multitarefa é preparado para dar ao usuário a ilusão que o número de processos em execução simultânea no computador é maior que o número de processadores instalados. Cada processo recebe uma fatia do tempo e a alternância entre vários processos é tão rápida que o usuário pensa que sua execução é simultânea.São utilizados algoritmos para determinar qual processo será executado em determinado momento e por quanto tempo.
Os processos podem comunicar-se, isto é conhecido como IPC (Inter-Process Communication). Os mecanismos geralmente utilizados são:
- sinais;
- pipes;
- named pipes;
- memória compartilhada;
- soquetes (sockets);
- trocas de mensagens.
Gerenciamento de memória
O sistema operacional tem acesso completo à memória do sistema e deve permitir que os processos dos usuários tenham acesso seguro à memória quando o requisitam.
- assegurar que cada processo tenha seu próprio espaço de endereçamento, começando em zero, para evitar ou resolver o problema de relocação (Tanenbaum, 1999);
- prover proteção da memória para impedir que um processo utilize um endereço de memória que não lhe pertença;
- possibilitar que uma aplicação utilize mais memória do que a fisicamente existente.
Swapping
Dentro de gerenciamento de memória, pode não ser possível manter todos os processos em memória, muitas vezes por não existir memória suficiente para alocar aquele processo. Para solucionar esse problema existe um mecanismo chamado swapping, onde a gerência de memória reserva uma área do disco para o seu uso em determinadas situações, e um processo é completamente copiado da memória para o disco; este processo é retirado da fila do processador e mais tarde será novamente copiado para a memória; Então, o processo ficará ativo na fila novamente. O resultado desse revezamento no disco é que o sistema operacional consegue executar mais processos do que caberia em um mesmo instante na memória. Swapping impõe aos programas um grande custo em termos de tempo de execução, pois é necessário copiar todo o processo para o disco e mais tarde copiar novamente todo o processo para a memória. Em sistemas onde o usuário interage com o programa durante sua execução, o mecanismo de swapping é utilizado em último caso, quando não se é possível manter todos os processos na memória, visto que a queda no desempenho do sistema é imediatamente sentida pelo usuário.[10]Sistema de arquivos
A memória principal do computador é volátil, e seu tamanho é limitado pelo custo do hardware. Assim, os usuários necessitam de algum método para armazenar e recuperar informações de modo permanente.Um arquivo é um conjunto de bytes, normalmente armazenado em um dispositivo periférico não volátil (p.ex., disco), que pode ser lido e gravado por um ou mais processos.
Tipos de Sistemas
Sistemas multi-processadores
Os sistemas multi-processadores – dois ou mais processadores trabalhando juntos – podem ser divididos em duas partes:- Sistemas fortemente acoplados;
- Sistemas fracamente acoplados.
- Sistemas simétricos – onde os processadores têm a mesma função;
- Sistemas assimétricos – onde um processador (mestre) pode executar serviços do sistema operacional.
- Sistemas operacionais de rede – cada sistema, também chamado host ou nó, possui seus próprios recursos de hardware, como processadores, memória e dispositivos de entrada e saída. Os nós são totalmente independentes dos terminais, sendo interconectados por uma rede de comunicação de dados, formando uma rede de computadores.
- Sistemas operacionais distribuídos – computadores independentes que parecem um único computador aos olhos do usuário; Trata-se de um conjunto de processos que são executados de forma concorrente, cada um dos quais acessando um subconjunto de recursos do sistema. E essa comunicação é feita em forma de envio de mensagens.
Interface de uso
GUI (Graphical user interface)
Nesse tipo de interface, o usuário tem à disposição um ambiente de trabalho composto por menus, ícones, janelas e outros itens. O usuário interage com esse tipo de interface usando o mouse, podendo também usar o teclado e teclas de atalho. É possível fazer todo tipo de tarefa usando interface gráfica, como edição de vídeos e imagens, sendo somente alguns tipos muito específicos de tarefas que se saem melhor em linha de comando. Acrescentar facilidade de uso e agilidade é o objetivo da GUI, tendo a desvantagem de consumir muito mais memória que interfaces de linha de comando. Em sistemas unix-likes, existe a possibilidade de escolher o gerenciador de janelas a utilizar, aumentando em muito a liberdade de escolha do ambiente.TUI (Text user interface)
CUI (Command-line user interface)
Além da interface gráfica, existe a interface de linha de comando, que funciona basicamente com a digitação de comandos, sendo nesse relativamente pouco interativa. Os comandos digitados são interpretados por um interpretador de comandos, conhecidos também por shells, bastante comuns em sistemas unix-likes. Um exemplo de interpretador de comandos seria o Bash. Usada geralmente por usuários avançados e em atividades específicas, como gerenciamento remoto, utiliza poucos recursos de hardware em comparação a interface gráfica. Nesse tipo de ambiente, raramente se usa o mouse, embora seja possível através do uso da biblioteca ncurses no desenvolvimento dos softwares.Classificações
- Núcleo monolítico ou monobloco: o núcleo consiste em um único processo executando numa memória protegida (espaço de núcleo) executando as principais funções. Ex.: MAC OS X, OS/2, Windows, Linux, FreeBSD.
- Micronúcleo ou modelo cliente-servidor: o núcleo consiste de funções mínimas (comunicação e gerenciamento de processos), e outras funções, como sistemas de arquivos e gerenciamento de memória, são executadas no espaço do usuário como serviços; as aplicações (programas) são os clientes. Ex.: GNU Hurd, Mach.
- Sistema em camadas: funções do núcleo irão executar em camadas distintas, de acordo com seu nível de privilégio. Ex.: Multics.
- Monitor de máquinas virtuais: fornece uma abstração do hardware para vários sistemas operacionais. Ex.: VM/370, VMware, Xen.
- Monotarefa: pode-se executar apenas um processo de cada vez Ex.: MS-DOS.
- Multitarefa: além do próprio SO, vários processos de utilizador (tarefas) estão carregados em memória, sendo que um pode estar ocupando o processador e outros ficam enfileirados, aguardando a sua vez. O compartilhamento de tempo no processador é feito de modo que o usuário tenha a impressão que vários processos estão sendo executados simultaneamente. Cada processo recebe um tempo para ser executado. Ao final desse tempo, outro processo é executado. Essa alternância de processos chama-se concorrência.
- Multitarefa cooperativa: Executa dois ou mais programas em simultâneo mas o programa que está em primeiro plano tem controlo sobre o processador. Neste caso se este programa falhar bloqueia o computador e tem que ser reiniciado. Exempo de SO: Windows 3.x e versões anteriores ao Mac OS 8.
- Multitarefa preempetiva: É o processador que controla a execução dos programas, desta forma permite ao sistema operativo recuperar o controlo caso um programa bloqueie. O utilizador perde os trabalhos do programa que falhou mas os restantes programas continuam a trabalhar. Exemplo de SO: Unix; Linux; Windows 95 e superiores; MAC OS 8 e superiores; etc.
- Elemento de lista com marcas:
- Multiprocessamento: o SO distribui as tarefas entre dois ou mais processadores. Se os processadores estivem na mesma máquina fisica, o sistema é chamado de Sistema Multiprocessado Fortemente Acoplado. Caso esteja em máquinas diferentes, trata-se de um Sistema Multiprocessado Fracamente Acoplado.
- Monousuário: apenas um usuário por vez (apesar de poder suportar recursos como troca de usuário). Ex.: Windows. Esse também pode ser acessado por terminais e conexão remota.
- Multiusuário: vários usuários usam o computador ao mesmo tempo, seja por diversos terminais, seja por conexão remota como o SSH. Ex.: Linux, Unix.
Exemplos de sistemas operacionais ativos
Para desktop
Para dispositivos móveis (tablets e smartphones)
Unix foi o primeiro sistema operacional moderno
Visando o problema da incompatibilidade de SOs de máquinas distintas, um grupo de desenvolvedores da AT&T criaram o Unix em 1969, sendo o primeiro sistema operacional moderno da computação.Sua primeira versão foi escrita em linguagem Assembly, sendo posteriormente reescrita em C no ano de 1973, linguagem que é utilizada até os dias de hoje. Este sistema introduziu conceitos muito importantes para a computação: portabilidade, multi-usuário, multi-tarefas e compartilhamento de tarefas.
Durante a década de 70, o Unix foi distribuído gratuitamente (incluindo seu código fonte) para universidades e órgãos governamentais norte-americanos, o que conferiu muita popularidade a este sistema. Sua interface era totalmente em modo texto sem interface gráfica.
Em 1977 foi lançado o BSD, sistema operacional fortemente baseado no Unix, focado principalmente para a execução em máquinas específicas de alto desempenho, como o famoso computador VAX, o qual foi uma referência de hardware na época.
Atualmente, a grande maioria dos sistemas operacionais são baseados no Unix, tanto em desktops quanto em servidores e em dispositivos móveis, sendo o Windows - líder absoluto no mercado de desktops - a mais notável exceção.
Exemplos de sistemas operacionais importantes que foram descontinuados
Ass: Carlos Monteiro
Equipe: <U.S.I>
Em computação, o núcleo ou cerne (em inglês: kernel) é o componente central do sistema operativo da maioria dos computadores; ele serve de ponte entre aplicativos e o processamento real de dados feito a nível de hardware. As responsabilidades do núcleo incluem gerenciar os recursos do sistema (a comunicação entre componentes de hardware e software). Geralmente como um componente básico do sistema operativo, um núcleo pode oferecer acamada de abstração de nível mais baixo para os recursos (especialmente processadores e dispositivos de entrada/saída) que softwares aplicativos devem controlar para realizar sua função. Ele tipicamente torna estas facilidades disponíveis para os processos de aplicativos através de mecanismos de comunicação entre processos e chamadas de sistema.
Tarefas de sistemas operativos são feitas de maneiras diferentes por núcleos diferentes, dependendo do seu desenho e abordagem. Enquanto núcleos monolíticos tentarão alcançar seus objetivos executando todos códigos de sistema no mesmo espaço de endereçamento para aumentar a performance do sistema, micronúcleos executam a maioria dos serviços do sistema no espaço de usuário como servidores, buscando melhorar a manutenção e a modularidade do sistema operativo. Uma gama de possibilidades existem entre estes extremos
 |
| |
Kernel
Um núcleo de sistema conecta o software aplicativo ao hardware de um computador.
Em computação, o núcleo ou cerne (em inglês: kernel) é o componente central do sistema operativo da maioria dos computadores; ele serve de ponte entre aplicativos e o processamento real de dados feito a nível de hardware. As responsabilidades do núcleo incluem gerenciar os recursos do sistema (a comunicação entre componentes de hardware e software).[Geralmente como um componente básico do sistema operativo, um núcleo pode oferecer acamada de abstração de nível mais baixo para os recursos (especialmente processadores e dispositivos de entrada/saída) que softwares aplicativos devem controlar para realizar sua função. Ele tipicamente torna estas facilidades disponíveis para os processos de aplicativos através de mecanismos de comunicação entre processos e chamadas de sistema.
Tarefas de sistemas operativos são feitas de maneiras diferentes por núcleos diferentes, dependendo do seu desenho e abordagem. Enquanto núcleos monolíticos tentarão alcançar seus objetivos executando todos códigos de sistema no mesmo espaço de endereçamento para aumentar a performance do sistema, micronúcleos executam a maioria dos serviços do sistema no espaço de usuário como servidores, buscando melhorar a manutenção e a modularidade do sistema operativo. Uma gama de possibilidades existem entre estes extremos.
Visão geral
Uma visão típica de uma arquitetura de computadores como séries de camadas de abstração: hardware,firmware, montador, núcleo, sistema operativo e aplicativos (veja tambémOrganização Estruturada de Computadores, por Andrew S. Tanenbaum.).
Na definição do 'núcleo', Jochen Liedtke disse que a palavra é "tradicionalmente usada para definir a parte do sistema operativo que é obrigatória e comum a todo software no sistema.
A maioria dos sistemas operativos depende do conceito de núcleo. A existência de um núcleo é uma consequência natural de projetar um sistema de computador como séries de camadas de abstração,cada uma das funções dependendo das funções das camadas abaixo de si. O núcleo deste ponto de vista, é simplesmente o nome dado ao nível mais inferior de abstração que é implementado em software. Para evitar ter um núcleo, teria-se que projetar todo o software no sistema de modo a não utilizar abstração alguma; isto iria aumentar a complexidade e o projeto a tal ponto que apenas os sistemas mais simples seriam capazes de ser implementados.
Enquanto isto hoje é chamado núcleo, originalmente a mesma parte do sistema também foi chamado o nucleus ou caroço (Nota, no entanto, este termo caroço também foi usado para se referir a memória primordial de um sistema de computador, por que alguns dos primeiros computadores usaram uma forma de memória chamada memória de caroços magnéticos), e foi concebido originalmente como contendo apenas os recursos de suporte essenciais do sistema operativo.
Na grande maioria dos casos, o processo de iniciação começa executando o núcleo no modo supervisor.O núcleo depois inicializa a si e depois o primeiro processo. Depois disto, tipicamente, o núcleo não executa diretamente, apenas em resposta para eventos externos (ex., através de chamadas de sistema usados pelos aplicativos para requisitar serviços do núcleo, ou via interrupções usadas pelo hardware para notificar o núcleo sobre eventos). Além disso, tipicamente o núcleo fornece um laço que é executado sempre que nenhum processo esta disponível para execução; geralmente chamado de processo desocupado.
O desenvolvimento do núcleo é considerado uma das mais complexas e difíceis tarefas em programação.Sua posição central em um sistema operativo implica a necessidade de bom desempenho, que define o núcleo como peça de software crítica e torna seu desenvolvimento correto e implementação correta difícil. Devido a diversas razões, o núcleo pode até não ser capaz de utilizar mecanismos de abstração, que ele fornece a outro software. Tais razões incluem preocupações com o gerenciamento de memória (ex. uma função em modo de usuário pode depender de memória estando sujeita a paginação por demanda, mas como o próprio núcleo fornece esta facilidade, ele não pode utilizá-la, pois ele pode não permanecer na memória para fornecer esta facilidade) e a falta de reentrância, logo o seu desenvolvimento torna-se ainda mais difícil para engenheiros de software.
Geralmente um núcleo vai fornecer recursos para escalonamento de processos de baixo nível. comunicação entre processos, sincronização de processos, troca de contexto, manipulação de blocos de controle de processo, gerenciamento de interrupções, criação e destruição de processos, e suspensão e continuação de processos (veja estados de processos).
Finalidades básicas do núcleo
O principal propósito do núcleo é gerenciar os recursos do computador e permitir que outros programas rodem e usem destes recursos.] Tipicamente estes recursos consistem de:
- A unidade de processamento central (CPU, o processador). Esta é a parte mais central de um sistema de computação, responsável por rodar ou executar programas nele. O núcleo têm a responsabilidade de decidir em qualquer momento qual dos programas em execução deve ser alocado para o processador ou processadores (cada um dos quais geralmente pode executar um programa por vez)
- A memória. A memória é usada para armazenar ambos instruções do programa e dados. Tipicamente, ambos precisam estar presentes na memória de modo a tornar a execução do programa possível. Frequentemente múltiplos programas buscarão acesso à memória ao mesmo tempo, na maioria das vezes exigindo mais memória do que o computador pode disponibilizar. O núcleo é responsável pela decisão de que memória cada processo pode utilizar, e determinar o que fazer quando menos do suficiente está disponível.
- Qualquer dispositivo de entrada/saída presente no computador, tais como teclado, rato, entradas de disquete, impressoras, telas, etc. O núcleo aloca pedidos de aplicativos para realizar entrada/saída para um dispositivo apropriado (ou subseção de um dispositivo, no caso de arquivos em um disco ou janelas em uma tela) e fornece métodos convenientes para o uso do dispositivo (tipicamente abstraído ao ponto onde o aplicativo não precisa mais conhecer os detalhes da implementação do dispositivo).
Aspectos importantes no gerenciamento de recursos são a definição de um domínio de execução (espaço de endereçamento) e o mecanismo de proteção utilizado para mediar o acesso a recursos dentro de um domínio.
Núcleos geralmente não oferecem métodos para sincronização e comunicação entre processos (IPC (em inglês)).
Um núcleo pode implementar estes recursos ele mesmo, ou depender de alguns processos que ele executa para fornecer estas facilidades a outros processos, no entanto neste caso ele deve oferecer algum modo do IPC permitir que processos acessem as facilidades fornecidas um pelo outro.
Finalmente, um núcleo deve oferecer um método de acesso a estas facilidades para os programas em execução.
Gerenciamento de Processos
A principal tarefa de um núcleo é permitir a execução de aplicativos e ajudá-los com recursos como abstrações de hardware. Um processo define que porções da memória o aplicativo pode acessar.(Para esta introdução, processo, aplicativo e programa são usados como sinônimos.) O gerenciamento de processos do núcleo deve levar em conta o equipamento de hardware embarcado para proteção de memória.
Para rodar um aplicativo, um núcleo geralmente cria um espaço de endereçamento para o aplicativo, carrega o arquivo contendo de instruções do programa na memória (talvez via paginação por demanda), cria uma pilha para o programa e ramos para uma dada localização dentro do programa, iniciando, portanto a sua execução.
Núcleos multitarefa são capazes de dar ao usuário a ilusão de que um número de processos que esta rodando simultaneamente no sistema é maior do que o número de processos que aquele sistema é fisicamente capaz de rodar simultaneamente. Usualmente, o número de processos que um sistema pode rodar simultaneamente é igual o número de CPUs que ele possui instaladas (no entanto, isto pode não ser o caso de processadores que suportam múltiplas linhas de execução simultâneas).
Em um sistema multitarefas preemptivo, o núcleo dará a todos programas uma parcela do tempo e vai alternar de processo a processo tão rapidamente que dará ao usuário a impressão de como se os processos estivessem sendo executados simultaneamente. O núcleo utiliza algoritmos de escalonamento para determinar qual processo será executado a seguir e quanto tempo lhe será dado. O algoritmo escolhido pode permitir que alguns processos tenham uma prioridade mais alta que muitos outros. O núcleo geralmente também provê a esses processos uma maneira de comunicarem-se; isto é chamado comunicação entre processos (IPC (em inglês)) e as principais implementações são memória compartilhada, troca de mensagens e chamadas de procedimento remoto (veja computação concorrente).
Outros sistemas (particularmente em computadores menores, menos potentes) podem fornecer multitarefa de cooperação, em que cada processo é permitido rodar sem ininterruptamente até que ele faça uma requisição especial que avisa ao núcleo que ele pode alternar para outro processo. Tais requisições são conhecidos como "indulgências" (yielding(em inglês), e tipicamente ocorrem em resposta a um pedido para comunicação entre processos, ou para esperar até o acontecimento de um evento. Versões mais antigas de ambos Microsoft Windows e Mac OSutilizaram o conceito de multitarefa cooperativa, mas alternaram para esquemas preemptivos conforme a potência dos computadores alvo de seu mercado aumentava
O sistema operativo pode também suportar o multiprocessamento (multiprocessamento simétrico (SMP (em inglês)), ou, acesso não-uniforme a memória); neste caso, diferentes programas e linhas de execução podem rodar em diferentes processadores. Um núcleo para tal sistema deve ser projetado para ser reentrante, o que significa que ele pode rodar seguramente duas partes de seu código simultaneamente. Isto tipicamente significa oferecer mecanismos de sincronização (como trava-giros) para assegurar que dois processadores não tentarão modificar os mesmos dados ao mesmo tempo.
Gerenciamento de Memória
O núcleo possui acesso completo a memória do sistema e deve permitir que processos acessem a memória com segurança conforme a sua necessidade. Frequentemente o primeiro passo para isso é o endereçamento virtual, geralmente alcançado através da paginação e/ou segmentação. Endereçamento virtual permite ao núcleo fazer com que um dado endereço físico pareça ser outro endereço, o endereço virtual. Espaços de endereço virtual podem ser diferentes para diferentes processos; a memória que um processos acessa em um endereço (virtual) particular pode ser diferente da que um outro processo acessa pelo mesmo endereço. Isto permite a todos programas funcionar como se ele fosse o único em execução, além do núcleo, e por isso evita que aplicativos travem uns aos outros.
Em vários sistemas, o endereço virtual de um programa pode se referir a dados que não estão na memória atualmente. A cama de indireção oferecida pelo endereçamento virtual permite que o sistema utilize meios de armazenagem de dados, como um disco rígido, para armazenar o que de outro modo teria que permanecer na memória (RAM(em inglês)). Como resultado. sistemas operativos podem permitir que programas usem mais memória do que está fisicamente disponível. Quando um programa precisa de dados que não estão na RAM, a CPU avisa o núcleo que isto ocorre, e o núcleo responde escrevendo o conteúdo de um bloco de memória inativo para o disco (se necessário), e substituindo-o na memória com os dados requisitados pelo programa. O programa pode então continuar sua execução do ponto em que foi suspenso. Este esquema é geralmente conhecido como paginação por demanda.
Endereçamento virtual também permite a criação de partições virtuais de memória em duas áreas separadas, uma sedo reservada para o núcleo (espaço de núcleo) e o outro para os aplicativos (espaço de usuário). Os aplicativos não tem permissão do processador para acessar a memória do núcleo, portanto prevenindo que um aplicativo possa danificar o núcleo em execução. Esta partição fundamental de espaço de memória contribuiu muito para os projetos de núcleos realmente de propósito geral e é quase universal em tais sistemas, embora algumas núcleos de pesquisa (ex. Singularity) usarem outros métodos.
Gerenciamento de dispositivos
Para realizar funções úteis, processos precisam acessar periféricos conectados ao computador, que são controlados pelo núcleo através do driver do dispositivo. Por exemplo, para mostrar ao usuário algo utilizando a tela, um aplicativo teria que fazer um requisição ao núcleo que encaminharia a requisição para o seu driver de tela, que é responsável por realmente tracejar os carácteres/pixeis.
Um núcleo deve manter uma lista de dispositivos disponíveis. Esta lista pode ser conhecida de antemão (ex. em um sistema embarcado onde o núcleo será reescrito se o hardware disponível mudar), configurado pelo usuário (típico em computadores pessoais antigos e em sistemas projetados para uso pessoal) ou detectado pelo sistema durante a execução (normalmente chamadoLigar e Usar).
Em um sistema "Ligar e Usar", um dispositivo realizar primeiro uma sondagem em nos diferentes barramentos de hardware, como Interconector de Componentes Periféricos (PCI(em inglês)) ouBarramento Serial Universal (USB(em inglês)), para detectar os dispositivos instalados, depois busca os drivers apropriados.
Como o gerenciamento de dispositivos é um tópico muito especifico do SO, estes drivers são manipulados de modos diferentes por cada tipo de desenho de núcleo, mas em todos os casos, o núcleo tem que fornecer a entrada/saída para permitir que os drivers acessem fisicamente seus dispositivos através alguma porta ou localização da memória. Decisões muito importantes precisam ser feitas ao projetar o sistema de gerenciamento de dispositivos, já que em alguns projetos de acesso podem envolver trocas de contexto , tornando a operação custosa para o processador e causando um gasto excessivo de recursos.
Chamadas do Sistema
Para realmente realizar algo útil, um processo deve acessar os serviços oferecidos pelo núcleo. Isto é implementado por cada núcleo, mas a maioria oferece uma Biblioteca padrão do C ou uma Interface de programação de aplicativos, que envolve as funções relativas ao núcleo.
O método de invocar as funções do núcleo varia de núcleo para núcleo. Se o isolamento de memória está sendo usado, é impossível para um processo de usuário chamar o núcleo diretamente, por que isso seria uma violação das regras de controle de acesso do processador. Algumas possibilidades são:
- Usar uma interrupção de software simulada. Este método está disponível na maioria dos hardwares, e é, portanto, muito comum.
- Usando um portão de chamada. Um portão de chamada é um endereço especial armazenado pelo núcleo em uma lista na memória do núcleo em uma localização conhecida pelo processador. Quando o processador detecta uma chamada para este endereço, ele ao invés disso redireciona para a localização alvo sem causar nenhuma violação de acesso. Exige suporte no hardware, mas este tipo de hardware é muito comum.
- Usando uma instrução de chamada de sistema especial. Esta técnica exige suporte especial no hardware, que em algumas arquiteturas habituais não possuem (notavelmente, x86). Instruções de chamadas de sistema foram adicionadas a modelos recentes do processadores x86, embora, poucos (mas não todos) sistemas operativos fazem uso destes quando disponíveis.
- Usando uma fila baseada na memória. Um aplicativo que faz um grande número de requisições mas não precisa esperar o resultado de cada uma pode adicionar detalhes das requisições em uma área da memória que o núcleo sonda periodicamente para encontrar requisições.
Decisões de desenho do Núcleo
Problemas com o suporte do núcleo para proteção
Uma consideração importante no desenho do núcleo é o suporte que ele oferece para proteção contra faltas (tolerância a falhas) e de comportamentos # mal-intencionados (segurança). Estes dois aspectos geralmente não são claramente distinguidos, e a separação no desenho do núcleo leva a rejeição de uma estrutura hierárquica de proteção.
Os mecanismos ou políticas oferecidos pelo núcleo podem ser classificados de acordo com vários critérios, como: estático (forçado durante o tempo de compilação) ou dinâmico (forçado durante o tempo de execução); preemptivo ou pós-detecção; de acordo com os princípios de proteção a que eles correspondem (ex. Denning); quer eles sejam suportados pelo hardware ou baseados em linguagem; quer eles sejam mais um mecanismo aberto ou ma política compulsiva; e muito mais.
Tolerância a falhas
Uma medida útil para o nível de tolerância a falhas de um sistema é quão estrito ele é com relação ao princípio do menor privilégio. Em casos onde múltiplos programas estão rodando em um único computador, é importante prevenir falhas em um dos programas de afetar negativamente outro. Estendendo-se ao desenho com más-intenções mais do que a falha em si, isto também implica a segurança, quando é necessário impedir processos de acessar informações sem que lhes seja dada a devida permissão.
As duas principais implementações via hardware para proteção (de informações sensíveis) são domínios hierárquicos de proteção (também chamadas arquiteturas anel, arquiteturas de segmento ou modo supervisor),e endereçamento baseado em capacidades.
anéis de privilégio, como na x86, são uma abordagem habitual de domínios hierárquicos de proteção usados em muitos sistemas comerciais para obter algum nível de tolerância a falhas.
Domínios hierárquicos de proteção são muito menos flexíveis, como no caso de qualquer núcleo com uma estrutura hierárquica presumida como um critério de desenvolvimento global. No caso de proteção não é possível designar diferentes privilégios a processos que não estão no mesmo nível de privilégio, e por isso não é possível corresponder aos quatro princípios de Denning para a tolerância a falhas,particularmente o princípio do menor privilégio. Domínios hierárquicos de proteção também carregam uma enorme desvantagem na performance, já que a interação entre diferentes níveis de proteção, quando um processos tem que manipular uma estrutura de dados em ambos 'modo usuário' e 'modo supervisor', sempre exige cópia de mensagens (transmissão por valor).Um núcleo baseado em capacidades, no entanto, é mais flexível em designar privilégios, pode corresponder aos princípios de Denning para a tolerância a falhas, e geralmente não sofrem de problemas de performance da cópia por valor.
Ambas implementações tipicamente exigem algum suporte de hardware ou firmware para serem operáveis e eficientes. O suporte de hardware para domínios hierárquicos de proteção geralmente é de "modos de CPU." Um modo simples e eficiente de fornecer suporte a hardware é delegar à unidade de gerenciamento de memória a responsabilidade por checar as permissões de acesso para todos acessos a memória, um mecanismo chamado endereçamento baseado em capacidades. Falta na maioria das arquiteturas comerciais, o suporte a MMU para capacidades.
Uma abordagem alternativa é simular capacidades usando domínios hierárquicos comumente suportados; nesta abordagem, cada objeto protegido deve residir num espaço de endereçamento ao qual o aplicativo não possui acesso; o núcleo também mantém uma lista de capacidades em tal memória. Quando um aplicativo precisa acessar um objeto protegido por uma capacidade, ele realiza uma chamada de sistema e o núcleo realiza o acesso a ele. O custo de performance de trocar de espaço de endereçamento limita a praticabilidade desta abordagem em sistemas com interações complexas entre objetos, mas é utilizado nos sistemas operativos atuais para objetos que não são acessados frequentemente ou que não devem ser feitos rapidamente.Implementações onde os mecanismos de proteção não suportados pelo firmware, mas são, ao invés disso, simulados em níveos mais altos (ex. simulando capacidades ao manipular tabelas de páginas em hardware que não possui suporte direto), são possíveis, mas há implicações de performance.No entanto, falta de suporte no hardware pode não ser problema, para sistemas que escolhem usar uma proteção baseada em linguagem.
Uma decisão importante no projeto do núcleo é a escolha dos níveis de abstração em que os mecanismos e políticas de segurança devem ser implementados. Os mecanismos de segurança do núcleo têm um papel crítico no suporte a segurança nos níveis superiores.
Uma abordagem é utilizar suporte no núcleo e firmware para tolerância a falhas (ver acima), e montar as políticas de segurança para comportamento malicioso em cima disso (adicionando recursos como mecanismos de criptografia quando necessário), delegar mais responsabilidade para o compilador. Implementações que delegam a aplicação de políticas de segurança para o compilador e/ou nível do aplicativo são geralmente chamados segurança baseada em linguagem.
A falta de muitos mecanismos críticos de segurança nos principais sistemas operativos impede a implementação adequada de políticas de segurança no nível de abstração do aplicativo.[28] Na verdade, um engano muito comum na segurança de computadores é que qualquer política de segurança pode ser implementada no aplicativo, independentemente do suporte no núcleo.[28]
Proteção baseada em hardware ou linguagem
Hoje, típicos sistemas de computação usam regras aplicadas pelo hardware sobre quais programas têm permissão para acessar quais dados. O processador monitora a execução e desliga um programa que viole uma regra (ex., um processo de usuário que tenta ler ou escrever na memória do núcleo, e assim por diante). Em sistemas que não possuem suporte para capacidades, processos são isolados um do outro, utilizando-se espaços de endereçamento separados.[32] Chamadas de um processo de usuário no núcleo são regidas pela exigência de que eles usem um dos métodos de chamada do sistema descritos acima.
Uma abordagem alternativa é usar proteção baseada em linguagem. Em um sistema de proteção baseado em linguagem, o núcleo vai permitir a execução apenas de código produzido por umcompilador em que ele confie. A linguagem pode então, ser projetada de modo tal que será impossível para o programador instruir algo que violaria os requisitos de segurança.[27]
Desvantagens incluem:
- Demora maior para a inicialização efetiva do aplicativo. Aplicativos deve ser verificadas sempre que elas são iniciadas para garantir que eles foram compiladas utilizando um compilador "corret", ou podem necessitar de recompilação de ambos código fonte ou bytecode.
- Sistema s de tipo inflexível. Em sistemas tradicionais, aplicativos realizam frequentemente operações que não são de tipagem forte. Tais operações não podem ser permitidas em um sistema de proteção baseado em linguagem, o que significa que aplicativos podem precisar ser reescritos e podem, em alguns casos, perder performance.
Vantagens desta abordagem incluem:
- Separação de espaços de endereçamento desnecessária. A troca de espaços de endereçamento é uma operação lenta que causa grande degradação na performance, e muito trabalho de otimização é feito atualmente para prevenir trocar desnecessárias nos sistemas operativos. Trocar é complemente desnecessário em um sistema de proteção baseada em linguagem, já que todo código opera no mesmo espaço de endereçamento.
- Flexibilidade. Qualquer esquema de proteção que possa ser desenvolvida para ser expresso através de linguagem de programação pode ser implementada através deste método. Mudanças no esquema de proteção (ex. de um sistema hierárquico para um baseado em capacidades) não exigem novo hardware.
Exemplos de sistemas com proteção baseada em linguagem incluem o JX e Singularity.
Cooperação de processos
Edsger Dijkstra provou que partindo de um ponto de vista lógico, operações atômicas de travamento e destravamento operando em semáforos binários são suficientemente primitivos para expressar a qualquer funcionalidade de cooperação entre processos.[33] No entanto esta abordagem é geralmente tomada como deficiente em termos de segurança e eficiência, enquanto que uma abordagem via troca de mensagens é mais flexível.[7]
Gerenciamento de dispositivos de entrada/saída
A ideia de um núcleo onde dispositivos de entrada/saída são gerenciados uniformemente com outros processos, como processos paralelos em cooperação, foi proposta e implementada primeiramente por Brinch Hansen (embora ideias similares tenham sido sugeridas em 1967[34][35]). Na descrição de Hansen disto, os processos "comuns" são chamados processos internos, enquanto que os dispositivos de entrada/saída são chamados processos externos.[7]
Abordagens de desenvolvimento de todo o núcleo
Naturalmente, as tarefas e recursos listados acima podem ser fornecidas de vários modos que diferem entre si em projeto e implementação.
O princípio da separação entre o mecanismo e a política é a diferença substancial entre a filosofia de micronúcleo e núcleo monolítico.[36][37] Aqui um mecanismo é o apoio que permite a implementação de várias políticas diferentes, enquanto uma política é um "modo de operação" particular. Por exemplo, uma mecanismo pode oferecer às tentativas de entrada de um usuário um método de chamar um servidor de autorização para determinar se um acesso deve ser dado; uma política pode ser para o servidor de autorização exigir uma senha e checá-la contra uma senha embaralhada armazenada numa base de dados. Devido ao fato do mecanismo ser genérico, a política pode ser alterada com mais facilidade (ex. ao exigir o uso de um passe) do que se um mecanismo e política fossem integrados no mesmo módulo.
Em um micronúcleo mínimo algumas políticas básicas são incluídas,[37] e seus mecanismos permite que o que está rodando sobre o núcleo (a parte remanescente do sistema operativo e outras aplicações) decida quais políticas adotar (como gerenciamento de memória, escalonamento de processo de alto nível, gerenciamento de sistema de arquivos, etc.).[1][7] Um núcleo monolítico ao invés disso, tende a incluir várias políticas, então restringindo o resto do sistema dependente delas.
Per Brinch Hansen apresentou um argumento convincente a favor da separação do mecanismo e da política.[1][7] A falha em preencher completamente esta separação, é uma das maiores causas para a falta de inovação nos sistemas operativos existentes atualmente,[1] um problema comum nas arquiteturas de computador.[38][39][40] O projeto monolítico é induzido pela abordagem de arquitetura "modo núcleo"/"modo usuário" para proteção (tecnicamente chamada de domínios hierárquicos de proteção), que é comum em sistemas comercias convencionais;[41]na verdade, todo módulo que necessite de proteção é portanto preferivelmente incluído no núcleo.[41] Esta ligação entre projeto e "modo privilegiado" pode ser reconduzida até o problema chave da separação do mecanismo e da política;[1] de fato, a abordagem de arquitetura de "modo privilegiado" se funde ao mecanismo de proteção com as políticas de segurança, enquanto a principal abordagem de arquitetura alternativa , endereçamento baseado em capacidades, claramente distingue ambos, levando naturalmente ao desenvolvimento de um micronúcleo design[1](veja Separação entre proteção e segurança).
Enquanto núcleos monolíticos executam todo seu código no mesmo espaço de endereçamento (espaço de núcleo) micronúcleos tentam executar a maior parte dos seus serviços no espaço de usuário, buscando aprimorar a manutenção e modulabilidade do código base.[2] A maioria dos núcleos não se encaixa exatamente em uma destas categorias, sendo mais encontrados entre estes dois projetos. Os chamados núcleos híbridos. Projetos mais exóticos como nanonúcleos e exonúcleos estão disponíveis, mas são usados raramente utilizado para sistemas produtivos. O virtualizador Xen, por exemplo, é um exonúcleo.
Diagrama de núcleos monolíticos.
Núcleos monolítico
Em um núcleo monolítico, todos os serviços do sistema operativo rodam junto com a linha de execução principal do núcleo, portanto, também se encontram na mesma área de memória. Esta abordagem permite o acesso vasto e poderoso de hardwares. Alguns desenvolvedores, como desenvolvedor do UNIX Ken Thompson, defendem que é "mais fácil de implementar um núcleo monolítico"[42] que micronúcleos. As principais desvantagens de núcleos monolíticos são as dependências entre os componentes do sistema - um defeito em um driver de dispositivo pode paralisar todo o sistema - e o fato de núcleos grandes podem se tornar muito difíceis de manter.
Na abordagem do micronúcleo, o próprio núcleo fornece apenas funcionalidades básicas que permite a execução de servidores, programas separados que assumem funções que seriam do núcleo monolítico, como drivers de dispositivos, servidores de interface de usuário, etc.
- MS-DOS e derivados, incluindo Windows 95, Windows 98 e Windows ME
Diagrama de interação de um micronúcleo.
Micronúcleos
Ver artigos principais: Micronúcleo (informática) e Micronúcleo
A abordagem de micronúcleo consiste em definir abstrações simples sobre o hardware, com um conjunto de primitivos ou chamadas de sistema para implementar serviços mínimos do sistema operativo como gerenciamento de memória, multitarefas, e comunicação entre processos. Outros serviços, incluindo aqueles normalmente fornecidos por um núcleo monolítico como rede, são implementados em programas de espaço de usuário, conhecidos como servidores. Micronúcleos são mais fáceis de manter do núcleos monolíticos, mas um grande número de chamadas de sistemas de trocas de contexto podem desacelerar o sistema por que eles geralmente geram mais degradação na performance do que simples chamadas de função.
Um micronúcleo permite a implementação das partes restantes do sistema operativo como aplicativos normais escritos em linguagem de alto nível, e o uso de diferentes sistemas operativos sobre o mesmo núcleo não-modificado.[7] Ele também torna possível alternar dinamicamente entre sistemas operativos e manter mais de um deles ativos simultaneamente.[7]
Núcleos monolíticos x micronúcleos
Conforme o núcleo do computador crescem, um número de problemas se tornam evidentes. Um dos mais óbvios é que o espaço de memóriaaumenta. Isto é mitigado de certo modo ao aperfeiçoar o sistema de memória virtual, mas nem todas arquitetura de computador suportam memórias virtuais.[43] Para reduzir o espaço utilizado pelo núcleo, modificações extensivas precisam ser realizadas para remover cuidadosamente código inútil, que pode ser muito difícil devido a dependências pouco aparentes entre partes de um núcleo com milhões de linhas de código.
Pelo começo dos anos 1990, devido a vários problemas de núcleos monolíticos em comparação a micronúcleos, núcleos monolíticos foram considerados obsoletos por virtualmente todos pesquisadores de sistemas operativos. Como resultado, o projeto do Linux, um núcleo monolítico mais do que um micronúcleo foi o tópico da famosa discussão inflamada entre Linus Torvalds e Andrew Tanenbaum.[44] Há méritos em ambos argumentos presentes no debate Tanenbaum–Torvalds.
Performances
Núcleos monolíticos são projetados para que todo o seu código fique no mesmo espaço de endereçamento (espaço de núcleo), que alguns desenvolvedores argumentam ser necessário para aumentar a performance do sistema.[45] Alguns desenvolvedores também sustentam a hipótese de que núcleos monolíticos são extremamente eficientes se forem bem escritos.[45][fonte fiável?]
A performance de micronúcleos construídos nos anos 1980 e começos dos 1990 era terrível.[3][46] Estudos empíricos que mediram a performance destes micronúcleos não analisaram os motivos para tal ineficiência .[3] As explicações para estes dados foram deixadas para o "folclore"[necessário esclarecer], com a suposição de que eles eram devido ao aumento da frequência da troca de modo núcleo para modo usuário,[3] devido a maior frequência de comunicação entre processos[3] e a maioria frequência de trocas de contexto.[3]
De fato, como foi conjeturado em 1995, os motivos para a terrível performance dos micronúcleos pode também ter sido: (1) uma real ineficiência na implementação de toda a abordagem de micronúcleo, (2) conceitos particulares implementados nesses micronúcleos, e (3) a implementação individual destes conceitos.[3] Portanto ainda falta estudar se a solução para construir um micronúcleo eficiente foi, ao contrário de tentativas anteriores, a de aplicar as técnicas corretas de construção.[3]
No outro extremo, a arquitetura de domínios hierárquicos de proteção que leva a um projeto de núcleo monolítico[41] gera impactos significativos na performance cada vez que há uma interação entre diferentes níveis de proteção (ex. quando um processo tem que manipular uma estrutura de dados em ambos 'modo usuário' e 'modo supervisor'), desde que isto exija cópia de mensagempor valor.[21]
Em meados de 1990, a maioria dos pesquisadores abandonou a crença de que ajustes cuidadosos poderiam reduzir estes impactos dramaticamente,[carece de fontes] mas recentemente, novos micronúcleos, otimizados para performance, tais como os L4[47] e K42 vêm trabalhando nestes problemas.[necessário verificar]
A abordagem de núcleo híbrido combina velocidade e projetos mais simples de um núcleo monolítico com a modularidade e execução segura de um micronúcleo.
Núcleos híbridos
- Ver artigo principal: Núcleo híbrido
Núcleos híbridos são um acordo entre o desenvolvimento de micronúcleos e núcleos monolíticos. Isto implica executar alguns serviços (como a pilha de rede ou o sistema de arquivos) no espaço do núcleo para reduzir o impacto na performance[carece de fontes] de um micronúcleo tradicional, mas ainda executar o código no núcleo (como drivers de dispositivos) como servidores no espaço de usuário.
Nanonúcleos
- Ver artigo principal: Nanonúcleo
Um nanonúcleo delega virtualmente todos os serviços — incluindo até os mais básicos como controlador de interrupções ou o temporizador — para drivers de dispositivo para tornar o requerimento de memória do núcleo ainda menor do que o dos tradicionais micronúcleos.[48]
Diagrama de interação de um exonúcleo.
Exonúcleos
- Ver artigo principal: Exonúcleo
Um exonúcleo é um tipo de núcleo que não abstrai hardware in modelos teóricos. Ao invés disso ele aloca recursos físicos de hardware, como o tempo de um processador, páginas de memória, e blocos de disco, para diferentes programas. Um programa rodando em um exonúcleo pode ligar para uma biblioteca do sistema operativo que usa o exonúcleo para simular as astrações de um sistema operativo conhecido, ou ele pode desenvolver abstrações específicas para aquele aplicativo para ume performance superior.[49]
História do desenvolvimento do núcleo
Núcleos dos primeiros sistemas operativos
- Ver artigo principal: História dos sitemas operacionais
Falando estritamente, um sistema operativo (e, isto inclui um núcleo) não é obrigado a rodar um computador. Programas podem ser carregados diretamente e executados na máquina de "metal descoberto", desde que os autores destes programas estiverem dispostos a trabalhar sem nenuma abstração de hardware ou suporte a sistema operativo. Os primeiros computadores operaram deste maneira durante os anos de 1950, começo dos 1960, eram reiniciados e recarregados entre cada execução de diferentes programas. Eventualmente, pequenos programas auxiliares comocarregadores de programas e depuradores foram mantidos na memória entre as execuções, ou carregados de memória somente de leitura . Conforme estas eram desenvolvidas, elas formaram a base do que depois se tornaria o núcleo dos sistemas operativos. A abordagem de "metal descoberto" ainda é usada hoje em alguns consoles de vídeo-jogo e sistemas embarcados, mas no geral, computadores novos usam sistemas operativos e núcleos modernos.
Em 1969 o RC 4000 Multiprogramming System introduziu a filosofia de desenvolvimento de sistemas de pequeno nucleus "na qual sistemas operativos para diferentes propósitos poderiam ser criados de maneira metódica",[50] algo que poderia ser chamado de abordagem de micronúcleo.
sistemas operativos de tempo compartilhado
- Ver artigo principal: tempo compartilhado
Na década precedendo o fenômeno Unix, computadores aumentaram muito em poder de processamento — ao ponto onde operadores de computador estavam buscando novos modos de conseguir com que as pessoas usarem o tempo livre em seus computadores. Uma das maiores evoluções durantes esta era foi o tempo compartilhado, onde um número de usuários conseguiria pequenas parcelas do tempo do computador, em uma taxa que pareceria que eles estavam cada um conectado a sua própria máquina, embora mais lenta.[51]
O desenvolvimento dos sistemas de tempo compartilhado levou a inúmeros problemas. Um deles foi que usuários, particularmente em universidades, onde os sistemas estavam sendo desenvolvidos, pareciam tentar hackear o sistema para conseguir mais tempo de processamento. Por esta razão, segurança e controles de acesso se tornaram um foco principal do projetoMultics em 1965.[52] Outro problema corrente era gerenciar apropriadamente os recursos do sistema: usuários gastavam a maior parte do tempo iniciando na tela e pensando ao invés de realmente utilizar os recursos do computador, e o sistema de tempo compartilhado deveria dar tempo de processamento para um usuário ativo durante estes períodos. Por fim, tipicamente os sistemas ofereciam uma hierarquia de memória de várias camadas de profundidade, e particionar este recurso caro levou a um grande desenvolvimento nos sistemas de memória virtual.
UNIX
Diagrama da relação de família de predecessor/sucessor para os sistemas tipo unix.
Durante a fase de projeto do Unix, os programadores decidiram modelar todo dispositivo de alto nível como um arquivo, por que eles acreditavam que o propósito da computação era a transformação de dados.[53] Por exemplo, impressoras eram representadas como um "ficheiro" em uma localização conhecida — quando dados eram copiados para o arquivo, ela imprimia-os. Outros sistemas, para fornecer uma funcionalidade similar, possuem a tendência de virtualizar dispositivos em um nível mais baixo — ou seja, ambos dispositivos e ficheiros seriam instâncias de algum conceito de nível inferior. Virtualizar o sistema a nível de ficheiros permitiu aos usuários manipular todo o sistema usando seus conceitos e ferramentas de gerenciamento de ficheiros, simplificando a operação dramaticamente. Como uma extensão do mesmo paradigma, o Unix permite que programadores manipulem arquivos usando uma série de pequenos programas, usando o conceito de encadeamento, que permitir aos usuários completar operações em etapas, alimentando um ficheiro através de uma cadeia de ferramentas de propósito único. Embora o resultado final fosse o mesmo, usar programas menores deste modo aumentou drasticamente a flexibilidade, assim como o uso e desenvolvimento, permitindo que o usuário modificasse seu fluxo de trabalho ao adicionar ou remover um programa da cadeia.
No modelo Unix, o sistema operativo consiste de duas partes; primeira, a enorme coleção de programas de utilidades que guiam a maioria das operações.[53] No Unix, do ponto de vista da programação, a distinção entre os dois é extremamente tênue; o núcleo é um programa rodando no modo supervisor[8] que age como um carregador de programas e supervisor para os pequenos programas de utilidade que integram o resto do sistema, e fornecem travas e serviços de entrada/saída para estes programas; além disso, o núcleo não intervém de modo algum no espaço de usuário.
Ao longo dos anos o modelo de computação mudou, e o tratamento do Unix de tudo como um ficheiro ou fluxo de baites não era mais universalmente aplicável como antes. Embora um terminal pudesse ser tratado como um ficheiro ou fluxo de baites, de que se exibia ou lia, o mesmo não parecia ser verdade para a interface gráfica. Rede se tornou outro problema. Mesmo se a comunicação de rede pudesse ser comparada ao acesso de ficheiros, a arquitetura de baixo nícel orientada a pacotes lidava com pedaços discretos de dados e não com ficheiros completos. Conforme a capacidade dos computadores crescia, o Unix se tornava cada vez mais desorganizado com relação a código. Enquanto núcleos podiam ter 100.000 linhas de código nos anos 1970 e 1980, núcleos sucessores modernos do núcleo do Unix como o Linux possuem mais de 4.5 milhões de linhas.[54]
Derivados modernos do Unix são geralmente baseados um núcleos monolíticos que carregam módulos. Exemplos disto são o Linux, um núcleo monolítico com suporte a núcleos, e diversas distribuições que o incluem, assim como os núcleos das variantes do BSD comoFreeBSD, DragonflyBSD, OpenBSD, NetBSD, etc. Além destas alternativas, desenvolvedores amadores mantém uma comunidade ativa de desenvolvimento de sistemas operativos, cheia de núcleos que são criados como passa-tempo que acabam compartilhando vários dos recursos com o Linux, e/ou os núcleos do FreeBSD, DragonflyBSD, OpenBSD e NetBSD e/ou sendo compatíveis com eles.[55]
Mac OS
A Apple lançou Mac OS pela primeira vez em 1984, empacotado com o seu computador pessoal Macintosh Apple. Pelos primeiros lançamento, o Mac OS (ou Sistema de Software, como ele foi chamado) #careceu de muitos recursos básicos, como multitarefas e um sistema hierárquico. Com o tempo, o sistema operativo evoluiu e se tornou o Mac OS 9 com alguns recursos adicionados, mas o núcleo se manteve basicamente o mesmo.[carece de fontes] Em oposição a isto, o Mac OS X é baseado no Darwin, que utiliza um conceito de núcleo híbrido chamado XNU, criado combinando o núcleo do 4.3BSD e o Mach.[56]
Amiga
- Ver artigo principal: AmigaOS
O Amiga da Commodore foi lançado em 1985, e estava dentre os primeiros (e certamente mais bem sucedidos) computadores domésticos a apresenter um sistema operativo com um micronúcleo. O núcleo do Amiga, a exec.library, era pequena mas capaz, oferecendo multitarefas rápidas e preemptivas em hardware similar ao do Apple Macintosh, e um sistema avançado deligações dinâmicas que permitia uma expansão fácil.[57]
Microsoft Windows
O Microsoft Windows foi lançado em 1985 como uma extensão para o MS-DOS. Devido à sua dependência de outro sistema operativo, todas as versões até a 95 são consideradas umambiente operacional (e não um sistema operativo propriamente dito). Tal linha de produtos continuou por 1980 e 1990, resultando nos lançamentos das séries Windows 9x, atualizando as capacidades do sistema para endereçamento de 32 bits e multitarefas preemptivo, ao longo dos anos 1990, terminando com o lançamento do Windows Me em 2000.
O lançamento do Windows XP em outubro de 2001 uniu as duas linhas de produto, com a intenção de combinar a estabilidade do núcleo NT com os recursos ao consumidor das séries 9x.[58] Aarquitetura do núcleo do windows nt é considerada híbrida pois o pŕoprio núcleo contém tarefas como o gerenciador de janelas e o gerenciador de comunicação entre processos, mas vários subsistemas são executados no modo de usuário.[59] O ponto de quebra exato entre espaço de usuário e espaço de núcleo têm deslocado conforme a versão, mas a introdução do Arcabouço de driver de espaço de usuário no windows vista, e escalonamento de linha de execução no espaço de usuário no Windows 7,[60] deslocou mais recursos do núcleo núcleo para processos no espaço de usuário.
Desenvolvimento de micronúcleos
Embora o Mach, desenvolvido na Universidade Carnegie Mellon de 1985 a 1994, é o micronúcleo de propósito geral mais conhecido, outros micronúcleos foram desenvolvidos com objetivos mais específicos. Um família de micronúcleos L4 (principalmente o micronúcleo L3 e o L4) foi criada para demonstrar que micronúcleos não são necessariamente lentos.[47] Implementações mais novas como Fiasco e Pistachio são capazes de executar o Linux junto com outros processo L4 em espaços de endereçamento separados.[61][62]
QNX é um Sistema Operativo de tempo-real com um projeto de micronúcleo minimalista que vem sendo desenvolvido deste 1982, sendo mais bem-sucedido do que o Mach em alcançar os objetivos do paradigma do micronúcleo.[63] Ele é usado principalmente em sistemas embarcados e ẽm situações em que o software não pode falhar, como nos braços robóticos do ônibus espacial e máquinas que controlam a moeção de vidro a tolerâncias extremamente finas, onde um minúsculo erro poderia custar centenas de milhares de reais.
O que é Kernel?
O Kernel é um componente do Sistema Operacional, mas fica tão escondido que a maioria dos usuários domésticos sequer ouviu falar nele. Isso se deve à sua importância: ao contrário do que pode parecer, ele é tão essencial para o funcionamento de um computador que é melhor mantê-lo a salvo de pessoas bisbilhoteiras e inexperientes.
O cérebro do S.O.
Um PC divide-se, basicamente, em duas camadas: hardware e software. Até aí, nenhuma novidade. Onde entra o Kernel na história, então? Pois bem: ele é o grande responsável por fazer a interação entre essas camadas. Em outras palavras, é o Kernel que gerencia os recursos do sistema e permite que os programas façam uso deles.
Simples assim?
Na verdade, não. O fato é que o Kernel é complexo demais para ser explicado de forma técnica a um público leigo no assunto. Basicamente, ele começa a funcionar assim que o computador é ligado; nesse momento ele inicia a detecção de todo o hardware indispensável ao funcionamento da máquina (monitor, placa de vídeo etc.). O Sistema Operacional é carregado em seguida e, uma vez que o usuário faça seu login, o Kernel passa a administrar as principais funções dentro do S.O.: isso inclui o gerenciamento da memória, dos processos, dos arquivos e de todos os dispositivos periféricos.
Dessa forma o Kernel pode ser descrito como um grande organizador: é ele o responsável por garantir que todos os programas terão acesso aos recursos de que necessitam (memória RAM, por exemplo) simultaneamente, fazendo com que haja um compartilhamento concorrente – mas sem oferecer riscos à integridade da máquina.
Ass:Samuel Ronaldo ´[Conteúdo]
Ass:Carlos Monteiro [design e Conteúdo}
Nenhum comentário:
Postar um comentário