Merge branch 'release/v2.1.0'

.nuke/build.schema.json

@@ -7,7 +7,7 @@
       "type": "object",
       "properties": {
         "BuildNo": {
-          "type": "string",
+          "type": "integer",
           "description": "The Buildnumber provided by the CI"
         },
         "Configuration": {
@@ -74,6 +74,10 @@
           "type": "string",
           "description": "Root directory during build execution"
         },
+        "RunTests": {
+          "type": "boolean",
+          "description": "Run UnitTests on build"
+        },
         "Skip": {
           "type": "array",
           "description": "List of targets to be skipped. Empty list skips all dependencies",

CHANGELOG.md

@@ -6,14 +6,23 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## vNext
 ### Added
-- 
+- ThreadBehaviour to define how a thread is created
+- Allow benchmarks to be run on the MainThread
 
 ### Changed
-- 
+- Added IDisposable to IThreadSessionHandler
 
 ### Fixed
 - 
 
+## v2.1.0
+### Added
+- ThreadBehaviour to define how a thread is created
+- Allow benchmarks to be run on the MainThread
+
+### Changed
+- Added IDisposable to IThreadSessionHandler
+
 ## v2.0.2
 ### Added
 - Added Benchmarks and samples oh how to use the BenchmarkRunner

appveyor.yml

@@ -1,7 +1,7 @@
 # http://www.appveyor.com/docs/appveyor-yml
 
 environment:
-  base_version: 2.0.2
+  base_version: 2.0.3
 
 # version format
 version: $(base_version).{build}

build/Build.cs

@@ -38,14 +38,17 @@ class Build : NukeBuild
     [GitRepository] readonly GitRepository GitRepository;
 
     [Parameter("Version to be injected in the Build")]
-    public string Version { get; set; } = $"2.0.2";
+    public string Version { get; set; } = $"2.1.0";
 
     [Parameter("The Buildnumber provided by the CI")]
-    public string BuildNo = "1";
+    public int BuildNo = 6;
 
     [Parameter("Is RC Version")]
     public bool IsRc = false;
 
+    [Parameter("Run UnitTests on build")]
+    public bool RunTests = true;
+
     AbsolutePath SourceDirectory => RootDirectory / "src";
 
     AbsolutePath TestsDirectory => RootDirectory / "src" / "tests";
@@ -89,6 +92,11 @@ class Build : NukeBuild
         .DependsOn(Compile)
         .Executes(() =>
         {
+            if (!RunTests)
+            {
+                return;
+            }
+
             DotNetTest(s => s
                 .SetProjectFile(Solution)
                 .SetConfiguration(Configuration)
@@ -131,6 +139,6 @@ class Build : NukeBuild
         });
 
     string PackageVersion 
-        => IsRc ? int.Parse(BuildNo) < 10 ? $"{Version}-RC0{BuildNo}" : $"{Version}-RC{BuildNo}" : Version;
+        => IsRc ? BuildNo < 10 ? $"{Version}-RC0{BuildNo}" : $"{Version}-RC{BuildNo}" : Version;
 
 }

build/_build.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <RootNamespace></RootNamespace>
     <NoWarn>CS0649;CS0169</NoWarn>
     <NukeRootDirectory>..</NukeRootDirectory>

src/MeasureMap/BenchmarkRunnerExtensions.cs

@@ -76,5 +76,18 @@ public static BenchmarkRunner SetMinLogLevel(this BenchmarkRunner runner, LogLev
             runner.Settings.Logger.MinLogLevel = level;
             return runner;
         }
+
+        /// <summary>
+        /// Set the <see cref="ThreadBehaviour"/> to the settings of the <see cref="BenchmarkRunner"/>.<br></br>
+        /// Using <see cref="ThreadBehaviour.RunOnMainThread"/> overwrites the ThreadingHandler defined in each ProfilerSession that is run in the Benchmark.
+        /// </summary>
+        /// <param name="runner"></param>
+        /// <param name="behaviour"></param>
+        /// <returns></returns>
+        public static BenchmarkRunner SetThreadBehaviour(this BenchmarkRunner runner, ThreadBehaviour behaviour)
+        {
+            runner.Settings.ThreadBehaviour = behaviour;
+            return runner;
+        }
     }
 }

src/MeasureMap/ExecutionContext.cs

@@ -22,20 +22,14 @@ public ExecutionContext()
         /// </summary>
         public ExecutionContext(IProfilerSettings settings)
         {
-            Threads = new ThreadList();
             Settings = settings;
         }
 
         /// <summary>
         /// The data store for the context
         /// </summary>
         public IDictionary<string, object> SessionData { get; } = new Dictionary<string, object>();
-
-        /// <summary>
-        /// Gets a list containing all threads that are associated with this run
-        /// </summary>
-        public IThreadList Threads { get; set; }
-
+
         /// <summary>
         /// Gets the settings associated with the session
         /// </summary>
@@ -140,10 +134,7 @@ public static IExecutionContext Clear(this IExecutionContext context)
         /// <returns></returns>
         public static IExecutionContext Clone(this IExecutionContext context)
         {
-            var child = new ExecutionContext(context.Settings)
-            {
-                Threads = context.Threads
-            };
+            var child = new ExecutionContext(context.Settings);
 
             foreach(var item in context.SessionData)
             {

src/MeasureMap/IExecutionContext.cs

@@ -1,5 +1,4 @@
 using MeasureMap.Diagnostics;
-using MeasureMap.Threading;
 using System.Collections.Generic;
 
 namespace MeasureMap
@@ -13,12 +12,7 @@ public interface IExecutionContext
         /// The data store for the context
         /// </summary>
         IDictionary<string, object> SessionData { get; }
-
-        /// <summary>
-        /// Gets a list containing all threads that are associated with this run
-        /// </summary>
-        IThreadList Threads { get; }
-
+
         /// <summary>
         /// Gets the settings associated with the session
         /// </summary>

src/MeasureMap/ProfilerSession.cs

@@ -73,11 +73,10 @@ public static ProfilerSession StartSession()
         /// Sets the amount of threads that the profiling sessions should run in.
         /// All iterations are run on every thread.
         /// </summary>
-        /// <param name="thredCount">The amount of threads that the task is run on</param>
         /// <returns>The current profiling session</returns>
-        public ProfilerSession SetThreads(int thredCount)
+        public ProfilerSession SetExecutionHandler(IThreadSessionHandler handler)
         {
-            _executor = new MultyThreadSessionHandler(thredCount);
+            _executor = handler;
 
             return this;
         }
@@ -172,10 +171,7 @@ public void Dispose()
         /// <param name="disposing"></param>
         protected virtual void Dispose(bool disposing)
         {
-            if (_executor is MultyThreadSessionHandler handler)
-            {
-                handler.DisposeThreads();
-            }
+            _executor.Dispose();
         }
     }
 }

src/MeasureMap/ProfilerSessionExtensions.cs

@@ -78,6 +78,38 @@ public static ProfilerSession Task<T>(this ProfilerSession session, Func<IExecut
             return session;
         }
 
+        /// <summary>
+        /// Sets the amount of threads that the profiling sessions should run in.
+        /// All iterations are run on every thread.
+        /// </summary>
+        /// <param name="session"></param>
+        /// <param name="thredCount">The amount of threads that the task is run on</param>
+        /// <returns>The current profiling session</returns>
+        public static ProfilerSession SetThreads(this ProfilerSession session, int thredCount)
+        {
+            session.SetExecutionHandler(new MultyThreadSessionHandler(thredCount));
+
+            return session;
+        }
+
+        /// <summary>
+        /// Set the <see cref="ThreadBehaviour"/> to the settings of the <see cref="ProfilerSession"/>
+        /// </summary>
+        /// <param name="session"></param>
+        /// <param name="behaviour"></param>
+        /// <returns></returns>
+        public static ProfilerSession SetThreadBehaviour(this ProfilerSession session, ThreadBehaviour behaviour)
+        {
+            session.Settings.ThreadBehaviour = behaviour;
+
+            if (behaviour == ThreadBehaviour.RunOnMainThread)
+            {
+                session.SetExecutionHandler(new MainThreadSessionHandler());
+            }
+
+            return session;
+        }
+
         /// <summary>
         /// Sets the amount of iterations that the profileing session should run the task
         /// </summary>
@@ -140,6 +172,13 @@ public static ProfilerSession RunWarmup(this ProfilerSession session, bool run)
         public static ProfilerSession SetSettings(this ProfilerSession session, ProfilerSettings settings)
         {
             settings.MergeChangesTo(session.Settings);
+
+            if(session.Settings.ThreadBehaviour != ThreadBehaviour.Thread)
+            {
+                // ensure the ThreadBehaviour is set when using the new settings
+                // this is only set when using the default ThreadBehaviour in a ProfilerSession
+                session.SetThreadBehaviour(session.Settings.ThreadBehaviour);
+            }
 
             return session;
         }

src/MeasureMap/ProfilerSettings.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using MeasureMap.Diagnostics;
 using MeasureMap.Runners;
+using MeasureMap.Threading;
 
 namespace MeasureMap
 {
@@ -15,6 +16,7 @@ public class ProfilerSettings : IProfilerSettings
         private int _iterations = 1;
         private bool _runWarmup = true;
         private TimeSpan _duration = TimeSpan.Zero;
+        private ThreadBehaviour _threadBehaviour = ThreadBehaviour.Thread;
 
         /// <summary>
         /// 
@@ -70,6 +72,19 @@ public bool RunWarmup
             }
         }
 
+        /// <summary>
+        /// Defines the way threads are created
+        /// </summary>
+        public ThreadBehaviour ThreadBehaviour
+        {
+            get => _threadBehaviour;
+            set
+            {
+                _threadBehaviour = value;
+                AddChange("threadBehaviour", s => s.ThreadBehaviour, (s, v) => s.ThreadBehaviour = v);
+            }
+        }
+
         /// <summary>
         /// Gets the <see cref="ITaskRunner"/> that is used to run the tasks
         /// </summary>
@@ -82,13 +97,15 @@ public bool RunWarmup
 
         private void AddChange<T>(string property, Func<ProfilerSettings, T> func, Action<ProfilerSettings, T> action)
         {
-            _changes[property] = (origSet, newSet) => action(origSet, func(newSet));
+            _changes[property] = (toSet, fromSet) => action(toSet, func(fromSet));
         }
 
         internal void MergeChangesTo(ProfilerSettings settings)
         {
             foreach (var action in _changes.Values)
             {
+                // settings = to
+                // this = from
                 action(settings, this);
             }
         }

src/MeasureMap/ProfilerSettingsExtensions.cs

@@ -0,0 +1,26 @@
+using MeasureMap.Threading;
+using System;
+
+namespace MeasureMap
+{
+    /// <summary>
+    /// Extensions for <see cref="ProfilerSettings"/>
+    /// </summary>
+    public static class ProfilerSettingsExtensions
+    {
+        /// <summary>
+        /// Get the ThreadFactory based on the <see cref="ThreadBehaviour"/> setting in <see cref="ProfilerSettings"/>
+        /// </summary>
+        /// <param name="settings"></param>
+        /// <returns></returns>
+        public static Func<int, Func<Result>, IWorkerThread> GetThreadFactory(this ProfilerSettings settings)
+        {
+            return settings.ThreadBehaviour switch
+            {
+                ThreadBehaviour.Thread => WorkerThread.Factory,
+                ThreadBehaviour.Task => WorkerTask.Factory,
+                _ => WorkerThread.Factory
+            };
+        }
+    }
+}

src/MeasureMap/SessionHandlers/BasicSessionHandler.cs

@@ -1,12 +1,11 @@
-
+using System;
 using MeasureMap.Threading;
-using System;
 using MeasureMap.Diagnostics;
 
 namespace MeasureMap
 {
     /// <summary>
-    /// A single threaded task session handler
+    /// A single threaded task session handler. Runs all tasks in a separate thread.
     /// </summary>
     public class BasicSessionHandler : SessionHandler, IThreadSessionHandler
     {
@@ -19,23 +18,39 @@ public class BasicSessionHandler : SessionHandler, IThreadSessionHandler
         public override IProfilerResult Execute(ITask task, ProfilerSettings settings)
         {
             var runnerThreads = new WorkerThreadList();
-            var threads = new ThreadList();
 
             var thread = runnerThreads.StartNew(0, () =>
             {
-                var worker = new Worker(threads);
+                var worker = new Worker();
                 return worker.Run(task, settings);
-            });
+            }, settings.GetThreadFactory());
 
             settings.Logger.Write($"Start thread {thread.Id}", LogLevel.Debug, nameof(BasicSessionHandler));
 
             runnerThreads.WaitAll();
-            threads.WaitAll();
 
             return new ProfilerResult
             {
                 thread.Result
             };
         }
+
+        /// <summary>
+        /// Dispose
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Dispose
+        /// </summary>
+        /// <param name="disposing"></param>
+        protected virtual void Dispose(bool disposing)
+        {
+            // nothing to dispose
+        }
     }
 }