summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/gallium/auxiliary/util/u_helpers.c120
-rw-r--r--src/gallium/auxiliary/util/u_helpers.h17
-rw-r--r--src/mesa/state_tracker/st_cb_texture.c16
-rw-r--r--src/mesa/state_tracker/st_context.c5
-rw-r--r--src/mesa/state_tracker/st_context.h7
5 files changed, 165 insertions, 0 deletions
diff --git a/src/gallium/auxiliary/util/u_helpers.c b/src/gallium/auxiliary/util/u_helpers.c
index 7d45b2f06db..f773360adde 100644
--- a/src/gallium/auxiliary/util/u_helpers.c
+++ b/src/gallium/auxiliary/util/u_helpers.c
@@ -221,3 +221,123 @@ util_wait_for_idle(struct pipe_context *ctx)
ctx->flush(ctx, &fence, 0);
ctx->screen->fence_finish(ctx->screen, NULL, fence, PIPE_TIMEOUT_INFINITE);
}
+
+void
+util_throttle_init(struct util_throttle *t, uint64_t max_mem_usage)
+{
+ t->max_mem_usage = max_mem_usage;
+}
+
+void
+util_throttle_deinit(struct pipe_screen *screen, struct util_throttle *t)
+{
+ for (unsigned i = 0; i < ARRAY_SIZE(t->ring); i++)
+ screen->fence_reference(screen, &t->ring[i].fence, NULL);
+}
+
+static uint64_t
+util_get_throttle_total_memory_usage(struct util_throttle *t)
+{
+ uint64_t total_usage = 0;
+
+ for (unsigned i = 0; i < ARRAY_SIZE(t->ring); i++)
+ total_usage += t->ring[i].mem_usage;
+ return total_usage;
+}
+
+static void util_dump_throttle_ring(struct util_throttle *t)
+{
+ printf("Throttle:\n");
+ for (unsigned i = 0; i < ARRAY_SIZE(t->ring); i++) {
+ printf(" ring[%u]: fence = %s, mem_usage = %"PRIu64"%s%s\n",
+ i, t->ring[i].fence ? "yes" : " no",
+ t->ring[i].mem_usage,
+ t->flush_index == i ? " [flush]" : "",
+ t->wait_index == i ? " [wait]" : "");
+ }
+}
+
+/**
+ * Notify util_throttle that the next operation allocates memory.
+ * util_throttle tracks memory usage and waits for fences until its tracked
+ * memory usage decreases.
+ *
+ * Example:
+ * util_throttle_memory_usage(..., w*h*d*Bpp);
+ * TexSubImage(..., w, h, d, ...);
+ *
+ * This means that TexSubImage can't allocate more memory its maximum limit
+ * set during initialization.
+ */
+void
+util_throttle_memory_usage(struct pipe_context *pipe,
+ struct util_throttle *t, uint64_t memory_size)
+{
+ (void)util_dump_throttle_ring; /* silence warning */
+
+ if (!t->max_mem_usage)
+ return;
+
+ struct pipe_screen *screen = pipe->screen;
+ struct pipe_fence_handle **fence = NULL;
+ unsigned ring_size = ARRAY_SIZE(t->ring);
+ uint64_t total = util_get_throttle_total_memory_usage(t);
+
+ /* If there is not enough memory, walk the list of fences and find
+ * the latest one that we need to wait for.
+ */
+ while (t->wait_index != t->flush_index &&
+ total && total + memory_size > t->max_mem_usage) {
+ assert(t->ring[t->wait_index].fence);
+
+ /* Release an older fence if we need to wait for a newer one. */
+ if (fence)
+ screen->fence_reference(screen, fence, NULL);
+
+ fence = &t->ring[t->wait_index].fence;
+ t->ring[t->wait_index].mem_usage = 0;
+ t->wait_index = (t->wait_index + 1) % ring_size;
+
+ total = util_get_throttle_total_memory_usage(t);
+ }
+
+ /* Wait for the fence to decrease memory usage. */
+ if (fence) {
+ screen->fence_finish(screen, pipe, *fence, PIPE_TIMEOUT_INFINITE);
+ screen->fence_reference(screen, fence, NULL);
+ }
+
+ /* Flush and get a fence if we've exhausted memory usage for the current
+ * slot.
+ */
+ if (t->ring[t->flush_index].mem_usage &&
+ t->ring[t->flush_index].mem_usage + memory_size >
+ t->max_mem_usage / (ring_size / 2)) {
+ struct pipe_fence_handle **fence =
+ &t->ring[t->flush_index].fence;
+
+ /* Expect that the current flush slot doesn't have a fence yet. */
+ assert(!*fence);
+
+ pipe->flush(pipe, fence, PIPE_FLUSH_ASYNC);
+ t->flush_index = (t->flush_index + 1) % ring_size;
+
+ /* Vacate the next slot if it's occupied. This should be rare. */
+ if (t->flush_index == t->wait_index) {
+ struct pipe_fence_handle **fence =
+ &t->ring[t->wait_index].fence;
+
+ t->ring[t->wait_index].mem_usage = 0;
+ t->wait_index = (t->wait_index + 1) % ring_size;
+
+ assert(*fence);
+ screen->fence_finish(screen, pipe, *fence, PIPE_TIMEOUT_INFINITE);
+ screen->fence_reference(screen, fence, NULL);
+ }
+
+ assert(!t->ring[t->flush_index].mem_usage);
+ assert(!t->ring[t->flush_index].fence);
+ }
+
+ t->ring[t->flush_index].mem_usage += memory_size;
+}
diff --git a/src/gallium/auxiliary/util/u_helpers.h b/src/gallium/auxiliary/util/u_helpers.h
index f00436e3b11..38c47c1cc98 100644
--- a/src/gallium/auxiliary/util/u_helpers.h
+++ b/src/gallium/auxiliary/util/u_helpers.h
@@ -64,6 +64,23 @@ util_end_pipestat_query(struct pipe_context *ctx, struct pipe_query *q,
void
util_wait_for_idle(struct pipe_context *ctx);
+/* A utility for throttling execution based on memory usage. */
+struct util_throttle {
+ struct {
+ struct pipe_fence_handle *fence;
+ uint64_t mem_usage;
+ } ring[10];
+
+ unsigned flush_index;
+ unsigned wait_index;
+ uint64_t max_mem_usage;
+};
+
+void util_throttle_init(struct util_throttle *t, uint64_t max_mem_usage);
+void util_throttle_deinit(struct pipe_screen *screen, struct util_throttle *t);
+void util_throttle_memory_usage(struct pipe_context *pipe,
+ struct util_throttle *t, uint64_t memory_size);
+
#ifdef __cplusplus
}
#endif
diff --git a/src/mesa/state_tracker/st_cb_texture.c b/src/mesa/state_tracker/st_cb_texture.c
index 5406d0247c5..e6e27a852f5 100644
--- a/src/mesa/state_tracker/st_cb_texture.c
+++ b/src/mesa/state_tracker/st_cb_texture.c
@@ -1392,6 +1392,7 @@ try_pbo_upload(struct gl_context *ctx, GLuint dims,
return success;
}
+
static void
st_TexSubImage(struct gl_context *ctx, GLuint dims,
struct gl_texture_image *texImage,
@@ -1417,6 +1418,7 @@ st_TexSubImage(struct gl_context *ctx, GLuint dims,
GLubyte *map;
unsigned dstz = texImage->Face + texImage->TexObject->MinLayer;
unsigned dst_level = 0;
+ bool throttled = false;
st_flush_bitmap_cache(st);
st_invalidate_readpix_cache(st);
@@ -1456,6 +1458,10 @@ st_TexSubImage(struct gl_context *ctx, GLuint dims,
layer_stride = stride;
}
+ util_throttle_memory_usage(pipe, &st->throttle,
+ width * height * depth *
+ util_format_get_blocksize(dst->format));
+
u_box_3d(xoffset, yoffset, zoffset + dstz, width, height, depth, &box);
pipe->texture_subdata(pipe, dst, dst_level, 0,
&box, data, stride, layer_stride);
@@ -1561,6 +1567,11 @@ st_TexSubImage(struct gl_context *ctx, GLuint dims,
goto fallback;
}
+ util_throttle_memory_usage(pipe, &st->throttle,
+ width * height * depth *
+ util_format_get_blocksize(src_templ.format));
+ throttled = true;
+
/* Create the source texture. */
src = screen->resource_create(screen, &src_templ);
if (!src) {
@@ -1651,6 +1662,11 @@ st_TexSubImage(struct gl_context *ctx, GLuint dims,
return;
fallback:
+ if (!throttled) {
+ util_throttle_memory_usage(pipe, &st->throttle,
+ width * height * depth *
+ _mesa_get_format_bytes(texImage->TexFormat));
+ }
_mesa_store_texsubimage(ctx, dims, texImage, xoffset, yoffset, zoffset,
width, height, depth, format, type, pixels,
unpack);
diff --git a/src/mesa/state_tracker/st_context.c b/src/mesa/state_tracker/st_context.c
index 146d9c629ab..354876746f4 100644
--- a/src/mesa/state_tracker/st_context.c
+++ b/src/mesa/state_tracker/st_context.c
@@ -275,6 +275,7 @@ st_destroy_context_priv(struct st_context *st, bool destroy_pipe)
/* free glReadPixels cache data */
st_invalidate_readpix_cache(st);
+ util_throttle_deinit(st->pipe->screen, &st->throttle);
cso_destroy_context(st->cso_context);
@@ -467,6 +468,10 @@ st_create_context_priv(struct gl_context *ctx, struct pipe_context *pipe,
PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTERS)
? true : false;
+ util_throttle_init(&st->throttle,
+ screen->get_param(screen,
+ PIPE_CAP_MAX_TEXTURE_UPLOAD_MEMORY_BUDGET));
+
/* GL limits and extensions */
st_init_limits(pipe->screen, &ctx->Const, &ctx->Extensions, ctx->API);
st_init_extensions(pipe->screen, &ctx->Const,
diff --git a/src/mesa/state_tracker/st_context.h b/src/mesa/state_tracker/st_context.h
index 6b1b5633ecc..14b9b018809 100644
--- a/src/mesa/state_tracker/st_context.h
+++ b/src/mesa/state_tracker/st_context.h
@@ -32,6 +32,7 @@
#include "state_tracker/st_api.h"
#include "main/fbobject.h"
#include "state_tracker/st_atom.h"
+#include "util/u_helpers.h"
#include "util/u_inlines.h"
#include "util/list.h"
#include "vbo/vbo.h"
@@ -302,6 +303,12 @@ struct st_context
/* Winsys buffers */
struct list_head winsys_buffers;
+
+ /* Throttling for texture uploads and similar operations to limit memory
+ * usage by limiting the number of in-flight operations based on
+ * the estimated allocated size needed to execute those operations.
+ */
+ struct util_throttle throttle;
};
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-04 19:20:07 +0000