ci

Author: jacobly0

.github/workflows/ci.yaml

@@ -3,81 +3,14 @@ on:
   pull_request:
   push:
     branches:
-      - master
+      - ci
 concurrency:
   # Cancels pending runs when a PR gets updated.
   group: ${{ github.head_ref || github.run_id }}-${{ github.actor }}
   cancel-in-progress: true
 jobs:
-  x86_64-linux-debug:
-    timeout-minutes: 420
-    runs-on: [self-hosted, Linux, x86_64]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Build and Test
-        run: sh ci/x86_64-linux-debug.sh
-  x86_64-linux-release:
-    timeout-minutes: 420
-    runs-on: [self-hosted, Linux, x86_64]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Build and Test
-        run: sh ci/x86_64-linux-release.sh
-  aarch64-linux-debug:
-    timeout-minutes: 480
-    runs-on: [self-hosted, Linux, aarch64]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Build and Test
-        run: sh ci/aarch64-linux-debug.sh
-  aarch64-linux-release:
-    timeout-minutes: 480
-    runs-on: [self-hosted, Linux, aarch64]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Build and Test
-        run: sh ci/aarch64-linux-release.sh
-  x86_64-macos-release:
-    runs-on: "macos-11"
-    env:
-      ARCH: "x86_64"
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Build and Test
-        run: ci/x86_64-macos-release.sh
-  aarch64-macos-debug:
-    runs-on: [self-hosted, macOS, aarch64]
-    env:
-      ARCH: "aarch64"
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Build and Test
-        run: ci/aarch64-macos-debug.sh
-  aarch64-macos-release:
-    runs-on: [self-hosted, macOS, aarch64]
-    env:
-      ARCH: "aarch64"
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Build and Test
-        run: ci/aarch64-macos-release.sh
-  x86_64-windows-debug:
-    runs-on: windows-latest
-    env:
-      ARCH: "x86_64"
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Build and Test
-        run: ci/x86_64-windows-debug.ps1
   x86_64-windows-release:
+    timeout-minutes: 120
     runs-on: windows-latest
     env:
       ARCH: "x86_64"
@@ -86,12 +19,3 @@ jobs:
         uses: actions/checkout@v3
       - name: Build and Test
         run: ci/x86_64-windows-release.ps1
-  aarch64-windows:
-    runs-on: [self-hosted, Windows, aarch64]
-    env:
-      ARCH: "aarch64"
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Build and Test
-        run: ci/aarch64-windows.ps1

ci/x86_64-windows-release.ps1

@@ -53,48 +53,10 @@ ninja install
 CheckLastExitCode
 
 Write-Output "Main test suite..."
-& "stage3-release\bin\zig.exe" build test docs `
+& "stage3-release\bin\zig.exe" build test `
   --zig-lib-dir "$ZIG_LIB_DIR" `
   --search-prefix "$PREFIX_PATH" `
   -Dstatic-llvm `
   -Dskip-non-native `
   -Denable-symlinks-windows
 CheckLastExitCode
-
-Write-Output "Build x86_64-windows-msvc behavior tests using the C backend..."
-& "stage3-release\bin\zig.exe" test `
-  ..\test\behavior.zig `
-  --zig-lib-dir "$ZIG_LIB_DIR" `
-  -ofmt=c `
-  -femit-bin="test-x86_64-windows-msvc.c" `
-  --test-no-exec `
-  -target x86_64-windows-msvc `
-  -lc
-CheckLastExitCode
-
-& "stage3-release\bin\zig.exe" build-obj `
-  --zig-lib-dir "$ZIG_LIB_DIR" `
-  -ofmt=c `
-  -OReleaseSmall `
-  --name compiler_rt `
-  -femit-bin="compiler_rt-x86_64-windows-msvc.c" `
-  --dep build_options `
-  -target x86_64-windows-msvc `
-  --mod root ..\lib\compiler_rt.zig `
-  --mod build_options config.zig
-CheckLastExitCode
-
-Import-Module "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"
-CheckLastExitCode
-
-Enter-VsDevShell -VsInstallPath "C:\Program Files\Microsoft Visual Studio\2022\Enterprise" `
-  -DevCmdArguments '-arch=x64 -no_logo' `
-  -StartInPath $(Get-Location)
-CheckLastExitCode
-
-Write-Output "Build and run behavior tests with msvc..."
-& cl.exe -I..\lib test-x86_64-windows-msvc.c compiler_rt-x86_64-windows-msvc.c /W3 /Z7 -link -nologo -debug -subsystem:console kernel32.lib ntdll.lib libcmt.lib
-CheckLastExitCode
-
-& .\test-x86_64-windows-msvc.exe
-CheckLastExitCode

lib/std/Build/Step.zig

@@ -405,7 +405,7 @@ pub fn evalZigProcess(
     child.stdin.?.close();
     child.stdin = null;
 
-    const term = child.wait() catch |err| {
+    const term = child.waitTimeout() catch |err| {
         return s.fail("unable to wait for {s}: {s}", .{ argv[0], @errorName(err) });
     };
     s.result_duration_ns = timer.read();

lib/std/Build/Step/Run.zig

@@ -1072,7 +1072,7 @@ fn spawnChildAndCollect(
     else
         evalGeneric(self, &child);
 
-    const term = try child.wait();
+    const term = try child.waitTimeout();
     const elapsed_ns = timer.read();
 
     return .{

lib/std/child_process.zig

@@ -262,6 +262,17 @@ pub const ChildProcess = struct {
         return term;
     }
 
+    pub fn waitTimeout(self: *ChildProcess) !Term {
+        const term = if (builtin.os.tag == .windows)
+            try self.waitWindowsTimeout()
+        else
+            try self.waitPosix();
+
+        self.id = undefined;
+
+        return term;
+    }
+
     pub const RunResult = struct {
         term: Term,
         stdout: []u8,
@@ -371,6 +382,16 @@ pub const ChildProcess = struct {
         return self.term.?;
     }
 
+    fn waitWindowsTimeout(self: *ChildProcess) !Term {
+        if (self.term) |term| {
+            self.cleanupStreams();
+            return term;
+        }
+
+        try self.waitUnwrappedWindowsTimeout();
+        return self.term.?;
+    }
+
     fn waitPosix(self: *ChildProcess) !Term {
         if (self.term) |term| {
             self.cleanupStreams();
@@ -403,6 +424,37 @@ pub const ChildProcess = struct {
         return result;
     }
 
+    fn waitUnwrappedWindowsTimeout(self: *ChildProcess) (windows.WaitForSingleObjectError || windows.GetProcessMemoryInfoError)!void {
+        const result = windows.WaitForSingleObjectEx(self.id, std.time.ms_per_hour / 2, false) catch |err| switch (err) {
+            error.WaitTimeOut => {
+                _ = self.kill() catch |kill_err| {
+                    std.debug.print("kill: {}\n", .{kill_err});
+                    return err;
+                };
+                return;
+            },
+            else => {},
+        };
+
+        self.term = @as(SpawnError!Term, x: {
+            var exit_code: windows.DWORD = undefined;
+            if (windows.kernel32.GetExitCodeProcess(self.id, &exit_code) == 0) {
+                break :x Term{ .Unknown = 0 };
+            } else {
+                break :x Term{ .Exited = @as(u8, @truncate(exit_code)) };
+            }
+        });
+
+        if (self.request_resource_usage_statistics) {
+            self.resource_usage_statistics.rusage = try windows.GetProcessMemoryInfo(self.id);
+        }
+
+        os.close(self.id);
+        os.close(self.thread_handle);
+        self.cleanupStreams();
+        return result;
+    }
+
     fn waitUnwrapped(self: *ChildProcess) !void {
         const res: os.WaitPidResult = res: {
             if (self.request_resource_usage_statistics) {