mono · alexrp · Sep 9, 2016 · Sep 9, 2016 · Sep 9, 2016 · Sep 9, 2016
diff --git a/acceptance-tests/profiler-stress.mk b/acceptance-tests/profiler-stress.mk
@@ -4,7 +4,8 @@ SYS_REFS = \
 	System.Data.dll \
 	System.Runtime.Serialization.dll \
 	System.Xml.dll \
-	System.Xml.Linq.dll
+	System.Xml.Linq.dll \
+	Mono.Posix.dll
 
 check-profiler-stress:
 	@$(MAKE) validate-benchmarker RESET_VERSIONS=1

diff --git a/acceptance-tests/profiler-stress/runner.cs b/acceptance-tests/profiler-stress/runner.cs
@@ -1,7 +1,14 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
+using System.Globalization;
 using System.IO;
 using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Xml;
+using Mono.Unix.Native;
 using Newtonsoft.Json;
 
 // Shut up CLS compliance warnings from Json.NET.
@@ -10,7 +17,8 @@
 namespace Mono.Profiling.Tests.Stress {
 
 	// https://github.com/xamarin/benchmarker/blob/master/tools/libdbmodel/Benchmark.cs
-	class Benchmark {
+	sealed class Benchmark {
+
 		public string Name { get; set; }
 		public string TestDirectory { get; set; }
 		public bool OnlyExplicit { get; set; }
@@ -24,8 +32,24 @@ public static Benchmark Load (string file)
 		}
 	}
 
+	sealed class TestResult {
+
+		public Benchmark Benchmark { get; set; }
+		public ProcessStartInfo StartInfo { get; set; }
+		public Stopwatch Stopwatch { get; set; } = new Stopwatch ();
+		public int? ExitCode { get; set; }
+		public StringBuilder StandardOutput { get; set; } = new StringBuilder ();
+		public StringBuilder StandardError { get; set; } = new StringBuilder ();
+	}
+
 	static class Program {
 
+		static readonly TimeSpan _timeout = TimeSpan.FromHours (6);
+
+		static string FilterInvalidXmlChars (string text) {
+			return Regex.Replace (text, @"[^\x09\x0A\x0D\x20-\uD7FF\uE000-\uFFFD\u10000-\u10FFFF]", string.Empty);
+		}
+
 		static int Main ()
 		{
 			var depDir = Path.Combine ("..", "external", "benchmarker");
@@ -44,8 +68,7 @@ static int Main ()
 			var rand = new Random ();
 			var cpus = Environment.ProcessorCount;
 
-			var successes = 0;
-			var failures = 0;
+			var results = new List<TestResult> (benchmarks.Length);
 
 			var sw = Stopwatch.StartNew ();
 
@@ -66,6 +89,8 @@ static int Main ()
 					WorkingDirectory = Path.Combine (testDir, bench.TestDirectory),
 					FileName = monoPath,
 					Arguments = $"--debug --profile=log:{profOptions} " + string.Join (" ", bench.CommandLine),
+					RedirectStandardOutput = true,
+					RedirectStandardError = true,
 				};
 
 				info.EnvironmentVariables.Clear ();
@@ -77,32 +102,177 @@ static int Main ()
 				Console.WriteLine ($"[{sw.Elapsed.ToString ("G")}] {progress} Running {bench.Name} with profiler options: {profOptions}");
 				Console.ResetColor ();
 
-				var sw2 = Stopwatch.StartNew ();
+				var result = new TestResult {
+					Benchmark = bench,
+					StartInfo = info,
+				};
+
+				using (var proc = new Process ()) {
+					proc.StartInfo = info;
+
+					proc.OutputDataReceived += (sender, args) => {
+						if (args.Data != null)
+							result.StandardOutput.AppendLine (args.Data);
+					};
+
+					proc.ErrorDataReceived += (sender, args) => {
+						if (args.Data != null)
+							result.StandardError.AppendLine (args.Data);
+					};
+
+					result.Stopwatch.Start ();
 
-				using (var proc = Process.Start (info)) {
-					proc.WaitForExit ();
-					sw2.Stop ();
+					proc.Start ();
 
-					Console.WriteLine ();
+					proc.BeginOutputReadLine ();
+					proc.BeginErrorReadLine ();
 
-					if (proc.ExitCode != 0)
-						failures++;
-					else
-						successes++;
+					if (!proc.WaitForExit ((int) _timeout.TotalMilliseconds)) {
+						// Force a thread dump.
+						Syscall.kill (proc.Id, Signum.SIGQUIT);
+						Thread.Sleep (1000);
 
-					Console.ForegroundColor = proc.ExitCode != 0 ? ConsoleColor.Red : ConsoleColor.Green;
-					Console.WriteLine ($"[{sw.Elapsed.ToString ("G")}] {progress} {bench.Name} took {sw2.Elapsed.ToString ("G")} and exited with code: {proc.ExitCode}");
+						try {
+							proc.Kill ();
+						} catch (Exception) {
+						}
+					} else
+						result.ExitCode = proc.ExitCode;
+
+					result.Stopwatch.Stop ();
+				}
+
+				var resultStr = result.ExitCode == null ? "timed out" : $"exited with code: {result.ExitCode}";
+
+				Console.ForegroundColor = result.ExitCode != 0 ? ConsoleColor.Red : ConsoleColor.Green;
+				Console.WriteLine ($"[{sw.Elapsed.ToString ("G")}] {progress} {bench.Name} took {result.Stopwatch.Elapsed.ToString ("G")} and {resultStr}");
+				Console.ResetColor ();
+
+				if (result.ExitCode != 0) {
+					Console.ForegroundColor = ConsoleColor.Red;
+					Console.WriteLine ("===== stdout =====");
 					Console.ResetColor ();
+
+					Console.WriteLine (result.StandardOutput.ToString ());
+
+					Console.ForegroundColor = ConsoleColor.Red;
+					Console.WriteLine ("===== stderr =====");
+					Console.ResetColor ();
+
+					Console.WriteLine (result.StandardError.ToString ());
 				}
+
+				results.Add (result);
 			}
 
 			sw.Stop ();
 
-			Console.ForegroundColor = failures != 0 ? ConsoleColor.Red : ConsoleColor.Green;
-			Console.WriteLine ($"[{sw.Elapsed.ToString ("G")}] Finished with {successes}/{benchmarks.Length} passing tests");
+			var successes = results.Count (r => r.ExitCode == 0);
+			var failures = results.Count (r => r.ExitCode != null && r.ExitCode != 0);
+			var timeouts = results.Count (r => r.ExitCode == null);
+
+			var settings = new XmlWriterSettings {
+				NewLineOnAttributes = true,
+				Indent = true,
+			};
+
+			using (var writer = XmlWriter.Create ("TestResult-profiler-stress.xml", settings)) {
+				writer.WriteStartDocument ();
+				writer.WriteComment ("This file represents the results of running a test suite");
+
+				writer.WriteStartElement ("test-results");
+				writer.WriteAttributeString ("name", "profiler-stress-tests.dummy");
+				writer.WriteAttributeString ("total", results.Count.ToString ());
+				writer.WriteAttributeString ("failures", failures.ToString ());
+				writer.WriteAttributeString ("not-run", "0");
+				writer.WriteAttributeString ("date", DateTime.Now.ToString ("yyyy-MM-dd"));
+				writer.WriteAttributeString ("time", DateTime.Now.ToString ("HH:mm:ss"));
+
+				writer.WriteStartElement ("environment");
+				writer.WriteAttributeString ("nunit-version", "2.4.8.0");
+				writer.WriteAttributeString ("clr-version", Environment.Version.ToString ());
+				writer.WriteAttributeString ("os-version", Environment.OSVersion.ToString ());
+				writer.WriteAttributeString ("platform", Environment.OSVersion.Platform.ToString ());
+				writer.WriteAttributeString ("cwd", Environment.CurrentDirectory);
+				writer.WriteAttributeString ("machine-name", Environment.MachineName);
+				writer.WriteAttributeString ("user", Environment.UserName);
+				writer.WriteAttributeString ("user-domain", Environment.UserDomainName);
+				writer.WriteEndElement ();
+
+				writer.WriteStartElement ("culture-info");
+				writer.WriteAttributeString ("current-culture", CultureInfo.CurrentCulture.Name);
+				writer.WriteAttributeString ("current-uiculture", CultureInfo.CurrentUICulture.Name);
+				writer.WriteEndElement ();
+
+				writer.WriteStartElement ("test-suite");
+				writer.WriteAttributeString ("name", "profiler-stress-tests.dummy");
+				writer.WriteAttributeString ("success", (failures + timeouts == 0).ToString ());
+				writer.WriteAttributeString ("time", ((int) sw.Elapsed.TotalSeconds).ToString ());
+				writer.WriteAttributeString ("asserts", (failures + timeouts).ToString ());
+				writer.WriteStartElement ("results");
+
+				writer.WriteStartElement ("test-suite");
+				writer.WriteAttributeString ("name", "MonoTests");
+				writer.WriteAttributeString ("success", (failures + timeouts == 0).ToString ());
+				writer.WriteAttributeString ("time", ((int) sw.Elapsed.TotalSeconds).ToString ());
+				writer.WriteAttributeString ("asserts", (failures + timeouts).ToString ());
+				writer.WriteStartElement ("results");
+
+				writer.WriteStartElement ("test-suite");
+				writer.WriteAttributeString ("name", "profiler-stress");
+				writer.WriteAttributeString ("success", (failures + timeouts == 0).ToString ());
+				writer.WriteAttributeString ("time", ((int) sw.Elapsed.TotalSeconds).ToString ());
+				writer.WriteAttributeString ("asserts", (failures + timeouts).ToString ());
+				writer.WriteStartElement ("results");
+
+				foreach (var result in results) {
+					var timeoutStr = result.ExitCode == null ? "_timeout" : string.Empty;
+
+					writer.WriteStartElement ("test-case");
+					writer.WriteAttributeString ("name", $"MonoTests.profiler-stress.{result.Benchmark.Name}{timeoutStr}");
+					writer.WriteAttributeString ("executed", "True");
+					writer.WriteAttributeString ("success", (result.ExitCode == 0).ToString ());
+					writer.WriteAttributeString ("time", ((int) result.Stopwatch.Elapsed.TotalSeconds).ToString ());
+					writer.WriteAttributeString ("asserts", result.ExitCode == 0 ? "0" : "1");
+
+					if (result.ExitCode != 0) {
+						writer.WriteStartElement ("failure");
+
+						writer.WriteStartElement ("message");
+						writer.WriteCData (FilterInvalidXmlChars (result.StandardOutput.ToString ()));
+						writer.WriteEndElement ();
+
+						writer.WriteStartElement ("stack-trace");
+						writer.WriteCData (FilterInvalidXmlChars (result.StandardError.ToString ()));
+						writer.WriteEndElement ();
+
+						writer.WriteEndElement ();
+					}
+
+					writer.WriteEndElement ();
+				}
+
+				writer.WriteEndElement ();
+				writer.WriteEndElement ();
+
+				writer.WriteEndElement ();
+				writer.WriteEndElement ();
+
+				writer.WriteEndElement ();
+				writer.WriteEndElement ();
+
+				writer.WriteEndElement ();
+
+				writer.WriteEndDocument ();
+			}
+
+			var failureStr = failures + timeouts != 0 ? $" ({failures} failures, {timeouts} timeouts)" : string.Empty;
+
+			Console.ForegroundColor = failures + timeouts != 0 ? ConsoleColor.Red : ConsoleColor.Green;
+			Console.WriteLine ($"[{sw.Elapsed.ToString ("G")}] Finished with {successes}/{results.Count} passing tests{failureStr}");
 			Console.ResetColor ();
 
-			return failures;
+			return failures + timeouts;
 		}
 	}
 }
diff --git a/configure.ac b/configure.ac
@@ -2666,12 +2666,6 @@ fi
 
 AC_ARG_ENABLE(bcl-opt, [  --disable-bcl-opt	BCL is compiled with no optimizations (allows accurate BCL debugging)], test_bcl_opt=$enableval, test_bcl_opt=yes)
 
-AC_ARG_ENABLE(perf-events, [  --enable-perf-events Enable using `perf` for profiling on Linux], test_perf_events=$enableval, test_perf_events=no)
-if test "x$test_perf_events" = "xyes"; then
-	AC_DEFINE(ENABLE_PERF_EVENTS, 1, [Enable using `perf` for profiling on Linux])
-	AC_SUBST(ENABLE_PERF_EVENTS)
-fi
-
 AC_MSG_CHECKING([if big-arrays are to be enabled])
 AC_ARG_ENABLE(big-arrays,  [  --enable-big-arrays	Enable the allocation and indexing of arrays greater than Int32.MaxValue], enable_big_arrays=$enableval, enable_big_arrays=no)
 if test "x$enable_big_arrays" = "xyes" ; then

diff --git a/man/mprof-report.1 b/man/mprof-report.1
@@ -92,7 +92,7 @@ provided by the Mono runtime and write them to a file named
 \f[I]output.mlpd\f[].
 When no option is specified, it is equivalent to using:
 .PP
-\f[B]--profile=log:calls,alloc,output=output.mlpd,maxframes=8,calldepth=100\f[]
+\f[B]--profile=log:calls,alloc,output=output.mlpd,maxframes=32,calldepth=100\f[]
 .PP
 The following options can be used to modify this default behaviour.
 Each option is separated from the next by a \f[B],\f[] character,
@@ -139,41 +139,16 @@ garbage collections
 to the control port
 .RE
 .IP \[bu] 2
-\f[I]sample[=TYPE[/FREQ]]\f[]: collect statistical samples of the
+\f[I]sample[=FREQ]\f[]: collect statistical samples of the
 program behaviour.
 The default is to collect a 100 times per second (100 Hz) the
 instruction pointer.
-This is equivalent to the value \[lq]cycles/100\[rq].
+This is equivalent to the value \[lq]100\[rq].
 A value of zero for \f[I]FREQ\f[] effectively disables sampling.
-On some systems, like with recent Linux kernels, it is possible to
-cause the sampling to happen for other events provided by the
-performance counters of the cpu.
-In this case, \f[I]TYPE\f[] can be one of:
-.RS 2
-.IP \[bu] 2
-\f[I]cycles\f[]: processor cycles
-.IP \[bu] 2
-\f[I]instr\f[]: executed instructions
-.IP \[bu] 2
-\f[I]cacherefs\f[]: cache references
-.IP \[bu] 2
-\f[I]cachemiss\f[]: cache misses
-.IP \[bu] 2
-\f[I]branches\f[]: executed branches
-.IP \[bu] 2
-\f[I]branchmiss\f[]: mispredicted branches
-.RE
-.IP \[bu] 2
-\f[I]time=TIMER\f[]: use the TIMER timestamp mode.
-TIMER can have the following values:
-.RS 2
-.IP \[bu] 2
-\f[I]fast\f[]: a usually faster but possibly more inaccurate timer
-.RE
 .IP \[bu] 2
 \f[I]maxframes=NUM\f[]: when a stack trace needs to be performed,
 collect \f[I]NUM\f[] frames at the most.
-The default is 8.
+The default is 32.
 .IP \[bu] 2
 \f[I]maxsamples=NUM\f[]: stop allocating reusable sample events
 once \f[I]NUM\f[] events have been allocated (a value of zero for
@@ -234,16 +209,15 @@ The following commands are available:
 \f[I]heapshot\f[]: perform a heapshot as soon as possible
 .RE
 .IP \[bu] 2
-\f[I]counters\f[]: sample counters values every 1 second. This allow
-a really lightweight way to have insight in some of the runtime key
-metrics. Counters displayed in non verbose mode are : Methods from AOT,
-Methods JITted using mono JIT, Methods JITted using LLVM, Total time
-spent JITting (sec), User Time, System Time, Total Time, Working Set,
-Private Bytes, Virtual Bytes, Page Faults and CPU Load Average (1min,
-5min and 15min).
+\f[I]nocounters\f[]: disables sampling of runtime and performance
+counters, which is normally done every 1 second.
 .IP \[bu] 2
 \f[I]coverage\f[]: collect code coverage data. This implies enabling
 the \f[I]calls\f[] option.
+.IP \[bu] 2
+\f[I]onlycoverage\f[]: can only be used with \f[I]coverage\f[]. This
+disables most other events so that the profiler mostly only collects
+coverage data.
 .RE
 .SS Analyzing the profile data
 .PP
@@ -274,10 +248,6 @@ with the \f[I]--maxframes=NUM\f[] option:
 The stack trace info will be available if method enter/leave events
 have been recorded or if stack trace collection wasn't explicitly
 disabled with the \f[I]maxframes=0\f[] profiler option.
-Note that the profiler will collect up to 8 frames by default at
-specific events when the \f[I]nocalls\f[] option is used, so in
-that case, if more stack frames are required in mprof-report, a
-bigger value for maxframes when profiling must be used, too.
 .PP
 The \f[I]--traces\f[] option also controls the reverse reference
 feature in the heapshot report: for each class it reports how many
@@ -487,15 +457,6 @@ option: especially if the managed heap is big, since every object
 needs to be inspected.
 The \f[I]MODE\f[] parameter of the \f[I]heapshot\f[] option can be
 used to reduce the frequency of the heap shots.
-.IP "\f[I]Reduce the timestamp overhead\f[]" 4
-.Sp
-On many operating systems or architectures what actually slows down
-profiling is the function provided by the system to get timestamp
-information.
-The \f[I]time=fast\f[] profiler option can be usually used to speed
-up this operation, but, depending on the system, time accounting
-may have some level of approximation (though statistically the data
-should be still fairly valuable).
 .SS Dealing with the size of the data files
 .PP
 When collecting a lot of information about a profiled program, huge

diff --git a/mono/cil/cil-opcodes.xml b/mono/cil/cil-opcodes.xml
@@ -320,4 +320,5 @@
 <opcode name="mono_lddomain" input="Pop0" output="PushI" args="InlineNone" o1="0xF0" o2="0x19" flow="next" />
 <opcode name="mono_atomic_store_i4" input="PopI+PopI" output="Push0" args="InlineI" o1="0xF0" o2="0x1A" flow="next" />
 <opcode name="mono_get_last_error" input="Pop0" output="PushI" args="InlineNone" o1="0xF0" o2="0x1B" flow="next" />
+<opcode name="mono_ldptr_profiler_events" input="Pop0" output="PushI" args="InlineNone" o1="0xF0" o2="0x1C" flow="next" />
 </opdesc>