consommation 80% du cpu - D'où ca vient ?

consommation 80% du cpu - D'où ca vient ? - C++ - Programmation

Marsh Posté le 15-03-2012 à 17:50:09    

Bonjour à tous,
Je me lance dans le C++ et la bibliothèque sdl pour essayer de coder un truc très simple pour l'instant : un personnage qui se balade sur un terrain vue de 3/4.  :ange:  
J'en suis à l’étape où mon personnage "glisse" (pas d'animation de marche pour l'instant) sur le terrain.
Et j'ai un problème que j'aimerais régler avant d'aller plus loin un consommation de 80% du cpu lors de l’exécution... Je trouve ca un peu excessif, dites moi si je me tompe. (d'un autre coté je viens de remarquer que firefox en utilise 64%)
Voici le code (je suis ouverts à tout conseil/remarque/insulte) :
 

Code :
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <iostream>
  4. #include <SDL/SDL.h>        //bibli de base de SDL
  5. #include <SDL/SDL_image.h>  //pour inclure des images non bmp.
  6. #include "personnage.h"
  7. #include "map.h"
  8. #include "affichage.h"
  11. using namespace std;
  13. void pauseIci(); // pause() était deja pris ...
  15. int main()
  16. {
  17.   cout << "begining of the story baby" << endl;
  18.   //creation du personnage
  19.   Personnage monPersonnage;
  20.   monPersonnage.afficherEtat();
  22.   //creation de la carte
  23.   Map maCarte;
  24.   maCarte.insererObjet(4,4,2);
  25.   maCarte.afficherTerrainTerm();
  26.  
  28.   //testSDL
  29.  
  30.   Affichage monEcran;
  31.   monEcran.initialisationFenetre();
  32.   monEcran.definirTerrain();
  33.   monEcran.afficherTerrain();
  34.   monEcran.definirPersonnage();
  35.   monEcran.afficherPersonnage();
  36.   monEcran.flip();
  38.   SDL_Event event;
  39.   int continuer = 1;
  40.   int tempsPrecedent = 0, tempsActuel = 0;
  42.   while (continuer)
  43.     {
  44.       SDL_PollEvent(&event);
  45.       switch(event.type)
  46.         {
  47. case SDL_QUIT:
  48.   continuer = 0;
  49.   break;
  51. case SDL_KEYDOWN:
  52.   tempsActuel = SDL_GetTicks();
  53.   if (tempsActuel - tempsPrecedent > 30)
  54.     // Si 30 ms se sont écoulées depuis le dernier tour de boucle
  55.     {
  56.       monEcran.deplacement(event);
  57.       tempsPrecedent = tempsActuel;
  58.     }
  59.   else //on endort le programme le temps qu'il faut
  60.     {
  61.       SDL_Delay(30 - (tempsActuel - tempsPrecedent));
  62.     }
  63.   break;
  64.         }
  66.       monEcran.clearScreen();
  67.       monEcran.afficherTerrain();
  68.       monEcran.afficherPersonnage();
  69.       monEcran.flip();
  70.     }
  71.   cout << "sortie de boucle, on désaloue la memoire" << endl;
  72.   monEcran.libererMemoire();
  73.   //monEcran.pauseIci();
  74.   return 0;
  75. }


 
Et le code de Affichage.cpp dans la foulé :

Code :
  1. #include "affichage.h"
  4. Affichage::Affichage()
  5. {
  6.   // Definition variables de l'ecran
  7.   HAUTEUR_ECRAN = 500;
  8.   LARGEUR_ECRAN = 500;
  9.  
  10.   //Personnage
  11.   positionPersonnage.x = LARGEUR_ECRAN/2;
  12.   positionPersonnage.y = HAUTEUR_ECRAN/2;
  13.  
  14.   //directions
  15.   direction = 0;
  16.   LEFT = 0;
  17.   RIGHT = 1;
  18.   UP = 2 ;
  19.   DOWN = 4 ;
  21.   //animation
  22.   frame = 0;
  23.  
  24.   //Decoupe du personnage
  25.   for(int i(0);i<4;i++) {
  26.         decoupePersonnageL[ i ].x = 26 * i -23;
  27.         decoupePersonnageL[ i ].y = 3*38 +2;
  28.         decoupePersonnageL[ i ].w = 26;
  29.         decoupePersonnageL[ i ].h = 35;
  30.   }
  31.   for(int i(0);i<4;i++) {
  32.         decoupePersonnageR[ i ].x = 205-26 * i -3;
  33.         decoupePersonnageR[ i ].y = 3*38 +2;
  34.         decoupePersonnageR[ i ].w = 26;
  35.         decoupePersonnageR[ i ].h = 35;
  36.   }
  37.   for(int i(0);i<4;i++) {
  38.         decoupePersonnageU[ i ].x = 26 * i -23;
  39.         decoupePersonnageU[ i ].y = 1*38 +2;
  40.         decoupePersonnageU[ i ].w = 26;
  41.         decoupePersonnageU[ i ].h = 35;
  42.   }
  43.     for(int i(0);i<4;i++) {
  44.         decoupePersonnageD[ i ].x = 26 * i -23;
  45.         decoupePersonnageD[ i ].y = 5*38 +3;
  46.         decoupePersonnageD[ i ].w = 26;
  47.         decoupePersonnageD[ i ].h = 35;
  48.   }
  49. }
  51. Affichage::~Affichage()
  52. {
  53. }
  55. void Affichage::initialisationFenetre()
  56. {
  57.   SDL_Init(SDL_INIT_VIDEO); // Initialisation de la SDL
  58.   ecran = SDL_SetVideoMode(LARGEUR_ECRAN, HAUTEUR_ECRAN, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
  59.   SDL_WM_SetCaption("Jeu cool", NULL); // Change titre de la fenetre
  60.   SDL_EnableKeyRepeat(10, 10); // interval de repetition des touches
  61.   coordX = 0;
  62.   coordY = 0;
  63. }
  65. void Affichage::afficherTerrain()
  66. {
  67.   SDL_Rect positionFond;
  68.   positionFond.x = coordX;
  69.   positionFond.y = coordY;
  70.   SDL_BlitSurface(Terrain, NULL, ecran, &positionFond);
  71. }
  73. void Affichage::afficherPersonnage()
  74. {
  76.   if (direction == LEFT)
  77.     {
  78.       SDL_BlitSurface(Personnage, &decoupePersonnageL[1], ecran, &positionPersonnage);
  79.     }
  80.   else if (direction == RIGHT)
  81.     {
  82.       SDL_BlitSurface(PersonnageInverse, &decoupePersonnageR[1], ecran, &positionPersonnage);
  83.     }
  84.   else if (direction == UP)
  85.     {
  86.       SDL_BlitSurface(Personnage, &decoupePersonnageU[1], ecran, &positionPersonnage);
  87.     }
  88.   else if (direction == DOWN)
  89.     {
  90.       SDL_BlitSurface(Personnage, &decoupePersonnageD[1], ecran, &positionPersonnage);
  91.     }
  92. }
  94. void Affichage::definirTerrain()
  95. {
  96.   Terrain = IMG_Load("ressources/herbe.jpg" );
  97. }
  99. void Affichage::definirPersonnage()
  100. {
  101.   Personnage = IMG_Load("ressources/iceboy.png" );
  102.   Personnage = SDL_DisplayFormat( Personnage );
  103.   SDL_SetColorKey(Personnage, SDL_RLEACCEL | SDL_SRCCOLORKEY, SDL_MapRGB(Personnage->format, 180, 255, 180)); // vire le fond
  104.   PersonnageInverse = copierEtRetourner(Personnage);
  105. }
  107. void Affichage::flip()
  108. {
  109.   SDL_Flip(ecran);
  110. }
  112. void Affichage::pauseIci()
  113. {
  114.   int continuer = 1;
  115.   SDL_Event event;
  117.   while (continuer)
  118.     {
  119.       SDL_WaitEvent(&event);
  120.       switch(event.type)
  121.         {
  122. case SDL_QUIT:
  123.   continuer = 0;
  124.         }
  125.     }
  126. }
  128. void Affichage::deplacement(SDL_Event event)
  129. {
  130.   switch(event.key.keysym.sym)
  131.     {
  132.     case SDLK_UP:   // Fleche haut
  133.       coordY++;direction = UP; break;
  134.     case SDLK_DOWN: // Fleche bas
  135.       coordY--;direction = DOWN; break;
  136.     case SDLK_RIGHT: // Fleche droite
  137.       coordX--; direction = RIGHT; break;
  138.     case SDLK_LEFT:  // Fleche gauche
  139.       coordX++; direction = LEFT; break;
  140.     }
  141. }
  143. void Affichage::clearScreen()
  144. {
  145.   SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
  146. }
  148. void Affichage::libererMemoire()
  149. {
  150.   SDL_FreeSurface(Personnage);
  151.   SDL_FreeSurface(Terrain);
  152. }


 
Merci d'avance.

Reply

Marsh Posté le 15-03-2012 à 17:50:09   

Reply

Marsh Posté le 15-03-2012 à 20:04:18    

Hmm, tu utilises SDL_PollEvent() qui ne fait aucune attente. Du coup, d'après ton code, si tu n'appuies sur aucune touche => 100% d'utilisation du CPU.
 
Tu pourrais regarder les fonctions SDL_WaitEvent et SDL_AddTimer() pour faire un truc un peu plus sympa pour le CPU. Fait attention à la précision des timers, ça tourne autour de 10/15ms sous Windows.
 
Aussi, j'ai le souvenir que sous Linusque, les perfs ne sont vraiment pas terribles (edit: avec la lib SDL, hein, c'est pas vraiment linusque le problème :o )


Message édité par tpierron le 15-03-2012 à 20:05:49
Reply

Marsh Posté le 15-03-2012 à 20:09:31    

Bonjour
 
Pour répondre à ta question:
Sur le Site du zéro il parle de:
«si vous utilisez SDL_WaitEvent votre programme utilisera très peu de processeur car il attendra qu'un évènement se produise»
http://www.siteduzero.com/tutoriel [...] e-1-2.html
et de
«SDL_Delay peut donc être utile pour réduire l'utilisation du processeur»
http://www.siteduzero.com/tutoriel [...] temps.html
 
Sinon, si tu veux faire du C++
N'utilise pas les entête C
#include <stdlib.h>
#include <stdio.h>
Remplace la SDL par la SFML
http://www.sfml-dev.org/index-fr.php

Reply

Marsh Posté le 15-03-2012 à 21:01:10    

Mouais, WaitEvent est pas ce qu'il faut pour du temps réel, vu qu'il freeze le programme jusqu'à ce qu'une touche soit pressée (à moins de le foutre dans un thread)
 
Par contre, t'as foutu le contrôleur de framerate dans le cas d'une touche pressé, faut pas. En gros ta boucle principale se fait comme ça :
 
- On gère les évements (PollEvent)
- On exécute chaque code de chaque objet (gestion des déplacements et compagnie)
- On dessine chaque objet
- On flip l'écran
- On calcule le temps à attendre (SDL_Delay())


---------------
Perhaps you don't deserve to breathe
Reply

Marsh Posté le 15-03-2012 à 22:57:00    

Merci à tous, pour ces bons conseils.
Je vais quand même rester sur de la SDL, même s'il y a plus performant.
J'ai complètement repensé la manière dont je gérais la pression des touches pour qu'on puisse en presser deux d'un coup et maintenant j'ai une utilisation du cpu qui varie de 16 à 20% ça me semble plus raisonnable. Je remets mon code (qui gere maintenant les déplacements en diagonale et les animations)
Voilà la boucle de mon main, j'utilise maintenant in qui est le tableau des touches enfoncées
 

Code :
  1. while(!(monEcran.in).key[SDLK_ESCAPE]) // On quiete en faisant echap.
  2.     {
  3.       tempsActuel = SDL_GetTicks();
  4.       // Si 30 ms se sont écoulées depuis le dernier tour de boucle  
  5.       if (tempsActuel - tempsPrecedent > 45)
  6.         {
  8.   monEcran.UpdateEvents(&(monEcran.in));
  9.   monEcran.deplacement();
  10.  
  11.   monEcran.clearScreen();              //applique du blanc sur tout l'ecran
  12.   monEcran.afficherTerrain();           //affiche le terrain
  13.   monEcran.afficherPersonnage();   //affiche le personnage
  14.   monEcran.flip();
  16.   tempsPrecedent = tempsActuel;
  17. }
  18.       else
  19. {
  20.   SDL_Delay(45 - (tempsActuel - tempsPrecedent));
  21. }
  22.     }


 
 
Je vous mets les fonctions principales de Affichage.cpp :
 
- un gros case tout moche pour l'affichage du personnage suivant la direction et la frame ou on est :

Code :
  1. void Affichage::afficherPersonnage()
  2. {
  3.   switch (direction) {
  4.   case LEFT:
  5.     SDL_BlitSurface(Personnage, &decoupePersonnageL[frame], ecran, &positionPersonnage); break;
  6.   case RIGHT:
  7.     SDL_BlitSurface(PersonnageInverse, &decoupePersonnageR[frame], ecran, &positionPersonnage); break;
  8.   case UP:
  9.     SDL_BlitSurface(Personnage, &decoupePersonnageU[frame], ecran, &positionPersonnage); break;
  10.   case DOWN:
  11.     SDL_BlitSurface(Personnage, &decoupePersonnageD[frame], ecran, &positionPersonnage); break;   
  12.   case UP_LEFT:
  13.     SDL_BlitSurface(Personnage, &decoupePersonnageUL[frame], ecran, &positionPersonnage); break;
  14.   case UP_RIGHT:
  15.     SDL_BlitSurface(PersonnageInverse, &decoupePersonnageUR[frame], ecran, &positionPersonnage); break;
  16.   case DOWN_LEFT:
  17.     SDL_BlitSurface(Personnage, &decoupePersonnageDL[frame], ecran, &positionPersonnage); break;
  18.   case DOWN_RIGHT:
  19.     SDL_BlitSurface(PersonnageInverse, &decoupePersonnageDR[frame], ecran, &positionPersonnage); break;
  21.   default:
  22.     break;
  23.   }
  24. }


 
- La fonction qui remplit le tableau de touche enfoncé

Code :
  1. void Affichage::deplacement() // On modifie direct la var global = MOCHE
  2. {
  3.    // UP
  4.   if (in.key[SDLK_UP] && !(in.key[SDLK_LEFT]) && !(in.key[SDLK_RIGHT]) && !(in.key[SDLK_DOWN])) {
  5.     coordY+=VITESSE; direction = UP; frame++;
  6.   }// DOWN
  7.   if (in.key[SDLK_DOWN] && !(in.key[SDLK_LEFT]) && !(in.key[SDLK_RIGHT]) && !(in.key[SDLK_UP])) {
  8.     coordY-=VITESSE; direction = DOWN; frame++;
  9.   }// RIGHT
  10.   if (in.key[SDLK_RIGHT] && !(in.key[SDLK_LEFT]) && !(in.key[SDLK_DOWN]) && !(in.key[SDLK_UP])) {
  11.     coordX-=VITESSE; direction = RIGHT; frame++;
  12.   }// LEFT
  13.   if (in.key[SDLK_LEFT] && !(in.key[SDLK_DOWN]) && !(in.key[SDLK_RIGHT]) && !(in.key[SDLK_UP])) {
  14.     coordX+=VITESSE; direction = LEFT; frame++;
  16.   }// UP + LEFT
  17.   if (in.key[SDLK_UP] && in.key[SDLK_LEFT]  && !(in.key[SDLK_RIGHT]) && !(in.key[SDLK_DOWN])) {
  18.     coordY+=VITESSED; coordX+=VITESSED; direction = UP_LEFT; frame++;
  19.   }//DOWN + LEFT
  20.   if (in.key[SDLK_DOWN] && in.key[SDLK_LEFT] && !(in.key[SDLK_RIGHT]) && !(in.key[SDLK_UP])) {
  21.     coordY-=VITESSED; coordX+=VITESSED; direction = DOWN_LEFT; frame++;
  22.   }// UP + RIGHT
  23.   if (in.key[SDLK_UP] && in.key[SDLK_RIGHT] && !(in.key[SDLK_LEFT]) && !(in.key[SDLK_DOWN])) {
  24.     coordY+=VITESSED; coordX-=VITESSED; direction = UP_RIGHT; frame++;
  25.   }// DOWN + RIGHT
  26.     if (in.key[SDLK_DOWN] && in.key[SDLK_RIGHT] && !(in.key[SDLK_LEFT]) && !(in.key[SDLK_UP])) {
  27.     coordY-=VITESSED; coordX-=VITESSED; direction = DOWN_RIGHT; frame++;
  28.   }
  30.   if (frame > 4) {
  31.       frame = 1;
  32.   }
  33. }


 
- la fonction qui remplit in le tableau des touches enfoncées

Code :
  1. void Affichage::UpdateEvents(Input *inp)
  2. {
  3.   SDL_Event event;
  4.   while(SDL_PollEvent(&event))
  5.     {
  6.       switch (event.type)
  7. {
  8. case SDL_KEYDOWN:
  9.   inp->key[event.key.keysym.sym]=1;
  10.   break;
  11. case SDL_KEYUP:
  12.   inp->key[event.key.keysym.sym]=0;
  13.   break;
  14. case SDL_QUIT:       //On quitte en fermant la fenetre
  15.   exit(EXIT_SUCCESS);
  16.   break;
  17. default:
  18.   break;
  19. }
  20.     }
  21. }


 
Le problème que j'ai, c'est que j'ai pas trouvé d'autre solution que de passer in en paramètre globale de la class affichage  :(  
En essayant de créer un fonction "renvoitIn" j'avais des problèmes de compilation de plus je ne sais pas ou définir la structure Input :

Code :
  1. typedef struct
  2. {
  3. char key[SDLK_LAST];
  4. } Input;


(pour l'instant definit dans Affichage.cpp)
 
Je présents que c'est un problème de passer une fonction en pointeur ou un truc du genre mais je suis dans le vague.


Message édité par beuted le 15-03-2012 à 22:57:32
Reply

Marsh Posté le 15-03-2012 à 23:29:35    

T'es pas obligé de mettre ton code update / déplacer et compagnie après le if pour la gestion du framerate, SDL_Delay() met le programme en pause, en gros aucune instruction n'est exécutée tant que le temps d'attente n'est pas fini.
aussi, typedef est inutile dans ton code, struct Input { }; suffit ;)
 
Pour la SDL, tu peux directement récupérer l'état des touches :
 

Code :
  1. Uint8 * keystate = SDL_GetKeyState(NULL); // ou SDL_GetKeyboardState(NULL), ça dépend de ta version
  2. if (keystate[SDLK_LEFT])
  3. // On a appuyé sur la flèche gauche
  4. if (keystate[SDLK_A])
  5. // On a appuyé sur la touche 'a'
  7. // etc


Message édité par Terminapor le 15-03-2012 à 23:30:10

---------------
Perhaps you don't deserve to breathe
Reply

Marsh Posté le 16-03-2012 à 21:54:24    

Merci pour les conseils,
J'avais le code que tu propose avant mais il ne gère pas le fait que l'utilisateur appuie sur deux boutons en même temps.
Et pour le SDL_Delay(), il me semble que faire comme je fais permet d'avoir des intervalles de temps entre chaque image plus réguliers.

Reply

Marsh Posté le 17-03-2012 à 02:07:43    

Ben pour les deux touches à la fois, tu fais par exemple "if (keystate[SDLK_LEFT] && keystate[SDLK_A] )",ça marche pas ?
Et pour le SDL_Delay, je sais pas trop, ça m'étonne un peu..


---------------
Perhaps you don't deserve to breathe
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed