Antes de los sistemas operativos, ¿qué concepto se usó para hacerlos funcionar? [cerrado]

Los sistemas operativos han estado estrechamente relacionados con la arquitectura de la computadora. Un sistema operativo se encarga de todas las entradas y salidas en un sistema informático. Gestiona usuarios, procesos, gestión de memoria, impresión, telecomunicaciones, redes, etc. Envía datos a un disco, la impresora, la pantalla y otros periféricos conectados a la computadora.

Antes de la introducción del sistema operativo,

¿Qué se utilizó en los sistemas informáticos para que funcionen?

¿Qué concepto se utilizó para el sistema operativo en nuestra evolución de la computadora?

Las primeras computadoras ^† ejecutaban un programa a la vez.

Los programas se cargaron directamente de (por ejemplo) cinta de papel con agujeros perforados.

Programarías las primeras computadoras ^† configurando un gran conjunto de interruptores de encendido y apagado.

Coloso:

Atlas:

Manchester:

^† Estoy usando la palabra "Computadora" para referirme al tipo de dispositivo que existe actualmente en miles de millones. De este gran número de computadoras, todas menos una cantidad insignificantemente pequeña son computadoras digitales electrónicas programables con programas almacenados. Estoy seguro de que la pregunta original no se trata de cómo las personas con el título de trabajo "Computadora" pasaron su jornada laboral. Entre esos dos tipos de computadora, hay una progresión de dispositivos interesantes no cubiertos en esta respuesta.

Fuente: Historia de los sistemas operativos.

Los sistemas operativos han evolucionado a través de varias fases o generaciones distintas que corresponden aproximadamente a las décadas.

La década de 1940 - Primeras generaciones

Las primeras computadoras digitales electrónicas no tenían sistemas operativos. Las máquinas de la época eran tan primitivas que los programas a menudo se ingresaban un bit a la vez en filas de interruptores mecánicos (tableros de enchufes) . Los lenguajes de programación eran desconocidos (ni siquiera los lenguajes ensambladores). Los sistemas operativos eran desconocidos.

La década de 1950 - Segunda generación

A principios de la década de 1950, la rutina había mejorado un poco con la introducción de las tarjetas perforadas. Los Laboratorios de Investigación de General Motors implementaron los primeros sistemas operativos a principios de la década de 1950 para su IBM 701 . El sistema de los años 50 generalmente ejecutaba un trabajo a la vez. Estos se llamaron sistemas de procesamiento por lotes de flujo único porque los programas y los datos se enviaron en grupos o lotes.

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

Las primeras computadoras eran mainframes que carecían de cualquier forma de sistema operativo.

Cada usuario tenía el uso exclusivo de la máquina durante un período de tiempo programado y llegaba a la computadora con el programa y los datos, a menudo en tarjetas de papel perforadas y cinta magnética o de papel. El programa se cargaría en la máquina, y la máquina se configuraría para funcionar hasta que el programa se completara o fallara.

Los programas generalmente se pueden depurar a través de un panel de control utilizando interruptores de palanca y luces del panel. Se dice que Alan Turing era un maestro de esto en las primeras máquinas Manchester Mark 1, y ya estaba derivando la concepción primitiva de un sistema operativo de los principios de la máquina Universal Turing.

Volviendo al inicio de los sistemas informáticos, no tenía sistemas informáticos únicos, sino que tenía mainframes.

Estos mainframes se ejecutarían en tarjetas perforadas que contendrían su programa (y a menudo sus datos). Las personas tendrían tiempo asignado en estos sistemas, llevarían sus tarjetas y las conectarían a las máquinas para que las procesen. La máquina ejecutaría el programa hasta que terminara, luego el siguiente usuario vendría junto con su cinta y tarjetas.

Básicamente así es como funcionó.

1890-1950 - Operación inherente al sistema Las primeras computadoras tenían el equivalente de lo que un sistema operativo ahora incorpora. Usted (el operador) también formaba parte del sistema operativo. Volteó los interruptores de registro (o usó una tarjeta perforada) e intercambió físicamente los cables del bus (piense en la antigua estación del operador telefónico) y la memoria se vinculó (a través de cables físicos) directamente con la bombilla (el monitor del día) y las impresoras ( el almacenamiento a largo plazo) de tal manera que la salida del programa se iluminaría e imprimiría directamente en el dispositivo mientras se colocaba en el búfer de memoria de salida. No se necesitaba un controlador para estas cosas porque (debido a la forma en que se corrieron esos cables físicos) 'simplemente funcionaban' (en estos días tampoco existía un monitor). De hecho, todavía iban a pasar algunas décadas en esta era hasta que se inventara una pantalla numérica digital para que pudiera ver los números que ya había ingresado en el registro y la salida como números decimales; Las impresoras gobernaron toda esta era hasta los monitores. Fueron cableados exactamente como necesitaban para funcionar correctamente. Nada de esta parte realmente cambió mucho con el cambio de mecánico (1890) a analógico eléctrico (1910) a digital (1930). Esta arquitectura 'Plug N play' fue reemplazada por el sistema de interrupción durante este tiempo y no volvería a aparecer hasta finales de los noventa; por supuesto para entonces habría mucho menos taponamiento. Con las interrupciones, se permitió que los dispositivos tomaran tiempo de CPU, lo que permitió arquitecturas que no eran No está directamente relacionado con el hardware, pero tomó varias generaciones para que este sea realmente el proceso simplificado que vemos en x86 arch (y más reciente); Los primeros sistemas a menudo se toparon con condiciones de carrera horribles, compatibilidad de hardware / problemas de retraso y otros comportamientos extraños en lo que respecta a las interrupciones. Porque cada máquina utilizó arquitecturas radicalmente diferentes (experimentales) en este período; Casi todos los dispositivos fueron hechos a medida para la máquina en la que trabajaban.

1950-1973 - Operación dentro de un sistema Esta era vio el advenimiento de la mayoría de las características en las que pensamos cuando hablamos de un verdadero sistema operativo. La depuración, lenguajes de programación, usuarios múltiples, tareas múltiples, terminales, unidades de disco, redes, estandarización de componentes, etc., se introdujeron en esta era. Esta vez vimos un gran salto hacia la estandarización de gran parte de esto, lo que significaba que teníamos más dispositivos estandarizados, pero aún así cada sistema operativo fue diseñado a mano para cada máquina, lo que significaba que la funcionalidad del sistema operativo estaba severamente limitada por lo que los ingenieros que diseñaron ese sistema en particular decidieron que necesitaban . Durante este tiempo, había un área gris sustancial en lo que era un sistema operativo porque las diferentes arquitecturas manejan las cosas de manera muy diferente y una máquina de uso más general necesitará mucho más sistema operativo que una máquina que incluya hardware para manejar los mismos trabajos. El hecho es que el hardware siempre será más rápido que el software y prácticamente cualquier cosa que se haga en software teóricamente se puede hacer en hardware (es el costo \ flexibilidad \ tamaño \ tiempo \ etc. lo que nos limita de hacer versiones de hardware casi puras de todo esto). día). Se creó un sistema operativo para una computadora o tipo de computadora en particular; No funcionaría en otro lado. Cada nuevo diseño de computadora necesitaba que todo el software del sistema operativo de bajo nivel se reescribiera desde cero para funcionar con un modelo de máquina en particular. Cerca del final de este tiempo, surgió un nuevo sistema operativo que pronto cambiaría este paradigma, UNIX escrito en Bell Labs por Ken Thompson y Dennis Ritchie.

1973 - Operación entre sistemas Un solo programa cambió todo esto, pero no era UNIX. Era el compilador de C (que fue famoso por Ken Thompson y Dennis Ritchie en un garaje después de que Bell Labs lo cortara). Hasta este punto, cada vez que escribía código era código de máquina (código que la máquina entiende directamente pero no es portátil) o estaba escrito en un lenguaje que compiló su código en código de bytes (código que otro programa interpreta como carreras). La gran diferencia para los sistemas operativos que C trajo consigo fue la capacidad de hacer lo que se conoce como compilación cruzada en código máquina. Esto significaba que el código podía escribirse una vez y compilarse para ejecutarse en muchos tipos de máquinas diferentes de forma nativa siempre que se hubiera escrito un compilador para esa máquina. Los sistemas operativos deben estar escritos en código de máquina porque el código de máquina es literalmente el único código que la máquina conoce.

Diría que no fue hasta que Ken y Dennis compilaron por primera vez el núcleo de UNIX utilizando un compilador de C que nació un verdadero sistema operativo en el sentido moderno. Antes de eso, un sistema operativo era un objeto físico o simplemente un fragmento de espacio de memoria preinicializado diseñado específicamente para una máquina en particular. Agregar nuevos dispositivos al sistema literalmente requería que el código 'kernel' fuera reescrito. Ahora, el sistema operativo UNIX que habían diseñado para una máquina en particular podría recompilarse y ejecutarse en otras máquinas sin tener que volver a escribir TODO (siempre y cuando esa máquina pudiera compilar un compilador C desde un entorno de arranque, el resto del sistema operativo podría escribirse en el código C de nivel relativamente alto).

Al principio, los programas estaban conectados a la computadora, lo que comenzaría a ejecutar el programa inmediatamente desde una ubicación particular durante el arranque.

Luego se inventaron varias formas de almacenamiento fuera de línea: tarjetas perforadas, cintas, tambores, incluso discos. Mucho más flexible. Pero no directamente accesible desde la CPU. El programa debe cargarse en la memoria antes de poder ejecutarse. Entonces escribes un programa para cargar tu programa. Esto se conoce como cargador o bootstrap (de la expresión "para levantarse con las correas de arranque").

A medida que el sistema se vuelve más complicado, es posible que un cargador simple cargue un cargador más complejo. Esto comenzó con microcomputadoras: el cargador de cinta normal era lento, así que cargue un descompresor y cargue rápidamente el resto de la cinta. O cargadores de disco que funcionan como sistemas de protección de copia al hacer cosas no estándar con el disco.

O el proceso de arranque de PC previo a UEFI: el procesador comienza a ejecutarse en el BIOS. Esto carga el primer sector del disco y salta a él. Busca una partición activa y carga un gestor de arranque desde allí, que carga el sistema operativo. Originalmente habría sido COMMAND.COM para MSDOS; ahora suele ser NTLDR.EXE para Windows.

Cabe señalar que al principio del hardware (antes de 1960), la E / S era mucho más simple. Puede leer una tarjeta, perforar una tarjeta o imprimir una línea en la impresora, cada una con una sola instrucción: el tamaño del búfer fue fijo y, a menudo, la dirección del búfer también.

Incluso a principios de los años 60, con procesadores más sofisticados (por ejemplo, el 7090), aún podía leer o perforar tarjetas con una pequeña rutina (aproximadamente 20 instrucciones), que se copiaba fácilmente en cada programa.

Dado que la computadora estaba completamente dedicada a un solo trabajo, no importaba si el procesador estaba inactivo mientras esperaba que el lector de tarjetas estuviera listo para leer la próxima tarjeta, o que la impresora de línea alimentara la siguiente línea.

Bueno, sí importaba, porque el tiempo de computación era realmente costoso. Esta es la razón por la cual las personas inventaron el procesamiento múltiple, el tiempo compartido, las E / S asíncronas agregadas, las interrupciones, los controladores de dispositivos y los sistemas operativos. Las interfaces del dispositivo de hardware se volvieron más complejas, para el programador, dando acceso a registros de E / S de nivel inferior, lo que requería más complejidad de los controladores del dispositivo. Este costo de complejidad (memoria, tiempo de programación) se amortizó en varios programas utilizando los dispositivos "simultáneamente", multiplexados por el sistema operativo.

Todavía en los años 80 estaba usando una computadora basada en un microprocesador, emulando uno de esos sistemas más antiguos. Las instrucciones de la máquina tenían un formato uniforme de más de 80 bits (10 octetos), y la instrucción para leer el primer sector del primer disco duro y almacenarlo en la memoria en la dirección 0 era muy conveniente: 0000000000. Por lo tanto, el procedimiento de arranque consistía todas las mañanas para escribir esta instrucción en el terminal, que la almacenó en la dirección 0 y la ejecutó, que luego cargó el sector de arranque y continuó la ejecución en la siguiente instrucción (en la dirección 10). El sistema de archivos consistía en una tabla estática que asignaba "nombres" de archivos a rangos de sectores, que se asignaban manualmente. La E / S se realizó en ensamblador de esos archivos leyendo o escribiendo directamente los sectores, compensados ​​por la posición del archivo en el disco duro que fue recuperado por el "

La primera generación de computadoras diseñadas para un uso personal más amplio había llamado "Monitor" en ROM (memoria de solo lectura).

Inmediatamente después del arranque, el monitor proporcionó una interfaz de línea de comandos muy limitada, principalmente para cargar el programa desde el almacenamiento de datos como una grabadora de cinta e iniciar la ejecución (algunos otros comandos estaban disponibles para la entrada de código manual, aunque rara vez se necesitaban). Solo un programa podría ejecutarse a la vez.

A diferencia del sistema operativo, Monitor no tenía soporte de sistema de archivos de ningún tipo. El operador humano fue responsable de encontrar la cinta correcta, colocarla en la grabadora y posicionarla al inicio del programa necesario para cargar.

Supervisó las funciones combinadas tanto del BIOS como del sistema operativo y ya era muy claramente un software.

Después de encender, la breve señal de "reinicio" simplemente ponía a cero el contador del programa igual que cualquier otro contador, al mismo tiempo que cambiaba el mapeador de memoria (si había alguno) para asignar la dirección 0000 a la ROM del monitor. Era común tener algún circuito de hardware para reasignar Monitor en el espacio de alta dirección más tarde. Además del inicio del código, el botón "Restablecer" también se usó para finalizar el programa en ejecución y poder cargar otro.

El botón de "reinicio" rudimentario se puede encontrar en algunas PC de escritorio, incluso en estos días.

El predecesor más directo del sistema operativo sería una combinación de bibliotecas estándar para interactuar con dispositivos, y el sistema de cargador de arranque para que un programa sea llevado a la memoria y comience a ejecutarse.