Performance

[8Observer8]

This is a branch of the thread that was started from the post.

As a result of testing the following example in PySDL3 0.9.8b1 + PyOpenGL 3.1.9 API works better on my weak laptop with CPU i3-2330M than on more powerful ajitid's AMD CPU:

pip install PySDL3 PyOpenGL

main.py

import ctypes
import os

import OpenGL.GL as gl

os.environ["SDL_MAIN_USE_CALLBACKS"] = "1"
os.environ["SDL_RENDER_DRIVER"] = "opengl"

import sdl3

glContext = None
window = None

@sdl3.SDL_AppInit_func
def SDL_AppInit(appstate, argc, argv):
    global glContext
    global window

    sdl3.SDL_Init(sdl3.SDL_INIT_VIDEO)
    window = sdl3.SDL_CreateWindow("Example".encode(), 350, 350, sdl3.SDL_WINDOW_OPENGL)
    glContext = sdl3.SDL_GL_CreateContext(window)

    sdl3.SDL_GL_SetSwapInterval(1) # Turn on vertical sync

    return sdl3.SDL_APP_CONTINUE

@sdl3.SDL_AppEvent_func
def SDL_AppEvent(appstate, event):
    if sdl3.SDL_DEREFERENCE(event).type == sdl3.SDL_EVENT_QUIT:
        return sdl3.SDL_APP_SUCCESS
    
    return sdl3.SDL_APP_CONTINUE

@sdl3.SDL_AppIterate_func
def SDL_AppIterate(appstate):
    gl.glClearColor(0.1, 0.3, 0.2, 1)
    gl.glClear(gl.GL_COLOR_BUFFER_BIT)
    sdl3.SDL_GL_SwapWindow(window)
    return sdl3.SDL_APP_CONTINUE

@sdl3.SDL_AppQuit_func
def SDL_AppQuit(appstate, result):
    global glContext
    sdl3.SDL_GL_DestroyContext(glContext)
    # SDL will clean up the window/renderer for us

My result:

ajitid's result:

But when we run this C + SDL3 + OpenGL example it works well for ajitid's AMD CPU and my Intel 3000 HD GPU:

My result:

ajitid's result:

I see an issue for my GPU in the example above. GPU is 31.1% in Python and 0% in C.

[8Observer8]

@ajitid try to use this:

sdl3.SDL_GL_SetSwapInterval(1) # Turn on vertical sync

You can add it after the if not context: block of code:

    if not context:
        print(f"Failed to create OpenGL context: {sdl3.SDL_GetError().decode()}.", flush = True)
        return -1

    sdl3.SDL_GL_SetSwapInterval(1) # Turn on vertical sync

[8Observer8]

This was the SDL3 API above. I expected both of your EXEs to show the same result on your machine like with PySDL3. Please test two more EXEs in OpenGL with SDL3 and C:

swap-interval-opengl-sdl3-c-exe.zip

I use SDL3.dll v3.1.10 in this example.

My result:

main.c

#define SDL_MAIN_USE_CALLBACKS 1 // Use the callbacks instead of main()

#include <SDL3/SDL.h>
#include <SDL3/SDL_main.h>
#include <glad/glad.h>

static SDL_Window *window = NULL;
SDL_GLContext glContext;

// This function runs once at startup
SDL_AppResult SDL_AppInit(void **appState, int argc, char *argv[])
{
    if (!SDL_Init(SDL_INIT_VIDEO))
    {
        SDL_Log("Couldn't initialize SDL: %s", SDL_GetError());
        return SDL_APP_FAILURE;
    }

    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); // Enable MULTISAMPLE
    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 2); // can be 2, 4, 8 or 16

    const char *title = "Example";
    size_t canvasWidth = 350;
    size_t canvasHeight = 350;
    window = SDL_CreateWindow(title, canvasWidth, canvasHeight, SDL_WINDOW_OPENGL);
    if (!window)
    {
        SDL_Log("Couldn't create the window: %s", SDL_GetError());
        return SDL_APP_FAILURE;
    }

    glContext = SDL_GL_CreateContext(window);
    if (!glContext)
    {
        SDL_Log("Couldn't create the glContext: %s", SDL_GetError());
        return SDL_APP_FAILURE;
    }

    SDL_GL_SetSwapInterval(1); // Turn on vertical sync

    if (!gladLoadGL())
    {
        SDL_Log("Failed to initialize OpenGL function pointers");
        return SDL_APP_FAILURE;
    }

    glClearColor(50.f / 255.f, 100.f / 255.f, 50.f / 255.f, 1.f);
    glViewport(0, 0, canvasWidth, canvasHeight);

    return SDL_APP_CONTINUE; // Carry on with the program
}

// This function runs when a new event (mouse input, keypresses, etc) occurs
SDL_AppResult SDL_AppEvent(void *appState, SDL_Event *event)
{
    switch (event->type)
    {
        case SDL_EVENT_QUIT:
        {
            return SDL_APP_SUCCESS;
            break;
        }
        default:
            break;
    }
    return SDL_APP_CONTINUE; // Carry on with the program
}

// This function runs once per frame, and is the heart of the program
SDL_AppResult SDL_AppIterate(void *appState)
{
    glClear(GL_COLOR_BUFFER_BIT);

    // Draw your stuff here
    // ...

    // Update the screen
    SDL_GL_SwapWindow(window);
    return SDL_APP_CONTINUE; // Carry on with the program
}

// This function runs once at shutdown
void SDL_AppQuit(void *appState, SDL_AppResult result)
{
    SDL_GL_DestroyContext(glContext);
    // SDL will clean up the window for us
}

CMakeLists.txt

cmake_minimum_required(VERSION 3.21)
project(swap-interval-opengl-sdl3-c LANGUAGES C)
add_executable(app WIN32)

target_include_directories(app PRIVATE ./libs/glad-2.0.8/include)

# Specify where the application source files are stored
target_sources(app
PRIVATE
    ./libs/glad-2.0.8/src/glad.c
    src/main.c
)

find_package(SDL3)
target_link_libraries(app PRIVATE SDL3::SDL3)

config.bat

cmake -G "MinGW Makefiles" -S . -B dist ^
-DSDL3_DIR=./libs/sdl-3.1.6-mingw/win/lib/cmake/SDL3 ^
-DCMAKE_BUILD_TYPE=Release

build.bat

cd dist
cmake --build .
cd ..

Source code with SDL3 3.1.6 and GLAD 2.0.8 included: swap-interval-opengl-sdl3-c.zip - 6.43 MB

To build it:

• Download MinGW GCC 11.2 using Mediafire or from TeraBox (zip - 182.3 MB, unzipped - 571 MB). This version of MinGW was taken from Qt 6.6.3
• Install CMake
  -- Link 1: https://github.com/kitware/cmake/releases
  -- Link 2: https://cmake.org/download/
• cd swap-interval-sdl3-c
• Type in CMD:
  -- config
  -- build
  -- and this command to run: dist\app

[8Observer8]

ajitid's answer:

Hi. This is the result:

Power usage in app-swap-interval-0.exe fluctuates between Very Low, Low and Moderate

[8Observer8]

I find it strange that both EXEs show the same % for CPU in C, OpenGL demos above. SwapInterval=0 should be higher. It's good that SwapInterval=1 is low. But you're right. It looks like PySDL3 + OpenGL has the problem you demonstrated in this post, because SwapInterval=1 should show a low %, both for C and PySDL3.

Please for the full picture make the last comparison of % CPU for PySDL3 API without OpenGL API. I opened GPU tab and see that GPU consumption on my machine is 15 - 30% - I think it because I have the integrated video card on my laptop. I have added the GPU tab to the screenshots in the previous posts.

1) SwapInterval=1

Sometimes % of GPU is 15:

2) SwapInterval=0 (CPU and especially GPU is very high for me)

main.py

import ctypes
import os

os.environ["SDL_MAIN_USE_CALLBACKS"] = "1"
os.environ["SDL_RENDER_DRIVER"] = "opengl"

import sdl3

renderer = ctypes.POINTER(sdl3.SDL_Renderer)()
window = ctypes.POINTER(sdl3.SDL_Window)()

@sdl3.SDL_AppInit_func
def SDL_AppInit(appstate, argc, argv):
    if not sdl3.SDL_Init(sdl3.SDL_INIT_VIDEO):
        sdl3.SDL_Log("Couldn't initialize SDL: %s".encode() % sdl3.SDL_GetError())
        return sdl3.SDL_APP_FAILURE

    title = "Background color using PySDL3".encode()
    if not sdl3.SDL_CreateWindowAndRenderer(title, 350, 350, 0, window, renderer):
        sdl3.SDL_Log("Couldn't create window/renderer: %s".encode() % sdl3.SDL_GetError())
        return sdl3.SDL_APP_FAILURE

    sdl3.SDL_SetRenderVSync(renderer, 1) # Turn on vertical sync

    return sdl3.SDL_APP_CONTINUE

@sdl3.SDL_AppEvent_func
def SDL_AppEvent(appstate, event):
    if sdl3.SDL_DEREFERENCE(event).type == sdl3.SDL_EVENT_QUIT:
        return sdl3.SDL_APP_SUCCESS

    return sdl3.SDL_APP_CONTINUE

@sdl3.SDL_AppIterate_func
def SDL_AppIterate(appstate):
    sdl3.SDL_SetRenderDrawColor(renderer, 50, 50, 50, sdl3.SDL_ALPHA_OPAQUE)
    sdl3.SDL_RenderClear(renderer)
    # Draw your stuff here
    # ...
    sdl3.SDL_RenderPresent(renderer)
    return sdl3.SDL_APP_CONTINUE

@sdl3.SDL_AppQuit_func
def SDL_AppQuit(appstate, result):
    ... # SDL will clean up the window/renderer for us

[8Observer8]

ajitid's answer:

Hi! The code you provided only mentions sdl3.SDL_SetRenderVSync(renderer, 1) and doesn't mention sdl3.SDL_GL_SetSwapInterval(1). Do you want me to add that?

Anyway, I'll provide screenshots for all the four combo:

sdl3.SDL_SetRenderVSync(renderer, 1)
sdl3.SDL_GL_SetSwapInterval(1)

sdl3.SDL_SetRenderVSync(renderer, 1)
sdl3.SDL_GL_SetSwapInterval(0)

sdl3.SDL_SetRenderVSync(renderer, 0)
sdl3.SDL_GL_SetSwapInterval(1)

sdl3.SDL_SetRenderVSync(renderer, 0)
sdl3.SDL_GL_SetSwapInterval(0)

[8Observer8]

These functions do the same thing. It's important which you called last.

These are two different ways for using SDL3:

1. SDL3 can be used for 2D drawing using its own SDL_Renderer. In this case you should use SDL_SetRenderVSync(renderer, 1) or SDL_GL_SetSwapInterval(1). You cannot use OpenGL functions for drawing in this case. For example, you can draw a rectangle using SDL_RenderFillRect(renderer, rect). Example in PySDL3: filled rectangle
2. SDL3 can be used for 2D and 3D drawing using OpenGL API directly. In this case you should use SDL_GL_SetSwapInterval(1). You cannot use SDL API functions and SDL_Renderer for drawing in this case. Maybe you can, but it doesn't make sense in my opinion. For example, a rectangle can be drawing using two triangles, VBO, glDrawArrays and so on. Example in PySDL3: Rotated rectangles. SDL3 is used for window, event handling and so on.

But it the case of SDL_Renderer it is not difference what to use: SDL_SetRenderVSync(renderer, 1) or SDL_GL_SetSwapInterval(1). If you use both the last will be applied.

As we can see the SDL_Renderer works normal as expected for both - C and Python:

1. Your result in C and SDL_Renderer:

2. Your result in Python and SDL_Renderer:

But for using SDL3 for drawing with pure OpenGL functions the picture is different for C and Python:

1. Your result in C and OpenGL API:

My result in C and OpenGL API:

2. Your result in Python and OpenGL API:

My result in PySDL3 and OpenGL API:

So, for PySDL3 + OpenGL API you have the high CPU usage on your computer and I have the low CPU usage on my laptop for the same example. And I have the high GPU usage on my computer for PySDL3 + OpenGL and I have the low GPU usage for C, SDL3, and OpenGL API.