panfrost: Identify layer_stride

[mesa.git] / src / panfrost / pandecode / common.c

diff --git a/src/panfrost/pandecode/common.c b/src/panfrost/pandecode/common.c
index 0cefdb899576541bc5f6cf242042406e492a55b8..65890e44955a11ec2d80574a0f33ffe2aec90a7c 100644 (file)
--- a/src/panfrost/pandecode/common.c
+++ b/src/panfrost/pandecode/common.c
@@ -31,49 +31,66 @@
 
 #include "decode.h"
 #include "util/macros.h"
+#include "util/u_debug.h"
+#include "util/hash_table.h"
 
 /* Memory handling */
 
-static struct pandecode_mapped_memory mmaps;
+static struct hash_table_u64 *mmap_table;
 
 struct pandecode_mapped_memory *
-pandecode_find_mapped_gpu_mem_containing(mali_ptr addr)
+pandecode_find_mapped_gpu_mem_containing(uint64_t addr)
 {
-        list_for_each_entry(struct pandecode_mapped_memory, pos, &mmaps.node, node) {
-                if (addr >= pos->gpu_va && addr < pos->gpu_va + pos->length)
-                        return pos;
-        }
+        return _mesa_hash_table_u64_search(mmap_table, addr & ~(4096 - 1));
+}
 
-        return NULL;
+static void
+pandecode_add_name(struct pandecode_mapped_memory *mem, uint64_t gpu_va, const char *name)
+{
+        if (!name) {
+                /* If we don't have a name, assign one */
+
+                snprintf(mem->name, ARRAY_SIZE(mem->name) - 1,
+                         "memory_%" PRIx64, gpu_va);
+        } else {
+                assert((strlen(name) + 1) < ARRAY_SIZE(mem->name));
+                memcpy(mem->name, name, strlen(name) + 1);
+        }
 }
 
 void
-pandecode_inject_mmap(mali_ptr gpu_va, void *cpu, unsigned sz, const char *name)
+pandecode_inject_mmap(uint64_t gpu_va, void *cpu, unsigned sz, const char *name)
 {
+        /* First, search if we already mapped this and are just updating an address */
+
+        struct pandecode_mapped_memory *existing =
+                pandecode_find_mapped_gpu_mem_containing(gpu_va);
+
+        if (existing && existing->gpu_va == gpu_va) {
+                existing->length = sz;
+                existing->addr = cpu;
+                pandecode_add_name(existing, gpu_va, name);
+                return;
+        }
+
+        /* Otherwise, add a fresh mapping */
         struct pandecode_mapped_memory *mapped_mem = NULL;
 
         mapped_mem = malloc(sizeof(*mapped_mem));
-        list_inithead(&mapped_mem->node);
-
         mapped_mem->gpu_va = gpu_va;
         mapped_mem->length = sz;
         mapped_mem->addr = cpu;
+        pandecode_add_name(mapped_mem, gpu_va, name);
 
-        if (!name) {
-                /* If we don't have a name, assign one */
-
-                snprintf(mapped_mem->name, ARRAY_SIZE(mapped_mem->name) - 1,
-                         "memory_%" PRIx64, gpu_va);
-        } else {
-                assert(strlen(name) < ARRAY_SIZE(mapped_mem->name));
-                memcpy(mapped_mem->name, name, strlen(name));
-        }
+        /* Add it to the table */
+        assert((gpu_va & 4095) == 0);
 
-        list_add(&mapped_mem->node, &mmaps.node);
+        for (unsigned i = 0; i < sz; i += 4096)
+                _mesa_hash_table_u64_insert(mmap_table, gpu_va + i, mapped_mem);
 }
 
 char *
-pointer_as_memory_reference(mali_ptr ptr)
+pointer_as_memory_reference(uint64_t ptr)
 {
         struct pandecode_mapped_memory *mapped;
         char *out = malloc(128);
@@ -89,14 +106,64 @@ pointer_as_memory_reference(mali_ptr ptr)
 
         /* Just use the raw address if other options are exhausted */
 
-        snprintf(out, 128, MALI_PTR_FMT, ptr);
+        snprintf(out, 128, "0x%" PRIx64, ptr);
         return out;
 
 }
 
+static int pandecode_dump_frame_count = 0;
+
+static void
+pandecode_dump_file_open(bool force_stderr)
+{
+        if (pandecode_dump_stream)
+                return;
+
+        /* This does a getenv every frame, so it is possible to use
+         * setenv to change the base at runtime.
+         */
+        const char *dump_file_base = debug_get_option("PANDECODE_DUMP_FILE", "pandecode.dump");
+        if (force_stderr || !strcmp(dump_file_base, "stderr"))
+                pandecode_dump_stream = stderr;
+        else {
+                char buffer[1024];
+                snprintf(buffer, sizeof(buffer), "%s.%04d", dump_file_base, pandecode_dump_frame_count);
+                printf("pandecode: dump command stream to file %s\n", buffer);
+                pandecode_dump_stream = fopen(buffer, "w");
+                if (!pandecode_dump_stream)
+                        fprintf(stderr,
+                                "pandecode: failed to open command stream log file %s\n",
+                                buffer);
+        }
+}
+
+static void
+pandecode_dump_file_close(void)
+{
+        if (pandecode_dump_stream && pandecode_dump_stream != stderr) {
+                fclose(pandecode_dump_stream);
+                pandecode_dump_stream = NULL;
+        }
+}
+
 void
-pandecode_initialize(void)
+pandecode_initialize(bool to_stderr)
 {
-        list_inithead(&mmaps.node);
+        mmap_table = _mesa_hash_table_u64_create(NULL);
+        pandecode_dump_file_open(to_stderr);
+}
 
+void
+pandecode_next_frame(void)
+{
+        pandecode_dump_file_close();
+        pandecode_dump_frame_count++;
+        pandecode_dump_file_open(false);
+}
+
+void
+pandecode_close(void)
+{
+        _mesa_hash_table_u64_destroy(mmap_table, NULL);
+        pandecode_dump_file_close();
 }