¿Se pueden implementar subprocesos múltiples en un sistema de un solo procesador?

Siempre he seguido el concepto de que los subprocesos múltiples solo se pueden implementar en un sistema de múltiples procesadores donde hay más de un procesador para asignar a cada subproceso y cada subproceso se puede ejecutar simultáneamente. No hay programación en este caso ya que cada subproceso tiene recursos separados, todos dedicados a él. Pero recientemente leí en alguna parte que también puedo hacer subprocesos múltiples en un sistema de un solo procesador. ¿Es correcto? y en caso afirmativo, ¿cuál es la diferencia entre los sistemas de un solo procesador y de varios procesadores?

Por supuesto, se puede hacer en un sistema de un solo procesador y, de hecho, es mucho más fácil de esa manera. Funciona de la misma manera que ejecutar varios procesos: el kernel, a través de una interrupción del temporizador u otro mecanismo similar, suspende uno, guarda el estado de la máquina y lo reemplaza por el estado previamente guardado de otro; la única diferencia es que dos los subprocesos del mismo proceso comparten el mismo espacio de memoria virtual, lo que hace que el cambio de tareas sea mucho más eficiente.

En realidad, los subprocesos múltiples en sistemas con múltiples procesadores son mucho más difíciles, ya que tiene problemas de acceso simultáneo a la memoria desde múltiples CPU/núcleos, y todos los desagradables problemas de sincronización de memoria que surgen de eso.

Recientemente leí en alguna parte que también puedo hacer subprocesos múltiples en un sistema de un solo procesador. ¿Es correcto? y en caso afirmativo, ¿cuál es la diferencia entre los sistemas de un solo procesador y de varios procesadores?

Sí, puede hacer subprocesos múltiples en un sistema de un solo procesador.

En un sistema multiprocesador, se ejecutan múltiples subprocesos, simultaneamente en diferentes núcleos. Por ejemplo, si hay dos subprocesos y dos núcleos, cada subproceso se ejecutará en un núcleo individual.

En un sistema de un solo procesador, varios subprocesos se ejecutan, uno tras otro o esperan hasta que un subproceso finaliza o el sistema operativo lo reemplaza, según la prioridad del subproceso y la política del sistema operativo. Pero los subprocesos en ejecución dan la ilusión de que se ejecutan simultáneamente. , en relación con el tiempo de respuesta de la aplicación requerida de la aplicación de espacio de usuario.

Comparación de tiempo (ejemplo):

si dos subprocesos tardan 10 us cada uno en ejecutarse, entonces en un sistema de 2 procesadores, el tiempo neto es de 10 us

si dos subprocesos tardan 10 us cada uno en ejecutarse, entonces en un sistema de 1 procesador, el tiempo neto es de 20 us

Puede tener más de cuatro subprocesos activos en un sistema de cuatro núcleos. Ahí es programación, a menos que pueda garantizar que los procesos no intentarán crear más subprocesos que procesadores.

Sí, puede tener múltiples subprocesos en una computadora de un solo núcleo.

La diferencia entre los sistemas de un solo procesador y los de varios procesadores es que un sistema de varios procesadores puede hacer más de una cosa a la vez. Puede hacer N cosas a la vez, donde N es el número de núcleos del procesador. Un núcleo de un solo procesador solo puede hacer una cosa a la vez. Como dijo WhozCraig en su comentario, es la diferencia entre la concurrencia real y percibida.

Sí, totalmente puedes. Hace mucho tiempo (¿Win 95?) pasamos de multitarea cooperativa a subprocesos múltiples, porque alguien siempre estropeaba la parte cooperativa. Cada programa en su computadora tiene al menos un hilo. Posiblemente más. Y la CPU sigue cambiando entre todos esos subprocesos como un loco unos cuantos millones de veces por segundo. Si ninguno de ellos tiene nada que hacer, incluso podría quedarse inactivo durante algún tiempo.

Los sistemas multinúcleo solo significan que dos o más de esos subprocesos pueden ejecutarse en paralelo.

Sin embargo, te trae mucho menos hacerlo. Todo lo que puede hacer con Multithreading en una máquina de un solo núcleo es simular Multitarea.

La multitarea es suficiente para evitar que el subproceso de la GUI se bloquee debido a una operación de larga duración. Sin embargo, generalmente es complicado de implementar, a menos que tenga ayuda del Compilador o Langauge (como C# async… await). Como resultado, muchos programadores de GUI simplemente usaron Multithreading e Invoking para falsificar la multitarea. Si ese código se ejecuta en un núcleo único o múltiple, no importa para esto.

Lo que es más importante, la multitarea NO es adecuada para operaciones vinculadas a la CPU. Pero el 95% de todos los problemas de Async no están vinculados a la CPU. Son Network o Disk Bound. En una computadora de un solo núcleo, Multithreading tampoco ayuda con las cosas vinculadas a la CPU. Si tiene dos subprocesos que necesitan el 100 % del tiempo de CPU (el mismo programa o uno diferente) pero solo un núcleo para ejecutarlos, la CPU solo tendrá que cambiar entre ejecutar ambos al 49 % y usar el 2 % restante para todos esos otros hilos que solo hacen un poco.

Finalmente, solo muy pocos problemas pueden ser multiproceso. Simplemente intente realizar varios subprocesos en la secuencia de Fibonacci (un subproceso para cada par) sin hacerlo más lento, más exigente en cuanto a memoria y más complejo.

tl;dr; Necesita subprocesos múltiples y una computadora multinúcleo para problemas vinculados a la CPU. La mayoría de los problemas asíncronos no están vinculados a la CPU. La multitarea es suficiente. Y puede realizar varias tareas a la vez utilizando subprocesos, incluso en una máquina de un solo núcleo.

He aquí un ejemplo muy simplificado. En realidad es un prototipo de un programa que estoy construyendo. Es una implementación de multitarea cooperativa en un solo hilo.

main simplemente establece el quit marca a falso, y llena una matriz de punteros de función (las tareas), y luego llama loop.

loop usos setjmp para establecer un punto de retorno para un salto no local (un salto fuera de la función a una ubicación anterior en la ejecución) y luego procede a llamar a la primera tarea (función).

Cada tarea termina con yield(). Es decir, ninguna de las funciones de la tarea en realidad return. No solo no contienen un return; declaración (que estaría bien ya que son void funciones, es decir. procedimientos), pero no llegarían al return incluso si estaba allí porque yield salta de nuevo a la setjmp llamar, esta vez dando un 1 a la if declaración en loop. La declaración controlada por el if declaración selecciona una tarea diferente antes de volver a entrar en el while lazo.

Así que cada función de tarea se ejecuta varias veces, dando lugar a la despachador (los if(setjmp... declaración) que selecciona una nueva tarea para ejecutar.

#include <stdio.h> 
#include <setjmp.h> 

jmp_buf dispatch; 
int ntasks; 
void (*task[10])(void); 
int quit; 

void yield(void) { 
    longjmp(dispatch, 1); 
} 

void loop() { 
    static int i = 0; 
    if(setjmp(dispatch)) 
        i = (i+1) % ntasks; 
    while(!quit) 
        task[i](); 
} 

int acc = 0; 

void a(void) { 
    if (acc > 10) quit = 1; 
    printf("A\n"); 
    yield(); 
} 
void b(void) { 
    acc *= 2; 
    printf("B\n"); 
    yield(); 
} 
void c(void) { 
    acc += 1; 
    printf("C\n"); 
    yield(); 
} 

int main() { 
    quit = 0; 
    ntasks = 3; 
    task[0] = a; 
    task[1] = b; 
    task[2] = c; 
    loop(); 
    return 0; 
} 

La diferencia entre este ejemplo y un sistema informático multitarea de un solo procesador es que el procesador real admite la interrupción de una tarea en medio de la ejecución y la reanuda más tarde desde el mismo lugar. Esto no es realmente posible en una simulación C con tareas como funciones individuales. Sin embargo, las tareas podrían estar compuestas por una secuencia de funciones C, cada una de las cuales cede al despachador (una matriz de punteros de función, tal vez, o una lista enlazada).

En un proceso de subprocesos múltiples en un solo procesador, el procesador puede cambiar los recursos de ejecución entre subprocesos, lo que da como resultado una ejecución simultánea. La simultaneidad indica que más de un subproceso está progresando, pero en realidad los subprocesos no se ejecutan simultáneamente. El cambio entre subprocesos ocurre lo suficientemente rápido como para que parezca que los subprocesos se ejecutan simultáneamente.

En el mismo proceso de subprocesos múltiples en un entorno de multiprocesador de memoria compartida, cada subproceso del proceso puede ejecutarse simultáneamente en un procesador independiente, lo que da como resultado una ejecución paralela, que es una verdadera ejecución simultánea. Cuando la cantidad de subprocesos en un proceso es menor o igual que la cantidad de procesadores disponibles, el sistema de soporte de subprocesos del sistema operativo garantiza que cada subproceso se ejecute en un procesador diferente. Por ejemplo, en una multiplicación de matrices que está programada con cuatro subprocesos y se ejecuta en un sistema que tiene dos procesadores de doble núcleo, cada subproceso de software puede ejecutarse simultáneamente en los cuatro núcleos del procesador para calcular una fila del resultado al mismo tiempo.