Comment puis-je vérifier combien de temps un processus passe-t-il à attendre le processeur dans une machine Linux? Par exemple, dans un système chargé, je veux vérifier la durée d'attente d'un processus SQL*Loader (sqlldr).Contention du processeur (temps d'attente) pour un processus sous Linux
Il serait utile s'il y a un outil de ligne de commande pour faire ceci.
J'ai rapidement giflé ça ensemble. Il imprime les «interférences» les plus petites et les plus grandes du changement de tâche ...
#include <sys/time.h>
#include <stdio.h>
double seconds()
{
timeval t;
gettimeofday(&t, NULL);
return t.tv_sec + t.tv_usec/1000000.0;
}
int main()
{
double min = 999999999, max = 0;
while (true)
{
double c = -(seconds() - seconds());
if (c < min)
{
min = c;
printf("%f\n", c);
fflush(stdout);
}
if (c > max)
{
max = c;
printf("%f\n", c);
fflush(stdout);
}
}
return 0;
}
Voici comment vous devriez procéder pour le mesurer. Avoir un certain nombre de processus, supérieur au nombre de vos processors * cores * threading capability attendre (bloquer) sur un événement qui va les réveiller tous en même temps. Un tel événement est un paquet de réseau de multidiffusion. Utilisez une bibliothèque d'instrumentation telle que PAPI (ou une autre adaptée à vos besoins) pour mesurer les différences de temps de «réveil» réel et virtuel entre vos processus. À partir de plusieurs itérations de l'expérience, vous pouvez obtenir une estimation du temps de contention du processeur pour vos processus. Évidemment, cela ne va pas du tout être parfait pour les processeurs multicœurs, mais peut-être que cela vous aidera.
Cheers.
J'ai eu ce problème il y a quelque temps. Je fini par utiliser getrusage: Vous pouvez obtenir une aide détaillée à: http://www.opengroup.org/onlinepubs/009695399/functions/getrusage.html
getrusage renseigne le struct rusage.
mesure temps d'attente avec getrusage
Vous pouvez appeler getrusage au début de votre code, puis appeler à nouveau à la fin, ou à un moment approprié pendant l'exécution. Vous avez alors initial_rusage et final_rusage. Le temps passé par votre processus est indiqué par rusage-> ru_utime.tv_sec et le temps système passé par le processus est indiqué par rusage-> ru_stime.tv_sec.
Ainsi le total utilisateur le temps passé par le processus sera: user_time = final_rusage.ru_utime.tv_sec - initial_rusage.ru_utime.tv_sec
Le total du système temps passé par le processus sera: system_time = final_rusage.ru_stime.tv_sec - initial_rusage.ru_stime.tv_sec
Si TOTAL_TIME est le temps écoulé entre les deux appels de getrusage alors le temps d'attente sera wait_time = TOTAL_TIME - (user_time + system_time)
Hope this il lps
Ce que vous mesurez est la latence de planification, pas la latence de contention. –
J'ai manqué la partie "Je veux vérifier combien de temps un processus sqlldr attend". Mon test montre combien de temps il ne passe pas avec le cpu. Ps -elF indique le temps de calcul total passé par le processeur. Je me demande si quelque chose de plus précis est dans/proc/ /. Vous pouvez prendre un instantané, exécuter une longue requête et la vérifier à nouveau. Le montant non dépensé avec le processeur est le temps passé moins le temps passé passé passé avec CPU, quelque chose comme ça. –
Mike