Require Windows 10 or Later and Remove 32-bit Support from PerfView

.pipelines/perfview-job.yml

@@ -35,21 +35,45 @@ steps:
     customFeed: 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public/nuget/v3/index.json'
 
 - task: VSTest@3
-  displayName: 'Run Tests'
+  displayName: 'Run TraceEvent Tests (x86)'
   inputs:
     testAssemblyVer2: |
       **\bin\**\LinuxTracingTests.dll
       **\bin\**\CtfTracingTests.dll
       **\bin\**\SymbolsAuthTests.dll
       **\bin\**\TraceEventTests.dll
-      **\bin\**\PerfViewTests.dll
       **\bin\**\TraceParserGen.Tests.dll
-    testRunTitle: 'PerfView - ${{ parameters.flavor }}'
+    testRunTitle: 'TraceEvent x86 - ${{ parameters.flavor }}'
     vsTestVersion: 'toolsInstaller'
     runTestsInIsolation: true
     donotPublishTestResults: true
     otherConsoleOptions: '--blame'
 
+- task: VSTest@3
+  displayName: 'Run TraceEvent Tests (x64)'
+  inputs:
+    testAssemblyVer2: |
+      **\bin\**\LinuxTracingTests.dll
+      **\bin\**\CtfTracingTests.dll
+      **\bin\**\SymbolsAuthTests.dll
+      **\bin\**\TraceEventTests.dll
+      **\bin\**\TraceParserGen.Tests.dll
+    testRunTitle: 'TraceEvent x64 - ${{ parameters.flavor }}'
+    vsTestVersion: 'toolsInstaller'
+    runTestsInIsolation: true
+    donotPublishTestResults: true
+    otherConsoleOptions: '--blame /Platform:x64'
+
+- task: VSTest@3
+  displayName: 'Run PerfView Tests'
+  inputs:
+    testAssemblyVer2: '**\bin\**\PerfViewTests.dll'
+    testRunTitle: 'PerfView x64 - ${{ parameters.flavor }}'
+    vsTestVersion: 'toolsInstaller'
+    runTestsInIsolation: true
+    donotPublishTestResults: true
+    otherConsoleOptions: '--blame /Platform:x64'
+
 - task: CopyFiles@2
   displayName: 'Copy Files to Artifacts Staging'
   inputs:

README.md

@@ -11,6 +11,12 @@ current version of PerfView.
 
 PerfView requires .NET Framework 4.7.2 or later, which is widely available for all supported versions of Windows.
 
+PerfView and TraceEvent require Windows 10 or Windows Server 2016 or later when running on Windows.
+
+There is no native ARM64 PerfView application build. PerfViewCollect requires the matching
+x64 .NET runtime, whose supported Windows releases may be more restrictive.
+Historical trace files and older target runtimes remain supported for analysis.
+
 ### Are you here about the TraceEvent Library?
 
 PerfView is built on a library called Microsoft.Diagnostics.Tracing.TraceEvent, that knows how to both collect and parse Event Tracing for Windows (ETW) and EventPipe (.NET Core trace) data. Thus if there is any information that PerfView collects and processes that you would like to manipulate yourself programmatically, you would probably be interested in the [TraceEvent Library Documentation](documentation/TraceEvent/TraceEventLibrary.md)

documentation/Downloading.md

@@ -4,6 +4,11 @@ PerfView is a free profiling tool from Microsoft.   This page tells you how to g
 See the [PerfView Overview](https://github.com/Microsoft/perfview#perfview-overview) for general information
 about PerfView.   
 
+PerfView is an x64 application requiring Windows 10 or Windows Server 2016 or later
+and .NET Framework 4.7.2 or later. It can collect from both x86 and x64 target processes.
+Windows-provided x64 emulation may be used where available; there is no native ARM64
+PerfView application build.
+
 # PerfView Releases
 
 The [PerfView GitHub Releases page](https://github.com/Microsoft/perfview/releases) is now the official 
@@ -50,8 +55,8 @@ This confirms that software is authentic. You can also do this by running the si
 # Additional Release Information
 
 The link above allows you to quickly download PerfView.exe which is what you need 95% of the time.
-If you wish to get other files associated with the release (e.g. the 64 bit version, or
-the debugging symbols), or wish to download older releases (not recommended), you can do
+If you wish to get other files associated with the release (e.g. debugging symbols),
+or wish to download older releases (not recommended), you can do
 so by visiting the [PerfView GitHub Releases](https://github.com/Microsoft/perfview/releases).
 
 
@@ -60,4 +65,3 @@ The Microsoft Download Site for PerfView has
 been retired as the official download site for PerfView.  It has been replaced by
 [PerfView GitHub Releases page](https://github.com/Microsoft/perfview/releases) referenced above. 
 
-

documentation/TraceEvent/TraceEventLibrary.md

@@ -35,13 +35,18 @@ class Program
 }
 ```
 
+## Supported Windows Versions
+
+On Windows, TraceEvent requires Windows 10 or Windows Server 2016 or later.
+Its module initializer throws `PlatformNotSupportedException` on older Windows;
+the CLR may wrap this in an initialization exception. This check is skipped on
+Linux and macOS, preserving the library's existing cross-platform capabilities.
+Older traces and target runtimes can still be analyzed on supported hosts.
+
 ## TraceEvent Samples
 
 To see more complete samples that use the APIs in more sophisticated (but not too sophisticated ways). In the [Samples directory](https://github.com/Microsoft/perfview/tree/main/src/TraceEvent/Samples) here are one or two page samples doing interesting things (collecting data, parsing from files or in real time, transforming one ETL file to another etc). Each sample is independent of the others.
 
-One way of getting the samples is to walk through the step by step guide in [Vance's Walkthough on TraceEvent](https://blogs.msdn.microsoft.com/vancem/2014/03/15/walk-through-getting-started-with-etw-traceevent-nuget-samples-package/). This walkthrough uses TraceEvent Samples package, however this code is old (but still completely relevant
-the APIs have not changed). These samples are exactly the samples in Github mentioned above.
-
 The easiest way to build the latest samples is to simply clone the [PerfView Repository](https://github.com/Microsoft/perfview) and and build it. The samples are in the _TraceEventSamples_ project in the PerfView solution. Simply set this project to be your _Startup Project_ (right click on it in Solution Explorer -> Set as Startup Project) and run it (F5). By default will run all the samples.
 
 ## Release Notes for the Microsoft.Diagnostics.Tracing.TraceEvent library

documentation/TraceEvent/TraceEventProgrammersGuide.md

@@ -436,7 +436,7 @@ Capabilities include:
 * The ability to turn on event providers selectively using ETW 'Keywords' and verbosity 'Levels'. You can also pass additional arguments to your provider which `EventSource` sources can pick up. In that way you can create very sophisticated filtering specification as well as execute simple commands (e.g. force a GC, flush the working set, and etc.).
 * The ability to enumerate the ETW providers on the system as well as in a particular process, and the ability to determine what ETW groups (Keywords) you can turn on.
 * Ability to take ETL files and merge them together into a single file.
-* Ability to read an ETL file or real time session and write an ETL file from it, filtering it or adding new events (Windows 8 only).
+* Ability to read an ETL file or real time session and write an ETL file from it, filtering it or adding new events.
 * The ability to capture stack traces when events are being logged.
 * The ability to convert the stacks to symbolic form both for .NET, Jscript, as well as native code.
 * The ability to store events in a new format (ETLX) that allows the events to be accessed efficiently in a random fashion as well as to enumerate the events backwards as well as forwards, and to efficiently represent the stack information.
@@ -456,7 +456,7 @@ Capabilities include:
     * Network I/O.
     * Every packet (with compete data) that comes on or off the network (network sniffer).
     * Every system call.
-    * Sampling of processor CPU counters (instructions executed, branch mispredicts, cache misses, ...) (Windows 8 only).
+    * Sampling of processor CPU counters (instructions executed, branch mispredicts, cache misses, ...).
     * Remote procedure calls.
     * How the machine is configured (disk, memory, CPUs, ...).
 * Access CLR (.NET Runtime) events, including:
@@ -481,13 +481,13 @@ You can also get a reasonably good idea of what is possible by taking a look at
 
 Unfortunately, there are some limitations in ETW that sometimes block it from being used in scenarios where it would otherwise be a natural fit. They are listed here for emphasis.
 
-* You send commands to providers on a machine wide basis. Thus you can't target particular processes (however if you own the event provider code you can pass it extra information as arguments to 'enable' command to the provider and have your provider implement logic to ignore 'enable' commands not intended for it). (Fixed in Windows 8.1).
+* Provider control is machine-wide, but `TraceEventProviderOptions.ProcessIDFilter` and `ProcessNameFilter` can limit collected events to selected processes on supported Windows hosts.
 * Because commands are machine wide and thus give you access to all information on the system, you have to be Elevated (Admin) to turn an ETW session on or off.
 * By design the communication between the controllers and the providers is 'fire and forget'. Thus ETW is not intended to be a general purpose cross process communication mechanism. Don't try to use it as such.
 * In real time mode, events are buffered and there is at least a second or so delay (typically 3 sec) between the firing of the event and the reception by the session (to allow events to be delivered in efficient clumps of many events).
-* Before Windows 8, there could only one kernel session. Thus using kernel mode events for 'monitoring' scenarios was problematic because any other tools that used kernel sessions were likely to interfere by overriding the single Kernel model event logging session.
+* Named sessions can combine kernel and user providers. The special `NT Kernel Logger` session remains kernel-only; reusing its name can interfere with another tool using that session.
 * In general scenarios having multiple controllers (sessions) controlling the same providers is dangerous. It can be done in some cases, but there is a significant potential for interference between the sessions.
-* The file format is private, and before Windows 8 could be quite space inefficient (it compresses 8-to-1). Files can get big fast.
+* ETL files can get large. Compression is available on supported Windows hosts; historical uncompressed traces may be substantially larger.
 * Logging more than 10K events/sec will load the system noticeably (5%). Logging more frequently than 10K/sec should be avoided if possible. Logging 1M events/sec will completely swamp a typical machine.
 
 ## Next Step: Code Samples
@@ -827,7 +827,7 @@ Below are the steps in converting logging an event with a stack to a resolved sy
 1. When the event is logged, the ETW system tries to crawl the stack at runtime. However this can fail for various reasons:
 
     1. On 32-bit machines the crawler assumes the compiler stores unwinding information (EBP frames) on the stack. If the compile does not do this the stack 'breaks' (can't be unwound) and you lose any frames 'toward thread start'.
-    2. On 64-bit processes on 64-bit machines the crawler needs 'unwind' information. For native code this is stored in the EXE, but for Just In Time (JIT) compiled code on Systems **before Windows 8 (or Win2012 server)** the ETW system did not know how to find this unwind information and break at the first frame with JIT compiled code. This is the most common reason for stack breakage, but will diminish machines are upgraded to new OSes.
+    2. For 64-bit processes, the crawler needs unwind information. Historical traces collected **before Windows 8 (or Windows Server 2012)** may have stacks broken at JIT-compiled frames because ETW could not locate that information. This old-host limitation is not a restriction on current collection, but reading an old trace cannot recover frames that were never recorded.
 
     If either of these happen there is nothing wrong with your code as it is an issue with the APP or with the ETW infrastructure. PerfView should have the same problem.
 

src/HeapDump/GCHeapDumper.cs

@@ -684,11 +684,11 @@ private void ResumeProcessIfNecessary(int processID)
                 throw new HeapDumpException("Could not find process with ID " + processID, HR.CouldNotFindProcessId);
             }
 
-            // Determine if we are a Win8 Application.  
+            // Resume packaged applications before collection.
             var fullPackageName = PackageUtil.FullPackageNameForProcess(process);
             if (fullPackageName != null)
             {
-                m_log.WriteLine("Process {0} is a Windows 8 application, resuming that process.", processID);
+                m_log.WriteLine("Process {0} is a packaged application, resuming that process.", processID);
                 var pkgDebugSettings = (IPackageDebugSettings)new PackageDebugSettingsClass();
                 // pkgDebugSettings.EnableDebugging(fullPackageName, null, IntPtr.Zero);
                 pkgDebugSettings.Resume(fullPackageName);
@@ -1609,18 +1609,12 @@ private NodeTypeIndex GetTypeIndexForName(string typeName, string moduleName, in
 public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);
 
 /// <summary>
-/// Gets at Win8 Package information.  
+/// Gets package information for a process.
 /// </summary>
 internal class PackageUtil
 {
     public static string FullPackageNameForProcess(Process process)
     {
-        var version = Environment.OSVersion.Version.Major * 10 + Environment.OSVersion.Version.Minor;
-        if (version < 62)
-        {
-            return null;        // Packages only exist on Windows 8
-        }
-
         var packageFullNameBuff = new StringBuilder(512);
         int packageFullNameBuffLen = packageFullNameBuff.Capacity;
         var hr = GetPackageFullName(process.Handle, ref packageFullNameBuffLen, packageFullNameBuff);
@@ -1656,4 +1650,3 @@ internal interface IPackageDebugSettings
 #endregion
 
 
-

src/PerfView.Tests/HeapDumperTests.cs

@@ -0,0 +1,50 @@
+using PerfView;
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using Xunit;
+
+namespace PerfViewTests
+{
+    public class HeapDumperTests
+    {
+        [Fact]
+        public void DetectsX64Target()
+        {
+            using (var process = Process.GetCurrentProcess())
+            {
+                Assert.Equal(ProcessorArchitecture.Amd64, HeapDumper.GetArchForProcess(process.Id));
+            }
+        }
+
+        [Fact]
+        public void DetectsX86TargetFromX64Host()
+        {
+            var startInfo = new ProcessStartInfo(
+                Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.SystemX86), "cmd.exe"),
+                "/d /c set /p PERFVIEW_TEST=")
+            {
+                UseShellExecute = false,
+                CreateNoWindow = true,
+                RedirectStandardInput = true
+            };
+            using (var process = Process.Start(startInfo))
+            {
+                try
+                {
+                    Assert.Equal(ProcessorArchitecture.X86, HeapDumper.GetArchForProcess(process.Id));
+                }
+                finally
+                {
+                    process.StandardInput.Close();
+                    if (!process.WaitForExit(5000))
+                    {
+                        process.Kill();
+                        process.WaitForExit();
+                    }
+                }
+            }
+        }
+    }
+}

src/PerfView.Tests/PerfView.Tests.csproj

@@ -5,6 +5,7 @@
     <TargetFrameworks>net462</TargetFrameworks>
     <RootNamespace>PerfViewTests</RootNamespace>
     <AssemblyName>PerfViewTests</AssemblyName>
+    <PlatformTarget>x64</PlatformTarget>
     <Description>Unit tests for PerfView.</Description>
     <Copyright>Copyright © Microsoft 2016</Copyright>
 

src/PerfView.Tests/StartupTests.cs

@@ -0,0 +1,68 @@
+using PerfView;
+using System;
+using System.ComponentModel;
+using Xunit;
+
+namespace PerfViewTests
+{
+    public class StartupTests
+    {
+        [Fact]
+        public void ApplicationAndTestHostAreX64()
+        {
+            Assert.Equal(8, IntPtr.Size);
+            Assert.Equal(System.Reflection.ProcessorArchitecture.Amd64, typeof(Startup).Assembly.GetName().ProcessorArchitecture);
+        }
+
+        [Fact]
+        public void HostResourcesUseX64AndKeepBothHelpers()
+        {
+            Assert.Equal("amd64", global::Utilities.SupportFiles.ProcessArchitectureDirectory);
+            var resources = typeof(Startup).Assembly.GetManifestResourceNames();
+            Assert.Contains(@".\runtimes\win-x64\native\WebView2Loader.dll", resources);
+            Assert.DoesNotContain(@".\runtimes\win-x86\native\WebView2Loader.dll", resources);
+            Assert.DoesNotContain(@".\runtimes\win-arm64\native\WebView2Loader.dll", resources);
+            Assert.Contains(@".\amd64\msdia140.dll", resources);
+            Assert.DoesNotContain(@".\x86\msdia140.dll", resources);
+            Assert.DoesNotContain(resources, name => name.StartsWith(@".\arm\", StringComparison.Ordinal));
+            foreach (var arch in new[] { "x86", "amd64" })
+            {
+                foreach (var file in new[] { "HeapDump.exe", "EtwClrProfiler.dll", "KernelTraceControl.dll" })
+                {
+                    Assert.Contains(@".\" + arch + @"\" + file, resources);
+                }
+            }
+        }
+
+        [Fact]
+        public void UnsupportedWindowsReportsOnceWithoutStarting()
+        {
+            int reports = 0;
+            int result = Startup.Run(() => false, message =>
+            {
+                reports++;
+                Assert.Contains("Windows 10", message);
+            }, () => throw new InvalidOperationException("Application must not start."));
+
+            Assert.Equal(1, result);
+            Assert.Equal(1, reports);
+        }
+
+        [Fact]
+        public void SupportedWindowsReturnsApplicationStatus()
+        {
+            Assert.Equal(42, Startup.Run(() => true,
+                message => throw new InvalidOperationException(message), () => 42));
+        }
+
+        [Fact]
+        public void VersionQueryFailureReportsWithoutStarting()
+        {
+            string reported = null;
+            int result = Startup.Run(() => throw new Win32Exception("Version query failed."),
+                message => reported = message, () => throw new InvalidOperationException("Application must not start."));
+            Assert.Equal(1, result);
+            Assert.Equal("Version query failed.", reported);
+        }
+    }
+}