Terminal.Gui/ALLOCATION_DOCS_README.md

Heap Allocation Investigation - Document Guide

This directory contains comprehensive documentation of the heap allocation analysis performed on Terminal.Gui in response to reported performance issues with intermediate allocations.

Quick Start

If you want to...

• 📊 Understand the problem quickly → Read ALLOCATION_INVESTIGATION_SUMMARY.md
• 🔍 See detailed technical analysis → Read HEAP_ALLOCATION_ANALYSIS.md
• 🛠️ Implement the fixes → Read OPTIMIZATION_RECOMMENDATIONS.md
• 📈 Understand call flows → Read ALLOCATION_CALL_FLOW.md

Document Overview

1. ALLOCATION_INVESTIGATION_SUMMARY.md

Type: Executive Summary
Audience: Project maintainers, decision makers
Length: ~10 pages

Contents:

• TL;DR with key findings
• Critical allocation hotspots (2 main issues)
• Real-world impact quantification
• Risk assessment
• Recommended next steps
• Decision point for maintainers

Read this if: You need to understand the issue quickly and decide on next steps

---

2. HEAP_ALLOCATION_ANALYSIS.md

Type: Technical Analysis
Audience: Developers, performance engineers
Length: ~15 pages

Contents:

• Complete list of 9 allocation hotspots with line numbers
• Root cause analysis for each issue
• Detailed performance impact estimates
• Memory allocation type breakdown
• GC impact analysis
• Comparison to v2_develop branch

Read this if: You need complete technical details and want to understand why allocations happen

---

3. ALLOCATION_CALL_FLOW.md

Type: Call Flow Analysis
Audience: Developers working on fixes
Length: ~12 pages

Contents:

• Detailed call stacks from user action to allocation
• Frequency analysis per scenario
• Allocation size calculations
• GC trigger estimations
• Code examples showing allocation points
• Measurement tool recommendations

Read this if: You're implementing fixes and need to understand the execution path

---

4. OPTIMIZATION_RECOMMENDATIONS.md

Type: Implementation Roadmap
Audience: Developers implementing solutions
Length: ~18 pages

Contents:

• Prioritized fix list (P0, P1, P2, P3)
• Concrete code solutions with examples
• 4-phase implementation roadmap (2-3 weeks)
• Testing strategy and benchmarks
• Success metrics and validation approach
• Breaking change considerations
• Risk assessment per change

Read this if: You're ready to implement optimizations and need detailed guidance

---

Reading Order Recommendations

For Decision Makers

1. ALLOCATION_INVESTIGATION_SUMMARY.md (complete)
2. OPTIMIZATION_RECOMMENDATIONS.md (section: Priority Ranking)

Time: 15-20 minutes
Goal: Understand issue and approve work

For Developers Implementing Fixes

1. ALLOCATION_INVESTIGATION_SUMMARY.md (complete)
2. HEAP_ALLOCATION_ANALYSIS.md (sections: Critical Allocation Hotspots, Root Cause)
3. OPTIMIZATION_RECOMMENDATIONS.md (complete)
4. ALLOCATION_CALL_FLOW.md (as reference during implementation)

Time: 1-2 hours
Goal: Full understanding before coding

For Performance Engineers

1. HEAP_ALLOCATION_ANALYSIS.md (complete)
2. ALLOCATION_CALL_FLOW.md (complete)
3. OPTIMIZATION_RECOMMENDATIONS.md (sections: Testing Strategy, Monitoring)

Time: 2-3 hours
Goal: Deep understanding for optimization and benchmarking

For Code Reviewers

1. ALLOCATION_INVESTIGATION_SUMMARY.md (complete)
2. OPTIMIZATION_RECOMMENDATIONS.md (sections: Implementation Roadmap, Risk Assessment)
3. HEAP_ALLOCATION_ANALYSIS.md (as reference for context)

Time: 30-45 minutes
Goal: Understand changes being reviewed

---

Key Findings at a Glance

🔴 Critical Issues (P0)

1. LineCanvas.GetMap() - Terminal.Gui/Drawing/LineCanvas/LineCanvas.cs:219-222

   • Per-pixel array allocation in nested loop
   • Impact: 1,920+ allocations per border redraw
   • Fix: Apply existing GetCellMap() pattern
   • Effort: 4-8 hours

2. TextFormatter.Draw() - Terminal.Gui/Text/TextFormatter.cs:126

   • Array allocation on every draw call
   • Impact: 10-60+ allocations per second
   • Fix: Use ArrayPool
   • Effort: 1-2 days

📊 Performance Impact

Current State:

• Progress bar demo: 3,000-5,000 allocations/second
• Gen0 GC: Every 5-10 seconds
• Result: Visible frame drops

After Fixes:

• Allocations: 50-100/second (98% reduction)
• Gen0 GC: Every 80-160 seconds (16× improvement)
• Result: Smooth performance

✅ Solution Confidence: HIGH

• Proven patterns (GetCellMap already works)
• Standard .NET tools (ArrayPool, Span)
• Low implementation risk
• Clear testing strategy

---

Investigation Methodology

This analysis was conducted through:

1. Static Code Analysis

   • Searched for .ToArray() and .ToList() patterns
   • Identified allocation sites with line numbers
   • Traced call stacks to understand frequency

2. Frequency Analysis

   • Examined Progress demo code (100ms update interval)
   • Analyzed ProgressBar.Fraction property (calls SetNeedsDraw)
   • Counted allocations per update cycle

3. Memory Impact Calculation

   • Estimated allocation sizes per operation
   • Calculated allocations per second for scenarios
   • Projected GC behavior based on allocation rate

4. Solution Research

   • Found existing optimizations (GetCellMap)
   • Identified proven patterns (ArrayPool usage)
   • Validated approach feasibility

5. Documentation

   • Created comprehensive analysis documents
   • Provided actionable recommendations
   • Included code examples and roadmap

---

Next Steps

Immediate Actions (This Week)

1. Review documents with team
2. Approve Phase 1 work if agreed
3. Assign developer for LineCanvas.GetMap() fix
4. Set up benchmarks to measure current state

Short Term (Next 2 Weeks)

1. Implement P0 fixes (LineCanvas + TextFormatter)
2. Validate improvements with benchmarks
3. Run Progress demo profiling

Medium Term (Next Month)

1. Complete optimization roadmap (all P1-P3 items)
2. Add comprehensive tests
3. Update performance documentation

---

Questions or Feedback

For technical questions about the analysis:

• Review the specific document section
• Check OPTIMIZATION_RECOMMENDATIONS.md for code examples
• Consult ALLOCATION_CALL_FLOW.md for execution details

For implementation questions:

• Start with OPTIMIZATION_RECOMMENDATIONS.md
• Reference code examples provided
• Review existing GetCellMap() implementation as template

For performance measurement:

• See ALLOCATION_CALL_FLOW.md (Measurement Tools section)
• See OPTIMIZATION_RECOMMENDATIONS.md (Testing Strategy section)
• Benchmark infrastructure already exists in Tests/Benchmarks

---

Related Files in Repository

Source Code:

• Terminal.Gui/Text/TextFormatter.cs - Main text rendering
• Terminal.Gui/Drawing/LineCanvas/LineCanvas.cs - Border/line rendering
• Terminal.Gui/Drawing/GraphemeHelper.cs - Text element enumeration
• Terminal.Gui/Drawing/Cell.cs - Cell validation

Tests:

• Tests/Benchmarks/Text/TextFormatter/ - Existing benchmarks
• Tests/UnitTests/ - Unit test infrastructure
• Tests/UnitTestsParallelizable/ - Parallel test infrastructure

Examples:

• Examples/UICatalog/Scenarios/Progress.cs - Progress demo (mentioned in issue)

---

Document Maintenance

These documents were created on December 3, 2025 as part of investigating the intermediate heap allocation issue.

Status: Investigation Complete ✅

Action Required: Decision on implementing optimizations

Owner: Awaiting assignment based on maintainer decision

---

Summary

Four comprehensive documents totaling ~55 pages provide:

• Complete problem analysis
• Quantified performance impact
• Concrete solutions with code examples
• Implementation roadmap with timeline
• Testing and validation strategy

The issue is confirmed, significant, and solvable. Documentation provides everything needed to proceed with confidence.

---

Document Navigation:

• ← Back to Root
• Executive Summary →
• Technical Analysis →
• Call Flow Analysis →
• Implementation Guide →