stgsharp/StgSharpDebug/Program.cs

//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="Program.cs"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. 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.
//     
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
using StgSharp.Collections;
using StgSharp.Controlling.UsrActivity;
using StgSharp.Geometries;
using StgSharp.Graphics;
using StgSharp.HighPerformance.Memory;
using StgSharp.Mathematics;
using StgSharp.Model.Step;
using StgSharp.MVVM;
using StgSharp.MVVM.ViewModel;
using StgSharp.Script;
using StgSharp.Script.Express;

using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.X86;
using System.Threading;
using System.Xml.XPath;

namespace StgSharp
{
    internal static partial class Program
    {

        private static string testExpPath = @"D:\Programmer\stepcode\data\ap203\ap203.exp";

        internal static unsafe void Main(string[] args)
        {
            /*
            try
            {
                /**/
            World.Init();

            Console.WriteLine("StgSharp 内存分配器综合性能评估系统");
            Console.WriteLine("===============================================\n");

            // HLSF test arena (保留原始测试)
            Console.WriteLine($"\n{new string('=', 80)}");
            Console.WriteLine(
                    "=== HLSF (Hybrid Layer Segregated Fit Allocator) Original Stress Test ===\n");


            // 使用适中的内存池大小
            HybridLayerSegregatedFitAllocator hlsfAllocator = new HybridLayerSegregatedFitAllocator(16 * 1024 * 1024);

            Console.WriteLine("开始单线程压力测试...\n");


            // 单线程压力测试：适度的分配和释放操作
            int totalCycles = 5;
            int allocationsPerCycle = 1024 * 64; // 65536 次分配

            for (int cycle = 0; cycle < totalCycles; cycle++)
            {
                Console.WriteLine($"\n=== 第 {cycle + 1} 轮压力测试 ===");

                // 预生成随机数
                uint[] randomSizes = new uint[allocationsPerCycle];
                Random random = new Random(cycle);
                for (int i = 0; i < allocationsPerCycle; i++) {
                    randomSizes[i] = (uint)(64 + random.Next(1024 - 64 + 1));
                }

                // 分配阶段
                List<HybridLayerSegregatedFitAllocationHandle> handles = new List<HybridLayerSegregatedFitAllocationHandle>(allocationsPerCycle);
                Stopwatch stopwatch = Stopwatch.StartNew();

                for (int i = 0; i < allocationsPerCycle; i++) {
                    handles.Add(hlsfAllocator.Alloc(randomSizes[i]));
                }

                stopwatch.Stop();
                Console.WriteLine($"分配完成，总计分配 {handles.Count} 个块");
                Console.WriteLine($"分配耗时: {stopwatch.ElapsedMilliseconds} ms");
                if (stopwatch.ElapsedMilliseconds > 0) {
                    Console.WriteLine($"分配速度: {allocationsPerCycle * 1000 / stopwatch.ElapsedMilliseconds} allocs/sec");
                }


                // 随机释放阶段
                stopwatch.Restart();

                for (int i = handles.Count - 1; i >= 0; i--) {
                    hlsfAllocator.Free(handles[i]);
                }

                stopwatch.Stop();
                Console.WriteLine($"释放完成，总计释放 {handles.Count} 个块");
                Console.WriteLine($"释放耗时: {stopwatch.ElapsedMilliseconds} ms");
                if (stopwatch.ElapsedMilliseconds > 0) {
                    Console.WriteLine($"释放速度: {handles.Count * 1000 / stopwatch.ElapsedMilliseconds} frees/sec");
                }

                handles.Clear();
            }

            Console.WriteLine("\n=== 边界测试 ===");


            // 测试最小分配
            Console.WriteLine("测试最小分配 (64字节)...");
            List<HybridLayerSegregatedFitAllocationHandle> minHandles = new List<HybridLayerSegregatedFitAllocationHandle>();
            for (int i = 0; i < 1000; i++) {
                minHandles.Add(hlsfAllocator.Alloc(64));
            }
            foreach (HybridLayerSegregatedFitAllocationHandle handle in minHandles) {
                hlsfAllocator.Free(handle);
            }
            Console.WriteLine("最小分配测试完成");

            // 测试最大分配
            Console.WriteLine("测试最大分配 (1024字节)...");
            List<HybridLayerSegregatedFitAllocationHandle> maxHandles = new List<HybridLayerSegregatedFitAllocationHandle>();
            for (int i = 0; i < 1000; i++) {
                maxHandles.Add(hlsfAllocator.Alloc(1024));
            }
            foreach (HybridLayerSegregatedFitAllocationHandle handle in maxHandles) {
                hlsfAllocator.Free(handle);
            }
            Console.WriteLine("最大分配测试完成");

            // 测试混合大小分配
            Console.WriteLine("测试混合大小分配...");
            List<HybridLayerSegregatedFitAllocationHandle> mixedHandles = new List<HybridLayerSegregatedFitAllocationHandle>();
            uint[] testSizes = {
                64, 128, 256, 512, 1024
            };
            for (int i = 0; i < 2000; i++)
            {
                uint size = testSizes[i % testSizes.Length];
                mixedHandles.Add(hlsfAllocator.Alloc(size));
            }
            foreach (HybridLayerSegregatedFitAllocationHandle handle in mixedHandles) {
                hlsfAllocator.Free(handle);
            }
            Console.WriteLine("混合大小分配测试完成");

            Console.WriteLine("\n所有测试完成！HLSF分配器表现良好。");
            Console.WriteLine("按任意键退出...");
            Console.ReadKey();
            /*
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
                World.Terminate(-1);
            }
            finally
            {
                World.Terminate(0);
            }
                /**/
        }

    }
}