radeonsi: fix user fence space when MCBP is enabled

[mesa.git] / src / gallium / drivers / v3d / v3d_bufmgr.c

diff --git a/src/gallium/drivers/v3d/v3d_bufmgr.c b/src/gallium/drivers/v3d/v3d_bufmgr.c
index f7a851f9d43129be3c85ef7d89268eed960a0d85..48f5a54936c8dbea641d8f826d91b3fc7ad1f312 100644 (file)
--- a/src/gallium/drivers/v3d/v3d_bufmgr.c
+++ b/src/gallium/drivers/v3d/v3d_bufmgr.c
@@ -35,14 +35,6 @@
 #include "v3d_context.h"
 #include "v3d_screen.h"
 
-#ifdef HAVE_VALGRIND
-#include <valgrind.h>
-#include <memcheck.h>
-#define VG(x) x
-#else
-#define VG(x)
-#endif
-
 static bool dump_stats = false;
 
 static void
@@ -53,18 +45,25 @@ v3d_bo_dump_stats(struct v3d_screen *screen)
 {
         struct v3d_bo_cache *cache = &screen->bo_cache;
 
+        uint32_t cache_count = 0;
+        uint32_t cache_size = 0;
+        list_for_each_entry(struct v3d_bo, bo, &cache->time_list, time_list) {
+                cache_count++;
+                cache_size += bo->size;
+        }
+
         fprintf(stderr, "  BOs allocated:   %d\n", screen->bo_count);
         fprintf(stderr, "  BOs size:        %dkb\n", screen->bo_size / 1024);
-        fprintf(stderr, "  BOs cached:      %d\n", cache->bo_count);
-        fprintf(stderr, "  BOs cached size: %dkb\n", cache->bo_size / 1024);
+        fprintf(stderr, "  BOs cached:      %d\n", cache_count);
+        fprintf(stderr, "  BOs cached size: %dkb\n", cache_size / 1024);
 
-        if (!list_empty(&cache->time_list)) {
-                struct v3d_bo *first = LIST_ENTRY(struct v3d_bo,
-                                                  cache->time_list.next,
-                                                  time_list);
-                struct v3d_bo *last = LIST_ENTRY(struct v3d_bo,
-                                                  cache->time_list.prev,
-                                                  time_list);
+        if (!list_is_empty(&cache->time_list)) {
+                struct v3d_bo *first = list_first_entry(&cache->time_list,
+                                                        struct v3d_bo,
+                                                        time_list);
+                struct v3d_bo *last = list_last_entry(&cache->time_list,
+                                                      struct v3d_bo,
+                                                      time_list);
 
                 fprintf(stderr, "  oldest cache time: %ld\n",
                         (long)first->free_time);
@@ -74,7 +73,7 @@ v3d_bo_dump_stats(struct v3d_screen *screen)
                 struct timespec time;
                 clock_gettime(CLOCK_MONOTONIC, &time);
                 fprintf(stderr, "  now:               %ld\n",
-                        time.tv_sec);
+                        (long)time.tv_sec);
         }
 }
 
@@ -83,8 +82,6 @@ v3d_bo_remove_from_cache(struct v3d_bo_cache *cache, struct v3d_bo *bo)
 {
         list_del(&bo->time_list);
         list_del(&bo->size_list);
-        cache->bo_count--;
-        cache->bo_size -= bo->size;
 }
 
 static struct v3d_bo *
@@ -98,9 +95,9 @@ v3d_bo_from_cache(struct v3d_screen *screen, uint32_t size, const char *name)
 
         struct v3d_bo *bo = NULL;
         mtx_lock(&cache->lock);
-        if (!list_empty(&cache->size_list[page_index])) {
-                bo = LIST_ENTRY(struct v3d_bo, cache->size_list[page_index].next,
-                                size_list);
+        if (!list_is_empty(&cache->size_list[page_index])) {
+                bo = list_first_entry(&cache->size_list[page_index],
+                                      struct v3d_bo, size_list);
 
                 /* Check that the BO has gone idle.  If not, then we want to
                  * allocate something new instead, since we assume that the
@@ -126,6 +123,10 @@ v3d_bo_alloc(struct v3d_screen *screen, uint32_t size, const char *name)
         struct v3d_bo *bo;
         int ret;
 
+        /* The CLIF dumping requires that there is no whitespace in the name.
+         */
+        assert(!strchr(name, ' '));
+
         size = align(size, 4096);
 
         bo = v3d_bo_from_cache(screen, size, name);
@@ -161,7 +162,7 @@ v3d_bo_alloc(struct v3d_screen *screen, uint32_t size, const char *name)
         bo->offset = create.offset;
 
         if (ret != 0) {
-                if (!list_empty(&screen->bo_cache.time_list) &&
+                if (!list_is_empty(&screen->bo_cache.time_list) &&
                     !cleared_and_retried) {
                         cleared_and_retried = true;
                         v3d_bo_cache_free_all(&screen->bo_cache);
@@ -238,14 +239,13 @@ free_stale_bos(struct v3d_screen *screen, time_t time)
 
         list_for_each_entry_safe(struct v3d_bo, bo, &cache->time_list,
                                  time_list) {
-                if (dump_stats && !freed_any) {
-                        fprintf(stderr, "Freeing stale BOs:\n");
-                        v3d_bo_dump_stats(screen);
-                        freed_any = true;
-                }
-
                 /* If it's more than a second old, free it. */
                 if (time - bo->free_time > 2) {
+                        if (dump_stats && !freed_any) {
+                                fprintf(stderr, "Freeing stale BOs:\n");
+                                v3d_bo_dump_stats(screen);
+                                freed_any = true;
+                        }
                         v3d_bo_remove_from_cache(cache, bo);
                         v3d_bo_free(bo);
                 } else {
@@ -292,7 +292,7 @@ v3d_bo_last_unreference_locked_timed(struct v3d_bo *bo, time_t time)
                  */
                 for (int i = 0; i < cache->size_list_size; i++) {
                         struct list_head *old_head = &cache->size_list[i];
-                        if (list_empty(old_head))
+                        if (list_is_empty(old_head))
                                 list_inithead(&new_list[i]);
                         else {
                                 new_list[i].next = old_head->next;
@@ -311,8 +311,6 @@ v3d_bo_last_unreference_locked_timed(struct v3d_bo *bo, time_t time)
         bo->free_time = time;
         list_addtail(&bo->size_list, &cache->size_list[page_index]);
         list_addtail(&bo->time_list, &cache->time_list);
-        cache->bo_count++;
-        cache->bo_size += bo->size;
         if (dump_stats) {
                 fprintf(stderr, "Freed %s %dkb to cache:\n",
                         bo->name, bo->size / 1024);
@@ -325,7 +323,6 @@ v3d_bo_last_unreference_locked_timed(struct v3d_bo *bo, time_t time)
 
 static struct v3d_bo *
 v3d_bo_open_handle(struct v3d_screen *screen,
-                   uint32_t winsys_stride,
                    uint32_t handle, uint32_t size)
 {
         struct v3d_bo *bo;
@@ -349,8 +346,7 @@ v3d_bo_open_handle(struct v3d_screen *screen,
         bo->private = false;
 
 #ifdef USE_V3D_SIMULATOR
-        v3d_simulator_open_from_handle(screen->fd, winsys_stride,
-                                       bo->handle, bo->size);
+        v3d_simulator_open_from_handle(screen->fd, bo->handle, bo->size);
         bo->map = malloc(bo->size);
 #endif
 
@@ -363,12 +359,16 @@ v3d_bo_open_handle(struct v3d_screen *screen,
                         strerror(errno));
                 free(bo->map);
                 free(bo);
-                return NULL;
+                bo = NULL;
+                goto done;
         }
         bo->offset = get.offset;
         assert(bo->offset != 0);
 
-        util_hash_table_set(screen->bo_handles, (void *)(uintptr_t)handle, bo);
+        _mesa_hash_table_insert(screen->bo_handles, (void *)(uintptr_t)handle, bo);
+
+        screen->bo_count++;
+        screen->bo_size += bo->size;
 
 done:
         mtx_unlock(&screen->bo_handles_mutex);
@@ -376,8 +376,7 @@ done:
 }
 
 struct v3d_bo *
-v3d_bo_open_name(struct v3d_screen *screen, uint32_t name,
-                 uint32_t winsys_stride)
+v3d_bo_open_name(struct v3d_screen *screen, uint32_t name)
 {
         struct drm_gem_open o = {
                 .name = name
@@ -389,11 +388,11 @@ v3d_bo_open_name(struct v3d_screen *screen, uint32_t name,
                 return NULL;
         }
 
-        return v3d_bo_open_handle(screen, winsys_stride, o.handle, o.size);
+        return v3d_bo_open_handle(screen, o.handle, o.size);
 }
 
 struct v3d_bo *
-v3d_bo_open_dmabuf(struct v3d_screen *screen, int fd, uint32_t winsys_stride)
+v3d_bo_open_dmabuf(struct v3d_screen *screen, int fd)
 {
         uint32_t handle;
         int ret = drmPrimeFDToHandle(screen->fd, fd, &handle);
@@ -410,7 +409,7 @@ v3d_bo_open_dmabuf(struct v3d_screen *screen, int fd, uint32_t winsys_stride)
                 return NULL;
         }
 
-        return v3d_bo_open_handle(screen, winsys_stride, handle, size);
+        return v3d_bo_open_handle(screen, handle, size);
 }
 
 int
@@ -427,7 +426,7 @@ v3d_bo_get_dmabuf(struct v3d_bo *bo)
 
         mtx_lock(&bo->screen->bo_handles_mutex);
         bo->private = false;
-        util_hash_table_set(bo->screen->bo_handles, (void *)(uintptr_t)bo->handle, bo);
+        _mesa_hash_table_insert(bo->screen->bo_handles, (void *)(uintptr_t)bo->handle, bo);
         mtx_unlock(&bo->screen->bo_handles_mutex);
 
         return fd;