Um Sistema de Computacional é composto por um ou mais processadores, uma certa quantidade de memória, terminais, discos magnéticos, interfaces de rede e dispositivos de I/O, ou seja, estamos lidando com um sistema extremamente complexo. Assim sendo, desenvolver Softwares que gerencie e integre esses componentes de forma correta e otimizada não é tarefa fácil.

O Software de um sistema pode ser dividido, a grosso modo, em duas categorias: os Programas do Sistema, que gerenciam as operações do próprio computador e os Aplicativos, que atuam diretamente sobre o problema do usuário. O mais importante de todos os programas do Sistema Operacional é o SISTEMA OPERACIONAL, que controla todos os recursos do computador e fornece a base sobre a qual os aplicativos são escritos.

Sistemas operacionais são programas que controlam todos os recursos do computador e fornecem a base para o desenvolvimento dos programas de aplicação. É um gerenciador de recursos, responsável pela gerência do processador, gerência de memória, gerência de arquivos, gerência dos dispositivos de entrada e saída e pelos mecanismos de acesso aos dados. O SO simplifica o uso da maquina e otimiza seu desempenho global.

Classificação de SO

Quanto ao número de usuários:

Monousuário
Multiusuário

Quanto ao número de programas na Memória Principal:

Monotarefa (monoprogramado)
Multitarefa (multiprogramado)

Quanto ao número de CPU:

Monoprocessados
Multiprocessados

Quanto ao tipo de processamento:

Batch - A principal característica desse grupo é o fato de que o usuário perde o controle do programa a partir do momento em que ele o submete ao sistema.
On-line (interativo) - A característica marcante desse grupo é permitir a monitoração e o controle do programa, através de um terminal, enquanto durar o processamento.

A Evolução do Sistema Operacional

Os Sistemas Operacionais vem passando por evoluções constantes. Partimos de sistemas operacionais complexos e utilizados somente por analistas de sistemas ou usuários ligados a área de programação e hoje temos com um apenas um clique diversos tipos de acessos e conseqüentemente todos os tipos de usuários ligados à máquinas operando Windows, Linux, etc. Layout’s claros e modernos facilitaram o acesso à tarefas até então complexas demais para alguns profissionais e talvez por isso, hoje temos no mundo milhões de usuários fazendo as mais diversas transações via PC.

Mas então, como funcionavam os computadores antigamente em relação aos SO?

Na década de 50 o que tínhamos eram computadores de grande porte (mainframes) que ficavam isoladas em salas especiais com ar-condicionado, operadas por equipes profissionais. Somente grandes corporações, agências governamentais ou universidades podiam pagar os vários milhões de dólares para tê-las. Para um job (isto é, um programa ou um conjunto de programas) ser executado, o programador primeiramente escrevia o programa no papel (em FORTRAN ou em linguagem de montagem) e depois o perfurava em cartões. Ele então levava o maço de cartões para a sala de entradas, entregava-o a um dos operadores e ia tomar um café até que a saída impressa estivesse pronta. Ao fim da execução de um job pelo computador, um operador ia até a impressora e retirava a saída da mesma e a levava para a sala de saídas, de modo que o programador pudesse retirá-la mais tarde. Ele então apanhava um dos maços de cartões que foram trazidos para a sala de entradas e o colocava na leitora de cartões. Se fosse necessário um compilador FORTRAN, o operador precisava retirar do armário o maço de cartões correspondente e lê-lo. Muito tempo de computador era desperdiçado enquanto os operadores andavam pela sala das máquinas.

Por causa do alto custo do equipamento, era natural que se começasse a buscar maneiras de reduzir o desperdício de tempo no uso da máquina. A solução geralmente adotada era a do sistema em lote (batch). A idéia era gravar vários jobs em fita magnética usando um computador relativamente mais barato, como o IBM 1401, que era muito bom para ler cartões, copiar fitas e imprimir saídas, mas não tão eficiente em cálculos numéricos.

Outras máquinas mais caras, como a IBM 7094, eram usadas para a computação propriamente dita. Essa situação é mostrada na figura abaixo.

Um sistema em lote (batch) antigo. (a) Os programadores levavam os cartões para o 1401. (b) O 1401 gravava o lote de jobs em fita. (c) O operador levava a fita de entrada para o 7094. (d) O 7094 executava o processamento. (e) O operador levava a fita de saída para o 1401. (f) O 1401 imprimia as saídas.

Depois de aproximadamente uma hora acumulando um lote de jobs, a fita era rebobinada e encaminhada para a sala das máquinas, onde era montada em uma unidade de fita. O operador então carregava um programa especial (o antecessor do sistema operacional de hoje), que lia o primeiro job da fita e executava-o. A saída não era impressa, mas gravada em uma segunda fita. Depois de cada job terminado, o sistema operacional automaticamente lia o próximo job da fita e começava a executá-lo. Quando todo o lote tivesse sido processado, o operador retirava a fita de entrada e a fita de saída, trocava a fita de entrada com a do próximo lote e levava a fita de saída para um computador 1401 imprimi-la off-line, isto é, não conectada ao computador principal.

Os grandes computadores desta época foram usados, em sua maioria, para cálculos científicos,como equações diferenciais parciais, muito freqüentes na física e na engenharia. Eles eram reponderantemente programados em FORTRAN e em linguagem de montagem. Os sistemas operacionais típicos eram o FMS (Fortran Monitor System) e o IBSYS, sistema operacional da IBM para o 7094.

Na década de 60, foi criado pela IBM uma série de máquinas (System/360.) cujo objetivo era atender as diversas linhas de usuários de computadores (desde a área científica até bancos e companhias de seguros) e tornar compatível os softwares utilizados nessa máquinas.

O forte da idéia de ‘família de máquinas’ era simultaneamente sua maior fraqueza. A intenção era que qualquer software, inclusive o sistema operacional OS/360, pudesse ser executado em qualquer um dos modelos. O software precisava ser executado em sistemas pequenos e em sistemas muito grandes. Tinha de ser eficiente tanto em sistemas com poucos periféricos como com muitos periféricos. Tinha de funcionar bem em ambientes comerciais e em ambientes científicos. E, acima de tudo, o sistema operacional precisava provar ser eficaz em todos esses diferentes usos.

Não havia como a IBM (ou qualquer outro fabricante) elaborar um software que resolvesse todos esses requisitos conflitantes. O resultado foi um sistema operacional enorme e extraordinariamente complexo, provavelmente duas ou três vezes maior que o FMS. Eram milhões de linhas escritas em linguagem de montagem por milhares de programadores, contendo milhares de erros, que precisavam de um fluxo contínuo de novas versões para tentar corrigi-los. Cada nova versão corrigia alguns erros, mas introduzia novos, fazendo com que, provavelmente, o número de erros permanecesse constante ao longo do tempo.

Apesar de seu enorme tamanho e de seus problemas, o OS/360 e sistemas operacionais similares de terceira geração elaborados por outros fabricantes de computadores atendiam razoavelmente bem à maioria dos clientes; também popularizavam várias técnicas fundamentais. Provavelmente a mais importante dessas técnicas foi a multiprogramação. No 7094, quando o job atual parava para esperar por uma fita magnética terminar a transferência ou aguardava o término de outra operação de E/S, a CPU simplesmente permanecia ociosa até que a E/S terminasse. Para cálculos científicos com uso intenso do processador (CPU-bound), a E/S era pouco freqüente, de modo que o tempo gasto com ela era quase nada significativo. Para o processamento de dados comerciais, o tempo de espera pela E/S chegava a 80 ou 90 por cento do tempo total (IO-bound). Algo então precisava ser feito para evitar que a CPU ficasse ociosa todo esse tempo.

A solução a que se chegou foi dividir a memória em várias partes, com um job diferente em cada partição, conforme mostrado na Figura 1.4. Enquanto um job esperava que uma operação de E/S se completasse, um outro poderia usar a CPU. Se um número suficiente de jobs pudesse ser mantido na memória ao mesmo tempo, a CPU poderia permanecer ocupada quase 100 por cento do tempo. Manter múltiplos jobs de maneira segura na memória, por sua vez, requeria hardware especial para proteger cada job contra danos e transgressões causados por outros jobs, mas o 360 e outros sistemas de terceira geração eram equipados com hardware para isso.

Um sistema multiprogramado com três jobs na memória.

Outro aspecto importante nos sistemas operacionais desta época era a capacidade de transferir jobs de cartões perfurados para discos magnéticos logo que esses chegassem à sala do computador. Assim que um job fosse completado, o sistema operacional poderia carregar um novo job a partir do disco nessa partição que acabou de ser liberada e então processá-lo. Essa técnica é denominada spooling (termo derivado da expressão simultaneous peripheral operation online) e foi também usada para arbitrar a saída. Com o spooling, os 1401 não eram mais necessários, e muito do leva-e-traz de fitas magnética desapareceu.

O anseio por respostas mais rápidas abriu caminho para o compartilhamento de tempo ou timesharing, uma variante da multiprogramação na qual cada usuário se conectava por meio de um terminal on-line. Em um sistema de tempo compartilhado, se 20 usuários estivessem conectados e 17 deles estivessem pensando, falando ou tomando café, a CPU podia ser ciclicamente alocada a cada um dos três jobs que estivessem requisitando a CPU. Como, ao depurar programas, emitem-se normalmente comandos curtos (como, por exemplo, compile um procedimento* de cinco páginas) em vez de comandos longos (como, por exemplo, ordene um arquivo de um milhão de registros), o computador era capaz de fornecer um serviço rápido e interativo a vários usuários e ainda processar grandes lotes de jobs em segundo plano nos instantes em que a CPU estivesse ociosa. O primeiro sistema importante de tempo compartilhado, o CTSS (compatible time sharing system — sistema de compartilhamento de tempo compatível), foi desenvolvido no MIT em um 7094 modificado (Corbató et al., 1962). Contudo, o tempo compartilhado só se popularizou mais tarde, em um período em que a necessária proteção em hardware foi largamente empregada.

No início dos anos 80, a IBM projetou o IBM PC e buscou um software para ser executado nele. O pessoal da IBM entrou em contato com Bill Gates para licenciar seu interpretador Basic. Também lhe foi indagado se ele conhecia algum sistema operacional que pudesse ser executado no PC. Gates sugeriu que a IBM contatasse a Digital Research, a empresa que dominava o mundo dos sistemas operacionais naquela época. Tomando seguramente a pior decisão de negócios registrada na história, Kildall recusou-se a se reunir com a IBM, enviando em seu lugar um subordinado. Para piorar a história, o advogado dele foi contra assinar um acordo de sigilo sobre o produto PC que ainda não havia sido divulgado. Conseqüentemente, a IBM voltou a Gates perguntando-lhe se seria possível fornecer-lhes um sistema operacional.

Então Gates percebeu que um fabricante local de computadores, a Seattle Computer Products, possuía um sistema operacional adequado, o DOS (disk operating system — sistema operacional de disco). Entrou em contato com essa empresa e disse que queria comprá-la (alegadamente por 50 mil dólares), o que foi prontamente aceito.Gates então ofereceu à IBM um pacote DOS/Basic, e ela aceitou. A IBM quis fazer algumas modificações, e para isso Gates contratou a pessoa que tinha escrito o DOS, Tim Paterson, como funcionário da empresa embrionária de Gates, a Microsoft. O sistema revisado teve seu nome mudado para MS-DOS (Microsoft disk operating system — sistema operacional de disco da Microsoft) e rapidamente viria a dominar o mercado do IBM PC. Um fator decisivo para isso foi a decisão de Gates (agora, olhando o passado, extremamente sábia) de vender o MS-DOS para empresas de computadores acompanhando o hardware, em vez de tentar vender diretamente aos usuários finais (pelo menos inicialmente), como tentou Kildall fazer com o CP/M.

Quando em 1983 o IBM PC/AT foi lançado utilizando a CPU Intel 80286, o MS-DOS avançava firmemente ao mesmo tempo que o CP/M definhava. O MS-DOS foi, mais tarde, também amplamente usado com o 80386 e 80486. Mesmo com uma versão inicial bastante primitiva, as versões subseqüentes do MS-DOS incluíram aspectos mais avançados, muitos deles derivados do Unix. (A Microsoft conhecia bem o Unix, pois, nos primeiros anos da empresa, vendeu uma versão para microcomputadores do Unix denominada Xenix.)

O CP/M, o MS-DOS e outros sistemas operacionais dos primeiros microcomputadores eram todos baseados na digitação de comandos em um teclado feita pelo usuário. Isso finalmente mudou graças a um trabalho de pesquisa de Doug Engelbart no Stanford Research Institute nos anos 60. Engelbart inventou uma interface gráfica — voltada para o usuário — com janelas, ícones, menus e mouse, denominada GUI (graphical user inter-face).

A Microsoft decidiu escrever um sucessor para o MS-DOS baseado na interface GUI e desenvolveu um sistema denominado Windows, que era executado originalmente em cima do MS-DOS (isto é, era como se fosse um interpretador de comandos em vez de um sistema operacional de verdade). Por aproximadamente dez anos, de 1985 a 1995, o Windows permaneceu apenas como um ambiente gráfico no topo do MS-DOS. Contudo, em 1995 lançou-se uma versão do Windows independente do MS-DOS, o Windows 95. Nessa versão, o Windows incorporou muitos aspectos de um sistema operacional, usando o MS-DOS apenas para ser carregado e executar programas antigos do MS-DOS. Em 1998, lançou-se uma versão levemente modificada desse sistema, chamada Windows 98.

Um outro sistema operacional da Microsoft é o Windows NT (NT é uma sigla para new technology), que é compatível com o Windows 95 em um certo nível, mas reescrito internamente por completo. A Microsoft esperava que a primeira versão do NT ‘aposentasse’ o MS-DOS e todas as outras versões do Windows, já que o NT era muito superior, mas isso não aconteceu. Somente com a versão Windows NT 4.0 foi que ele finalmente deslanchou, especialmente em redes corporativas. A versão 5 do Windows NT foi renomeada para Windows 2000 no início de 1999. Seu objetivo era suceder tanto o Windows 98 quanto o Windows NT 4.0, mas também não obteve êxito, e então a Microsoft lançou mais uma versão do Windows 98 denominada Windows Me (Millenium edition).

O outro grande competidor no mundo dos computadores pessoais é o Unix (e seus vários derivados). O Unix é o mais forte em estações de trabalho e em outros computadores mais avançados, como os servidores de rede. Ele é especialmente popular em máquinas cujos processadores são chips RISC de alto desempenho. Em computadores baseados em Pentium, o Linux está se tornando uma alternativa popular para estudantes e um crescente número de usuários corporativos.

Um fato interessante, que teve início em meados dos anos 80, foi o desenvolvimento das redes de computadores pessoais executando sistemas operacionais de rede e sistemas operacionais distribuídos. Em um sistema operacional de redes, os usuários sabem da existência de múltiplos computa-dores e podem conectar-se a máquinas remotas e copiar arquivos de uma máquina para outra. Cada máquina executa seu próprio sistema operacional local e tem seu próprio usuário local (ou usuários locais).

Sistemas operacionais de rede não são fundamentalmente diferentes de sistemas operacionais voltados para um único processador: obviamente precisam de um controlador de interface de rede e de software de baixo nível para controlá-la, bem como de programas para conseguir sessões remotas e também ter acesso remoto a arquivos, mas esses acréscimos não alteram a estrutura essencial do sistema operacional.

Um sistema operacional distribuído, por outro lado, é aquele que parece aos olhos dos usuários um sistema operacional tradicional de processador único, mesmo que na realidade seja composto de múltiplos processadores. Os usuários não precisam saber onde seus programas estão sendo executados nem onde seus arquivos estão localizados, pois tudo é tratado automática e eficientemente pelo sistema operacional.

Os verdadeiros sistemas operacionais distribuídos requerem muito mais do que apenas adicionar algum código a um sistema operacional monoprocessador, pois os sistemas distribuídos e centralizados são muito diferentes em pontos fundamentais. Por exemplo, é comum que sistemas distribuídos permitam que aplicações sejam executadas em vários processadores ao mesmo tempo, o que exige algoritmos mais complexos de escalonamento de processadores para otimizar o paralelismo. Atrasos de comunicação na rede muitas vezes significam que esses (e outros) algoritmos devam ser executados com informações incompletas, desatualizadas ou até mesmo incorretas. Essa situação é radicalmente diferente de um sistema monoprocessador, em que o sistema operacional tem toda a informação sobre o estado do sistema.