CPU and RAM usage in OpenGL too high in Swift

Question

My game is set up so the the display controls the game loop, usual in Cocoa. The callback function calls run() which is this. The thing is, the thread running the callback is using 63% CPU and the RAM is constantly rising, slowly (memory leak?). I fixed it up a bit, before RAM used was 2.32 GB. The code in question is meant to draw one rotating emoji on the screen, which it does.

func run(){
    update()
    render()
}

Where render() calls draw() for all GameObjects is this:

func draw(graphic: Graphic2D) {

    programID = 0
    vaoID = 0
    vboID = 0
    eboID = 0
    vertexShader = 0
    fragmentShader = 0

    let vertices: [GLfloat] = [ -0.25, -0.25, graphic.colors[0].r, graphic.colors[0].g, graphic.colors[0].b, graphic.colors[0].a, 0.0, 0.0,
                                -0.25,  0.25, graphic.colors[1].r, graphic.colors[1].g, graphic.colors[1].b, graphic.colors[1].a, 0.0, 1.0,
                                 0.25,  0.25, graphic.colors[2].r, graphic.colors[2].g, graphic.colors[2].b, graphic.colors[2].a, 1.0, 1.0,
                                 0.25, -0.25, graphic.colors[3].r, graphic.colors[3].g, graphic.colors[3].b, graphic.colors[3].a, 1.0, 0.0 ]

    let indices: [GLuint] = [ 0, 1, 2,
                              2, 3, 0 ]

    let translationMat = GLKMatrix4Translate(GLKMatrix4Identity, graphic.position.x, graphic.position.y, 0)
    let rotationMat = GLKMatrix4RotateZ(GLKMatrix4Identity, graphic.rotation)
    finalTransform = GLKMatrix4Multiply(translationMat, rotationMat)

    let texURL = NSBundle.mainBundle().URLForResource(graphic.textures[0].pathName, withExtension: graphic.textures[0].fileType)

    let texInfo: GLKTextureInfo? = try? GLKTextureLoader.textureWithContentsOfURL(texURL!, options: [GLKTextureLoaderGenerateMipmaps : 1 , GLKTextureLoaderOriginBottomLeft : 1])



    var shaderSource: String

    glGenBuffers(1, &vboID)
    glGenBuffers(1, &eboID)

    glTexParameteri(GLenum(GL_TEXTURE_2D), GLenum(GL_TEXTURE_MIN_FILTER), GL_LINEAR)
    glTexParameteri(GLenum(GL_TEXTURE_2D), GLenum(GL_TEXTURE_MAG_FILTER), GL_LINEAR)
    glTexParameteri(GLenum(GL_TEXTURE_2D), GLenum(GL_TEXTURE_WRAP_S), GL_CLAMP_TO_EDGE)
    glTexParameteri(GLenum(GL_TEXTURE_2D), GLenum(GL_TEXTURE_WRAP_T), GL_CLAMP_TO_EDGE)


    glGenVertexArrays(1, &vaoID)

    vertexShader = glCreateShader(GLenum(GL_VERTEX_SHADER))
    fragmentShader = glCreateShader(GLenum(GL_FRAGMENT_SHADER))

    shaderSource = graphic.shaders.vertexShader
    var vsptr = getShaderRef(shaderSource)
    glShaderSource(vertexShader, 1, &vsptr, nil)
    glCompileShader(vertexShader)

    var success: GLint = 0
    glGetShaderiv(vertexShader, GLbitfield(GL_COMPILE_STATUS), &success)
    if success <= 0 { Swift.print("ERROR O00:: vertex shader compile error")
                      Swift.print(shaderSource)}

    shaderSource = graphic.shaders.fragmentShader
    var fsptr = getShaderRef(shaderSource)
    glShaderSource(fragmentShader, 1, &fsptr, nil)
    glCompileShader(fragmentShader)

    glGetShaderiv(fragmentShader, GLbitfield(GL_COMPILE_STATUS), &success)
    if success <= 0 { Swift.print("ERROR O01:: fragment shader compile error")
                      Swift.print(shaderSource)}

    programID = glCreateProgram()

    glAttachShader(programID, vertexShader)
    glAttachShader(programID, fragmentShader)
    glLinkProgram(programID)

    glGetProgramiv(programID, GLbitfield(GL_LINK_STATUS), &success)
    if success <= 0 { Swift.print("ERROR O02:: program compile error") }

    glDetachShader(programID, vertexShader)
    glDetachShader(programID, fragmentShader)

    glDeleteShader(vertexShader)
    glDeleteShader(fragmentShader)


    glBindVertexArray(vaoID)

        glBindBuffer(GLenum(GL_ARRAY_BUFFER), vboID)
        glBufferData(GLenum(GL_ARRAY_BUFFER), vertices.count * sizeof(GLfloat), vertices, GLenum(GL_STATIC_DRAW))

        glBindBuffer(GLenum(GL_ELEMENT_ARRAY_BUFFER), eboID)
        glBufferData(GLenum(GL_ELEMENT_ARRAY_BUFFER), indices.count * sizeof(GLuint), indices, GLenum(GL_STATIC_DRAW))

        glVertexAttribPointer(0, 2, GLenum(GL_FLOAT), GLboolean(GL_FALSE), 32, UnsafePointer<GLuint>(bitPattern: 0))
        glEnableVertexAttribArray(0)

        glVertexAttribPointer(1, 4, GLenum(GL_FLOAT), GLboolean(GL_FALSE), 32, UnsafePointer<GLuint>(bitPattern: 8))
        glEnableVertexAttribArray(1)

        glVertexAttribPointer(2, 2, GLenum(GL_FLOAT), GLboolean(GL_FALSE), 32, UnsafePointer<GLuint>(bitPattern: 24))
        glEnableVertexAttribArray(2)

    glBindVertexArray(0)


    glActiveTexture(GLenum(GL_TEXTURE0))
    if texInfo != nil {
        glBindTexture(texInfo!.target, texInfo!.name)
    }

    let transLocation = glGetUniformLocation(programID, "transform")

    glUseProgram(programID)


    glBindVertexArray(vaoID)


    glUniformMatrix4fv(transLocation, 1, 0, finalTransform.array)
    glDrawElements(GLenum(GL_TRIANGLES), 6, GLenum(GL_UNSIGNED_INT), UnsafePointer<Void>(bitPattern: 0))

    glBindVertexArray(0)

    if texInfo != nil {
        var name = texInfo?.name
        glBindTexture(texInfo!.target, 0)
        glDeleteTextures(1, &name!)
    }

    glDeleteVertexArrays(1, &vaoID)
    glDeleteBuffers(1, &vboID)
    glDeleteBuffers(1, &eboID)
    glDeleteProgram(programID)

}

Answer 1

The first issue is that you are re-creating and destroying the buffers, reloading the texture, and recompiling the shader on every single draw loop.

This is the source of the huge CPU usage.

As for the memory going up, there could be a memory leak in the scripting language you are using.

Not recreating everything on every loop will probably reduce the impact to practically nothing.

Create a LoadEverything() function that is called once when your program start.

Cheers,