Notas de estudio sobre "Introducción al sistema operativo" (1): Descripción general del sistema operativo

Esta serie de artículos son principalmente las notas de estudio de "Sistemas operativos: tres piezas fáciles" y su curso de apoyo CS-537 (Introducción a los sistemas operativos) de la Universidad de Wisconsin. Al mismo tiempo, se intercalarán algunos materiales fáciles de entender durante este período.

Resumen

La introducción del sistema operativo parte de la esencia de los tres sistemas operativos de diseño, como la virtualidad, la concurrencia y la persistencia, y se ejecuta a través de la gestión de procesos, la gestión de la memoria, la gestión de archivos y la gestión de E / S del sistema operativo tradicional.

	Virtualidad	Concurrencia	Persistencia
Gestión de procesos	Proceso, programación de CPU	Hilo, punto muerto, sincronización de procesos
Gestión de la memoria	Gestión de la memoria
Gestión de almacenamiento	Sistema de E / S		Sistema de archivos, gran almacenamiento

¿Por qué necesitas un sistema operativo?

El sistema informático puede dividirse aproximadamente en hardware informático, sistema operativo, sistema y software de aplicación de abajo hacia arriba. Los usuarios trabajan en la capa de software y usan Word, Matlab y otro software para lograr sus propios propósitos. Desde la perspectiva del hardware, la computadora es solo el proceso de recuperación, decodificación y ejecución de la CPU. Entonces, cómo conectar razonablemente el software de la aplicación con el hardware, esto requiere la introducción del software del sistema operativo como interfaz entre los dos.

La esencia del software del sistema operativo es un programa infinitamente cíclico. Después del arranque, continuará aceptando instrucciones del usuario hasta que el programa se vea obligado a cerrarse. macOS basados, Linux y otros sistemas, y las descargas common.htales como las cabeceras , que pueden simular el proceso de ejecución del sistema operativo:

// cpu.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <assert.h>
#include "common.h"

int main(int argc, char *argv[])  // argc 命令行参数个数
{								  // argv 命令行参数向量
  if (argc != 2) {
    fprintf(stderr, "usage: cpu <string>\n");
    exit(1);
  }

  char *str = argv[1];
  while (1) {
    Spin(1);
    printf("%s\n", str);
  }

  return 0;
}

Función Spin (): ubicada en common.h, hace que el intervalo de salida del programa
gcc -o ejecute el nombre del archivo nombre del archivo fuente: compile el archivo fuente
Muro: muestre todas las advertencias después de la compilación
Werror: procese todas las advertencias como errores y

ejecute el comando hola, Podemos encontrar que el programa continuará generando saludos hasta que se vea obligado a finalizar.

Ingrese algunos comandos más, el programa generará 3 comandos al mismo tiempo, de modo que el usuario tenga la ilusión de que varias CPU están ejecutando comandos al mismo tiempo. Esta es la virtualización de la CPU.

Virtualización

La virtualización es mapear una entidad física en varias contrapartes lógicas, y el método de implementación es multiplexación por división de tiempo y multiplexación por división de espacio. Podemos simular la virtualización de la memoria y obtener el número de proceso a través de getpid (), actualizar los datos con el puntero p y obtener la dirección de almacenamiento de datos.

// mem.c
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include "common.h"

int main(int argc, char *argv[])
{
  if (argc != 2) {
    fprintf(stderr, "usage: mem <value>\n");
    exit(1);
  }
  
  int *p = malloc(sizeof(int));
  assert(p != NULL);                         // getpid() 进程识别码   p 指向内存的指针
  printf("(pid:%d) addr of p:        %llx\n", (int)getpid(), (unsigned long long)p);
  printf("(pid:%d) addr stored in p: %llx\n", (int)getpid(), (unsigned long long)p);
  
  *p = atoi(argv[1]); // assign value to addr stored in p
  while (1) {
    Spin(1);
    *p = *p + 1;
    printf("(pid:%d) p: %d\n", getpid(), *p);
  }
 
  return 0;
}

En este momento, se ejecutan dos procesos en mi máquina, los números de proceso son 11984 y 11985, las direcciones de almacenamiento son 7fbf56c01720 y 7fb86cc01720, y aumentan en 1 cada vez de 1000 y 2000 respectivamente.

Concurrencia

La concurrencia es ejecutar múltiples procesos dentro del mismo intervalo de tiempo en la macro. El sistema operativo implementa procesos y subprocesos.

// threads.c
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include "common.h"

volatile int counter = 0;  // 本条指令不会因编译器的优化而省略，且要求每次直接读值。
int loops;

void *worker(void *arg) {  // 计数器
  int i;
  for (i = 0; i < loops; i++) {
    counter++;
  }
  return NULL;
}

int main(int argc, char *argv[]) {
  if (argc != 2) {
    fprintf(stderr, "usage: threads <value>\n");
    exit(1);
  }

  loops = atoi(argv[1]);
  pthread_t p1, p2;		// 声明线程id
  printf("Initial value : %d\n", counter);

  pthread_create(&p1, NULL, worker, NULL);
  pthread_create(&p2, NULL, worker, NULL);
  pthread_join(p1, NULL);
  pthread_join(p2, NULL);
  printf("Final value   : %d\n", counter);
  return 0;
}

pthread_create (): crea un hilo y ejecuta funciones de hilo relacionadas.
El primer parámetro es un puntero al identificador de hilo.
El segundo parámetro se usa para establecer los atributos del hilo.
El tercer parámetro es la dirección de inicio de la función de ejecución de subprocesos.
El último parámetro es el parámetro de la función de ejecución.

pthread_join (): Bloquea los recursos actuales de subproceso / reclamo de subproceso
. El primer parámetro es el identificador de subproceso. El
segundo parámetro es un puntero definido por el usuario que se utiliza para almacenar el valor de retorno del subproceso en espera.

El programa crea dos funciones de trabajador de contador de ejecución de subprocesos, el valor inicial es 0, los bucles de parámetros son 1000 y el resultado es 2000. Pero cuando el parámetro es grande, el resultado puede ser menor que el valor esperado. Esto se debe a que dos hilos del contador comparten el mismo contador, y dos hilos pueden tomar el contador y ejecutarlo al mismo tiempo. La solución es bloquear el contador, es decir, la operación PV.

pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;    // 全局信号量初始化
void *worker(void *arg) {
  int i;
  for (i = 0; i < loops; i++) {
    pthread_mutex_lock(&m);		// 上锁
    counter++;
    pthread_mutex_unlock(&m);	// 开锁
  }
  printf("%d\n", counter);
  pthread_exit(NULL);
}

Persistencia

La persistencia es guardar datos transitorios (como objetos en la memoria) en un dispositivo de almacenamiento (como un disco) que se puede guardar permanentemente.

// io.c
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <assert.h>
#include <fcntl.h>
#include <sys/types.h>

void dowork()
{
  int fd = open("/tmp/file", O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
  assert(fd >= 0);
  
  char buffer[20];
  sprintf(buffer, "hello world\n");
  int rc = write(fd, buffer, strlen(buffer));
  assert(rc == (strlen(buffer)));
  printf("wrote %d bytes\n", rc);
  
  fsync(fd);
  close(fd);
}
int main(int argc, char *argv[]) {
  dowork();
  return 0;
}

comando cat: ver el contenido del archivo

Concepto importante

Sistema operativo: controle y administre los recursos de hardware y software de todo el sistema informático, controle razonablemente el flujo de trabajo de la computadora y proporcione a los usuarios y otro software interfaces y entornos convenientes.

Concurrencia: durante un período de tiempo, hay varios programas ejecutándose al mismo tiempo en la macro, pero en un sistema de un solo procesador, solo se puede ejecutar un programa a la vez, por lo que estos programas solo se pueden ejecutar alternativamente de forma microscópica.
Paralelismo: dos o más eventos ocurren al mismo tiempo. En el nivel macro, la CPU y los dispositivos de E / S son paralelos. En el nivel micro, la CPU ejecuta múltiples instrucciones al mismo tiempo. Debe implementarse mediante la introducción de una tubería de etapas múltiples o procesadores de núcleos múltiples.

Uso compartido mutuamente exclusivo: solo un único proceso puede acceder a recursos críticos al mismo tiempo, y se introduce un mecanismo de sincronización.
Multiplexación por división de tiempo: cada proceso se turna para tomar una cantidad fija de tiempo de CPU y cambia rápidamente al siguiente proceso cuando se acaba el tiempo.
Multiplexación por división espacial: la memoria se divide en marcos de página de tamaño fijo, y cada proceso también se divide en páginas de tamaño fijo, que se asignan parcialmente a la memoria, y los algoritmos de reemplazo de página se utilizan para reemplazar páginas cuando faltan páginas.

Asincronía: el proceso no se completa de una vez, sino que se detiene y avanza a una velocidad impredecible.

Notas de estudio "Introducción al sistema operativo" (2): virtualización de la CPU (proceso)