仿真平台内核初版 -tlib库 包含<sparc arm riscv powerPC>

lib/Migrant/PerformanceTester/TestRunner.cs

@@ -0,0 +1,109 @@
+//
+// Copyright (c) 2012-2021 Antmicro
+//
+// This file is licensed under the MIT License.
+// Full license text is available in the LICENSE file.
+
+using System;
+using System.IO;
+using System.Linq;
+using System.Diagnostics;
+using Antmicro.Migrant.PerformanceTester.Tests;
+using Antmicro.Migrant.PerformanceTester.Serializers;
+using Antmicro.Migrant;
+using System.Collections.Generic;
+
+namespace Antmicro.Migrant.PerformanceTester
+{
+    public class TestRunner
+    {
+        public TestRunner(TestType testType, SerializerType serializerType)
+        {
+            this.testType = testType;
+            serializer = SerializerFactory.Produce(serializerType);
+        }
+
+        public TestResult Run<T>(ITest<T> test)
+        {
+            var stream = new MemoryStream();
+            if(testType == TestType.Serialization)
+            {
+                return Run(
+                    () => serializer.Serialize(test.Object, stream),
+                    after: () => stream.Seek(0, SeekOrigin.Begin));
+            }
+            else
+            {
+                serializer.Serialize(test.Object, stream);
+                return Run(() =>
+                    serializer.Deserialize<T>(stream),
+                    before: () => stream.Seek(0, SeekOrigin.Begin));
+            }
+        }
+
+        private static TestResult Run(Action whatToRun, Action before = null, Action after = null)
+        {
+            before = before ?? new Action(() => {});
+            after = after ?? new Action(() => {});
+
+            PrintProgress("warming up...");
+            for(var i = 0; i < WarmUpRounds; i++)
+            {
+                before();
+                whatToRun();
+                after();
+            }
+
+            var rounds = 0;
+            var results = new List<double>();
+            while(true)
+            {
+                before();
+                results.Add(Measure(whatToRun));
+                after();
+                rounds++;
+                if(rounds < MinimalNumberOfRounds)
+                {
+                    PrintProgress(string.Format("Round {0}.", rounds));
+                }
+                else
+                {
+                    var average = results.Skip(results.Count - MinimalNumberOfRounds).Average();
+                    var deviation = results.Skip(results.Count - MinimalNumberOfRounds).StandardDeviation();
+                    var percentDeviation = deviation/average;
+                    PrintProgress(string.Format("Round {1}, {0:#0.#}% deviation.", percentDeviation*100.0, rounds));
+                    if(percentDeviation < DesiredDeviation)
+                    {
+                        PrintProgress("done.");
+                        Console.WriteLine();
+                        return new TestResult(average, deviation);
+                    }
+                }
+            }
+        }
+
+        private static double Measure(Action whatToRun)
+        {
+            var stopwatch = Stopwatch.StartNew();
+            whatToRun();
+            stopwatch.Stop();
+            return stopwatch.Elapsed.TotalSeconds;
+        }
+
+        private static void PrintProgress(string what)
+        {
+            Console.CursorLeft = 0;
+            Console.Write(Enumerable.Repeat(" ", Console.BufferWidth - 1).Aggregate((x, y) => x + y));
+            Console.CursorLeft = 0;
+            Console.Write("Running... {0}", what);
+        }
+
+        private readonly TestType testType;
+        private readonly ISerializer serializer;
+
+        private const int WarmUpRounds = 2;
+        private const int MinimalNumberOfRounds = 7;
+        private const double DesiredDeviation = 0.05;
+    }
+}
+