[PATCH v6 1/1] opengl32: speed up wow64 mapping.

[Etaash Mathamsetty]

From: Etaash Mathamsetty

---
 dlls/opengl32/unix_wgl.c | 121 ++++++++++++++++++++++++++++-----------
 1 file changed, 88 insertions(+), 33 deletions(-)

diff --git a/dlls/opengl32/unix_wgl.c b/dlls/opengl32/unix_wgl.c
index 453a9824046..4932930c27b 100644
--- a/dlls/opengl32/unix_wgl.c
+++ b/dlls/opengl32/unix_wgl.c
@@ -1852,28 +1852,70 @@ static void unmap_named_buffer( TEB *teb, GLint buffer )
     if (func) func( buffer );
 }

-static NTSTATUS wow64_map_buffer( TEB *teb, GLint buffer, GLenum target, void *ptr, SIZE_T size,
-                                  GLbitfield access, PTR32 *ret )
+static void gl_buffer_sub_data( TEB *teb, GLenum target, GLintptr offset, GLsizeiptr size, const void *data )
+{
+    const struct opengl_funcs *funcs = teb->glTable;
+    typeof(*funcs->ext.p_glBufferSubData) *func;
+    if (!(func = funcs->ext.p_glBufferSubData)) func = (void *)funcs->wgl.p_wglGetProcAddress( "glBufferSubData" );
+    if (func) func( target, offset, size, data );
+}
+
+static void gl_named_buffer_sub_data( TEB *teb, GLint buffer, GLintptr offset, GLsizeiptr size, const void *data )
+{
+    const struct opengl_funcs *funcs = teb->glTable;
+    typeof(*funcs->ext.p_glNamedBufferSubData) *func;
+    if (!(func = funcs->ext.p_glNamedBufferSubData)) func = (void *)funcs->wgl.p_wglGetProcAddress( "glNamedBufferSubData" );
+    if (func) func( buffer, offset, size, data );
+}
+
+static void gl_get_buffer_sub_data( TEB *teb, GLenum target, GLintptr offset, GLsizeiptr size, void *data )
+{
+    const struct opengl_funcs *funcs = teb->glTable;
+    typeof(*funcs->ext.p_glGetBufferSubData) *func;
+    if (!(func = funcs->ext.p_glGetBufferSubData)) func = (void *)funcs->wgl.p_wglGetProcAddress( "glGetBufferSubData" );
+    if (func) func( target, offset, size, data );
+}
+
+static void gl_get_named_buffer_sub_data( TEB *teb, GLint buffer, GLintptr offset, GLsizeiptr size, void *data )
+{
+    const struct opengl_funcs *funcs = teb->glTable;
+    typeof(*funcs->ext.p_glGetNamedBufferSubData) *func;
+    if (!(func = funcs->ext.p_glGetNamedBufferSubData)) func = (void *)funcs->wgl.p_wglGetProcAddress( "glGetNamedBufferSubData" );
+    if (func) func( buffer, offset, size, data );
+}
+
+static NTSTATUS wow64_map_buffer( TEB *teb, GLint buffer, GLenum target, void **ptr, GLintptr offset, SIZE_T size,
+                                  GLbitfield access, PTR32 *ret, NTSTATUS (*gl_map_buffer64)(void *), void *params )
 {
     static unsigned int once;

if (*ret)  /* wow64 pointer provided, map buffer to it */
     {
-        if (!(access & (GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT)))
-        {
-            if (!once++)
-                FIXME( "Doing a copy of a mapped buffer (expect performance issues)\n" );
+        /* getting sub buffer data for smaller buffers produces more overhead when size is small */
+        const BOOL do_memcpy = size < 0x5000;
+
+        if (!once++)
+            FIXME( "Doing a copy of a mapped buffer (expect performance issues)\n" );

-            TRACE( "Copying %#zx from buffer at %p to wow64 buffer %p\n", size, ptr, UlongToPtr(*ret) );
-            memcpy( UlongToPtr(*ret), ptr, size );
+        TRACE( "Copying %#zx from buffer at %p to wow64 buffer %p\n", size, ptr, UlongToPtr(*ret) );
+
+        if (!do_memcpy && !(access & (GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT)))
+        {
+            if (buffer)
+                gl_get_named_buffer_sub_data( teb, buffer, offset, size, UlongToPtr(*ret) );
+            else
+                gl_get_buffer_sub_data( teb, target, offset, size, UlongToPtr(*ret) );
         }

+        gl_map_buffer64(params);
+
+        if (do_memcpy) memcpy( UlongToPtr(*ret), *ptr, size );
+
         /* save the wow64 pointer in the buffer data, we'll overwrite it on unmap */
-        *(PTR32 *)ptr = (UINT_PTR)*ret;
+        *(PTR32 *)(*ptr) = (UINT_PTR)*ret;
         return STATUS_SUCCESS;
     }

-    if (ULongToPtr(*ret = PtrToUlong(ptr)) == ptr) return STATUS_SUCCESS;  /* we're lucky */
     if (access & GL_MAP_PERSISTENT_BIT)
     {
         FIXME( "GL_MAP_PERSISTENT_BIT not supported!\n" );
@@ -1905,17 +1947,23 @@ static GLbitfield map_range_flags_from_map_flags( GLenum flags )
     }
 }

-static NTSTATUS wow64_unmap_buffer( void *ptr, SIZE_T size, GLbitfield access )
+static NTSTATUS wow64_unmap_buffer( TEB *teb, void *ptr, GLenum target, GLint buffer, GLintptr offset, 
+                                    SIZE_T size, GLbitfield access, NTSTATUS (*gl_unmap_buffer64)(void *), void *params)
 {
-    void *wow_ptr;
+    void *wow_ptr = UlongToPtr(*(PTR32 *)ptr);
+
+    /* overwrite the stored pointer with the correct data */
+    memcpy( ptr, wow_ptr, sizeof(PTR32) );

-    if (ULongToPtr(PtrToUlong(ptr)) == ptr) return STATUS_SUCCESS;  /* we're lucky */
+    gl_unmap_buffer64( params );

-    wow_ptr = UlongToPtr(*(PTR32 *)ptr);
     if (access & GL_MAP_WRITE_BIT)
     {
         TRACE( "Copying %#zx from wow64 buffer %p to buffer %p\n", size, wow_ptr, ptr );
-        memcpy( ptr, wow_ptr, size );
+        if (buffer)
+            gl_named_buffer_sub_data( teb, buffer, offset, size, wow_ptr );
+        else
+            gl_buffer_sub_data( teb, target, offset, size, wow_ptr );
     }

return STATUS_INVALID_ADDRESS;
@@ -1943,7 +1991,7 @@ static NTSTATUS wow64_gl_get_buffer_pointer_v( void *args, NTSTATUS (*get_buffer

if ((status = get_buffer_pointer_v64( &params ))) return status;
     if (params.pname != GL_BUFFER_MAP_POINTER) return STATUS_NOT_IMPLEMENTED;
-    if (ULongToPtr(*wow_ptr = PtrToUlong(ptr)) == ptr) return STATUS_SUCCESS;  /* we're lucky */
+
     *wow_ptr = ptr[0];
     return STATUS_SUCCESS;
 }
@@ -1980,7 +2028,7 @@ static NTSTATUS wow64_gl_get_named_buffer_pointer_v( void *args, NTSTATUS (*gl_g

if ((status = gl_get_named_buffer_pointer_v64( &params ))) return status;
     if (params.pname != GL_BUFFER_MAP_POINTER) return STATUS_NOT_IMPLEMENTED;
-    if (ULongToPtr(*wow_ptr = PtrToUlong(ptr)) == ptr) return STATUS_SUCCESS;  /* we're lucky */
+
     *wow_ptr = ptr[0];
     return STATUS_SUCCESS;
 }
@@ -2014,10 +2062,10 @@ static NTSTATUS wow64_gl_map_buffer( void *args, NTSTATUS (*gl_map_buffer64)(voi

/* already mapped, we're being called again with a wow64 pointer */
     if (params32->ret) params.ret = get_buffer_pointer( params.teb, params.target );
-    else if ((status = gl_map_buffer64( &params ))) return status;

-    status = wow64_map_buffer( params.teb, 0, params.target, params.ret, 0,
-                               map_range_flags_from_map_flags( params.access ), &params32->ret );
+    status = wow64_map_buffer( params.teb, 0, params.target, &params.ret, 0, 0,
+                               map_range_flags_from_map_flags( params.access ), &params32->ret,
+                               gl_map_buffer64, &params );
     if (!status || status == STATUS_INVALID_ADDRESS) return status;

unmap_buffer( params.teb, params.target );
@@ -2057,9 +2105,10 @@ NTSTATUS wow64_ext_glMapBufferRange( void *args )

/* already mapped, we're being called again with a wow64 pointer */
     if (params32->ret) params.ret = (char *)get_buffer_pointer( params.teb, params.target );
-    else if ((status = ext_glMapBufferRange( &params ))) return status;

-    status = wow64_map_buffer( params.teb, 0, params.target, params.ret, params.length, params.access, &params32->ret );
+    status = wow64_map_buffer( params.teb, 0, params.target, &params.ret, params.offset, 
+                               params.length, params.access, &params32->ret,
+                               ext_glMapBufferRange, &params );
     if (!status || status == STATUS_INVALID_ADDRESS) return status;

unmap_buffer( params.teb, params.target );
@@ -2085,10 +2134,10 @@ static NTSTATUS wow64_gl_map_named_buffer( void *args, NTSTATUS (*gl_map_named_b

/* already mapped, we're being called again with a wow64 pointer */
     if (params32->ret) params.ret = get_named_buffer_pointer( params.teb, params.buffer );
-    else if ((status = gl_map_named_buffer64( &params ))) return status;

-    status = wow64_map_buffer( params.teb, params.buffer, 0, params.ret, 0,
-                               map_range_flags_from_map_flags( params.access ), &params32->ret );
+    status = wow64_map_buffer( params.teb, params.buffer, 0, &params.ret, 0, 0,
+                               map_range_flags_from_map_flags( params.access ), &params32->ret, 
+                               gl_map_named_buffer64, &params );
     if (!status || status == STATUS_INVALID_ADDRESS) return status;

unmap_named_buffer( params.teb, params.buffer );
@@ -2128,9 +2177,10 @@ static NTSTATUS wow64_gl_map_named_buffer_range( void *args, NTSTATUS (*gl_map_n

/* already mapped, we're being called again with a wow64 pointer */
     if (params32->ret) params.ret = get_named_buffer_pointer( params.teb, params.buffer );
-    else if ((status = gl_map_named_buffer_range64( &params ))) return status;

-    status = wow64_map_buffer( params.teb, params.buffer, 0, params.ret, params.length, params.access, &params32->ret );
+    status = wow64_map_buffer( params.teb, params.buffer, 0, &params.ret, params.offset, 
+                               params.length, params.access, &params32->ret,
+                               gl_map_named_buffer_range64, &params );
     if (!status || status == STATUS_INVALID_ADDRESS) return status;

unmap_named_buffer( params.teb, params.buffer );
@@ -2166,9 +2216,12 @@ static NTSTATUS wow64_gl_unmap_buffer( void *args, NTSTATUS (*gl_unmap_buffer64)

if (!(ptr = get_buffer_pointer( params.teb, params.target ))) return STATUS_SUCCESS;

-    status = wow64_unmap_buffer( ptr, get_buffer_param( params.teb, params.target, GL_BUFFER_MAP_LENGTH ),
-                                 get_buffer_param( params.teb, params.target, GL_BUFFER_ACCESS_FLAGS ) );
-    gl_unmap_buffer64( &params );
+    status = wow64_unmap_buffer( params.teb, ptr, params.target, 0,
+                                 get_buffer_param( params.teb, params.target, GL_BUFFER_MAP_OFFSET ),
+                                 get_buffer_param( params.teb, params.target, GL_BUFFER_MAP_LENGTH ),
+                                 get_buffer_param( params.teb, params.target, GL_BUFFER_ACCESS_FLAGS ), 
+                                 gl_unmap_buffer64, &params );
+
     params32->ret = params.ret;

return status;
@@ -2203,9 +2256,11 @@ static NTSTATUS wow64_gl_unmap_named_buffer( void *args, NTSTATUS (*gl_unmap_nam

if (!(ptr = get_named_buffer_pointer( params.teb, params.buffer ))) return STATUS_SUCCESS;

-    status = wow64_unmap_buffer( ptr, get_named_buffer_param( params.teb, params.buffer, GL_BUFFER_MAP_LENGTH ),
-                                 get_named_buffer_param( params.teb, params.buffer, GL_BUFFER_ACCESS_FLAGS ) );
-    gl_unmap_named_buffer64( &params );
+    status = wow64_unmap_buffer( params.teb, ptr, 0, params.buffer, 
+                                 get_named_buffer_param( params.teb, params.buffer, GL_BUFFER_MAP_OFFSET ),
+                                 get_named_buffer_param( params.teb, params.buffer, GL_BUFFER_MAP_LENGTH ),
+                                 get_named_buffer_param( params.teb, params.buffer, GL_BUFFER_ACCESS_FLAGS ), 
+                                 gl_unmap_named_buffer64, &params );
     params32->ret = params.ret;

return status;