SDL software rendering faster than hardware rendering - c++

Question

I've just found out a strange behavior of SDL.
I've written a simple particle renderer, and for some reason it runs about 6 times faster with the software renderer than with the hardware renderer.
Here's the source code:
main.cpp
#define _USE_MATH_DEFINES
#include <iostream>
#include <cstdlib>
#include <Windows.h>
#include <vector>
#include <math.h>
#include <time.h>
#include <SDL.h>
#include "Particle.h"
const int SCREEN_WIDTH = 1024;
const int SCREEN_HEIGHT = 600;
const int PARTICLE_NUMBER = 50000;
const int MAX_SPEED = 200;
const int MIN_SPEED = 5;
long long getMs (void) {
SYSTEMTIME stime;
GetLocalTime(&stime);
long long ms = stime.wMilliseconds +
stime.wSecond * 1000 +
stime.wMinute * 60000 +
stime.wHour * 3600000 +
stime.wDay * 86400000 +
stime.wMonth * 2592000000 +
(stime.wYear - 1970) * 31104000000;
return ms;
}
int main(int argc, char *argv[])
{
bool hardwareAccelerated = true;
if (argc == 2)
{
if (strncmp(argv[1], "-software", 9) == 0)
{
hardwareAccelerated = false;
}
}
char title [100];
sprintf(title, "Particles: %d - (%s)", PARTICLE_NUMBER, (hardwareAccelerated ? "HARDWARE ACCELERATED" : "SOFTWARE RENDERING"));
Particle<double> *particles = (Particle<double>*) malloc(sizeof(Particle<double>) * PARTICLE_NUMBER);
for (int i = 0; i < PARTICLE_NUMBER; i++)
{
double x = rand() % SCREEN_WIDTH;
double y = rand() % SCREEN_HEIGHT;
double direction = (((double) rand() / (double) RAND_MAX) - 0.5f) * 2 * M_PI;
double speed = rand() % (MAX_SPEED - MIN_SPEED) + MIN_SPEED;
(particles+i)->setPos(x, y);
(particles+i)->setDirection(direction);
(particles+i)->setSpeed(speed);
// std::cout << (particles+i) << std::endl;
}
if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
return 1;
}
SDL_Window *window = SDL_CreateWindow(title,
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
if (window == nullptr) {
return 2;
}
SDL_RendererFlags flags = (hardwareAccelerated ? SDL_RENDERER_ACCELERATED : SDL_RENDERER_SOFTWARE);
SDL_Renderer *renderer = SDL_CreateRenderer(window, -1,
flags);
if (renderer == nullptr) {
return 3;
}
bool quit = false;
SDL_Event evt;
long long lastFrame = getMs();
double delta = 0.f;
while (!quit)
{
long long currentTime = getMs();
delta = currentTime - lastFrame;
lastFrame = currentTime;
std::cout << "delta: " << delta << std::endl;
while(SDL_PollEvent(&evt) != 0)
{
if (evt.type == SDL_QUIT)
{
quit = true;
}
}
SDL_SetRenderDrawColor(renderer, 0,0,0,1);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(renderer, 255,0,0,255);
for (int i = 0; i < PARTICLE_NUMBER; i++)
{
(particles+i)->tick(delta);
double *pos = (particles+i)->getPos();
SDL_RenderDrawPoint(renderer, pos[0], pos[1]);
}
SDL_RenderPresent(renderer);
}
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}
particle.h
#ifndef _H_PARTICLE
#define _H_PARTICLE
#include <math.h>
template <class T>
class Particle
{
public:
Particle(void);
void tick(double);
void setPos(T, T);
T* getPos(void);
void setDirection(double);
double getDirection(void);
void setSpeed(T);
T getSpeed(void);
~Particle(void);
private:
T x;
T y;
T speed;
double direction;
};
template <class T>
Particle<T>::Particle(void)
{
}
template <class T>
void Particle<T>::tick(double delta)
{
double dt = delta / 1000;
T d_speed = this->speed * dt;
// std::cout << d_speed << std::endl;
this->x += cos(this->direction) * d_speed;
this->y += sin(this->direction) * d_speed;
if (this->x > SCREEN_WIDTH) this->x = 0;
if (this->y > SCREEN_HEIGHT) this->y = 0;
if (this->x < 0) this->x = SCREEN_WIDTH;
if (this->y < 0) this->y = SCREEN_HEIGHT;
}
template <class T>
void Particle<T>::setPos(T x, T y)
{
this->x = x;
this->y = y;
}
template <class T>
T* Particle<T>::getPos(void)
{
T pos[2];
pos[0] = this->x;
pos[1] = this->y;
return pos;
}
template <class T>
void Particle<T>::setDirection(double direction)
{
this->direction = direction;
}
template <class T>
double Particle<T>::getDirection(void)
{
return this->direction;
}
template <class T>
void Particle<T>::setSpeed(T speed)
{
this->speed = speed;
}
template <class T>
T Particle<T>::getSpeed(void)
{
return this->speed;
}
template <class T>
Particle<T>::~Particle(void)
{
}
#endif
Why is this happening? Shouldn't the hardware renderer be a lot faster than the software one?

Answer 1

SDL_RenderDrawPoint() calls SDL_RenderDrawPoints() but wiht a count of 1.
SDL_RenderDrawPoints() calls SDL_stack_alloc() before rendering the number of points it needs to, and SDL_stack_free() when it's finished. That's probably your problem. You're doing a malloc and free for every single particle in your system, each frame.
I reckon Retired Ninja has the right idea - use SDL_RenderDrawPoints() instead and just do the malloc and free once each frame.
Alternatively - use a different paradigm. Create an SDL_Surface once. Each frame, you blit all the pixels you need to ( by directly manipulating the pixel memory of the SDL_Surface by doing SDL_MapRGB() on a particular pixel ) and then when it comes to rendering, convert the SDL_Surface to a an SDL_Texture and present that to the renderer.
Some example code - if a Particle is a class and contains a pointer to an SDL_Surface, then you could have a draw function that looks like this:
void Particle::draw()
{
Uint32 x = m_position.getX();
Uint32 y = m_position.getY();
Uint32 * pixel = (Uint32*)m_screen->pixels+(y*(m_pitch/4))+x;
Uint8 r1 = 0;
Uint8 g1 = 0;
Uint8 b1 = 0;
Uint8 a1 = 0;
GFX_RGBA_FROM_PIXEL(*pixel, m_screen->format, &r1, &g1, &b1, &a1);
Uint32 * p = (Uint32*)m_screen->pixels+(y*(m_pitch/4))+x;
*p = SDL_MapRGB(m_screen->format, m_r, m_g, m_b);
}
Where GFX_RGBA_FROM_PIXEL is (stolen from Andreas Schiffler's SDL2_gfx library) and is defined as:
///////////////////////////////////////////////////////////////////
void GFX_RGBA_FROM_PIXEL(Uint32 pixel, SDL_PixelFormat * fmt, Uint8* r, Uint8* g, Uint8* b, Uint8* a)
{
*r = ((pixel&fmt->Rmask)>>fmt->Rshift)<<fmt->Rloss;
*g = ((pixel&fmt->Gmask)>>fmt->Gshift)<<fmt->Gloss;
*b = ((pixel&fmt->Bmask)>>fmt->Bshift)<<fmt->Bloss;
*a = ((pixel&fmt->Amask)>>fmt->Ashift)<<fmt->Aloss;
}
It might work faster. I haven't done any time tests but it might be worth it, as you're directly manipulating the colour of pixel memory, and then simply blitting it each frame. You're not doing any mallocs or frees.