¿Alguna idea para optimizar el código?

[reethok]

Estoy usando la librería SFML 2, lo que pasa es que al principio consume aprox 4% del CPU según htop, pero también cuenta que estoy usando una netbook con intel atom.

Cualquier optimización, por más peqieña que sea, me serviría.

Muchas gracias.

Código C++:

#include <SFML/Graphics.hpp>
#include <SFML/Audio.hpp>
#include <SFML/System.hpp>
 
int main()
{
    // Ventana en la que se muestra todo el contenido del juego.    
    sf::RenderWindow gameWindow(sf::VideoMode(1024, 600, 32), "Project Genesis",
                                sf::Style::Fullscreen);
 
    // Se establece el límite de frames por segundo a 60
    gameWindow.setFramerateLimit(60);
 
    enum Boton{NUEVO_JUEGO, CONTINUAR, OPCIONES, SALIR};
    Boton boton = NUEVO_JUEGO;
 
    // Música
    sf::SoundBuffer buffer;
    buffer.loadFromFile("main.wav");
 
    sf::SoundBuffer button;
    button.loadFromFile("button.wav");
 
    sf::SoundBuffer selection;
    selection.loadFromFile("selection.wav");
 
    sf::Sound sound;
    sound.setBuffer(buffer);
    sound.setLoop(true);
 
    sf::Sound buttons;
    buttons.setBuffer(button);
 
    sf::Sound selections;
    selections.setBuffer(selection);
 
    sf::Texture menu_i;
    if(!menu_i.loadFromFile("menu.png"))
        return EXIT_FAILURE;
    sf::Sprite menu_s;
    menu_s.setTexture(menu_i);
 
    sf::Texture nuevo_juego_i;
    if(!nuevo_juego_i.loadFromFile("nuevo_juego.png"))
        return EXIT_FAILURE;
    sf::Sprite nuevo_juego_s;
    nuevo_juego_s.setTexture(nuevo_juego_i);
    nuevo_juego_s.setPosition(700, 225);
 
    sf::Texture nuevo_juego2_i;
    if(!nuevo_juego2_i.loadFromFile("nuevo_juego2.png"))
        return EXIT_FAILURE;
    sf::Sprite nuevo_juego2_s;
    nuevo_juego2_s.setTexture(nuevo_juego2_i);
    nuevo_juego2_s.setPosition(700, 225);
 
    sf::Texture continuar_i;
    if(!continuar_i.loadFromFile("continuar.png"))
        return EXIT_FAILURE;
    sf::Sprite continuar_s;
    continuar_s.setTexture(continuar_i);
    continuar_s.setPosition(700, 275);
 
    sf::Texture continuar2_i;
    if(!continuar2_i.loadFromFile("continuar2.png"))
        return EXIT_FAILURE;
    sf::Sprite continuar2_s;
    continuar2_s.setTexture(continuar2_i);
    continuar2_s.setPosition(700, 275);
 
    sf::Texture opciones_i;
    if(!opciones_i.loadFromFile("opciones.png"))
        return EXIT_FAILURE;
    sf::Sprite opciones_s;
    opciones_s.setTexture(opciones_i);
    opciones_s.setPosition(700, 325);
 
    sf::Texture opciones2_i;
    if(!opciones2_i.loadFromFile("opciones2.png"))
        return EXIT_FAILURE;
    sf::Sprite opciones2_s;
    opciones2_s.setTexture(opciones2_i);
    opciones2_s.setPosition(700, 325);
 
    sf::Texture salir_i;
    if(!salir_i.loadFromFile("salir.png"))
        return EXIT_FAILURE;
    sf::Sprite salir_s;
    salir_s.setTexture(salir_i);
    salir_s.setPosition(700, 375);
 
    sf::Texture salir2_i;
    if(!salir2_i.loadFromFile("salir2.png"))
        return EXIT_FAILURE;
    sf::Sprite salir2_s;
    salir2_s.setTexture(salir2_i);
    salir2_s.setPosition(700, 375);
 
    gameWindow.draw(menu_s);
    gameWindow.draw(nuevo_juego2_s);
    gameWindow.draw(continuar_s);
    gameWindow.draw(opciones_s);
    gameWindow.draw(salir_s);
    gameWindow.display();
 
    sf::Image captura;
    captura = gameWindow.capture();
    captura.saveToFile("captura.png");
    
    sound.play();
 
    // Mientras la ventana esté abierta
    while(gameWindow.isOpen())
    {
        // Ciclo para procesar eventos
 
        // Variable para almacenar los eventos
        sf::Event Event;
 
        while(gameWindow.pollEvent(Event))
        {
            switch (Event.type)
            {
                case sf::Event::Closed:
                    gameWindow.close();
                    break;
                case sf::Event::KeyPressed:
                    if(Event.key.code == sf::Keyboard::Escape)
                        gameWindow.close();
                    if(Event.key.code == sf::Keyboard::Up)
                    {
                        buttons.play();
                        switch(boton)
                        {
                            case NUEVO_JUEGO:
                                boton = SALIR;
                                break;
                            case CONTINUAR:
                                boton = NUEVO_JUEGO;
                                break;
                            case OPCIONES:
                                boton = CONTINUAR;
                                break;
                            case SALIR:
                                boton = OPCIONES;
                                break;
                        }
                    }
                    if(Event.key.code == sf::Keyboard::Down)
                    {
                        buttons.play();
                        switch(boton)
                        {
                            case NUEVO_JUEGO:
                                boton = CONTINUAR;
                                break;
                            case CONTINUAR:
                                boton = OPCIONES;
                                break;
                            case OPCIONES:
                                boton = SALIR;
                                break;
                            case SALIR:
                                boton = NUEVO_JUEGO;
                                break;
                        }
                    }
                    if(Event.key.code == sf::Keyboard::Return)
                    {
                        switch(boton)
                        {
                            case SALIR:
                                selections.play();
                                while(selections.getStatus() == sf::SoundSource::Status::Playing)
                                    sf::sleep(sf::milliseconds(1));
                                gameWindow.close();
                                break;
                        }
                    }
                default:
                    break;
            }
 
            // Limpia la pantalla
            gameWindow.clear();
 
            switch(boton)
            {
                case NUEVO_JUEGO:
                    gameWindow.draw(menu_s);
                    gameWindow.draw(nuevo_juego2_s);
                    gameWindow.draw(continuar_s);
                    gameWindow.draw(opciones_s);
                    gameWindow.draw(salir_s);
                    break;
                case CONTINUAR:
                    gameWindow.draw(menu_s);
                    gameWindow.draw(nuevo_juego_s);
                    gameWindow.draw(continuar2_s);
                    gameWindow.draw(opciones_s);
                    gameWindow.draw(salir_s);
                    break;
                case OPCIONES:
                    gameWindow.draw(menu_s);
                    gameWindow.draw(nuevo_juego_s);
                    gameWindow.draw(continuar_s);
                    gameWindow.draw(opciones2_s);
                    gameWindow.draw(salir_s);
                    break;
                case SALIR:
                    gameWindow.draw(menu_s);
                    gameWindow.draw(nuevo_juego_s);
                    gameWindow.draw(continuar_s);
                    gameWindow.draw(opciones_s);
                    gameWindow.draw(salir2_s);
                    break;
            }
 
            // Redibuja la oantalla
            gameWindow.display();
        }
    }
}
 

Saludos.

[Malenko]

Un consumo de un 4% no lo veo para nada preocupante ya que has de cargar las texturas. Si fuese mucho más elevado ese consumo entendería que quisieras bajarlo.

La única optimización que se me ocurre es pasar a un switch el contenido del case "sf::Event::KeyPressed:". En un switch el compilador construye, si es más óptimo (sino usa una estructura similar al if), una tabla de hash para realizar los saltos, en lugar de comprobar una a una las condiciones. Pero vamos, que aunque sea una pequeña optimización, no es algo que te vaya a bajar el consumo de CPU. Has probado con los switch del compilador? Los -O

[reethok]

No he probado, probaré, gracias. Y sí, empezar con 4% no es alarmante, pero olvidé mencionar que cuando la canción empieza a sonar "bien", sube a ~70-80%, y eso sí es terrorífico. :S

[Malenko]

Iniciado por reethok

No he probado, probaré, gracias. Y sí, empezar con 4% no es alarmante, pero olvidé mencionar que cuando la canción empieza a sonar "bien", sube a ~70-80%, y eso sí es terrorífico. :S

Eso ya es otra cosa xD

De todas formas, si el consumo viene básicamente de la reproducción de la canción... ya estas descartando que sea algo de tu código, sino que se trata de la propia función de reproducir el audio. Como ahí no creo que le vayas a meter mano... yo optaría por otras opciones:

1) Bajar la "calidad" (o muestreo) del audio para que no tenga que consumir tanta CPU para reproducirlo. Yo haría un proyecto de prueba donde reproduzcas un audio y al pulsar una tecla te muestre el consumo de CPU que tenía y repita la prueba con otro audio diferente. Así podrás ver que formato/calidad te consume menos

2) La otra opción es... cambiar de librería de audio :P

Yo optaría por hacer las pruebas del punto 1. Si con eso no ves ningún cambio en el consumo de CPU... no te va a quedar otra que pasar al punto 2.

[reethok]

Bueno, primero que nada gracias por tu respuesta, ahora, he logrado ciertos avances descubriendo cosas un poco "raras".

1.- Usando el flag -O3 hago que el porcentaje de consumo del CPU se mantenga en 3-4%, que sigue siendo mucho a mi parecer, pero ya va mejor. Probaré bajando el framerate a 45 o 30.

2.- Si uso los flags -O1 u -O2, no pasa ABSOLUTAMENTE nada, me corre el programa como si no utilizara optimización alguna, ¿a qué se deberá?

Saludos!

EDIT Acabo de probar con 30FPS y -O3 y va a 70% del CPU, algo definitivmente está mal con los procesadores Atom xD

[amchacon]

El % de CPU no se corresponde con la carga sino con las veces "que descansa".

Prueba compilar este programa:

Código C++:

int main()
{
    int Cosita = 0;
    
    while (true)
    {
        Cosita++;
        Cosita--;
    }
    return 0;
}
 

No hace nada, pero consume el 100% de la CPU (en procesadores mononúcleo). Como puedes ver, no está haciendo nada del otro mundo. Incluso podríamos dejarlo así:

Código C++:

int main()
{
    while (true);
 
    return 0;
}
 

La razón que use el 100% de la CPU es que este programa no deja descansar al procesador.

En condiciones normales el procesador siempre está descansando porque está esperando una acción (por ejemplo, ya sea a que el usuario le introduzca datos por teclado/ratón o porque está cargando archivos del disco duro). Muy a menudo también se "induce" a que el procesador descanse (con alguna función tipo sleep).

En resumen, el uso de la CPU depende de:

- Los descansos que tenga el procesador en el programa.
- Los núcleos que tenga el procesador (cada núcleo puede lanzar un hilo de ejecución, por tanto si saturas un núcleo te quedan los demás). Como tienes un procesador mononúcleo el porcentaje se dispara.

[dontexplain]

Iniciado por amchacon

En resumen, el uso de la CPU depende de:

- Los descansos que tenga el procesador en el programa.
- Los núcleos que tenga el procesador (cada núcleo puede lanzar un hilo de ejecución, por tanto si saturas un núcleo te quedan los demás). Como tienes un procesador mononúcleo el porcentaje se dispara.

Toda la razón. Hace no mucho tiempo estuve haciendo straces a algunos procesos y hace muchos descansos. Las llamadas al sistema revelan que hace o bien con sleep descansos de segundos o con microsleep (usleep), incluso con nanosleep que admite estructuras de {seconds, nanoseconds} para la resolución del descanso (sobre todo). Desconozco el impacto que pueden tener en el rendimiento, porque no lo he analizado más que nada, pero también se usa while, y su impacto es relativamente bajo (creo que menor que sleep porque hace interrupciones para calcular la diferencia de tiempo además de que hace llamadas a estas funciones de la librería)

(asumiendo que val es un bool)

while(val)

Código Ensamblador:

mov eax, 00000001h (00000032h)
// entre medias las operaciones que sean
cmp eax,dword ptr [val] // asumiendo 4 bytes y que val podría haber cambiado
je main+xxh (u otra, pero la cuestión es que salte a 00000032h)
 

Asumo que true es 1 (lo es), y que cmp compara el valor de eax donde se almacena true invariablemente con el valor del puntero [val] que almacena el boleano variable. En la línea 4 hay un salto corto, revisar EB. (1)

Si consigo que mi PC deje de dar pantallazos azules cuando le de la gana, reviso el código resultante de usleep y microsleep y posteo la comparación aquí.

(1) El salto corto hace un salto relativo corto a la posición indicada como suma. La mayoría de los desensambladores suelen sumar a ese valor +2 posiciones de memoria porque las instrucciones son 2 bytes y hace el cálculo teniendo en cuenta el tamaño. En cualquier caso siempre será el valor de main+((xxh)+2) ya que será referente a EIP que almacena siempre la siguiente dirección de la memoria mientras ejecuta. O sea, si está ejecutando 0x0000000d almacenará 0x0000000f y el salto será referente a la segunda dirección, ergo habrá que sumar el offset corto a esa última dirección.