From 57079538eb6974e58873c6c35dcca28e23e26059 Mon Sep 17 00:00:00 2001
From: Marios Zikos <mariosz@microsoft.com>
Date: Tue, 17 Dec 2019 06:20:13 -0800
Subject: [PATCH] Add Plugins and improve Thread startup

    * Adding plugin capability.
      Just add code that implements the IWorkerJob interface to the directory of NetLing.Client
      and it will be loaded during runtime.
      New command line option to select plugin name (-n)

     * Add Thread WarmUp capability
       Each thread performs some time of test, to warmup the server

     * Add P99, P95 reporting from command line

     * Start all thread together testing server
       If yoo many threads are used, some threads used to start earlier
       Add an event that controls the start of work on all threads
---
 Netling.Client/MainWindow.xaml                |  24 +++-
 Netling.Client/MainWindow.xaml.cs             |  56 ++++++++-
 Netling.ConsoleClient/Program.cs              | 106 ++++++++++++-----
 .../HttpClientWorkerJob.cs                    |  13 ++-
 Netling.Core.SocketWorker/SocketWorkerJob.cs  |  11 +-
 Netling.Core/IWorkerJob.cs                    |   7 +-
 Netling.Core/Models/WorkerResult.cs           |  11 ++
 Netling.Core/Models/WorkerThreadResult.cs     |   7 ++
 Netling.Core/PluginLoader.cs                  | 108 ++++++++++++++++++
 Netling.Core/Worker.cs                        | 106 ++++++++++++++---
 10 files changed, 395 insertions(+), 54 deletions(-)
 create mode 100644 Netling.Core/PluginLoader.cs

diff --git a/Netling.Client/MainWindow.xaml b/Netling.Client/MainWindow.xaml
index 5204192..e20771f 100644
--- a/Netling.Client/MainWindow.xaml
+++ b/Netling.Client/MainWindow.xaml
@@ -1,12 +1,13 @@
 <Window x:Class="Netling.Client.MainWindow"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-        Title="Netling" Width="500" Height="223" ResizeMode="NoResize">
+        Title="Netling" Width="500" Height="342" ResizeMode="NoResize">
     <Grid Margin="10">
         <StackPanel Orientation="Horizontal">
             <StackPanel Margin="0,0,20,0">
                 <TextBlock Text="Threads" VerticalAlignment="Top" HorizontalAlignment="Left"/>
                 <ComboBox x:Name="Threads" VerticalAlignment="Top" HorizontalAlignment="Left" Width="120" Height="25" Margin="0,5,0,0" />
+                <Grid Height="100"/>
             </StackPanel>
             <StackPanel Margin="0,0,20,0">
                 <TextBlock Text="Duration" VerticalAlignment="Top" HorizontalAlignment="Left"/>
@@ -23,11 +24,28 @@
                     <ComboBoxItem>3000 runs on 1 thread</ComboBoxItem>
                     <ComboBoxItem>10000 runs on 1 thread</ComboBoxItem>
                 </ComboBox>
+
+            </StackPanel>
+            <StackPanel Margin="0,0,20,0">
+                <TextBlock Text="Warmup" VerticalAlignment="Top" HorizontalAlignment="Left"/>
+                <ComboBox x:Name="Warmup" VerticalAlignment="Top" HorizontalAlignment="Left" Width="120" Height="25" Margin="0,5,0,0">
+                    <ComboBoxItem IsSelected="True">2 seconds</ComboBoxItem>
+                    <ComboBoxItem>0 seconds</ComboBoxItem>
+                    <ComboBoxItem>2 seconds</ComboBoxItem>
+                    <ComboBoxItem>10 seconds</ComboBoxItem>
+                    <ComboBoxItem>20 seconds</ComboBoxItem>
+                    <ComboBoxItem>30 seconds</ComboBoxItem>
+                    <ComboBoxItem>1 minute</ComboBoxItem>
+                    <ComboBoxItem>2 minutes</ComboBoxItem>
+                </ComboBox>
+
             </StackPanel>
         </StackPanel>
-        
+
         <TextBlock Text="URL" VerticalAlignment="Top" HorizontalAlignment="Left" Margin="0,61,0,0"/>
-        <TextBox x:Name="Url" VerticalAlignment="Stretch" KeyUp="Urls_OnKeyUp" HorizontalAlignment="Stretch" Padding="6" Margin="0,82,0,50" />
+        <TextBox x:Name="Url" KeyUp="Urls_OnKeyUp" Padding="6" Margin="0,82,0,166" />
+
+        <ListBox x:Name="Plugins" Margin="0,153,0,48"/>
 
         <Button Content="Run" x:Name="StartButton" Background="#ff0079c5" BorderThickness="0" Foreground="White" Click="StartButton_Click" VerticalAlignment="Bottom" HorizontalAlignment="Left" Width="100" Height="30"/>
         <ProgressBar x:Name="StatusProgressbar" VerticalAlignment="Bottom" Minimum="0" Maximum="100" HorizontalAlignment="Stretch" Visibility="Hidden" Height="16" Margin="120,0,0,7" />
diff --git a/Netling.Client/MainWindow.xaml.cs b/Netling.Client/MainWindow.xaml.cs
index 7d12877..badd398 100644
--- a/Netling.Client/MainWindow.xaml.cs
+++ b/Netling.Client/MainWindow.xaml.cs
@@ -1,13 +1,17 @@
 using System;
 using System.Collections.Generic;
+using System.Data;
 using System.Diagnostics;
 using System.Globalization;
+using System.Linq;
+using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Input;
 using Netling.Core;
+using Netling.Core.HttpClientWorker;
 using Netling.Core.Models;
 using Netling.Core.SocketWorker;
 
@@ -21,7 +25,6 @@ public partial class MainWindow
         private List<ResultWindow> _resultWindows;
         private ResultWindowItem _baselineResult;
 
-
         public MainWindow()
         {
             _resultWindows = new List<ResultWindow>();
@@ -49,6 +52,10 @@ private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
 
             Threads.SelectedIndex = 0;
             Url.Focus();
+
+            List<PluginInfo> pluginList = PluginLoader.GetPluginList(".");
+            Plugins.ItemsSource = pluginList.Select(x => string.Format("{0} ({1})", x.TypeName, x.AssemblyShort));
+            Plugins.Tag = pluginList;
         }
 
         private async void StartButton_Click(object sender, RoutedEventArgs e)
@@ -56,9 +63,11 @@ private async void StartButton_Click(object sender, RoutedEventArgs e)
             if (!_running)
             {
                 var duration = default(TimeSpan);
+                var warmup = TimeSpan.FromSeconds(0);
                 int? count = null;
                 var threads = Convert.ToInt32(((KeyValuePair<int, string>)Threads.SelectionBoxItem).Key);
                 var durationText = (string)((ComboBoxItem)Duration.SelectedItem).Content;
+                var warmupText = (string)((ComboBoxItem)Warmup.SelectedItem).Content;
                 StatusProgressbar.IsIndeterminate = false;
 
                 switch (durationText)
@@ -102,7 +111,31 @@ private async void StartButton_Click(object sender, RoutedEventArgs e)
                         count = 10000;
                         StatusProgressbar.IsIndeterminate = true;
                         break;
-
+                }
+                
+                switch (warmupText)
+                {
+                    case "0 seconds":
+                        warmup = TimeSpan.FromSeconds(0);
+                        break;
+                    case "2 seconds":
+                        warmup = TimeSpan.FromSeconds(2);
+                        break;
+                    case "10 seconds":
+                        warmup = TimeSpan.FromSeconds(10);
+                        break;
+                    case "20 seconds":
+                        warmup = TimeSpan.FromSeconds(20);
+                        break;
+                    case "30 seconds":
+                        warmup = TimeSpan.FromSeconds(30);
+                        break;
+                    case "1 minute":
+                        warmup = TimeSpan.FromMinutes(1);
+                        break;
+                    case "2 minutes":
+                        warmup = TimeSpan.FromMinutes(2);
+                        break;
                 }
 
                 if (string.IsNullOrWhiteSpace(Url.Text))
@@ -115,6 +148,11 @@ private async void StartButton_Click(object sender, RoutedEventArgs e)
                     return;
                 }
 
+                if (Plugins.SelectedIndex == -1)
+                {
+                    return;
+                }
+
                 Threads.IsEnabled = false;
                 Duration.IsEnabled = false;
                 Url.IsEnabled = false;
@@ -127,15 +165,23 @@ private async void StartButton_Click(object sender, RoutedEventArgs e)
                 StatusProgressbar.Value = 0;
                 StatusProgressbar.Visibility = Visibility.Visible;
 
-                var worker = new Worker(new SocketWorkerJob(uri));
+                List<PluginInfo> pluginList = Plugins.Tag as List<PluginInfo>;
+                PluginInfo selectedPlugin = pluginList[Plugins.SelectedIndex];
+
+                Assembly workerPluginAssembly = PluginLoader.LoadPlugin(selectedPlugin.AssemblyName);
+                var workerPlugin = PluginLoader.CreateInstance(workerPluginAssembly, selectedPlugin.TypeName);
+
+                workerPlugin.Initialize(uri);
+
+                var worker = new Worker(workerPlugin);
 
                 if (count.HasValue)
                 {
-                    _task = worker.Run(uri.ToString(), count.Value, cancellationToken);
+                    _task = worker.Run(uri.ToString(), count.Value, warmup, cancellationToken);
                 }
                 else
                 {
-                    _task = worker.Run(uri.ToString(), threads, duration, cancellationToken);
+                    _task = worker.Run(uri.ToString(), threads, duration, warmup, cancellationToken);
                 }
 
                 _task.GetAwaiter().OnCompleted(async () =>
diff --git a/Netling.ConsoleClient/Program.cs b/Netling.ConsoleClient/Program.cs
index b7753dc..bc3cf0c 100644
--- a/Netling.ConsoleClient/Program.cs
+++ b/Netling.ConsoleClient/Program.cs
@@ -1,10 +1,13 @@
 using System;
+using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
 using CommandLine.Options;
 using Netling.Core;
+using Netling.Core.HttpClientWorker;
 using Netling.Core.Models;
 using Netling.Core.SocketWorker;
 
@@ -20,29 +23,51 @@ static void Main(string[] args)
             var threads = 1;
             var duration = 10;
             int? count = null;
+            int? warmupOpt = null;
+            int warmup = 0;
+            string testname = string.Empty;
 
             var p = new OptionSet()
             {
                 {"t|threads=", (int v) => threads = v},
                 {"d|duration=", (int v) => duration = v},
-                {"c|count=", (int? v) => count = v}
+                {"c|count=", (int? v) => count = v},
+                {"w|warmup=", (int? w) => warmupOpt = w},
+                {"n|testname=", (string n) => testname = n},
             };
 
             var extraArgs = p.Parse(args);
             var url = extraArgs.FirstOrDefault(e => e.StartsWith("http://", StringComparison.OrdinalIgnoreCase) || e.StartsWith("https://", StringComparison.OrdinalIgnoreCase));
             Uri uri = null;
+            PluginInfo pluginTest = null;
+
+            if (string.IsNullOrEmpty(testname))
+            {
+                ShowHelp();
+                return;
+            }
+            else
+            {
+                List<PluginInfo> pluginList = PluginLoader.GetPluginList(".");
+                pluginTest = pluginList.Where(x => x.TypeName == testname).FirstOrDefault();
+            }
+
+            if (warmupOpt.HasValue)
+            {
+                warmup = warmupOpt.Value;
+            }
 
             if (url != null && !Uri.TryCreate(url, UriKind.Absolute, out uri))
             {
                 Console.WriteLine("Failed to parse URL");
             }
-            else if (url != null && count.HasValue)
+            else if (pluginTest != null && url != null && count.HasValue)
             {
-                RunWithCount(uri, count.Value).Wait();
+                RunWithCount(uri, pluginTest, count.Value, TimeSpan.FromSeconds(warmup)).Wait();
             }
-            else if (url != null)
+            else if (pluginTest != null && url != null)
             {
-                RunWithDuration(uri, threads, TimeSpan.FromSeconds(duration)).Wait();
+                RunWithDuration(uri, pluginTest, threads, TimeSpan.FromSeconds(duration), TimeSpan.FromSeconds(warmup)).Wait();
             }
             else
             {
@@ -53,44 +78,64 @@ static void Main(string[] args)
         private static void ShowHelp()
         {
             Console.WriteLine(HelpString);
+
+            List<PluginInfo> pluginList = PluginLoader.GetPluginList(".");
+
+            Console.WriteLine("Plugins Availiable:");
+            foreach (var plugin in pluginList)
+            {
+                Console.WriteLine("{0} {1}", plugin.TypeName, plugin.AssemblyShort);
+            }
         }
 
-        private static Task RunWithCount(Uri uri, int count)
+        private static Task RunWithCount(Uri uri, PluginInfo selectedPlugin, int count, TimeSpan warmupDuration)
         {
             Console.WriteLine(StartRunWithCountString, count, uri);
-            return Run(uri, 1, TimeSpan.MaxValue, count);
+            return Run(uri, selectedPlugin, 1, TimeSpan.MaxValue, warmupDuration, count);
         }
 
-        private static Task RunWithDuration(Uri uri, int threads, TimeSpan duration)
+        private static Task RunWithDuration(Uri uri, PluginInfo selectedPlugin, int threads, TimeSpan duration, TimeSpan warmupDuration)
         {
-            Console.WriteLine(StartRunWithDurationString, duration.TotalSeconds, uri, threads);
-            return Run(uri, threads, duration, null);
+            Console.WriteLine(StartRunWithDurationString, duration.TotalSeconds, warmupDuration, uri, threads);
+            return Run(uri, selectedPlugin, threads, duration, warmupDuration, null);
         }
 
-        private static async Task Run(Uri uri, int threads, TimeSpan duration, int? count)
+        private static async Task Run(Uri uri, PluginInfo selectedPlugin, int threads, TimeSpan duration, TimeSpan warmupDuration, int? count)
         {
             WorkerResult result;
-            var worker = new Worker(new SocketWorkerJob(uri));
+
+            Console.WriteLine("Running tests from {0} : {1}", selectedPlugin.AssemblyShort, selectedPlugin.TypeName);
+
+            Assembly workerPluginAssembly = PluginLoader.LoadPlugin(selectedPlugin.AssemblyName);
+            var workerPlugin = PluginLoader.CreateInstance(workerPluginAssembly, selectedPlugin.TypeName);
+            workerPlugin.Initialize(uri);
+
+            var worker = new Worker(workerPlugin);
 
             if (count.HasValue)
             {
-                result = await worker.Run(uri.ToString(), count.Value, new CancellationToken());
+                result = await worker.Run(uri.ToString(), count.Value, warmupDuration, new CancellationToken());
             }
             else
             {
-                result = await worker.Run(uri.ToString(), threads, duration, new CancellationToken());
+                result = await worker.Run(uri.ToString(), threads, duration, warmupDuration, new CancellationToken());
             }
 
-            Console.WriteLine(ResultString, 
+            Console.WriteLine(ResultString1,
                 result.Count,
                 result.Elapsed.TotalSeconds,
-                result.RequestsPerSecond, 
-                result.Bandwidth, 
-                result.Errors,
+                result.RequestsPerSecond,
+                result.Bandwidth,
+                result.Errors);
+
+            Console.WriteLine(ResultString2,
                 result.Median,
                 result.StdDev,
                 result.Min,
                 result.Max,
+                result.P99,
+                result.P95,
+                result.P50,
                 GetAsciiHistogram(result));
         }
 
@@ -122,12 +167,14 @@ private static string GetAsciiHistogram(WorkerResult workerResult)
         }
 
         private const string HelpString = @"
-Usage: netling [-t threads] [-d duration] url
+Usage: netling [-t threads] [-d duration] [-w warmupSec] -n plugin url
 
 Options:
     -t count        Number of threads to spawn.
     -d count        Duration of the run in seconds.
+    -w warmup       Duration of the warmup phase in seconds.
     -c count        Amount of requests to send on a single thread.
+    -n pluginname   Name of plugin type to use for testing.
 
 Examples:
     netling http://localhost:5000/
@@ -141,18 +188,23 @@ private static string GetAsciiHistogram(WorkerResult workerResult)
         private const string StartRunWithDurationString = @"
 Running {0}s test with {2} threads @ {1}";
 
-        private const string ResultString = @"
+        private const string ResultString1 = @"
 {0} requests in {1:0.##}s
     Requests/sec:   {2:0}
     Bandwidth:      {3:0} mbit
-    Errors:         {4:0}
-Latency
-    Median:         {5:0.000} ms
-    StdDev:         {6:0.000} ms
-    Min:            {7:0.000} ms
-    Max:            {8:0.000} ms
+    Errors:         {4:0}";
 
-{9}
+        private const string ResultString2 = @"
+Latency
+    Median:         {0:0.000} ms
+    StdDev:         {1:0.000} ms
+    Min:            {2:0.000} ms
+    Max:            {3:0.000} ms
+    P99:            {4:0.000} ms
+    P95:            {5:0.000} ms
+    P50:            {6:0.000} ms
+
+{7}
 ";
     }
 }
diff --git a/Netling.Core.HttpClientWorker/HttpClientWorkerJob.cs b/Netling.Core.HttpClientWorker/HttpClientWorkerJob.cs
index 43ad931..4af993c 100644
--- a/Netling.Core.HttpClientWorker/HttpClientWorkerJob.cs
+++ b/Netling.Core.HttpClientWorker/HttpClientWorkerJob.cs
@@ -9,20 +9,29 @@ namespace Netling.Core.HttpClientWorker
     public class HttpClientWorkerJob : IWorkerJob
     {
         private readonly int _index;
-        private readonly Uri _uri;
+        private Uri _uri;
         private readonly Stopwatch _stopwatch;
         private readonly Stopwatch _localStopwatch;
         private readonly WorkerThreadResult _workerThreadResult;
         private readonly HttpClient _httpClient;
 
         // Used to approximately calculate bandwidth
-        private static readonly int MissingHeaderLength = "HTTP/1.1 200 OK\r\nContent-Length: 123\r\nContent-Type: text/plain\r\n\r\n".Length; 
+        private static readonly int MissingHeaderLength = "HTTP/1.1 200 OK\r\nContent-Length: 123\r\nContent-Type: text/plain\r\n\r\n".Length;
+
+        public HttpClientWorkerJob()
+        {
+        }
 
         public HttpClientWorkerJob(Uri uri)
         {
             _uri = uri;
         }
 
+        public void Initialize(Uri uri)
+        {
+            _uri = uri;
+        }
+
         private HttpClientWorkerJob(int index, Uri uri, WorkerThreadResult workerThreadResult)
         {
             _index = index;
diff --git a/Netling.Core.SocketWorker/SocketWorkerJob.cs b/Netling.Core.SocketWorker/SocketWorkerJob.cs
index 940a4f0..f7eeb3d 100644
--- a/Netling.Core.SocketWorker/SocketWorkerJob.cs
+++ b/Netling.Core.SocketWorker/SocketWorkerJob.cs
@@ -9,17 +9,26 @@ namespace Netling.Core.SocketWorker
     public class SocketWorkerJob : IWorkerJob
     {
         private readonly int _index;
-        private readonly Uri _uri;
+        private Uri _uri;
         private readonly Stopwatch _stopwatch;
         private readonly Stopwatch _localStopwatch;
         private readonly WorkerThreadResult _workerThreadResult;
         private readonly HttpWorker _httpWorker;
 
+        public SocketWorkerJob()
+        {
+        }
+
         public SocketWorkerJob(Uri uri)
         {
             _uri = uri;
         }
 
+        public void Initialize(Uri uri)
+        {
+            _uri = uri;
+        }
+
         private SocketWorkerJob(int index, Uri uri, WorkerThreadResult workerThreadResult)
         {
             _index = index;
diff --git a/Netling.Core/IWorkerJob.cs b/Netling.Core/IWorkerJob.cs
index 8a84b33..1a02768 100644
--- a/Netling.Core/IWorkerJob.cs
+++ b/Netling.Core/IWorkerJob.cs
@@ -1,12 +1,17 @@
-using System.Threading.Tasks;
+using System;
+using System.Threading.Tasks;
 using Netling.Core.Models;
 
 namespace Netling.Core
 {
     public interface IWorkerJob
     {
+        void Initialize(Uri uri);
+
         ValueTask<IWorkerJob> Init(int index, WorkerThreadResult workerThreadResult);
+
         ValueTask DoWork();
+
         WorkerThreadResult GetResults();
     }
 }
\ No newline at end of file
diff --git a/Netling.Core/Models/WorkerResult.cs b/Netling.Core/Models/WorkerResult.cs
index be9b070..e3ef56b 100644
--- a/Netling.Core/Models/WorkerResult.cs
+++ b/Netling.Core/Models/WorkerResult.cs
@@ -32,6 +32,13 @@ public WorkerResult(string name, int threads, TimeSpan elapsed)
         public double StdDev { get; private set; }
         public double Min { get; private set; }
         public double Max { get; private set; }
+
+        public double P99 { get; private set; }
+
+        public double P95 { get; private set; }
+
+        public double P50 { get; private set; }
+
         public int[] Histogram { get; private set; }
 
         public double Bandwidth => Math.Round(BytesPrSecond * 8 / 1024 / 1024, MidpointRounding.AwayFromZero);
@@ -58,6 +65,10 @@ public void Process(CombinedWorkerThreadResult wtResult)
             Min = responseTimes.First();
             Max = responseTimes.Last();
             Histogram = GenerateHistogram(responseTimes);
+
+            P99 = responseTimes[(int)(responseTimes.Length * 0.99)];
+            P95 = responseTimes[(int)(responseTimes.Length * 0.95)];
+            P50 = responseTimes[(int)(responseTimes.Length / 2 )];
         }
 
         private static float[] GetResponseTimes(List<List<float>> items)
diff --git a/Netling.Core/Models/WorkerThreadResult.cs b/Netling.Core/Models/WorkerThreadResult.cs
index eff9e32..0dc0199 100644
--- a/Netling.Core/Models/WorkerThreadResult.cs
+++ b/Netling.Core/Models/WorkerThreadResult.cs
@@ -33,6 +33,13 @@ public void AddError(int elapsedSeconds, float responsetime, int statusCode, boo
             }
         }
 
+        public void Clear()
+        {
+            this.Seconds.Clear();
+            this.StatusCodes.Clear();
+            this.Exceptions.Clear();
+        }
+
         private void AddOrUpdateStatusCode(int statusCode)
         {
             if (statusCode == 0)
diff --git a/Netling.Core/PluginLoader.cs b/Netling.Core/PluginLoader.cs
new file mode 100644
index 0000000..1191188
--- /dev/null
+++ b/Netling.Core/PluginLoader.cs
@@ -0,0 +1,108 @@
+using System;
+using System.Reflection;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace Netling.Core
+{
+    public class PluginInfo
+    {
+        public string AssemblyShort { get; set; }
+        public string AssemblyName { get; set; }
+        public string TypeName { get; set; }
+    }
+
+    public class PluginLoader
+    {
+        public static List<PluginInfo>  GetPluginList(string relativePath)
+        {
+            List<PluginInfo> plugins = new List<PluginInfo>();
+
+            string root = Path.GetFullPath(Path.GetDirectoryName(Path.Combine(typeof(PluginLoader).Assembly.Location)));
+            string pluginLocation = Path.GetFullPath(Path.Combine(root, relativePath.Replace('\\', Path.DirectorySeparatorChar)));
+
+            DirectoryInfo dir = new DirectoryInfo(pluginLocation);
+
+            foreach (FileInfo file in dir.GetFiles("*.dll"))
+            {
+                Assembly assembly = Assembly.LoadFrom(file.FullName);
+                foreach (Type type in assembly.GetTypes())
+                {
+                    if (typeof(IWorkerJob).IsAssignableFrom(type) && type.IsAbstract == false)
+                    {
+                        PluginInfo info = new PluginInfo
+                        {
+                            AssemblyShort = file.Name,
+                            AssemblyName = file.FullName,
+                            TypeName = type.Name,
+                        };
+
+                        plugins.Add(info);
+                    }
+                }
+            }
+
+            return plugins;
+        }
+
+        public static Assembly LoadPlugin(string pluginLocation)
+        {
+            Console.WriteLine($"Loading commands from: {pluginLocation}");
+
+            Assembly assembly = Assembly.LoadFrom(pluginLocation);
+
+            return assembly;
+        }
+
+        public static IWorkerJob CreateInstance(Assembly assembly, string typeName)
+        {
+            foreach (Type type in assembly.GetTypes())
+            {
+                if (typeof(IWorkerJob).IsAssignableFrom(type) && type.Name == typeName)
+                {
+                    IWorkerJob result = Activator.CreateInstance(type) as IWorkerJob;
+
+                    if (result != null)
+                    {
+                        return result;
+                    }
+                }
+            }
+
+            string availableTypes = string.Join(",", assembly.GetTypes().Select(t => t.FullName));
+
+            throw new ApplicationException(
+                $"Can't find any type which implements IWorkerJob in {assembly} from {assembly.Location}.\n" +
+                $"Available types: {availableTypes}");
+        }
+
+        public static IEnumerable<IWorkerJob> CreateInstances(Assembly assembly)
+        {
+            int count = 0;
+
+            foreach (Type type in assembly.GetTypes())
+            {
+                if (typeof(IWorkerJob).IsAssignableFrom(type))
+                {
+                    IWorkerJob result = Activator.CreateInstance(type) as IWorkerJob;
+
+                    if (result != null)
+                    {
+                        count++;
+                        yield return result;
+                    }
+                }
+            }
+
+            if (count == 0)
+            {
+                string availableTypes = string.Join(",", assembly.GetTypes().Select(t => t.FullName));
+
+                throw new ApplicationException(
+                    $"Can't find any type which implements IWorkerJob in {assembly} from {assembly.Location}.\n" +
+                    $"Available types: {availableTypes}");
+            }
+        }
+    }
+}
diff --git a/Netling.Core/Worker.cs b/Netling.Core/Worker.cs
index 99d36ff..8f6f593 100644
--- a/Netling.Core/Worker.cs
+++ b/Netling.Core/Worker.cs
@@ -18,33 +18,35 @@ public Worker(IWorkerJob workerJob)
             _workerJob = workerJob;
         }
 
-        public Task<WorkerResult> Run(string name, int threads, TimeSpan duration, CancellationToken cancellationToken)
+        public Task<WorkerResult> Run(string name, int threads, TimeSpan duration, TimeSpan warmupDuration, CancellationToken cancellationToken)
         {
-            return Run(name, threads, duration, null, cancellationToken);
+            return Run(name, threads, duration, warmupDuration, null, cancellationToken);
         }
 
-        public Task<WorkerResult> Run(string name, int count, CancellationToken cancellationToken)
+        public Task<WorkerResult> Run(string name, int count, TimeSpan warmupDuration, CancellationToken cancellationToken)
         {
-            return Run(name, 1, TimeSpan.MaxValue, count, cancellationToken);
+            return Run(name, 1, TimeSpan.MaxValue, warmupDuration, count, cancellationToken);
         }
 
-        private Task<WorkerResult> Run(string name, int threads, TimeSpan duration, int? count, CancellationToken cancellationToken)
+        private Task<WorkerResult> Run(string name, int threads, TimeSpan duration, TimeSpan warmupDuration, int? count, CancellationToken cancellationToken)
         {
             return Task.Run(() =>
             {
-                var combinedWorkerThreadResult = QueueWorkerThreads(threads, duration, count, cancellationToken);
+                var combinedWorkerThreadResult = QueueWorkerThreads(threads, duration, warmupDuration, count, cancellationToken);
                 var workerResult = new WorkerResult(name, threads, combinedWorkerThreadResult.Elapsed);
                 workerResult.Process(combinedWorkerThreadResult);
                 return workerResult;
             });
         }
 
-        private CombinedWorkerThreadResult QueueWorkerThreads(int threads, TimeSpan duration, int? count, CancellationToken cancellationToken)
+        private CombinedWorkerThreadResult QueueWorkerThreads(int threads, TimeSpan duration, TimeSpan warmupDuration, int? count, CancellationToken cancellationToken)
         {
             var results = new ConcurrentQueue<WorkerThreadResult>();
             var events = new List<ManualResetEventSlim>();
             var sw = Stopwatch.StartNew();
 
+            var startWorkEvent = new ManualResetEventSlim(false);
+
             for (var i = 0; i < threads; i++)
             {
                 var resetEvent = new ManualResetEventSlim(false);
@@ -53,27 +55,43 @@ private CombinedWorkerThreadResult QueueWorkerThreads(int threads, TimeSpan dura
 
                 if (count.HasValue)
                 {
-                    thread = new Thread(async (index) => await DoWork_Count(count.Value, results, cancellationToken, resetEvent, (int)index));
+                    thread = new Thread(async (index) => await DoWork_Count(count.Value, results, warmupDuration, sw, cancellationToken, startWorkEvent, resetEvent, (int)index));
                 }
                 else
                 {
-                    thread = new Thread(async (index) => await DoWork_Duration(duration, sw, results, cancellationToken, resetEvent, (int)index));
+                    thread = new Thread(async (index) => await DoWork_Duration(duration, warmupDuration, sw, results, cancellationToken, startWorkEvent, resetEvent, (int)index));
                 }
 
                 thread.Start(i);
                 events.Add(resetEvent);
+
+                Thread.Sleep(100);
             }
 
+            sw.Restart();
+
+            // start the work on all threads
+            startWorkEvent.Set();
+
+
             for (var i = 0; i < events.Count; i += 50)
             {
                 var group = events.Skip(i).Take(50).Select(r => r.WaitHandle).ToArray();
                 WaitHandle.WaitAll(group);
             }
 
-            return new CombinedWorkerThreadResult(results, sw.Elapsed);
+            return new CombinedWorkerThreadResult(results, sw.Elapsed - warmupDuration);
         }
 
-        private async Task DoWork_Duration(TimeSpan duration, Stopwatch sw, ConcurrentQueue<WorkerThreadResult> results, CancellationToken cancellationToken, ManualResetEventSlim resetEvent, int workerIndex)
+        private async Task DoWork_Duration(
+            TimeSpan duration, 
+            TimeSpan warmupDuration, 
+            Stopwatch sw, 
+            ConcurrentQueue<WorkerThreadResult> results, 
+            CancellationToken cancellationToken,
+            ManualResetEventSlim startWorkEvent,
+            ManualResetEventSlim resetEvent, 
+            int workerIndex)
         {
             IWorkerJob job;
             var workerThreadResult = new WorkerThreadResult();
@@ -81,6 +99,7 @@ private async Task DoWork_Duration(TimeSpan duration, Stopwatch sw, ConcurrentQu
             try
             {
                 job = await _workerJob.Init(workerIndex, workerThreadResult);
+                await job.DoWork();
             }
             catch (Exception ex)
             {
@@ -90,7 +109,25 @@ private async Task DoWork_Duration(TimeSpan duration, Stopwatch sw, ConcurrentQu
                 return;
             }
 
-            while (!cancellationToken.IsCancellationRequested && duration.TotalMilliseconds > sw.Elapsed.TotalMilliseconds)
+            startWorkEvent.Wait();
+
+            // warmup phase
+            while (!cancellationToken.IsCancellationRequested && warmupDuration.TotalMilliseconds > sw.Elapsed.TotalMilliseconds)
+            {
+                try
+                {
+                    await job.DoWork();
+                }
+                catch (Exception ex)
+                {
+                    workerThreadResult.AddError((int)sw.ElapsedMilliseconds / 1000, 0, 0, false, ex);
+                }
+            }
+
+            workerThreadResult.Clear();
+
+            // main phase
+            while (!cancellationToken.IsCancellationRequested && (duration.TotalMilliseconds + warmupDuration .TotalMilliseconds)> sw.Elapsed.TotalMilliseconds)
             {
                 try
                 {
@@ -101,16 +138,55 @@ private async Task DoWork_Duration(TimeSpan duration, Stopwatch sw, ConcurrentQu
                     workerThreadResult.AddError((int)sw.ElapsedMilliseconds / 1000, 0, 0, false, ex);
                 }
             }
-            
+
             results.Enqueue(job.GetResults());
             resetEvent.Set();
         }
 
-        private async Task DoWork_Count(int count, ConcurrentQueue<WorkerThreadResult> results, CancellationToken cancellationToken, ManualResetEventSlim resetEvent, int workerIndex)
+        private async Task DoWork_Count(
+            int count, 
+            ConcurrentQueue<WorkerThreadResult> results, 
+            TimeSpan warmupDuration, 
+            Stopwatch sw, 
+            CancellationToken cancellationToken,
+            ManualResetEventSlim startWorkEvent,
+            ManualResetEventSlim resetEvent, 
+            int workerIndex)
         {
             var workerThreadResult = new WorkerThreadResult();
-            var job = await _workerJob.Init(workerIndex, workerThreadResult);
+            IWorkerJob job;
+
+            try
+            {
+                job = await _workerJob.Init(workerIndex, workerThreadResult);
+                await job.DoWork();
+            }
+            catch (Exception ex)
+            {
+                workerThreadResult.AddError((int)sw.ElapsedMilliseconds / 1000, 0, 0, false, ex);
+                results.Enqueue(workerThreadResult);
+                resetEvent.Set();
+                return;
+            }
+
+            startWorkEvent.Wait();
+
+            // warmup phase
+            while (!cancellationToken.IsCancellationRequested && warmupDuration.TotalMilliseconds > sw.Elapsed.TotalMilliseconds)
+            {
+                try
+                {
+                    await job.DoWork();
+                }
+                catch (Exception ex)
+                {
+                    workerThreadResult.AddError((int)sw.ElapsedMilliseconds / 1000, 0, 0, false, ex);
+                }
+            }
+
+            workerThreadResult.Clear();
 
+            // main phase
             for (var i = 0; i < count && !cancellationToken.IsCancellationRequested; i++)
             {
                 await job.DoWork();