Daily update on 20260307-020120 by Nitload Youmu. Additional Message : None
Signed-off-by: Nitload <YoumuLiu_NSI@whv0t.onmicrosoft.com>
This commit is contained in:
Nitload
@@ -29,41 +29,127 @@ using BenchmarkDotNet.Attributes;
|
||||
using StgSharp.Collections;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Runtime.CompilerServices;
|
||||
|
||||
namespace StgSharp.Benchmark
|
||||
{
|
||||
/// <summary>
|
||||
/// Benchmark comparing SwissTable (SSE2 SIMD probing, zero-GC, native memory) against <see
|
||||
/// cref="Dictionary{TKey, TValue}" /> for the L4 cache address mapping workload: concentrated
|
||||
/// small-key insert/lookup/remove cycles. <para> SwissTable.Create() performs a 1 MB memset
|
||||
/// (65536 × 16 control bytes), which is separated into IterationSetup to avoid polluting
|
||||
/// insert timings.</para>
|
||||
/// Benchmark comparing SwissTable against <see cref="Dictionary{TKey, TValue}" />
|
||||
/// under realistic L4 software cache address-mapping workloads.
|
||||
/// <para>
|
||||
/// L4 scenario characteristics:
|
||||
/// - Keys are HLSF/malloc pointer addresses (large, 1024-byte aligned)
|
||||
/// - Access pattern is Zipfian-skewed (20% hot cache lines receive 80% of lookups)
|
||||
/// - Steady state: high hit-rate lookups dominate, with rare evict+refill on miss
|
||||
/// - Working set: 512–4096 active cache line mappings
|
||||
/// </para>
|
||||
/// </summary>
|
||||
[MemoryDiagnoser]
|
||||
public class SwissTableBench
|
||||
{
|
||||
|
||||
private const int LookupCount = 4096;
|
||||
/// <summary> L4 cache line size in bytes (per L4_design.md). </summary>
|
||||
private const int CacheLineSize = 1024;
|
||||
|
||||
private nint[] _lookupKeys = null!;
|
||||
/// <summary> Simulated heap base address for pointer-like keys. </summary>
|
||||
private const long HeapBase = 0x7FFF_0000_0000L;
|
||||
|
||||
// ── Pre-generated key arrays ──
|
||||
/// <summary> Number of lookup operations per Lookup benchmark call. </summary>
|
||||
private const int LookupIterations = 8192;
|
||||
|
||||
private nint[] _preloadedKeys = null!;
|
||||
/// <summary>
|
||||
/// Number of steady-state operations per call.
|
||||
/// Each op is either a lookup (hit) or an evict+insert+lookup (miss).
|
||||
/// </summary>
|
||||
private const int SteadyStateOps = 4096;
|
||||
|
||||
/// <summary> Fraction of steady-state ops that are cache misses. </summary>
|
||||
private const double MissRate = 0.05;
|
||||
|
||||
// ── Pre-generated key arrays (pointer-like, 1024-byte aligned) ──
|
||||
|
||||
/// <summary> Keys for initial table fill (simulates cached addresses). </summary>
|
||||
private nint[] _residentKeys = null!;
|
||||
|
||||
/// <summary> Additional keys not in the table, for triggering misses. </summary>
|
||||
private nint[] _externalKeys = null!;
|
||||
|
||||
/// <summary> Zipfian-skewed lookup sequence (hot 20% accessed 80% of time). </summary>
|
||||
private nint[] _zipfianLookups = null!;
|
||||
|
||||
/// <summary> Uniform random lookup sequence (baseline comparison). </summary>
|
||||
private nint[] _uniformLookups = null!;
|
||||
|
||||
/// <summary>
|
||||
/// Pre-built steady-state operation script.
|
||||
/// Each entry: positive index → lookup _residentKeys[idx],
|
||||
/// negative value → cache miss trigger (evict + insert from _externalKeys).
|
||||
/// </summary>
|
||||
private int[] _steadyStateScript = null!;
|
||||
|
||||
/// <summary> Indices into _residentKeys for eviction targets (cold entries, tail region). </summary>
|
||||
private int[] _evictOrder = null!;
|
||||
|
||||
// ── Pre-filled lookup targets ──
|
||||
|
||||
private SwissTable _swissLookup = null!;
|
||||
private Dictionary<nint, nint> _dictLookup = null!;
|
||||
private Dictionary<nint, nint> _freshDict = null!;
|
||||
|
||||
// ── Fresh instances for insert/mixed (rebuilt each iteration) ──
|
||||
|
||||
private SwissTable _freshSwiss = null!;
|
||||
private Dictionary<nint, nint> _freshDict = null!;
|
||||
|
||||
// ── Lookup targets (pre-filled in GlobalSetup) ──
|
||||
|
||||
private SwissTable _swissLookup = null!;
|
||||
|
||||
[Params(500, 2000, 5000)]
|
||||
/// <summary>
|
||||
/// Active cache line count. Matches L4 capacity range:
|
||||
/// 5 MB / 1024B ≈ 5120, 10 MB / 1024B ≈ 10240.
|
||||
/// 512 and 1024 test low-occupancy; 4096 tests near-capacity.
|
||||
/// </summary>
|
||||
[Params(512, 1024, 4096)]
|
||||
public int KeyCount;
|
||||
|
||||
// ════════════════════════════════════════════════════════════
|
||||
// Setup / Teardown
|
||||
// ════════════════════════════════════════════════════════════
|
||||
|
||||
[GlobalSetup]
|
||||
public void Setup()
|
||||
{
|
||||
Random rng = new Random(42);
|
||||
|
||||
// ── Generate pointer-like keys (HeapBase + random_offset * 1024) ──
|
||||
_residentKeys = GeneratePointerKeys(KeyCount, rng);
|
||||
_externalKeys = GeneratePointerKeys(KeyCount, rng); // disjoint set for miss simulation
|
||||
|
||||
// ── Build lookup sequences ──
|
||||
_zipfianLookups = GenerateZipfianLookups(_residentKeys, LookupIterations, rng);
|
||||
_uniformLookups = GenerateUniformLookups(_residentKeys, LookupIterations, rng);
|
||||
|
||||
// ── Build steady-state operation script ──
|
||||
_steadyStateScript = GenerateSteadyStateScript(KeyCount, SteadyStateOps, MissRate, rng);
|
||||
|
||||
// ── Build eviction order (cold tail entries first) ──
|
||||
_evictOrder = new int[KeyCount];
|
||||
for (int i = 0; i < KeyCount; i++)
|
||||
{
|
||||
_evictOrder[i] = i;
|
||||
}
|
||||
// Shuffle so eviction isn't just sequential
|
||||
Shuffle(_evictOrder, rng);
|
||||
|
||||
// ── Pre-fill lookup tables ──
|
||||
_swissLookup = SwissTable.Create();
|
||||
_dictLookup = new Dictionary<nint, nint>(KeyCount);
|
||||
|
||||
for (int i = 0; i < KeyCount; i++)
|
||||
{
|
||||
nint key = _residentKeys[i];
|
||||
nint val = key ^ unchecked((nint)0xDEAD_BEEF); // simulated cache pointer
|
||||
_swissLookup.TryAddOrSet(key, val, out _);
|
||||
_dictLookup[key] = val;
|
||||
}
|
||||
}
|
||||
|
||||
[GlobalCleanup]
|
||||
public void Cleanup()
|
||||
{
|
||||
@@ -71,119 +157,114 @@ namespace StgSharp.Benchmark
|
||||
_dictLookup.TrimExcess();
|
||||
}
|
||||
|
||||
// ══════════════════════════════════════
|
||||
// Insert: pure write throughput
|
||||
// Empty table → fill N keys
|
||||
// Create() cost excluded via IterationSetup
|
||||
// ══════════════════════════════════════
|
||||
|
||||
[Benchmark]
|
||||
public void Dictionary_Insert()
|
||||
{
|
||||
Dictionary<nint, nint> dict = _freshDict;
|
||||
nint[] keys = _preloadedKeys;
|
||||
for (int i = 0; i < keys.Length; i++) {
|
||||
dict[keys[i]] = keys[i] * 2;
|
||||
}
|
||||
}
|
||||
|
||||
// ══════════════════════════════════════
|
||||
// Lookup: pure read throughput
|
||||
// Pre-filled table, random key access
|
||||
// ══════════════════════════════════════
|
||||
|
||||
[Benchmark(Baseline = true)]
|
||||
public nint Dictionary_Lookup()
|
||||
{
|
||||
nint sum = 0;
|
||||
nint[] keys = _lookupKeys;
|
||||
Dictionary<nint, nint> dict = _dictLookup;
|
||||
for (int i = 0; i < keys.Length; i++)
|
||||
{
|
||||
if (dict.TryGetValue(keys[i], out nint value)) {
|
||||
sum += value;
|
||||
}
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
||||
// ══════════════════════════════════════
|
||||
// Mixed: insert all → lookup half → remove half → lookup all
|
||||
// Simulates L4 cache lifecycle:
|
||||
// load working set → compute → evict → recompute
|
||||
// ══════════════════════════════════════
|
||||
|
||||
[Benchmark]
|
||||
public nint Dictionary_Mixed()
|
||||
{
|
||||
Dictionary<nint, nint> dict = _freshDict;
|
||||
nint[] keys = _preloadedKeys;
|
||||
nint sum = 0;
|
||||
|
||||
// insert all
|
||||
for (int i = 0; i < keys.Length; i++)
|
||||
{
|
||||
dict[keys[i]] = keys[i] * 2;
|
||||
}
|
||||
|
||||
// lookup first half
|
||||
for (int i = 0; i < keys.Length / 2; i++)
|
||||
{
|
||||
if (dict.TryGetValue(keys[i], out nint value)) {
|
||||
sum += value;
|
||||
}
|
||||
}
|
||||
|
||||
// remove first half (eviction)
|
||||
for (int i = 0; i < keys.Length / 2; i++)
|
||||
{
|
||||
dict.Remove(keys[i]);
|
||||
}
|
||||
|
||||
// lookup all (half hit, half miss)
|
||||
for (int i = 0; i < keys.Length; i++)
|
||||
{
|
||||
if (dict.TryGetValue(keys[i], out nint value)) {
|
||||
sum += value;
|
||||
}
|
||||
}
|
||||
|
||||
return sum;
|
||||
}
|
||||
|
||||
[IterationSetup(Targets = [
|
||||
nameof(SwissTable_Insert),
|
||||
nameof(SwissTable_Mixed),
|
||||
nameof(SwissTable_SteadyState),
|
||||
nameof(Dictionary_Insert),
|
||||
nameof(Dictionary_Mixed)
|
||||
nameof(Dictionary_SteadyState)
|
||||
])]
|
||||
public void IterationSetup()
|
||||
{
|
||||
_freshSwiss = SwissTable.Create();
|
||||
_freshDict = new Dictionary<nint, nint>(KeyCount);
|
||||
}
|
||||
|
||||
// ── Setup / Teardown ──
|
||||
|
||||
[GlobalSetup]
|
||||
public void Setup()
|
||||
{
|
||||
_preloadedKeys = new nint[KeyCount];
|
||||
_lookupKeys = new nint[LookupCount];
|
||||
|
||||
_swissLookup = SwissTable.Create();
|
||||
_dictLookup = new Dictionary<nint, nint>(KeyCount);
|
||||
|
||||
// Pre-fill for steady-state benchmarks
|
||||
for (int i = 0; i < KeyCount; i++)
|
||||
{
|
||||
_preloadedKeys[i] = (nint)i;
|
||||
_swissLookup.TryAddOrSet((nint)i, (nint)(i * 2), out _);
|
||||
_dictLookup[(nint)i] = (nint)(i * 2);
|
||||
nint key = _residentKeys[i];
|
||||
nint val = key ^ unchecked((nint)0xDEAD_BEEF);
|
||||
_freshSwiss.TryAddOrSet(key, val, out _);
|
||||
_freshDict[key] = val;
|
||||
}
|
||||
}
|
||||
|
||||
Random rng = new Random(42);
|
||||
for (int i = 0; i < LookupCount; i++) {
|
||||
_lookupKeys[i] = (nint)rng.Next(0, KeyCount);
|
||||
// ════════════════════════════════════════════════════════════
|
||||
// Lookup — Zipfian (L4 hot path, skewed access)
|
||||
// 20% of cache lines receive 80% of accesses.
|
||||
// This is the most representative L4 benchmark.
|
||||
// ════════════════════════════════════════════════════════════
|
||||
|
||||
[Benchmark(Baseline = true)]
|
||||
public nint Dictionary_Lookup_Zipfian()
|
||||
{
|
||||
nint sum = 0;
|
||||
nint[] keys = _zipfianLookups;
|
||||
Dictionary<nint, nint> dict = _dictLookup;
|
||||
for (int i = 0; i < keys.Length; i++)
|
||||
{
|
||||
if (dict.TryGetValue(keys[i], out nint value))
|
||||
{
|
||||
sum += value;
|
||||
}
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
||||
[Benchmark]
|
||||
public nint SwissTable_Lookup_Zipfian()
|
||||
{
|
||||
nint sum = 0;
|
||||
nint[] keys = _zipfianLookups;
|
||||
SwissTable swiss = _swissLookup;
|
||||
for (int i = 0; i < keys.Length; i++)
|
||||
{
|
||||
if (swiss.TryGet(keys[i], out nint value))
|
||||
{
|
||||
sum += value;
|
||||
}
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
||||
// ════════════════════════════════════════════════════════════
|
||||
// Lookup — Uniform (baseline comparison)
|
||||
// ════════════════════════════════════════════════════════════
|
||||
|
||||
[Benchmark]
|
||||
public nint Dictionary_Lookup_Uniform()
|
||||
{
|
||||
nint sum = 0;
|
||||
nint[] keys = _uniformLookups;
|
||||
Dictionary<nint, nint> dict = _dictLookup;
|
||||
for (int i = 0; i < keys.Length; i++)
|
||||
{
|
||||
if (dict.TryGetValue(keys[i], out nint value))
|
||||
{
|
||||
sum += value;
|
||||
}
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
||||
[Benchmark]
|
||||
public nint SwissTable_Lookup_Uniform()
|
||||
{
|
||||
nint sum = 0;
|
||||
nint[] keys = _uniformLookups;
|
||||
SwissTable swiss = _swissLookup;
|
||||
for (int i = 0; i < keys.Length; i++)
|
||||
{
|
||||
if (swiss.TryGet(keys[i], out nint value))
|
||||
{
|
||||
sum += value;
|
||||
}
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
||||
// ════════════════════════════════════════════════════════════
|
||||
// Insert — bulk fill with scattered pointer addresses
|
||||
// Simulates L4 initial cache warm-up phase.
|
||||
// ════════════════════════════════════════════════════════════
|
||||
|
||||
[Benchmark]
|
||||
public void Dictionary_Insert()
|
||||
{
|
||||
Dictionary<nint, nint> dict = _freshDict;
|
||||
nint[] keys = _residentKeys;
|
||||
for (int i = 0; i < keys.Length; i++)
|
||||
{
|
||||
dict[keys[i]] = keys[i] ^ unchecked((nint)0xDEAD_BEEF);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -191,64 +272,235 @@ namespace StgSharp.Benchmark
|
||||
public void SwissTable_Insert()
|
||||
{
|
||||
SwissTable swiss = _freshSwiss;
|
||||
nint[] keys = _preloadedKeys;
|
||||
for (int i = 0; i < keys.Length; i++) {
|
||||
swiss.TryAddOrSet(keys[i], keys[i] * 2, out _);
|
||||
nint[] keys = _residentKeys;
|
||||
for (int i = 0; i < keys.Length; i++)
|
||||
{
|
||||
swiss.TryAddOrSet(keys[i], keys[i] ^ unchecked((nint)0xDEAD_BEEF), out _);
|
||||
}
|
||||
}
|
||||
|
||||
// ════════════════════════════════════════════════════════════
|
||||
// SteadyState — the KEY L4 benchmark
|
||||
// Pre-filled table at capacity, then 4096 operations:
|
||||
// ~95% are lookups (cache hits)
|
||||
// ~5% are miss → evict cold entry → insert new entry → lookup new
|
||||
// This directly simulates L4's main runtime loop.
|
||||
// ════════════════════════════════════════════════════════════
|
||||
|
||||
[Benchmark]
|
||||
public nint SwissTable_Lookup()
|
||||
public nint Dictionary_SteadyState()
|
||||
{
|
||||
nint sum = 0;
|
||||
nint[] keys = _lookupKeys;
|
||||
SwissTable swiss = _swissLookup;
|
||||
for (int i = 0; i < keys.Length; i++)
|
||||
Dictionary<nint, nint> dict = _freshDict;
|
||||
nint[] resident = _residentKeys;
|
||||
nint[] external = _externalKeys;
|
||||
int[] script = _steadyStateScript;
|
||||
int[] evict = _evictOrder;
|
||||
int evictCursor = 0;
|
||||
int externalCursor = 0;
|
||||
|
||||
for (int i = 0; i < script.Length; i++)
|
||||
{
|
||||
if (swiss.TryGet(keys[i], out nint value)) {
|
||||
sum += value;
|
||||
int op = script[i];
|
||||
if (op >= 0)
|
||||
{
|
||||
// Cache hit: lookup existing entry
|
||||
if (dict.TryGetValue(resident[op], out nint value))
|
||||
{
|
||||
sum += value;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Cache miss: evict a cold entry, insert a new one, then lookup
|
||||
int evictIdx = evict[evictCursor % evict.Length];
|
||||
evictCursor++;
|
||||
dict.Remove(resident[evictIdx]);
|
||||
|
||||
int extIdx = externalCursor % external.Length;
|
||||
externalCursor++;
|
||||
nint newKey = external[extIdx];
|
||||
nint newVal = newKey ^ unchecked((nint)0xDEAD_BEEF);
|
||||
dict[newKey] = newVal;
|
||||
|
||||
if (dict.TryGetValue(newKey, out nint v))
|
||||
{
|
||||
sum += v;
|
||||
}
|
||||
}
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
||||
[Benchmark]
|
||||
public nint SwissTable_Mixed()
|
||||
public nint SwissTable_SteadyState()
|
||||
{
|
||||
nint sum = 0;
|
||||
SwissTable swiss = _freshSwiss;
|
||||
nint[] keys = _preloadedKeys;
|
||||
nint sum = 0;
|
||||
nint[] resident = _residentKeys;
|
||||
nint[] external = _externalKeys;
|
||||
int[] script = _steadyStateScript;
|
||||
int[] evict = _evictOrder;
|
||||
int evictCursor = 0;
|
||||
int externalCursor = 0;
|
||||
|
||||
// insert all
|
||||
for (int i = 0; i < keys.Length; i++)
|
||||
for (int i = 0; i < script.Length; i++)
|
||||
{
|
||||
swiss.TryAddOrSet(keys[i], keys[i] * 2, out _);
|
||||
}
|
||||
int op = script[i];
|
||||
if (op >= 0)
|
||||
{
|
||||
// Cache hit: lookup existing entry
|
||||
if (swiss.TryGet(resident[op], out nint value))
|
||||
{
|
||||
sum += value;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Cache miss: evict a cold entry, insert a new one, then lookup
|
||||
int evictIdx = evict[evictCursor % evict.Length];
|
||||
evictCursor++;
|
||||
swiss.TryRemove(resident[evictIdx], out _);
|
||||
|
||||
// lookup first half
|
||||
for (int i = 0; i < keys.Length / 2; i++)
|
||||
{
|
||||
if (swiss.TryGet(keys[i], out nint value)) {
|
||||
sum += value;
|
||||
int extIdx = externalCursor % external.Length;
|
||||
externalCursor++;
|
||||
nint newKey = external[extIdx];
|
||||
nint newVal = newKey ^ unchecked((nint)0xDEAD_BEEF);
|
||||
swiss.TryAddOrSet(newKey, newVal, out _);
|
||||
|
||||
if (swiss.TryGet(newKey, out nint v))
|
||||
{
|
||||
sum += v;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// remove first half (eviction)
|
||||
for (int i = 0; i < keys.Length / 2; i++)
|
||||
{
|
||||
swiss.TryRemove(keys[i], out _);
|
||||
}
|
||||
|
||||
// lookup all (half hit, half miss)
|
||||
for (int i = 0; i < keys.Length; i++)
|
||||
{
|
||||
if (swiss.TryGet(keys[i], out nint value)) {
|
||||
sum += value;
|
||||
}
|
||||
}
|
||||
|
||||
return sum;
|
||||
}
|
||||
|
||||
// ════════════════════════════════════════════════════════════
|
||||
// Data generation helpers
|
||||
// ════════════════════════════════════════════════════════════
|
||||
|
||||
/// <summary>
|
||||
/// Generate <paramref name="count"/> unique pointer-like keys.
|
||||
/// Each key = HeapBase + randomOffset * CacheLineSize,
|
||||
/// simulating HLSF-allocated 1024-byte aligned addresses
|
||||
/// scattered across a ~1 GB virtual address range.
|
||||
/// </summary>
|
||||
private static nint[] GeneratePointerKeys(
|
||||
int count,
|
||||
Random rng
|
||||
)
|
||||
{
|
||||
nint[] keys = new nint[count];
|
||||
HashSet<long> used = new HashSet<long>(count);
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
long offset;
|
||||
do
|
||||
{
|
||||
// Random offset within ~1M cache lines (1 GB range)
|
||||
offset = (long)rng.Next(0, 1 << 20) * CacheLineSize;
|
||||
} while (!used.Add(offset));
|
||||
keys[i] = (nint)(HeapBase + offset);
|
||||
}
|
||||
return keys;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Generate Zipfian-skewed lookup sequence:
|
||||
/// 80% of accesses hit the hottest 20% of keys (sorted by index as "hotness proxy"),
|
||||
/// 20% of accesses hit the remaining 80%.
|
||||
/// This models matrix computation where a small panel working set is reused heavily.
|
||||
/// </summary>
|
||||
private static nint[] GenerateZipfianLookups(
|
||||
nint[] sourceKeys,
|
||||
int count,
|
||||
Random rng
|
||||
)
|
||||
{
|
||||
int hotSetSize = Math.Max(1, sourceKeys.Length / 5);
|
||||
nint[] lookups = new nint[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
if (rng.NextDouble() < 0.8)
|
||||
{
|
||||
lookups[i] = sourceKeys[rng.Next(0, hotSetSize)];
|
||||
}
|
||||
else
|
||||
{
|
||||
lookups[i] = sourceKeys[rng.Next(hotSetSize, sourceKeys.Length)];
|
||||
}
|
||||
}
|
||||
return lookups;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Generate uniform random lookup sequence (baseline for comparison with Zipfian).
|
||||
/// </summary>
|
||||
private static nint[] GenerateUniformLookups(
|
||||
nint[] sourceKeys,
|
||||
int count,
|
||||
Random rng
|
||||
)
|
||||
{
|
||||
nint[] lookups = new nint[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
lookups[i] = sourceKeys[rng.Next(0, sourceKeys.Length)];
|
||||
}
|
||||
return lookups;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Generate a steady-state operation script.
|
||||
/// Each entry: non-negative value = index into _residentKeys (lookup/hit),
|
||||
/// negative value (-1) = cache miss trigger (evict → insert → lookup).
|
||||
/// Lookup indices are Zipfian-skewed.
|
||||
/// </summary>
|
||||
private static int[] GenerateSteadyStateScript(
|
||||
int keyCount,
|
||||
int opCount,
|
||||
double missRate,
|
||||
Random rng
|
||||
)
|
||||
{
|
||||
int hotSetSize = Math.Max(1, keyCount / 5);
|
||||
int[] script = new int[opCount];
|
||||
for (int i = 0; i < opCount; i++)
|
||||
{
|
||||
if (rng.NextDouble() < missRate)
|
||||
{
|
||||
script[i] = -1; // miss
|
||||
}
|
||||
else
|
||||
{
|
||||
// Zipfian hit
|
||||
if (rng.NextDouble() < 0.8)
|
||||
{
|
||||
script[i] = rng.Next(0, hotSetSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
script[i] = rng.Next(hotSetSize, keyCount);
|
||||
}
|
||||
}
|
||||
}
|
||||
return script;
|
||||
}
|
||||
|
||||
/// <summary> Fisher-Yates shuffle. </summary>
|
||||
private static void Shuffle(
|
||||
int[] array,
|
||||
Random rng
|
||||
)
|
||||
{
|
||||
for (int i = array.Length - 1; i > 0; i--)
|
||||
{
|
||||
int j = rng.Next(0, i + 1);
|
||||
(array[i], array[j]) = (array[j], array[i]);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user