[WIP] Perf: construct & reuse clusters in output thread

src/buffer/out/AttrRow.cpp

@@ -120,6 +120,11 @@ size_t ATTR_ROW::GetNumberOfRuns() const noexcept
     return _list.size();
 }
 
+TextAttributeRun ATTR_ROW::GetRunByIndex(size_t index) const
+{
+    return _list.at(index);
+}
+
 // Routine Description:
 // - This routine finds the nth attribute in this ATTR_ROW.
 // Arguments:

src/buffer/out/AttrRow.hpp

@@ -37,6 +37,7 @@ class ATTR_ROW final
                                   size_t* const pApplies) const;
 
     size_t GetNumberOfRuns() const noexcept;
+    TextAttributeRun GetRunByIndex(size_t index) const;
 
     size_t FindAttrIndex(const size_t index,
                          size_t* const pApplies) const;

src/buffer/out/Row.cpp

@@ -23,6 +23,7 @@ ROW::ROW(const SHORT rowId, const short rowWidth, const TextAttribute fillAttrib
     _attrRow{ gsl::narrow<UINT>(rowWidth), fillAttribute },
     _pParent{ pParent }
 {
+    RefreshClusters(rowWidth);
 }
 
 size_t ROW::size() const noexcept
@@ -69,6 +70,8 @@ void ROW::SetId(const SHORT id) noexcept
 bool ROW::Reset(const TextAttribute Attr)
 {
     _charRow.Reset();
+    RefreshClusters(_rowWidth);
+
     try
     {
         _attrRow.Reset(Attr);
@@ -90,6 +93,8 @@ bool ROW::Reset(const TextAttribute Attr)
 [[nodiscard]] HRESULT ROW::Resize(const size_t width)
 {
     RETURN_IF_FAILED(_charRow.Resize(width));
+    RefreshClusters(width);
+
     try
     {
         _attrRow.Resize(width);
@@ -98,6 +103,7 @@ bool ROW::Reset(const TextAttribute Attr)
 
     _rowWidth = width;
 
+
     return S_OK;
 }
 
@@ -122,6 +128,11 @@ std::wstring ROW::GetText() const
     return _charRow.GetText();
 }
 
+std::vector<Microsoft::Console::Render::Cluster> ROW::GetClusters() const
+{
+    return _clusters;
+}
+
 RowCellIterator ROW::AsCellIter(const size_t startIndex) const
 {
     return AsCellIter(startIndex, size() - startIndex);
@@ -157,6 +168,8 @@ OutputCellIterator ROW::WriteCells(OutputCellIterator it, const size_t index, co
     THROW_HR_IF(E_INVALIDARG, limitRight.value_or(0) >= _charRow.size());
     size_t currentIndex = index;
 
+    size_t clusterIndex = index;
+
     // If we're given a right-side column limit, use it. Otherwise, the write limit is the final column index available in the char row.
     const auto finalColumnInRow = limitRight.value_or(_charRow.size() - 1);
 
@@ -199,6 +212,19 @@ OutputCellIterator ROW::WriteCells(OutputCellIterator it, const size_t index, co
             {
                 _charRow.DbcsAttrAt(currentIndex) = it->DbcsAttr();
                 _charRow.GlyphAt(currentIndex) = it->Chars();
+
+                if (it->DbcsAttr().IsDbcs())
+                {
+                    if (it->DbcsAttr().IsLeading())
+                    {
+                        _clusters.at(clusterIndex).SetColumns(0);
+                    }
+                    if (it->DbcsAttr().IsTrailing())
+                    {
+                        _clusters.at(clusterIndex).SetColumns(2);
+                    }
+                }
+
                 ++it;
             }
 
@@ -220,7 +246,30 @@ OutputCellIterator ROW::WriteCells(OutputCellIterator it, const size_t index, co
 
         // Move to the next cell for the next time through the loop.
         ++currentIndex;
+        ++clusterIndex;
     }
 
     return it;
 }
+
+void ROW::RefreshClusters(const size_t width)
+{
+    _clusters.clear();
+
+    for (size_t i = 0; i < width; ++i)
+    {
+        _clusters.emplace_back(_charRow.GlyphAt(i), _charRow.GlyphAt(i).operator std::basic_string_view<wchar_t>().size());
+        const auto dbcsAttr = _charRow.DbcsAttrAt(i);
+        if (dbcsAttr.IsDbcs())
+        {
+            if (dbcsAttr.IsLeading())
+            {
+                _clusters.at(i).SetColumns(0);
+            }
+            if (dbcsAttr.IsTrailing())
+            {
+                _clusters.at(i).SetColumns(2);
+            }
+        }
+    }
+}

src/buffer/out/Row.hpp

@@ -27,6 +27,8 @@ Revision History:
 #include "RowCellIterator.hpp"
 #include "UnicodeStorage.hpp"
 
+#include "../renderer/inc/Cluster.hpp"
+
 class TextBuffer;
 
 class ROW final
@@ -50,6 +52,7 @@ class ROW final
 
     void ClearColumn(const size_t column);
     std::wstring GetText() const;
+    std::vector<Microsoft::Console::Render::Cluster> GetClusters() const;
 
     RowCellIterator AsCellIter(const size_t startIndex) const;
     RowCellIterator AsCellIter(const size_t startIndex, const size_t count) const;
@@ -66,8 +69,12 @@ class ROW final
 #endif
 
 private:
+
+    void RefreshClusters(const size_t width);
+
     CharRow _charRow;
     ATTR_ROW _attrRow;
+    std::vector<Microsoft::Console::Render::Cluster> _clusters;
     SHORT _id;
     size_t _rowWidth;
     TextBuffer* _pParent; // non ownership pointer

src/buffer/out/textBuffer.cpp

@@ -791,8 +791,7 @@ void TextBuffer::Reset()
 
     for (auto& row : _storage)
     {
-        row.GetCharRow().Reset();
-        row.GetAttrRow().Reset(attr);
+        row.Reset(attr);
     }
 }
 

src/renderer/base/Cluster.cpp

@@ -9,6 +9,12 @@
 
 using namespace Microsoft::Console::Render;
 
+Cluster::Cluster() :
+    _text(L" "),
+    _columns(1)
+{
+}
+
 // Routine Description:
 // - Instantiates a new cluster structure
 // Arguments:
@@ -59,3 +65,21 @@ const size_t Cluster::GetColumns() const noexcept
 {
     return _columns;
 }
+
+Cluster::Cluster(const Cluster& other)
+{
+    _text = other.GetText();
+    _columns = other.GetColumns();
+} 
+
+Cluster& Cluster::operator=(const Cluster& other)
+{
+    _text = other.GetText();
+    _columns = other.GetColumns();
+    return *this;
+}
+
+void Cluster::SetColumns(size_t column)
+{
+    _columns = column;
+}

src/renderer/base/renderer.cpp

@@ -582,11 +582,11 @@ void Renderer::_PaintBufferOutput(_In_ IRenderEngine* const pEngine)
             // This means that we need 14,27 out of the backing buffer to fill in the 1,1 cell of the screen.
             const auto screenLine = Viewport::Offset(bufferLine, -view.Origin());
 
-            // Retrieve the cell information iterator limited to just this line we want to redraw.
-            auto it = buffer.GetCellDataAt(bufferLine.Origin(), bufferLine);
+            //auto it = buffer.GetCellDataAt(bufferLine.Origin(), bufferLine);
+            //_PaintBufferOutputHelper(pEngine, it, screenLine.Origin());
 
-            // Ask the helper to paint through this specific line.
-            _PaintBufferOutputHelper(pEngine, it, screenLine.Origin());
+            const auto& rowData = buffer.GetRowByOffset(row);
+            _PaintBufferLineOutputHelper(pEngine, rowData, screenLine.Origin());
         }
     }
 }
@@ -664,6 +664,71 @@ void Renderer::_PaintBufferOutputHelper(_In_ IRenderEngine* const pEngine,
     }
 }
 
+void Renderer::_PaintBufferLineOutputHelper(_In_ IRenderEngine* const pEngine,
+                                            const ROW& row,
+                                            const COORD target)
+{
+    size_t cols = 0;
+    const ATTR_ROW& attrRow = row.GetAttrRow();
+    const std::vector<Cluster> rowClusters = row.GetClusters();
+
+    const size_t runCount = attrRow.GetNumberOfRuns();
+    size_t runIndex = 0;
+    // And hold the point where we should start drawing.
+    auto screenPoint = target;
+
+    size_t runStart = 0;
+    // This outer loop will continue until we reach the end of the text we are trying to draw.
+    while (runIndex < runCount)
+    {
+        const TextAttributeRun run = attrRow.GetRunByIndex(runIndex);
+        const TextAttribute attr = run.GetAttributes();
+        const size_t runLength = run.GetLength();
+
+        const auto currentRunColor = attr;
+
+        // Update the drawing brushes with our color.
+        THROW_IF_FAILED(_UpdateDrawingBrushes(pEngine, currentRunColor, false));
+
+        // Advance the point by however many columns we've just outputted and reset the accumulator.
+        screenPoint.X += gsl::narrow<SHORT>(cols);
+        cols = 0;
+
+        size_t count = 0;
+        std::vector<Cluster> clusters;
+        clusters.reserve(runLength);
+        for (auto it = rowClusters.cbegin() + runStart;
+           cols < runLength && it != rowClusters.cend(); ++it)
+        {
+            auto cluster = (*it);
+            const auto columnCount = cluster.GetColumns();
+            cols += columnCount;
+            count++;
+
+            if (cluster.GetColumns() <= 0)
+            {
+                continue;
+            }
+
+            clusters.emplace_back(cluster);
+        }
+
+        // Do the painting.
+        // TODO: Calculate when trim left should be TRUE
+        THROW_IF_FAILED(pEngine->PaintBufferLine({ clusters.data(), clusters.size() }, screenPoint, false));
+
+        // If we're allowed to do grid drawing, draw that now too (since it will be coupled with the color data)
+        if (_pData->IsGridLineDrawingAllowed())
+        {
+            // We're only allowed to draw the grid lines under certain circumstances.
+           _PaintBufferOutputGridLineHelper(pEngine, currentRunColor, cols, screenPoint);
+        }
+
+        runStart += count;
+        ++runIndex;
+    }
+}
+
 // Method Description:
 // - Generates a IRenderEngine::GridLines structure from the values in the
 //      provided textAttribute

src/renderer/base/renderer.hpp

@@ -98,6 +98,10 @@ namespace Microsoft::Console::Render
                                       TextBufferCellIterator it,
                                       const COORD target);
 
+        void _PaintBufferLineOutputHelper(_In_ IRenderEngine* const pEngine,
+                                          const ROW& row,
+                                          const COORD target);
+
         static IRenderEngine::GridLines s_GetGridlines(const TextAttribute& textAttribute) noexcept;
 
         void _PaintBufferOutputGridLineHelper(_In_ IRenderEngine* const pEngine,

src/renderer/inc/Cluster.hpp

@@ -21,6 +21,8 @@ namespace Microsoft::Console::Render
     class Cluster
     {
     public:
+        Cluster();
+
         Cluster(const std::wstring_view text, const size_t columns);
 
         const wchar_t GetTextAsSingle() const noexcept;
@@ -29,11 +31,17 @@ namespace Microsoft::Console::Render
 
         const size_t GetColumns() const noexcept;
 
+        Cluster(const Cluster&);
+
+        Cluster& operator=(const Cluster&);
+
+        void SetColumns(size_t column);
+
     private:
         // This is the UTF-16 string of characters that form a particular drawing cluster
-        const std::wstring_view _text;
+        std::wstring_view _text;
 
         // This is how many columns we're expecting this cluster to take in the display grid
-        const size_t _columns;
+        size_t _columns;
     };
 }