Improve the dump-arrays performance on Windows

Use the HeapWalk API for heap iteration instead of the
Heap32First/Next API, which was known to be slow. Since HeapWalk only
works locally, it requires using a remote thread and a DLL.

Author: hjyamauchi

tools/swift-inspect/Package.swift

@@ -5,6 +5,9 @@ import PackageDescription
 
 let package = Package(
     name: "swift-inspect",
+    products: [
+        .library(name: "SwiftInspectHeapWalk", type: .dynamic, targets: ["SwiftInspectHeapWalk"]),
+    ],
     dependencies: [
         .package(url: "https://github.com/apple/swift-argument-parser", from: "0.0.1"),
     ],
@@ -16,12 +19,15 @@ let package = Package(
             dependencies: [
                 "SymbolicationShims",
                 .product(name: "ArgumentParser", package: "swift-argument-parser"),
+                "SwiftInspectHeapWalk",
             ],
             swiftSettings: [
                 .unsafeFlags([
                     "-parse-as-library",
                 ]),
             ]),
+        .target(
+            name: "SwiftInspectHeapWalk"),
         .testTarget(
             name: "swiftInspectTests",
             dependencies: ["swift-inspect"]),

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

@@ -0,0 +1,184 @@
+#if defined(_WIN32)
+
+#pragma comment(lib, "swiftCore.lib")
+
+#include <windows.h>
+#include <stdio.h>
+
+namespace {
+struct HeapEntry {
+  uintptr_t address;
+  uintptr_t size;
+};
+} // anonymous namespace
+
+#define BUF_SIZE 512
+#define BUF_NUM_ENTRIES (BUF_SIZE / sizeof(HeapEntry))
+#define SHARED_MEM_NAME "Local\\SwiftInspectFileMapping"
+#define READ_EVENT_NAME "Local\\SwiftInspectReadEvent"
+#define WRITE_EVENT_NAME "Local\\SwiftInspectWriteEvent"
+#define WAIT_TIMEOUT_MS 30000
+
+static int heapWalk() {
+  HANDLE hMapFile = OpenFileMappingA(FILE_MAP_ALL_ACCESS, false,
+                                     SHARED_MEM_NAME);
+  if (hMapFile == NULL) {
+    printf("OpenFileMapping failed\n");
+    return 1;
+  }
+  HeapEntry *buf = (HeapEntry *)
+    MapViewOfFile(hMapFile,
+                  FILE_MAP_ALL_ACCESS,
+                  0,
+                  0,
+                  BUF_SIZE);
+  if (buf == NULL) {
+    printf("MapViewOfFile failed\n");
+    CloseHandle(hMapFile);
+    return 1;
+  }
+  memset(buf, 0, BUF_SIZE);
+  HANDLE writeEvent = OpenEventA(EVENT_ALL_ACCESS,
+                                 false,
+                                 WRITE_EVENT_NAME);
+  if (writeEvent == NULL) {
+    printf("OpenEventA failed\n");
+    CloseHandle(hMapFile);
+    UnmapViewOfFile(buf);
+    return 1;
+  }
+  HANDLE readEvent = OpenEventA(EVENT_ALL_ACCESS,
+                                false,
+                                READ_EVENT_NAME);
+  if (readEvent == NULL) {
+    printf("OpenEventA failed\n");
+    CloseHandle(hMapFile);
+    UnmapViewOfFile(buf);
+    CloseHandle(writeEvent);
+    return 1;
+  }
+
+  auto cleanupIPC = [&] {
+    CloseHandle(hMapFile);
+    UnmapViewOfFile(buf);
+    CloseHandle(writeEvent);
+    CloseHandle(readEvent);
+  };
+
+  // Collect heaps. This is a loop because GetProcessHeaps requires
+  // specifying the max number of heaps to get upfront.
+  DWORD heapCount = 0;
+  PHANDLE heaps = NULL;
+  while (TRUE) {
+    DWORD actualHeapCount = GetProcessHeaps(heapCount, heaps);
+    if (actualHeapCount <= heapCount) {
+      break;
+    }
+    heapCount = actualHeapCount;
+    free(heaps);
+    heaps = (HANDLE*)malloc(heapCount * sizeof(HANDLE));
+    if (heaps == NULL) {
+      printf("malloc failed for the list of heaps\n");
+      cleanupIPC();
+      return 1;
+    }
+  }
+
+  auto cleanup = [&] {
+    free(heaps);
+    cleanupIPC();
+  };
+
+  // Iterate heaps and heap entries
+  size_t count = 0;
+  for (DWORD heapIndex = 0; heapIndex < heapCount; heapIndex++) {
+    PROCESS_HEAP_ENTRY entry;
+
+    if (!HeapLock(heaps[heapIndex])) {
+      printf("Failed to lock heap\n");
+      continue;
+    }
+
+    uintptr_t i = 0;
+    entry.lpData = NULL;
+    while (HeapWalk(heaps[heapIndex], &entry)) {
+      if ((!(entry.wFlags & PROCESS_HEAP_REGION)) &&
+          (!(entry.wFlags & PROCESS_HEAP_UNCOMMITTED_RANGE)) &&
+          (entry.wFlags & PROCESS_HEAP_ENTRY_BUSY)) {
+        if (count < BUF_NUM_ENTRIES) {
+          buf[count].address = (uintptr_t)entry.lpData;
+          buf[count].size = entry.cbData + entry.cbOverhead;
+          ++count;
+        } else {
+          if (!SetEvent(readEvent)) {
+            printf("SetEvent on readEvent failed\n");
+            HeapUnlock(heaps[heapIndex]);
+            cleanup();
+            return 1;
+          }
+          DWORD wait = WaitForSingleObject(writeEvent, WAIT_TIMEOUT_MS);
+          if (wait != WAIT_OBJECT_0) {
+            printf("WaitForSingleObject failed %lu\n", wait);
+            HeapUnlock(heaps[heapIndex]);
+            cleanup();
+            return 1;
+          }
+          memset(buf, 0, BUF_SIZE);
+          count = 0;
+        }
+      }
+    }
+
+    // Write the remaining entries.
+    if (!SetEvent(readEvent)) {
+      printf("SetEvent on readEvent failed\n");
+      HeapUnlock(heaps[heapIndex]);
+      cleanup();
+      return 1;
+    }
+    if (count > 0) {
+      DWORD wait = WaitForSingleObject(writeEvent, WAIT_TIMEOUT_MS);
+      if (wait != WAIT_OBJECT_0) {
+        printf("WaitForSingleObject failed %lu\n", wait);
+        HeapUnlock(heaps[heapIndex]);
+        cleanup();
+        return 1;
+      }
+      memset(buf, 0, BUF_SIZE);
+      count = 0;
+    }
+
+    if (!HeapUnlock(heaps[heapIndex])) {
+      printf("Failed to unlock heap\n");
+    }
+  }
+
+  // Indicate the end of iteration with one last write.
+  memset(buf, 0, BUF_SIZE);
+  buf[0].address = -1;
+  if (!SetEvent(readEvent)) {
+    printf("SetEvent at the end of heap iteration failed\n");
+    cleanup();
+    return 1;
+  }
+  DWORD wait = WaitForSingleObject(writeEvent, WAIT_TIMEOUT_MS);
+  if (wait != WAIT_OBJECT_0) {
+    printf("WaitForSingleObject failed %lu\n", wait);
+    cleanup();
+    return 1;
+  }
+
+  cleanup();
+  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