X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fauxiliary%2Futil%2Fu_upload_mgr.c;h=f703852be817cdea84a11a683b68d46f77570bd9;hb=37db383abbec071e2b3d26d0a531ec8296705b63;hp=71fe53e3a273ce2b71abd3025606134dc623c30f;hpb=636d01bd61cac83e13c3c64874e7e34e828ca93a;p=mesa.git diff --git a/src/gallium/auxiliary/util/u_upload_mgr.c b/src/gallium/auxiliary/util/u_upload_mgr.c index 71fe53e3a27..f703852be81 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 @@ -42,228 +42,240 @@ struct u_upload_mgr { struct pipe_context *pipe; unsigned default_size; /* Minimum size of the upload buffer, in bytes. */ - unsigned alignment; /* Alignment of each sub-allocation. */ 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 size; /* Actual size of the upload buffer. */ unsigned offset; /* Aligned offset to the upload buffer, pointing * at the first unused byte. */ }; -struct u_upload_mgr *u_upload_create( struct pipe_context *pipe, - unsigned default_size, - unsigned alignment, - unsigned bind ) +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->buffer = NULL; + upload->usage = usage; + 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; } -void u_upload_unmap( struct u_upload_mgr *upload ) +struct u_upload_mgr * +u_upload_create_default(struct pipe_context *pipe) +{ + return u_upload_create(pipe, 1024 * 1024, + PIPE_BIND_VERTEX_BUFFER | + PIPE_BIND_INDEX_BUFFER | + PIPE_BIND_CONSTANT_BUFFER, + PIPE_USAGE_STREAM, 0); +} + +struct u_upload_mgr * +u_upload_clone(struct pipe_context *pipe, struct u_upload_mgr *upload) { + return u_upload_create(pipe, upload->default_size, upload->bind, + upload->usage, upload->flags); +} + +static void +upload_unmap_internal(struct u_upload_mgr *upload, boolean destroying) +{ + if (!destroying && upload->map_persistent) + return; + if (upload->transfer) { struct pipe_box *box = &upload->transfer->box; - if (upload->offset > box->x) { + if (!upload->map_persistent && (int) upload->offset > box->x) { pipe_buffer_flush_mapped_range(upload->pipe, upload->transfer, box->x, upload->offset - box->x); } + pipe_transfer_unmap(upload->pipe, upload->transfer); - pipe_transfer_destroy(upload->pipe, upload->transfer); upload->transfer = NULL; upload->map = NULL; } } -/* 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 ) + +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) { /* Unmap and unreference the upload buffer. */ - u_upload_unmap(upload); - pipe_resource_reference( &upload->buffer, NULL ); - upload->size = 0; + 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 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->bind, - PIPE_USAGE_STREAM, - size ); - if (upload->buffer == NULL) - goto fail; + 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; + } + + 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, - PIPE_TRANSFER_WRITE | - PIPE_TRANSFER_FLUSH_EXPLICIT, + 0, size, upload->map_flags, &upload->transfer); - - upload->size = size; + if (upload->map == NULL) { + upload->transfer = NULL; + pipe_resource_reference(&upload->buffer, NULL); + return; + } upload->offset = 0; - return 0; - -fail: - if (upload->buffer) - pipe_resource_reference( &upload->buffer, NULL ); - - return PIPE_ERROR_OUT_OF_MEMORY; } -enum pipe_error u_upload_alloc( struct u_upload_mgr *upload, - unsigned min_out_offset, - unsigned size, - unsigned *out_offset, - struct pipe_resource **outbuf, - boolean *flushed, - void **ptr ) +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 ); - unsigned alloc_offset = align(min_out_offset, upload->alignment); + unsigned buffer_size = upload->buffer ? upload->buffer->width0 : 0; unsigned offset; + min_out_offset = align(min_out_offset, alignment); + + 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 (MAX2(upload->offset, alloc_offset) + alloc_size > upload->size) { - enum pipe_error ret = u_upload_alloc_buffer(upload, - alloc_offset + alloc_size); - if (ret) - return ret; - - *flushed = TRUE; - } else { - *flushed = FALSE; - } + * 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 = MAX2(upload->offset, alloc_offset); + offset = min_out_offset; + buffer_size = upload->buffer->width0; + } - if (!upload->map) { + if (unlikely(!upload->map)) { upload->map = pipe_buffer_map_range(upload->pipe, upload->buffer, - offset, upload->size - offset, - PIPE_TRANSFER_WRITE | - PIPE_TRANSFER_FLUSH_EXPLICIT | - PIPE_TRANSFER_UNSYNCHRONIZED, - &upload->transfer); + 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; } - assert(offset < upload->buffer->width0); - assert(offset + size <= upload->buffer->width0); + 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 ); + pipe_resource_reference(outbuf, upload->buffer); *out_offset = offset; - upload->offset = offset + alloc_size; - return PIPE_OK; + upload->offset = offset + size; } -enum pipe_error u_upload_data( struct u_upload_mgr *upload, - unsigned min_out_offset, - unsigned size, - const void *data, - unsigned *out_offset, - struct pipe_resource **outbuf, - boolean *flushed ) +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; - enum pipe_error ret = u_upload_alloc(upload, min_out_offset, size, - out_offset, outbuf, flushed, - (void**)&ptr); - if (ret) - return ret; - - memcpy(ptr, data, size); - return PIPE_OK; -} - - -/* 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 min_out_offset, - unsigned offset, - unsigned size, - struct pipe_resource *inbuf, - unsigned *out_offset, - struct pipe_resource **outbuf, - boolean *flushed ) -{ - enum pipe_error ret = PIPE_OK; - struct pipe_transfer *transfer = NULL; - const char *map = NULL; - - map = (const char *)pipe_buffer_map_range(upload->pipe, - inbuf, - offset, size, - PIPE_TRANSFER_READ, - &transfer); - - if (map == NULL) { - ret = PIPE_ERROR_OUT_OF_MEMORY; - goto done; - } - - if (0) - debug_printf("upload ptr %p ofs %d sz %d\n", map, offset, size); - - ret = u_upload_data( upload, - min_out_offset, - size, - map + offset, - out_offset, - outbuf, flushed ); - -done: - if (map) - pipe_buffer_unmap( upload->pipe, transfer ); - return ret; + u_upload_alloc(upload, min_out_offset, size, alignment, + out_offset, outbuf, + (void**)&ptr); + if (ptr) + memcpy(ptr, data, size); }