Salut, salut,

J'avance tranquilou dans ce que je souhaite faire et j'ai un léger soucis (j'ai du mal à le comprendre d'ailleurs, j'ai jamais vue ça)... en gros

Cas 1 : Utilisation Proc 25%
while(1){
MaFonction2();
MaFonction1();
}

Cas 2 : Utilisation Proc 0-4%
while(1){
MaFonction2();
Mafonction1();
cout<<"test";
}

Comment le proc utilisé 25% sans cout et passez a 0-3% avec un cout ?!

s'il n'y a pas de cout le proc tourne a 25%, s'il y a un cout dans la boucle : 2/3% <_<

vous avez une idée ?! je n'avais jamais vue ça

Parce que si tu mesures le nombre de fois que ta boucle tourne pour un temps T, tu verras que dans le cas 1 c'est énormément plus.

Pendant toute la durée du cout le thread fait quasiment plus qu'attendre qu'on lui rende la main ce qui fait logiquement diminuer sa charge processeur.

Ok, j'ai compris, donc pour règler le problème, je doit mettre sleep ou autre pour endormir X temps le "thread" ? (comment t'as su que j'utilisai des threads, j'en ai pas parler ? ^^' le topic du dessous ?)

Non, un processus contient au minimum un thread. C'est pas parce qu'on fait pas du "multithread" dans un processus que les threads n'existent pas.

"Ok, j'ai compris, donc pour règler le problème, je doit mettre sleep ou autre pour endormir X temps le "thread" ? (comment t'as su que j'utilisai des threads, j'en ai pas parler ? ^^' le topic du dessous ?) "

Pour régler quel problème ? Avec un sleep, tu vas juste ralentir encore ton thread (qui sera probablement à 0% à ce momement là, même s'il continuera à travailler). Le "problème" que tu vois est que faire des entrée sortie par tout petit morceau est une opération très lente (car dans le cas de cout, ce que tu demande à être affiché est tout de suite affiché et non pas mis en attente). Le "solution" consiste à ne pas appeler cout dans chaque tour de boucle, mais à le faire à la fin d'un seul coup avec tout le résultat (et pas cout qui est bien très lent). Ou à ne l'appeler que une fois toutes les cinquante itérations par exemple.

Bah... cout c'est juste un exemple pour expliquer... dans mon "programme", il n'y a pas de cout

et le "problème" c'est que sa me pompe 25% (pas + pas -) en permanence pour une simple boucle et une simple fonction... (il y en aura bien plus dans a la fin du projet) et bon, 25% pour un simple while(1) qui appelle une fonction qui vérifie si les X et Y correponds cay lourd (exemple pour X et Y)

Tu t'attendrais à quoi? Tant que ton CPU a de la ressource il exécutera ta boucle aussi vite et autant de fois que possible. Ca a pas besoin d'être des instructions sophistiquées si elles se produisent 100'000 fois par seconde.

Pour une boucle de ce type, 25% c'est plutôt peu. Est-ce qu'il y a quelque chose qui prend les 75% restant ? Sinon, tu t'attend à ce que lorsque c'est possible, ton programme prenne 100% de ton CPU, aussi con soit-il. Si ce n'est pas le cas c'est qu'il y a des latences quelque part (entrée-sortie, erreur de cache, ...) que tu devrais tenter de résoudre.

Non, il y a rien d'autre, au total je doit utilisé 28% du proc avec mon prog + le reste de mon programme

je pense que le 25% est dû à mon processeur c'est un QuadCore et sa me pompe 1 core vue que c'est à 25%

J'ai ajouter 2 autres boucles infini pour voir se que sa donne et avec 2 boucles sa reste à 25%, avec 3 boucles sa monte a 50% (j'utilise des threads tout s'execute en même temps)(cay marrant, sa ferait quoi avec 50 boucles ? )

j'irais essayer ce soir sur mon autre pc qui un Celeron D

Oui mais c'est un très mauvais indicateur pour savoir si le code est performant ou même raisonnable...

C'est rarement totalement justifié de faire un while(true).

mais si regarde:
<em>while (true)</em>

• bruit de circuits cramés*

bah le while est justifié

c'est un code qui doit tourné en boucle sans interruption :D et donc, voilà quoi :D

a moins de me sortir autre chose qu'une while(1) qui puisse faire tournée en boucle mon code

ce que veut dire _skip, c'est qu'a un moment le programme est cense s'arreter. Quand il n'y a plus de donnees a traiter, quand l'utilisateur ferme l'application, quand l'administrateur arrete le service... un programme a une fin. Donc une boucle infini c'est moche parce qu'il y a toujours une condition de fin de boucle.

Parfois les gens prefere ecrire qqch du genre:

while (1)
{
//some code
if (weirdcondition()) break;
//some other code
}

mais ca reste assez moche un:
bool cont = true;
while (cont)
{
//some code
if (weirdcondition()) cont=false;
else
//some other code
}

Fait exactement la meme chose et n'expose pas de boucle infini. Cela rends le code plus facil a lire.

Je tiens à signaler qu'il existe des programmes qui justement ne sont pas censés s'arrêter, genre le noyau d'un système d'exploitation.

init 0 ...

Évidemment si tu programme tourne sur un quadcore, une boucle infini prendra 25% du CPU, on aurait pu deviner. Ce qui est étonnant c'est que deux boucles n'en prenne pas déjà 50% tu dois avoir un problème à ce niveau là. Par contre, évidemment, à 50 threads, tu ne dépassera pas 100% de CPU, mais par contre, chaque boucle ira beaucoup moins vite.

Ca depend d'un paquet de trucs, des mutex, des priorités, de l'OS, du compilateur et du type de traitement.

Ce qu'il faut surtout savoir c'est si dans cette situation ton truc tient la route, et franchement si tu vérifies une égalité 200'000 fois par seconde dans une boucle infinie, j'ai quelques doutes.