/**
- * Vertex and index buffers need hardware backing. Constant buffers
- * do not. No other types of buffers currently supported.
+ * Determine what buffers eventually need hardware backing.
+ *
+ * Vertex- and index buffers need hardware backing. Constant buffers
+ * do on vgpu10. Staging texture-upload buffers do when they are
+ * supported.
*/
static inline boolean
-svga_buffer_needs_hw_storage(unsigned usage)
+svga_buffer_needs_hw_storage(const struct svga_screen *ss,
+ const struct pipe_resource *template)
{
- return (usage & (PIPE_BIND_VERTEX_BUFFER | PIPE_BIND_INDEX_BUFFER |
- PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_STREAM_OUTPUT)) != 0;
-}
+ unsigned bind_mask = (PIPE_BIND_VERTEX_BUFFER | PIPE_BIND_INDEX_BUFFER |
+ PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_STREAM_OUTPUT |
+ PIPE_BIND_SHADER_BUFFER | PIPE_BIND_COMMAND_ARGS_BUFFER);
+
+ if (ss->sws->have_vgpu10) {
+ /*
+ * Driver-created upload const0- and staging texture upload buffers
+ * tagged with PIPE_BIND_CUSTOM
+ */
+ bind_mask |= PIPE_BIND_CUSTOM;
+ /**
+ * Uniform buffer objects.
+ * Don't create hardware storage for state-tracker constant buffers,
+ * because we frequently map them for reading and writing, and
+ * the length of those buffers are always small, so it is better
+ * to just use system memory.
+ */
+ }
+ if (template->flags & PIPE_RESOURCE_FLAG_MAP_PERSISTENT)
+ return TRUE;
+
+ return !!(template->bind & bind_mask);
+}
/**
* Create a buffer transfer.
struct svga_screen *ss = svga_screen(pipe->screen);
struct svga_buffer *sbuf = svga_buffer(resource);
struct pipe_transfer *transfer;
- uint8_t *map;
+ uint8_t *map = NULL;
int64_t begin = svga_get_time(svga);
+ SVGA_STATS_TIME_PUSH(svga_sws(svga), SVGA_STATS_TIME_BUFFERTRANSFERMAP);
+
assert(box->y == 0);
assert(box->z == 0);
assert(box->height == 1);
transfer = MALLOC_STRUCT(pipe_transfer);
if (!transfer) {
- return NULL;
+ goto done;
}
transfer->resource = resource;
transfer->stride = 0;
transfer->layer_stride = 0;
- if ((usage & PIPE_TRANSFER_READ) && sbuf->dirty) {
- enum pipe_error ret;
+ if (usage & PIPE_TRANSFER_WRITE) {
+ /* If we write to the buffer for any reason, free any saved translated
+ * vertices.
+ */
+ pipe_resource_reference(&sbuf->translated_indices.buffer, NULL);
+ }
+
+ if ((usage & PIPE_TRANSFER_READ) && sbuf->dirty &&
+ !sbuf->key.coherent && !svga->swc->force_coherent) {
/* Host-side buffers can only be dirtied with vgpu10 features
* (streamout and buffer copy).
assert(svga_have_vgpu10(svga));
if (!sbuf->user) {
- (void) svga_buffer_handle(svga, resource);
+ (void) svga_buffer_handle(svga, resource, sbuf->bind_flags);
}
- if (sbuf->dma.pending > 0) {
+ if (sbuf->dma.pending) {
svga_buffer_upload_flush(svga, sbuf);
svga_context_finish(svga);
}
assert(sbuf->handle);
- ret = SVGA3D_vgpu10_ReadbackSubResource(svga->swc, sbuf->handle, 0);
- if (ret != PIPE_OK) {
- svga_context_flush(svga, NULL);
- ret = SVGA3D_vgpu10_ReadbackSubResource(svga->swc, sbuf->handle, 0);
- assert(ret == PIPE_OK);
- }
-
+ SVGA_RETRY(svga, SVGA3D_vgpu10_ReadbackSubResource(svga->swc,
+ sbuf->handle, 0));
svga->hud.num_readbacks++;
svga_context_finish(svga);
}
if (usage & PIPE_TRANSFER_WRITE) {
- if (usage & PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE) {
+ if ((usage & PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE) &&
+ !(resource->flags & PIPE_RESOURCE_FLAG_MAP_PERSISTENT)) {
/*
* Flush any pending primitives, finish writing any pending DMA
* commands, and tell the host to discard the buffer contents on
/*
* We have a pending DMA upload from a hardware buffer, therefore
* we need to ensure that the host finishes processing that DMA
- * command before the state tracker can start overwriting the
+ * command before the gallium frontend can start overwriting the
* hardware buffer.
*
* XXX: This could be avoided by tying the hardware buffer to
*/
FREE(transfer);
- return NULL;
+ goto done;
}
svga_context_flush(svga, NULL);
}
if (!sbuf->swbuf && !svga_buffer_has_hw_storage(sbuf)) {
- if (svga_buffer_create_hw_storage(ss, sbuf) != PIPE_OK) {
+ if (svga_buffer_create_hw_storage(ss, sbuf, sbuf->bind_flags) != PIPE_OK) {
/*
* We can't create a hardware buffer big enough, so create a malloc
* buffer instead.
sbuf->swbuf = align_malloc(sbuf->b.b.width0, 16);
if (!sbuf->swbuf) {
FREE(transfer);
- return NULL;
+ goto done;
}
}
}
else if (svga_buffer_has_hw_storage(sbuf)) {
boolean retry;
- map = svga_buffer_hw_storage_map(svga, sbuf, transfer->usage, &retry);
+ map = SVGA_TRY_MAP(svga_buffer_hw_storage_map
+ (svga, sbuf, transfer->usage, &retry), retry);
if (map == NULL && retry) {
/*
* At this point, svga_buffer_get_transfer() has already
* hit the DISCARD_WHOLE_RESOURCE path and flushed HWTNL
* for this buffer.
*/
+ svga_retry_enter(svga);
svga_context_flush(svga, NULL);
map = svga_buffer_hw_storage_map(svga, sbuf, transfer->usage, &retry);
+ svga_retry_exit(svga);
}
}
else {
svga->hud.map_buffer_time += (svga_get_time(svga) - begin);
+done:
+ SVGA_STATS_TIME_POP(svga_sws(svga));
return map;
}
static void
-svga_buffer_transfer_flush_region( struct pipe_context *pipe,
- struct pipe_transfer *transfer,
- const struct pipe_box *box)
+svga_buffer_transfer_flush_region(struct pipe_context *pipe,
+ struct pipe_transfer *transfer,
+ const struct pipe_box *box)
{
struct svga_screen *ss = svga_screen(pipe->screen);
struct svga_buffer *sbuf = svga_buffer(transfer->resource);
-
+ struct svga_context *svga = svga_context(pipe);
unsigned offset = transfer->box.x + box->x;
unsigned length = box->width;
assert(transfer->usage & PIPE_TRANSFER_WRITE);
assert(transfer->usage & PIPE_TRANSFER_FLUSH_EXPLICIT);
- pipe_mutex_lock(ss->swc_mutex);
- svga_buffer_add_range(sbuf, offset, offset + length);
- pipe_mutex_unlock(ss->swc_mutex);
+ if (!(svga->swc->force_coherent || sbuf->key.coherent) || sbuf->swbuf) {
+ mtx_lock(&ss->swc_mutex);
+ svga_buffer_add_range(sbuf, offset, offset + length);
+ mtx_unlock(&ss->swc_mutex);
+ }
}
static void
-svga_buffer_transfer_unmap( struct pipe_context *pipe,
- struct pipe_transfer *transfer )
+svga_buffer_transfer_unmap(struct pipe_context *pipe,
+ struct pipe_transfer *transfer)
{
struct svga_screen *ss = svga_screen(pipe->screen);
struct svga_context *svga = svga_context(pipe);
struct svga_buffer *sbuf = svga_buffer(transfer->resource);
- pipe_mutex_lock(ss->swc_mutex);
+ SVGA_STATS_TIME_PUSH(svga_sws(svga), SVGA_STATS_TIME_BUFFERTRANSFERUNMAP);
+
+ mtx_lock(&ss->swc_mutex);
assert(sbuf->map.count);
if (sbuf->map.count) {
}
if (svga_buffer_has_hw_storage(sbuf)) {
+
+ /* Note: we may wind up flushing here and unmapping other buffers
+ * which leads to recursively locking ss->swc_mutex.
+ */
svga_buffer_hw_storage_unmap(svga, sbuf);
}
sbuf->dma.flags.discard = TRUE;
- svga_buffer_add_range(sbuf, 0, sbuf->b.b.width0);
+ if (!(svga->swc->force_coherent || sbuf->key.coherent) || sbuf->swbuf)
+ svga_buffer_add_range(sbuf, 0, sbuf->b.b.width0);
+ }
+
+ if (sbuf->swbuf &&
+ (!sbuf->bind_flags || (sbuf->bind_flags & PIPE_BIND_CONSTANT_BUFFER))) {
+ /*
+ * Since the constant buffer is in system buffer, we need
+ * to set the constant buffer dirty bits, so that the context
+ * can update the changes in the device.
+ * According to the GL spec, buffer bound to other contexts will
+ * have to be explicitly rebound by the user to have the changes take
+ * into effect.
+ */
+ svga->dirty |= SVGA_NEW_CONST_BUFFER;
}
}
- pipe_mutex_unlock(ss->swc_mutex);
+ mtx_unlock(&ss->swc_mutex);
FREE(transfer);
+ SVGA_STATS_TIME_POP(svga_sws(svga));
}
static void
-svga_buffer_destroy( struct pipe_screen *screen,
- struct pipe_resource *buf )
+svga_buffer_destroy(struct pipe_screen *screen,
+ struct pipe_resource *buf)
{
- struct svga_screen *ss = svga_screen(screen);
- struct svga_buffer *sbuf = svga_buffer( buf );
+ struct svga_screen *ss = svga_screen(screen);
+ struct svga_buffer *sbuf = svga_buffer(buf);
assert(!p_atomic_read(&buf->reference.count));
if (sbuf->swbuf && !sbuf->user)
align_free(sbuf->swbuf);
+ pipe_resource_reference(&sbuf->translated_indices.buffer, NULL);
+
ss->hud.total_resource_bytes -= sbuf->size;
assert(ss->hud.num_resources > 0);
if (ss->hud.num_resources > 0)
struct pipe_resource *
svga_buffer_create(struct pipe_screen *screen,
- const struct pipe_resource *template)
+ const struct pipe_resource *template)
{
struct svga_screen *ss = svga_screen(screen);
struct svga_buffer *sbuf;
+ unsigned bind_flags;
+
+ SVGA_STATS_TIME_PUSH(ss->sws, SVGA_STATS_TIME_CREATEBUFFER);
sbuf = CALLOC_STRUCT(svga_buffer);
if (!sbuf)
sbuf->b.vtbl = &svga_buffer_vtbl;
pipe_reference_init(&sbuf->b.b.reference, 1);
sbuf->b.b.screen = screen;
- sbuf->bind_flags = template->bind;
+ bind_flags = template->bind & ~PIPE_BIND_CUSTOM;
- if (template->bind & PIPE_BIND_CONSTANT_BUFFER) {
+ list_inithead(&sbuf->surfaces);
+
+ if (bind_flags & PIPE_BIND_CONSTANT_BUFFER) {
/* Constant buffers can only have the PIPE_BIND_CONSTANT_BUFFER
* flag set.
*/
if (ss->sws->have_vgpu10) {
- sbuf->bind_flags = PIPE_BIND_CONSTANT_BUFFER;
-
- /* Constant buffer size needs to be in multiples of 16. */
- sbuf->b.b.width0 = align(sbuf->b.b.width0, 16);
+ bind_flags = PIPE_BIND_CONSTANT_BUFFER;
}
}
- if (svga_buffer_needs_hw_storage(template->bind)) {
+ /* Although svga device only requires constant buffer size to be
+ * in multiples of 16, in order to allow bind_flags promotion,
+ * we are mandating all buffer size to be in multiples of 16.
+ */
+ sbuf->b.b.width0 = align(sbuf->b.b.width0, 16);
+
+ if (svga_buffer_needs_hw_storage(ss, template)) {
- /* If the buffer will be used for vertex/index/stream data, set all
- * the flags so that the buffer will be accepted for all those uses.
- * Note that the PIPE_BIND_ flags we get from the state tracker are
+ /* If the buffer is not used for constant buffer, set
+ * the vertex/index bind flags as well so that the buffer will be
+ * accepted for those uses.
+ * Note that the PIPE_BIND_ flags we get from the gallium frontend are
* just a hint about how the buffer may be used. And OpenGL buffer
* object may be used for many different things.
+ * Also note that we do not unconditionally set the streamout
+ * bind flag since streamout buffer is an output buffer and
+ * might have performance implication.
*/
- if (!(template->bind & PIPE_BIND_CONSTANT_BUFFER)) {
- /* Not a constant buffer. The buffer may be used for vertex data,
- * indexes or stream-out.
+ if (!(template->bind & PIPE_BIND_CONSTANT_BUFFER) &&
+ !(template->bind & PIPE_BIND_CUSTOM)) {
+ /* Not a constant- or staging buffer.
+ * The buffer may be used for vertex data or indexes.
*/
- sbuf->bind_flags |= (PIPE_BIND_VERTEX_BUFFER |
- PIPE_BIND_INDEX_BUFFER);
- if (ss->sws->have_vgpu10)
- sbuf->bind_flags |= PIPE_BIND_STREAM_OUTPUT;
+ bind_flags |= (PIPE_BIND_VERTEX_BUFFER |
+ PIPE_BIND_INDEX_BUFFER);
+
+ /* It may be used for shader resource as well. */
+ bind_flags |= PIPE_BIND_SAMPLER_VIEW;
}
- if (svga_buffer_create_host_surface(ss, sbuf) != PIPE_OK)
+ if (svga_buffer_create_host_surface(ss, sbuf, bind_flags) != PIPE_OK)
goto error2;
}
else {
sbuf->swbuf = align_malloc(sbuf->b.b.width0, 64);
if (!sbuf->swbuf)
goto error2;
+
+ /* Since constant buffer is usually small, it is much cheaper to
+ * use system memory for the data just as it is being done for
+ * the default constant buffer.
+ */
+ if ((bind_flags & PIPE_BIND_CONSTANT_BUFFER) || !bind_flags)
+ sbuf->use_swbuf = TRUE;
}
debug_reference(&sbuf->b.b.reference,
(debug_reference_descriptor)debug_describe_resource, 0);
+ sbuf->bind_flags = bind_flags;
sbuf->size = util_resource_size(&sbuf->b.b);
ss->hud.total_resource_bytes += sbuf->size;
ss->hud.num_resources++;
+ SVGA_STATS_TIME_POP(ss->sws);
return &sbuf->b.b;
error2:
FREE(sbuf);
error1:
+ SVGA_STATS_TIME_POP(ss->sws);
return NULL;
}
svga_user_buffer_create(struct pipe_screen *screen,
void *ptr,
unsigned bytes,
- unsigned bind)
+ unsigned bind)
{
struct svga_buffer *sbuf;
struct svga_screen *ss = svga_screen(screen);
no_sbuf:
return NULL;
}
-
-
-
projects / mesa.git / blobdiff