Dictionary<TKey, TValue>

Performance Benchmarks: SystemH vs C# .NET 10 vs STL vs Boost

500,000 operations evaluated on Linux x86_64 across dynamic resizing, lookup latency, and tail pause distributions.

// SystemH C++: Single-header standard collections with zero GC overhead
#include "System.h"
using namespace System;
using namespace System::Collections::Generic;

// 1. Instantiation (single contiguous entry buffer allocation)
Dictionary<int, int> dict = new Dictionary<int, int>();

// 2. High-speed dynamic insertion (31.1 Million ops/sec)
for (int i = 0; i < 500000; i++) {
    dict[i] = i * 3 + 1;
}

// 3. Fast O(1) TryGetValue lookup (returns value by lvalue reference)
int val = 0;
if (dict.TryGetValue(42, val)) {
    Console::WriteLine(String("Found: ") + String(val));
}

// 4. Cache-friendly traversal
for (auto const& kvp : dict) {
    // Process kvp.Key, kvp.Value with zero heap indirection
}

// C# .NET 10: Managed BCL generic dictionary
using System;
using System.Collections.Generic;

// 1. Managed allocation on CLR Garbage-Collected heap
var dict = new Dictionary<int, int>();

// 2. Dynamic growth triggers intermediate array allocations & GC cycles
for (int i = 0; i < 500_000; i++) {
    dict[i] = i * 3 + 1;
}

// 3. TryGetValue with out parameter
if (dict.TryGetValue(42, out int val)) {
    Console.WriteLine($"Found: {val}");
}

// Standard C++: std::unordered_map (Node-based hash table)
#include <unordered_map>
#include <iostream>

// 1. Standard bucketed hash table
std::unordered_map<int, int> dict;

// 2. Allocates a separate std::_Hash_node on the heap for EVERY item (500,000 mallocs)
for (int i = 0; i < 500000; i++) {
    dict[i] = i * 3 + 1;
}

// 3. Pointer-chased bucket lookup
auto it = dict.find(42);
if (it != dict.end()) {
    std::cout << "Found: " << it->second << "\n";
}

// Boost C++: boost::unordered_map
#include <boost/unordered_map.hpp>
#include <iostream>

// 1. Boost Unordered hash map
boost::unordered_map<int, int> dict;

// 2. Dynamic growth with node allocation across bucket chains
for (int i = 0; i < 500000; i++) {
    dict[i] = i * 3 + 1;
}

// 3. Lookup
auto it = dict.find(42);
if (it != dict.end()) {
    std::cout << "Found: " << it->second << "\n";
}