tor-browser

OverlayWidgets.cpp (30948B)

---

//
// Copyright 2019 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// OverlayWidgets.cpp:
//    Implements functions that interpret widget data.  Data formats and limits correspond to the
//    Vulkan implementation (as the only implementation).  They are generic enough so other backends
//    could respect them too, if they implement the overlay.
//

#include "libANGLE/Overlay.h"
#include "libANGLE/Overlay_font_autogen.h"

#include <functional>

namespace gl
{
namespace
{
// Internally, every widget is either Text or Graph.
enum class WidgetInternalType
{
   Text,
   Graph,

   InvalidEnum,
   EnumCount = InvalidEnum,
};

// A map that says how the API-facing widget types map to internal types.
constexpr angle::PackedEnumMap<WidgetType, WidgetInternalType> kWidgetTypeToInternalMap = {
   {WidgetType::Count, WidgetInternalType::Text},
   {WidgetType::Text, WidgetInternalType::Text},
   {WidgetType::PerSecond, WidgetInternalType::Text},
   {WidgetType::RunningGraph, WidgetInternalType::Graph},
   {WidgetType::RunningHistogram, WidgetInternalType::Graph},
};

// Structures and limits matching uniform buffers in vulkan/shaders/src/OverlayDraw.comp.  The size
// of text and graph widgets is chosen such that they could fit in uniform buffers with minimum
// required Vulkan size.
constexpr size_t kMaxRenderableTextWidgets  = 32;
constexpr size_t kMaxRenderableGraphWidgets = 32;
constexpr size_t kMaxTextLength             = 256;
constexpr size_t kMaxGraphDataSize          = 256;

constexpr angle::PackedEnumMap<WidgetInternalType, size_t> kWidgetInternalTypeMaxWidgets = {
   {WidgetInternalType::Text, kMaxRenderableTextWidgets},
   {WidgetInternalType::Graph, kMaxRenderableGraphWidgets},
};

ANGLE_ENABLE_STRUCT_PADDING_WARNINGS

// Structure matching buffer in vulkan/shaders/src/OverlayCull.comp.
struct WidgetCoordinates
{
   uint32_t coordinates[kMaxRenderableTextWidgets + kMaxRenderableGraphWidgets][4];
};

// Structures matching buffers in vulkan/shaders/src/OverlayDraw.comp.
struct TextWidgetData
{
   uint32_t coordinates[4];
   float color[4];
   uint32_t fontSize[3];
   uint32_t padding;
   uint8_t text[kMaxTextLength];
};

struct GraphWidgetData
{
   uint32_t coordinates[4];
   float color[4];
   uint32_t valueWidth;
   uint32_t padding[3];
   uint32_t values[kMaxGraphDataSize];
};

struct TextWidgets
{
   TextWidgetData widgets[kMaxRenderableTextWidgets];
};

struct GraphWidgets
{
   GraphWidgetData widgets[kMaxRenderableGraphWidgets];
};

ANGLE_DISABLE_STRUCT_PADDING_WARNINGS

uint32_t GetWidgetCoord(int32_t src, uint32_t extent)
{
   int32_t dst = src < 0 ? extent + src : src;

   return std::min<uint32_t>(std::max(dst, 0), extent - 1);
}

void GetWidgetCoordinates(const int32_t srcCoords[4],
                         const gl::Extents &imageExtent,
                         uint32_t dstCoordsOut[4])
{
   dstCoordsOut[0] = GetWidgetCoord(srcCoords[0], imageExtent.width);
   dstCoordsOut[1] = GetWidgetCoord(srcCoords[1], imageExtent.height);
   dstCoordsOut[2] = GetWidgetCoord(srcCoords[2], imageExtent.width);
   dstCoordsOut[3] = GetWidgetCoord(srcCoords[3], imageExtent.height);
}

void GetWidgetColor(const float srcColor[4], float dstColor[4])
{
   memcpy(dstColor, srcColor, 4 * sizeof(dstColor[0]));
}

void GetTextFontSize(int srcFontSize, uint32_t dstFontSize[3])
{
   // .xy contains the font glyph width/height
   dstFontSize[0] = overlay::kFontGlyphWidth >> srcFontSize;
   dstFontSize[1] = overlay::kFontGlyphHeight >> srcFontSize;
   // .z contains the mip
   dstFontSize[2] = srcFontSize;
}

void GetGraphValueWidth(const int32_t srcCoords[4], size_t valueCount, uint32_t *dstValueWidth)
{
   const int32_t graphWidth = std::abs(srcCoords[2] - srcCoords[0]);

   // If valueCount doesn't divide graphWidth, the graph bars won't fit well in its frame.
   // Fix initOverlayWidgets() in that case.
   ASSERT(graphWidth % valueCount == 0);

   *dstValueWidth = graphWidth / valueCount;
}

void GetTextString(const std::string &src, uint8_t textOut[kMaxTextLength])
{
   for (size_t i = 0; i < src.length() && i < kMaxTextLength; ++i)
   {
       // The font image has 95 ASCII characters starting from ' '.
       textOut[i] = src[i] - ' ';
   }
}

void GetGraphValues(const std::vector<uint64_t> srcValues,
                   size_t startIndex,
                   float scale,
                   uint32_t valuesOut[kMaxGraphDataSize])
{
   ASSERT(srcValues.size() <= kMaxGraphDataSize);

   for (size_t i = 0; i < srcValues.size(); ++i)
   {
       size_t index = (startIndex + i) % srcValues.size();
       valuesOut[i] = static_cast<uint32_t>(srcValues[index] * scale);
   }
}

std::vector<uint64_t> CreateHistogram(const std::vector<uint64_t> values)
{
   std::vector<uint64_t> histogram(values.size(), 0);

   for (uint64_t rank : values)
   {
       ++histogram[static_cast<size_t>(rank)];
   }

   return histogram;
}

using OverlayWidgetCounts  = angle::PackedEnumMap<WidgetInternalType, uint32_t>;
using AppendWidgetDataFunc = void (*)(const overlay::Widget *widget,
                                     const gl::Extents &imageExtent,
                                     TextWidgetData *textWidget,
                                     GraphWidgetData *graphWidget,
                                     OverlayWidgetCounts *widgetCounts);
}  // namespace

namespace overlay_impl
{
#define ANGLE_DECLARE_APPEND_WIDGET_PROC(WIDGET_ID)                                              \
   static void Append##WIDGET_ID(const overlay::Widget *widget, const gl::Extents &imageExtent, \
                                 TextWidgetData *textWidget, GraphWidgetData *graphWidget,      \
                                 OverlayWidgetCounts *widgetCounts);

// This class interprets the generic data collected in every element into a human-understandable
// widget.  This often means generating text specific to this item and scaling graph data to
// something sensible.
class AppendWidgetDataHelper
{
 public:
   ANGLE_WIDGET_ID_X(ANGLE_DECLARE_APPEND_WIDGET_PROC)

 private:
   static std::ostream &OutputPerSecond(std::ostream &out, const overlay::PerSecond *perSecond);

   static std::ostream &OutputText(std::ostream &out, const overlay::Text *text);

   static std::ostream &OutputCount(std::ostream &out, const overlay::Count *count);

   static void AppendTextCommon(const overlay::Widget *widget,
                                const gl::Extents &imageExtent,
                                const std::string &text,
                                TextWidgetData *textWidget,
                                OverlayWidgetCounts *widgetCounts);

   using FormatGraphTitleFunc = std::function<std::string(uint64_t curValue, uint64_t maxValue)>;
   static void AppendRunningGraphCommon(const overlay::Widget *widget,
                                        const gl::Extents &imageExtent,
                                        TextWidgetData *textWidget,
                                        GraphWidgetData *graphWidget,
                                        OverlayWidgetCounts *widgetCounts,
                                        FormatGraphTitleFunc formatFunc);

   using FormatHistogramTitleFunc =
       std::function<std::string(size_t peakRange, size_t maxValueRange, size_t numRanges)>;
   static void AppendRunningHistogramCommon(const overlay::Widget *widget,
                                            const gl::Extents &imageExtent,
                                            TextWidgetData *textWidget,
                                            GraphWidgetData *graphWidget,
                                            OverlayWidgetCounts *widgetCounts,
                                            FormatHistogramTitleFunc formatFunc);

   static void AppendGraphCommon(const overlay::Widget *widget,
                                 const gl::Extents &imageExtent,
                                 const std::vector<uint64_t> runningValues,
                                 size_t startIndex,
                                 float scale,
                                 GraphWidgetData *graphWidget,
                                 OverlayWidgetCounts *widgetCounts);
};

void AppendWidgetDataHelper::AppendTextCommon(const overlay::Widget *widget,
                                             const gl::Extents &imageExtent,
                                             const std::string &text,
                                             TextWidgetData *textWidget,
                                             OverlayWidgetCounts *widgetCounts)
{
   GetWidgetCoordinates(widget->coords, imageExtent, textWidget->coordinates);
   GetWidgetColor(widget->color, textWidget->color);
   GetTextFontSize(widget->fontSize, textWidget->fontSize);
   GetTextString(text, textWidget->text);

   ++(*widgetCounts)[WidgetInternalType::Text];
}

void AppendWidgetDataHelper::AppendGraphCommon(const overlay::Widget *widget,
                                              const gl::Extents &imageExtent,
                                              const std::vector<uint64_t> runningValues,
                                              size_t startIndex,
                                              float scale,
                                              GraphWidgetData *graphWidget,
                                              OverlayWidgetCounts *widgetCounts)
{
   const overlay::RunningGraph *widgetAsGraph = static_cast<const overlay::RunningGraph *>(widget);

   GetWidgetCoordinates(widget->coords, imageExtent, graphWidget->coordinates);
   GetWidgetColor(widget->color, graphWidget->color);
   GetGraphValueWidth(widget->coords, widgetAsGraph->runningValues.size(),
                      &graphWidget->valueWidth);
   GetGraphValues(runningValues, startIndex, scale, graphWidget->values);

   ++(*widgetCounts)[WidgetInternalType::Graph];
}

void AppendWidgetDataHelper::AppendRunningGraphCommon(
   const overlay::Widget *widget,
   const gl::Extents &imageExtent,
   TextWidgetData *textWidget,
   GraphWidgetData *graphWidget,
   OverlayWidgetCounts *widgetCounts,
   AppendWidgetDataHelper::FormatGraphTitleFunc formatFunc)
{
   const overlay::RunningGraph *graph   = static_cast<const overlay::RunningGraph *>(widget);
   const overlay::Widget *matchToWidget = widget->matchToWidget;

   if (matchToWidget == nullptr)
   {
       matchToWidget = widget;
   }
   const overlay::RunningGraph *matchToGraph =
       static_cast<const overlay::RunningGraph *>(matchToWidget);

   const uint64_t maxValue =
       *std::max_element(graph->runningValues.begin(), graph->runningValues.end());
   const uint64_t maxValueInMatchToGraph =
       *std::max_element(matchToGraph->runningValues.begin(), matchToGraph->runningValues.end());
   const int32_t graphHeight = std::abs(widget->coords[3] - widget->coords[1]);
   const float graphScale    = static_cast<float>(graphHeight) / maxValueInMatchToGraph;

   const size_t graphSize  = graph->runningValues.size();
   const size_t currentIdx = graph->lastValueIndex - 1;

   const uint64_t curValue = graph->runningValues[(graphSize + currentIdx) % graphSize];

   AppendGraphCommon(widget, imageExtent, graph->runningValues, graph->lastValueIndex + 1,
                     graphScale, graphWidget, widgetCounts);

   if ((*widgetCounts)[WidgetInternalType::Text] <
       kWidgetInternalTypeMaxWidgets[WidgetInternalType::Text])
   {
       std::string text = formatFunc(curValue, maxValue);
       AppendTextCommon(&graph->description, imageExtent, text, textWidget, widgetCounts);
   }
}

// static
void AppendWidgetDataHelper::AppendRunningHistogramCommon(const overlay::Widget *widget,
                                                         const gl::Extents &imageExtent,
                                                         TextWidgetData *textWidget,
                                                         GraphWidgetData *graphWidget,
                                                         OverlayWidgetCounts *widgetCounts,
                                                         FormatHistogramTitleFunc formatFunc)
{
   const overlay::RunningHistogram *runningHistogram =
       static_cast<const overlay::RunningHistogram *>(widget);

   std::vector<uint64_t> histogram = CreateHistogram(runningHistogram->runningValues);
   auto peakRangeIt                = std::max_element(histogram.rbegin(), histogram.rend());
   const uint64_t peakRangeValue   = *peakRangeIt;
   const int32_t graphHeight       = std::abs(widget->coords[3] - widget->coords[1]);
   const float graphScale          = static_cast<float>(graphHeight) / peakRangeValue;
   auto maxValueIter               = std::find_if(histogram.rbegin(), histogram.rend(),
                                                  [](uint64_t value) { return value != 0; });

   AppendGraphCommon(widget, imageExtent, histogram, 0, graphScale, graphWidget, widgetCounts);

   if ((*widgetCounts)[WidgetInternalType::Text] <
       kWidgetInternalTypeMaxWidgets[WidgetInternalType::Text])
   {
       size_t peakRange     = std::distance(peakRangeIt, histogram.rend() - 1);
       size_t maxValueRange = std::distance(maxValueIter, histogram.rend() - 1);

       std::string text = formatFunc(peakRange, maxValueRange, histogram.size());
       AppendTextCommon(&runningHistogram->description, imageExtent, text, textWidget,
                        widgetCounts);
   }
}

void AppendWidgetDataHelper::AppendFPS(const overlay::Widget *widget,
                                      const gl::Extents &imageExtent,
                                      TextWidgetData *textWidget,
                                      GraphWidgetData *graphWidget,
                                      OverlayWidgetCounts *widgetCounts)
{
   const overlay::PerSecond *fps = static_cast<const overlay::PerSecond *>(widget);
   std::ostringstream text;
   text << "FPS: ";
   OutputPerSecond(text, fps);

   AppendTextCommon(widget, imageExtent, text.str(), textWidget, widgetCounts);
}

void AppendWidgetDataHelper::AppendVulkanLastValidationMessage(const overlay::Widget *widget,
                                                              const gl::Extents &imageExtent,
                                                              TextWidgetData *textWidget,
                                                              GraphWidgetData *graphWidget,
                                                              OverlayWidgetCounts *widgetCounts)
{
   const overlay::Text *lastValidationMessage = static_cast<const overlay::Text *>(widget);
   std::ostringstream text;
   text << "Last VVL Message: ";
   OutputText(text, lastValidationMessage);

   AppendTextCommon(widget, imageExtent, text.str(), textWidget, widgetCounts);
}

void AppendWidgetDataHelper::AppendVulkanValidationMessageCount(const overlay::Widget *widget,
                                                               const gl::Extents &imageExtent,
                                                               TextWidgetData *textWidget,
                                                               GraphWidgetData *graphWidget,
                                                               OverlayWidgetCounts *widgetCounts)
{
   const overlay::Count *validationMessageCount = static_cast<const overlay::Count *>(widget);
   std::ostringstream text;
   text << "VVL Message Count: ";
   OutputCount(text, validationMessageCount);

   AppendTextCommon(widget, imageExtent, text.str(), textWidget, widgetCounts);
}

void AppendWidgetDataHelper::AppendVulkanRenderPassCount(const overlay::Widget *widget,
                                                        const gl::Extents &imageExtent,
                                                        TextWidgetData *textWidget,
                                                        GraphWidgetData *graphWidget,
                                                        OverlayWidgetCounts *widgetCounts)
{
   auto format = [](uint64_t curValue, uint64_t maxValue) {
       std::ostringstream text;
       text << "RenderPass Count: " << maxValue;
       return text.str();
   };

   AppendRunningGraphCommon(widget, imageExtent, textWidget, graphWidget, widgetCounts, format);
}

void AppendWidgetDataHelper::AppendVulkanSecondaryCommandBufferPoolWaste(
   const overlay::Widget *widget,
   const gl::Extents &imageExtent,
   TextWidgetData *textWidget,
   GraphWidgetData *graphWidget,
   OverlayWidgetCounts *widgetCounts)
{
   auto format = [](size_t peakRange, size_t maxValueRange, size_t numRanges) {
       std::ostringstream text;
       size_t peakPercent = (peakRange * 100 + 50) / numRanges;
       text << "CB Pool Waste (Peak: " << peakPercent << "%)";
       return text.str();
   };

   AppendRunningHistogramCommon(widget, imageExtent, textWidget, graphWidget, widgetCounts,
                                format);
}

void AppendWidgetDataHelper::AppendVulkanRenderPassBufferCount(const overlay::Widget *widget,
                                                              const gl::Extents &imageExtent,
                                                              TextWidgetData *textWidget,
                                                              GraphWidgetData *graphWidget,
                                                              OverlayWidgetCounts *widgetCounts)
{
   auto format = [](uint64_t curValue, uint64_t maxValue) {
       std::ostringstream text;
       text << "RP VkBuffers (Max: " << maxValue << ")";
       return text.str();
   };

   AppendRunningGraphCommon(widget, imageExtent, textWidget, graphWidget, widgetCounts, format);
}

void AppendWidgetDataHelper::AppendVulkanWriteDescriptorSetCount(const overlay::Widget *widget,
                                                                const gl::Extents &imageExtent,
                                                                TextWidgetData *textWidget,
                                                                GraphWidgetData *graphWidget,
                                                                OverlayWidgetCounts *widgetCounts)
{
   auto format = [](uint64_t curValue, uint64_t maxValue) {
       std::ostringstream text;
       text << "WriteDescriptorSet Count: " << maxValue;
       return text.str();
   };

   AppendRunningGraphCommon(widget, imageExtent, textWidget, graphWidget, widgetCounts, format);
}

void AppendWidgetDataHelper::AppendVulkanDescriptorSetAllocations(const overlay::Widget *widget,
                                                                 const gl::Extents &imageExtent,
                                                                 TextWidgetData *textWidget,
                                                                 GraphWidgetData *graphWidget,
                                                                 OverlayWidgetCounts *widgetCounts)
{
   auto format = [](uint64_t curValue, uint64_t maxValue) {
       std::ostringstream text;
       text << "Descriptor Set Allocations: " << maxValue;
       return text.str();
   };

   AppendRunningGraphCommon(widget, imageExtent, textWidget, graphWidget, widgetCounts, format);
}

void AppendWidgetDataHelper::AppendVulkanShaderResourceDSHitRate(const overlay::Widget *widget,
                                                                const gl::Extents &imageExtent,
                                                                TextWidgetData *textWidget,
                                                                GraphWidgetData *graphWidget,
                                                                OverlayWidgetCounts *widgetCounts)
{
   auto format = [](uint64_t curValue, uint64_t maxValue) {
       std::ostringstream text;
       text << "Shader Resource DS Hit Rate (Max: " << maxValue << "%)";
       return text.str();
   };

   AppendRunningGraphCommon(widget, imageExtent, textWidget, graphWidget, widgetCounts, format);
}

void AppendWidgetDataHelper::AppendVulkanDynamicBufferAllocations(const overlay::Widget *widget,
                                                                 const gl::Extents &imageExtent,
                                                                 TextWidgetData *textWidget,
                                                                 GraphWidgetData *graphWidget,
                                                                 OverlayWidgetCounts *widgetCounts)
{
   auto format = [](uint64_t curValue, uint64_t maxValue) {
       std::ostringstream text;
       text << "DynamicBuffer Allocations (Max: " << maxValue << ")";
       return text.str();
   };

   AppendRunningGraphCommon(widget, imageExtent, textWidget, graphWidget, widgetCounts, format);
}

void AppendWidgetDataHelper::AppendVulkanTextureDescriptorCacheSize(
   const overlay::Widget *widget,
   const gl::Extents &imageExtent,
   TextWidgetData *textWidget,
   GraphWidgetData *graphWidget,
   OverlayWidgetCounts *widgetCounts)
{
   auto format = [](uint64_t curValue, uint64_t maxValue) {
       std::ostringstream text;
       text << "Total Texture Descriptor Cache Size: " << curValue;
       return text.str();
   };

   AppendRunningGraphCommon(widget, imageExtent, textWidget, graphWidget, widgetCounts, format);
}

void AppendWidgetDataHelper::AppendVulkanUniformDescriptorCacheSize(
   const overlay::Widget *widget,
   const gl::Extents &imageExtent,
   TextWidgetData *textWidget,
   GraphWidgetData *graphWidget,
   OverlayWidgetCounts *widgetCounts)
{
   auto format = [](uint64_t curValue, uint64_t maxValue) {
       std::ostringstream text;
       text << "Total Uniform Descriptor Cache Size: " << curValue;
       return text.str();
   };

   AppendRunningGraphCommon(widget, imageExtent, textWidget, graphWidget, widgetCounts, format);
}

void AppendWidgetDataHelper::AppendVulkanDescriptorCacheSize(const overlay::Widget *widget,
                                                            const gl::Extents &imageExtent,
                                                            TextWidgetData *textWidget,
                                                            GraphWidgetData *graphWidget,
                                                            OverlayWidgetCounts *widgetCounts)
{
   auto format = [](uint64_t curValue, uint64_t maxValue) {
       std::ostringstream text;
       text << "Total Descriptor Cache Size: " << curValue;
       return text.str();
   };

   AppendRunningGraphCommon(widget, imageExtent, textWidget, graphWidget, widgetCounts, format);
}

void AppendWidgetDataHelper::AppendVulkanDescriptorCacheKeySize(const overlay::Widget *widget,
                                                               const gl::Extents &imageExtent,
                                                               TextWidgetData *textWidget,
                                                               GraphWidgetData *graphWidget,
                                                               OverlayWidgetCounts *widgetCounts)
{
   const overlay::Count *countWidget = static_cast<const overlay::Count *>(widget);
   std::ostringstream text;
   double kb = static_cast<double>(countWidget->count) / 1000.0;
   text << "DS Cache Key Size: " << std::fixed << std::setprecision(1) << kb << " kb";

   AppendTextCommon(widget, imageExtent, text.str(), textWidget, widgetCounts);
}

void AppendWidgetDataHelper::AppendVulkanAttemptedSubmissions(const overlay::Widget *widget,
                                                             const gl::Extents &imageExtent,
                                                             TextWidgetData *textWidget,
                                                             GraphWidgetData *graphWidget,
                                                             OverlayWidgetCounts *widgetCounts)
{
   auto format = [](uint64_t curValue, uint64_t maxValue) {
       std::ostringstream text;
       text << "Attempted submissions (peak): " << maxValue;
       return text.str();
   };

   AppendRunningGraphCommon(widget, imageExtent, textWidget, graphWidget, widgetCounts, format);
}

void AppendWidgetDataHelper::AppendVulkanActualSubmissions(const overlay::Widget *widget,
                                                          const gl::Extents &imageExtent,
                                                          TextWidgetData *textWidget,
                                                          GraphWidgetData *graphWidget,
                                                          OverlayWidgetCounts *widgetCounts)
{
   auto format = [](uint64_t curValue, uint64_t maxValue) {
       std::ostringstream text;
       text << "Actual submissions (peak): " << maxValue;
       return text.str();
   };

   AppendRunningGraphCommon(widget, imageExtent, textWidget, graphWidget, widgetCounts, format);
}

void AppendWidgetDataHelper::AppendVulkanPipelineCacheLookups(const overlay::Widget *widget,
                                                             const gl::Extents &imageExtent,
                                                             TextWidgetData *textWidget,
                                                             GraphWidgetData *graphWidget,
                                                             OverlayWidgetCounts *widgetCounts)
{
   auto format = [](uint64_t curValue, uint64_t maxValue) {
       std::ostringstream text;
       text << "Pipeline Cache Lookups (peak): " << maxValue;
       return text.str();
   };

   AppendRunningGraphCommon(widget, imageExtent, textWidget, graphWidget, widgetCounts, format);
}

void AppendWidgetDataHelper::AppendVulkanPipelineCacheMisses(const overlay::Widget *widget,
                                                            const gl::Extents &imageExtent,
                                                            TextWidgetData *textWidget,
                                                            GraphWidgetData *graphWidget,
                                                            OverlayWidgetCounts *widgetCounts)
{
   auto format = [](uint64_t curValue, uint64_t maxValue) {
       std::ostringstream text;
       text << "Pipeline Cache Misses (peak): " << maxValue;
       return text.str();
   };

   AppendRunningGraphCommon(widget, imageExtent, textWidget, graphWidget, widgetCounts, format);
}

void AppendWidgetDataHelper::AppendVulkanTotalPipelineCacheHitTimeMs(
   const overlay::Widget *widget,
   const gl::Extents &imageExtent,
   TextWidgetData *textWidget,
   GraphWidgetData *graphWidget,
   OverlayWidgetCounts *widgetCounts)
{
   const overlay::Count *totalTime = static_cast<const overlay::Count *>(widget);
   std::ostringstream text;
   text << "Total Pipeline Cache Hit Time: ";
   OutputCount(text, totalTime);
   text << "ms";

   AppendTextCommon(widget, imageExtent, text.str(), textWidget, widgetCounts);
}

void AppendWidgetDataHelper::AppendVulkanTotalPipelineCacheMissTimeMs(
   const overlay::Widget *widget,
   const gl::Extents &imageExtent,
   TextWidgetData *textWidget,
   GraphWidgetData *graphWidget,
   OverlayWidgetCounts *widgetCounts)
{
   const overlay::Count *totalTime = static_cast<const overlay::Count *>(widget);
   std::ostringstream text;
   text << "Total Pipeline Cache Miss Time: ";
   OutputCount(text, totalTime);
   text << "ms";

   AppendTextCommon(widget, imageExtent, text.str(), textWidget, widgetCounts);
}

std::ostream &AppendWidgetDataHelper::OutputPerSecond(std::ostream &out,
                                                     const overlay::PerSecond *perSecond)
{
   return out << perSecond->lastPerSecondCount;
}

std::ostream &AppendWidgetDataHelper::OutputText(std::ostream &out, const overlay::Text *text)
{
   return out << text->text;
}

std::ostream &AppendWidgetDataHelper::OutputCount(std::ostream &out, const overlay::Count *count)
{
   return out << count->count;
}
}  // namespace overlay_impl

namespace
{
#define ANGLE_APPEND_WIDGET_MAP_PROC(WIDGET_ID) \
   {WidgetId::WIDGET_ID, overlay_impl::AppendWidgetDataHelper::Append##WIDGET_ID},

constexpr angle::PackedEnumMap<WidgetId, AppendWidgetDataFunc> kWidgetIdToAppendDataFuncMap = {
   ANGLE_WIDGET_ID_X(ANGLE_APPEND_WIDGET_MAP_PROC)};
}  // namespace

namespace overlay
{
const Text *Widget::getDescriptionWidget() const
{
   return nullptr;
}
RunningGraph::RunningGraph(size_t n) : runningValues(n, 0) {}
RunningGraph::~RunningGraph() = default;
const Text *RunningGraph::getDescriptionWidget() const
{
   return &description;
}
}  // namespace overlay

size_t OverlayState::getWidgetCoordinatesBufferSize() const
{
   return sizeof(WidgetCoordinates);
}

size_t OverlayState::getTextWidgetsBufferSize() const
{
   return sizeof(TextWidgets);
}

size_t OverlayState::getGraphWidgetsBufferSize() const
{
   return sizeof(GraphWidgets);
}

void OverlayState::fillWidgetData(const gl::Extents &imageExtents,
                                 uint8_t *textData,
                                 uint8_t *graphData,
                                 uint32_t *activeTextWidgetCountOut,
                                 uint32_t *activeGraphWidgetCountOut) const
{
   TextWidgets *textWidgets   = reinterpret_cast<TextWidgets *>(textData);
   GraphWidgets *graphWidgets = reinterpret_cast<GraphWidgets *>(graphData);

   memset(textWidgets, overlay::kFontCharacters, sizeof(*textWidgets));
   memset(graphWidgets, 0, sizeof(*graphWidgets));

   OverlayWidgetCounts widgetCounts = {};

   for (WidgetId id : angle::AllEnums<WidgetId>())
   {
       const std::unique_ptr<overlay::Widget> &widget = mOverlayWidgets[id];
       if (!widget->enabled)
       {
           continue;
       }

       WidgetInternalType internalType = kWidgetTypeToInternalMap[widget->type];
       ASSERT(internalType != WidgetInternalType::InvalidEnum);

       if (widgetCounts[internalType] >= kWidgetInternalTypeMaxWidgets[internalType])
       {
           continue;
       }

       AppendWidgetDataFunc appendFunc = kWidgetIdToAppendDataFuncMap[id];
       ASSERT(appendFunc);
       appendFunc(widget.get(), imageExtents,
                  &textWidgets->widgets[widgetCounts[WidgetInternalType::Text]],
                  &graphWidgets->widgets[widgetCounts[WidgetInternalType::Graph]], &widgetCounts);
   }

   *activeTextWidgetCountOut  = widgetCounts[WidgetInternalType::Text];
   *activeGraphWidgetCountOut = widgetCounts[WidgetInternalType::Graph];
}

}  // namespace gl