List<T>

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

500,000 operations evaluated on Linux x86_64 across dynamic geometric resize, preallocated insert, iteration, and tail latency.

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