utils: add dma occupancy mode to viv_gpu_top

3 files changed, 253 insertions, 33 deletions

diff --git a/native/etnaviv/viv.c b/native/etnaviv/viv.c
index 9b89987..76afb8c 100644
--- a/native/etnaviv/viv.c
+++ b/native/etnaviv/viv.c
@@ -542,3 +542,23 @@ int viv_unmap_user_memory(struct viv_conn *conn, void *memory, size_t size, viv_
     return viv_invoke(conn, &id);
 }
 
+int viv_read_register(struct viv_conn *conn, uint32_t address, uint32_t *data)
+{
+    gcsHAL_INTERFACE id;
+    int rv;
+    id.command = gcvHAL_READ_REGISTER;
+    id.u.ReadRegisterData.address = address;
+    rv = viv_invoke(conn, &id);
+    *data = id.u.ReadRegisterData.data;
+    return rv;
+}
+
+int viv_write_register(struct viv_conn *conn, uint32_t address, uint32_t data)
+{
+    gcsHAL_INTERFACE id;
+    id.command = gcvHAL_WRITE_REGISTER;
+    id.u.WriteRegisterData.address = address;
+    id.u.WriteRegisterData.data = data;
+    return viv_invoke(conn, &id);
+}
+
diff --git a/native/etnaviv/viv.h b/native/etnaviv/viv.h
index 74c7b37..4d0ebd4 100644
--- a/native/etnaviv/viv.h
+++ b/native/etnaviv/viv.h
@@ -277,6 +277,18 @@ void viv_show_chip_info(struct viv_conn *conn);
  */
 int viv_reset(struct viv_conn *conn);
 
+/** Read register from GPU.
+ * @note Needs kernel module compiled with user space register access
+ * (gcdREGISTER_ACCESS_FROM_USER=1)
+ */
+int viv_read_register(struct viv_conn *conn, uint32_t address, uint32_t *data);
+
+/** Write register to GPU.
+ * @note Needs kernel module compiled with user space register access
+ * (gcdREGISTER_ACCESS_FROM_USER=1)
+ */
+int viv_write_register(struct viv_conn *conn, uint32_t address, uint32_t data);
+
 /** Convenience macro to probe features from state.xml.h:
  * VIV_FEATURE(chipFeatures, FAST_CLEAR)
  * VIV_FEATURE(chipMinorFeatures1, AUTO_DISABLE)
diff --git a/native/utils/viv_gpu_top.c b/native/utils/viv_gpu_top.c
index f62df7f..7dbb3e1 100644
--- a/native/utils/viv_gpu_top.c
+++ b/native/utils/viv_gpu_top.c
@@ -26,6 +26,8 @@
 
 #include <etnaviv/viv.h>
 #include <etnaviv/viv_profile.h>
+#include <etnaviv/state_hi.xml.h>
+#include <etnaviv/state.xml.h>
 
 static const char *bars[] = {
 	" ",
@@ -47,15 +49,18 @@ static const char color_num_max[] = "\x1b[1;37m";
 static const char color_num_zero[] = "\x1b[1;30m";
 static const char color_num[] = "\x1b[1;33m";
 static const char color_reset[] = "\x1b[0m";
+static const char color_percentage_1[] = "\x1b[38;5;154;48;5;236m";
+static const char color_percentage_2[] = "\x1b[38;5;112;48;5;236m";
+static const char color_title[] = "\x1b[38;5;249m";
 
-#define STATS_LEN (20)
-#define PERCENTAGE_BAR_END      (79 - STATS_LEN)
-
-static void print_percentage_bar(float percent, int cur_line_len)
+static void print_percentage_bar(float percent, int bar_width)
 {
-    int bar_avail_len = (PERCENTAGE_BAR_END - cur_line_len - 1) * 8;
+    int bar_avail_len = bar_width * 8;
     int bar_len = bar_avail_len * (percent + .5) / 100.0;
+    int cur_line_len = 0;
     int i;
+    if(bar_len > bar_avail_len)
+        bar_len = bar_avail_len;
 
     for (i = bar_len; i >= 8; i -= 8) {
         printf("%s", bars[8]);
@@ -68,7 +73,8 @@ static void print_percentage_bar(float percent, int cur_line_len)
 
     /* NB: We can't use a field width with utf8 so we manually
     * guarantee a field with of 45 chars for any bar. */
-    printf("%*s", PERCENTAGE_BAR_END - cur_line_len, "");
+
+    printf("%*s", bar_width - cur_line_len, "");
 }
 
 /* Get time in microseconds */
@@ -132,23 +138,13 @@ struct counter_rec
     uint64_t events_per_s;
 };
 
-/* Sort counters descending */
-static int counter_rec_compar(const void *a, const void *b)
-{
-    uint64_t ca = ((const struct counter_rec*)a)->events_per_s;
-    uint64_t cb = ((const struct counter_rec*)b)->events_per_s;
-    if(ca < cb)
-        return 1;
-    else if(cb > ca)
-        return -1;
-    else return 0;
-}
-
 enum display_mode
 {
     MODE_ALL = 0,
     MODE_MAX = 1,
-    MODE_SORTED = 2
+    MODE_SORTED = 2,
+    MODE_OCCUPANCY = 3,
+    MODE_DMA = 4
 };
 
 /* derived counters (derived information computed from existing counters) */
@@ -160,6 +156,71 @@ static struct viv_profile_counter_info derived_counter_info[] = {
     [0] = {"TOTAL_INST_COUNTER", "Total inst counter"},
 };
 
+static struct {
+    const char *name;
+    uint32_t bit;
+    bool inv; /* show inverted value */
+} idle_module_names[] = {
+    {"FE", VIVS_HI_IDLE_STATE_FE, true},
+    {"DE", VIVS_HI_IDLE_STATE_DE, true},
+    {"PE", VIVS_HI_IDLE_STATE_PE, true},
+    {"SH", VIVS_HI_IDLE_STATE_SH, true},
+    {"PA", VIVS_HI_IDLE_STATE_PA, true},
+    {"SE", VIVS_HI_IDLE_STATE_SE, true},
+    {"RA", VIVS_HI_IDLE_STATE_RA, true},
+    {"TX", VIVS_HI_IDLE_STATE_TX, true},
+    {"VG", VIVS_HI_IDLE_STATE_VG, true},
+    {"IM", VIVS_HI_IDLE_STATE_IM, true},
+    {"FP", VIVS_HI_IDLE_STATE_FP, true},
+    {"TS", VIVS_HI_IDLE_STATE_TS, true},
+    {"AXI_LP", VIVS_HI_IDLE_STATE_AXI_LP, false}
+};
+#define NUM_IDLE_MODULES (sizeof(idle_module_names)/sizeof(idle_module_names[0]))
+
+static const char* cmd_state_names[]={
+"IDLE", "DEC", "ADR0", "LOAD0", "ADR1", "LOAD1", "3DADR", "3DCMD",
+"3DCNTL", "3DIDXCNTL", "INITREQDMA", "DRAWIDX", "DRAW", "2DRECT0", "2DRECT1", "2DDATA0",
+"2DDATA1", "WAITFIFO", "WAIT", "LINK", "END", "STALL", "UNKNOWN"
+};
+#define NUM_CMD_STATE_NAMES (sizeof(cmd_state_names)/sizeof(cmd_state_names[0]))
+
+static const char* cmd_dma_state_names[]={
+    "IDLE", "START", "REQ", "END"
+};
+#define NUM_CMD_DMA_STATE_NAMES (sizeof(cmd_dma_state_names)/sizeof(cmd_dma_state_names[0]))
+
+static const char* cmd_fetch_state_names[]={
+    "IDLE", "RAMVALID", "VALID", "UNKNOWN"
+};
+#define NUM_CMD_FETCH_STATE_NAMES (sizeof(cmd_fetch_state_names)/sizeof(cmd_fetch_state_names[0]))
+
+static const char* req_dma_state_names[]={
+    "IDLE", "START", "REQ", "END"
+};
+#define NUM_REQ_DMA_STATE_NAMES (sizeof(req_dma_state_names)/sizeof(req_dma_state_names[0]))
+
+static const char* cal_state_names[]={
+    "IDLE", "LDADR", "IDXCALC", "UNKNOWN"
+};
+#define NUM_CAL_STATE_NAMES (sizeof(cal_state_names)/sizeof(cal_state_names[0]))
+
+static const char* ve_req_state_names[]={
+    "IDLE", "CKCACHE", "MISS", "UNKNOWN"
+};
+#define NUM_VE_REQ_STATE_NAMES (sizeof(ve_req_state_names)/sizeof(ve_req_state_names[0]))
+
+/* Sort counters descending */
+static int counter_rec_compar(const void *a, const void *b)
+{
+    uint64_t ca = ((const struct counter_rec*)a)->events_per_s;
+    uint64_t cb = ((const struct counter_rec*)b)->events_per_s;
+    if(ca < cb)
+        return 1;
+    else if(cb > ca)
+        return -1;
+    else return 0;
+}
+
 static struct viv_profile_counter_info *get_counter_info(uint32_t idx)
 {
     if(idx < derived_counters_base)
@@ -168,6 +229,26 @@ static struct viv_profile_counter_info *get_counter_info(uint32_t idx)
         return &derived_counter_info[idx - derived_counters_base];
 }
 
+static void print_percentage_row(int l, double percent, const char *name, int name_width, bool color, int bar_width)
+{
+    printf("%-*s ", name_width, name);
+    if(color)
+    {
+        if(percent > 99.0)
+            printf("%s", color_num_max);
+        else if(percent < 1.0)
+            printf("%s", color_num_zero);
+        else
+            printf("%s", color_num);
+    }
+    printf("%5.1f%%  ", percent);
+    if(color)
+        printf("%s%s", color_reset, (l%2) ? color_percentage_1 : color_percentage_2);
+    print_percentage_bar(percent, bar_width);
+    if(color)
+        printf("%s", color_reset);
+}
+
 int main(int argc, char **argv)
 {
     struct viv_conn *conn = 0;
@@ -197,6 +278,8 @@ int main(int argc, char **argv)
             case 'm': mode = MODE_MAX; break;
             case 'a': mode = MODE_ALL; break;
             case 's': mode = MODE_SORTED; break;
+            case 'o': mode = MODE_OCCUPANCY; break;
+            case 'd': mode = MODE_DMA; break;
             default:
                 printf("Unknown mode %s\n", optarg);
             }
@@ -230,28 +313,59 @@ int main(int argc, char **argv)
             events_per_s[c] = 0;
         }
 
+        uint32_t idle_states[NUM_IDLE_MODULES] = {};
+        uint32_t cmd_state[32] = {};
+        uint32_t cmd_dma_state[4] = {};
+        uint32_t cmd_fetch_state[4] = {};
+        uint32_t req_dma_state[4] = {};
+        uint32_t cal_state[4] = {};
+        uint32_t ve_req_state[4] = {};
         for(int sample=0; sample<samples_per_second; ++sample)
         {
-            if(viv_read_profile_counters_3d(conn, counter_data) != 0)
+            if(mode == MODE_OCCUPANCY)
             {
-                fprintf(stderr, "Error querying counters (probably unsupported with this kernel, or not built into libetnaviv)\n");
-                exit(1);
-            }
-            for(int c=0; c<num_profile_counters; ++c)
+                uint32_t data = 0;
+                viv_read_register(conn, VIVS_HI_IDLE_STATE, &data);
+                for(int mid=0; mid<NUM_IDLE_MODULES; ++mid)
+                {
+                    if(data & idle_module_names[mid].bit)
+                        idle_states[mid]++;
+                }
+            } else if(mode == MODE_DMA)
             {
-                if(!reset_after_read[c])
+                uint32_t data = 0;
+                viv_read_register(conn, VIVS_FE_DMA_DEBUG_STATE, &data);
+                int cmd_state_idx = data & 0x1F;
+                if(cmd_state_idx >= (NUM_CMD_STATE_NAMES-1)) /* Mark unknowns as UNKNOWN */
+                    cmd_state_idx = NUM_CMD_STATE_NAMES-1;
+                cmd_state[cmd_state_idx]++;
+                cmd_dma_state[(data>>8) & 3]++;
+                cmd_fetch_state[(data>>10) & 3]++;
+                req_dma_state[(data>>12) & 3]++;
+                cal_state[(data>>14) & 3]++;
+                ve_req_state[(data>>16) & 3]++;
+            } else {
+                if(viv_read_profile_counters_3d(conn, counter_data) != 0)
                 {
-                    if(counter_data_last[c] > counter_data[c])
+                    fprintf(stderr, "Error querying counters (probably unsupported with this kernel, or not built into libetnaviv)\n");
+                    exit(1);
+                }
+                for(int c=0; c<num_profile_counters; ++c)
+                {
+                    if(!reset_after_read[c])
                     {
+                        if(counter_data_last[c] > counter_data[c])
+                        {
+                            events_per_s[c] += counter_data[c];
+                        } else {
+                            events_per_s[c] += (uint32_t)(counter_data[c] - counter_data_last[c]);
+                        }
+                    } else
                         events_per_s[c] += counter_data[c];
-                    } else {
-                        events_per_s[c] += (uint32_t)(counter_data[c] - counter_data_last[c]);
-                    }
-                } else
-                    events_per_s[c] += counter_data[c];
+                }
+                for(int c=0; c<num_profile_counters; ++c)
+                    counter_data_last[c] = counter_data[c];
             }
-            for(int c=0; c<num_profile_counters; ++c)
-                counter_data_last[c] = counter_data[c];
 
             usleep(interval);
         }
@@ -349,6 +463,80 @@ int main(int argc, char **argv)
                     }
                     printf("\n");
                 }
+            } else if(mode == MODE_OCCUPANCY)
+            {
+                int lines = NUM_IDLE_MODULES;
+                if(lines > max_lines)
+                    lines = max_lines;
+
+                if(color)
+                    printf("%s", color_title);
+                printf("Module occupancy\n");
+                if(color)
+                    printf("%s", color_reset);
+                for(int l=0; l<lines; ++l)
+                {
+                    double percent = 100.0 * (double)idle_states[l] / (double)samples_per_second;
+                    if(idle_module_names[l].inv)
+                        percent = 100.0 - percent;
+                    print_percentage_row(l, percent, idle_module_names[l].name, 6, color, 40);
+                    printf("\n");
+                }
+            } else if(mode == MODE_DMA)
+            {
+                const struct dma_table {
+                    int column;
+                    int base_y;
+                    const char *title;
+                    int data_size;
+                    const char **data_names;
+                    uint32_t *data;
+                } dma_tables[] = {
+                    {0, 1, "Command state", NUM_CMD_STATE_NAMES, cmd_state_names, cmd_state},
+                    {1, 1, "Command DMA state", NUM_CMD_DMA_STATE_NAMES, cmd_dma_state_names, cmd_dma_state},
+                    {1, 7, "Command fetch state", NUM_CMD_FETCH_STATE_NAMES, cmd_fetch_state_names, cmd_fetch_state},
+                    {1, 13, "DMA request state", NUM_REQ_DMA_STATE_NAMES, req_dma_state_names, req_dma_state},
+                    {1, 19, "Cal state", NUM_CAL_STATE_NAMES, cal_state_names, cal_state},
+                    {1, 25, "VE req state", NUM_VE_REQ_STATE_NAMES, ve_req_state_names, ve_req_state}
+                };
+#define NUM_DMA_TABLES (sizeof(dma_tables) / sizeof(dma_tables[0]))
+                for(int l=0; l<max_lines; ++l)
+                {
+                    for(int column=0; column<2; ++column)
+                    {
+                        bool match = false;
+                        for(int t=0; t<NUM_DMA_TABLES; ++t) /* find table that this column,row slot is part of, if any */
+                        {
+                            const struct dma_table *table = &dma_tables[t];
+                            if(table->column == column)
+                            {
+                                if(l == table->base_y-1)
+                                {
+                                    if(color)
+                                        printf("%s", color_title);
+                                    printf("%-59s", table->title);
+                                    if(color)
+                                        printf("%s", color_reset);
+                                    match = true;
+                                    break;
+                                } else if(l >= table->base_y && l < (table->base_y + table->data_size))
+                                {
+                                    int y = l - table->base_y;
+                                    double percent = 100.0 * (double)table->data[y] / (double)samples_per_second;
+                                    print_percentage_row(y, percent, table->data_names[y], 10, color, 40);
+                                    match = true;
+                                    break;
+                                }
+                            }
+                        }
+                        if(!match) /* empty slot */
+                        {
+                            printf("%-59s", "");
+                        }
+                        printf(" ");
+                    }
+                    printf("\n");
+                }
             }
         }
         begin_time = end_time;