Antes dos sistemas operacionais, que conceito era usado para fazê-los funcionar? [fechadas]

Os sistemas operacionais estão intimamente relacionados à arquitetura do computador. Um sistema operacional cuida de todas as entradas e saídas de um sistema de computador. Ele gerencia usuários, processos, gerenciamento de memória, impressão, telecomunicações, rede etc. Envia dados para um disco, impressora, tela e outros periféricos conectados ao computador.

Antes da introdução do sistema operacional,

O que foi usado nos sistemas de computador para fazê-los funcionar?

Qual conceito foi usado para o sistema operacional em nossa evolução do computador?

Os computadores antigos ^† executavam um programa por vez.

Os programas foram carregados diretamente (por exemplo) de fita de papel com furos.

Você programava os computadores mais antigos ^† configurando um grande conjunto de interruptores liga / desliga.

Colosso:

Atlas:

Manchester:

^† Estou usando a palavra "Computador" para significar o tipo de dispositivo que existe hoje em bilhões. Desse vasto número de computadores, quase um número insignificantemente pequeno são computadores programáveis ​​eletrônicos digitais com programas armazenados. Tenho certeza de que a pergunta original não é sobre como as pessoas com o cargo "Computador" passaram o dia útil. Entre esses dois tipos de computador, há uma progressão de dispositivos interessantes não abordados nesta resposta.

Fonte: História dos Sistemas Operacionais

Os sistemas operacionais evoluíram através de várias fases ou gerações distintas, que correspondem aproximadamente às décadas.

Os anos 40 - Primeiras gerações

Os primeiros computadores digitais eletrônicos não tinham sistema operacional. As máquinas da época eram tão primitivas que os programas eram frequentemente inseridos um pouco de cada vez em fileiras de interruptores mecânicos (plugues) . As linguagens de programação eram desconhecidas (nem mesmo as linguagens de montagem). Os sistemas operacionais eram inéditos.

Os anos 50 - Segunda Geração

No início dos anos 50, a rotina havia melhorado um pouco com a introdução de cartões perfurados. Os Laboratórios de Pesquisa General Motors implementaram os primeiros sistemas operacionais no início dos anos 50 para o IBM 701 . O sistema dos anos 50 geralmente executava um trabalho por vez. Esses foram chamados de sistemas de processamento em lote de fluxo único porque os programas e os dados foram enviados em grupos ou lotes.

Fonte: http://en.wikipedia.org/wiki/History_of_operating_systems

Os computadores mais antigos eram mainframes que não possuíam nenhuma forma de sistema operacional.

Cada usuário fazia uso exclusivo da máquina por um período agendado e chegava ao computador com programa e dados, geralmente em cartões de papel perfurados e fita magnética ou de papel. O programa seria carregado na máquina e a máquina seria configurada para funcionar até que o programa fosse concluído ou travasse.

Os programas geralmente podem ser depurados por meio de um painel de controle usando interruptores e luzes do painel. Dizem que Alan Turing era um mestre nisso na máquina Manchester Mark 1, e ele já estava derivando a concepção primitiva de um sistema operacional dos princípios da máquina Universal Turing.

Voltando ao início dos sistemas de computador, você não tinha sistemas de computador único; em vez disso, você tinha mainframes.

Esses mainframes seriam executados em cartões perfurados que conteriam seu programa (e freqüentemente seus dados). As pessoas recebiam tempo alocado nesses sistemas, traziam seus cartões e os conectavam nas máquinas para processamento. A máquina executaria o programa até terminar, e o próximo usuário acompanharia a fita e os cartões.

Basicamente, foi assim que funcionou.

1890-1950 - Operação inerente ao sistema Os computadores mais antigos tinham o equivalente ao que um sistema operacional faz agora. Você (o operador) também fazia parte do sistema operacional. Você ligou os interruptores de registro (ou usou um cartão perfurado) e os fios de barramento fisicamente trocados (pense na antiga estação telefônica) e a memória foi conectada (através dos fios físicos) diretamente à lâmpada (o monitor do dia) e às impressoras ( armazenamento de longo prazo) de forma que a saída do programa acenda e imprima diretamente no dispositivo, à medida que ele é colocado no buffer de memória de saída. Não era necessário um driver para essas coisas porque (devido à maneira como esses fios físicos eram executados) "apenas funcionavam" (também não havia monitor nos dias de hoje). De fato, ainda demorariam algumas décadas até que um display numérico digital fosse inventado, para que você pudesse realmente ver os números que já havia inserido no registro e a saída como números decimais; as impressoras governaram toda essa época até os monitores. Eles foram conectados exatamente como precisavam para funcionar corretamente. Nada dessa parte realmente mudou muito com a mudança do mecânico (1890) para o analógico elétrico (1910) para o digital (1930). Essa arquitetura 'Plug N play' foi substituída pelo sistema de interrupção durante esse período e não voltaria à tona novamente até o final dos anos 90; é claro que até lá haveria muito menos entupimento. Com interrupções, os dispositivos podiam levar tempo de CPU, o que permitia arquiteturas que não eram ' t diretamente ligado ao hardware, mas levou várias gerações para que esse fosse realmente o processo simplificado que vemos no x86 arch (e mais recente); os primeiros sistemas frequentemente enfrentavam condições horríveis de corrida, problemas de compatibilidade / atraso de hardware e outros comportamentos estranhos no que diz respeito a interrupções. Porque cada máquina usou arquiteturas radicalmente diferentes (experimentais) nesse período; quase todos os dispositivos foram feitos sob medida para a máquina em que trabalhavam.

1950-1973 - Operação dentro de um sistema Esta era viu o advento da maioria dos recursos que pensamos quando falamos sobre um verdadeiro sistema operacional. Depuração, linguagens de programação, multiusuários, multitarefas, terminais, unidades de disco, rede, padronização de componentes etc. foram todos introduzidos nesta era. Desta vez, houve um grande salto em direção à padronização de grande parte disso, o que significava que tínhamos dispositivos mais padronizados, mas ainda cada SO era criado manualmente para cada máquina, o que significava que a funcionalidade do SO era severamente limitada pelo que os engenheiros que projetaram esse sistema específico decidiram que precisavam. . Durante esse período, houve uma área cinzenta substancial no que era um sistema operacional, porque as diferentes arquiteturas lidam com as coisas de maneira muito diferente e uma máquina de uso geral precisará de muito mais SO do que uma máquina que inclui hardware para lidar com os mesmos trabalhos. O fato é que o hardware sempre será mais rápido que o software e praticamente tudo o que é feito em software pode ser teoricamente feito em hardware (é custo \ flexibilidade \ tamanho \ tempo \ etc, o que nos limita a criar versões quase puras de tudo. dia). Um sistema operacional foi criado para um computador ou tipo de computador específico; não funcionaria em outro lugar. Cada novo design de computador precisava que todos os softwares de baixo nível do SO fossem reescritos do zero para funcionar com um modelo de máquina específico. Perto do final desse período, surgiu um novo sistema operacional que em breve mudaria esse paradigma, o UNIX, escrito no Bell Labs por Ken Thompson e Dennis Ritchie.

1973 - Operação entre sistemas Um único programa mudou tudo isso, mas não era o UNIX. Era o compilador C (que foi famoso em uma garagem por Ken Thompson e Dennis Ritchie depois que o Bell Labs o cortou). Até esse momento, sempre que você escrevia um código, ele era um código de máquina (código que a máquina entende diretamente, mas não é portátil) ou foi escrito em uma linguagem que compilava seu código em código de bytes (código que é interpretado por outro programa como corre). A enorme diferença para os sistemas operacionais que C trouxe com ele foi a capacidade de fazer o que é conhecido como compilação cruzada no código da máquina. Isso significava que o código poderia ser escrito uma vez e compilado para rodar em muitos tipos diferentes de máquinas nativamente, desde que um compilador tivesse sido escrito para essa máquina. Os sistemas operacionais devem ser escritos em código de máquina, porque o código de máquina é literalmente o único código que a máquina conhece.

Eu diria que não foi até Ken e Dennis compilarem o kernel UNIX pela primeira vez usando um compilador C que nasceu um verdadeiro sistema operacional no sentido moderno. Antes disso, um sistema operacional era um objeto físico ou simplesmente um pedaço de espaço de memória pré-inicializado, projetado especificamente para uma máquina específica. Adicionar novos dispositivos ao sistema literalmente exigia que o código do 'kernel' fosse reescrito. Agora, o sistema operacional UNIX que eles haviam projetado para uma máquina específica poderia ser recompilado e executado em outras máquinas sem reescrever TUDO (desde que essa máquina fosse capaz de compilar um compilador C a partir de um ambiente de inicialização, o restante do sistema operacional poderia ser escrito em o código C de nível relativamente alto).

No começo, os programas eram conectados ao computador, o que começaria a executar o programa imediatamente a partir de um local específico na inicialização.

Em seguida, várias formas de armazenamento offline foram inventadas: cartões perfurados, fita adesiva, bateria e até discos. Muito mais flexível. Mas não diretamente acessível a partir da CPU. O programa precisa ser carregado na memória antes de poder ser executado. Então você escreve um programa para carregar seu programa. Isso é conhecido como carregador ou bootstrap (da expressão "para se destacar pelas tiras de inicialização").

À medida que o sistema fica mais complicado, você pode ter um carregador simples carregando um carregador mais complexo. Isso começou com os microcomputadores: o carregador de fita normal era lento; portanto, carregue um descompressor e carregue rapidamente o restante da fita. Ou carregadores de velocidade de disco que funcionavam como sistemas de proteção contra cópia, fazendo coisas fora do padrão com o disco.

Ou o processo de inicialização do PC pré-UEFI: o processador começa a executar no BIOS. Isso carrega o primeiro setor do disco e salta para ele. Isso procura por uma partição ativa e carrega um gerenciador de inicialização a partir daí, que carrega o sistema operacional. Originalmente, isso teria sido o COMMAND.COM para MSDOS; agora é geralmente NTLDR.EXE para Windows.

Deve-se notar que no hardware inicial (antes de 1960), a E / S era muito mais simples. Você pode ler um cartão, perfurar um cartão ou imprimir uma linha na impressora, cada uma com uma única instrução: o tamanho do buffer foi corrigido e, freqüentemente, o endereço do buffer também foi corrigido.

Mesmo no início dos anos 60, com processadores mais sofisticados (por exemplo, o 7090), você ainda podia ler ou perfurar cartões com uma rotina pequena (cerca de 20 instruções), que era facilmente copiada em cada programa.

Como o computador foi totalmente dedicado a um único trabalho, não importava se o processador estava ocioso enquanto esperava o leitor de cartões estar pronto para ler o próximo cartão ou se a impressora de linha alimentava a próxima linha.

Bem, importava, porque o tempo de computação era realmente caro. É por isso que as pessoas inventaram o multiprocessamento, o compartilhamento de tempo, adicionaram E / S assíncrona e interrompem e controlam dispositivos e sistemas operacionais. As interfaces de dispositivo de hardware tornaram-se mais complexas, para o programador, fornecendo acesso a registros de E / S de nível inferior, o que exigia mais complexidade dos drivers de dispositivo. Esse custo de complexidade (memória, tempo de programação) foi amortizado nos vários programas usando os dispositivos "simultaneamente", multiplexados pelo sistema operacional.

Ainda nos anos 80, eu estava usando um computador com microprocessador, emulando um desses sistemas mais antigos. As instruções da máquina tinham um formato uniforme acima de 80 bits (10 octetos), e a instrução para ler o primeiro setor do primeiro disco rígido e armazená-lo na memória no endereço 0 era muito conveniente: 0000000000. Portanto, o procedimento de inicialização consistia todas as manhãs para digitar esta instrução no terminal, que a armazenou no endereço 0 e a executou, que carregou o setor de inicialização e continuou a execução na próxima instrução (no endereço 10). O sistema de arquivos consistia em um arquivo estático de mapeamento de tabela "nomes" para intervalos de setores, que foram alocados manualmente! A E / S foi feita no assembler para esses arquivos, lendo ou gravando diretamente os setores, compensada pela posição do arquivo no disco rígido que foi recuperado pelo "

A primeira geração de computadores projetados para uso pessoal mais amplo havia chamado "Monitor" na ROM (memória somente leitura).

Imediatamente após a inicialização, o monitor forneceu uma interface de linha de comando muito limitada, principalmente para carregar o programa do armazenamento de dados como um gravador e iniciar a execução (alguns outros comandos estavam disponíveis para a entrada manual de código, embora raramente necessários). Somente um programa pode ser executado por vez.

Diferentemente do sistema operacional, o Monitor não tinha suporte para nenhum sistema de arquivos. O operador humano foi responsável por encontrar a fita certa, colocá-la no gravador e posicionar no início do programa necessário para carregar.

Monitore as funções combinadas do BIOS e do sistema operacional e já era claramente um software.

Depois de ligar, o sinal curto de "reset" estava zerando o contador de programa da mesma forma que qualquer outro contador, ao mesmo tempo em que trocava o mapeador de memória (se houver algum) para mapear o endereço 0000 para a ROM do Monitor. Era comum haver algum circuito de hardware para remapear o Monitor no espaço de endereço alto posteriormente. Além da inicialização do código, o botão "Redefinir" também foi usado para finalizar o programa em execução, para que outro pudesse ser carregado.

O rudimentar botão "redefinir" pode ser encontrado em alguns PCs de mesa mesmo hoje em dia.

O antecessor mais direto do sistema operacional seria uma combinação de bibliotecas padrão para interface com dispositivos e o sistema do carregador de inicialização para colocar um programa na memória e começar a executar.