---
# Add description/tips for each metric in this section.
# So it could be shown in hover.
Metric Description:

# Define the panel properties and properties of each metric in the panel.
Panel Config:
  id: 1600
  title: Vector L1 Data Cache
  data source:
    - metric_table:
        id: 1601
        title: Speed-of-Light
        header:
          metric: Metric
          value: Avg
          unit: Unit
          tips: Tips
        metric:
          Hit rate:
            value: AVG(((100 - ((100 * (((TCP_TCC_READ_REQ_sum + TCP_TCC_WRITE_REQ_sum)
              + TCP_TCC_ATOMIC_WITH_RET_REQ_sum) + TCP_TCC_ATOMIC_WITHOUT_RET_REQ_sum))
              / TCP_TOTAL_CACHE_ACCESSES_sum)) if (TCP_TOTAL_CACHE_ACCESSES_sum != 0) else
              None))
            unit: Pct of Peak
            tips:
          Bandwidth:
            value: ((100 * AVG(((TCP_TOTAL_CACHE_ACCESSES_sum * 128) / (End_Timestamp - Start_Timestamp))))
              / ((($max_sclk / 1000) * 128) * $cu_per_gpu))
            unit: Pct of Peak
            tips:
          Utilization:
            value: AVG((((TCP_GATE_EN2_sum * 100) / TCP_GATE_EN1_sum) if (TCP_GATE_EN1_sum
              != 0) else None))
            unit: Pct of Peak
            tips:
          Coalescing:
            value: AVG(((((TA_TOTAL_WAVEFRONTS_sum * 64) * 100) / (TCP_TOTAL_ACCESSES_sum
              * 4)) if (TCP_TOTAL_ACCESSES_sum != 0) else None))
            unit: Pct of Peak
            tips:
        comparable: false # for now
        cli_style: simple_bar

    - metric_table:
        id: 1602
        title: L1D Cache Stalls (%)
        header:
          metric: Metric
          expr: Expression
          tips: Tips
        metric:
          Stalled on L2 Data:
            expr:
              (((100 * TCP_PENDING_STALL_CYCLES_sum) / TCP_GATE_EN1_sum) if (TCP_GATE_EN1_sum
              != 0) else None)
            tips:
          Stalled on L2 Req:
            expr:
              (((100 * TCP_TCR_TCP_STALL_CYCLES_sum) / TCP_GATE_EN1_sum) if (TCP_GATE_EN1_sum
              != 0) else None)
            tips:
          Stalled on Address:
            expr:
              (((100 * TCP_TCP_TA_ADDR_STALL_CYCLES_sum) / TCP_GATE_EN1_sum) if (TCP_GATE_EN1_sum
              != 0) else None)
            tips:
          Stalled on Data:
            expr:
              (((100 * TCP_TCP_TA_DATA_STALL_CYCLES_sum) / TCP_GATE_EN1_sum) if (TCP_GATE_EN1_sum
              != 0) else None)
            tips:
          Stalled on Latency FIFO:
            expr:
              (((100 * TCP_LFIFO_STALL_CYCLES_sum) / TCP_GATE_EN1_sum) if (TCP_GATE_EN1_sum
              != 0) else None)
            tips:
          Stalled on Request FIFO:
            expr:
              (((100 * TCP_RFIFO_STALL_CYCLES_sum) / TCP_GATE_EN1_sum) if (TCP_GATE_EN1_sum
              != 0) else None)
            tips:
          Stalled on Read Return:
            expr:
              (((100 * TCP_TCR_RDRET_STALL_sum) / TCP_GATE_EN1_sum) if (TCP_GATE_EN1_sum
              != 0) else None)
            tips:
          Tag RAM Stall (Read):
            expr:
              (((100 * TCP_READ_TAGCONFLICT_STALL_CYCLES_sum) / TCP_GATE_EN1_sum)
              if (TCP_GATE_EN1_sum != 0) else None)
            tips:
          Tag RAM Stall (Write):
            expr:
              (((100 * TCP_WRITE_TAGCONFLICT_STALL_CYCLES_sum) / TCP_GATE_EN1_sum)
              if (TCP_GATE_EN1_sum != 0) else None)
            tips:
          Tag RAM Stall (Atomic):
            expr:
              (((100 * TCP_ATOMIC_TAGCONFLICT_STALL_CYCLES_sum) / TCP_GATE_EN1_sum)
              if (TCP_GATE_EN1_sum != 0) else None)
            tips:
        cli_style: simple_box

    - metric_table:
        id: 1603
        title: L1D Cache Accesses
        header:
          metric: Metric
          avg: Avg
          min: Min
          max: Max
          unit: Unit
          tips: Tips
        metric:
          Total Req:
            avg: AVG((TCP_TOTAL_ACCESSES_sum / $denom))
            min: MIN((TCP_TOTAL_ACCESSES_sum / $denom))
            max: MAX((TCP_TOTAL_ACCESSES_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          Read Req:
            avg: AVG((TCP_TOTAL_READ_sum / $denom))
            min: MIN((TCP_TOTAL_READ_sum / $denom))
            max: MAX((TCP_TOTAL_READ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          Write Req:
            avg: AVG((TCP_TOTAL_WRITE_sum / $denom))
            min: MIN((TCP_TOTAL_WRITE_sum / $denom))
            max: MAX((TCP_TOTAL_WRITE_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          Atomic Req:
            avg: AVG(((TCP_TOTAL_ATOMIC_WITH_RET_sum + TCP_TOTAL_ATOMIC_WITHOUT_RET_sum)
              / $denom))
            min: MIN(((TCP_TOTAL_ATOMIC_WITH_RET_sum + TCP_TOTAL_ATOMIC_WITHOUT_RET_sum)
              / $denom))
            max: MAX(((TCP_TOTAL_ATOMIC_WITH_RET_sum + TCP_TOTAL_ATOMIC_WITHOUT_RET_sum)
              / $denom))
            unit: (Req  + $normUnit)
            tips:
          Cache BW:
            avg: AVG(((TCP_TOTAL_CACHE_ACCESSES_sum * 128) / $denom))
            min: MIN(((TCP_TOTAL_CACHE_ACCESSES_sum * 128) / $denom))
            max: MAX(((TCP_TOTAL_CACHE_ACCESSES_sum * 128) / $denom))
            unit: (Bytes + $normUnit)
            tips:
          Cache Hit Rate:
            avg: AVG(((100 - ((100 * (((TCP_TCC_READ_REQ_sum + TCP_TCC_WRITE_REQ_sum) +
              TCP_TCC_ATOMIC_WITH_RET_REQ_sum) + TCP_TCC_ATOMIC_WITHOUT_RET_REQ_sum)) /
              TCP_TOTAL_CACHE_ACCESSES_sum)) if (TCP_TOTAL_CACHE_ACCESSES_sum != 0) else
               None))
            min: MIN(((100 - ((100 * (((TCP_TCC_READ_REQ_sum + TCP_TCC_WRITE_REQ_sum) +
              TCP_TCC_ATOMIC_WITH_RET_REQ_sum) + TCP_TCC_ATOMIC_WITHOUT_RET_REQ_sum)) /
              TCP_TOTAL_CACHE_ACCESSES_sum)) if (TCP_TOTAL_CACHE_ACCESSES_sum != 0) else
               None))
            max: MAX(((100 - ((100 * (((TCP_TCC_READ_REQ_sum + TCP_TCC_WRITE_REQ_sum) +
              TCP_TCC_ATOMIC_WITH_RET_REQ_sum) + TCP_TCC_ATOMIC_WITHOUT_RET_REQ_sum)) /
              TCP_TOTAL_CACHE_ACCESSES_sum)) if (TCP_TOTAL_CACHE_ACCESSES_sum != 0) else
               None))
            unit: pct
            tips:
          Cache Accesses:
            avg: AVG((TCP_TOTAL_CACHE_ACCESSES_sum / $denom))
            min: MIN((TCP_TOTAL_CACHE_ACCESSES_sum / $denom))
            max: MAX((TCP_TOTAL_CACHE_ACCESSES_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          Cache Hits:
            avg: AVG(((TCP_TOTAL_CACHE_ACCESSES_sum - (((TCP_TCC_READ_REQ_sum + TCP_TCC_WRITE_REQ_sum)
              + TCP_TCC_ATOMIC_WITH_RET_REQ_sum) + TCP_TCC_ATOMIC_WITHOUT_RET_REQ_sum))
              / $denom))
            min: MIN(((TCP_TOTAL_CACHE_ACCESSES_sum - (((TCP_TCC_READ_REQ_sum + TCP_TCC_WRITE_REQ_sum)
              + TCP_TCC_ATOMIC_WITH_RET_REQ_sum) + TCP_TCC_ATOMIC_WITHOUT_RET_REQ_sum))
              / $denom))
            max: MAX(((TCP_TOTAL_CACHE_ACCESSES_sum - (((TCP_TCC_READ_REQ_sum + TCP_TCC_WRITE_REQ_sum)
              + TCP_TCC_ATOMIC_WITH_RET_REQ_sum) + TCP_TCC_ATOMIC_WITHOUT_RET_REQ_sum))
              / $denom))
            unit: (Req  + $normUnit)
            tips:
          Invalidations:
            avg: AVG((TCP_TOTAL_WRITEBACK_INVALIDATES_sum / $denom))
            min: MIN((TCP_TOTAL_WRITEBACK_INVALIDATES_sum / $denom))
            max: MAX((TCP_TOTAL_WRITEBACK_INVALIDATES_sum / $denom))
            unit: (Req + $normUnit)
            tips:
          L1-L2 BW:
            avg: AVG(((128 * TCP_TCC_READ_REQ_sum + 64 *
                      (TCP_TCC_WRITE_REQ_sum + TCP_TCC_ATOMIC_WITH_RET_REQ_sum +
                        TCP_TCC_ATOMIC_WITHOUT_RET_REQ_sum)) / $denom))
            min: MIN(((128 * TCP_TCC_READ_REQ_sum + 64 *
                      (TCP_TCC_WRITE_REQ_sum + TCP_TCC_ATOMIC_WITH_RET_REQ_sum +
                        TCP_TCC_ATOMIC_WITHOUT_RET_REQ_sum)) / $denom))
            max: MAX(((128 * TCP_TCC_READ_REQ_sum + 64 *
                      (TCP_TCC_WRITE_REQ_sum + TCP_TCC_ATOMIC_WITH_RET_REQ_sum +
                        TCP_TCC_ATOMIC_WITHOUT_RET_REQ_sum)) / $denom))
            unit: (Bytes + $normUnit)
            tips:
          Tag RAM 0 Req:
            avg: AVG((TCP_TAGRAM0_REQ_sum / $denom))
            min: MIN((TCP_TAGRAM0_REQ_sum / $denom))
            max: MAX((TCP_TAGRAM0_REQ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          Tag RAM 1 Req:
            avg: AVG((TCP_TAGRAM1_REQ_sum / $denom))
            min: MIN((TCP_TAGRAM1_REQ_sum / $denom))
            max: MAX((TCP_TAGRAM1_REQ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          Tag RAM 2 Req:
            avg: AVG((TCP_TAGRAM2_REQ_sum / $denom))
            min: MIN((TCP_TAGRAM2_REQ_sum / $denom))
            max: MAX((TCP_TAGRAM2_REQ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          Tag RAM 3 Req:
            avg: AVG((TCP_TAGRAM3_REQ_sum / $denom))
            min: MIN((TCP_TAGRAM3_REQ_sum / $denom))
            max: MAX((TCP_TAGRAM3_REQ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          L1-L2 Read:
            avg: AVG((TCP_TCC_READ_REQ_sum / $denom))
            min: MIN((TCP_TCC_READ_REQ_sum / $denom))
            max: MAX((TCP_TCC_READ_REQ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          L1-L2 Write:
            avg: AVG((TCP_TCC_WRITE_REQ_sum / $denom))
            min: MIN((TCP_TCC_WRITE_REQ_sum / $denom))
            max: MAX((TCP_TCC_WRITE_REQ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          L1-L2 Atomic:
            avg: AVG(((TCP_TCC_ATOMIC_WITH_RET_REQ_sum + TCP_TCC_ATOMIC_WITHOUT_RET_REQ_sum)
              / $denom))
            min: MIN(((TCP_TCC_ATOMIC_WITH_RET_REQ_sum + TCP_TCC_ATOMIC_WITHOUT_RET_REQ_sum)
              / $denom))
            max: MAX(((TCP_TCC_ATOMIC_WITH_RET_REQ_sum + TCP_TCC_ATOMIC_WITHOUT_RET_REQ_sum)
              / $denom))
            unit: (Req  + $normUnit)
            tips:
          L1 Access Latency:
            avg: AVG((TCP_TCP_LATENCY_sum / $denom))
            min: MIN((TCP_TCP_LATENCY_sum / $denom))
            max: MAX((TCP_TCP_LATENCY_sum / $denom))
            unit: (Cycles  + $normUnit)
            tips:
          L1-L2 Read Latency:
            avg: AVG((TCP_TCC_READ_REQ_LATENCY_sum / $denom))
            min: MIN((TCP_TCC_READ_REQ_LATENCY_sum / $denom))
            max: MAX((TCP_TCC_READ_REQ_LATENCY_sum / $denom))
            unit: (Cycles  + $normUnit)
            tips:
          L1-L2 Write Latency:
            avg: AVG((TCP_TCC_WRITE_REQ_LATENCY_sum / $denom))
            min: MIN((TCP_TCC_WRITE_REQ_LATENCY_sum / $denom))
            max: MAX((TCP_TCC_WRITE_REQ_LATENCY_sum / $denom))
            unit: (Cycles  + $normUnit)
            tips:

    - metric_table:
        id: 1604
        title: L1D - L2 Transactions
        header:
          metric: Metric
          xfer: Xfer
          coherency: Coherency
          avg: Avg
          min: Min
          max: Max
          unit: Unit
          tips: Tips
        metric:
          NC - Read:
            xfer: Read
            coherency: NC
            avg: AVG((TCP_TCC_NC_READ_REQ_sum / $denom))
            min: MIN((TCP_TCC_NC_READ_REQ_sum / $denom))
            max: MAX((TCP_TCC_NC_READ_REQ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          UC - Read:
            xfer: Read
            coherency: UC
            avg: AVG((TCP_TCC_UC_READ_REQ_sum / $denom))
            min: MIN((TCP_TCC_UC_READ_REQ_sum / $denom))
            max: MAX((TCP_TCC_UC_READ_REQ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          CC - Read:
            xfer: Read
            coherency: CC
            avg: AVG((TCP_TCC_CC_READ_REQ_sum / $denom))
            min: MIN((TCP_TCC_CC_READ_REQ_sum / $denom))
            max: MAX((TCP_TCC_CC_READ_REQ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          RW - Read:
            xfer: Read
            coherency: RW
            avg: AVG((TCP_TCC_RW_READ_REQ_sum / $denom))
            min: MIN((TCP_TCC_RW_READ_REQ_sum / $denom))
            max: MAX((TCP_TCC_RW_READ_REQ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          RW - Write:
            xfer: Write
            coherency: RW
            avg: AVG((TCP_TCC_RW_WRITE_REQ_sum / $denom))
            min: MIN((TCP_TCC_RW_WRITE_REQ_sum / $denom))
            max: MAX((TCP_TCC_RW_WRITE_REQ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          NC - Write:
            xfer: Write
            coherency: NC
            avg: AVG((TCP_TCC_NC_WRITE_REQ_sum / $denom))
            min: MIN((TCP_TCC_NC_WRITE_REQ_sum / $denom))
            max: MAX((TCP_TCC_NC_WRITE_REQ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          UC - Write:
            xfer: Write
            coherency: UC
            avg: AVG((TCP_TCC_UC_WRITE_REQ_sum / $denom))
            min: MIN((TCP_TCC_UC_WRITE_REQ_sum / $denom))
            max: MAX((TCP_TCC_UC_WRITE_REQ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          CC - Write:
            xfer: Write
            coherency: CC
            avg: AVG((TCP_TCC_CC_WRITE_REQ_sum / $denom))
            min: MIN((TCP_TCC_CC_WRITE_REQ_sum / $denom))
            max: MAX((TCP_TCC_CC_WRITE_REQ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          NC - Atomic:
            xfer: Atomic
            coherency: NC
            avg: AVG((TCP_TCC_NC_ATOMIC_REQ_sum / $denom))
            min: MIN((TCP_TCC_NC_ATOMIC_REQ_sum / $denom))
            max: MAX((TCP_TCC_NC_ATOMIC_REQ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          UC - Atomic:
            xfer: Atomic
            coherency: UC
            avg: AVG((TCP_TCC_UC_ATOMIC_REQ_sum / $denom))
            min: MIN((TCP_TCC_UC_ATOMIC_REQ_sum / $denom))
            max: MAX((TCP_TCC_UC_ATOMIC_REQ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          CC - Atomic:
            xfer: Atomic
            coherency: CC
            avg: AVG((TCP_TCC_CC_ATOMIC_REQ_sum / $denom))
            min: MIN((TCP_TCC_CC_ATOMIC_REQ_sum / $denom))
            max: MAX((TCP_TCC_CC_ATOMIC_REQ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:
          RW - Atomic:
            xfer: Atomic
            coherency: RW
            avg: AVG((TCP_TCC_RW_ATOMIC_REQ_sum / $denom))
            min: MIN((TCP_TCC_RW_ATOMIC_REQ_sum / $denom))
            max: MAX((TCP_TCC_RW_ATOMIC_REQ_sum / $denom))
            unit: (Req  + $normUnit)
            tips:

    - metric_table:
        id: 1605
        title: L1D Addr Translation
        header:
          metric: Metric
          avg: Avg
          min: Min
          max: Max
          units: Units
          tips: Tips
        metric:
          Req:
            avg: AVG((TCP_UTCL1_REQUEST_sum / $denom))
            min: MIN((TCP_UTCL1_REQUEST_sum / $denom))
            max: MAX((TCP_UTCL1_REQUEST_sum / $denom))
            units: (Req + $normUnit)
            tips:
          Inflight Req:
            avg: AVG((TCP_CLIENT_UTCL1_INFLIGHT_sum / $denom))
            min: MIN((TCP_CLIENT_UTCL1_INFLIGHT_sum / $denom))
            max: MAX((TCP_CLIENT_UTCL1_INFLIGHT_sum / $denom))
            units: (Req + $normUnit)
            tips:
          Hit Ratio:
            avg: AVG((((100 * TCP_UTCL1_TRANSLATION_HIT_sum) / TCP_UTCL1_REQUEST_sum) if
              (TCP_UTCL1_REQUEST_sum != 0) else None))
            min: MIN((((100 * TCP_UTCL1_TRANSLATION_HIT_sum) / TCP_UTCL1_REQUEST_sum) if
              (TCP_UTCL1_REQUEST_sum != 0) else None))
            max: MAX((((100 * TCP_UTCL1_TRANSLATION_HIT_sum) / TCP_UTCL1_REQUEST_sum) if
              (TCP_UTCL1_REQUEST_sum != 0) else None))
            units: pct
            tips:
          Hits:
            avg: AVG((TCP_UTCL1_TRANSLATION_HIT_sum / $denom))
            min: MIN((TCP_UTCL1_TRANSLATION_HIT_sum / $denom))
            max: MAX((TCP_UTCL1_TRANSLATION_HIT_sum / $denom))
            units: (Req + $normUnit)
            tips:
          Translation Misses:
            avg: AVG((TCP_UTCL1_TRANSLATION_MISS_sum / $denom))
            min: MIN((TCP_UTCL1_TRANSLATION_MISS_sum / $denom))
            max: MAX((TCP_UTCL1_TRANSLATION_MISS_sum / $denom))
            units: (Req + $normUnit)
            tips:
          Misses under Translation Miss:
            avg: AVG((TCP_UTCL1_TRANSLATION_MISS_UNDER_MISS_sum / $denom))
            min: MIN((TCP_UTCL1_TRANSLATION_MISS_UNDER_MISS_sum / $denom))
            max: MAX((TCP_UTCL1_TRANSLATION_MISS_UNDER_MISS_sum / $denom))
            units: (Req + $normUnit)
            tips:
          Permission Misses:
            avg: AVG((TCP_UTCL1_PERMISSION_MISS_sum / $denom))
            min: MIN((TCP_UTCL1_PERMISSION_MISS_sum / $denom))
            max: MAX((TCP_UTCL1_PERMISSION_MISS_sum / $denom))
            units: (Req + $normUnit)
            tips:
    - metric_table:
        id: 1606
        title: L1D Addr Translation Stalls
        header:
          metric: Metric
          avg: Avg
          min: Min
          max: Max
          units: Units
          tips: Tips
        metric:
          Cache Full Stall:
            avg: AVG((TCP_UTCL1_STALL_INFLIGHT_MAX_sum / $denom))
            min: MIN((TCP_UTCL1_STALL_INFLIGHT_MAX_sum / $denom))
            max: MAX((TCP_UTCL1_STALL_INFLIGHT_MAX_sum / $denom))
            units: (Cycles + $normUnit)
            tips:
          Cache Miss Stall:
            avg: AVG((TCP_UTCL1_STALL_MULTI_MISS_sum / $denom))
            min: MIN((TCP_UTCL1_STALL_MULTI_MISS_sum / $denom))
            max: MAX((TCP_UTCL1_STALL_MULTI_MISS_sum / $denom))
            units: (Cycles + $normUnit)
            tips:
          Serialization Stall:
            avg: AVG((TCP_UTCL1_SERIALIZATION_STALL_sum / $denom))
            min: MIN((TCP_UTCL1_SERIALIZATION_STALL_sum / $denom))
            max: MAX((TCP_UTCL1_SERIALIZATION_STALL_sum / $denom))
            units: (Cycles + $normUnit)
            tips:
          Thrashing Stall:
            avg: AVG((TCP_UTCL1_THRASHING_STALL_sum / $denom))
            min: MIN((TCP_UTCL1_THRASHING_STALL_sum / $denom))
            max: MAX((TCP_UTCL1_THRASHING_STALL_sum / $denom))
            units: (Cycles + $normUnit)
            tips:
          Latency FIFO Stall:
            avg: AVG((TCP_UTCL1_LFIFO_FULL_sum / $denom))
            min: MIN((TCP_UTCL1_LFIFO_FULL_sum / $denom))
            max: MAX((TCP_UTCL1_LFIFO_FULL_sum / $denom))
            units: (Cycles + $normUnit)
            tips:
          Resident Page Full Stall:
            avg: AVG((TCP_UTCL1_STALL_LFIFO_NO_RES_sum / $denom))
            min: MIN((TCP_UTCL1_STALL_LFIFO_NO_RES_sum / $denom))
            max: MAX((TCP_UTCL1_STALL_LFIFO_NO_RES_sum / $denom))
            units: (Cycles + $normUnit)
            tips:
          UTCL2 Stall:
            avg: AVG((TCP_UTCL1_STALL_UTCL2_REQ_OUT_OF_CREDITS_sum / $denom))
            min: MIN((TCP_UTCL1_STALL_UTCL2_REQ_OUT_OF_CREDITS_sum / $denom))
            max: MAX((TCP_UTCL1_STALL_UTCL2_REQ_OUT_OF_CREDITS_sum / $denom))
            units: (Cycles + $normUnit)
            tips:
