[utils] Support CPU/GPU stats analytics

[raysan5]

It could be useful to keep track of some CPU/GPU analytics, like memory usage.

Info already displayed on initialization: GPU vendor, renderer, version, GLSL version

Data loading memory usage:

• CPU: Images / Sounds / MusicStream / Font.chars
• GPU: Textures / Shaders / Meshes / Font.texture

Data loading can be registered with: RL_MALLOC() / RL_CALLOC() / RL_FREE()

enum StatsMemType {
    CPU_RAW_DATA,
    CPU_VERTEX_DATA, 
    CPU_IMAGE, 
    CPU_TEXT, 
    CPU_FONT_DATA,
    CPU_AUDIO_BUFFER, 
    GPU_VERTEX_BUFFER, 
    GPU_TEXTURE, 
    GPU_SHADER, 
    GPU_FBO
} StatsMemType;

// Global memory usage stats
struct StatsMemAlloc {
    int id;
    int type;               // StatsMemType 
    unsigned int size;      // Size in bytes
} StatsMemAlloc;

#define STATS_MEM_RECORD(int type, int size) StatsMemAlloc(type, size)

• GPU memory allocations (VRAM): glBufferData(), glTexImage2D(), glShaderSource()
• Frame times: updateTime, drawTime, idleTime
• Draw calls counter (and batching)
• Textures information (# textures, id, format, samplerState)

This issue is a draft, just some notes. Need to think about the best way to organize/record this information.

typedef struct GpuStats {	// 1 frame? General? → FrameStats?
	int drawsCount;
	int vertexCount;
	int trianglesCount;
	int texturesCount;	// total? used in frame?
	int texturesMemory;	// in bytes
	int vertexMemory;	// in bytes, in CPU/GPU?
	float timeUpdate;	// in seconds
	float timeDraw;		
	float timeIdle;
} GpuStats;

[Obscure2020]

Most games on Steam list their minimum required RAM and VRAM. It would be handy to have some sort of way to get a raylib program to spit out the maximum amount of RAM and VRAM it ever used while running, so that we know what to put for the minimum required stats for games we publish that were made using raylib. What do you think?

[raysan5]

@Obscure2020 Actually that's some of the information intended to be provided by this new feature.

[Obscure2020]

Wonderful. I am in support of these features!

@raysan5 Maybe the big GPU and CPU profiler https://github.com/wolfpld/tracy/ can give some impressions.

[jmorel33]

I up vote this, and would enjoy a way to know what OpenGL/GLSL support the system has prior to saying; yes the game will run fine.

[tokorv]

This sounds like a good idea.

[chriscamacho]

It would be useful to get the monitor frame rate if possible...

[jmorel33]

It would be useful to get the monitor frame rate if possible...

I personally have found an easy way to get the Monitor Refresh rate;
current_monitor = GetCurrentMonitor();
GetMonitorRefreshRate(current_monitor);

[raysan5]

I've been investigating this improvement a bit further. Supporting this kind of stats data requires hooking multiple functions and designing an specific system just for it. Here some ideas:

CPU RAM memory usage

Every time RL_*ALLOC is called, some memory is allocated. Functions involved:

// core
    LoadFileData();
    LoadFileText();

// textures
    LoadImage();
    LoadImageRaw();
    LoadImageAnim();
    LoadImageColors();
    LoadImagePalette();
    GenImage*();
    LoadTexture();
    LoadTextureFromImage();
    LoadTextureCubemap();
    LoadRenderTexture();

// text
    LoadFontEx();
    LoadFontFromImage();
    LoadFontData();
    
// models
    LoadModel();
    LoadModelFromMesh();
    UploadMesh();
    GenMesh*();
    LoadMaterials();
    LoadMaterialDefault();
    LoadModelAnimations();

// audio 
    LoadWave();
    LoadSound();
    LoadSoundFromWave();
    LoadWaveSamples();
    LoadMusicStream();
    LoadAudioBuffer();

GPU VRAM memory usage

All GPU memory allocations go through rlgl module:

    // Vertex buffers
    rlLoadVertexBuffer();            // glBufferData()
    rlLoadVertexBufferElement();     // glBufferData()

    // Textures
    rlLoadTexture();                 // glTexImage2D()
    rlLoadTextureDepth();            // glTexImage2D()
    rlLoadTextureCubemap();          // glTexImage2D()

    // FBO use texture attachments

    // Shaders
    rlLoadShaderProgram();           // glLinkProgram()

GPU one frame analytics

• Total time (delta time) -> CORE.Time
  • Update time
  • Draw time
  • Wait/idle time
• Draw passes info
  • Draw calls count -> RLGL.currentBatch->drawsCounter, only batching system!
  • Textures used
  • Shaders used
  • Fbo used
  • VBO used (total vertex processed)

GPU capabilities -> rlLoadExtensions() ✔️

• GPU model (vendor/renderer)
• OpenGL/GLSL version
• GL extensions supported
• GL limits supported
  • Max texture count/size
  • Max shader uniforms
  • Anisotropic levels
  • ETC.

This is some of the data that can be analyzed, the problem is that it requires lot of code automation to grab this data and a bunch of extra memory and structs to store this data properly. Also, most users probably don't care for this data, so, It should be possible to disabled the stats system if required.

[jmorel33]

Knowing gpu memory I find a useful metric as it can inflate fast if not careful or if out of control.

The other metric imho would be all of the features the GPU supports in order to know fi we can use either OpenGL 1.1 or 2.1 or 3.3 or greater.