Improve the dump-arrays performance on Windows

tools/swift-inspect/Package.swift

@@ -1,10 +1,13 @@
-// swift-tools-version:5.2
+// swift-tools-version:5.3
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
 
 let package = Package(
     name: "swift-inspect",
+    products: [
+        .library(name: "SwiftInspectClient", type: .dynamic, targets: ["SwiftInspectClient"]),
+    ],
     dependencies: [
         .package(url: "https://github.com/apple/swift-argument-parser", from: "0.0.1"),
     ],
@@ -16,12 +19,18 @@ let package = Package(
             dependencies: [
                 "SymbolicationShims",
                 .product(name: "ArgumentParser", package: "swift-argument-parser"),
+                .target(name: "SwiftInspectClient", condition: .when(platforms: [.windows])),
+                .target(name: "SwiftInspectClientInterface", condition: .when(platforms: [.windows])),
             ],
             swiftSettings: [
                 .unsafeFlags([
                     "-parse-as-library",
                 ]),
             ]),
+        .target(
+            name: "SwiftInspectClient"),
+        .systemLibrary(
+            name: "SwiftInspectClientInterface"),
         .testTarget(
             name: "swiftInspectTests",
             dependencies: ["swift-inspect"]),

tools/swift-inspect/Sources/SwiftInspectClient/SwiftInspectClient.cpp

@@ -0,0 +1,222 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(_WIN32)
+
+#pragma comment(lib, "swiftCore.lib")
+
+#include "../SwiftInspectClientInterface/SwiftInspectClientInterface.h"
+#include <assert.h>
+#include <memory>
+#include <stdio.h>
+#include <strsafe.h>
+#include <vector>
+#include <windows.h>
+
+namespace {
+
+struct ScopedHandle {
+  HANDLE Handle;
+  explicit ScopedHandle(HANDLE Handle) noexcept : Handle(Handle) {}
+  ~ScopedHandle() noexcept {
+    if (Handle != NULL && Handle != INVALID_HANDLE_VALUE) {
+      CloseHandle(Handle);
+    }
+  }
+  operator HANDLE() const { return Handle; }
+};
+
+struct ScopedViewOfFile {
+  void *View;
+  explicit ScopedViewOfFile(void *View) noexcept : View(View) {}
+  ~ScopedViewOfFile() noexcept {
+    if (View != NULL) {
+      UnmapViewOfFile(View);
+    }
+  }
+  void *get() const { return View; }
+  template <typename T> T *as() const { return reinterpret_cast<T *>(View); }
+};
+
+struct ScopedHeapLock {
+  HANDLE Heap;
+  bool Failure = false;
+  explicit ScopedHeapLock(HANDLE Heap) noexcept : Heap(Heap) {
+    if (!HeapLock(Heap)) {
+      OutputDebugStringA("Failed to lock heap\n");
+      Failure = true;
+    }
+  }
+  ~ScopedHeapLock() noexcept {
+    if (Heap != NULL && !Failure) {
+      if (!HeapUnlock(Heap)) {
+        OutputDebugStringA("Failed to lock heap\n");
+      }
+    }
+  }
+};
+
+} // anonymous namespace
+
+#define BUF_NUM_ENTRIES (BUF_SIZE / sizeof(HeapEntry))
+
+static int heapWalk() {
+  // Format the shared mem and event object names
+  DWORD Pid = GetCurrentProcessId();
+  char SharedMemName[128];
+  char ReadEventName[128];
+  char WriteEventName[128];
+  if (StringCbPrintfA(SharedMemName, sizeof(SharedMemName), "%hS-%lu",
+                      SHARED_MEM_NAME_PREFIX, Pid) != S_OK) {
+    OutputDebugStringA("StringCbPrintfA for SharedMemName failed\n");
+    return 1;
+  }
+  if (StringCbPrintfA(ReadEventName, sizeof(ReadEventName), "%hS-%lu",
+                      READ_EVENT_NAME_PREFIX, Pid) != S_OK) {
+    OutputDebugStringA("StringCbPrintfA for ReadEventName failed\n");
+    return 1;
+  }
+  if (StringCbPrintfA(WriteEventName, sizeof(WriteEventName), "%hS-%lu",
+                      WRITE_EVENT_NAME_PREFIX, Pid) != S_OK) {
+    OutputDebugStringA("StringCbPrintfA for WriteEventName failed\n");
+    return 1;
+  }
+
+  ScopedHandle MapFile(
+      OpenFileMappingA(FILE_MAP_ALL_ACCESS, false, SharedMemName));
+  if (MapFile == NULL) {
+    OutputDebugStringA("OpenFileMapping failed\n");
+    return 1;
+  }
+  ScopedViewOfFile Buf(
+      MapViewOfFile(MapFile.Handle, FILE_MAP_ALL_ACCESS, 0, 0, BUF_SIZE));
+  if (Buf.get() == NULL) {
+    OutputDebugStringA("MapViewOfFile failed\n");
+    return 1;
+  }
+  std::memset(Buf.get(), 0, BUF_SIZE);
+  ScopedHandle WriteEvent(OpenEventA(EVENT_ALL_ACCESS, false, WriteEventName));
+  if (WriteEvent == NULL) {
+    OutputDebugStringA("OpenEventA failed\n");
+    return 1;
+  }
+  ScopedHandle ReadEvent(OpenEventA(EVENT_ALL_ACCESS, false, ReadEventName));
+  if (ReadEvent == NULL) {
+    OutputDebugStringA("OpenEventA failed\n");
+    return 1;
+  }
+
+  // Collect heaps. This is a loop because GetProcessHeaps requires
+  // specifying the max number of heaps to get upfront.
+  std::vector<HANDLE> Heaps;
+  while (TRUE) {
+    DWORD ActualHeapCount = GetProcessHeaps(Heaps.size(), Heaps.data());
+    if (ActualHeapCount <= Heaps.size()) {
+      Heaps.resize(ActualHeapCount);
+      break;
+    }
+    Heaps.resize(ActualHeapCount);
+  }
+
+  // Iterate heaps and heap entries
+  size_t Count = 0;
+  for (HANDLE Heap : Heaps) {
+    PROCESS_HEAP_ENTRY Entry;
+
+    // NOTE: Be careful not to reenter the heap lock while holding the
+    // heap lock or else it would hang.
+    ScopedHeapLock HeapLock(Heap);
+    if (HeapLock.Failure) {
+      continue;
+    }
+
+    Entry.lpData = NULL;
+    while (HeapWalk(Heap, &Entry)) {
+      if ((Entry.wFlags & PROCESS_HEAP_REGION) ||
+          (Entry.wFlags & PROCESS_HEAP_UNCOMMITTED_RANGE) ||
+          (!(Entry.wFlags & PROCESS_HEAP_ENTRY_BUSY))) {
+        continue;
+      }
+      assert(Count < BUF_NUM_ENTRIES);
+      Buf.as<HeapEntry>()[Count] = {
+        reinterpret_cast<uintptr_t>(Entry.lpData),
+        Entry.cbData + Entry.cbOverhead
+      };
+      if (++Count == BUF_NUM_ENTRIES) {
+        if (!SetEvent(ReadEvent)) {
+          OutputDebugStringA("SetEvent on ReadEvent failed\n");
+          return 1;
+        }
+        DWORD Wait = WaitForSingleObject(WriteEvent, WAIT_TIMEOUT_MS);
+        if (Wait != WAIT_OBJECT_0) {
+          char Msg[128];
+          if (StringCbPrintfA(Msg, sizeof(Msg),
+                              "WaitForSingleObject failed %lu\n",
+                              Wait) == S_OK) {
+            OutputDebugStringA(Msg);
+          }
+          return 1;
+        }
+        std::memset(Buf.get(), 0, BUF_SIZE);
+        Count = 0;
+      }
+    }
+
+    if (Count > 0) {
+      // Write the remaining entries.
+      if (!SetEvent(ReadEvent)) {
+        OutputDebugStringA("SetEvent on ReadEvent failed\n");
+        return 1;
+      }
+      DWORD Wait = WaitForSingleObject(WriteEvent, WAIT_TIMEOUT_MS);
+      if (Wait != WAIT_OBJECT_0) {
+        char Msg[128];
+        if (StringCbPrintfA(Msg, sizeof(Msg),
+                            "WaitForSingleObject failed %lu\n", Wait) == S_OK) {
+          OutputDebugStringA(Msg);
+        }
+        return 1;
+      }
+      std::memset(Buf.get(), 0, BUF_SIZE);
+      Count = 0;
+    }
+  }
+
+  // Indicate the end of iteration with one last write.
+  std::memset(Buf.get(), 0, BUF_SIZE);
+  Buf.as<HeapEntry>()[0].Address = -1;
+  if (!SetEvent(ReadEvent)) {
+    OutputDebugStringA("SetEvent at the end of heap iteration failed\n");
+    return 1;
+  }
+  DWORD Wait = WaitForSingleObject(WriteEvent, WAIT_TIMEOUT_MS);
+  if (Wait != WAIT_OBJECT_0) {
+    char Msg[128];
+    if (StringCbPrintfA(Msg, sizeof(Msg), "WaitForSingleObject failed %lu\n",
+                        Wait) == S_OK) {
+      OutputDebugStringA(Msg);
+    }
+    return 1;
+  }
+
+  return 0;
+}
+
+BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call,
+                      LPVOID lpReserved) {
+  if (ul_reason_for_call == DLL_PROCESS_ATTACH) {
+    heapWalk();
+  }
+  return TRUE;
+}
+
+#endif

tools/swift-inspect/Sources/SwiftInspectClientInterface/SwiftInspectClientInterface.h

@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(_WIN32)
+
+#include <stdint.h>
+
+#define BUF_SIZE 512
+#define SHARED_MEM_NAME_PREFIX "Local\\SwiftInspectFileMapping"
+#define READ_EVENT_NAME_PREFIX "Local\\SwiftInspectReadEvent"
+#define WRITE_EVENT_NAME_PREFIX "Local\\SwiftInspectWriteEvent"
+#define WAIT_TIMEOUT_MS 30000
+
+struct HeapEntry {
+  uintptr_t Address;
+  uintptr_t Size;
+};
+
+#endif

tools/swift-inspect/Sources/SwiftInspectClientInterface/module.modulemap

@@ -0,0 +1,4 @@
+module SwiftInspectClientInterface {
+  header "SwiftInspectClientInterface.h"
+  export *
+}

tools/swift-inspect/Sources/swift-inspect/WinSDK+Extentions.swift

@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#if os(Windows)
+
+import WinSDK
+
+internal let FILE_MAP_ALL_ACCESS = DWORD(
+  STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_WRITE | SECTION_MAP_READ
+    | SECTION_MAP_EXECUTE | SECTION_EXTEND_SIZE)
+
+#endif