Upgraded from 1.6 to 2.4.0 is ~18 Times Slower

[Ezekiel]

Greetings All:

I have been upgrading one of my sfml 1.6 VS2008 programs to sfml 2.4.0 VS2013 and found the math cycles between graphics frames are significantly slower than the previous version.

I made a simplified version for the comparison, and the math cycles are about ~18 times slower than the original.  The demo code can be pre-compile selected to run on either Visual Studio versions.  Here is the code...

(click to show/hide)

#define _USE_MATH_DEFINES // for C++
#include <cmath>

#include <sfml.h>//incudeds all sfml libs, and set sfml libs as static link
//#include <stdio.h>
#include <sstream>
#include <conio.h>
//#include <iostream>
#include <sstream>

#include <windows.h>

//two versions
//SFML 1.6 in Visual Studio Express 2008
//SFML 2.4.0 in Visual Studio Express 2013

#define USING_SFML_240//comment-out to use sfml 1.6, change properties below...
//#if defined USING_SFML_240
//#else//USING SFML 1.6
//#endif//USING_SFML_240

//properties...
//C:\Programming\C++Projects\SFML-2.4.0\include
//C:\Programming\C++Projects\SFML-2.4.0\lib
//E:\Programming\C++Projects\SFML-1.6\include
//E:\Programming\C++Projects\SFML-1.6\lib

void main(void)
{
        unsigned int WindowX = 800;
        unsigned int WindowY = 600;

        std::stringstream string;
        string << "start string";

        sf::RenderWindow App(sf::VideoMode(WindowX, WindowY, 32), "Speed Test");
        sf::Font font;

        sf::Image image;
        sf::Sprite sprite;

#if defined USING_SFML_240
        font.loadFromFile("courbd.ttf");
        sf::Text text("Init", font);
        text.setColor(sf::Color::Red);
        text.setString(string.str());
        text.setCharacterSize(30);

        image.create(App.getSize().x,App.getSize().y,sf::Color(0, 50, 50));
        sf::Texture texture;
        texture.create(WindowX, WindowY);
        sprite.setTexture(texture);
#else//USING SFML 1.6
        font.LoadFromFile("courbd.ttf");
        sf::String text("Init", font);
        text.SetColor(sf::Color::Red);
        text.SetSize(30);

        image.Create(App.GetWidth(),App.GetHeight(),sf::Color(0, 50, 50));
        sprite.SetImage(image);
        sf::View& DefaultView = App.GetDefaultView();
#endif//USING_SFML_240


        sf::Color color = sf::Color::Black;
        sf::Clock clock;

        unsigned int PixelX = 0;
        unsigned int PixelY = 0;
        const unsigned int BrightColor = 128;

        double FrameRate = 60;
        float FrameTime = 1 / (float)FrameRate;//as seconds

        const unsigned int DivFrameRate = 5;//slows text rate
        unsigned int TextCount = 0;

        unsigned int ShiftRegister = 0xffffffff;
        unsigned int Cycles = 0;

        unsigned int FilteredCycles = 0;
        const unsigned int ShiftCoef = 9;//ShiftCoef * 2 + Cycles bit-width MUST fit within 32-bits
        const unsigned int MultCoef = 1 << (ShiftCoef-1);
        const double CornerFreq = 0.5;
        const double Coef = pow(M_E, -M_2_PI * (CornerFreq/FrameRate));
        const unsigned int BackCoef = (unsigned int)(Coef * (double)MultCoef);
        const unsigned int ForwardCoef = MultCoef - BackCoef;

#if defined USING_SFML_240
        App.clear(sf::Color::Magenta);
        ////App.draw(sprite);
        App.draw(text);
        App.display();
        Sleep(500);
        //text.setString("Test");
#else//USING SFML 1.6
        App.Clear(sf::Color::Magenta);
        ////App.draw(sprite);
        App.Draw(text);
        App.Display();
        Sleep(500);
        //text.setString("Test");
#endif//USING_SFML_240

        //main loop
        char key_char = 0;
        while(key_char != 27)//exit program
        {
                //poll events
                sf::Event Event;
#if defined USING_SFML_240

                while (App.pollEvent(Event))
                {
                        //exit
                        if(Event.type == sf::Event::KeyPressed && Event.key.code == sf::Keyboard::Escape)key_char = 27;

                        //gain focus
                        if(Event.type == sf::Event::GainedFocus)
                        {
                                App.display();
                        }
                        //resize
                        if(Event.type == sf::Event::Resized)
                        {
                                WindowX = App.getSize().x;
                                WindowY = App.getSize().y;

                                image.create(WindowX, WindowY, sf::Color(0, 50, 25));

                                texture.create(WindowX, WindowY);
                                texture.update(image);

                                sprite.setTextureRect(sf::IntRect(0, 0, WindowX, WindowY));
                                //sprite.setTexture(texture);

                                App.setView(sf::View(sf::FloatRect(0.0f, 0.0f, App.getSize().x, App.getSize().y)));
                        }
                }
#else
                while (App.GetEvent(Event))
                {
                        //exit
                        if(Event.Type == sf::Event::KeyPressed && Event.Key.Code == sf::Key::Escape)key_char = 27;

                        //gain focus
                        if(Event.Type == sf::Event::GainedFocus)
                        {
                                App.Display();
                        }
                        //resize
                        if(Event.Type == sf::Event::Resized)
                        {
                                WindowX = App.GetWidth();
                                WindowY = App.GetHeight();

                                image.Create(WindowX, WindowY, sf::Color(0, 50, 25));

                                sprite.SetImage(image);
                                sprite.SetSubRect(sf::IntRect(0, 0, WindowX, WindowY));
                                //sprite.setTexture(texture);
                                DefaultView.SetFromRect(sf::FloatRect(0, 0, (float)App.GetWidth(), (float)App.GetHeight()));
                        }
                }

#endif//USING_SFML_240


                //32-bit linear feedback shift register, next pseudo-random number
                bool NextState = false;
                if((ShiftRegister & (1 << (1-1))) != 0)NextState = true;
                if((ShiftRegister & (1 << (2-1))) != 0)NextState = !NextState;
                if((ShiftRegister & (1 << (21-1))) != 0)NextState = !NextState;
                if((ShiftRegister & (1 << (32-1))) != 0)NextState = !NextState;

                ShiftRegister *= 2;
                if(NextState)ShiftRegister += 1;

                //psuedo-random color, 1st 3 Shift Register bits
                if((ShiftRegister & (1 << (1-1))) != 0)color.r = BrightColor; else color.r = 0;
                if((ShiftRegister & (1 << (2-1))) != 0)color.g = BrightColor; else color.g = 0;
                if((ShiftRegister & (1 << (3-1))) != 0)color.b = BrightColor; else color.b = 0;

                //psuedo-random pixel position
                PixelX = ShiftRegister / (1 << 3) % WindowX;
                PixelY = ShiftRegister / (1 << 14) % WindowY;
                Cycles++;

                //change image
#if defined USING_SFML_240
                image.setPixel(PixelX, PixelY, color);


                //frame-rate passed
                if(clock.getElapsedTime() >= sf::seconds(FrameTime))// || index >= width * heigth - 1)
                {
                        //reset time
                        clock.restart();
#else//USING SFML 1.6
                image.SetPixel(PixelX, PixelY, color);


                //frame-rate passed
                if(clock.GetElapsedTime() >= FrameTime)// || index >= width * heigth - 1)
                {
                        //reset time
                        clock.Reset();
#endif//USING_SFML_240

                        //filter cycles
                        FilteredCycles = Cycles * (ForwardCoef) + FilteredCycles * BackCoef / MultCoef;

                        //read  and reset cycles
                        if(TextCount >= DivFrameRate)
                        {
                                TextCount = 0;

                                string.str("????");
                                string << "\n  Cycles => " << Cycles << "  Filtered => " << FilteredCycles / MultCoef;

                        }
                        else TextCount++;
                        Cycles = 0;
#if defined USING_SFML_240

                        //display image
                        App.clear(sf::Color::Green);
                        //App.clear();
                        texture.update(image);
                        //sprite.setTextureRect(sf::IntRect(0, 0, WindowX, WindowY));
                        App.draw(sprite);
                        text.setString(string.str());
                        App.draw(text);
                        App.display();

#else//USING SFML 1.6

                        //display image
                        App.Clear(sf::Color::Green);
                        //App.clear();
                       
                        sprite.SetImage(image);
                        App.Draw(sprite);
                        text.SetText(string.str());
                        App.Draw(text);
                        App.Display();
#endif//USING_SFML_240
                }

        }

}
 

I could use some help to find the faster path using the newer sfml 2.4.0.  There could also be some differences in the compilers and/or computer hardware interface as well.

Specs:
AMD 64 X2 Dual Core Processor 5200+
Windows 7
NVIDIA GeForce 7600 GT

[Ezekiel]

Greetings All:

I did some additional testing using time measuring by adding clock points in the software loop.  I found 2 changes between SFML 1.6 and SFML 2.4.0 that affect the speed of the main loop.

1st, the speed calling the App.pollEvent(Event) command.  Times Measured:
SFML 1.6    SFML 2.4.0
~3us         ~29us

I improved that issue by only polling the Event's on the loop following the frame display, not every loop.  This change improved the 1.6 version by about 25%, and the 2.4.0 rate about 10 times.  After that, the 1.6 loop speed is still about 2.5 * the 2.4.0 loop speed.

2nd, the speed calling the getElapsedTime was different between the 1.6 and 2.4.0 versions.  Times Measured:
SFML 1.6    SFML 2.4.0
~1.2us         3.000us

As shown, the 2.4.0 is longer by about 2.5 * than the 1.6 time, indicating the difference causes the result I see.  Also as shown, the 2.4.0 time is way more accurate, the 1.6 time was very randomized.  Calling the getElapsedTime frequently is required to perform drawing the frame accurately, so I haven't found a good option to solve this yet.

The good news is the time of the App.Draw sequence is about 2.8ms for both versions, so it doesn't seem there aren't time result changes to the graphics section.

Here is the new version test code with the added time measurement...

(click to show/hide)

#define _USE_MATH_DEFINES // for C++
#include <cmath>

#include <sfml.h>//incudeds all sfml libs, and set sfml libs as static link
//#include <stdio.h>
#include <sstream>
#include <conio.h>
//#include <iostream>
#include <sstream>

#include <windows.h>

//two versions
//SFML 1.6 in Visual Studio Express 2008
//SFML 2.4.0 in Visual Studio Express 2013

#define USING_SFML_240//comment-out to use sfml 1.6, change properties below...
//#if defined USING_SFML_240
//#else//USING SFML 1.6
//#endif//USING_SFML_240

//properties...
//C:\Programming\C++Projects\SFML-2.4.0\include
//C:\Programming\C++Projects\SFML-2.4.0\lib
//E:\Programming\C++Projects\SFML-1.6\include
//E:\Programming\C++Projects\SFML-1.6\lib

void main(void)
{
        unsigned int WindowX = 800;
        unsigned int WindowY = 600;

        std::stringstream string;
        string << "start string";

        sf::RenderWindow App(sf::VideoMode(WindowX, WindowY, 32), "Speed Test - SFML 1.6 VS 2008");//changed to SFML 2.4.0 below, if selected
        sf::Font font;

        sf::Image image;
        sf::Sprite sprite;

#if defined USING_SFML_240
        App.setTitle("Speed Test - SFML 2.4.0 VS 2013");
        font.loadFromFile("courbd.ttf");
        sf::Text text("Init", font);
        text.setColor(sf::Color::Red);
        text.setString(string.str());
        text.setCharacterSize(30);

        image.create(App.getSize().x,App.getSize().y,sf::Color(0, 50, 50));
        sf::Texture texture;
        texture.create(WindowX, WindowY);
        sprite.setTexture(texture);
#else//USING SFML 1.6
        font.LoadFromFile("courbd.ttf");
        sf::String text("Init", font);
        text.SetColor(sf::Color::Red);
        text.SetSize(30);

        image.Create(App.GetWidth(),App.GetHeight(),sf::Color(0, 50, 50));
        sprite.SetImage(image);
        //sprite.SetBlendMode(sf::Blend::None);
        sf::View& DefaultView = App.GetDefaultView();
#endif//USING_SFML_240


        sf::Color color = sf::Color::Black;
        sf::Clock clock;
        float LoopTime = 0.0;

        //sf::Clock DrawTimer;
        float DisplayTime = 0.0;
        float PollTime = 0.0;
        bool FetchPollTime = true;
        float SolvePixelTime = 0.0;
        bool FetchSolvePixelTime = true;
        float SetPixelTime = 0.0;
        bool FetchSetPixelTime = true;
        float MathLoopTime = 0.0;
        float OldMathLoopTime = 0.0;

        unsigned int PixelX = 0;
        unsigned int PixelY = 0;
        const unsigned int BrightColor = 128;

        unsigned TestSquareX = 300;
        unsigned TestSquareY = 300;
        unsigned TestSquareSize = 15;
        sf::Color TestSquareColor(192, 192, 192);

        double FrameRate = 60;
        float FrameTime = 1 / (float)FrameRate;//as seconds

        const unsigned int DivFrameRate = 5;//slows text rate
        unsigned int TextCount = 0;

        unsigned int ShiftRegister = 0xffffffff;
        unsigned int Cycles = 0;

        unsigned int FilteredCycles = 0;
        const unsigned int ShiftCoef = 9;//ShiftCoef * 2 + Cycles bit-width MUST fit within 32-bits
        const unsigned int MultCoef = 1 << (ShiftCoef-1);
        const double CornerFreq = 0.5;
        const double Coef = pow(M_E, -M_2_PI * (CornerFreq/FrameRate));
        const unsigned int BackCoef = (unsigned int)(Coef * (double)MultCoef);
        const unsigned int ForwardCoef = MultCoef - BackCoef;

#if defined USING_SFML_240
        App.clear(sf::Color::Magenta);
        ////App.draw(sprite);
        App.draw(text);
        App.display();
        Sleep(500);
        //text.setString("Test");
#else//USING SFML 1.6
        App.Clear(sf::Color::Magenta);
        ////App.draw(sprite);
        App.Draw(text);
        App.Display();
        Sleep(500);
        //text.setString("Test");
#endif//USING_SFML_240

        //main loop
        char key_char = 0;
        while(key_char != 27)//exit program
        {
                //poll events
                sf::Event Event;
#if defined USING_SFML_240
               
                if(FetchPollTime)
                while (App.pollEvent(Event))
                {
                        //exit
                        if((Event.type == sf::Event::Closed) || (Event.type == sf::Event::KeyPressed && Event.key.code == sf::Keyboard::Escape))key_char = 27;

                        //gain focus
                        if(Event.type == sf::Event::GainedFocus)
                        {
                                App.display();
                        }
                        //resize
                        if(Event.type == sf::Event::Resized)
                        {
                                WindowX = App.getSize().x;
                                WindowY = App.getSize().y;

                                image.create(WindowX, WindowY, sf::Color(0, 50, 25));

                                texture.create(WindowX, WindowY);
                                texture.update(image);

                                sprite.setTextureRect(sf::IntRect(0, 0, WindowX, WindowY));
                                //sprite.setTexture(texture);

                                App.setView(sf::View(sf::FloatRect(0.0f, 0.0f, App.getSize().x, App.getSize().y)));
                        }
                }
                if(FetchPollTime)
                {
                        PollTime = clock.getElapsedTime().asSeconds() - DisplayTime;
                        FetchPollTime = false;
                }
#else
                if(FetchPollTime)
                while (App.GetEvent(Event))
                {
                        //exit
                        if(Event.Type == sf::Event::Closed || (sf::Event::KeyPressed && Event.Key.Code == sf::Key::Escape))key_char = 27;

                        //gain focus
                        if(Event.Type == sf::Event::GainedFocus)
                        {
                                App.Display();
                        }
                        //resize
                        if(Event.Type == sf::Event::Resized)
                        {
                                WindowX = App.GetWidth();
                                WindowY = App.GetHeight();

                                image.Create(WindowX, WindowY, sf::Color(0, 50, 25));

                                sprite.SetImage(image);
                                sprite.SetSubRect(sf::IntRect(0, 0, WindowX, WindowY));
                                //sprite.setTexture(texture);
                                DefaultView.SetFromRect(sf::FloatRect(0, 0, (float)App.GetWidth(), (float)App.GetHeight()));
                        }
                }
                if(FetchPollTime)
                {
                        PollTime = clock.GetElapsedTime() - DisplayTime;
                        FetchPollTime = false;
                }
#endif//USING_SFML_240


                //32-bit linear feedback shift register, next pseudo-random number
                bool NextState = false;
                if((ShiftRegister & (1 << (1-1))) != 0)NextState = true;
                if((ShiftRegister & (1 << (2-1))) != 0)NextState = !NextState;
                if((ShiftRegister & (1 << (21-1))) != 0)NextState = !NextState;
                if((ShiftRegister & (1 << (32-1))) != 0)NextState = !NextState;

                ShiftRegister *= 2;
                if(NextState)ShiftRegister += 1;

                //psuedo-random color, 1st 3 Shift Register bits
                if((ShiftRegister & (1 << (1-1))) != 0)color.r = BrightColor; else color.r = 0;
                if((ShiftRegister & (1 << (2-1))) != 0)color.g = BrightColor; else color.g = 0;
                if((ShiftRegister & (1 << (3-1))) != 0)color.b = BrightColor; else color.b = 0;

                //psuedo-random pixel position
                PixelX = ShiftRegister / (1 << 3) % WindowX;
                PixelY = ShiftRegister / (1 << 14) % WindowY;
                if(PixelX  >= TestSquareX && PixelX < TestSquareX + TestSquareSize
                && PixelY  >= TestSquareY && PixelY < TestSquareY + TestSquareSize)
                        color = TestSquareColor;
                Cycles++;

                //change image
#if defined USING_SFML_240
                if(FetchSolvePixelTime)
                {
                        SolvePixelTime = clock.getElapsedTime().asSeconds() - DisplayTime - PollTime;
                        FetchSolvePixelTime = false;
                }

                image.setPixel(PixelX, PixelY, color);

                if(FetchSetPixelTime)
                {
                        SetPixelTime = clock.getElapsedTime().asSeconds() - DisplayTime - PollTime - SolvePixelTime;
                        FetchSetPixelTime = false;
                }

                //frame-rate passed
                LoopTime = clock.getElapsedTime().asSeconds();//read it once
                if(LoopTime >= sf::seconds(FrameTime).asSeconds())// || index >= width * heigth - 1)
                {
                        //reset time
                        clock.restart();
                        OldMathLoopTime = 0.0;
#else//USING SFML 1.6
                if(FetchSolvePixelTime)
                {
                        SolvePixelTime = clock.GetElapsedTime() - DisplayTime - PollTime;
                        FetchSolvePixelTime = false;
                }

                image.SetPixel(PixelX, PixelY, color);

                if(FetchSetPixelTime)
                {
                        SetPixelTime = clock.GetElapsedTime() - DisplayTime - PollTime - SolvePixelTime;
                        FetchSetPixelTime = false;
                }


                //frame-rate passed
                LoopTime = clock.GetElapsedTime();//read it once
                if(LoopTime >= FrameTime)
                {
                        //reset time
                        clock.Reset();
                        OldMathLoopTime = 0.0;
#endif//USING_SFML_240

                        //filter cycles
                        FilteredCycles = Cycles * (ForwardCoef) + FilteredCycles * BackCoef / MultCoef;

                        //read  and reset cycles
                        if(TextCount >= DivFrameRate)
                        {
                                TextCount = 0;

                                string.str("????");
                                string << "\n  Cycles => " << Cycles << "  Filtered => " << FilteredCycles / MultCoef
                                           << "\n  Display Time => " << DisplayTime
                                           << "\n  Poll Time => " << PollTime
                                           << "\n  Solve Pixel Time => " << SolvePixelTime
                                           << "\n  Set Pixel Time => " << SetPixelTime
                                           << "\n  Math Loop Time => " << MathLoopTime;

                        }
                        else TextCount++;

                        FetchPollTime = true;
                        FetchSolvePixelTime = true;
                        FetchSetPixelTime = true;
                        Cycles = 0;

#if defined USING_SFML_240

                        //display image
                        App.clear(sf::Color::Green);
                        //App.clear();
                        texture.update(image);
                        //sprite.setTextureRect(sf::IntRect(0, 0, WindowX, WindowY));
                        App.draw(sprite);
                        text.setString(string.str());
                        App.draw(text);
                        App.display();

                        DisplayTime = clock.getElapsedTime().asSeconds();
                }
                //else
                //{
                //      MathLoopTime = MathLoopClock.getElapsedTime().asSeconds();
                //      MathLoopClock.restart();
                //}
#else//USING SFML 1.6

                        //display image
                        App.Clear(sf::Color::Green);
                        //App.clear();
                       
                        sprite.SetImage(image);
                        App.Draw(sprite);
                        text.SetText(string.str());
                        App.Draw(text);
                        App.Display();

                        DisplayTime = clock.GetElapsedTime();
                }

#endif//USING_SFML_240

                else
                {
                        if(OldMathLoopTime != 0.0)//ignore loop after display
                        {
                                MathLoopTime = LoopTime - OldMathLoopTime;
                        }
                        OldMathLoopTime = LoopTime;
                }

        }

}
 

Be forewarned, any measurements I made can be dramatically different with different hardware or operating systems.

I hope this is found interesting.  Any suggestions would be appreciated.

[Mr_Blame]

Did you compile both tests in release configuration? SFML versions(from 2.0 i think) have a lot of checks in their code when compiled in debug.

[Ezekiel]

Greetings Mr_Blame:

I tested both types as mentioned and compared the speeds between them before posting the responses.  I used Release as Debug tends to slow things down quite a bit, so I didn't try Debug.  The timing measurements are posted in the program window when you get it running.  It obviously can be different than my measurements on different hardware or operating systems

If you want to test the 1.6 version, VS 2008 is the latest version of the old SFML library version, so that Visual Studio will be required I believe.

I used 2.3 for a while, and upgraded to 2.4.0 a few days ago, and it required no changes at all, but I'm not familiar with 2.0.  I'm also not very skilled linking all the lib's, so that may cause errors as well.  I use the following in the 2.4.0 include folder, and an older version posted in an old post I made a while ago for the 1.6 version.  The versions less than 2.2 may be more similar than the 1.6 version, but I'm not sure.

include reference to lib's...

(click to show/hide)

//original by Disch, posted Here: http://www.cplusplus.com/forum/beginner/78091/#msg420663
#pragma once
#ifndef SFMLFULL_INCLUDED
#define SFMLFULL_INCLUDED

//comment out the following 3 lines to dynamicaly link
//#ifndef SFML_STATIC
//#define SFML_STATIC
//#endif

#include <SFML/Audio.hpp>
#include <SFML/Graphics.hpp>
#include <SFML/Network.hpp>
#include <SFML/System.hpp>
#include <SFML/Window.hpp>

#if defined(_DEBUG) || defined(DEBUG)
    #if defined(SFML_STATIC)
        #pragma comment(lib,"sfml-graphics-s-d.lib")
        #pragma comment(lib,"sfml-audio-s-d.lib")
        #pragma comment(lib,"sfml-network-s-d.lib")
        #pragma comment(lib,"sfml-window-s-d.lib")
        #pragma comment(lib,"sfml-system-s-d.lib")
        #pragma comment(lib,"sfml-main-d.lib")
        #pragma comment(lib,"opengl32.lib")
        #pragma comment(lib,"freetype.lib")
        #pragma comment(lib,"jpeg.lib")
        #pragma comment(lib,"winmm.lib")
        #pragma comment(lib,"gdi32.lib")
        #pragma comment(lib,"openal32.lib")
        #pragma comment(lib,"flac.lib")
        #pragma comment(lib,"vorbis.lib")
        #pragma comment(lib,"vorbisenc.lib")
        #pragma comment(lib,"vorbisfile.lib")
        #pragma comment(lib,"ogg.lib")
        #pragma comment(lib,"ws2_32.lib")
    #else
        #pragma comment(lib,"sfml-graphics-d.lib")
        #pragma comment(lib,"sfml-audio-d.lib")
        #pragma comment(lib,"sfml-network-d.lib")
        #pragma comment(lib,"sfml-window-d.lib")
        #pragma comment(lib,"sfml-system-d.lib")
        #pragma comment(lib,"sfml-main-d.lib")
    #endif
#else
    #if defined(SFML_STATIC)
        #pragma comment(lib,"sfml-graphics-s.lib")
        #pragma comment(lib,"sfml-audio-s.lib")
        #pragma comment(lib,"sfml-network-s.lib")
        #pragma comment(lib,"sfml-window-s.lib")
        #pragma comment(lib,"sfml-system-s.lib")
        #pragma comment(lib,"sfml-main.lib")
        #pragma comment(lib,"opengl32.lib")
        #pragma comment(lib,"freetype.lib")
        #pragma comment(lib,"jpeg.lib")
        #pragma comment(lib,"winmm.lib")
        #pragma comment(lib,"gdi32.lib")
        #pragma comment(lib,"openal32.lib")
        #pragma comment(lib,"flac.lib")
        #pragma comment(lib,"vorbis.lib")
        #pragma comment(lib,"vorbisenc.lib")
        #pragma comment(lib,"vorbisfile.lib")
        #pragma comment(lib,"ogg.lib")
        #pragma comment(lib,"ws2_32.lib")

#else
        #pragma comment(lib,"sfml-graphics.lib")
        #pragma comment(lib,"sfml-audio.lib")
        #pragma comment(lib,"sfml-network.lib")
        #pragma comment(lib,"sfml-window.lib")
        #pragma comment(lib,"sfml-system.lib")
        #pragma comment(lib,"sfml-main.lib")
    #endif
#endif

#endif // SFMLFULL_INCLUDED

//sfml-graphics-s.lib
//sfml-audio-s.lib
//sfml-network-s.lib
//sfml-window-s.lib
//sfml-system-s.lib
//sfml-main.lib
//opengl32.lib
//freetype.lib
//jpeg.lib
//winmm.lib
//gdi32.lib
//openal32.lib
//flac.lib
//vorbis.lib
//vorbisenc.lib
//vorbisfile.lib
//ogg.lib
//ws2_32.lib
 

I that helps.

[dabbertorres]

Well, at lines 149-152:

image.create(WindowX, WindowY, sf::Color(0, 50, 25));
texture.create(WindowX, WindowY);
texture.update(image);

You're creating an image in RAM and uploading it to VRAM every single frame. Of course that's going to be slow. I'm assuming this is demo code since the image isn't changing at all, but, I wouldn't be surprised if this is at least part of your slow-down.

However, the best thing to do, since you're using Visual Studio, would be to use its built-in profiler to figure out which function calls are taking up the most time.

[Ezekiel]

Greetings dabbertorres:

The section you mentioned is only done on Event Resized, however around line 300 in 2.4.0 mode, a similar sequence is done except the resizing functions.  In the main loop, every time through a new random pixel is generated (line 200 to 220) and modified the single pixel in the image (230 in 2.4.0 mode).  The image is modified thousands of times during each frame, so this is best done in ram, as I understand.  Any improvements to the display time would be appreciated.

Here are some pictures of the two versions attached below.  The first line shows how many pixels are modified per frame, and the next shows time per loop, while the pixel is updated and the time is checked if it's frame-time yet.  The next 4 lines are tested during each frame, the display time, poll time, solve time, and pixel mod time.  The last 2 lines time is by set the 2 getElapsedTime calls, as the Math Loop time does the same since it calls the function once.

I hope you find that helps.

[eXpl0it3r]

As has been suggested, run a profiler and see where you're losing time.

Single pixel manipulation should still be fast enough, but the question really is, why do you need to do that? Texture manipulations should really happen through shaders nowadays.

And finally, does it really negatively impact your game or is it just a comparison for fun?

[Ezekiel]

Greetings eXpl0it3r:

The program I upgraded from SFML 1.6 to 2.4.0 is a Mandelbrot Fractal program.  Since its much larger program, I copied out the small sections needed to check the differences.  Since the fractal section is complicated and uses other classes, I made a random pixel section so it could be done in 20 lines in a single main function, and still behave similar requirements in its graphics.  Both formats do some math to solve a single pixel in an array of pixels, and update the display every frame.

Most of the changes required for the upgrade 1.6 to 2.xx are spelling or capitalization and a few getSize().x rather than GetWidth(), except for the graphics section requiring a texture step displaying an image.  I apologize for my assumption, when the graphics with the only change mentioned was much slower, it seemed to be a graphics changing the speed.  However, as mentioned in previous posts, the time changes are in the poll event call and getElapsedTime call in the main loop, so this should have been placed in the window or system section, respectively.  Both versions display the image in the same amount of time, so graphics are affect by timing changes, but aren't the culprit.

The program does a lot of calculation to solve a single pixel, so waiting for the poll event or getElapsedTime for a longer time slows the progression rate, and image is the only place to modify a single pixel in ram I could find.  If there are any faster ways, let me know and I will see if I can modify my test program.  I will also have to get to know the profiler, I haven't used that before.

[eXpl0it3r]

Since the Mandelbrot Fractal only needs to be "recalculated" when you change the parameter that you look at it, you could update the texture only when the image has changed.

The event polling has been show to be slow when there are issues with gamepads/joysticks, however 29us is still very fast and should never really be a problem.
3ms for retrieving the elapsed time sounds a bit long, but on the other hand the question is, why do you need to call it many times during one frame iteration?

So am I getting the right conclusion that so far there hasn't been any actual performance issue?
0.029ms + 3ms are still way below 16.66ms that you need to render something at 60fps.

My Mandelbrot fractal renderer I wrote with SFML 2 doesn't suffer from rendering issues, but the main problem is to generate the pixel information quickly enough. This is usually not possible within 16.666ms which is why I used loading screens (iirc) and tried to parallelize the calculation.

And as a final note, fractals can also be rendered on the GPU directly with shaders.

[Mario]

Did my own test run in VS 2015 (only 2.4):

• GPU load on a GTX 680 is hardly measurable (work per frame takes between ~40µs and 610µs).
• Most time spent indeed happens to be texture.update(image);, which is understandable. (57.1%)
  
• App.pollEvent(event) takes the second place due to joystick handling. (13.9%)
  
• Third place and no longer significant are the calls to clock.getElapsedTime(). (0.7%)

So with these stats I still decided to have a closer look into sf::Texture::update() and this is where it indeed gets interesting:



Maybe I'm missing something, but I'm not really sure what I should think of this. This might indeed be some bug or quirks, but it's not really in SFML's code, because this "throwaway" object has a very simple connstructor:



This function only retrieves the current active texture identifier (read: an integer).

According to OpenGL.org this behavior is actually to be expected:

Note that this solution emphasizes correctness over performance; the glGetIntegerv​ call may not be particularly fast.

They provide another workaround (Direct State Access), although right now I'm not sure whether that's feasible in our situation or not. This is definitely something to look into I guess.


But besides that. It's still possible you've got some other bottleneck somewhere, so you'd have to do the measurement/analysis yourself.


Edit: Replaced the TextureSaver with some simple pushing/popping OpenGL states (not 100% sure this would work here) and also tried removing the code together. The load moves to actual texture loading, but overall I didn't get any noticeable performance difference (still around 3000 fps, if I manipulate the framerate capping).

[Ezekiel]

Greetings All:

I forgot to show what my first performance issue was.  See attached picture...

...it was about 10 times slower.  As mentioned in the second post, I solved the pollEvent() issue by only calling once per frame, and it also improved the 1.6 version.  I enabled that issue by commenting out "if(FetchPollTime)" on line 132.  29us every loop is large wast of time, once frame is not a big deal.  Anyone can check that if desired.

eXpl0it3r, the getElapsedTime() time is 3us, not 3ms, so that would be MUCH WORSE if it was in milliseconds.

Modifying the random pixel loop would be easy, since solving each pixel is in a fixed number of assembly instructions, so I could calculate and go through the number of times taking ~16.5ms, then check the time frequently to start the frame draw at the right time.  Fractals are more difficult, some pixels take 1 check (not even an iteration), and some never escape so take iteration limit.  The limit can be in the billions for deep zooms.  So after a pixel is calculated, checking if the frame display time is ready shows the progress.  And now as I recall, on deep zooms, any Event functions can be delayed since a single pixel can take a long time.

Well I have my task in front of me, calculate pixels until frame-time, without asking the clock.  Also I haven't performed using treads for multi-core efficiency or using GPU shading for that as well.  Is there class/functions in SFML that are convenient for GPU processing?  And if so, does the shading prefer float, double or integer math?

[Mr_Blame]

Do not call pollEvent once per frame, event queue may overflow!

[Mario]

Mr_Blame is right, while that might work in general, there are cases where it will screw up, especially once you've got major frame drops.

Process all the events you need. 30µs is nothing. If that is a problem for you, you're indeed running the event loop too often, which might be due to the way you try to handle your events. Just slow down the event loop, if there isn't anything to process (just always render between update loops).

As for your question regarding GPU processing: SFML allows you to use geometry, vertex, and pixel shaderrs. To access stuff like CUDA, you'd have to use another library.

However, I guess it's still the best idea to just render your fractal in a pixel shader, especially considering shaders are very good and efficient at calculating things in parallel (on modern cards several thousand pixels in parallel). Here's a simple example for a Mandelbrot renderer.

[eXpl0it3r]

I still don't see what the actual problem is here. Do you have a performance issue or not?

Are you just saying that SFML 2.4.0 performs differently than 1.6? If so, SFML's goal is not to be the fastest and best performing library out there. We focus on a clean API and maintainable code. As such updates don't imply that performance will stay the same or get better, as long as the difference are insignificant.
In the past we had reports that the joystick checks within the event loop can be quite slow on Windows. In such cases where people don't need joysticks/gamepads, but need more frametime, we suggested to comment out that joystick calls in the event polling SFML code and rebuild SFML.
Other solutions include the more complex and error prone way to put event handling into a dedicated thread with waitEvent(). That way the OS events can be handled independently and you can forward the events in a secure way (no race conditions, protected shared memory, etc) to your main thread. Only go this path if you really know, what you're doing.