C++ boucle While, usleep()/sleep() ne pas utiliser de 90% du CPU? (Ubuntu 12.04)
Supposons que j'ai un code C++ comme
#include "myheaderfiles.h"
//..some stuff
//...some more stuff
int main()
{
double milliseconds;
int seconds;
int minutes;
int timelimit=2;
...
...
//...code here that increments
//.....milliseconds,seconds, and minutes
while(minutes <=timelimit)
{
//...do stuff
if(milliseconds>500)
{
//...do stuff
//...every half second
} //end if
} //end while
}//end main
Le programme fonctionnent très bien et fait ce que son supposé le faire, mais il va utiliser jusqu'à 90%+ de mon cpu.
Il m'a été suggéré d'utiliser usleep() dans ma boucle while jamais 100ms depuis que j'ai vraiment ne se soucient de faire des trucs tous les 500ms de toute façon. De cette façon, il monopolisent le CPU lorsqu'il n'est pas nécessaire.
Donc je l'ai ajouté à ma boucle while comme
while(minutes <=timelimit)
{
//...do stuff
if(milliseconds>500)
{
//...do stuff
//...every half second
} //end if
usleep(100000);
} //end while
Il compile bien, mais quand je le lance, le programme va se bloquer droit à usleep et ne jamais revenir. J'ai lu quelque part qu'avant d'appeler usleep, on a besoin de vider tous les tampons, j'ai donc vidé tous les flux de fichiers et les couts etc etc. Toujours pas de chance.
J'ai cherché pendant 2 jours pour trouver une solution. J'ai utilisé sleep() aussi, avec pas de chance.
J'ai trouvé quelques solutions de rechange, mais ils semblent compliquées et va ajouter une grande quantité de code de mon programme que je n'ai pas vraiment de comprendre pleinement ce qui va compliquer et de le rendre sale, plus il pourrait ne pas fonctionner.
Je n'ai jamais vraiment mettre trop de pensée dans mon while() boucles avant parce que la plupart des programmes que j'écrivais étaient pour les microcontrôleurs ou des Fpga qui n'est pas un problème de porc le processeur.
Si quelqu'un peut aider.... des ressources, des liens,des livres? Merci.
Pouvez-vous montrer votre boucle while (). Il pourrait y avoir de nombreuses raisons pour cela, et ce qui est connu comme boucle occupée de problème. usleep() n'entraînerait pas de se bloquer. Il y a autre chose de mal dans votre code.
Je me demandais -- est-il quelque chose à faire pour le programme ou est-ce juste les bras croisés interrogation quelque part? Si il y a quelque chose à faire, que de le faire plus vite ne fait pas de mal (sous unix ou windows, on pourrait baisser les prio). Si vous êtes d'interrogation, peut-être il ya un événement piloté par la solution?
pourquoi ne pas vous venez de vous inscrire pour avoir une minuterie de réveil et de vous appeler toutes les demi-secondes si c'est ce que vous voulez? cela ne semble pas être la bonne solution pour commencer. êtes-vous sûr que c'est accroché à usleep? peut-être que vous n'êtes pas d'incrémentation de "millisecondes" correctement.
utilisez-vous du signal dans votre programme, par hasard?
OriginalL'auteur user3474042 | 2014-04-11
Vous devez vous connecter pour publier un commentaire.
Votre approche assez provient de la mauvaise fin. Un programme devrait consomme de 90 à 100% de CPU tant qu'il a quelque chose d'utile à faire (et il doit bloquer autrement, consommer zéro du PROCESSEUR).
Dormir dans entre va entraîner l'exécution étant de plus pour aucune bonne raison, et consomment plus d'énergie que de simplement faire le travail aussi vite que possible (à 100% de CPU), puis bloquer complètement jusqu'à ce que plus de travail est disponible ou jusqu'à ce qu'une autre chose importante (par exemple, une demi-seconde, a passé, si ce qui compte pour vous) arrive.
Avec cela à l'esprit, de la structure de votre programme de manière conceptuellement comme:
Aussi, de ne pas dormir pendant l'exécution, mais l'utilisation des chronomètres (par exemple
setitimer
) à faire quelque chose à intervalle régulier. Ce ne sera pas seulement plus efficace, mais aussi beaucoup plus précis et fiable.Exactement comment implémenter cela dépend de combien de portable, vous voulez que votre logiciel. Sous Ubuntu/Linux, vous pouvez par exemple utiliser des Api comme
epoll_wait
aveceventfd
plutôt que d'écrire un gestionnaire de signal de la minuterie.OriginalL'auteur Damon
Ce code fonctionne comme prévu pour moi (fonctionne sur OSX).
OriginalL'auteur Buddy
Il y a un problème de logique ou peut-être vous êtes à la prise de plusieurs compteurs? Puisque vous avez dit que vous avez fait des microcontrôleurs, je suppose que vous essayez d'utiliser l'horloge-cycles en tant que méthode de comptage tout en appelant le système timers? Aussi, ce qui m'a le questionnement est si vous êtes recommandé d'utiliser usleep(x), pourquoi êtes-vous en utilisant le double pour la milliseconde? usleep(1) est de 1 microseconde == 1000 millisecondes. Le sommeil(x) est un compteur par x seconde, de sorte que le système va suspendre la tâche en cours pour un montant de x secondes.
Si vous souhaitez utiliser 500ms puis remplacer usleep(DEUXIÈME) avec usleep(500*ordre de la MILLISECONDE).
Je vous suggère d'utiliser un débogueur et pas à travers votre code pour voir ce qui se passe.
OriginalL'auteur Tony