augmenter Charge CPU

Bonjour

Je souhaite réaliser une fonction me permettant de charger plus ou moins mon processeur, en fonction d'un coefficient.
Que puis je utiliser comme fonction, ou écrire comme boucle ou pièce de code pour charger plus ou moins l’exécution de mon programme ?
Je sais récupérer mes coefficients dans un fichier (coefficient de 1 à 100 par exemple, mais ca peut changer), mais je ne sais pas bien quelle fonction ecrire pour charger le traitement.

Merci d'avance

Tu souhaiterais par exemple qu'en lisant le coefficient 2 / 20 / 42, tu lances une fonction qui occupe 2% / 20% / 42% de ton CPU ?

Citation:

Envoyé par iron_man53

mais je ne sais pas bien quelle fonction ecrire pour charger le traitement.

N'importe quelle fonction de calcul pur charge un CPU à 100%. Pour avoir moins de 100%, il suffit d'intercaler des périodes d'attente où la charge sera de 0%. Le rapport entre les deux te permettra de faire varier la charge moyenne entre 1 et 100%.

Citation:

Envoyé par Bktero

Tu souhaiterais par exemple qu'en lisant le coefficient 2 / 20 / 42, tu lances une fonction qui occupe 2% / 20% / 42% de ton CPU ?

Oui, c'est exactement ca... mais je ne vois pas trop comment faire.
Car bon, l'execution d'une fonction est tres rapide.... je voudrais pouvoir charger par exemple à 20% mon CPU pendant 3secondes...

Citation:

Envoyé par jlliagre

N'importe quelle fonction de calcul pur charge un CPU à 100%. Pour avoir moins de 100%, il suffit d'intercaler des périodes d'attente où la charge sera de 0%. Le rapport entre les deux te permettra de faire varier la charge moyenne entre 1 et 100%.

Je ne pige pas bien.
Tu me conseilles de faire des boucles qui alternent les temps d'attentes et les temps de calcul ?

Oui, il n'y pas vraiment d'alternative. A un instant donné, un CPU est soit utilisé à 100%, soit utilisé à 0%. Si tu veux autre chose, c'est une moyenne.

Donc, pas exemple, si je prends un tri par insertion d'un tableau de N élément...
On va dire que ca fait N*N opérations.
Code:

1 2 3 4 5 6 7 8 9 10 void tri_insertion(int tab[], int taille) { int i, j; for (i = 1; i < taille; ++i) { int elem = tab[i]; for (j = i; j > 0 && tab[j-1] > elem; j--) tab[j] = tab[j-1]; tab[j] = elem; } }
Si je lis dans mon fichier un paramètre de taille de tableau... je vais augmenter la durée de mon occupation CPU.
Et si , à l'endroit ou je met "boucle attente" il y a une tempo plus ou moins longue en fonction d'un autre coef lu (un usleep?)...je fais baisser ma charge moyenne ? C ca ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 void tri_insertion(int tab[], int taille) { int i, j; for (i = 1; i < taille; ++i) { int elem = tab[i]; for (j = i; j > 0 && tab[j-1] > elem; j--) tab[j] = tab[j-1]; tab[j] = elem; } /* boucle attente */ usleep(1000); /* faire varier ici le temps d'attente pour baisser la charge */ }

Oui mais autant faire :
Code:

1 2 3 4 5 6 while(...)//tant qu'on ne sort pas { if(...) //si on temporise //on s'endors }
C'est plus rapide et plus propre si tu veut contrôler la charge moyenne de ton CPU.

Citation:

Envoyé par iron_man53

Donc, pas exemple, si je prends un tri par insertion d'un tableau de N élément...

Ca n'apporte rien de prendre un code de calcul particulier. Incrémenter une variable indéfiniment est plus simple et tout aussi efficace.

Citation:

Si je lis dans mon fichier un paramètre de taille de tableau... je vais augmenter la durée de mon occupation CPU.

Oui, mais c'est très empirique. Utilise plutôt des timers pour fixer la durée d'occupation CPU.

Citation:

Et si , à l'endroit ou je met "boucle attente" il y a une tempo plus ou moins longue en fonction d'un autre coef lu (un usleep?)...je fais baisser ma charge moyenne ? C ca ?

C'est çà. L'idéal serait de mesurer régulièrement la charge CPU effective du processus courant et d'ajuster automatiquement la durée de temporisation pour arriver au taux de charge souhaité.

Si tu as une question pose-là plutôt ici que par mp.

Je vais à ta demande détailler ce que je te propose :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 int k; while(...) //on met ici la condition d'arrêt de la boucle = condition de sortie de ton programme { int x = getChargeCPU(); //on récupère la charge du CPU (cette fonction n'est là qu'à titre d'exemple, elle n'existe pas) if(x > k) //si la charge moyen du CPU est supérieur à la valeur maximale que tu souhaites { int z = (x - k)*5; //on calcule le temps qu'il faudrait dormir (ce n'est qu'un exemple usleep(z); //on dort } }
Ainsi tant que tu n'as pas atteins la valeur que tu souhaites, tu continus de faire des tours de boucles donc tu utilise le CPU. Dès que tu dépasse cette valeur, tu t'endors pour la faire rebaisser.

Citation:
Envoyé par Neckara
Si tu as une question pose-là plutôt ici que par mp.

Je vais à ta demande détailler ce que je te propose :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 int k; while(...) //on met ici la condition d'arrêt de la boucle = condition de sortie de ton programme { int x = getChargeCPU(); //on récupère la charge du CPU (cette fonction n'est là qu'à titre d'exemple, elle n'existe pas) if(x > k) //si la charge moyen du CPU est supérieur à la valeur maximale que tu souhaites { int z = (x - k)*5; //on calcule le temps qu'il faudrait dormir (ce n'est qu'un exemple usleep(z); //on dort } }
Ainsi tant que tu n'as pas atteins la valeur que tu souhaites, tu continus de faire des tours de boucles donc tu utilise le CPU. Dès que tu dépasse cette valeur, tu t'endors pour la faire rebaisser.
Oui, en fait, c'est ce que je visualise mal... le fait qu'il soit juste utile de faire une boucle qui ne fait rien pour charger le CPU à 100%

Citation:

Envoyé par iron_man53

Oui, en fait, c'est ce que je visualise mal... le fait qu'il soit juste utile de faire une boucle qui ne fait rien pour charger le CPU à 100%

La boucle ne fait pas rien, elle appelle une fonction qui mesure la charge CPU et fait aussi au moins un test, s'il n'y a pas d'I/O dans la fonction de mesure, la charge est de 100%.

Si la boucle était vide, elle chargerait tout autant le CPU, le simple fait de boucler indéfiniment charge un CPU à 100%.

Le problème vient de la fonction qui mesure la charge CPU. On ne lui laisse pas le temps d'échantillonner sufisamment de temps pour qu'elle retourne autre chose que 100%, il faut donc une fonction qui mesure la charge moyenne sur une période de temps glissante relativement "longue" pour que ce soit pertinent.

De plus, il faudrait savoir si tu souhaites intégrer ou pas à la charge générée celle provenant des autres processus en cours d'exécution.

Enfin, le cas des CPU multi-core ou des machines à plusieurs CPU doit aussi être envisagé.