gallium/swr: Fix glVertexPointer race condition.

Sometimes using user buffer (not VBO) e.g. glVertexPointer
one thread could free memory before other thread used it.
Instead of copying this memory to driver simplier thing is
to block until draw finish.

Reviewed-by: Jan Zielinski <jan.zielinski@intel.com>

diff --git a/src/gallium/drivers/swr/swr_context.h b/src/gallium/drivers/swr/swr_context.h
index 82e6a6692f744c3ae547113cc0fe3ceb8cb92216..465357cc519769c0b6090d01706bb064503cb8ed 100644 (file)
--- a/src/gallium/drivers/swr/swr_context.h
+++ b/src/gallium/drivers/swr/swr_context.h
@@ -53,7 +53,7 @@
 #define SWR_NEW_FRAMEBUFFER (1 << 15)
 #define SWR_NEW_CLIP (1 << 16)
 #define SWR_NEW_SO (1 << 17)
-#define SWR_LARGE_CLIENT_DRAW (1<<18) // Indicates client draw will block
+#define SWR_BLOCK_CLIENT_DRAW ( 1 << 18) // Indicates client draw will block
 
 namespace std
 {

diff --git a/src/gallium/drivers/swr/swr_draw.cpp b/src/gallium/drivers/swr/swr_draw.cpp
index 0377861b7a49e8b791b68d747a174a9372a907e3..b7f354cd2a21826a6ad08b2e70241c03ada1f789 100644 (file)
--- a/src/gallium/drivers/swr/swr_draw.cpp
+++ b/src/gallium/drivers/swr/swr_draw.cpp
@@ -236,10 +236,10 @@ swr_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *info)
                                    info->start,
                                    info->start_instance);
 
-   /* On large client-buffer draw, we used client buffer directly, without
+   /* On client-buffer draw, we used client buffer directly, without
     * copy.  Block until draw is finished.
     * VMD is an example application that benefits from this. */
-   if (ctx->dirty & SWR_LARGE_CLIENT_DRAW) {
+   if (ctx->dirty & SWR_BLOCK_CLIENT_DRAW) {
       struct swr_screen *screen = swr_screen(pipe->screen);
       swr_fence_submit(ctx, screen->flush_fence);
       swr_fence_finish(pipe->screen, NULL, screen->flush_fence, 0);

diff --git a/src/gallium/drivers/swr/swr_state.cpp b/src/gallium/drivers/swr/swr_state.cpp
index 3a007db4c1c0af4965bdc90408a039d732669a4e..cd55e68b8d44dc59aa03f3addb09cfd71ee21849 100644 (file)
--- a/src/gallium/drivers/swr/swr_state.cpp
+++ b/src/gallium/drivers/swr/swr_state.cpp
@@ -1307,20 +1307,12 @@ swr_update_derived(struct pipe_context *pipe,
             partial_inbounds = 0;
             min_vertex_index = info.min_index + info.index_bias;
 
-            size = AlignUp(size, 4);
-            /* If size of client memory copy is too large, don't copy. The
-             * draw will access user-buffer directly and then block.  This is
-             * faster than queuing many large client draws. */
-            if (size >= screen->client_copy_limit) {
-               post_update_dirty_flags |= SWR_LARGE_CLIENT_DRAW;
-               p_data = (const uint8_t *) vb->buffer.user;
-            } else {
-               /* Copy only needed vertices to scratch space */
-               const void *ptr = (const uint8_t *) vb->buffer.user + base;
-               ptr = (uint8_t *)swr_copy_to_scratch_space(
-                     ctx, &ctx->scratch->vertex_buffer, ptr, size);
-               p_data = (const uint8_t *)ptr - base;
-            }
+            /* Use user memory directly. The draw will access user-buffer
+             * directly and then block. It's easier and usually
+             * faster than copying.
+             */
+            post_update_dirty_flags |= SWR_BLOCK_CLIENT_DRAW;
+            p_data = (const uint8_t *) vb->buffer.user;
          } else if (vb->buffer.resource) {
             /* VBO */
             if (!pitch) {
@@ -1380,20 +1372,13 @@ swr_update_derived(struct pipe_context *pipe,
             post_update_dirty_flags |= SWR_NEW_VERTEX;
 
             size = info.count * pitch;
-            size = AlignUp(size, 4);
-            /* If size of client memory copy is too large, don't copy. The
-             * draw will access user-buffer directly and then block.  This is
-             * faster than queuing many large client draws. */
-            if (size >= screen->client_copy_limit) {
-               post_update_dirty_flags |= SWR_LARGE_CLIENT_DRAW;
-               p_data = (const uint8_t *) info.index.user;
-            } else {
-               /* Copy indices to scratch space */
-               const void *ptr = info.index.user;
-               ptr = swr_copy_to_scratch_space(
-                     ctx, &ctx->scratch->index_buffer, ptr, size);
-               p_data = (const uint8_t *)ptr;
-            }
+
+            /* Use user memory directly. The draw will access user-buffer
+             * directly and then block. It's easier and usually
+             * faster than copying.
+             */
+            post_update_dirty_flags |= SWR_BLOCK_CLIENT_DRAW;
+            p_data = (const uint8_t *) info.index.user;
          }
 
          SWR_INDEX_BUFFER_STATE swrIndexBuffer;