From 61b4545d541527ca2bd76811195b964595db7ed1 Mon Sep 17 00:00:00 2001 From: Carl Worth Date: Tue, 15 Oct 2013 20:23:08 -0700 Subject: [PATCH] Aggregate non-shader GPU operations into their own operations These operations are named after representative functions, (glClear, glReadPixels, etc.). Aggregate time spent in any of these operations is sorted together with the existing reports for time spent in particular shader programs. The shader program times should now be more accurate since time spent in operations such as glClear will now no longer be accumulated into the most recently-used shader. --- eglwrap.c | 1 + glwrap.c | 1231 ++++++++++++++++++++++++++++++++++++++++++++++++++++- glxwrap.c | 2 + metrics.c | 128 ++++-- metrics.h | 44 +- 5 files changed, 1356 insertions(+), 50 deletions(-) diff --git a/eglwrap.c b/eglwrap.c index f74ae40..9e58389 100644 --- a/eglwrap.c +++ b/eglwrap.c @@ -112,6 +112,7 @@ eglMakeCurrent (EGLDisplay display, EGLSurface draw, EGLSurface read, EGLWRAP_DEFER_WITH_RETURN (ret, eglMakeCurrent, display, draw, read, context); + metrics_set_current_op (METRICS_OP_SHADER + 0); metrics_counter_start (); return ret; diff --git a/glwrap.c b/glwrap.c index ec03ce7..80c5e36 100644 --- a/glwrap.c +++ b/glwrap.c @@ -49,6 +49,11 @@ static void *gl_handle; +#define SWITCH_METRICS_OP(op) \ + metrics_counter_stop (); \ + metrics_set_current_op (op); \ + metrics_counter_start (); + void glwrap_set_gl_handle (void *handle) { @@ -111,11 +116,7 @@ glwrap_lookup (char *name) void glUseProgram (GLuint program) { - metrics_counter_stop (); - - metrics_set_current_program (program); - - metrics_counter_start (); + SWITCH_METRICS_OP (METRICS_OP_SHADER + program); GLWRAP_DEFER(glUseProgram, program); } @@ -123,11 +124,1223 @@ glUseProgram (GLuint program) void glUseProgramObjectARB (GLhandleARB programObj) { - metrics_counter_stop (); + SWITCH_METRICS_OP (METRICS_OP_SHADER + programObj); - metrics_set_current_program (programObj); + GLWRAP_DEFER(glUseProgramObjectARB, programObj); +} - metrics_counter_start (); +/* METRICS_OP_ACCUM */ +void +glAccum (GLenum op, GLfloat value) +{ + SWITCH_METRICS_OP (METRICS_OP_ACCUM); - GLWRAP_DEFER(glUseProgramObjectARB, programObj); + GLWRAP_DEFER (glAccum, op, value); +} + +void +glClearAccum (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + SWITCH_METRICS_OP (METRICS_OP_ACCUM); + + GLWRAP_DEFER (glClearAccum, red, green, blue, alpha); +} + +void +glClearAccumxOES (GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) +{ + SWITCH_METRICS_OP (METRICS_OP_ACCUM); + + GLWRAP_DEFER (glClearAccumxOES, red, green, blue, alpha); +} + +/* METRICS_OP_BUFFER_DATA */ +void +glBufferData (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage) +{ + SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA); + + GLWRAP_DEFER (glBufferData, target, size, data, usage); +} + +void +glNamedBufferDataEXT (GLuint buffer, GLsizeiptr size, const GLvoid *data, + GLenum usage) +{ + SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA); + + GLWRAP_DEFER (glNamedBufferDataEXT, buffer, size, data, usage); +} + +void +glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, + const GLvoid *data) +{ + SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA); + + GLWRAP_DEFER (glBufferSubData, target, offset, size, data); +} + +void +glNamedBufferSubDataEXT (GLuint buffer, GLintptr offset, GLsizeiptr size, + const GLvoid *data) +{ + SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA); + + GLWRAP_DEFER (glNamedBufferSubDataEXT, buffer, offset, size, data); +} + +void * +glMapBuffer (GLenum target, GLenum access) +{ + void *ret; + + SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA); + + GLWRAP_DEFER_WITH_RETURN (ret, glMapBuffer, target, access); + + return ret; +} + +void * +glMapBufferARB (GLenum target, GLenum access) +{ + void *ret; + + SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA); + + GLWRAP_DEFER_WITH_RETURN (ret, glMapBufferARB, target, access); + + return ret; +} + +void * +glMapBufferRange (GLenum target, GLintptr offset, GLsizeiptr length, + GLbitfield access) +{ + void *ret; + + SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA); + + GLWRAP_DEFER_WITH_RETURN (ret, glMapBufferRange, target, offset, + length, access); + + return ret; +} + +GLboolean +glUnmapBuffer (GLenum target) +{ + GLboolean ret; + + SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA); + + GLWRAP_DEFER_WITH_RETURN (ret, glUnmapBuffer, target); + + return ret; +} + +GLboolean +glUnmapNamedBufferEXT (GLuint buffer) +{ + GLboolean ret; + + SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA); + + GLWRAP_DEFER_WITH_RETURN (ret, glUnmapNamedBufferEXT, buffer); + + return ret; +} + +GLboolean +glUnmapBufferARB (GLenum target) +{ + GLboolean ret; + + SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA); + + GLWRAP_DEFER_WITH_RETURN (ret, glUnmapBufferARB, target); + + return ret; +} + +void +glFlushMappedBufferRange (GLenum target, GLintptr offset, GLsizeiptr length) +{ + SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA); + + GLWRAP_DEFER (glFlushMappedBufferRange, target, offset, length); +} + +void +glFlushMappedBufferRangeAPPLE (GLenum target, GLintptr offset, GLsizeiptr size) +{ + SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA); + + GLWRAP_DEFER (glFlushMappedBufferRangeAPPLE, target, offset, size); +} + +void +glFlushMappedNamedBufferRangeEXT (GLuint buffer, GLintptr offset, + GLsizeiptr length) +{ + SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA); + + GLWRAP_DEFER (glFlushMappedNamedBufferRangeEXT, buffer, offset, length); +} + +void * +glMapNamedBufferEXT (GLuint buffer, GLenum access) +{ + void *ret; + + SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA); + + GLWRAP_DEFER_WITH_RETURN (ret, glMapNamedBufferEXT, buffer, access); + + return ret; +} + +void * +glMapNamedBufferRangeEXT (GLuint buffer, GLintptr offset, GLsizeiptr length, + GLbitfield access) +{ + void *ret; + + SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA); + + GLWRAP_DEFER_WITH_RETURN (ret, glMapNamedBufferRangeEXT, buffer, + offset, length, access); + + return ret; +} + +/* METRICS_OP_BUFFER_SUB_DATA */ +void +glCopyBufferSubData (GLenum readTarget, GLenum writeTarget, + GLintptr readOffset, GLintptr writeOffset, + GLsizeiptr size) +{ + SWITCH_METRICS_OP (METRICS_OP_BUFFER_SUB_DATA); + + GLWRAP_DEFER (glCopyBufferSubData, readTarget, writeTarget, + readOffset, writeOffset, size); +} + +void +glNamedCopyBufferSubDataEXT (GLuint readBuffer, GLuint writeBuffer, + GLintptr readOffset, GLintptr writeOffset, + GLsizeiptr size) +{ + SWITCH_METRICS_OP (METRICS_OP_BUFFER_SUB_DATA); + + GLWRAP_DEFER (glNamedCopyBufferSubDataEXT, readBuffer, + writeBuffer, readOffset, writeOffset, size); +} + +/* METRICS_OP_BITMAP */ +void +glBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, + GLfloat xmove, GLfloat ymove, const GLubyte *bitmap) +{ + SWITCH_METRICS_OP (METRICS_OP_BITMAP); + + GLWRAP_DEFER (glBitmap, width, height, xorig, yorig, + xmove, ymove, bitmap); +} + +void +glBitmapxOES (GLsizei width, GLsizei height, GLfixed xorig, GLfixed yorig, + GLfixed xmove, GLfixed ymove, const GLubyte *bitmap) +{ + SWITCH_METRICS_OP (METRICS_OP_BITMAP); + + GLWRAP_DEFER (glBitmapxOES, width, height, xorig, yorig, + xmove, ymove, bitmap); +} + +/* METRICS_OP_BLIT_FRAMEBUFFER */ +void +glBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, + GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, + GLbitfield mask, GLenum filter) +{ + SWITCH_METRICS_OP (METRICS_OP_BLIT_FRAMEBUFFER); + + GLWRAP_DEFER (glBlitFramebuffer, srcX0, srcY0, srcX1, srcY1, + dstX0, dstY0, dstX1, dstY1, mask, filter); +} + +void +glBlitFramebufferEXT (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, + GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, + GLbitfield mask, GLenum filter) +{ + SWITCH_METRICS_OP (METRICS_OP_BLIT_FRAMEBUFFER); + + GLWRAP_DEFER (glBlitFramebufferEXT, srcX0, srcY0, srcX1, srcY1, + dstX0, dstY0, dstX1, dstY1, mask, filter); +} + +/* METRICS_OP_CLEAR */ +void +glClear (GLbitfield mask) +{ + SWITCH_METRICS_OP (METRICS_OP_CLEAR); + + GLWRAP_DEFER (glClear, mask); +} + +void +glClearBufferfi (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + SWITCH_METRICS_OP (METRICS_OP_CLEAR); + + GLWRAP_DEFER (glClearBufferfi, buffer, drawbuffer, depth, stencil); +} + +void +glClearBufferfv (GLenum buffer, GLint drawbuffer, const GLfloat *value) +{ + SWITCH_METRICS_OP (METRICS_OP_CLEAR); + + GLWRAP_DEFER (glClearBufferfv, buffer, drawbuffer, value); +} + +void +glClearBufferiv (GLenum buffer, GLint drawbuffer, const GLint *value) +{ + SWITCH_METRICS_OP (METRICS_OP_CLEAR); + + GLWRAP_DEFER (glClearBufferiv, buffer, drawbuffer, value); +} + +void +glClearBufferuiv (GLenum buffer, GLint drawbuffer, const GLuint *value) +{ + SWITCH_METRICS_OP (METRICS_OP_CLEAR); + + GLWRAP_DEFER (glClearBufferuiv, buffer, drawbuffer, value); +} + +/* METRICS_OP_CLEAR_BUFFER_DATA */ + +void +glClearBufferData (GLenum target, GLenum internalformat, GLenum format, + GLenum type, const void *data) +{ + SWITCH_METRICS_OP (METRICS_OP_CLEAR_BUFFER_DATA); + + GLWRAP_DEFER (glClearBufferData, target, internalformat, format, + type, data); +} + +void +glClearBufferSubData (GLenum target, GLenum internalformat, GLintptr offset, + GLsizeiptr size, GLenum format, GLenum type, + const void *data) +{ + SWITCH_METRICS_OP (METRICS_OP_CLEAR_BUFFER_DATA); + + GLWRAP_DEFER (glClearBufferSubData, target, internalformat, + offset, size, format, type, data); +} + +void +glClearNamedBufferDataEXT (GLuint buffer, GLenum internalformat, GLenum format, + GLenum type, const void *data) +{ + SWITCH_METRICS_OP (METRICS_OP_CLEAR_BUFFER_DATA); + + GLWRAP_DEFER (glClearNamedBufferDataEXT, buffer, internalformat, + format, type, data); +} + +void +glClearNamedBufferSubDataEXT (GLuint buffer, GLenum internalformat, + GLenum format, GLenum type, GLsizeiptr offset, + GLsizeiptr size, const void *data) +{ + SWITCH_METRICS_OP (METRICS_OP_CLEAR_BUFFER_DATA); + + GLWRAP_DEFER (glClearNamedBufferSubDataEXT, buffer, + internalformat, format, type, offset, size, data); +} + +/* METRICS_OP_CLEAR_TEX_IMAGE */ + + +/* METRICS_OP_COPY_PIXELS */ +void +glCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type ) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_PIXELS); + + GLWRAP_DEFER (glCopyPixels, x, y, width, height, type); +} + +/* METRICS_OP_COPY_TEX_IMAGE */ +void +glCopyTexImage1D (GLenum target, GLint level, GLenum internalformat, + GLint x, GLint y, GLsizei width, GLint border) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyTexImage1D, target, level, internalformat, + x, y, width, border); +} + +void +glCopyTexImage1DEXT (GLenum target, GLint level, GLenum internalformat, + GLint x, GLint y, GLsizei width, GLint border) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyTexImage1DEXT, target, level, internalformat, + x, y, width, border); +} + +void +glCopyTexImage2D (GLenum target, GLint level, GLenum internalformat, + GLint x, GLint y, GLsizei width, GLsizei height, + GLint border) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyTexImage2D, target, level, internalformat, + x, y, width, height, border); +} + +void +glCopyTexImage2DEXT (GLenum target, GLint level, GLenum internalformat, + GLint x, GLint y, GLsizei width, GLsizei height, + GLint border) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyTexImage2DEXT, target, level, internalformat, + x, y, width, height, border); +} + +void +glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, + GLint x, GLint y, GLsizei width) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyTexSubImage1D, target, level, xoffset, + x, y, width); +} + +void +glCopyTexSubImage1DEXT (GLenum target, GLint level, GLint xoffset, + GLint x, GLint y, GLsizei width) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyTexSubImage1DEXT, target, level, xoffset, + x, y, width); +} + +void +glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, + GLint yoffset, GLint x, GLint y, GLsizei width, + GLsizei height) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyTexSubImage2D, target, level, xoffset, yoffset, + x, y, width, height); +} + +void +glCopyTexSubImage2DEXT (GLenum target, GLint level, GLint xoffset, + GLint yoffset, GLint x, GLint y, GLsizei width, + GLsizei height) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyTexSubImage2DEXT, target, level, xoffset, yoffset, + x, y, width, height); +} + +void +glCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset, + GLint yoffset, GLint zoffset, GLint x, GLint y, + GLsizei width, GLsizei height) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyTexSubImage3D, target, level, xoffset, yoffset, + zoffset, x, y, width, height); +} + +void +glCopyTexSubImage3DEXT (GLenum target, GLint level, GLint xoffset, + GLint yoffset, GLint zoffset, GLint x, GLint y, + GLsizei width, GLsizei height) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyTexSubImage3DEXT, target, level, xoffset, yoffset, + zoffset, x, y, width, height); +} + +void +glCopyTextureImage1DEXT (GLuint texture, GLenum target, GLint level, + GLenum internalformat, GLint x, GLint y, + GLsizei width, GLint border) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyTextureImage1DEXT, texture, target, level, + internalformat, x, y, width, border); +} + +void +glCopyTextureImage2DEXT (GLuint texture, GLenum target, GLint level, + GLenum internalformat, GLint x, GLint y, GLsizei width, + GLsizei height, GLint border) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyTextureImage2DEXT, texture, target, + level, internalformat, x, y, width, height, border); +} + +void +glCopyTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level, + GLint xoffset, GLint x, GLint y, GLsizei width) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyTextureSubImage1DEXT, texture, target, level, + xoffset, x, y, width); +} + +void +glCopyTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level, + GLint xoffset, GLint yoffset, GLint x, GLint y, + GLsizei width, GLsizei height) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyTextureSubImage2DEXT, texture, target, level, + xoffset, yoffset, x, y, width, height); +} + +void +glCopyTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level, + GLint xoffset, GLint yoffset, GLint zoffset, + GLint x, GLint y, GLsizei width, GLsizei height) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyTextureSubImage3DEXT, texture, target, level, + xoffset, yoffset, zoffset, x, y, width, height); +} + +void +glCopyMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level, + GLenum internalformat, GLint x, GLint y, + GLsizei width, GLint border) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyMultiTexImage1DEXT, texunit, target, level, + internalformat, x, y, width, border); +} + +void +glCopyMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level, + GLenum internalformat, GLint x, GLint y, + GLsizei width, GLsizei height, GLint border) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyMultiTexImage2DEXT, texunit, target, level, + internalformat, x, y, width, height, border); +} + +void +glCopyMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level, + GLint xoffset, GLint x, GLint y, GLsizei width) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyMultiTexSubImage1DEXT, texunit, target, level, + xoffset, x, y, width); +} + +void +glCopyMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level, + GLint xoffset, GLint yoffset, GLint x, GLint y, + GLsizei width, GLsizei height) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyMultiTexSubImage2DEXT, texunit, target, level, + xoffset, yoffset, x, y, width, height); +} + +void +glCopyMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level, + GLint xoffset, GLint yoffset, GLint zoffset, + GLint x, GLint y, GLsizei width, GLsizei height) +{ + SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE); + + GLWRAP_DEFER (glCopyMultiTexSubImage3DEXT, texunit, target, level, + xoffset, yoffset, zoffset, x, y, width, height); +} + +/* METRICS_OP_DRAW_PIXELS */ +void +glDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type, + const GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_DRAW_PIXELS); + + GLWRAP_DEFER (glDrawPixels, width, height, format, type, pixels); +} + +/* METRICS_OP_GET_TEX_IMAGE */ + +void +glGetCompressedMultiTexImageEXT (GLenum texunit, GLenum target, + GLint lod, GLvoid *img) +{ + SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE); + + GLWRAP_DEFER (glGetCompressedMultiTexImageEXT, texunit, + target, lod, img); +} + +void +glGetCompressedTexImage (GLenum target, GLint level, GLvoid *img) +{ + SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE); + + GLWRAP_DEFER (glGetCompressedTexImage, target, level, img); +} + +void +glGetCompressedTexImageARB (GLenum target, GLint level, GLvoid *img) +{ + SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE); + + GLWRAP_DEFER (glGetCompressedTexImageARB, target, level, img); +} + +void +glGetCompressedTextureImageEXT (GLuint texture, GLenum target, + GLint lod, GLvoid *img) +{ + SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE); + + GLWRAP_DEFER (glGetCompressedTextureImageEXT, texture, + target, lod, img); +} + +void +glGetMultiTexImageEXT (GLenum texunit, GLenum target, GLint level, + GLenum format, GLenum type, GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE); + + GLWRAP_DEFER (glGetMultiTexImageEXT, texunit, + target, level, format, type, pixels); +} + +void +glGetnCompressedTexImageARB (GLenum target, GLint lod, + GLsizei bufSize, GLvoid *img) +{ + SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE); + + GLWRAP_DEFER (glGetnCompressedTexImageARB, target, lod, bufSize, img); +} + +void +glGetnTexImageARB (GLenum target, GLint level, GLenum format, + GLenum type, GLsizei bufSize, GLvoid *img) +{ + SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE); + + GLWRAP_DEFER (glGetnTexImageARB, target, level, + format, type, bufSize, img); +} + +void +glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, + GLvoid *pixels ) +{ + SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE); + + GLWRAP_DEFER (glGetTexImage, target, level, format, type, pixels); +} + +/* METRICS_OP_READ_PIXELS */ +void +glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, + GLenum format, GLenum type, GLvoid *pixels ) +{ + SWITCH_METRICS_OP (METRICS_OP_READ_PIXELS); + + GLWRAP_DEFER (glReadPixels, x, y, width, height, format, type, pixels); +} + +void +glReadnPixelsARB (GLint x, GLint y, GLsizei width, GLsizei height, + GLenum format, GLenum type, GLsizei bufSize, GLvoid *data) +{ + SWITCH_METRICS_OP (METRICS_OP_READ_PIXELS); + + GLWRAP_DEFER (glReadnPixelsARB, x, y, width, height, + format, type, bufSize, data); +} + +/* METRICS_OP_TEX_IMAGE */ +void +glTexImage1D (GLenum target, GLint level, GLint internalFormat, + GLsizei width, GLint border, GLenum format, GLenum type, + const GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glTexImage1D, target, level, internalFormat, width, + border, format, type, pixels); +} + +void +glTexImage2D (GLenum target, GLint level, GLint internalFormat, + GLsizei width, GLsizei height, GLint border, GLenum format, + GLenum type, const GLvoid *pixels ) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glTexImage2D, target, level, internalFormat, + width, height, border, format, type, pixels); +} + + +void +glTexImage2DMultisample (GLenum target, GLsizei samples, + GLint internalformat, GLsizei width, GLsizei height, + GLboolean fixedsamplelocations) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glTexImage2DMultisample, target, samples, + internalformat, width, height, fixedsamplelocations); +} + +void +glTexImage2DMultisampleCoverageNV (GLenum target, GLsizei coverageSamples, + GLsizei colorSamples, GLint internalFormat, + GLsizei width, GLsizei height, + GLboolean fixedSampleLocations) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glTexImage2DMultisampleCoverageNV, target, + coverageSamples, colorSamples, internalFormat, + width, height, fixedSampleLocations); +} + +void +glTexImage3D (GLenum target, GLint level, GLint internalformat, + GLsizei width, GLsizei height, GLsizei depth, GLint border, + GLenum format, GLenum type, const GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glTexImage3D, target, level, internalformat, + width, height, depth, border, format, type, pixels); +} + +void +glTexImage3DEXT (GLenum target, GLint level, GLenum internalformat, + GLsizei width, GLsizei height, GLsizei depth, GLint border, + GLenum format, GLenum type, const GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glTexImage3DEXT, target, level, internalformat, + width, height, depth, border, format, type, pixels); +} + +void +glTexImage3DMultisample (GLenum target, GLsizei samples, GLint internalformat, + GLsizei width, GLsizei height, GLsizei depth, + GLboolean fixedsamplelocations) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glTexImage3DMultisample, target, samples, + internalformat, width, height, depth, + fixedsamplelocations); +} + +void +glTexImage3DMultisampleCoverageNV (GLenum target, GLsizei coverageSamples, + GLsizei colorSamples, GLint internalFormat, + GLsizei width, GLsizei height, GLsizei depth, + GLboolean fixedSampleLocations) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glTexImage3DMultisampleCoverageNV, target, + coverageSamples, colorSamples, internalFormat, + width, height, depth, fixedSampleLocations); +} + +void +glTexImage4DSGIS (GLenum target, GLint level, GLenum internalformat, + GLsizei width, GLsizei height, GLsizei depth, + GLsizei size4d, GLint border, GLenum format, + GLenum type, const GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glTexImage4DSGIS, target, level, + internalformat, width, height, depth, + size4d, border, format, type, pixels); +} + +void +glTexSubImage1D (GLenum target, GLint level, GLint xoffset, + GLsizei width, GLenum format, GLenum type, + const GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glTexSubImage1D, target, level, xoffset, + width, format, type, pixels); +} + +void +glTexSubImage1DEXT (GLenum target, GLint level, GLint xoffset, + GLsizei width, GLenum format, GLenum type, + const GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glTexSubImage1DEXT, target, level, xoffset, + width, format, type, pixels); +} + +void +glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, + GLsizei width, GLsizei height, GLenum format, GLenum type, + const GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glTexSubImage2D, target, level, xoffset, yoffset, + width, height, format, type, pixels); +} + +void +glTexSubImage2DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, + GLsizei width, GLsizei height, GLenum format, GLenum type, + const GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glTexSubImage2DEXT, target, level, xoffset, yoffset, + width, height, format, type, pixels); +} + +void +glTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, + GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, + GLenum format, GLenum type, const GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glTexSubImage3D, target, level, xoffset, yoffset, + zoffset, width, height, depth, format, type, pixels); +} + +void +glTexSubImage3DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, + GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, + GLenum format, GLenum type, const GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glTexSubImage3DEXT, target, level, xoffset, yoffset, + zoffset, width, height, depth, format, type, pixels); +} + +void +glTexSubImage4DSGIS (GLenum target, GLint level, GLint xoffset, GLint yoffset, + GLint zoffset, GLint woffset, GLsizei width, + GLsizei height, GLsizei depth, GLsizei size4d, + GLenum format, GLenum type, const GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glTexSubImage4DSGIS, target, level, xoffset, + yoffset, zoffset, woffset, width, height, + depth, size4d, format, type, pixels); +} + +void +glCompressedMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level, + GLenum internalformat, GLsizei width, + GLint border, GLsizei imageSize, + const GLvoid *bits) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedMultiTexImage1DEXT, texunit, target, + level, internalformat, width, border, imageSize, bits); +} + +void +glCompressedMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level, + GLenum internalformat, GLsizei width, + GLsizei height, GLint border, + GLsizei imageSize, const GLvoid *bits) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedMultiTexImage2DEXT, texunit, target, level, + internalformat, width, height, border, imageSize, bits); +} + +void +glCompressedMultiTexImage3DEXT (GLenum texunit, GLenum target, GLint level, + GLenum internalformat, GLsizei width, + GLsizei height, GLsizei depth, GLint border, + GLsizei imageSize, const GLvoid *bits) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedMultiTexImage3DEXT, texunit, target, + level, internalformat, width, height, depth, + border, imageSize, bits); +} + +void +glCompressedMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level, + GLint xoffset, GLsizei width, GLenum format, + GLsizei imageSize, const GLvoid *bits) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedMultiTexSubImage1DEXT, texunit, target, + level, xoffset, width, format, imageSize, bits); +} + +void +glCompressedMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level, + GLint xoffset, GLint yoffset, GLsizei width, + GLsizei height, GLenum format, + GLsizei imageSize, const GLvoid *bits) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedMultiTexSubImage2DEXT, texunit, target, level, + xoffset, yoffset, width, height, format, imageSize, bits); +} + +void +glCompressedMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level, + GLint xoffset, GLint yoffset, GLint zoffset, + GLsizei width, GLsizei height, GLsizei depth, + GLenum format, GLsizei imageSize, + const GLvoid *bits) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedMultiTexSubImage3DEXT, texunit, target, + level, xoffset, yoffset, zoffset, width, height, + depth, format, imageSize, bits); +} + +void +glCompressedTexImage1D (GLenum target, GLint level, GLenum internalformat, + GLsizei width, GLint border, GLsizei imageSize, + const GLvoid *data) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedTexImage1D, target, level, + internalformat, width, border, imageSize, data); +} + +void +glCompressedTexImage1DARB (GLenum target, GLint level, GLenum internalformat, + GLsizei width, GLint border, GLsizei imageSize, + const GLvoid *data) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedTexImage1DARB, target, level, internalformat, + width, border, imageSize, data); +} + +void +glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, + GLsizei width, GLsizei height, GLint border, + GLsizei imageSize, const GLvoid *data) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedTexImage2D, target, level, internalformat, + width, height, border, imageSize, data); +} + +void +glCompressedTexImage2DARB (GLenum target, GLint level, GLenum internalformat, + GLsizei width, GLsizei height, GLint border, + GLsizei imageSize, const GLvoid *data) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedTexImage2DARB, target, level, internalformat, + width, height, border, imageSize, data); +} + +void +glCompressedTexImage3D (GLenum target, GLint level, GLenum internalformat, + GLsizei width, GLsizei height, GLsizei depth, + GLint border, GLsizei imageSize, const GLvoid *data) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedTexImage3D, target, level, internalformat, + width, height, depth, border, imageSize, data); +} + +void +glCompressedTexImage3DARB (GLenum target, GLint level, GLenum internalformat, + GLsizei width, GLsizei height, GLsizei depth, + GLint border, GLsizei imageSize, const GLvoid *data) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedTexImage3DARB, target, level, internalformat, + width, height, depth, border, imageSize, data); +} + +void +glCompressedTexSubImage1D (GLenum target, GLint level, GLint xoffset, + GLsizei width, GLenum format, GLsizei imageSize, + const GLvoid *data) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedTexSubImage1D, target, level, xoffset, + width, format, imageSize, data); +} + +void +glCompressedTexSubImage1DARB (GLenum target, GLint level, GLint xoffset, + GLsizei width, GLenum format, GLsizei imageSize, + const GLvoid *data) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedTexSubImage1DARB, target, level, xoffset, + width, format, imageSize, data); +} + +void +glCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, + GLint yoffset, GLsizei width, GLsizei height, + GLenum format, GLsizei imageSize, const GLvoid *data) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedTexSubImage2D, target, level, xoffset, + yoffset, width, height, format, imageSize, data); +} + +void +glCompressedTexSubImage2DARB (GLenum target, GLint level, GLint xoffset, + GLint yoffset, GLsizei width, GLsizei height, + GLenum format, GLsizei imageSize, + const GLvoid *data) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedTexSubImage2DARB, target, level, xoffset, + yoffset, width, height, format, imageSize, data); +} + +void +glCompressedTexSubImage3D (GLenum target, GLint level, GLint xoffset, + GLint yoffset, GLint zoffset, GLsizei width, + GLsizei height, GLsizei depth, GLenum format, + GLsizei imageSize, const GLvoid *data) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedTexSubImage3D, target, level, xoffset, + yoffset, zoffset, width, height, depth, format, + imageSize, data); +} + +void +glCompressedTexSubImage3DARB (GLenum target, GLint level, GLint xoffset, + GLint yoffset, GLint zoffset, GLsizei width, + GLsizei height, GLsizei depth, GLenum format, + GLsizei imageSize, const GLvoid *data) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedTexSubImage3DARB, target, level, xoffset, + yoffset, zoffset, width, height, depth, format, + imageSize, data); +} + +void +glCompressedTextureImage1DEXT (GLuint texture, GLenum target, GLint level, + GLenum internalformat, GLsizei width, + GLint border, GLsizei imageSize, + const GLvoid *bits) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedTextureImage1DEXT, texture, target, level, + internalformat, width, border, imageSize, bits); +} + +void +glCompressedTextureImage2DEXT (GLuint texture, GLenum target, GLint level, + GLenum internalformat, GLsizei width, + GLsizei height, GLint border, + GLsizei imageSize, const GLvoid *bits) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedTextureImage2DEXT, texture, target, level, + internalformat, width, height, border, imageSize, bits); +} + +void +glCompressedTextureImage3DEXT (GLuint texture, GLenum target, GLint level, + GLenum internalformat, GLsizei width, + GLsizei height, GLsizei depth, GLint border, + GLsizei imageSize, const GLvoid *bits) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedTextureImage3DEXT, texture, target, + level, internalformat, width, height, depth, + border, imageSize, bits); +} + +void +glCompressedTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level, + GLint xoffset, GLsizei width, GLenum format, + GLsizei imageSize, const GLvoid *bits) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedTextureSubImage1DEXT, texture, target, + level, xoffset, width, format, imageSize, bits); +} + +void +glCompressedTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level, + GLint xoffset, GLint yoffset, GLsizei width, + GLsizei height, GLenum format, + GLsizei imageSize, const GLvoid *bits) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedTextureSubImage2DEXT, texture, target, level, + xoffset, yoffset, width, height, format, imageSize, bits); +} + +void +glCompressedTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level, + GLint xoffset, GLint yoffset, GLint zoffset, + GLsizei width, GLsizei height, GLsizei depth, + GLenum format, GLsizei imageSize, + const GLvoid *bits) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glCompressedTextureSubImage3DEXT, texture, target, + level, xoffset, yoffset, zoffset, width, height, + depth, format, imageSize, bits); +} + +void +glMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level, + GLenum internalformat, GLsizei width, GLint border, + GLenum format, GLenum type, const GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glMultiTexImage1DEXT, texunit, target, level, + internalformat, width, border, format, type, pixels); +} + +void +glMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level, + GLenum internalformat, GLsizei width, GLsizei height, + GLint border, GLenum format, GLenum type, + const GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glMultiTexImage2DEXT, texunit, target, level, + internalformat, width, height, border, format, + type, pixels); +} + +void +glMultiTexImage3DEXT (GLenum texunit, GLenum target, GLint level, + GLenum internalformat, GLsizei width, GLsizei height, + GLsizei depth, GLint border, GLenum format, + GLenum type, const GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glMultiTexImage3DEXT, texunit, target, level, + internalformat, width, height, depth, border, + format, type, pixels); +} + +void +glMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level, + GLint xoffset, GLsizei width, GLenum format, + GLenum type, const GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glMultiTexSubImage1DEXT, texunit, target, level, + xoffset, width, format, type, pixels); +} + +void +glMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level, + GLint xoffset, GLint yoffset, GLsizei width, + GLsizei height, GLenum format, GLenum type, + const GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glMultiTexSubImage2DEXT, texunit, target, level, xoffset, + yoffset, width, height, format, type, pixels); +} + +void +glMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level, + GLint xoffset, GLint yoffset, GLint zoffset, + GLsizei width, GLsizei height, GLsizei depth, + GLenum format, GLenum type, const GLvoid *pixels) +{ + SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE); + + GLWRAP_DEFER (glMultiTexSubImage3DEXT, texunit, target, level, + xoffset, yoffset, zoffset, width, height, depth, + format, type, pixels); } diff --git a/glxwrap.c b/glxwrap.c index a57c557..eda3583 100644 --- a/glxwrap.c +++ b/glxwrap.c @@ -88,6 +88,7 @@ glXMakeCurrent (Display *dpy, GLXDrawable drawable, GLXContext ctx) GLWRAP_DEFER_WITH_RETURN (ret, glXMakeCurrent, dpy, drawable, ctx); + metrics_set_current_op (METRICS_OP_SHADER + 0); metrics_counter_start (); return ret; @@ -102,6 +103,7 @@ glXMakeContextCurrent (Display *dpy, GLXDrawable drawable, GLXDrawable read, GLX GLWRAP_DEFER_WITH_RETURN (ret, glXMakeContextCurrent, dpy, drawable, read, ctx); + metrics_set_current_op (METRICS_OP_SHADER + 0); metrics_counter_start (); return ret; diff --git a/metrics.c b/metrics.c index 39c90ad..327c270 100644 --- a/metrics.c +++ b/metrics.c @@ -33,28 +33,29 @@ typedef struct counter { unsigned id; - unsigned program; + + metrics_op_t op; struct counter *next; } counter_t; -typedef struct program_metrics +typedef struct op_metrics { /* This happens to also be the index into the - * ctx->program_metrics array currently + * ctx->op_metrics array currently */ - unsigned id; + metrics_op_t op; double time_ns; -} program_metrics_t; +} op_metrics_t; typedef struct context { - unsigned int program; + metrics_op_t op; counter_t *counter_head; counter_t *counter_tail; - unsigned num_program_metrics; - program_metrics_t *program_metrics; + unsigned num_op_metrics; + op_metrics_t *op_metrics; } context_t; /* FIXME: Need a map from integers to context objects and track the @@ -65,6 +66,51 @@ context_t current_context; int frames; int verbose; +static const char * +metrics_op_string (metrics_op_t op) +{ + if (op >= METRICS_OP_SHADER) + return "Shader program"; + + switch (op) + { + case METRICS_OP_ACCUM: + return "glAccum*(+)"; + case METRICS_OP_BUFFER_DATA: + return "glBufferData(+)"; + case METRICS_OP_BUFFER_SUB_DATA: + return "glCopyBufferSubData*"; + case METRICS_OP_BITMAP: + return "glBitmap*"; + case METRICS_OP_BLIT_FRAMEBUFFER: + return "glBlitFramebuffer*"; + case METRICS_OP_CLEAR: + return "glClear(+)"; + case METRICS_OP_CLEAR_BUFFER_DATA: + return "glCearBufferData(+)"; + case METRICS_OP_CLEAR_TEX_IMAGE: + return "glClearTexImage(+)"; + case METRICS_OP_COPY_PIXELS: + return "glCopyPixels"; + case METRICS_OP_COPY_TEX_IMAGE: + return "glCopyTexImage(+)"; + case METRICS_OP_DRAW_PIXELS: + return "glDrawPixels"; + case METRICS_OP_GET_TEX_IMAGE: + return "glGetTexImage(+)"; + case METRICS_OP_READ_PIXELS: + return "glReadPixels*"; + case METRICS_OP_TEX_IMAGE: + return "glTexImage*(+)"; + default: + fprintf (stderr, "Internal error: " + "Unknown metrics op value: %d\n", op); + exit (1); + } + + return ""; +} + void metrics_counter_start (void) { @@ -78,7 +124,7 @@ metrics_counter_start (void) glGenQueries (1, &counter->id); - counter->program = current_context.program; + counter->op = current_context.op; counter->next = NULL; if (current_context.counter_tail) { @@ -99,29 +145,29 @@ metrics_counter_stop (void) } void -metrics_set_current_program (unsigned program) +metrics_set_current_op (metrics_op_t op) { - current_context.program = program; + current_context.op = op; } static void -accumulate_program_time (unsigned program_id, unsigned time_ns) +accumulate_program_time (metrics_op_t op, unsigned time_ns) { context_t *ctx = ¤t_context; unsigned i; - if (program_id >= ctx->num_program_metrics) { - ctx->program_metrics = realloc (ctx->program_metrics, - (program_id + 1) * sizeof (program_metrics_t)); - for (i = ctx->num_program_metrics; i < program_id + 1; i++) { - ctx->program_metrics[i].id = i; - ctx->program_metrics[i].time_ns = 0.0; + if (op >= ctx->num_op_metrics) { + ctx->op_metrics = realloc (ctx->op_metrics, + (op + 1) * sizeof (op_metrics_t)); + for (i = ctx->num_op_metrics; i < op + 1; i++) { + ctx->op_metrics[i].op = i; + ctx->op_metrics[i].time_ns = 0.0; } - ctx->num_program_metrics = program_id + 1; + ctx->num_op_metrics = op + 1; } - ctx->program_metrics[program_id].time_ns += time_ns; + ctx->op_metrics[op].time_ns += time_ns; } static int @@ -129,7 +175,7 @@ time_compare(const void *in_a, const void *in_b, void *arg) { int a = *(const int *)in_a; int b = *(const int *)in_b; - struct program_metrics *metrics = arg; + struct op_metrics *metrics = arg; if (metrics[a].time_ns < metrics[b].time_ns) return -1; @@ -142,24 +188,24 @@ static void print_program_metrics (void) { context_t *ctx = ¤t_context; - unsigned i; - int *sorted; /* Sorted indices into the ctx->program_metrics */ + unsigned i, j; + int *sorted; /* Sorted indices into the ctx->op_metrics */ double total = 0; - /* Make a sorted list of the programs by time used, and figure - * out to total so we can print percentages. + /* Make a sorted list of the operations by time used, and figure + * out the total so we can print percentages. */ - sorted = calloc(ctx->num_program_metrics, sizeof(*sorted)); - for (i = 0; i < ctx->num_program_metrics; i++) { + sorted = calloc(ctx->num_op_metrics, sizeof(*sorted)); + for (i = 0; i < ctx->num_op_metrics; i++) { sorted[i] = i; - total += ctx->program_metrics[i].time_ns; + total += ctx->op_metrics[i].time_ns; } - qsort_r(sorted, ctx->num_program_metrics, sizeof(*sorted), - time_compare, ctx->program_metrics); + qsort_r(sorted, ctx->num_op_metrics, sizeof(*sorted), + time_compare, ctx->op_metrics); - for (i = 0; i < ctx->num_program_metrics; i++) { - struct program_metrics *metric = - &ctx->program_metrics[sorted[i]]; + for (i = 0; i < ctx->num_op_metrics; i++) { + const char *op_string; + op_metrics_t *metric =&ctx->op_metrics[sorted[i]]; /* Since we sparsely fill the array based on program * id, many "programs" have no time. @@ -167,8 +213,18 @@ print_program_metrics (void) if (metric->time_ns == 0.0) continue; - printf ("Program %d:\t%7.2f ms (% 2.1f%%)\n", - metric->id, metric->time_ns / 1e6, + op_string = metrics_op_string (metric->op); + + printf ("%s", op_string); + if (metric->op >= METRICS_OP_SHADER) { + printf (" %d:", metric->op - METRICS_OP_SHADER); + } else { + printf (":"); + for (j = strlen (op_string); j < 20; j++) + printf (" "); + } + printf ("\t%7.2f ms (% 2.1f%%)\n", + metric->time_ns / 1e6, metric->time_ns / total * 100); } } @@ -215,7 +271,7 @@ metrics_end_frame (void) glGetQueryObjectuiv (counter->id, GL_QUERY_RESULT, &elapsed); - accumulate_program_time (counter->program, elapsed); + accumulate_program_time (counter->op, elapsed); current_context.counter_head = counter->next; if (current_context.counter_head == NULL) diff --git a/metrics.h b/metrics.h index 8b68867..b5f9859 100644 --- a/metrics.h +++ b/metrics.h @@ -22,6 +22,34 @@ #ifndef METRICS_H #define METRICS_H +typedef enum +{ + METRICS_OP_ACCUM, + METRICS_OP_BUFFER_DATA, + METRICS_OP_BUFFER_SUB_DATA, + METRICS_OP_BITMAP, + METRICS_OP_BLIT_FRAMEBUFFER, + METRICS_OP_CLEAR, + METRICS_OP_CLEAR_BUFFER_DATA, + METRICS_OP_CLEAR_TEX_IMAGE, + METRICS_OP_COPY_PIXELS, + METRICS_OP_COPY_TEX_IMAGE, + METRICS_OP_DRAW_PIXELS, + METRICS_OP_GET_TEX_IMAGE, + METRICS_OP_READ_PIXELS, + METRICS_OP_TEX_IMAGE, + + /* METRICS_OP_SHADER must be last. + * + * All larger values for metrics_op_t are interpreted as: + * + * METRICS_OP_SHADER + shader_program_number + * + * to indicate a specific shader program. + */ + METRICS_OP_SHADER +} metrics_op_t; + /* Start accumulating GPU time. * * The time accumulated will be accounted against the @@ -34,14 +62,20 @@ metrics_counter_start (void); void metrics_counter_stop (void); -/* Set the ID of the currently executing shader program. +/* Set a metrics_op_t value to indicate what kind of operation is + * being performed. + * + * The metrics-tracking code will account for timings by accumulating + * measured counter values into a separate counter for each + * metrics_op_t value, (so that the report can describe which + * operations are the most expensive). * - * The metrics-tracking code will account for per-shader-program - * timings by accumulating counter values measured while each porogram - * is active (see metrics_add_counter). + * In addition, for the value METRICS_OP_SHADER, each specific shader + * program can be distinguished. To accomplish this, pass a value of + * METRICS_OP_SHADER + shader_program_number to this function. */ void -metrics_set_current_program (unsigned program); +metrics_set_current_op (metrics_op_t op); /* Should be called at the end of every function wrapper for a * function that ends a frame, (glXSwapBuffers and similar). -- 2.43.0