260 lines
10 KiB
C#
260 lines
10 KiB
C#
//-----------------------------------------------------------------------
|
|
// -----------------------------------------------------------------------
|
|
// file="HlsfStressTest"
|
|
// Project: StgSharp
|
|
// AuthorGroup: Nitload
|
|
// Copyright (c) Nitload. All rights reserved.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in all
|
|
// copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
// SOFTWARE.
|
|
//
|
|
// -----------------------------------------------------------------------
|
|
// -----------------------------------------------------------------------
|
|
// -----------------------------------------------------------------------
|
|
// file="HlsfStressTest" (performance benchmark)
|
|
// Project: StgSharp
|
|
// -----------------------------------------------------------------------
|
|
using StgSharp.HighPerformance.Memory;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
|
|
namespace StgSharp
|
|
{
|
|
internal static class HlsfStressTest
|
|
{
|
|
|
|
private const uint MaxAllocSize = 32 * 1024 * 1024; // 32MB documented cap
|
|
|
|
// Allow overriding arena size via env HLSF_ARENA_MB (must be >=64MB)
|
|
private static readonly ulong ArenaBytes = Environment.GetEnvironmentVariable("HLSF_ARENA_MB") is string mbStr &&
|
|
int.TryParse(mbStr, out int mb) &&
|
|
mb >= 64 ?
|
|
(ulong)mb * 1024UL * 1024UL :
|
|
3UL * 1024UL * 1024UL * 1024UL;
|
|
|
|
private static readonly uint[] SizeSweep = {
|
|
64, 128, 192, 256, 512, 768, 1024, 2048, 3072, 4096, 8192, 12288, 16384, 32768, 49152, 65536, 131072, 196608, 262144, 524288, 786432, 1_048_576, 2_097_152, 3_145_728, 4_194_304, 8_388_608, 12_582_912, 16_777_216, 25_165_824, 33_554_432
|
|
};
|
|
|
|
public static unsafe void Run()
|
|
{
|
|
Console.WriteLine("=== HLSF Allocator Single-Thread Performance Benchmark ===");
|
|
Console.WriteLine($"Arena size: {ArenaBytes / (1024 * 1024)} MiB (env override: HLSF_ARENA_MB)");
|
|
using HybridLayerSegregatedFitAllocator allocator = new HybridLayerSegregatedFitAllocator((nuint)ArenaBytes);
|
|
|
|
Warmup(allocator);
|
|
|
|
Console.WriteLine();
|
|
Console.WriteLine("[1] Allocation throughput (no touch)");
|
|
foreach (uint sz in SizeSweep)
|
|
{
|
|
uint size = sz > MaxAllocSize ? MaxAllocSize : sz;
|
|
BenchAllocThroughput(allocator, size, touch:false);
|
|
GC.Collect();
|
|
GC.WaitForPendingFinalizers();
|
|
}
|
|
|
|
Console.WriteLine();
|
|
Console.WriteLine("[2] Allocation throughput (touch first byte)");
|
|
foreach (uint sz in SizeSweep)
|
|
{
|
|
uint size = sz > MaxAllocSize ? MaxAllocSize : sz;
|
|
BenchAllocThroughput(allocator, size, touch:true);
|
|
GC.Collect();
|
|
GC.WaitForPendingFinalizers();
|
|
}
|
|
|
|
Console.WriteLine();
|
|
Console.WriteLine("[3] Free throughput after pre-allocation (256k blocks of 1KB)");
|
|
BenchFreeThroughput(allocator, 256 * 1024, 1024);
|
|
|
|
Console.WriteLine();
|
|
Console.WriteLine("[4] Alloc+Immediate Free pairs (5,000,000 x 256B)");
|
|
BenchAllocFreePairs(allocator, 5_000_000, 256);
|
|
|
|
Console.WriteLine();
|
|
Console.WriteLine("[5] Fragmentation cycle (allocate ~1024MB random, free half, reallocate)");
|
|
BenchFragmentationCycle(allocator, 1024);
|
|
|
|
Console.WriteLine();
|
|
Console.WriteLine("=== Benchmark Complete ===");
|
|
}
|
|
|
|
private static void BenchAllocFreePairs(
|
|
HybridLayerSegregatedFitAllocator allocator,
|
|
int pairs,
|
|
uint blockSize)
|
|
{
|
|
Stopwatch sw = Stopwatch.StartNew();
|
|
for (int i = 0; i < pairs; i++)
|
|
{
|
|
HybridLayerSegregatedFitAllocationHandle h = allocator.Alloc(blockSize);
|
|
allocator.Free(h);
|
|
}
|
|
sw.Stop();
|
|
double opsPerSec = pairs / sw.Elapsed.TotalSeconds;
|
|
Console.WriteLine($" size={Fmt(blockSize),7} pairs={pairs,9} alloc+free/s={opsPerSec,12:0.0}");
|
|
}
|
|
|
|
private static void BenchAllocThroughput(
|
|
HybridLayerSegregatedFitAllocator allocator,
|
|
uint blockSize,
|
|
bool touch)
|
|
{
|
|
ulong budget = ArenaBytes / 2; // use half arena for test
|
|
if (blockSize == 0) {
|
|
return;
|
|
}
|
|
|
|
long ops = (long)(budget / blockSize);
|
|
ops = Math.Min(ops, blockSize >= (4 * 1024 * 1024) ? 2048 : 2_000_000);
|
|
if (ops <= 0) {
|
|
return;
|
|
}
|
|
|
|
List<HybridLayerSegregatedFitAllocationHandle> list = new List<HybridLayerSegregatedFitAllocationHandle>((int)ops);
|
|
Stopwatch sw = Stopwatch.StartNew();
|
|
for (long i = 0; i < ops; i++)
|
|
{
|
|
HybridLayerSegregatedFitAllocationHandle h = allocator.Alloc(blockSize);
|
|
if (touch)
|
|
{
|
|
Span<byte> span = h.BufferHandle;
|
|
if (!span.IsEmpty) {
|
|
span[0] = (byte)(i & 0xFF);
|
|
}
|
|
}
|
|
list.Add(h);
|
|
}
|
|
sw.Stop();
|
|
double allocOpsPerSec = ops / sw.Elapsed.TotalSeconds;
|
|
foreach (HybridLayerSegregatedFitAllocationHandle h in list) {
|
|
allocator.Free(h);
|
|
}
|
|
|
|
Console.WriteLine($" size={Fmt(blockSize),7} ops={ops,9} alloc/s={allocOpsPerSec,12:0.0} touch={touch}");
|
|
}
|
|
|
|
private static void BenchFragmentationCycle(
|
|
HybridLayerSegregatedFitAllocator allocator,
|
|
int targetMiB)
|
|
{
|
|
int targetBytes = targetMiB * 1024 * 1024;
|
|
Random rng = new Random(123);
|
|
List<HybridLayerSegregatedFitAllocationHandle> live = new List<HybridLayerSegregatedFitAllocationHandle>(128 * 1024);
|
|
long allocated = 0;
|
|
Stopwatch swA = Stopwatch.StartNew();
|
|
while (allocated < targetBytes)
|
|
{
|
|
uint sz = PickSize(rng);
|
|
HybridLayerSegregatedFitAllocationHandle h = allocator.Alloc(sz);
|
|
live.Add(h);
|
|
allocated += sz;
|
|
}
|
|
swA.Stop();
|
|
Console.WriteLine($" phaseA alloc {targetMiB}MB in {swA.Elapsed.TotalSeconds:0.00}s blocks={live.Count}");
|
|
|
|
Stopwatch swB = Stopwatch.StartNew();
|
|
int freed = 0;
|
|
for (int i = live.Count - 1; i >= 0; i -= 2)
|
|
{
|
|
allocator.Free(live[i]);
|
|
live.RemoveAt(i);
|
|
freed++;
|
|
}
|
|
swB.Stop();
|
|
Console.WriteLine($" phaseB freed {freed} in {swB.Elapsed.TotalSeconds:0.00}s remain={live.Count}");
|
|
|
|
allocated = 0;
|
|
int reCount = 0;
|
|
Stopwatch swC = Stopwatch.StartNew();
|
|
while (allocated < targetBytes / 2)
|
|
{
|
|
uint sz = PickSize(rng);
|
|
HybridLayerSegregatedFitAllocationHandle h = allocator.Alloc(sz);
|
|
live.Add(h);
|
|
allocated += sz;
|
|
reCount++;
|
|
}
|
|
swC.Stop();
|
|
Console.WriteLine($" phaseC re-alloc {reCount} in {swC.Elapsed.TotalSeconds:0.00}s ~{allocated / (1024.0 * 1024.0):0}MB");
|
|
|
|
Stopwatch swD = Stopwatch.StartNew();
|
|
foreach (HybridLayerSegregatedFitAllocationHandle h in live) {
|
|
allocator.Free(h);
|
|
}
|
|
|
|
swD.Stop();
|
|
Console.WriteLine($" cleanup freed {live.Count} in {swD.Elapsed.TotalSeconds:0.00}s");
|
|
}
|
|
|
|
private static void BenchFreeThroughput(
|
|
HybridLayerSegregatedFitAllocator allocator,
|
|
int count,
|
|
uint blockSize)
|
|
{
|
|
List<HybridLayerSegregatedFitAllocationHandle> list = new List<HybridLayerSegregatedFitAllocationHandle>(count);
|
|
for (int i = 0; i < count; i++) {
|
|
list.Add(allocator.Alloc(blockSize));
|
|
}
|
|
|
|
Stopwatch sw = Stopwatch.StartNew();
|
|
for (int i = 0; i < count; i++) {
|
|
allocator.Free(list[i]);
|
|
}
|
|
|
|
sw.Stop();
|
|
double freesPerSec = count / sw.Elapsed.TotalSeconds;
|
|
Console.WriteLine($" size={Fmt(blockSize),7} count={count,9} free/s={freesPerSec,12:0.0}");
|
|
}
|
|
|
|
private static string Fmt(uint bytes)
|
|
{
|
|
if (bytes >= 1024 * 1024) {
|
|
return $"{bytes / (1024 * 1024)}MB";
|
|
}
|
|
|
|
if (bytes >= 1024) {
|
|
return $"{bytes / 1024}KB";
|
|
}
|
|
|
|
return $"{bytes}B";
|
|
}
|
|
|
|
private static uint PickSize(Random rng)
|
|
{
|
|
uint raw = SizeSweep[rng.Next(SizeSweep.Length)];
|
|
return raw > MaxAllocSize ? MaxAllocSize : raw;
|
|
}
|
|
|
|
private static void Warmup(HybridLayerSegregatedFitAllocator allocator)
|
|
{
|
|
List<HybridLayerSegregatedFitAllocationHandle> tmp = new List<HybridLayerSegregatedFitAllocationHandle>(4096);
|
|
for (int i = 0; i < 4096; i++) {
|
|
tmp.Add(allocator.Alloc(256));
|
|
}
|
|
|
|
foreach (HybridLayerSegregatedFitAllocationHandle h in tmp) {
|
|
allocator.Free(h);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|