X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fstate_tracker%2Fst_cb_bufferobjects.c;h=86ebfc674b564b2ca2a7b9bead667e5b7b6b819b;hb=962cc1bd17cbe34101c647c3e8bb72986810c652;hp=c75f4765b949421fd4fbb5c1ffc9791a88190f3d;hpb=1c2187b1c225b2f7e1891544d184bde60390977e;p=mesa.git diff --git a/src/mesa/state_tracker/st_cb_bufferobjects.c b/src/mesa/state_tracker/st_cb_bufferobjects.c index c75f4765b94..86ebfc674b5 100644 --- a/src/mesa/state_tracker/st_cb_bufferobjects.c +++ b/src/mesa/state_tracker/st_cb_bufferobjects.c @@ -40,6 +40,7 @@ #include "st_context.h" #include "st_cb_bufferobjects.h" +#include "st_cb_memoryobjects.h" #include "st_debug.h" #include "pipe/p_context.h" @@ -96,9 +97,9 @@ st_bufferobj_free(struct gl_context *ctx, struct gl_buffer_object *obj) */ static void st_bufferobj_subdata(struct gl_context *ctx, - GLintptrARB offset, - GLsizeiptrARB size, - const GLvoid * data, struct gl_buffer_object *obj) + GLintptrARB offset, + GLsizeiptrARB size, + const void * data, struct gl_buffer_object *obj) { struct st_buffer_object *st_obj = st_buffer_object(obj); @@ -130,8 +131,8 @@ st_bufferobj_subdata(struct gl_context *ctx, * buffer directly. */ pipe_buffer_write(st_context(ctx)->pipe, - st_obj->buffer, - offset, size, data); + st_obj->buffer, + offset, size, data); } @@ -142,7 +143,7 @@ static void st_bufferobj_get_subdata(struct gl_context *ctx, GLintptrARB offset, GLsizeiptrARB size, - GLvoid * data, struct gl_buffer_object *obj) + void * data, struct gl_buffer_object *obj) { struct st_buffer_object *st_obj = st_buffer_object(obj); @@ -163,44 +164,42 @@ st_bufferobj_get_subdata(struct gl_context *ctx, offset, size, data); } - -/** - * Allocate space for and store data in a buffer object. Any data that was - * previously stored in the buffer object is lost. If data is NULL, - * memory will be allocated, but no copy will occur. - * Called via ctx->Driver.BufferData(). - * \return GL_TRUE for success, GL_FALSE if out of memory - */ -static GLboolean -st_bufferobj_data(struct gl_context *ctx, - GLenum target, - GLsizeiptrARB size, - const GLvoid * data, - GLenum usage, - GLbitfield storageFlags, - struct gl_buffer_object *obj) +static ALWAYS_INLINE GLboolean +bufferobj_data(struct gl_context *ctx, + GLenum target, + GLsizeiptrARB size, + const void *data, + struct gl_memory_object *memObj, + GLuint64 offset, + GLenum usage, + GLbitfield storageFlags, + struct gl_buffer_object *obj) { struct st_context *st = st_context(ctx); struct pipe_context *pipe = st->pipe; + struct pipe_screen *screen = pipe->screen; struct st_buffer_object *st_obj = st_buffer_object(obj); + struct st_memory_object *st_mem_obj = st_memory_object(memObj); unsigned bind, pipe_usage, pipe_flags = 0; if (target != GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD && - size && data && st_obj->buffer && + size && st_obj->buffer && st_obj->Base.Size == size && st_obj->Base.Usage == usage && st_obj->Base.StorageFlags == storageFlags) { - /* Just discard the old contents and write new data. - * This should be the same as creating a new buffer, but we avoid - * a lot of validation in Mesa. - */ - struct pipe_box box; - - u_box_1d(0, size, &box); - pipe->transfer_inline_write(pipe, st_obj->buffer, 0, - PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE, - &box, data, 0, 0); - return GL_TRUE; + if (data) { + /* Just discard the old contents and write new data. + * This should be the same as creating a new buffer, but we avoid + * a lot of validation in Mesa. + */ + pipe->buffer_subdata(pipe, st_obj->buffer, + PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE, + 0, size, data); + return GL_TRUE; + } else if (screen->get_param(screen, PIPE_CAP_INVALIDATE_BUFFER)) { + pipe->invalidate_resource(pipe, st_obj->buffer); + return GL_TRUE; + } } st_obj->Base.Size = size; @@ -228,8 +227,16 @@ st_bufferobj_data(struct gl_context *ctx, bind = PIPE_BIND_CONSTANT_BUFFER; break; case GL_DRAW_INDIRECT_BUFFER: + case GL_PARAMETER_BUFFER_ARB: bind = PIPE_BIND_COMMAND_ARGS_BUFFER; break; + case GL_ATOMIC_COUNTER_BUFFER: + case GL_SHADER_STORAGE_BUFFER: + bind = PIPE_BIND_SHADER_BUFFER; + break; + case GL_QUERY_BUFFER: + bind = PIPE_BIND_QUERY_BUFFER; + break; default: bind = 0; } @@ -237,10 +244,14 @@ st_bufferobj_data(struct gl_context *ctx, /* Set usage. */ if (st_obj->Base.Immutable) { /* BufferStorage */ - if (storageFlags & GL_CLIENT_STORAGE_BIT) - pipe_usage = PIPE_USAGE_STAGING; - else + if (storageFlags & GL_CLIENT_STORAGE_BIT) { + if (storageFlags & GL_MAP_READ_BIT) + pipe_usage = PIPE_USAGE_STAGING; + else + pipe_usage = PIPE_USAGE_STREAM; + } else { pipe_usage = PIPE_USAGE_DEFAULT; + } } else { /* BufferData */ @@ -248,7 +259,7 @@ st_bufferobj_data(struct gl_context *ctx, case GL_STATIC_DRAW: case GL_STATIC_COPY: default: - pipe_usage = PIPE_USAGE_DEFAULT; + pipe_usage = PIPE_USAGE_DEFAULT; break; case GL_DYNAMIC_DRAW: case GL_DYNAMIC_COPY: @@ -278,6 +289,8 @@ st_bufferobj_data(struct gl_context *ctx, pipe_flags |= PIPE_RESOURCE_FLAG_MAP_PERSISTENT; if (storageFlags & GL_MAP_COHERENT_BIT) pipe_flags |= PIPE_RESOURCE_FLAG_MAP_COHERENT; + if (storageFlags & GL_SPARSE_STORAGE_BIT_ARB) + pipe_flags |= PIPE_RESOURCE_FLAG_SPARSE; pipe_resource_reference( &st_obj->buffer, NULL ); @@ -287,7 +300,6 @@ st_bufferobj_data(struct gl_context *ctx, } if (size != 0) { - struct pipe_screen *screen = pipe->screen; struct pipe_resource buffer; memset(&buffer, 0, sizeof buffer); @@ -301,7 +313,12 @@ st_bufferobj_data(struct gl_context *ctx, buffer.depth0 = 1; buffer.array_size = 1; - if (target == GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD) { + if (st_mem_obj) { + st_obj->buffer = screen->resource_from_memobj(screen, &buffer, + st_mem_obj->memory, + offset); + } + else if (target == GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD) { st_obj->buffer = screen->resource_from_user_memory(screen, &buffer, (void*)data); } @@ -319,12 +336,78 @@ st_bufferobj_data(struct gl_context *ctx, } } - /* BufferData may change an array or uniform buffer, need to update it */ - st->dirty.st |= ST_NEW_VERTEX_ARRAYS | ST_NEW_UNIFORM_BUFFER; + /* The current buffer may be bound, so we have to revalidate all atoms that + * might be using it. + */ + /* TODO: Add arrays to usage history */ + ctx->NewDriverState |= ST_NEW_VERTEX_ARRAYS; + if (st_obj->Base.UsageHistory & USAGE_UNIFORM_BUFFER) + ctx->NewDriverState |= ST_NEW_UNIFORM_BUFFER; + if (st_obj->Base.UsageHistory & USAGE_SHADER_STORAGE_BUFFER) + ctx->NewDriverState |= ST_NEW_STORAGE_BUFFER; + if (st_obj->Base.UsageHistory & USAGE_TEXTURE_BUFFER) + ctx->NewDriverState |= ST_NEW_SAMPLER_VIEWS | ST_NEW_IMAGE_UNITS; + if (st_obj->Base.UsageHistory & USAGE_ATOMIC_COUNTER_BUFFER) + ctx->NewDriverState |= ST_NEW_ATOMIC_BUFFER; return GL_TRUE; } +/** + * Allocate space for and store data in a buffer object. Any data that was + * previously stored in the buffer object is lost. If data is NULL, + * memory will be allocated, but no copy will occur. + * Called via ctx->Driver.BufferData(). + * \return GL_TRUE for success, GL_FALSE if out of memory + */ +static GLboolean +st_bufferobj_data(struct gl_context *ctx, + GLenum target, + GLsizeiptrARB size, + const void *data, + GLenum usage, + GLbitfield storageFlags, + struct gl_buffer_object *obj) +{ + return bufferobj_data(ctx, target, size, data, NULL, 0, usage, storageFlags, obj); +} + +static GLboolean +st_bufferobj_data_mem(struct gl_context *ctx, + GLenum target, + GLsizeiptrARB size, + struct gl_memory_object *memObj, + GLuint64 offset, + GLenum usage, + struct gl_buffer_object *bufObj) +{ + return bufferobj_data(ctx, target, size, NULL, memObj, offset, usage, 0, bufObj); +} + +/** + * Called via glInvalidateBuffer(Sub)Data. + */ +static void +st_bufferobj_invalidate(struct gl_context *ctx, + struct gl_buffer_object *obj, + GLintptr offset, + GLsizeiptr size) +{ + struct st_context *st = st_context(ctx); + struct pipe_context *pipe = st->pipe; + struct st_buffer_object *st_obj = st_buffer_object(obj); + + /* We ignore partial invalidates. */ + if (offset != 0 || size != obj->Size) + return; + + /* Nothing to invalidate. */ + if (!st_obj->buffer) + return; + + pipe->invalidate_resource(pipe, st_obj->buffer); +} + /** * Called via glMapBufferRange(). @@ -368,7 +451,7 @@ st_bufferobj_map_range(struct gl_context *ctx, flags |= PIPE_TRANSFER_COHERENT; /* ... other flags ... - */ + */ if (access & MESA_MAP_NOWAIT_BIT) flags |= PIPE_TRANSFER_DONTBLOCK; @@ -379,10 +462,10 @@ st_bufferobj_map_range(struct gl_context *ctx, assert(offset + length <= obj->Size); obj->Mappings[index].Pointer = pipe_buffer_map_range(pipe, - st_obj->buffer, - offset, length, - flags, - &st_obj->transfer[index]); + st_obj->buffer, + offset, length, + flags, + &st_obj->transfer[index]); if (obj->Mappings[index].Pointer) { obj->Mappings[index].Offset = offset; obj->Mappings[index].Length = length; @@ -475,7 +558,7 @@ st_copy_buffer_subdata(struct gl_context *ctx, static void st_clear_buffer_subdata(struct gl_context *ctx, GLintptr offset, GLsizeiptr size, - const GLvoid *clearValue, + const void *clearValue, GLsizeiptr clearValueSize, struct gl_buffer_object *bufObj) { @@ -496,29 +579,32 @@ st_clear_buffer_subdata(struct gl_context *ctx, clearValue, clearValueSize); } - -/* TODO: if buffer wasn't created with appropriate usage flags, need - * to recreate it now and copy contents -- or possibly create a - * gallium entrypoint to extend the usage flags and let the driver - * decide if a copy is necessary. - */ -void -st_bufferobj_validate_usage(struct st_context *st, - struct st_buffer_object *obj, - unsigned usage) +static void +st_bufferobj_page_commitment(struct gl_context *ctx, + struct gl_buffer_object *bufferObj, + GLintptr offset, GLsizeiptr size, + GLboolean commit) { -} + struct pipe_context *pipe = st_context(ctx)->pipe; + struct st_buffer_object *buf = st_buffer_object(bufferObj); + struct pipe_box box; + u_box_1d(offset, size, &box); + + if (!pipe->resource_commit(pipe, buf->buffer, 0, &box, commit)) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBufferPageCommitmentARB(out of memory)"); + return; + } +} void -st_init_bufferobject_functions(struct dd_function_table *functions) +st_init_bufferobject_functions(struct pipe_screen *screen, + struct dd_function_table *functions) { - /* plug in default driver fallbacks (such as for ClearBufferSubData) */ - _mesa_init_buffer_object_functions(functions); - functions->NewBufferObject = st_bufferobj_alloc; functions->DeleteBuffer = st_bufferobj_free; functions->BufferData = st_bufferobj_data; + functions->BufferDataMem = st_bufferobj_data_mem; functions->BufferSubData = st_bufferobj_subdata; functions->GetBufferSubData = st_bufferobj_get_subdata; functions->MapBufferRange = st_bufferobj_map_range; @@ -526,4 +612,8 @@ st_init_bufferobject_functions(struct dd_function_table *functions) functions->UnmapBuffer = st_bufferobj_unmap; functions->CopyBufferSubData = st_copy_buffer_subdata; functions->ClearBufferSubData = st_clear_buffer_subdata; + functions->BufferPageCommitment = st_bufferobj_page_commitment; + + if (screen->get_param(screen, PIPE_CAP_INVALIDATE_BUFFER)) + functions->InvalidateBufferSubData = st_bufferobj_invalidate; }