Unity&DeepSeek开发简易AI对话助手

# Benchmark Framework ## Table of Contents - [Overview and Features](#overview-and-features) - [Using the Framework](#using-the-framework) - [Attribute Summary](#attribute-summary) - [Example](#example) - [Glue Layer - Native Containers](#glue-layer---native-containers) - [Performance and Benchmark Tests - Native Containers](#performance-and-benchmark-tests---native-containers) - [Results](#results) ## Overview and Features The Benchmark Framework is a complimentary framework to the Performance Test Framework. It provides a means to write a code for performance tests *one time* for a given type while providing the following benefits: - Both benchmarks comparisons and performance/regression testing from a single implementation - A managed execution path (JIT) from the same single implementation - A Burst compiled *with safety* path from the same single implementation - A Burst compiled *without safety* path from the same single implementation - Automatically generate markdown formatted documentation for the Benchmark results - Provide a simple means for running benchmarks through custom menu items with easily trackable progress and ability to cancel at any time For the Benchmark Framework itself, tests can be designed to easily group together multiple variations for comparison. For example, the list above may apply to: - An implementation for Native containers - Another implementation for Unsafe containers - And yet another implementation for the container types included in .NET/Mono/IL2CPP Base Class Libraries Finally, test implementations may be classified such as: - Only test for benchmarking, but not for performance/regression testing (such as managed BCL containers) - Consider an implementation variation as the baseline, and compare all other implementation variations against it - Include only a subset of implementation in case there is a gap in functionality (intentional or not) at this time <br/> --- ## Using the Framework To take advantage of the features above and write tests for the Benchmark Framework, three components are required: 1. The Benchmark Framework itself which works alongside the Performance Test Framework 2. An intermediate 'glue' layer for a given benchmark comparison type i.e. BenchmarkContainer, BenchmarkAllocator 3. The Performance Tests themselves, using the intermediate layer from #2 above Because #1 is provided by the Framework here, the rest of this documentation will give an example of using it to create a 'glue' layer and then a performance test which makes use of this example 'glue' layer. ### Attribute Summary Most (but not *quite* all) interaction with the Benchmark Framework will occur through its attributes. These are all defined in the `Unity.PerformanceTesting.Benchmark` namespace. A summary will be given here, but further details can be found in the inline code documentation. As mentioned, a small example demonstrating their use will follow. |Attribute|Description| |---|---| |**`[Benchmark]`**|This marks a class containing performance tests to be used in Benchmark Comparison report generation.| |**`[BenchmarkComparison]`**|This marks an enum as defining the variants that will be generated and simultaneously covers both the Performance Test Framework tests as well as Benchmark Framework tests. *Optionally, this can define the Benchmark baseline if it is also a Performance Test Framework measurement.*| |**`[BenchmarkComparisonExternal]`**|Used on the same enum definition, this associates non-enum values with the enum for Benchmark Framework tests which *are not* to be included in Performance Test Framework tests. *Optionally, this can define the Benchmark baseline if it is not a Performance Test Framework measurement.*| |**`[BenchmarkComparisonDisplay]`**|Also used on the same enum definition, this overrides the default measurement sample unit (millisecond, microsecond, etc.), the decimal places for Benchmark report generation, and the ranking statistic for Benchmark report generation (median, minimum, etc.).| |**`[BenchmarkName]`**|Required with each enum value, this describes a formatting string for naming Benchmark result variations when a report is generated, such as `[BenchmarkName("Native{0}")]`, which when used with a `[Benchmark]` attributed class such as `HashSet`, would generate a the name "NativeHashSet"| |**`[BenchmarkNameOverride]`**|Override the formatted name in case the class doesn't precisely represent the name that should appear in reports.| |**`[BenchmarkTestFootnote]`**|Generate a footnote in the Benchmark Comparison report for a given Performance Test method. When used, the footnote will always include a description of the method and its parameters. Optionally, user-defined footnote text may be specified as well.| Generally, `[Benchmark]`, `[BenchmarkNameOverride]`, and `[BenchmarkTestFootnote]` will be used while writing tests. The rest are used solely in the 'glue' layer, so if you are writing tests on top of a pre-existing 'glue' layer, you will be unlikely to need or use them. <br/> --- ## Example ### Glue Layer - Native Containers This will illustrate a simplified version of the com.unity.collections `BenchmarkContainer` implementation as an example of creating an intermediate 'glue' layer between the Benchmark Framework and user-defined performance tests. 1. The first requirement is an `enum` type which defines the test variations that will be benchmarked. Values defined in the enum will also generate Performance Test Framework tests used in regression testing and performance analysis. Values defined through the `[BenchmarkComparison]` attribute will only appear in Benchmark reports.<br/><br/> You'll notice two attributes used. `[BenchmarkComparison]` denotes this `enum` will be used for benchmarking as well as indicates an externally defined comparison type (BCL) as the baseline to benchmark against, and `[BenchmarkComparisonDisplay]` overrides the default format for report generation and the statistic used for comparison.<br/><br/> It's worth pointing out that the `{0}` in the name strings will be replaced with the name of the test group, such as `HashSet` or `List`. This also references a `MyExampleConfig` for convenience and consistency which will be defined next. ``` [BenchmarkComparison(MyExampleConfig.BCL, "{0} (BCL)")] [BenchmarkComparisonDisplay(SampleUnit.Millisecond, 3, BenchmarkRankingStatistic.Median)] public enum MyExampleType : int { [BenchmarkName("Native{0}")] Managed, [BenchmarkName("Native{0} (B)")] BurstCompiled, } ``` 2. The configuration class is not a requirement, but rather it is a recommended pattern for storing common data for all tests as well as the interface (in this case a menu item) for running benchmarks and generating the resulting markdown file.<br/><br/> The main takeaway here is the call to `GenerateMarkdown` which also runs the benchmark tests. Specifically, the argument `typeof(MyExampleType)` refers to the above defined comparison `enum`, and this call will find all the types with a `[Benchmark(typeof(MyExampleType))]` attribute and their methods with the combined `[Test]` and `[Performance]` attributes discover and run benchmark tests. More on this later with the example performance tests which will be benchmarked. ``` public static class MyExampleConfig { public const int BCL = -1; internal const int kCountWarmup = 5; internal const int kCountMeasure = 10; #if UNITY_EDITOR [UnityEditor.MenuItem("Benchmark Example/Generate My Benchmarks")] #endif static void RunBenchmarks() => BenchmarkGenerator.GenerateMarkdown( "Containers Example", typeof(MyExampleType), "Temp/performance-comparison-example.md", $"Example benchmark - {kCountMeasure} runs after {kCountWarmup} warmup runs", "Legend", new string[] {