tipos - ¿Cómo se implementa el sueño a nivel de SO?
trastornos del sueño pdf (6)
En un sistema operativo típico, las llamadas de reposo en el kernel, que establecen el proceso para que espere hasta que transcurra el tiempo especificado, y luego van y encuentran algún otro proceso para ejecutar. A falta de algo mejor que hacer, se ejecutará el ''proceso inactivo''. Una vez que transcurre el tiempo, el programador notará que el proceso de suspensión está en marcha y lo programará nuevamente.
Solo me interesa cómo se implementa la sleep(time in ms) en una biblioteca de C o básicamente a nivel del sistema operativo ...
Estoy adivinando...
- Puede ser el basado en la velocidad del procesador que hace un bucle while de nop''s (no estoy seguro si el tiempo de sueño será exacto) ...
- Cualquier registro especial en el procesador, donde se escribe algo de valor y el procesador simplemente se detiene por un tiempo específico (esto sería muy ineficiente ya que el procesador no puede ejecutar incluso otros programas).
¿Alguna pista? Probablemente el código fuente de la biblioteca C puede explicar? No soy demasiado particular acerca de cómo "C" lo está implementando ... Me pregunto en general cómo se implementa la función "sleep ()".
La respuesta a su pregunta es completamente dependiente del sistema operativo y de la implementación.
Una forma sencilla de pensar en ello: cuando llama a la sleep() , el sistema operativo calcula la hora de activación y, a continuación, pega el proceso en una cola de prioridad en algún lugar. Entonces, simplemente no programa su proceso para obtener tiempo de ejecución hasta que haya pasado suficiente tiempo real para que salga de la cola.
La suspensión bloquea su tarea / hilo para el valor de tiempo pasado. Su tarea no se puede ejecutar durante ese período o hasta que ocurra algo interesante (como una señal), lo que ocurra primero.
No es raro que el modo de espera llame a select () y no pase ningún descriptor para esperar y un valor de tiempo de espera igual a su período de espera.
El sistema puede implementar esto configurando un temporizador para que caduque después del tiempo transcurrido y luego esperando en un semáforo que será señalado cuando el temporizador expire. Así queda bloqueado en ese semáforo.
Usted no hace ningún bucle de tiempo, de lo contrario el sistema no podrá hacer nada, no responder al mouse, el teclado, la red, etc.
Por lo general, lo que la mayoría de los sistemas operativos hacen es agregar el retraso a la marca de tiempo actual para obtener la marca de tiempo cuando se reanudará la tarea que solicitó el retraso (asumiendo que no se está ejecutando una tarea de mayor prioridad en ese momento) y agregar el [wakeupTimestamp, puntero de la tarea ] a una lista que está ordenada por ascendente por la marca de tiempo. Después de eso, el sistema operativo realiza un cambio de contexto y ejecuta la siguiente tarea disponible. Periódicamente, el sistema compara la marca de tiempo más antigua en la lista de sueño con la marca de tiempo actual, y si la fecha límite ha pasado, mueve la tarea de reposo a la cola de tareas "lista".
uso de la CPU: 0%
requisitos:
create_gate (configurar los controladores de IRQ)
pic_mask_clear (Habilitar interrupciones específicas)
rtc_poll (configurar RTC)
rtc_irq
smp_wake_up
; In/ RAX = Time in millisecond
; Out/ All registers preserved
sleep:
push rcx
push rax
mov rcx, [rtc_irq.up_time]
add rax, rcx
.os_delay_loop:
hlt
cmp qword [rtc_irq.up_time], rax
jle .os_delay_loop
pop rax
pop rcx
ret
smp_wake_up
; In/ Nothing
; Out/ Nohting
smp_wakeup_all:
push rdi
push rax
mov rdi, [os_LocalAPICAddress]
xor eax, eax
mov [rdi+0x0310], eax ; Write to the high bits first
mov eax, 0x000C0080 ; Execute interrupt 0x80
mov [rdi+0x0300], eax ; Then write to the low bits
pop rax
pop rdi
ret
rtc_irq:
; UIP (0), [email protected] (010), Rate@1024Hz (0110)
; In/ Nothing
; Out/ Nothing
rtc_irq:
inc qword[.up_time]
call smp_wakup_all
ret
.up_time: dq 0
uso:
mov rax, 1000 (millisecond)
call sleep
está bien
Sleep() se implementa a nivel del sistema operativo. El procesador no gira cuando una tarea / hilo / proceso está durmiendo. Ese subproceso en particular se coloca en una cola pendiente (el subproceso no está listo para ejecutarse) hasta que el tiempo haya expirado, momento en el que el subproceso se colocará en la lista para ejecutarse en la cola.
Mientras tanto, se ejecutarán otros subprocesos que están listos para ejecutarse.
Solo si no hay subprocesos listos para ejecutarse, el sistema operativo entrará en el subproceso inactivo, que generalmente emite instrucciones para apagar (o poner en estado de baja potencia) el procesador hasta que se produzca una interrupción de hardware.
Solo para un sistema muy simple (como el más simple de los sistemas integrados), Sleep() podría implementarse como nada más que un ciclo de espera ocupado.
Cualquier libro de texto de sistemas operativos, como "Modern Operating Systems" de Tanenbaum cubrirá esto con gran detalle, casi cualquiera de ellos (incluso uno antiguo, barato, usado).