Adding bonus section at the end.

Author: FranciscoThiesen

cppcon2025/compiler_explorer_serialization_reflection_based.asm

@@ -1175,8 +1175,7 @@ Welcome to the future of C++ serialization! 🚀
 - The authors of P2996 for making compile-time reflection a reality
 
 **Compiler Implementation Teams**
-- EDG team for the experimental implementation
-- Contributors to experimental GCC and Clang branches
+- Everyone that implemented P2996 and made it publicly available.
 - Early adopters testing and providing feedback
 
 **Compiler Explorer Team**
@@ -1197,3 +1196,302 @@ Daniel Lemire and Francisco Geiman Thiesen
 GitHub: github.com/simdjson/simdjson
 
 Thank you!
+
+---
+
+# BONUS: Assembly Deep Dive
+
+Want to see the actual machine code?
+
+Let's look under the hood! 🔧
+
+---
+
+# The Shocking Truth: Instruction Counts
+
+<div style="display: flex; align-items: center; gap: 30px">
+<div style="flex: 1.5">
+
+![Instruction Count Analysis](images/bonus_chart1_instructions.png)
+
+</div>
+<div style="flex: 1">
+
+### The Numbers:
+- **Manual:** 1,635 instructions
+- **Reflection:** 648 instructions
+- **Speedup:** 2.5x fewer!
+
+### You Write:
+- **Manual:** 70+ lines of C++
+- **Reflection:** 1 line!
+
+[Try it yourself →](https://godbolt.org/z/94jPx6bEb)
+
+</div>
+</div>
+
+---
+
+# Field Names: The Power of Compile-Time Constants
+
+<div style="display: flex; gap: 20px">
+<div style="flex: 1">
+
+### Manual: Byte-by-byte
+```asm
+mov  byte ptr [rdx], 34      ; '"'
+mov  byte ptr [rdx+1], 109   ; 'm'
+mov  byte ptr [rdx+2], 97    ; 'a'
+mov  byte ptr [rdx+3], 107   ; 'k'
+mov  byte ptr [rdx+4], 101   ; 'e'
+mov  byte ptr [rdx+5], 34    ; '"'
+mov  byte ptr [rdx+6], 58    ; ':'
+; ... plus bounds checks
+```
+**50+ instructions per field name**
+
+</div>
+<div style="flex: 1">
+
+### Reflection: 64-bit constant
+```asm
+movabs  rax, 0x223A656B616D22
+; "make":" as single value!
+
+mov  qword ptr [rdx], rax
+; Store 8 bytes at once!
+```
+**2 instructions per field name**
+
+</div>
+</div>
+
+![Field Name Encoding](images/bonus_chart3_fields.png)
+
+*Source: compiler_explorer_instruction_comparison.asm - 25x fewer instructions for field operations*
+
+---
+
+# Branch Prediction: The Hidden Performance Killer
+
+<div style="columns: 2; column-gap: 40px">
+
+### Manual: 311 branches! 😱
+```asm
+cmp     al, 34        ; quote?
+je      .LBB0_19      ; branch!
+cmp     al, 92        ; backslash?
+je      .LBB0_27      ; branch!
+cmp     al, 10        ; newline?
+je      .LBB0_35      ; branch!
+cmp     al, 13        ; return?
+je      .LBB0_42      ; branch!
+; ... 300+ more conditions
+```
+
+**Problem:** Each branch = potential CPU pipeline stall
+
+<div style="break-before: column"></div>
+
+### Reflection: 20 branches 🎯
+```asm
+call simdjson::to_json_string
+; Most logic inside optimized
+; library with straight-line
+; SIMD code
+```
+
+**Benefit:**
+- 15x fewer misprediction opportunities
+- Better CPU pipeline utilization
+- Predictable control flow
+
+</div>
+
+*Measured from assembly: 311 je/jne/jb/ja instructions vs 20*
+
+---
+
+# Memory Allocation: Death by a Thousand Cuts
+
+<style scoped>
+table {
+  font-size: 0.9em;
+}
+</style>
+
+| Operation | Manual | Reflection | Impact |
+|-----------|--------|------------|--------|
+| String appends | 40 | 5 | 8x fewer |
+| Memory reallocations | 235 | 1 | **235x fewer!** |
+| Escape checks | 600+ | (inside lib) | Bulk SIMD |
+
+### Manual: Growing pain
+```cpp
+std::string json = "{";           // alloc 1
+json += "\"make\":\"";            // realloc 2
+json += car.make;                 // realloc 3
+json += "\",\"model\":\"";        // realloc 4
+// ... 231 more reallocations!
+```
+
+### Reflection: Pre-sized perfection
+```cpp
+return simdjson::to_json(car);    // 1 allocation, perfectly sized!
+```
+
+*Source: Assembly analysis of compiler_explorer_instruction_comparison.asm*
+
+---
+
+# Real Code Comparison
+
+## What developers write (Manual):
+```cpp
+std::string serialize_manual(const Car& car) {
+    std::string json = "{";
+    json += "\"make\":\"";
+    for (char c : car.make) {
+        switch(c) {
+            case '"':  json += "\\\""; break;
+            case '\\': json += "\\\\"; break;
+            case '\n': json += "\\n"; break;
+            // ... more escape cases
+            default: json += c;
+        }
+    }
+    json += "\",\"model\":\"";
+    // ... 70+ more lines of similar code
+}
+```
+
+## What developers write (Reflection):
+```cpp
+std::string serialize_reflection(const Car& car) {
+    return simdjson::to_json(car);  // That's it!
+}
+```
+
+Try both: https://godbolt.org/z/1n539e7cq
+
+---
+
+# Branch Complexity Analysis
+
+![Branch Complexity](images/bonus_chart2_branches.png)
+
+### What the Numbers Mean:
+- **Manual:** 311 conditional branches in assembly
+- **Reflection:** 20 conditional branches in assembly
+- **Impact:** Fewer branches = fewer potential mispredictions
+- **Note:** Actual performance depends on data patterns
+
+---
+
+
+
+# How Reflection Optimizes
+
+## Compile-Time Field Discovery
+```cpp
+template for (constexpr auto member : 
+              std::meta::nonstatic_data_members_of(^^Car)) {
+    // Field names known at compile time!
+    // Compiler generates optimal code for each field
+}
+```
+
+## Result: Pre-computed Constants
+- Field names → 64-bit integers
+- String lengths → compile-time constants  
+- Escape sequences → eliminated entirely
+- Buffer sizes → calculated at compile time
+
+---
+
+# Escape Processing: Different Approaches
+
+## Manual: Character-by-character checking
+```cpp
+for (char c : str) {
+    if (c == '"') output += "\\\"";
+    else if (c == '\\') output += "\\\\";
+    else if (c < 0x20) {
+        // Unicode escape sequence
+        snprintf(buf, 7, "\\u%04x", c);
+        output += buf;
+    }
+    // ... more checks
+}
+```
+
+## Reflection: Library handles escaping
+- Escaping logic encapsulated in simdjson
+- Implementation may use SIMD for bulk processing
+- Details hidden inside `simdjson::to_json_string`
+
+---
+
+# Try It Yourself!
+
+## Compiler Explorer Links:
+
+1. **Basic Comparison** (Manual vs Reflection):
+   https://godbolt.org/z/1n539e7cq
+
+2. **Reflection-Only Serialization**:
+   https://godbolt.org/z/94jPx6bEb
+
+3. **Full simdjson Integration** (requires reflection support):
+   ```bash
+   clang++ -std=c++26 -freflection \
+           -fexpansion-statements -O3
+   ```
+
+## What to Look For:
+- Search for `movabs` instructions with large numbers
+- Count the `je/jne/jb/ja` branch instructions
+- Look at the size of each function
+- Notice the `.rodata` section with pre-computed strings
+
+---
+
+# Why This Matters for Real Applications
+
+## Benefits Compound:
+1. Fewer instructions → Better I-cache usage
+2. Fewer branches → Better speculation
+3. Compile-time strings → Better D-cache usage
+4. SIMD-ready layout → Vectorization opportunities
+
+---
+
+# Key Takeaways from Assembly Analysis
+
+1. **Reflection generates highly optimized code**
+   - Consistently applies optimizations
+   - Eliminates manual boilerplate
+   - Reduces opportunity for errors
+
+2. **Compile-time is powerful**
+   - Field names become constants
+   - No runtime string building
+   - Pre-computed buffer sizes
+
+3. **Modern C++ delivers on its promises**
+   - Zero-overhead abstraction is real
+   - Better performance AND better ergonomics
+
+4. **simdjson + reflection = excellent match**
+   - Compile-time structure analysis
+   - Optimized library implementation
+   - Significant reduction in code complexity
+
+---
+
+# End of Bonus Section
+
+Return to main presentation or explore the code yourself!
+
+Remember: The assembly doesn't lie! 🚀