X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fauxiliary%2Futil%2Fu_upload_mgr.c;h=73f6cae0b6dddd9274d4c1e414e26d1df1cc1e94;hb=d32690b43c91d4aab938da83704e4ebb68fccf6f;hp=75d44432d9e7e9c1f23075df90bccf3e18ddac65;hpb=ccd13da0fc1f1813b55fc0d2181a6cb0d3b42b0d;p=mesa.git diff --git a/src/gallium/auxiliary/util/u_upload_mgr.c b/src/gallium/auxiliary/util/u_upload_mgr.c index 75d44432d9e..73f6cae0b6d 100644 --- a/src/gallium/auxiliary/util/u_upload_mgr.c +++ b/src/gallium/auxiliary/util/u_upload_mgr.c @@ -1,8 +1,8 @@ /************************************************************************** - * + * * Copyright 2009 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,11 +10,11 @@ * 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. @@ -22,7 +22,7 @@ * 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. - * + * **************************************************************************/ /* Helper utility for uploading user buffers & other data, and @@ -41,207 +41,272 @@ struct u_upload_mgr { struct pipe_context *pipe; - unsigned default_size; - unsigned alignment; - unsigned usage; - - /* The active buffer: - */ - struct pipe_resource *buffer; - unsigned size; - unsigned offset; + unsigned default_size; /* Minimum size of the upload buffer, in bytes. */ + unsigned bind; /* Bitmask of PIPE_BIND_* flags. */ + enum pipe_resource_usage usage; + unsigned flags; + unsigned map_flags; /* Bitmask of PIPE_TRANSFER_* flags. */ + boolean map_persistent; /* If persistent mappings are supported. */ + + struct pipe_resource *buffer; /* Upload buffer. */ + struct pipe_transfer *transfer; /* Transfer object for the upload buffer. */ + uint8_t *map; /* Pointer to the mapped upload buffer. */ + unsigned offset; /* Aligned offset to the upload buffer, pointing + * at the first unused byte. */ + unsigned flushed_size; /* Size we have flushed by transfer_flush_region. */ }; -struct u_upload_mgr *u_upload_create( struct pipe_context *pipe, - unsigned default_size, - unsigned alignment, - unsigned usage ) +struct u_upload_mgr * +u_upload_create(struct pipe_context *pipe, unsigned default_size, + unsigned bind, enum pipe_resource_usage usage, unsigned flags) { - struct u_upload_mgr *upload = CALLOC_STRUCT( u_upload_mgr ); + struct u_upload_mgr *upload = CALLOC_STRUCT(u_upload_mgr); + if (!upload) + return NULL; upload->pipe = pipe; upload->default_size = default_size; - upload->alignment = alignment; + upload->bind = bind; upload->usage = usage; - upload->buffer = NULL; + upload->flags = flags; + + upload->map_persistent = + pipe->screen->get_param(pipe->screen, + PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT); + + if (upload->map_persistent) { + upload->map_flags = PIPE_TRANSFER_WRITE | + PIPE_TRANSFER_UNSYNCHRONIZED | + PIPE_TRANSFER_PERSISTENT | + PIPE_TRANSFER_COHERENT; + } + else { + upload->map_flags = PIPE_TRANSFER_WRITE | + PIPE_TRANSFER_UNSYNCHRONIZED | + PIPE_TRANSFER_FLUSH_EXPLICIT; + } return upload; } -/* Slightly specialized version of buffer_write designed to maximize - * chances of the driver consolidating successive writes into a single - * upload. - * - * dirty_size may be slightly greater than size to cope with - * alignment. We don't want to leave holes between succesively mapped - * regions as that may prevent the driver from consolidating uploads. - * - * Note that the 'data' pointer has probably come from the application - * and we cannot read even a byte past its end without risking - * segfaults, or at least complaints from valgrind.. - */ -static INLINE enum pipe_error -my_buffer_write(struct pipe_context *pipe, - struct pipe_resource *buf, - unsigned offset, unsigned size, unsigned dirty_size, - const void *data) +struct u_upload_mgr * +u_upload_create_default(struct pipe_context *pipe) { - struct pipe_transfer *transfer = NULL; - uint8_t *map; - - assert(offset < buf->width0); - assert(offset + size <= buf->width0); - assert(dirty_size >= size); - assert(size); + return u_upload_create(pipe, 1024 * 1024, + PIPE_BIND_VERTEX_BUFFER | + PIPE_BIND_INDEX_BUFFER | + PIPE_BIND_CONSTANT_BUFFER, + PIPE_USAGE_STREAM, 0); +} - map = pipe_buffer_map_range(pipe, buf, offset, dirty_size, - PIPE_TRANSFER_WRITE | - PIPE_TRANSFER_FLUSH_EXPLICIT | - PIPE_TRANSFER_DISCARD | - PIPE_TRANSFER_UNSYNCHRONIZED, - &transfer); - if (map == NULL) - return PIPE_ERROR_OUT_OF_MEMORY; +struct u_upload_mgr * +u_upload_clone(struct pipe_context *pipe, struct u_upload_mgr *upload) +{ + struct u_upload_mgr *result = u_upload_create(pipe, upload->default_size, + upload->bind, upload->usage, + upload->flags); + if (!upload->map_persistent && result->map_persistent) + u_upload_disable_persistent(result); + else if (upload->map_persistent && + upload->map_flags & PIPE_TRANSFER_FLUSH_EXPLICIT) + u_upload_enable_flush_explicit(result); + + return result; +} - memcpy(map + offset, data, size); - pipe_buffer_flush_mapped_range(pipe, transfer, offset, dirty_size); - pipe_buffer_unmap(pipe, buf, transfer); +void +u_upload_enable_flush_explicit(struct u_upload_mgr *upload) +{ + assert(upload->map_persistent); + upload->map_flags &= ~PIPE_TRANSFER_COHERENT; + upload->map_flags |= PIPE_TRANSFER_FLUSH_EXPLICIT; +} - return PIPE_OK; +void +u_upload_disable_persistent(struct u_upload_mgr *upload) +{ + upload->map_persistent = FALSE; + upload->map_flags &= ~(PIPE_TRANSFER_COHERENT | PIPE_TRANSFER_PERSISTENT); + upload->map_flags |= PIPE_TRANSFER_FLUSH_EXPLICIT; } -/* Release old buffer. - * - * This must usually be called prior to firing the command stream - * which references the upload buffer, as many memory managers will - * cause subsequent maps of a fired buffer to wait. - * - * Can improve this with a change to pipe_buffer_write to use the - * DONT_WAIT bit, but for now, it's easiest just to grab a new buffer. - */ -void u_upload_flush( struct u_upload_mgr *upload ) +static void +upload_unmap_internal(struct u_upload_mgr *upload, boolean destroying) +{ + if (!upload->transfer) + return; + + if (upload->map_flags & PIPE_TRANSFER_FLUSH_EXPLICIT) { + struct pipe_box *box = &upload->transfer->box; + unsigned flush_offset = box->x + upload->flushed_size; + + if (upload->offset > flush_offset) { + pipe_buffer_flush_mapped_range(upload->pipe, upload->transfer, + flush_offset, + upload->offset - flush_offset); + upload->flushed_size = upload->offset; + } + } + + if (destroying || !upload->map_persistent) { + pipe_transfer_unmap(upload->pipe, upload->transfer); + upload->transfer = NULL; + upload->map = NULL; + upload->flushed_size = 0; + } +} + + +void +u_upload_unmap(struct u_upload_mgr *upload) +{ + upload_unmap_internal(upload, FALSE); +} + + +static void +u_upload_release_buffer(struct u_upload_mgr *upload) { - pipe_resource_reference( &upload->buffer, NULL ); - upload->size = 0; + /* Unmap and unreference the upload buffer. */ + upload_unmap_internal(upload, TRUE); + pipe_resource_reference(&upload->buffer, NULL); } -void u_upload_destroy( struct u_upload_mgr *upload ) +void +u_upload_destroy(struct u_upload_mgr *upload) { - u_upload_flush( upload ); - FREE( upload ); + u_upload_release_buffer(upload); + FREE(upload); } -static enum pipe_error -u_upload_alloc_buffer( struct u_upload_mgr *upload, - unsigned min_size ) +static void +u_upload_alloc_buffer(struct u_upload_mgr *upload, unsigned min_size) { + struct pipe_screen *screen = upload->pipe->screen; + struct pipe_resource buffer; unsigned size; - /* Release old buffer, if present: + /* Release the old buffer, if present: */ - u_upload_flush( upload ); + u_upload_release_buffer(upload); - /* Allocate a new one: + /* Allocate a new one: */ size = align(MAX2(upload->default_size, min_size), 4096); - upload->buffer = pipe_buffer_create( upload->pipe->screen, - upload->usage, - size ); - if (upload->buffer == NULL) - goto fail; - - upload->size = size; - - upload->offset = 0; - return 0; + memset(&buffer, 0, sizeof buffer); + buffer.target = PIPE_BUFFER; + buffer.format = PIPE_FORMAT_R8_UNORM; /* want TYPELESS or similar */ + buffer.bind = upload->bind; + buffer.usage = upload->usage; + buffer.flags = upload->flags; + buffer.width0 = size; + buffer.height0 = 1; + buffer.depth0 = 1; + buffer.array_size = 1; + + if (upload->map_persistent) { + buffer.flags |= PIPE_RESOURCE_FLAG_MAP_PERSISTENT | + PIPE_RESOURCE_FLAG_MAP_COHERENT; + } -fail: - if (upload->buffer) - pipe_resource_reference( &upload->buffer, NULL ); + upload->buffer = screen->resource_create(screen, &buffer); + if (upload->buffer == NULL) + return; + + /* Map the new buffer. */ + upload->map = pipe_buffer_map_range(upload->pipe, upload->buffer, + 0, size, upload->map_flags, + &upload->transfer); + if (upload->map == NULL) { + upload->transfer = NULL; + pipe_resource_reference(&upload->buffer, NULL); + return; + } - return PIPE_ERROR_OUT_OF_MEMORY; + upload->offset = 0; } - -enum pipe_error u_upload_data( struct u_upload_mgr *upload, - unsigned size, - const void *data, - unsigned *out_offset, - struct pipe_resource **outbuf ) +void +u_upload_alloc(struct u_upload_mgr *upload, + unsigned min_out_offset, + unsigned size, + unsigned alignment, + unsigned *out_offset, + struct pipe_resource **outbuf, + void **ptr) { - unsigned alloc_size = align( size, upload->alignment ); - enum pipe_error ret = PIPE_OK; + unsigned buffer_size = upload->buffer ? upload->buffer->width0 : 0; + unsigned offset; - if (upload->offset + alloc_size > upload->size) { - ret = u_upload_alloc_buffer( upload, alloc_size ); - if (ret) - return ret; - } + min_out_offset = align(min_out_offset, alignment); - /* Copy the data, using map_range if available: - */ - ret = my_buffer_write( upload->pipe, - upload->buffer, - upload->offset, - size, - alloc_size, - data ); - if (ret) - return ret; - - /* Emit the return values: - */ - pipe_resource_reference( outbuf, upload->buffer ); - *out_offset = upload->offset; - upload->offset += alloc_size; - return PIPE_OK; -} + offset = align(upload->offset, alignment); + offset = MAX2(offset, min_out_offset); + /* Make sure we have enough space in the upload buffer + * for the sub-allocation. + */ + if (unlikely(!upload->buffer || offset + size > buffer_size)) { + u_upload_alloc_buffer(upload, min_out_offset + size); + + if (unlikely(!upload->buffer)) { + *out_offset = ~0; + pipe_resource_reference(outbuf, NULL); + *ptr = NULL; + return; + } + + offset = min_out_offset; + buffer_size = upload->buffer->width0; + } -/* As above, but upload the full contents of a buffer. Useful for - * uploading user buffers, avoids generating an explosion of GPU - * buffers if you have an app that does lots of small vertex buffer - * renders or DrawElements calls. - */ -enum pipe_error u_upload_buffer( struct u_upload_mgr *upload, - unsigned offset, - unsigned size, - struct pipe_resource *inbuf, - unsigned *out_offset, - struct pipe_resource **outbuf ) -{ - enum pipe_error ret = PIPE_OK; - struct pipe_transfer *transfer = NULL; - const char *map = NULL; - - map = (const char *)pipe_buffer_map(upload->pipe, - inbuf, - PIPE_TRANSFER_READ, - &transfer); - - if (map == NULL) { - ret = PIPE_ERROR_OUT_OF_MEMORY; - goto done; + if (unlikely(!upload->map)) { + upload->map = pipe_buffer_map_range(upload->pipe, upload->buffer, + offset, + buffer_size - offset, + upload->map_flags, + &upload->transfer); + if (unlikely(!upload->map)) { + upload->transfer = NULL; + *out_offset = ~0; + pipe_resource_reference(outbuf, NULL); + *ptr = NULL; + return; + } + + upload->map -= offset; } - if (0) - debug_printf("upload ptr %p ofs %d sz %d\n", map, offset, size); + assert(offset < buffer_size); + assert(offset + size <= buffer_size); + assert(size); + + /* Emit the return values: */ + *ptr = upload->map + offset; + pipe_resource_reference(outbuf, upload->buffer); + *out_offset = offset; - ret = u_upload_data( upload, - size, - map + offset, - out_offset, - outbuf ); - if (ret) - goto done; + upload->offset = offset + size; +} -done: - if (map) - pipe_buffer_unmap( upload->pipe, inbuf, transfer ); +void +u_upload_data(struct u_upload_mgr *upload, + unsigned min_out_offset, + unsigned size, + unsigned alignment, + const void *data, + unsigned *out_offset, + struct pipe_resource **outbuf) +{ + uint8_t *ptr; - return ret; + u_upload_alloc(upload, min_out_offset, size, alignment, + out_offset, outbuf, + (void**)&ptr); + if (ptr) + memcpy(ptr, data, size); }