Create benchmark for [[likely]] performance

[konard]

🎯 Summary

This PR implements comprehensive benchmarks to evaluate the performance impact of different optimization strategies in C# that simulate C++ [[likely]] and [[unlikely]] branch prediction attributes.

📋 Issue Reference

Fixes #96

🔍 Background

Issue #96 requested benchmarks comparing performance of code with and without C++ [[likely]]/[[unlikely]] attributes. Since this is a C# codebase, I've implemented equivalent optimization strategies available in C#/.NET.

💡 Implementation Details

C# Equivalents to [[likely]]/[[unlikely]]

Added six new benchmark scenarios to test different optimization approaches:

1. AggressiveInlining: Uses [MethodImpl(MethodImplOptions.AggressiveInlining)] to force method inlining for hot paths

   • Simulates C++'s inline behavior combined with branch prediction hints

2. AggressiveOptimization: Uses [MethodImpl(MethodImplOptions.AggressiveOptimization)] to enable aggressive optimizations

   • Allows JIT compiler more freedom to optimize the hot path

3. BothOptimizations: Combines both AggressiveInlining and AggressiveOptimization

   • Maximum optimization hints for the likely path

4. DoesNotReturn + NoInlining: Separates exception throwing into a helper method marked with:

   • [DoesNotReturn] - Helps optimizer understand this path never returns
   • [MethodImpl(MethodImplOptions.NoInlining)] - Keeps exception path out of hot path
   • Simulates C++'s [[unlikely]] by isolating cold path

5. InlineException: Exception handling within the same method with optimizations

   • Tests if separation into helper method provides benefits

6. UnlikelyFirst: Anti-pattern with exception check before happy path

   • Demonstrates performance impact of poor branch ordering

7. GenericOptimized: Generic version using modern .NET generic math (IUnsignedNumber<T>)

   • Tests optimization effectiveness with generic constraints

Key Insights

The benchmarks test the Factorial function with different optimization strategies, focusing on:

• Branch prediction optimization
• Exception path isolation (cold path)
• Code organization (hot path first vs exception path first)
• Inlining decisions
• Generic vs non-generic performance

Test Scenario

All benchmarks use FactorialNumber = 19 (within valid range) to ensure we're measuring the hot path performance rather than exception handling.

🧪 Running the Benchmarks

cd csharp/Platform.Numbers.Benchmarks
dotnet run -c Release

📊 Expected Results

The benchmarks will show:

• Impact of different MethodImpl attributes on hot path performance
• Benefits of separating exception paths with DoesNotReturn
• Performance differences between code organization patterns
• Generic vs non-generic implementation overhead

✅ Changes Made

• Added 7 new factorial implementation alternatives
• Added 6 new benchmark methods
• All implementations handle the same logic with different optimization hints
• Code compiles successfully and maintains existing behavior

🔗 Related Work

• Issue Create benchmark for [[likely]] performance #96: Original request for [[likely]] performance benchmarks
• PR Translation to C++ #91: C++ translation showing the context for [[likely]]/[[unlikely]] attributes

---

🤖 Generated with Claude Code

[konard]

🤖 Solution Draft Log

This log file contains the complete execution trace of the AI solution draft process.

📎 Log file uploaded as GitHub Gist (205KB)
🔗 View complete solution draft log

---

Now working session is ended, feel free to review and add any feedback on the solution draft.