Detecting virtual machine hypervisor, #167

docs/guide/FAQ.md

@@ -36,4 +36,7 @@ For example, you can use the `SimpleJob` or `ShortRunJob` attributes:
 [ShortRunJob]
 ```
 * **Q** My benchmark unexpectedly stopped and I saw the information about error code. What can I do?  
-**A** BenchmarkDotNet generates, builds and runs new process for every benchmark. This behavior is sometimes interpreted by anti-virus as dangerous, and the process is killed. Use `EnvironmentAnalyser` to detect antivirus software and configure your benchmark to use `InProcessToolchain`.
+**A** BenchmarkDotNet generates, builds and runs new process for every benchmark. This behavior is sometimes interpreted by anti-virus as dangerous, and the process is killed. Use `EnvironmentAnalyser` to detect antivirus software and configure your benchmark to use `InProcessToolchain`.
+
+* **Q** Can I run benchmark on the virtual machine?  
+**A** Yes, of course. However, it can affect results because of the shared, physical machine, virtualization process and incorrect `Stopwatch.Frequency`. If you are unsure whether an application is running on virtual environment, use `EnvironmentAnalyser` to detect VM hypervisor.

src/BenchmarkDotNet.Core/Analysers/EnvironmentAnalyser.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Text;
@@ -37,6 +36,13 @@ public override IEnumerable<Conclusion> AnalyseSummary(Summary summary)
                 if (avProducts.Any())
                     yield return CreateWarning(CreateWarningAboutAntivirus(avProducts));
             }
+
+            var vmHypervisor = summary.HostEnvironmentInfo.VirtualMachineHypervisor.Value;
+            if (vmHypervisor != null)
+            {
+                yield return CreateWarning($"Benchmark was executed on the virtual machine with {vmHypervisor.Name} hypervisor. " +
+                                           "Virtualization can affect the measurement result.");
+            }
         }
 
         private static string CreateWarningAboutAntivirus(ICollection<Antivirus> avProducts)

src/BenchmarkDotNet.Core/Environments/HostEnvironmentInfo.cs

@@ -58,6 +58,8 @@ public class HostEnvironmentInfo : BenchmarkEnvironmentInfo
 
         public Lazy<ICollection<Antivirus>> AntivirusProducts { get; protected set; }
 
+        public Lazy<VirtualMachineHypervisor> VirtualMachineHypervisor { get; protected set; }
+
         static HostEnvironmentInfo()
         {
             MainCultureInfo = (CultureInfo)CultureInfo.InvariantCulture.Clone();
@@ -75,6 +77,7 @@ protected HostEnvironmentInfo()
             JitModules = RuntimeInformation.GetJitModulesInfo();
             DotNetSdkVersion = new Lazy<string>(DotNetCliCommandExecutor.GetDotNetSdkVersion);
             AntivirusProducts = new Lazy<ICollection<Antivirus>>(RuntimeInformation.GetAntivirusProducts);
+            VirtualMachineHypervisor = new Lazy<VirtualMachineHypervisor>(RuntimeInformation.GetVirtualMachineHypervisor);
         }
 
         public new static HostEnvironmentInfo GetCurrent() => Current ?? (Current = new HostEnvironmentInfo());

src/BenchmarkDotNet.Core/Portability/HyperV.cs

@@ -0,0 +1,16 @@
+namespace BenchmarkDotNet.Portability
+{
+    public class HyperV : VirtualMachineHypervisor
+    {
+        public static HyperV Default { get; } = new HyperV();
+
+        private HyperV() { }
+
+        public override string Name => "Hyper-V";
+
+        public override bool IsVirtualMachine(string manufacturer, string model)
+        {
+            return ContainsVmIdentifier(manufacturer, "microsoft") && ContainsVmIdentifier(model, "virtual");
+        }
+    }
+}

src/BenchmarkDotNet.Core/Portability/RuntimeInformation.cs

@@ -321,5 +321,35 @@ internal static ICollection<Antivirus> GetAntivirusProducts()
             return Array.Empty<Antivirus>();
 #endif
         }
+
+
+        internal static VirtualMachineHypervisor GetVirtualMachineHypervisor()
+        {
+            VirtualMachineHypervisor[] hypervisors = { HyperV.Default, VirtualBox.Default, VMware.Default };
+
+            if (IsWindows())
+            {
+#if !CORE
+                try
+                {
+                    using (ManagementObjectSearcher searcher = new ManagementObjectSearcher("Select * from Win32_ComputerSystem"))
+                    {
+                        using (ManagementObjectCollection items = searcher.Get())
+                        {
+                            foreach (ManagementBaseObject item in items)
+                            {
+                                string manufacturer = item["Manufacturer"]?.ToString();
+                                string model = item["Model"]?.ToString();
+                                return hypervisors.FirstOrDefault(x => x.IsVirtualMachine(manufacturer, model));
+                            }
+                        }
+                    }
+                }
+                catch { }
+#endif
+            }
+
+            return null;
+        }
     }
 }

src/BenchmarkDotNet.Core/Portability/StringExtensions.cs

@@ -6,12 +6,25 @@ internal static class StringExtensions
     {
         internal static bool EqualsWithIgnoreCase(this string left, string right)
         {
+            return left.Equals(right, IgnoreCaseStringComparison);
+        }
+
+        internal static bool ContainsWithIgnoreCase(this string text, string word)
+        {
+            return text.IndexOf(word, IgnoreCaseStringComparison) >= 0;
+        }
+
+        private static StringComparison IgnoreCaseStringComparison
+        {
+            get
+            {
 #if !CORE
-            return left.Equals(right, StringComparison.InvariantCultureIgnoreCase);
+                return StringComparison.InvariantCultureIgnoreCase;
 #else
-            // http://stackoverflow.com/questions/14600694/where-has-stringcomparison-invariantcultureignorecase-gone
-            return left.Equals(right, StringComparison.OrdinalIgnoreCase);
+// http://stackoverflow.com/questions/14600694/where-has-stringcomparison-invariantcultureignorecase-gone
+                return StringComparison.OrdinalIgnoreCase;
 #endif
+            }
         }
     }
 }

src/BenchmarkDotNet.Core/Portability/VMware.cs

@@ -0,0 +1,16 @@
+namespace BenchmarkDotNet.Portability
+{
+    public class VMware : VirtualMachineHypervisor
+    {
+        public static VMware Default { get; } = new VMware();
+
+        private VMware() { }
+
+        public override string Name => "VMware";
+
+        public override bool IsVirtualMachine(string manufacturer, string model)
+        {
+            return ContainsVmIdentifier(model, "vmware");
+        }
+    }
+}

src/BenchmarkDotNet.Core/Portability/VirtualBox.cs

@@ -0,0 +1,16 @@
+namespace BenchmarkDotNet.Portability
+{
+    public class VirtualBox : VirtualMachineHypervisor
+    {
+        public static VirtualBox Default { get; } = new VirtualBox();
+
+        private VirtualBox() { }
+
+        public override string Name => "VirtualBox";
+
+        public override bool IsVirtualMachine(string manufacturer, string model)
+        {
+            return ContainsVmIdentifier(model, "virtualbox");
+        }
+    }
+}

src/BenchmarkDotNet.Core/Portability/VirtualMachineHypervisor.cs

@@ -0,0 +1,14 @@
+namespace BenchmarkDotNet.Portability
+{
+    public abstract class VirtualMachineHypervisor
+    {
+        public abstract string Name { get; }
+
+        public abstract bool IsVirtualMachine(string manufacturer, string model);
+
+        protected bool ContainsVmIdentifier(string systemInformation, string vmIdentifier)
+        {
+            return systemInformation != null && systemInformation.ContainsWithIgnoreCase(vmIdentifier);
+        }
+    }
+}

tests/BenchmarkDotNet.Tests/Portability/HyperVTests.cs

@@ -0,0 +1,30 @@
+using BenchmarkDotNet.Portability;
+using Xunit;
+
+namespace BenchmarkDotNet.Tests.Portability
+{
+    public class HyperVTests
+    {
+        private readonly VirtualMachineHypervisor hypervisor = HyperV.Default;
+
+        [Fact]
+        public void ContainsCorrectName()
+        {
+            Assert.Equal("Hyper-V", hypervisor.Name);
+        }
+
+        [Theory]
+        [InlineData("Microsoft Corporation", "Virtual Machine", true)]
+        [InlineData("microsoft corporation", "virtual machine", true)]
+        [InlineData("microsoft", "virtual", true)]
+        [InlineData("Dell", "virtual", false)]
+        [InlineData("Dell", "ubuntu", false)]
+        [InlineData("microsoft corporation", null, false)]
+        [InlineData(null, "virtual machine", false)]
+        public void DetectsVirtualMachine(string manufacturer, string model, bool expectedResult)
+        {
+            bool result = hypervisor.IsVirtualMachine(manufacturer, model);
+            Assert.Equal(expectedResult, result);
+        }
+    }
+}

tests/BenchmarkDotNet.Tests/Portability/RuntimeInformationTests.cs

@@ -0,0 +1,17 @@
+using BenchmarkDotNet.Portability;
+using BenchmarkDotNet.Tests.XUnit;
+using Xunit;
+
+namespace BenchmarkDotNet.Tests.Portability
+{
+    public class RuntimeInformationTests
+    {
+        [AppVeyorWithClassicFrameworkOnlyFact]
+        public void DetectsHyperVOnAppveyor()
+        {
+            VirtualMachineHypervisor hypervisor = RuntimeInformation.GetVirtualMachineHypervisor();
+
+            Assert.Equal(hypervisor, HyperV.Default);
+        }
+    }
+}

tests/BenchmarkDotNet.Tests/Portability/VMWareTests.cs

@@ -0,0 +1,29 @@
+using BenchmarkDotNet.Portability;
+using Xunit;
+
+namespace BenchmarkDotNet.Tests.Portability
+{
+    public class VMwareTests
+    {
+        private readonly VirtualMachineHypervisor hypervisor = VMware.Default;
+
+        [Fact]
+        public void ContainsCorrectName()
+        {
+            Assert.Equal("VMware", hypervisor.Name);
+        }
+
+        [Theory]
+        [InlineData("VMWare Inc", "VMWare", true)]
+        [InlineData("VMWare Inc", "vmWare", true)]
+        [InlineData("redundant", "vmWare", true)]
+        [InlineData(null, "vmWare", true)]
+        [InlineData("VMWare Inc", "redundant", false)]
+        [InlineData("VMWare Inc", null, false)]
+        public void DetectsVirtualMachine(string manufacturer, string model, bool expectedResult)
+        {
+            bool result = hypervisor.IsVirtualMachine(manufacturer, model);
+            Assert.Equal(expectedResult, result);
+        }
+    }
+}

tests/BenchmarkDotNet.Tests/Portability/VirtualBoxTests.cs

@@ -0,0 +1,27 @@
+using BenchmarkDotNet.Portability;
+using Xunit;
+
+namespace BenchmarkDotNet.Tests.Portability
+{
+    public class VirtualBoxTests
+    {
+        private readonly VirtualMachineHypervisor hypervisor = VirtualBox.Default;
+
+        [Fact]
+        public void ContainsCorrectName()
+        {
+            Assert.Equal("VirtualBox", hypervisor.Name);
+        }
+
+        [Theory]
+        [InlineData("redundant", "virtualbox", true)]
+        [InlineData("redundant", "VirtualBox", true)]
+        [InlineData("redundant", "vmware", false)]
+        [InlineData("redundant", null, false)]
+        public void DetectsVirtualMachine(string manufacturer, string model, bool expectedResult)
+        {
+            bool result = hypervisor.IsVirtualMachine(manufacturer, model);
+            Assert.Equal(expectedResult, result);
+        }
+    }
+}

tests/BenchmarkDotNet.Tests/XUnit/AppveyorOnlyFactAttribute.cs

@@ -0,0 +1,21 @@
+using System;
+using BenchmarkDotNet.Portability;
+using Xunit;
+
+namespace BenchmarkDotNet.Tests.XUnit
+{
+    public class AppVeyorOnlyFactAttribute : FactAttribute
+    {
+        private const string Message = "Test is available only on the AppVeyor";
+        private static readonly string skip;
+
+        static AppVeyorOnlyFactAttribute()
+        {
+            string value = Environment.GetEnvironmentVariable("APPVEYOR");
+            bool appVeyorDetected = !string.IsNullOrEmpty(value) && value.EqualsWithIgnoreCase("true");
+            skip = appVeyorDetected ? null : Message;
+        }
+
+        public override string Skip => skip;
+    }
+}

tests/BenchmarkDotNet.Tests/XUnit/AppveyorWithClassicFrameworkOnlyFactAttribute.cs

@@ -0,0 +1,21 @@
+namespace BenchmarkDotNet.Tests.XUnit
+{
+    public class AppVeyorWithClassicFrameworkOnlyFactAttribute : AppVeyorOnlyFactAttribute
+    {
+        private const string Message = "Test requires classic .NET Framework";
+
+        private bool classicDotNet
+        {
+            get
+            {
+#if !CORE
+                return true;
+#else
+                return false;
+#endif
+            }
+        }
+
+        public override string Skip => base.Skip ?? (classicDotNet ? null : Message);
+    }
+}