Salut à tous !

Voilà, une question de programmation système, pour changer !

J'ai besoin de mettre un processus au repos, et de l'activer quand la charge du CPU baisse, de façon à faire de la maintenance pendant les phases d'inactivité.

On m'a parlé de nice(), en mettant la priorité du processus à 20, comme ça il est actif après presque tout le monde quand c'est calme... Après essai, c'est pas terrible, le programme tourne normalement !
Mon prof m'a suggeré de trouver un moyen de mesurer la charge directement, et quand c'est calme faire le boulot. D'ou ma question: quelqu'un sait comment on fait ?

Edité par CMT ( 14/03/2007 17:06:45 )

Tu peux parser la sortie de la commande "uptime" pour connaitre la charge.

Si tu prends la dernière des trois valeurs, tu travailles avec une moyenne à plus long terme pour ne pas lancer puis couper le processus à tout vas.

Merci du tuyau Neliger !

Juste une autre question: comment je récupère ces valeurs ? Uptime n'est pas une fonction de la glibc, du coup je fait un "system("uptime")" mais je n'arrive pas à récupérer les valeures.

Lis la doc, il doit y avoir 36 moyen de récupérer la sortie d'une commande.

Merci ! J'ai trouvé comment faire...

N'oublie pas de poster ce que tu as trouvé ici, cela peux aider d'autres développeurs qui trouverons ce sujet à partir des moteurs de recherche

Sous linux, on peut trouver des mesures de charge du CPU dans le fichier : /proc/loadavg
Les 3 premiers nombres qu'il contient sont respectivement : le load sur
1 minute, le load sur 5 minutes, le load sur 15 minutes.

Sous Windows, on peut tout simplement régler la priorité de son programme de telle façon qu'il se mette en pause lorsque le système demande de la mémoire vive.

Pour cela on utilise l'api

Declare Function SetPriorityClass Lib "kernel32" (ByVal hProcess As Long, ByVal dwPriorityClass As Long) As Long

Hprocess est un pointeur sur le handle de l'application
dwPriorityClass est une constante parmi :
IDLE_PRIORITY_CLASS &H40 Priorité minimum.
BELOW_NORMAL_PRIORITY_CLASS &H4000 Priorité en dessous de normal.
NORMAL_PRIORITY_CLASS &H20 Priorité normale.
ABOVE_NORMAL_PRIORITY_CLASS &H8000 Priorité au dessus de normal.
HIGH_PRIORITY_CLASS &H80 Priorité haute.
REALTIME_PRIORITY_CLASS &H100 Priorité maximum (temps réel).

Attention cependant, avec une priorité temps réel, les entrées ne sont pas analysées..donc plus de clavier ni de souris.
Avec IDLE_PRIORITY_CLASS, ton processus ne tourne que si le système est quasiment inactif.


Edité par neamar ( 17/03/2007 10:24:41 )

Merci neamar mais ici on parle de GNU/Linux, et on a déjà évoqué le nice level qui gère également les priorités entre les processus sur ce noyau.

Bon, voilà comment je fais:

system("uptime > data.txt");

je lance une commande shell par la fonction system, en l'occurence uptime qui donne l'activité sur la dernière minute, les 5 dernières minutes, le dernier quart d'heure (uptime doit lire dans /proc/loadavg comme le suggerait Mazzu).
La sortie s'effectue normalemement dans le terminal, je l'envoie ici dans un fichier ( data.txt dans mon exemple) et ensuite par quelques manipulations de lecture dans un fichier (fseek et autres...) je lis les valeurs qui se trouvent en fin de ligne...

Voilà, et encore merci à tous !

[EDIT] Pour les vrai programmeurs qui sont trops puissant, y'a getloadavg aussi...

Edité par CMT ( 30/03/2007 15:12:33 )