GLFW OpenGL window slow to update on resize?

Question

I have a simple triangle program:

#include <cstddef>
#include<glad/glad.h>
#include<GLFW/glfw3.h>
#include<iostream>


void framebuffer_resize_callback(GLFWwindow *window,int width,int height)
{
    glViewport(0,0,width,height);   
}
void processInput(GLFWwindow *window)
{
    if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
    {
        glfwSetWindowShouldClose(window, GLFW_TRUE);
    }
}
void render()
{
    glClearColor(0.5,0.5,0.5,1.0);
    glClear(GL_COLOR_BUFFER_BIT);

    
    glDrawArrays(GL_TRIANGLES,0,3);
}

void opengl_setup(void)
{
    float verticies[] = {
        -0.5,-0.5,0.0,
        0.5,-0.5,0.0,
        0.0,0.5,0.0
    };
    unsigned int VAO;
    glGenVertexArrays(1,&VAO);
    glBindVertexArray(VAO);

    unsigned int VBO;
    glGenBuffers(1,&VBO);
    glBindBuffer(GL_ARRAY_BUFFER,VBO);
    glBufferData(GL_ARRAY_BUFFER,sizeof(verticies),verticies,GL_STATIC_DRAW);

    const char *vertexshadersource = "#version 460 core\n"
    "layout (location = 0) in vec3 aPos;\n"
    "void main()\n"
    "{\n"
    "   gl_Position = vec4(aPos.x,aPos.y,aPos.z,1.0);\n"
    "}\0";

    unsigned int vertexShader;
    vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader,1,&vertexshadersource,NULL);
    glCompileShader(vertexShader);

    int success;
    char infoLog[512];
    glGetShaderiv(vertexShader,GL_COMPILE_STATUS,&success);

    if(!success)
    {
        glGetShaderInfoLog(vertexShader,512,NULL,infoLog);
        std::cout << "ERROR::SHADER::VERTEX::COMPILATION FAILED\n" << infoLog;
    }

    unsigned int fragmentShader;
    fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    char *fragmentshadersource = "#version 460 core\n"
    "out vec4 FragColor;\n"
    "void main()\n"
    "{\n"
    "   FragColor = vec4(1.0,0.5,0.2,1.0);\n"
    "}\0";
    glShaderSource(fragmentShader,1,&fragmentshadersource,NULL);
    glCompileShader(fragmentShader);

   
    glGetShaderiv(fragmentShader,GL_COMPILE_STATUS,&success);

    if(!success)
    {
        glGetShaderInfoLog(fragmentShader,512,NULL,infoLog);
        std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION FAILED\n" << infoLog;
    }

    unsigned int shaderProgram;
    shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram,vertexShader);
    glAttachShader(shaderProgram,fragmentShader);
    glLinkProgram(shaderProgram);
    glGetProgramiv(shaderProgram,GL_LINK_STATUS,&success);

    if(!success)
    {
        glGetProgramInfoLog(shaderProgram,512,NULL,infoLog);
        std::cout << "ERROR::PROGRAM::LINKING FAILED\n" << infoLog;
    }

    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);
    glUseProgram(shaderProgram);

    glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,3*sizeof(float),(void*)0);
    glEnableVertexAttribArray(0);
    glBindVertexArray(VAO);

    
   

}
int main(void)
{
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    GLFWwindow *window = glfwCreateWindow(800, 600, "OpenGL", NULL, NULL);
    glfwMakeContextCurrent(window);
    if(window == NULL)
    {
        fprintf(stderr,"ERROR: could not create window!\n");
        glfwTerminate();
        exit(-1);
    }
    
    if(!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        fprintf(stderr,"ERROR: could not init glad\n");
        glfwTerminate();
        exit(-1);
    }
    
    glfwSetFramebufferSizeCallback(window, framebuffer_resize_callback);
    
    glViewport(0,0,800,600);
    opengl_setup();
    while(!glfwWindowShouldClose(window))
    {
        processInput(window);
        render();
        glfwSwapBuffers(window);
        glfwPollEvents();
    }
    glfwTerminate();

    return 0;
}

...however the render of the triangle slightly lags behind the resizing of the window.

I used glGetString(GL_RENDERER) to confirm that openGL is using my AMD Radeon RX 570 and not the software renderer, so I don't know what might be causing this issue.

Can anyone help explain this lag drawing a triangle of 3 vertices?

System: Fedora 38, OpenGl 4.6, AMD Radeon RX 570