X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fstate_tracker%2Fst_cb_bufferobjects.c;h=49c4b903e594e692fd85d8bbdba741229d34e172;hb=d8f7e3d79ede749e59af9092acac4405e5c7866c;hp=0102d8a6f7d42047d8e35af6e4c26eb426041b97;hpb=c727fa6dbf5a9fca5fc94de06c309f54402449d1;p=mesa.git diff --git a/src/mesa/state_tracker/st_cb_bufferobjects.c b/src/mesa/state_tracker/st_cb_bufferobjects.c index 0102d8a6f7d..49c4b903e59 100644 --- a/src/mesa/state_tracker/st_cb_bufferobjects.c +++ b/src/mesa/state_tracker/st_cb_bufferobjects.c @@ -1,8 +1,8 @@ /************************************************************************** - * - * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. + * + * Copyright 2007 VMware, Inc. * All Rights Reserved. - * + * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including @@ -10,19 +10,19 @@ * distribute, sub license, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: - * + * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial portions * of the Software. - * + * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. - * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR + * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - * + * **************************************************************************/ @@ -36,13 +36,13 @@ #include "main/arrayobj.h" #include "main/bufferobj.h" -#include "st_inlines.h" #include "st_context.h" #include "st_cb_bufferobjects.h" +#include "st_debug.h" #include "pipe/p_context.h" #include "pipe/p_defines.h" -#include "pipe/p_inlines.h" +#include "util/u_inlines.h" /** @@ -52,14 +52,14 @@ * internal structure where somehow shared. */ static struct gl_buffer_object * -st_bufferobj_alloc(GLcontext *ctx, GLuint name, GLenum target) +st_bufferobj_alloc(struct gl_context *ctx, GLuint name, GLenum target) { struct st_buffer_object *st_obj = ST_CALLOC_STRUCT(st_buffer_object); if (!st_obj) return NULL; - _mesa_initialize_buffer_object(&st_obj->Base, name, target); + _mesa_initialize_buffer_object(ctx, &st_obj->Base, name, target); return &st_obj->Base; } @@ -71,14 +71,18 @@ st_bufferobj_alloc(GLcontext *ctx, GLuint name, GLenum target) * Called via glDeleteBuffersARB(). */ static void -st_bufferobj_free(GLcontext *ctx, struct gl_buffer_object *obj) +st_bufferobj_free(struct gl_context *ctx, struct gl_buffer_object *obj) { struct st_buffer_object *st_obj = st_buffer_object(obj); - if (st_obj->buffer) - pipe_buffer_reference(&st_obj->buffer, NULL); + assert(obj->RefCount == 0); + _mesa_buffer_unmap_all_mappings(ctx, obj); - _mesa_free(st_obj); + if (st_obj->buffer) + pipe_resource_reference(&st_obj->buffer, NULL); + + free(st_obj->Base.Label); + free(st_obj); } @@ -90,8 +94,7 @@ st_bufferobj_free(GLcontext *ctx, struct gl_buffer_object *obj) * Called via glBufferSubDataARB(). */ static void -st_bufferobj_subdata(GLcontext *ctx, - GLenum target, +st_bufferobj_subdata(struct gl_context *ctx, GLintptrARB offset, GLsizeiptrARB size, const GLvoid * data, struct gl_buffer_object *obj) @@ -114,8 +117,20 @@ st_bufferobj_subdata(GLcontext *ctx, if (!data) return; - st_cond_flush_pipe_buffer_write(st_context(ctx), st_obj->buffer, - offset, size, data); + if (!st_obj->buffer) { + /* we probably ran out of memory during buffer allocation */ + return; + } + + /* Now that transfers are per-context, we don't have to figure out + * flushing here. Usually drivers won't need to flush in this case + * even if the buffer is currently referenced by hardware - they + * just queue the upload as dma rather than mapping the underlying + * buffer directly. + */ + pipe_buffer_write(st_context(ctx)->pipe, + st_obj->buffer, + offset, size, data); } @@ -123,8 +138,7 @@ st_bufferobj_subdata(GLcontext *ctx, * Called via glGetBufferSubDataARB(). */ static void -st_bufferobj_get_subdata(GLcontext *ctx, - GLenum target, +st_bufferobj_get_subdata(struct gl_context *ctx, GLintptrARB offset, GLsizeiptrARB size, GLvoid * data, struct gl_buffer_object *obj) @@ -139,8 +153,13 @@ st_bufferobj_get_subdata(GLcontext *ctx, if (!size) return; - st_cond_flush_pipe_buffer_read(st_context(ctx), st_obj->buffer, - offset, size, data); + if (!st_obj->buffer) { + /* we probably ran out of memory during buffer allocation */ + return; + } + + pipe_buffer_read(st_context(ctx)->pipe, st_obj->buffer, + offset, size, data); } @@ -152,160 +171,214 @@ st_bufferobj_get_subdata(GLcontext *ctx, * \return GL_TRUE for success, GL_FALSE if out of memory */ static GLboolean -st_bufferobj_data(GLcontext *ctx, +st_bufferobj_data(struct gl_context *ctx, GLenum target, GLsizeiptrARB size, const GLvoid * data, - GLenum usage, + GLenum usage, + GLbitfield storageFlags, struct gl_buffer_object *obj) { struct st_context *st = st_context(ctx); struct pipe_context *pipe = st->pipe; struct st_buffer_object *st_obj = st_buffer_object(obj); - unsigned buffer_usage; + unsigned bind, pipe_usage, pipe_flags = 0; + + if (size && data && 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; + } st_obj->Base.Size = size; st_obj->Base.Usage = usage; - - switch(target) { + st_obj->Base.StorageFlags = storageFlags; + + switch (target) { case GL_PIXEL_PACK_BUFFER_ARB: case GL_PIXEL_UNPACK_BUFFER_ARB: - buffer_usage = PIPE_BUFFER_USAGE_PIXEL; + bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW; break; case GL_ARRAY_BUFFER_ARB: - buffer_usage = PIPE_BUFFER_USAGE_VERTEX; + bind = PIPE_BIND_VERTEX_BUFFER; break; case GL_ELEMENT_ARRAY_BUFFER_ARB: - buffer_usage = PIPE_BUFFER_USAGE_INDEX; + bind = PIPE_BIND_INDEX_BUFFER; + break; + case GL_TEXTURE_BUFFER: + bind = PIPE_BIND_SAMPLER_VIEW; + break; + case GL_TRANSFORM_FEEDBACK_BUFFER: + bind = PIPE_BIND_STREAM_OUTPUT; + break; + case GL_UNIFORM_BUFFER: + bind = PIPE_BIND_CONSTANT_BUFFER; break; default: - buffer_usage = 0; + bind = 0; } - pipe_buffer_reference( &st_obj->buffer, NULL ); + /* Set usage. */ + if (st_obj->Base.Immutable) { + /* BufferStorage */ + if (storageFlags & GL_CLIENT_STORAGE_BIT) + pipe_usage = PIPE_USAGE_STAGING; + else + pipe_usage = PIPE_USAGE_DEFAULT; + } + else { + /* BufferData */ + switch (usage) { + case GL_STATIC_DRAW: + case GL_STATIC_READ: + case GL_STATIC_COPY: + default: + pipe_usage = PIPE_USAGE_DEFAULT; + break; + case GL_DYNAMIC_DRAW: + case GL_DYNAMIC_READ: + case GL_DYNAMIC_COPY: + pipe_usage = PIPE_USAGE_DYNAMIC; + break; + case GL_STREAM_DRAW: + case GL_STREAM_READ: + case GL_STREAM_COPY: + pipe_usage = PIPE_USAGE_STREAM; + break; + } + } - if (size != 0) { - st_obj->buffer = pipe_buffer_create(pipe->screen, 32, buffer_usage, size); + /* Set flags. */ + if (storageFlags & GL_MAP_PERSISTENT_BIT) + pipe_flags |= PIPE_RESOURCE_FLAG_MAP_PERSISTENT; + if (storageFlags & GL_MAP_COHERENT_BIT) + pipe_flags |= PIPE_RESOURCE_FLAG_MAP_COHERENT; - if (!st_obj->buffer) { - return GL_FALSE; - } + pipe_resource_reference( &st_obj->buffer, NULL ); - if (data) - st_no_flush_pipe_buffer_write(st_context(ctx), st_obj->buffer, 0, - size, data); - return GL_TRUE; + if (ST_DEBUG & DEBUG_BUFFER) { + debug_printf("Create buffer size %td bind 0x%x\n", size, bind); } - return GL_TRUE; -} + if (size != 0) { + struct pipe_resource buffer; + memset(&buffer, 0, sizeof buffer); + buffer.target = PIPE_BUFFER; + buffer.format = PIPE_FORMAT_R8_UNORM; /* want TYPELESS or similar */ + buffer.bind = bind; + buffer.usage = pipe_usage; + buffer.flags = pipe_flags; + buffer.width0 = size; + buffer.height0 = 1; + buffer.depth0 = 1; + buffer.array_size = 1; -/** - * Called via glMapBufferARB(). - */ -static void * -st_bufferobj_map(GLcontext *ctx, GLenum target, GLenum access, - struct gl_buffer_object *obj) -{ - struct st_buffer_object *st_obj = st_buffer_object(obj); - uint flags; + st_obj->buffer = pipe->screen->resource_create(pipe->screen, &buffer); - switch (access) { - case GL_WRITE_ONLY: - flags = PIPE_BUFFER_USAGE_CPU_WRITE; - break; - case GL_READ_ONLY: - flags = PIPE_BUFFER_USAGE_CPU_READ; - break; - case GL_READ_WRITE: - /* fall-through */ - default: - flags = PIPE_BUFFER_USAGE_CPU_READ | PIPE_BUFFER_USAGE_CPU_WRITE; - break; - } + if (!st_obj->buffer) { + /* out of memory */ + st_obj->Base.Size = 0; + return GL_FALSE; + } - obj->Pointer = st_cond_flush_pipe_buffer_map(st_context(ctx), - st_obj->buffer, - flags); - if (obj->Pointer) { - obj->Offset = 0; - obj->Length = obj->Size; + if (data) + pipe_buffer_write(pipe, st_obj->buffer, 0, size, data); } - return obj->Pointer; -} + /* BufferData may change an array or uniform buffer, need to update it */ + st->dirty.st |= ST_NEW_VERTEX_ARRAYS | ST_NEW_UNIFORM_BUFFER; -/** - * Dummy data whose's pointer is used for zero length ranges. - */ -static long -st_bufferobj_zero_length_range = 0; + return GL_TRUE; +} /** * Called via glMapBufferRange(). */ static void * -st_bufferobj_map_range(GLcontext *ctx, GLenum target, +st_bufferobj_map_range(struct gl_context *ctx, GLintptr offset, GLsizeiptr length, GLbitfield access, - struct gl_buffer_object *obj) + struct gl_buffer_object *obj, + gl_map_buffer_index index) { struct pipe_context *pipe = st_context(ctx)->pipe; struct st_buffer_object *st_obj = st_buffer_object(obj); - uint flags = 0x0; + enum pipe_transfer_usage flags = 0x0; if (access & GL_MAP_WRITE_BIT) - flags |= PIPE_BUFFER_USAGE_CPU_WRITE; + flags |= PIPE_TRANSFER_WRITE; if (access & GL_MAP_READ_BIT) - flags |= PIPE_BUFFER_USAGE_CPU_READ; + flags |= PIPE_TRANSFER_READ; if (access & GL_MAP_FLUSH_EXPLICIT_BIT) - flags |= PIPE_BUFFER_USAGE_FLUSH_EXPLICIT; - + flags |= PIPE_TRANSFER_FLUSH_EXPLICIT; + + if (access & GL_MAP_INVALIDATE_BUFFER_BIT) { + flags |= PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE; + } + else if (access & GL_MAP_INVALIDATE_RANGE_BIT) { + if (offset == 0 && length == obj->Size) + flags |= PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE; + else + flags |= PIPE_TRANSFER_DISCARD_RANGE; + } + if (access & GL_MAP_UNSYNCHRONIZED_BIT) - flags |= PIPE_BUFFER_USAGE_UNSYNCHRONIZED; + flags |= PIPE_TRANSFER_UNSYNCHRONIZED; + + if (access & GL_MAP_PERSISTENT_BIT) + flags |= PIPE_TRANSFER_PERSISTENT; + + if (access & GL_MAP_COHERENT_BIT) + flags |= PIPE_TRANSFER_COHERENT; /* ... other flags ... */ if (access & MESA_MAP_NOWAIT_BIT) - flags |= PIPE_BUFFER_USAGE_DONTBLOCK; + flags |= PIPE_TRANSFER_DONTBLOCK; assert(offset >= 0); assert(length >= 0); assert(offset < obj->Size); assert(offset + length <= obj->Size); - /* - * We go out of way here to hide the degenerate yet valid case of zero - * length range from the pipe driver. - */ - if (!length) { - obj->Pointer = &st_bufferobj_zero_length_range; + obj->Mappings[index].Pointer = pipe_buffer_map_range(pipe, + 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; + obj->Mappings[index].AccessFlags = access; } else { - obj->Pointer = pipe_buffer_map_range(pipe->screen, st_obj->buffer, offset, length, flags); - if (obj->Pointer) { - obj->Pointer = (ubyte *) obj->Pointer + offset; - } - } - - if (obj->Pointer) { - obj->Offset = offset; - obj->Length = length; - obj->AccessFlags = access; + st_obj->transfer[index] = NULL; } - return obj->Pointer; + return obj->Mappings[index].Pointer; } static void -st_bufferobj_flush_mapped_range(GLcontext *ctx, GLenum target, +st_bufferobj_flush_mapped_range(struct gl_context *ctx, GLintptr offset, GLsizeiptr length, - struct gl_buffer_object *obj) + struct gl_buffer_object *obj, + gl_map_buffer_index index) { struct pipe_context *pipe = st_context(ctx)->pipe; struct st_buffer_object *st_obj = st_buffer_object(obj); @@ -313,13 +386,15 @@ st_bufferobj_flush_mapped_range(GLcontext *ctx, GLenum target, /* Subrange is relative to mapped range */ assert(offset >= 0); assert(length >= 0); - assert(offset + length <= obj->Length); - + assert(offset + length <= obj->Mappings[index].Length); + assert(obj->Mappings[index].Pointer); + if (!length) return; - pipe_buffer_flush_mapped_range(pipe->screen, st_obj->buffer, - obj->Offset + offset, length); + pipe_buffer_flush_mapped_range(pipe, st_obj->transfer[index], + obj->Mappings[index].Offset + offset, + length); } @@ -327,17 +402,19 @@ st_bufferobj_flush_mapped_range(GLcontext *ctx, GLenum target, * Called via glUnmapBufferARB(). */ static GLboolean -st_bufferobj_unmap(GLcontext *ctx, GLenum target, struct gl_buffer_object *obj) +st_bufferobj_unmap(struct gl_context *ctx, struct gl_buffer_object *obj, + gl_map_buffer_index index) { struct pipe_context *pipe = st_context(ctx)->pipe; struct st_buffer_object *st_obj = st_buffer_object(obj); - if(obj->Length) - pipe_buffer_unmap(pipe->screen, st_obj->buffer); + if (obj->Mappings[index].Length) + pipe_buffer_unmap(pipe, st_obj->transfer[index]); - obj->Pointer = NULL; - obj->Offset = 0; - obj->Length = 0; + st_obj->transfer[index] = NULL; + obj->Mappings[index].Pointer = NULL; + obj->Mappings[index].Offset = 0; + obj->Mappings[index].Length = 0; return GL_TRUE; } @@ -346,7 +423,7 @@ st_bufferobj_unmap(GLcontext *ctx, GLenum target, struct gl_buffer_object *obj) * Called via glCopyBufferSubData(). */ static void -st_copy_buffer_subdata(GLcontext *ctx, +st_copy_buffer_subdata(struct gl_context *ctx, struct gl_buffer_object *src, struct gl_buffer_object *dst, GLintptr readOffset, GLintptr writeOffset, @@ -355,48 +432,52 @@ st_copy_buffer_subdata(GLcontext *ctx, struct pipe_context *pipe = st_context(ctx)->pipe; struct st_buffer_object *srcObj = st_buffer_object(src); struct st_buffer_object *dstObj = st_buffer_object(dst); - ubyte *srcPtr, *dstPtr; + struct pipe_box box; - if(!size) + if (!size) return; /* buffer should not already be mapped */ - assert(!src->Pointer); - assert(!dst->Pointer); + assert(!_mesa_check_disallowed_mapping(src)); + assert(!_mesa_check_disallowed_mapping(dst)); - srcPtr = (ubyte *) pipe_buffer_map_range(pipe->screen, - srcObj->buffer, - readOffset, size, - PIPE_BUFFER_USAGE_CPU_READ); + u_box_1d(readOffset, size, &box); - dstPtr = (ubyte *) pipe_buffer_map_range(pipe->screen, - dstObj->buffer, - writeOffset, size, - PIPE_BUFFER_USAGE_CPU_WRITE); + pipe->resource_copy_region(pipe, dstObj->buffer, 0, writeOffset, 0, 0, + srcObj->buffer, 0, &box); +} - if (srcPtr && dstPtr) - _mesa_memcpy(dstPtr + writeOffset, srcPtr + readOffset, size); - pipe_buffer_unmap(pipe->screen, srcObj->buffer); - pipe_buffer_unmap(pipe->screen, dstObj->buffer); +/* 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) +{ } void st_init_bufferobject_functions(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->BufferSubData = st_bufferobj_subdata; functions->GetBufferSubData = st_bufferobj_get_subdata; - functions->MapBuffer = st_bufferobj_map; functions->MapBufferRange = st_bufferobj_map_range; functions->FlushMappedBufferRange = st_bufferobj_flush_mapped_range; functions->UnmapBuffer = st_bufferobj_unmap; functions->CopyBufferSubData = st_copy_buffer_subdata; /* For GL_APPLE_vertex_array_object */ - functions->NewArrayObject = _mesa_new_array_object; - functions->DeleteArrayObject = _mesa_delete_array_object; + functions->NewArrayObject = _mesa_new_vao; + functions->DeleteArrayObject = _mesa_delete_vao; }