Solución:
Hay una tarea especial llamada tarea inactiva que se ejecuta cuando no se puede ejecutar ninguna otra tarea. El% de uso es solo el porcentaje de tiempo que no estamos ejecutando la tarea inactiva. El sistema operativo mantendrá un total acumulado del tiempo dedicado a ejecutar la tarea inactiva:
- cuando cambiamos a la tarea inactiva, establecemos t = hora actual
- cuando nos alejamos de la tarea inactiva, agregamos (hora actual – t) al total acumulado
Si tomamos dos muestras del total de ejecución con n segundos de diferencia, podemos calcular el porcentaje de esos n segundos dedicados a la ejecución de la tarea inactiva como (segunda muestra – primera muestra) / n
Tenga en cuenta que esto es algo que hace el sistema operativo, no la CPU. ¡El concepto de tarea no existe a nivel de CPU! (En la práctica, la tarea inactiva pondrá el procesador en suspensión con una instrucción HLT, de modo que la CPU sepa cuándo no se está utilizando)
En cuanto a la segunda pregunta, los sistemas operativos modernos son multitarea preventivamente, lo que significa que el sistema operativo puede cambiar de su tarea en cualquier momento. ¿Cómo el sistema operativo realmente roba la CPU de su tarea? Interrupciones: http://en.wikipedia.org/wiki/Interrupt
La CPU no hace los cálculos de uso por sí misma. Puede tener características de hardware para facilitar esa tarea, pero es principalmente el trabajo del sistema operativo. Entonces, obviamente, los detalles de las implementaciones variarán (especialmente en el caso de sistemas multinúcleo).
La idea general es ver qué tan larga es la cola de cosas que la CPU necesita hacer. El sistema operativo puede echar un vistazo al programador periódicamente para determinar la cantidad de cosas que tiene que hacer.
Esta es una función de Linux en (extraída de Wikipedia) que realiza dicho cálculo:
#define FSHIFT 11 /* nr of bits of precision */
#define FIXED_1 (1<<FSHIFT) /* 1.0 as fixed-point */
#define LOAD_FREQ (5*HZ) /* 5 sec intervals */
#define EXP_1 1884 /* 1/exp(5sec/1min) as fixed-point */
#define EXP_5 2014 /* 1/exp(5sec/5min) */
#define EXP_15 2037 /* 1/exp(5sec/15min) */
#define CALC_LOAD(load,exp,n)
load *= exp;
load += n*(FIXED_1-exp);
load >>= FSHIFT;
unsigned long avenrun[3];
static inline void calc_load(unsigned long ticks)
{
unsigned long active_tasks; /* fixed-point */
static int count = LOAD_FREQ;
count -= ticks;
if (count < 0) {
count += LOAD_FREQ;
active_tasks = count_active_tasks();
CALC_LOAD(avenrun[0], EXP_1, active_tasks);
CALC_LOAD(avenrun[1], EXP_5, active_tasks);
CALC_LOAD(avenrun[2], EXP_15, active_tasks);
}
}
En cuanto a la segunda parte de su pregunta, la mayoría de los sistemas operativos modernos son multitarea. Eso significa que el sistema operativo no permitirá que los programas ocupen todo el tiempo de procesamiento y que no tengan nada para sí mismos (a menos que usted lo obligue a hacerlo). En otras palabras, incluso si una aplicación parece bloqueada, el sistema operativo puede todavía robar algo de tiempo para su propio trabajo.
Para obtener el uso de la CPU, pruebe periódicamente total procesar el tiempo y encontrar la diferencia.
Por ejemplo, si estos son los tiempos de CPU para el proceso 1:
kernel: 1:00:00.0000
user: 9:00:00.0000
Y luego los obtienes nuevamente dos segundos después, y son:
kernel: 1:00:00.0300
user: 9:00:00.6100
Restas los tiempos del kernel (para una diferencia de 0.03) y los tiempos del usuario (0.61), agréguelos (0.64) y dividir por el tiempo de muestra de 2 segundos (0.32).
Entonces, durante los últimos dos segundos, el proceso usó un promedio del 32% del tiempo de CPU.
Las llamadas al sistema específicas necesarias para obtener esta información son (obviamente) diferentes en cada plataforma. En Windows, puede usar GetProcessTimes o GetSystemTimes si desea un acceso directo a total tiempo de CPU usado o inactivo.