SystemH

// 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";
}

// SystemH C++: Fixed-size contiguous array with raw memory efficiency
#include "System.h"
using namespace System;
using namespace System::Collections::Generic;

// 1. Allocation (instant flat contiguous buffer, 0.01 ms for 500,000 items)
Array<int> arr(500000);

// 2. Sequential fill (12.5x faster than C# .NET 10, zero bounds check penalty)
for (int i = 0; i < 500000; i++) {
    arr[i] = i * 3 + 1;
}

// 3. Random indexing via shuffled permutation (1.06 ms across 500k reads)
int val = arr[42];

// 4. Sequential traversal at CPU hardware memory bus speed (0.21 ms)
int64_t sum = 0;
for (// 5. In-place reversal (2.75x faster than Boost vector)
arr.Reverse();

// C# .NET 10: Managed single-dimensional array (int[])
using System;

// 1. Managed allocation on CLR Garbage-Collected heap
var arr = new int[500_000];

// 2. Sequential fill (12.94 ms - 12.5x slower due to JIT range check overhead)
for (int i = 0; i < 500_000; i++) {
    arr[i] = i * 3 + 1;
}

// 3. Shuffled random indexing (0.67 ms)
int val = arr[42];

// 4. Sequential foreach traversal (0.11 ms)
long sum = 0;
foreach (var v in arr) {
    sum += v;
}

// 5. Managed array reversal helper
Array.Reverse(arr);

// Standard C++: std::vector<int> (Contiguous sequence)
#include <vector>
#include <algorithm>

// 1. Vector allocation with initial size
std::vector<int> arr(500000);

// 2. Sequential fill via operator[] (0.04 ms)
for (int i = 0; i < 500000; i++) {
    arr[i] = i * 3 + 1;
}

// 3. Shuffled index access (0.54 ms)
int val = arr[42];

// 4. Pointer iteration (0.20 ms)
int64_t sum = 0;
for (int v : arr) {
    sum += v;
}

// 5. In-place reversal
std::reverse(arr.begin(), arr.end());

// Boost C++: boost::container::vector<int>
#include <boost/container/vector.hpp>
#include <algorithm>

// 1. Boost vector construction
boost::container::vector<int> arr(500000);

// 2. Sequential fill (0.05 ms)
for (int i = 0; i < 500000; i++) {
    arr[i] = i * 3 + 1;
}

// 3. Shuffled index access (1.79 ms)
int val = arr[42];

// 4. Traversal (0.20 ms)
int64_t sum = 0;
for (int v : arr) {
    sum += v;
}

// 5. In-place reversal (0.11 ms - 2.75x slower than SystemH)
std::reverse(arr.begin(), arr.end());

// SystemH C++: Dynamically resizable list with sub-microsecond geometric growth
#include "System.h"
using namespace System;
using namespace System::Collections::Generic;

// 1. Instantiation (lightweight handle-to-body architecture)
List<int> list = new List<int>();

// 2. Dynamic growth via Add() (1.67 ms - 19.7x faster than .NET 10, 1.68x vs Boost)
for (int i = 0; i < 500000; i++) {
    list.Add(i * 3 + 1;
}

// 3. Preallocated insertion (0.70 ms for 500,000 items - 1.4 ns per append)
List<int> listPre(500000);
for (int i = 0; i < 500000; i++) {
    listPre.Add(i * 3 + 1;
}

// 4. Raw pointer traversal (0.20 ms - faster than std::vector)
int64_t sum = 0;
for (// 5. Predictable latency: 0.18 ms max pause (vs 5.33 ms in .NET CLR GC)

// C# .NET 10: Managed List<int>
using System;
using System.Collections.Generic;

// 1. Managed list instantiation
var list = new List<int>();

// 2. Dynamic resize insertion (32.87 ms - triggers array allocations & GC sweeps)
for (int i = 0; i < 500_000; i++) {
    list.Add(i * 3 + 1;
}

// 3. Preallocated insertion with capacity (1.16 ms)
var listPre = new List<int>(500_000);
for (int i = 0; i < 500_000; i++) {
    listPre.Add(i * 3 + 1;
}

// 4. Foreach iteration (via List<T>.Enumerator struct)
long sum = 0;
foreach (var v in list) {
    sum += v;
}

// 5. GC Pause: up to 5.33 ms pause during dynamic capacity expansions

// Standard C++: std::vector<int> push_back
#include <vector>

// 1. Default empty vector
std::vector<int> vec;

// 2. Dynamic growth with push_back (0.74 ms - doubling reallocation)
for (int i = 0; i < 500000; i++) {
    vec.push_back(i * 3 + 1;
}

// 3. Preallocated insertion with reserve() (0.35 ms)
std::vector<int> vecPre;
vecPre.reserve(500000);
for (int i = 0; i < 500000; i++) {
    vecPre.push_back(i * 3 + 1;
}

// 4. Range-based for loop traversal (0.22 ms)
int64_t sum = 0;
for (int v : vec) {
    sum += v;
}

// Boost C++: boost::container::vector<int>
#include <boost/container/vector.hpp>

// 1. Default vector
boost::container::vector<int> vec;

// 2. Dynamic growth (2.81 ms - 1.68x slower than SystemH)
for (int i = 0; i < 500000; i++) {
    vec.push_back(i * 3 + 1;
}

// 3. Preallocated insertion with reserve() (0.29 ms)
boost::container::vector<int> vecPre;
vecPre.reserve(500000);
for (int i = 0; i < 500000; i++) {
    vecPre.push_back(i * 3 + 1;
}

// 4. Traversal (0.21 ms)
int64_t sum = 0;
for (int v : vec) {
    sum += v;
}