4 posts tagged with "documentation"

This week, the Leios team focused on improving simulation capabilities, enhancing transaction processing, and expanding the test coverage. The team also made significant progress in addressing transaction inclusion rates and developing a comprehensive conformance testing framework.

Simulation improvements​

Rust simulation​

• Investigated and addressed poor transaction inclusion rates
• Implemented 'late IB inclusion' extension to Full Leios, significantly improving transaction ledger inclusion odds
• Identified and addressed issues with non-sharded input transactions causing excessive duplication
• Made several key enhancements:
  • Enabled late IB inclusion by default
  • Fixed the off-by-one error in late IB inclusion logic
  • Added praos-fallback-enabled setting for throughput investigation
  • Improved transaction deduplication in Praos blocks.

Testing framework​

Conformance testing​

• Developed a comprehensive catalog of potential conformance tests
• Implemented a property-based testing suite for trace verification
• Added both positive and negative test cases covering:
  • Genesis slot operations
  • Block production (RB, IB, EB)
  • Vote generation
  • Various production patterns (sporadic, noisy)
  • Invalid scenarios (equivocation, gaps)
• Successfully verified golden traces against the Agda specification.

Documentation​

Formal specification​

• Launched comprehensive web-based documentation for the Ouroboros Leios formal specification at leios.cardano-scaling.org/formal-spec
• Enhanced documentation features:
  • Interactive exploration of Leios modules
  • Type linking between related components
  • Full text search capabilities
  • Improved accessibility of formal specification details.

Transaction lifecycle analysis​

• Conducted detailed analysis of transaction processing efficiency
• Generated a cumulative probability model for transaction ledger inclusion
• Analyzed the relationship between IB production rate and stage length
• Created visualization of transaction-to-block inclusion probabilities.

Next steps​

• Continue monitoring and optimizing transaction inclusion rates
• Expand conformance test coverage as the Agda specification evolves
• Further investigate transaction sharding strategies
• Refine transaction lifecycle model based on simulation results.

This week, the team made significant progress on simulation improvements, trace verification, and a comprehensive analysis of Leios' transaction processing capacity.

Trace verification​

• Improved the trace verifier with better error handling and reporting
• Added support for starting verification from non-initial states
• Created manually curated test cases for the Leios trace verifier
  • Valid traces
  • Invalid traces
• Integrated the trace verifier into Nix infrastructure and CI builds
• Removed deterministic conformance testing in favor of a trace-based approach.

Simulation improvements​

Haskell simulation​

• Conducted an informal review assessing code quality, design, and implementation
• Analyzed the simulation organization and identified areas for future improvement
• Found that most prospective changes to the Leios protocol would only involve a small fraction of the codebase
• Determined that adding memory pool and transactions would take approximately 100-200 hours of labor.

The review of the Haskell simulator was documented in detail in PR#353, covering its statistics, organization, code quality, design, implementation, and documentation aspects.

Rust simulation​

• Added tx-start-time and tx-stop-time parameters to avoid effects of slow starts or sudden terminations on transaction analysis
• Created a new Leios variant full-without-ibs where endorser blocks directly reference transactions.

Documentation and analysis​

• Relocated the original Leios report to avoid confusion, while preserving valuable background information
• Added partially-drafted technical reports on Haskell simulations to Nix and CI builds:
  • Ouroboros Leios network specification
  • Ouroboros Leios simulation: building confidence in the performance results.

The team ran higher excess-capacity simulations to test hypotheses about transaction inclusion. The transaction lifecycle simulations raised the question of whether duplicated transactions in IBs were preventing other transactions from ever being included. The team ran simulations with IBs produced at three times the normal rate to test this, providing ample space for transaction duplication.

Detailed analysis showed that transaction loss persisted despite increased capacity, indicating that other factors are preventing transactions from reaching the ledger. The results are documented in:

• Analysis overview
• Results at 1x IB capacity
• Results at 3x IB capacity.

This week, the Leios team made significant progress in protocol documentation, simulation improvements, and transaction lifecycle analysis. The team completed a draft of the Leios CIP, enhanced simulation visualization capabilities, and conducted detailed analysis of transaction processing times in Full Leios.

Simulation and analysis​

• Completed simulation of 270 Full Leios scenarios at tag leios-2025w17
• Resolved all outstanding discrepancies between Rust and Haskell simulation results
• Conducted detailed transaction lifecycle analysis:
  • Average IB inclusion time: 2.4 seconds
  • Average EB referencing time: 27.6 seconds
  • Average RB referencing time: 67.2 seconds
  • Identified issues with transaction referencing and duplication in current Full Leios implementation.

Protocol documentation​

• Drafted major sections of the Leios CIP using standard CIP template
• Documented evidence-based arguments for Leios necessity and viability
• Pending completion of Full Leios protocol sections due to ongoing discussions.

Rust implementation​

• Publicly hosted visualization as part of the Leios documentation
• Added new "transactions" view showing transaction state graphs over time
• Fixed stability issues in long-running simulations
• Implemented leios-late-ib-inclusion extension for referencing older pipeline IBs.

Plutus benchmarking​

• Documented workflow for benchmarking Plutus
• Prepared methodology for potential experiments with increased Plutus execution budgets
• Established framework for relating Plutus execution units to CPU time measurements.

Next steps​

• Address transaction referencing and duplication issues in Full Leios
• Complete remaining Full Leios protocol sections in CIP
• Investigate higher transaction rates after resolution of #305
• Continue monitoring and optimizing transaction lifecycle performance.

This week in Leios development, the team focused on simulation analysis, formal methods, and documentation updates. Key accomplishments include in-depth analysis of simulations at tag leios-2025w10, advancements in formal methods through a working trace verifier, and the development of technical reports.

Cross-simulation analysis​

• Completed a comprehensive analysis of simulations at tag leios-2025w10:
  • Analyzed Haskell simulation performance with and without CPU usage considerations
  • Varying key protocol parameters:
    • IB production rate
    • IB size
    • Length of Leios stages
  • Identified the following aspects of Leios:
    • Delay between IB generation and receipt at nodes
    • Peak and mean CPU usage over time
    • Breakdown of CPU usage by task type
    • Sizes of IBs, EBs, and RBs
    • Duplicate IB references in EBs
    • Reference to EBs from RBs
    • Resource utilization in network traffic.

Protocol and formal methods​

• Began developing a trace verifier in Agda:
  • Implemented event trace parsing using the Haskell module leios-trace-hs.

Documentation and research​

• Completed the full draft of the Leios technical report #1
• Created a skeletal draft of the Leios CIP
• Aligned with the latest CIP template
• Developed a detailed simulation analysis for the 100-node Leios network.

Programming and testing​

• Resolved several simulation issues:
  • #235: RB size does not reflect the presence of a certificate
  • #234: Fast transmission of large blocks at moderate IB rate
  • #232: Monotonicity of EB inclusion in RBs
  • #230: EBs are not large enough to include their IBs
  • #229: Rust simulations panics from overflow
• Enabled the visualization of network traffic and logging messages for multiple predefined 'scenarios' instead of a single hard-coded trace
• Updated the visualization to display resource utilization in network traffic.

Rust simulation visualization​

• Improved visualization capabilities:
  • Added support for multiple predefined 'scenarios' instead of single hard-coded trace
  • Moved the visualization logic to the client-side web worker for better performance
  • Added the visualization of per-node network traffic breakdown by message type
• Fixed critical simulation bugs:
  • Resolved issue #229 causing time travel and crashes in high-traffic high-latency scenarios.