I'm making a lua-sfml engine and i decide to test the performace making the same code on pure C++.
All compiler optimizations are on on both projects ( -O3 -fexpensive-optimizations ). (using codeblocks)
Not frame limit in both projects.
Lua-jit gets version 11 fps stable ( with 1000 crates on display , physics engine active ( there are 3 physics object active in the scene, some events dispatcher actives )
In C++ pure version got 8 fps stable ( with ONLY 1000 crates on the display..no physics engine active..no Lua states actives )
I use 2 counters for the test.. a custom counter on the game..and FRAPS.. both counter say the same fps rate. ( 11 for lua / 8 for c++ )
C++ code for the test only this no more:
#include <iostream>
using namespace std ;
#include <SFML/Graphics.hpp>
using namespace sf ;
int main()
{
// create the window
sf::RenderWindow window(sf::VideoMode(600, 600), "My window") ;
int fps_rate = 0 ;
Clock *fps = new Clock ;
sf::Texture t ;
// load the texture
t.loadFromFile( "crate.png" ) ;
t.setSmooth( true ) ;
Sprite *obj = new Sprite[ 1000 ] ;
for( int s = 0 ; s < 1000 ; ++s )
obj[s].setTexture( t ) ;
// run the program as long as the window is open
while (window.isOpen())
{
// fps counter
++fps_rate ;
if ( fps->getElapsedTime().asSeconds() >= 1 )
{ fps->restart() ;
cout << fps_rate << endl ;
fps_rate = 0 ;
}
// check all the window's events that were triggered since the last iteration of the loop
sf::Event event;
while (window.pollEvent(event))
{
// "close requested" event: we close the window
if (event.type == sf::Event::Closed)
window.close();
}
// clear the window with black color
window.clear(sf::Color::Black);
// draw everything here...
for( int i = 0 ; i < 1000 ; ++i )
{
window.draw( obj[ i ] ) ;
}
// end the current frame
window.display();
}
return 0;
}
Screenshots:
lua version
(http://www.subirimagenes.com/imagedata.php?url=http://s2.subirimagenes.com/imagen/9376732luaversion.png)
The small crate and the long crates are physics objects. (the small crates is falling)
The bigs crates ( there are one thousand , you cant see it because are one behind other )
The console show the fps..and the yellow numbers are shown by FRAPS.
The same in the C++ version :
(http://www.subirimagenes.com/imagedata.php?url=http://s2.subirimagenes.com/imagen/9376734c.png)
As you can see.. no physics..no lua States..
Please..if you can optimizate more this c++ code please post it for test it.
I would like yours reviews. :)
PD: link for the full images:
c++ : http://www.subirimagenes.com/imagedata.php?url=http://s2.subirimagenes.com/imagen/9376734c.png
lua : http://www.subirimagenes.com/imagedata.php?url=http://s2.subirimagenes.com/imagen/9376732luaversion.png
Lua game engine topic: http://en.sfml-dev.org/forums/index.php?topic=18074.0
Incredible performace of Lua (luajit) over C++
Whenever I read such a sensational headline, I'm almost sure the measurement is distorted. There are JIT compilers that can outperform C++ in certain situations, but people who do so come with more analytic ways of presenting their results ;)
Indeed, there are several issues with your C++ code, making the measurement meaningless:
- You should measure frame time, not FPS.
- Having a std::cout in the measurement slows down everything -- ah, I saw you're only doing it once a second, sorry.
- If you're really going for CPU performance and not just the GPU communication overhead, use fewer draw calls (sf::VertexArray instead of sf::Sprite).
- Use iterators or range-based for instead of index access. Make also sure that any debug checks in the STL are disabled.
And what's the point of
Clock *fps = new Clock;
Sprite *obj = new Sprite[ 1000 ] ;
when you can just use
Clock fps;
std::vector<Sprite> obj(1000);
without the need for manual memory management? Use RAII (http://www.bromeon.ch/articles/raii.html) where possible.
There are several issues with your C++ code, making the measurement meaningless:
- You should measure frame time, not FPS.
- Having a std::cout in the measurement slows down everything, might as well be the bottleneck.
- If you're really going for CPU performance and not just the GPU communication overhead, use fewer draw calls (sf::VertexArray instead of sf::Sprite).
- Use iterators or range-based for instead of index access. Make also sure that any debug checks in the STL are disabled.
And what's the point of
Clock *fps = new Clock;
Sprite *obj = new Sprite[ 1000 ] ;
when you can just use
Clock fps;
std::vector<Sprite> obj(1000);
without the need for manual memory management? Use RAII (http://www.bromeon.ch/articles/raii.html) where possible.
I replace all the code with the one that you give me.
Even i take off the fps counter and "cout" ..still the same..sometime ups to 10 fps (FRAPS) but then slow to 8 again.
i use memory management because i like C style.