Detalhes

Categoria: Sistemas Operacionais

Atualização: Quinta, 03 Abril 2008 14:52

Autor: vovó Vicki

Acessos: 40130

Desenvolvimento histórico

Os sistemas operacionais evoluíram com o aumento da necessidade de tecnologia. Os primeiros computadores eram enormes, extremamente caros e muito difíceis de serem operados.

Open Shop

Indivíduos (chamados de usuários) contratavam horas nas quais podiam "mexer" num computador. As máquinas possuíam dois componentes principais: os dispositivos de transposição (entrada/saída) e a capacidade de executar um programa. Uma sessão típica no IBM 1620, computador usado ao redor de 1964, envolvia várias etapas na compilação e execução de um programa. Primeiro, o usuário carregava a primeira passada no compilador Fortran. Esta operação envolvia a limpeza da memória (digitando-se instruções estranhíssimas no console de teclado), a preparação do compilador (colocando uma pilha de uns 30 cm de cartões perfurados no leitor de cartões), depois a colocação do programa a ser compilado (outra pilha de cartões perfurados no leitor de cartões) e finalmente o acionamento do botão "load" (carregar) do leitor. O resultado era um novo conjunto de cartões perfurados chamado de "saída intermediária". Se ocorressem erros de compilação, uma luz ficava piscando no console e mensagens de erro apareciam no console de teclado. Se tudo corresse bem, o próximo passo era como o primeiro: carregar a segunda passada no compilador Fortran e colocar os cartões intermediários no leitor de cartões. Caso não ocorressem erros, esta operação gerava um segundo conjunto de cartões perfurados, o "jogo executável". A terceira etapa consistia em misturar um pouco o jogo executável de cartões, carregá-lo juntamente com uma biblioteca de subrotinas enorme (mais uns 30 cm de cartões) e observar o programa ser executado.

A saída de um programa podia ser em cartões ou em papel e, com frequência, a saída estava errada. Para descobrir porque, era preciso conferir (debugar) o programa, o que muitas vezes era feito alterando-se manualmente o conteúdo da memória ou até mesmo fazendo remendos (patches) no programa através de interruptores do console. Se o tempo contratado estivesse terminando, o usuário frustrado podia imprimir uma listagem da memória (conhecida como dump de memória) para depois tentar decifrá-la. Se o usuário terminasse antes do tempo contratado, a máquina ficava ociosa até completar o tempo.

Shop executado por operador

Devido ao custo da computação, cada minuto de máquina parada era uma verdadeira fortuna. Num esforço para evitar esta ociosidade, foram contratados operadores para realizar as tarefas repetitivas de montar pilhas de cartões ou preparar fitas magnéticas. Geralmente os operadores eram muito mais rápidos que os usuários comuns, diminuindo o tempo gasto na preparação das etapas de trabalho. Se o programa falhasse, o operador fazia um dump e o entregava ao solicitante - os usuários não podiam mais debugar diretamente. Além disso, dependendo do número de solicitações, o operador podia realizar tarefas em lotes como, por exemplo, fazer a primeira passada de várias tarefas no compilador Fortran, guardar todas as saídas intermediárias e depois fazer a segunda passada numa tacada só. Com isto, diminuía-se ainda mais o tempo ocioso.

Outro aspecto importante era a priorização de tarefas visando a otimização do trabalho, onde trabalhos muito demorados podiam ser deixados para o turno da noite.

Transposição offline

Muitas das tarefas realizadas pelo operador eram repetitivas. O estágio seguinte do desenvolvimento foi automatizar estas tarefas. Em primeiro lugar, as tarefas de entrada passaram a ser realizadas offline usando-se computadores separados, algumas vezes chamados de "satélites", cuja única tarefa era transferir cartões para fitas magnéticas. Quando uma fita estivesse completa, o operador a transferia para o computador principal. A leitura da fita era mais rápida do que a dos cartões, ganhando-se tempo na transposição (entrada). Da mesma forma, as saídas também eram geradas em fita, processo muito mais rápido do que perfurar cartões. A fita de saída era depois convertida numa listagem através de uma impressora offline.

Um pequeno programa monitor residente, que permanecia na memória enquanto as tarefas eram executadas, reinicializava a máquina após cada uma das tarefas completadas e carregava a próxima. Foram estabelecidas convenções para os cartões (ou "imagem de cartões" quando estavam em fita) para separar tarefas e especificar suas necessidades. Estas convenções foram os rudimentos das linguagens de comando. Por exemplo, uma das convenções era colocar um asterisco na primeira coluna dos cartões de controle para diferenciá-los dos cartões de dados.

O monitor residente tinha várias atribuições: interpretar a linguagem de comando, realizar uma contabilidade rudimentar e fornecer entradas e saídas independentes de dispositivos substituindo fitas por cartões. O programa executado podia lidar diretamente com fitas mas, como facilidade, o monitor residente fornecia algumas subrotinas para a leitura da fita de entrada e para a escrita da fita de saída.

Sistemas de spooling

O passo seguinte da evolução foi que as unidades de transposição (entrada/saída) trabalhassem simultaneamente com o computador. Elas geravam uma pedido de interrupção quando terminavam a leitura ou a escrita de um registro ao invés de ficarem sendo monitoradas o tempo todo. Uma interrupção fazia com que o computador armazenasse algumas informações críticas e que desviasse o processamento para uma localização específica, própria para o tipo da interrupção. Rotinas de serviços de dispositivos, conhecidas como drivers de dispositivo (condutores de dispositivos), foram adicionadas ao monitor residente para lidar com estas interrupções.

Foram adicionados discos como meio de armazenamento secundário. A partir daí o computador podia realizar um trabalho de computação enquanto lia outro do disco e imprimia os resultados de um terceiro a partir do disco. Diferentemente da fita, o disco permitia que os programas fossem armazenados em qualquer parte, de modo que o computador não precisava mais realizar as tarefas respeitando a ordem de entrada das mesmas. Um planejador (scheduler) primitivo foi adicionado ao monitor residente para organizar as tarefas de acordo com a prioridade e o tempo requerido para realizá-las. Estes critérios podiam ser especificados em cartões de controle. Apesar destas inovações, os operadores ainda eram necessários: montavam fitas de dados, tomavam decisões de prioridade de tarefas e reiniciavam o monitor residente quando este falhava ou era destruído inadvertidamente por alguma tarefa.

Este modo de operação ficou conhecido como sistema de spooling e seu monitor residente foi o avô dos modernos sistemas operacionais. A palavra spool, cuja tradução é bobina, carretel, na verdade foi derivada de Simultaneous Peripheral Operations On Line mas, na prática, é mais fácil imaginar um carretel de linha que corresponde às tarefas enroladas. Um dos primeiros sistemas de spooling foi o HASP (Houston Automatic Spooling Program), um adicional ao OS/360 para a família de computadores IBM 360.